Changeset 16710

Timestamp:

2008-08-12T11:57:10+12:00 (16 years ago)

Author:

mdewsnip

Message:

Completely tidied up abstractlistaction::validateAction() to handle the resumptionToken argument properly, and to structure the checking code more consistently.

Location:

gsdl/trunk/runtime-src/src/oaiservr

Files:

• abstractlistaction.cpp (modified) (2 diffs)
• abstractlistaction.h (modified) (1 diff)
• listidsaction.cpp (modified) (1 diff)
• listrecsaction.cpp (modified) (1 diff)

gsdl/trunk/runtime-src/src/oaiservr/abstractlistaction.cpp

@@ -4 +4 @@
 #include "oaitools.h"
 
-bool abstractlistaction::validateAction(recptproto *protocol, oaiargs &params, int &numArgs)
-{ 
-  // Remove any parameters that aren't valid for this action
+bool abstractlistaction::validateAction(recptproto *protocol, oaiargs &params)
+{
+  // ----------------------------------------------------------------------------
+  //  1. Check for invalid arguments
+  // ----------------------------------------------------------------------------
+  bool invalid_argument_supplied = false;
   text_tmap::const_iterator param_iterator = params.begin();
   while (param_iterator != params.end())
   {
+    // Check for arguments that aren't valid for this action
     if (param_iterator->first != "verb" &&
     param_iterator->first != "from" &&
@@ -17 +21 @@
     param_iterator->first != "metadataPrefix")
     {
+      // We've found an invalid argument
+      invalid_argument_supplied = true;
+
+      // Delete the invalid argument from the list so it doesn't end up in the <request> tag that is returned
       params.erase(param_iterator->first);
     }
 
+    // The metadataPrefix argument is not allowed in OAI v1.1
+    else if (param_iterator->first == "metadataPrefix" && this->configuration->getOAIVersion() <= 110)
+    {
+      // We've found an invalid argument
+      invalid_argument_supplied = true;
+
+      // Delete the invalid argument from the list so it doesn't end up in the <request> tag that is returned
+      params.erase(param_iterator->first);
+    }
+
     param_iterator++;
   }
 
-  text_t from  = params["from"];
-  text_t until = params["until"];
-
-  // from date must be less than, or equal to, until date
-  if ((from != "") && (until != "") && !(from <= until)){
+  // If we found an invalid argument it's an error, so don't go any further 
+  if (invalid_argument_supplied)
+  {
     this->errorType = "badArgument";
     return false;
   }
 
-  if (from != ""){
-    // Must be in the form YYYY-MM-DD
-    if(from.size() != 10){
+  // ----------------------------------------------------------------------------
+  //  2. Handle any exclusive arguments
+  // ----------------------------------------------------------------------------
+
+  //  The resumptionToken argument is exclusive
+  if (params["resumptionToken"] != "")
+  {
+    // This argument is exclusive, so no other arguments are allowed (except "verb" of course)
+    if (params.getSize() != 2)
+    {
       this->errorType = "badArgument";
-      params.erase("from");
-    }
-    else{
-      if(from[4] != '-' || from[7] != '-'){
+      return false;
+    }
+
+    // Check the resumption token is valid
+    ResumptionToken token(params["resumptionToken"]);
+    if (token.isValid())
+    {
+      // Everything is fine, and we don't continue further because this is an exclusive argument
+      this->errorType = "";
+      return true;
+    }
+    else
+    {
+      // There was an error with the resumption token
+      this->errorType = "badResumptionToken";
+      return false;
+    }
+  }
+
+  // ----------------------------------------------------------------------------
+  //  3. Handle any required arguments
+  // ----------------------------------------------------------------------------
+
+  // OAI v2.0 requires metadataPrefix
+  if (this->configuration->getOAIVersion() > 110)
+  {
+    text_t metadataPrefix = params["metadataPrefix"];
+
+    // Check that the metadataPrefix argument exists
+    if (metadataPrefix == "")
+    {
+      this->errorType = "badArgument";
+      return false;
+    }
+    // Check that the metadataPrefix is a format we support
+    if (this->formatNotSupported(metadataPrefix))
+    {
+      this->errorType = "cannotDisseminateFormat";
+      return false;
+    }
+  }
+
+  // ----------------------------------------------------------------------------
+  // 4. Check any remaining arguments
+  // ----------------------------------------------------------------------------
+
+  // Check "from" and "until" arguments
+  if (params["from"] != "" || params["until"] != "")
+  {
+    text_t from  = params["from"];
+    text_t until = params["until"];
+
+    // Check the from date is in the correct format: YYYY-MM-DD
+    if (from != "")
+    {
+      // Must be in the form YYYY-MM-DD
+      if (from.size() != 10 || from[4] != '-' || from[7] != '-')
+      {
     this->errorType = "badArgument";
     params.erase("from");
       }
     }
-    ++numArgs; // Increase valid args count
-  }
-
-  if (until != ""){
-    // Must be in the form YYYY-MM-DD
-    if(until.size() != 10){
-      this->errorType = "badArgument";
-      params.erase("until");
-    }
-    else{
-      if(until[4] != '-' || until[7] != '-'){
+    // Check the until date is in the correct format: YYYY-MM-DD
+    if (until != "")
+    {
+      // Must be in the form YYYY-MM-DD
+      if (until.size() != 10 || until[4] != '-' || until[7] != '-')
+      {
     this->errorType = "badArgument";
     params.erase("until");
       }
     }
-    ++numArgs; // Increase valid args count
-  }
-
-  if (this->errorType == "badArgument")
+
+    if (this->errorType == "badArgument")
+    {
+      return false;
+    }
+
+    // If both arguments are supplied the from date must be less than or equal to the until date
+    if (from != "" && until != "" && !(from <= until))
+    {
+      this->errorType = "badArgument";
+      return false;
+    }
+  }
+
+  // Check "set" argument
+  if (params["set"] != "")
   {
-    return false;
-  }
-
-  if (params["set"] != "") { 
-    text_t gsdlSet = params["set"];
-    text_t gsdlCollect = "";
-
-    // given 'demo:CL2', toGSDL returns 'demo' in gsdlCollect and 'CL2' in gsdlSet. If there is no further
-    // set specified after the name of the collection however, then gsdlSet is empty.
-    oaiclassifier::toGSDL(gsdlCollect, gsdlSet);
-
+    // Example set specification: "demo:CL2"
+    text_t set = params["set"];
+
+    // given 'demo:CL2', toGSDL returns 'demo' in collection and 'CL2' in set. If there is no further
+    // set specified after the name of the collection however, then set is empty.
+    text_t collection = "";
+    oaiclassifier::toGSDL(collection, set);
+
+    // Check that the collection is accessible
+    ColInfoResponse_t cinfo;
     comerror_t err;
-    ColInfoResponse_t cinfo;
-
-    // check that the collection is accessible
-    protocol->get_collectinfo(gsdlCollect, cinfo, err, cerr);
-    if (err != noError) {
+    protocol->get_collectinfo(collection, cinfo, err, cerr);
+    if (err != noError)
+    {
       this->errorType = "badArgument";
       return false;
     }
 
-    // exclude collections that are not listed in the configured OAI list
+    // Check the collection is one that is in the list in the oai.cfg file
     text_tarray &collections = this->configuration->getCollectionsList();
-    int          c;
-    for (c = 0; c < collections.size(); c ++) {
-      if (collections[c] == gsdlCollect)
+    bool collection_found = false;
+    for (int c = 0; c < collections.size(); c++)
+    {
+      if (collections[c] == collection)
+      {
+    collection_found = true;
     break;
-    }
-    if (c == collections.size()) {
+      }
+    }
+
+    // The collection was not found
+    if (!collection_found)
+    {
       this->errorType = "badArgument";
       return false;
     }
-    
-    if (gsdlSet != "") {
-      // check the child set if it is given
-      if (!this->check_classifier(protocol, gsdlCollect, gsdlSet)) {
-    this->errorType = "badArgument";
-    return false;
-      }
-    }
-    ++numArgs;
-  }
-
-  if (params["resumptionToken"] != "") {
-    ResumptionToken token(params["resumptionToken"]);
-
-    if (!token.isValid()) {
-      this->errorType = "badResumptionToken";
-      return false;
-    }
-    ++numArgs;
-  }
-  
+
+    // Check the child set if it was given
+    if (set != "" && !this->check_classifier(protocol, collection, set))
+    {
+      this->errorType = "badArgument";
+      return false;
+    }
+  }
+
+  // If we've reached here everything must be fine
   this->errorType = "";
   return true;

gsdl/trunk/runtime-src/src/oaiservr/abstractlistaction.h

@@ -9 +9 @@
  public:
   abstractlistaction(const text_t &name) : oaiaction(name) {this->prevDocSeen = false;}
-  virtual bool validateAction(recptproto *protocol, oaiargs &params, int &numArgs); // Check that this is a valid action
+  virtual bool validateAction(recptproto *protocol, oaiargs &params); // Check that this is a valid action
   virtual bool output_document(ostream &output, recptproto *protocol, const text_t &collection, 
                    const text_t &OID, const text_t &metadataPrefix) = 0;

gsdl/trunk/runtime-src/src/oaiservr/listidsaction.cpp

@@ -6 +6 @@
 
 bool listidsaction::validateAction(recptproto *protocol, oaiargs &params)
-{ 
-  int params_size = params.getSize();
-  int numArgs  = 1; // For "verb" arg
-
-  if (!abstractlistaction::validateAction(protocol, params, numArgs)) {
-    return false;
-  }
-
-  // In OAI v1.1 metadataPrefix is not allowed.
-  if (this->configuration->getOAIVersion() <= 110){
-    if(numArgs != params_size){
-      this->errorType = "badArgument";
-      return false;
-    }
-  }
-  else { // In OAI v2.0, it is compulsory
-    text_t metaFormat = params["metadataPrefix"];
-    if (metaFormat == ""){
-      this->errorType = "badArgument";
-      return false;
-    }
-    else { // If it isn't empty, increase the valid args count and compare this to the total num of args
-      if (++numArgs != params_size){
-    this->errorType = "badArgument";
-    return false;
-      }
-    }
-    // Check that the metadataPrefix is a format we support
-    if (this->formatNotSupported(metaFormat)){
-      this->errorType = "cannotDisseminateFormat";
-      return false;
-    }
-  }
-  this->errorType = "";
-  return true;
+{
+  return abstractlistaction::validateAction(protocol, params);
 }
 

gsdl/trunk/runtime-src/src/oaiservr/listrecsaction.cpp

@@ -6 +6 @@
 bool listrecsaction::validateAction(recptproto *protocol, oaiargs &params)
 { 
-  int params_size = params.getSize();
-
-  text_t meta    = params["metadataPrefix"];
-  int    numArgs = 1;                // 1st arg (Verb=ListRecords) must be present for us to be here
-
-  if (!abstractlistaction::validateAction(protocol, params, numArgs)) {
-    return false;
-  }
-
-  // metadataPrefix is required - if it's not there, throw an error. Note that the arg isn't 
-  // required (or allowed) if a resumptionToken is given, but as we don't handle resumption
-  // tokens this is sufficient. When we DO handle the tokens, this will have to change.
-  if (meta == "") { 
-    this->errorType = "badArgument";
-    return false;
-  }
-  else {
-    ++numArgs; // If it's there, increase arg count
-  }
-  
-  // The number of valid args should be exactly equal to the number of args actually there.
-  // If not, throw a 'badArgument' error.
-  if (numArgs != params_size) {
-    this->errorType = "badArgument";
-    return false;
-  }
-     
-  if (this->formatNotSupported(meta)) { // Check that the metadataPrefix is supported
-    this->errorType = "cannotDisseminateFormat";
-    this->record_action->setErrorType(this->errorType);
-    return false;
-  }
-
-  return true;
+  return abstractlistaction::validateAction(protocol, params);
 }