Rename from yp2 to metaproxy. The namespace for all definitions

[metaproxy-moved-to-github.git] / src / filter_query_rewrite.cpp

diff --git a/src/filter_query_rewrite.cpp b/src/filter_query_rewrite.cpp
index 8ae8400..e431b27 100644 (file)
--- a/src/filter_query_rewrite.cpp
+++ b/src/filter_query_rewrite.cpp
@@ -1,5 +1,5 @@
-/* $Id: filter_query_rewrite.cpp,v 1.1 2006-01-19 12:18:09 marc Exp $
-   Copyright (c) 2005, Index Data.
+/* $Id: filter_query_rewrite.cpp,v 1.6 2006-03-16 10:40:59 adam Exp $
+   Copyright (c) 2005-2006, Index Data.
 
 %LICENSE%
  */
@@ -9,85 +9,165 @@
 #include "filter.hpp"
 #include "package.hpp"
 
-//#include <boost/thread/mutex.hpp>
-
 #include "util.hpp"
 #include "filter_query_rewrite.hpp"
 
 #include <yaz/zgdu.h>
+#include <yaz/xmlquery.h>
+#include <yaz/diagbib1.h>
+
+#include <libxslt/xsltutils.h>
+#include <libxslt/transform.h>
 
-namespace yf = yp2::filter;
+namespace mp = metaproxy_1;
+namespace yf = mp::filter;
 
-namespace yp2 {
+namespace metaproxy_1 {
     namespace filter {
         class QueryRewrite::Rep {
-            friend class QueryRewrite;
-            int dummy;
+        public:
+            Rep();
+            ~Rep();
+            void process(mp::Package &package) const;
+            void configure(const xmlNode * ptr);
+        private:
+            xsltStylesheetPtr m_stylesheet;
         };
     }
 }
 
+yf::QueryRewrite::Rep::Rep()
+{
+    m_stylesheet = 0;
+}
+
+yf::QueryRewrite::Rep::~Rep()
+{
+    if (m_stylesheet)
+        xsltFreeStylesheet(m_stylesheet);
+}
+
 yf::QueryRewrite::QueryRewrite() : m_p(new Rep)
 {
-    m_p->dummy = 1;
 }
 
 yf::QueryRewrite::~QueryRewrite()
 {  // must have a destructor because of boost::scoped_ptr
 }
 
-void yf::QueryRewrite::process(yp2::Package &package) const
+void yf::QueryRewrite::process(mp::Package &package) const
 {
+    m_p->process(package);
+}
 
-    if (package.session().is_closed())
-    {
-        std::cout << "Got Close.\n";
-    }
-    
+void mp::filter::QueryRewrite::configure(const xmlNode *ptr)
+{
+    m_p->configure(ptr);
+}
+
+void yf::QueryRewrite::Rep::process(mp::Package &package) const
+{
     Z_GDU *gdu = package.request().get();
     
-    if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
-        Z_APDU_initRequest)
-    {
-        std::cout << "Got Z3950 Init PDU\n";         
-        //Z_InitRequest *req = gdu->u.z3950->u.initRequest;
-        //package.request() = gdu;
-    } 
-    else if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
-             Z_APDU_searchRequest)
-    {
-        std::cout << "Got Z3950 Search PDU\n";   
-        //Z_SearchRequest *req = gdu->u.z3950->u.searchRequest;
-        //package.request() = gdu;
-    } 
-    else if (gdu && gdu->which == Z_GDU_Z3950 && gdu->u.z3950->which ==
-             Z_APDU_scanRequest)
+    if (gdu && gdu->which == Z_GDU_Z3950)
     {
-        std::cout << "Got Z3950 Scan PDU\n";   
-        //Z_ScanRequest *req = gdu->u.z3950->u.scanRequest;
-        //package.request() = gdu;
-    } 
+        Z_APDU *apdu_req = gdu->u.z3950;
+        if (apdu_req->which == Z_APDU_searchRequest)
+        {
+            int error_code = 0;
+            const char *addinfo = 0;
+            mp::odr odr;
+            Z_SearchRequest *req = apdu_req->u.searchRequest;
+            
+            xmlDocPtr doc_input = 0;
+            yaz_query2xml(req->query, &doc_input);
+            
+            if (!doc_input)
+            {
+                error_code = YAZ_BIB1_MALFORMED_QUERY;
+                addinfo = "converion from Query to XML failed";
+            }
+            else
+            {
+                if (m_stylesheet)
+                {
+                    xmlDocPtr doc_res = xsltApplyStylesheet(m_stylesheet,
+                                                            doc_input, 0);
+                    if (!doc_res)
+                    {
+                        error_code = YAZ_BIB1_MALFORMED_QUERY;
+                        addinfo = "XSLT transform failed for query";
+                    }
+                    else
+                    {
+                        const xmlNode *root_element = xmlDocGetRootElement(doc_res);
+                        yaz_xml2query(root_element, &req->query, odr,
+                                      &error_code, &addinfo);
+                        xmlFreeDoc(doc_res);
+                    }
+                }
+                xmlFreeDoc(doc_input);
+            }
+            package.request() = gdu;
+            if (error_code)
+            {
+                Z_APDU *f_apdu = 
+                    odr.create_searchResponse(apdu_req, error_code, addinfo);
+                package.response() = f_apdu;
+                return;
+            }
+        } 
+    }
     package.move();
 }
 
-static yp2::filter::Base* filter_creator()
+void mp::filter::QueryRewrite::Rep::configure(const xmlNode *ptr)
+{
+    for (ptr = ptr->children; ptr; ptr = ptr->next)
+    {
+        if (ptr->type != XML_ELEMENT_NODE)
+            continue;
+        if (!strcmp((const char *) ptr->name, "xslt"))
+        {
+            if (m_stylesheet)
+            {
+                throw mp::filter::FilterException
+                    ("Only one xslt element allowed in query_rewrite filter");
+            }
+
+            std::string fname = mp::xml::get_text(ptr);
+            m_stylesheet = xsltParseStylesheetFile(BAD_CAST fname.c_str());
+            if (!m_stylesheet)
+            {
+                throw mp::filter::FilterException
+                    ("Failed to read stylesheet " 
+                     + fname
+                     + " in query_rewrite filter");
+            }
+        }
+        else
+        {
+            throw mp::filter::FilterException
+                ("Bad element " 
+                 + std::string((const char *) ptr->name)
+                 + " in query_rewrite filter");
+        }
+    }
+}
+
+static mp::filter::Base* filter_creator()
 {
-    return new yp2::filter::QueryRewrite;
+    return new mp::filter::QueryRewrite;
 }
 
 extern "C" {
-    struct yp2_filter_struct yp2_filter_query_rewrite = {
+    struct metaproxy_1_filter_struct metaproxy_1_filter_query_rewrite = {
         0,
         "query-rewrite",
         filter_creator
     };
 }
 
-extern "C" {
-    extern struct yp2_filter_struct yp2_filter_query_rewrite;
-}
-
-
 /*
  * Local variables:
  * c-basic-offset: 4