Exemplo n.º 1
0
 def __metadataFormatList(self):
     systemConfig = JsonSimpleConfig()
     metadataFormats = systemConfig.getObject(["portal", "oai-pmh", "metadataFormats"])
     metadataList = []
     for format in metadataFormats.keySet():
         metadataList.append(str(format))
     return metadataList
Exemplo n.º 2
0
class OaiPmhVerb:
    def __init__(self, formData, currentToken, sessionState, context):
        self.log = context["log"]
        self.config = JsonSimpleConfig()

        self.__error = None
        self.__verb = formData.get("verb")
        self.__metadataFormats = self.__metadataFormatList()
        self.log.debug(" * OAI Verb = '{}'", self.__verb)

        if self.__verb is None:
            self.__error = OaiPmhError("badVerb", "No verb was specified")

        elif self.__verb in ["GetRecord", "ListIdentifiers", "ListRecords"]:
            self.__metadataPrefix = formData.get("metadataPrefix")
            if self.__metadataPrefix is None:
                if currentToken:
                    #check expiry
                    if currentToken.getExpiry() > System.currentTimeMillis():
                        self.__metadataPrefix = currentToken.getMetadataPrefix()
                    else:
                        self.__error = OaiPmhError("badResumptionToken", "Token has expired")
                        tokenList = sessionState.get("resumptionTokenList")
                        tokenList.pop(currentToken.getToken())
                        sessionState.set("resumptionTokenList", tokenList)
                else:
                    self.__error = OaiPmhError("badResumptionToken", "Invalid token")
            elif self.__metadataPrefix not in self.__metadataFormats:
                self.__error = OaiPmhError("cannotDisseminateFormat",
                                           "Record not available as metadata type: %s" % self.__metadataPrefix)
        elif self.__verb in ["Identify", "ListMetadataFormats", "ListSets"]:
            pass
        else:
            self.__error = OaiPmhError("badVerb", "Unknown verb: '%s'" % self.__verb)

    def __metadataFormatList(self):
        metadataFormats = self.config.getObject(["portal", "oai-pmh", "metadataFormats"])
        metadataList = []
        for format in metadataFormats.keySet():
            metadataList.append(str(format))
        return metadataList

    def getError(self):
        return self.__error

    def getVerb(self):
        return self.__verb

    def getMetadataPrefix(self):
        return self.__metadataPrefix

    def getIdentifier(self):
        return self.__identifier
Exemplo n.º 3
0
class OaiPmhVerb:
    def __init__(self, context, tokenDB, currentToken):
        self.log = context["log"]
        self.config = JsonSimpleConfig()
        formData = context["formData"]

        self.__error = None
        self.__verb = formData.get("verb")
        self.__metadataFormats = self.__metadataFormatList()
        self.__fromDate = None
        self.__untilDate = None
        self.log.debug(" * OAI Verb = '{}'", self.__verb)

        # No verb provided
        if self.__verb is None:
            self.__error = OaiPmhError("badVerb", "No verb was specified")

        # Some verbs require additional data
        elif self.__verb in ["GetRecord", "ListIdentifiers", "ListRecords"]:
            # What format metadata is requested?
            self.__metadataPrefix = formData.get("metadataPrefix")
            if self.__metadataPrefix is None:
                # No metadata supplied, error...
                #   unless the are resuming an earlier request
                if currentToken is not None:
                    # Make sure the resumption token hasn't expired
                    if currentToken.getExpiry() > System.currentTimeMillis():
                        # And retrieve the metadata prefix from the last request
                        self.__metadataPrefix = currentToken.getMetadataPrefix()

                    # Expired token, make sure it's not in the database anymore
                    else:
                        self.log.error("Using an expired token")
                        self.__error = OaiPmhError("badResumptionToken", "Token has expired")
                        success = tokenDB.removeToken(currentToken)
                        if not success:
                            self.log.error("Error removing expired token!")

                # No prefix and no token. We're done
                else:
                    attemptedToken = context["formData"].get("resumptionToken")
                    # Either they used an invalid token
                    if attemptedToken is not None:
                        self.log.error("Illegal resumption token: '{}'", attemptedToken)
                        self.__error = OaiPmhError("badResumptionToken", "Illegal resumption token")
                    # Or were missing their metadata prefix
                    else:
                        self.log.error("No metadata prefix supplied, and no token")
                        self.__error = OaiPmhError("badArgument", "Metadata prefix required")

            # These verbs require a metadata format... and we must be able to support it
            elif self.__metadataPrefix not in self.__metadataFormats:
                self.log.error("Metadata prefix is not valid for this view")
                self.__error = OaiPmhError("cannotDisseminateFormat",
                                           "Record not available as metadata type: %s" % self.__metadataPrefix)

            # These verbs allow for date limits, validate them if found
            if self.__verb in ["ListIdentifiers", "ListRecords"]:
                # From date
                fromStr = context["formData"].get("from")
                fromTIndex = None
                if fromStr is not None:
                    fromTIndex = fromStr.find("T")
                    # Basic dates
                    try:
                        if fromTIndex == -1:
                            self.__fromDate = datetime.strptime(fromStr, "%Y-%m-%d")
                        # Or datetimes
                        else:
                            self.__fromDate = datetime.strptime(fromStr, "%Y-%m-%dT%H:%M:%SZ")
                    except:
                        self.log.error("Invalid FROM date: '{}'", fromStr)
                        self.__error = OaiPmhError("badArgument", "From date not in valid format!")
                        return

                # Until Date
                untilStr = context["formData"].get("until")
                if untilStr is not None:
                    untilTIndex = untilStr.find("T")
                    # Granularity mismatches
                    if (fromTIndex is not None) and \
                            ((fromTIndex == -1 and untilTIndex != -1) or \
                            (fromTIndex != -1 and untilTIndex == -1)):
                        self.log.error("Date granularity mismatch: '{}' vs '{}'", fromStr, untilStr)
                        self.__error = OaiPmhError("badArgument", "Date granularity mismatch")
                        return
                    # Basic dates
                    try:
                        if untilTIndex == -1:
                            self.__untilDate = datetime.strptime(untilStr, "%Y-%m-%d")
                        # Or datetimes
                        else:
                            self.__untilDate = datetime.strptime(untilStr, "%Y-%m-%dT%H:%M:%SZ")
                    except:
                        self.log.error("Invalid UNTIL date: '{}'", untilStr)
                        self.__error = OaiPmhError("badArgument", "Until date not in valid format!")
                        return

                # Sanity check
                if self.__fromDate is not None and self.__untilDate is not None:
                    if self.__fromDate > self.__untilDate:
                        self.log.error("FROM date > UNTIL date: '{}' > '{}'", fromStr, untilStr)
                        self.__error = OaiPmhError("badArgument", "From date cannot be later then Until date!")
                        return

            # Check for a valid identifier
            if self.__verb == "GetRecord":
                id = context["formData"].get("identifier")
                if id is None or id == "":
                    self.log.error("GetRecord missing an identifier")
                    self.__error = OaiPmhError("badArgument", "Identifier required")
                    return

        # Basic verbs we will respond to easily
        elif self.__verb in ["Identify", "ListMetadataFormats", "ListSets"]:
            pass

        # Invalid verb
        else:
            self.log.error("Invalid verb provided: '{}'", self.__verb)
            self.__error = OaiPmhError("badVerb", "Unknown verb: '%s'" % self.__verb)

    def __metadataFormatList(self):
        metadataFormats = self.config.getObject(["portal", "oai-pmh", "metadataFormats"])
        metadataList = []
        for format in metadataFormats.keySet():
            metadataList.append(str(format))
        return metadataList

    def getError(self):
        return self.__error

    def setError(self, code, message):
        self.__error = OaiPmhError(code, message)

    def getVerb(self):
        return self.__verb

    def getMetadataPrefix(self):
        return self.__metadataPrefix

    def getIdentifier(self):
        return self.__identifier

    def getFromDate(self):
        return self.__fromDate

    def getUntilDate(self):
        return self.__untilDate