/* This file is part of the YAZ toolkit.
- * Copyright (C) 1995-2013 Index Data
+ * Copyright (C) Index Data
* See the file LICENSE for details.
*/
/**
#include <yaz/nmem.h>
#include <yaz/tpath.h>
#include <yaz/z-opac.h>
+#include <yaz/xml_get.h>
#if YAZ_HAVE_XML2
#include <libxml/parser.h>
#include <libxml/tree.h>
#include <libxml/xinclude.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
#if YAZ_HAVE_XSLT
#include <libxslt/xsltutils.h>
#include <libxslt/transform.h>
info->xsl_parms[2 * no_parms + 1] = qvalue;
no_parms++;
}
-
- info->xsl_parms[2 * no_parms] = '\0';
+ info->xsl_parms[2 * no_parms] = 0;
if (!stylesheet)
{
wrbuf_printf(wr_error, "Element <xslt>: "
"attribute 'stylesheet' expected");
nmem_destroy(nmem);
- return 0;
}
else
{
")");
xmlFreeDoc(info->xsp_doc);
nmem_destroy(info->nmem);
- return 0;
}
else
{
/* YAZ_HAVE_XSLT */
#endif
+struct select_info {
+ NMEM nmem;
+ char *xpath_expr;
+};
+
+static void *construct_select(const xmlNode *ptr,
+ const char *path, WRBUF wr_error)
+{
+ if (strcmp((const char *) ptr->name, "select"))
+ return 0;
+ else
+ {
+ NMEM nmem = nmem_create();
+ struct select_info *info = nmem_malloc(nmem, sizeof(*info));
+ const char *attr_str;
+ const char *xpath = 0;
+
+ info->nmem = nmem;
+ info->xpath_expr = 0;
+ attr_str = yaz_xml_get_prop(ptr, "path%s", &xpath);
+ if (attr_str)
+ {
+ wrbuf_printf(wr_error, "Bad attribute '%s'"
+ "Expected xpath.", attr_str);
+ nmem_destroy(nmem);
+ return 0;
+ }
+ if (xpath)
+ info->xpath_expr = nmem_strdup(nmem, xpath);
+ return info;
+ }
+}
+
+static int convert_select(void *vinfo, WRBUF record, WRBUF wr_error)
+{
+ int ret = 0;
+ struct select_info *info = vinfo;
+
+ xmlDocPtr doc = xmlParseMemory(wrbuf_buf(record),
+ wrbuf_len(record));
+ if (!doc)
+ {
+ wrbuf_printf(wr_error, "xmlParseMemory failed");
+ ret = -1;
+ }
+ else
+ {
+ xmlXPathContextPtr xpathCtx = xmlXPathNewContext(doc);
+ if (xpathCtx && info->xpath_expr)
+ {
+ xmlXPathObjectPtr xpathObj =
+ xmlXPathEvalExpression((const xmlChar *) info->xpath_expr,
+ xpathCtx);
+ if (xpathObj)
+ {
+ xmlNodeSetPtr nodes = xpathObj->nodesetval;
+ if (nodes)
+ {
+ int i;
+ if (nodes->nodeNr > 0)
+ wrbuf_rewind(record);
+ for (i = 0; i < nodes->nodeNr; i++)
+ {
+ xmlNode *ptr = nodes->nodeTab[i];
+ if (ptr->type == XML_ELEMENT_NODE)
+ ptr = ptr->children;
+ for (; ptr; ptr = ptr->next)
+ if (ptr->type == XML_TEXT_NODE)
+ wrbuf_puts(record, (const char *) ptr->content);
+ }
+ }
+ xmlXPathFreeObject(xpathObj);
+ }
+ xmlXPathFreeContext(xpathCtx);
+ }
+ xmlFreeDoc(doc);
+ }
+ return ret;
+}
+
+static void destroy_select(void *vinfo)
+{
+ struct select_info *info = vinfo;
+
+ if (info)
+ nmem_destroy(info->nmem);
+}
+
+
+static void *construct_solrmarc(const xmlNode *ptr,
+ const char *path, WRBUF wr_error)
+{
+ if (strcmp((const char *) ptr->name, "solrmarc"))
+ return 0;
+ return wr_error; /* any non-null ptr will do; we don't use it later*/
+}
+
+static int convert_solrmarc(void *info, WRBUF record, WRBUF wr_error)
+{
+ WRBUF w = wrbuf_alloc();
+ const char *buf = wrbuf_buf(record);
+ size_t i, sz = wrbuf_len(record);
+ for (i = 0; i < sz; i++)
+ {
+ int ch;
+ if (buf[i] == '#' && i < sz - 3 && buf[i+3] == ';'
+ && atoi_n_check(buf+i+1, 2, &ch))
+ i += 3;
+ else
+ ch = buf[i];
+ wrbuf_putc(w, ch);
+ }
+ wrbuf_rewind(record);
+ wrbuf_write(record, wrbuf_buf(w), wrbuf_len(w));
+ wrbuf_destroy(w);
+ return 0;
+}
+
+static void destroy_solrmarc(void *info)
+{
+}
static void *construct_marc(const xmlNode *ptr,
const char *path, WRBUF wr_error)
nmem_destroy(nmem);
return 0;
}
-
info->nmem = nmem;
info->input_charset = 0;
info->output_charset = 0;
if (!info->input_charset && info->output_charset)
info->input_charset = "utf-8";
}
+ else if (!strcmp(input_format, "json"))
+ {
+ info->input_format_mode = YAZ_MARC_JSON;
+ }
else
{
wrbuf_printf(wr_error, "Element <marc inputformat='%s'>: "
if (info->input_charset && !info->output_charset)
info->output_charset = "utf-8";
}
+ else if (!strcmp(output_format, "json"))
+ {
+ info->output_format_mode = YAZ_MARC_JSON;
+ if (info->input_charset && !info->output_charset)
+ info->output_charset = "utf-8";
+ }
else
{
wrbuf_printf(wr_error, "Element <marc outputformat='%s'>: "
static int convert_marc(void *info, WRBUF record, WRBUF wr_error)
{
struct marc_info *mi = info;
+ const char *input_charset = mi->input_charset;
int ret = 0;
-
- yaz_iconv_t cd = yaz_iconv_open(mi->output_charset, mi->input_charset);
yaz_marc_t mt = yaz_marc_create();
yaz_marc_xml(mt, mi->output_format_mode);
if (mi->leader_spec)
yaz_marc_leader_spec(mt, mi->leader_spec);
- if (cd)
- yaz_marc_iconv(mt, cd);
if (mi->input_format_mode == YAZ_MARC_ISO2709)
{
int sz = yaz_marc_read_iso2709(mt, wrbuf_buf(record),
wrbuf_len(record));
if (sz > 0)
+ {
+ if (yaz_marc_check_marc21_coding(input_charset, wrbuf_buf(record),
+ wrbuf_len(record)))
+ input_charset = "utf-8";
ret = 0;
+ }
else
ret = -1;
}
}
if (ret == 0)
{
+ yaz_iconv_t cd = yaz_iconv_open(mi->output_charset, input_charset);
+
+ if (cd)
+ yaz_marc_iconv(mt, cd);
+
wrbuf_rewind(record);
ret = yaz_marc_write_mode(mt, record);
if (ret)
wrbuf_printf(wr_error, "yaz_marc_write_mode failed");
+ if (cd)
+ yaz_iconv_close(cd);
}
- if (cd)
- yaz_iconv_close(cd);
yaz_marc_destroy(mt);
return ret;
}
int yaz_record_conv_configure_t(yaz_record_conv_t p, const xmlNode *ptr,
struct yaz_record_conv_type *types)
{
- struct yaz_record_conv_type bt[2];
+ struct yaz_record_conv_type bt[4];
+ size_t i = 0;
/* register marc */
- bt[0].construct = construct_marc;
- bt[0].convert = convert_marc;
- bt[0].destroy = destroy_marc;
+ bt[i].construct = construct_marc;
+ bt[i].convert = convert_marc;
+ bt[i++].destroy = destroy_marc;
+
+ bt[i-1].next = &bt[i];
+ bt[i].construct = construct_solrmarc;
+ bt[i].convert = convert_solrmarc;
+ bt[i++].destroy = destroy_solrmarc;
+
+ bt[i-1].next = &bt[i];
+ bt[i].construct = construct_select;
+ bt[i].convert = convert_select;
+ bt[i++].destroy = destroy_select;
#if YAZ_HAVE_XSLT
/* register xslt */
- bt[0].next = &bt[1];
- bt[1].next = types;
- bt[1].construct = construct_xslt;
- bt[1].convert = convert_xslt;
- bt[1].destroy = destroy_xslt;
-#else
- bt[0].next = types;
+ bt[i-1].next = &bt[i];
+ bt[i].construct = construct_xslt;
+ bt[i].convert = convert_xslt;
+ bt[i++].destroy = destroy_xslt;
#endif
+ bt[i-1].next = types;
yaz_record_conv_reset(p);
/* parsing element children */
int ret = 0;
struct yaz_record_conv_rule *r = p->rules;
if (!r || r->type->construct != construct_marc)
+ {
+ wrbuf_puts(p->wr_error, "Expecting MARC rule as first rule for OPAC");
ret = -1; /* no marc rule so we can't do OPAC */
+ }
else
{
struct marc_info *mi = r->info;
+ const char *input_charset = mi->input_charset;
+ yaz_iconv_t cd;
WRBUF res = wrbuf_alloc();
yaz_marc_t mt = yaz_marc_create();
- yaz_iconv_t cd = yaz_iconv_open(mi->output_charset,
- mi->input_charset);
+
+ if (yaz_opac_check_marc21_coding(input_charset, input_record))
+ input_charset = "utf-8";
+ cd = yaz_iconv_open(mi->output_charset, input_charset);
wrbuf_rewind(p->wr_error);
yaz_marc_xml(mt, mi->output_format_mode);
p->wr_error = wrbuf_alloc();
p->rules = 0;
p->path = 0;
-#if YAZ_HAVE_EXSLT
- exsltRegisterAll();
-#endif
return p;
}