Beispiel #1
0
        private XDocument CreateIdentify(DateTime date, ArgumentContainer arguments)
        {
            OaiVerb verb = OaiVerb.Identify;

            OaiArgument allowedArguments = OaiArgument.None;

            if (!OaiErrors.ValidateArguments(arguments, allowedArguments, out XElement errorElement))
            {
                return(CreateErrorDocument(date, verb, arguments, errorElement));
            }

            IList <XElement> root = new List <XElement>();

            root.Add(CreateRequest(verb, arguments));

            XElement content = new XElement(verb.ToString());

            root.Add(content);

            TryAddXElement(content, "repositoryName", _configuration.RepositoryName);
            TryAddXElement(content, "baseURL", _configuration.BaseUrl());
            TryAddXElement(content, "protocolVersion", _configuration.ProtocolVersion);

            if (_configuration.AdminEmails != null)
            {
                foreach (var adminEmail in _configuration.AdminEmails)
                {
                    TryAddXElement(content, "adminEmail", adminEmail);
                }
            }

            TryAddXElement(content, "earliestDatestamp", _configuration.EarliestDatestamp);
            TryAddXElement(content, "deletedRecord", _configuration.DeletedRecord);
            TryAddXElement(content, "granularity", GetDisplayGranularity());

            if (_configuration.Compressions != null)
            {
                foreach (var compression in _configuration.Compressions)
                {
                    TryAddXElement(content, "compression", compression);
                }
            }

            if (_configuration.Descriptions != null)
            {
                foreach (var description in _configuration.Descriptions)
                {
                    TryAddXElement(content, "description", description);
                }
            }

            return(CreateXml(date, root.ToArray()));
        }
Beispiel #2
0
        private XDocument CreateListMetadataFormats(DateTime date, ArgumentContainer arguments)
        {
            OaiVerb verb = OaiVerb.ListMetadataFormats;

            OaiArgument allowedArguments = OaiArgument.Identifier;

            if (!OaiErrors.ValidateArguments(arguments, allowedArguments, out XElement errorElement))
            {
                return(CreateErrorDocument(date, verb, arguments, errorElement));
            }

            if (!string.IsNullOrWhiteSpace(arguments.Identifier) && _recordRepository.GetRecord(arguments.Identifier, arguments.MetadataPrefix) == null)
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.IdDoesNotExist));
            }

            var formats = _metadataFormatRepository.GetMetadataFormats().OrderBy(e => e.Prefix);

            if (formats.Count() <= 0)
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.NoMetadataFormats));
            }

            IList <XElement> root = new List <XElement>();

            root.Add(CreateRequest(verb, arguments));

            XElement content = new XElement(verb.ToString());

            root.Add(content);

            foreach (var format in formats)
            {
                XElement formatElement = new XElement("metadataFormat");
                content.Add(formatElement);
                TryAddXElement(formatElement, "metadataPrefix", format.Prefix);
                TryAddXElement(formatElement, "schema", format.Schema?.ToString());
                TryAddXElement(formatElement, "metadataNamespace", format.Namespace?.ToString());
            }

            return(CreateXml(date, root.ToArray()));
        }
Beispiel #3
0
        private XDocument CreateListSets(DateTime date, ArgumentContainer arguments, IResumptionToken resumptionToken = null)
        {
            OaiVerb verb = OaiVerb.ListSets;

            OaiArgument allowedArguments = OaiArgument.ResumptionToken;

            if (!OaiErrors.ValidateArguments(arguments, allowedArguments, out XElement errorElement))
            {
                return(CreateErrorDocument(date, verb, arguments, errorElement));
            }

            // Set
            if (!_configuration.SupportSets)
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.NoSetHierarchy));
            }

            // Decode ResumptionToken
            if (resumptionToken == null && !string.IsNullOrWhiteSpace(arguments.ResumptionToken))
            {
                if (!OaiErrors.ValidateArguments(arguments, OaiArgument.ResumptionToken))
                {
                    return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadArgumentExclusiveResumptionToken));
                }

                IResumptionToken decodedResumptionToken = _resumptionTokenConverter.Decode(arguments.ResumptionToken);
                if (decodedResumptionToken.ExpirationDate >= DateTime.UtcNow)
                {
                    return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadResumptionToken));
                }

                ArgumentContainer resumptionTokenArguments = new ArgumentContainer(
                    verb.ToString(), decodedResumptionToken.MetadataPrefix, arguments.ResumptionToken, null,
                    _dateConverter.Encode(_configuration.Granularity, decodedResumptionToken.From),
                    _dateConverter.Encode(_configuration.Granularity, decodedResumptionToken.Until),
                    decodedResumptionToken.Set);

                return(CreateListSets(date, resumptionTokenArguments, decodedResumptionToken));
            }

            var setContainer = _setRepository.GetSets(arguments, resumptionToken);

            IList <XElement> root = new List <XElement>();

            root.Add(CreateRequest(verb, arguments));

            XElement content = new XElement(verb.ToString());

            root.Add(content);

            if (setContainer != null)
            {
                foreach (var set in setContainer.Sets)
                {
                    XElement setElement = new XElement("set");
                    content.Add(setElement);
                    TryAddXElement(setElement, "setSpec", set.Spec);
                    TryAddXElement(setElement, "setName", set.Name);
                    TryAddXElement(setElement, "setDescription", set.Description);
                    foreach (var additionalDescription in set.AdditionalDescriptions)
                    {
                        setElement.Add(new XElement("setDescription", additionalDescription));
                    }
                }

                if (setContainer.ResumptionToken != null)
                {
                    content.Add(_resumptionTokenConverter.ToXElement(setContainer.ResumptionToken));
                }
            }

            return(CreateXml(date, root.ToArray()));
        }
Beispiel #4
0
        private XDocument CreateListIdentifiersOrRecords(DateTime date, ArgumentContainer arguments, OaiVerb verb, IResumptionToken resumptionToken = null)
        {
            OaiArgument allowedArguments = OaiArgument.MetadataPrefix | OaiArgument.ResumptionToken |
                                           OaiArgument.From | OaiArgument.Until | OaiArgument.Set;

            if (!OaiErrors.ValidateArguments(arguments, allowedArguments, out XElement errorElement))
            {
                return(CreateErrorDocument(date, verb, arguments, errorElement));
            }

            // Set
            if (!string.IsNullOrWhiteSpace(arguments.Set) && !_configuration.SupportSets)
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.NoSetHierarchy));
            }

            // From
            DateTime fromDate = DateTime.MinValue;

            if (!string.IsNullOrWhiteSpace(arguments.From) && !_dateConverter.TryDecode(arguments.From, out fromDate))
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadFromArgument));
            }

            // Until
            DateTime untilDate = DateTime.MinValue;

            if (!string.IsNullOrWhiteSpace(arguments.Until) && !_dateConverter.TryDecode(arguments.Until, out untilDate))
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadUntilArgument));
            }

            // The from argument must be less than or equal to the until argument.
            if (fromDate > untilDate)
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadFromUntilCombinationArgument));
            }

            // Decode ResumptionToken
            if (resumptionToken == null && !string.IsNullOrWhiteSpace(arguments.ResumptionToken))
            {
                if (!OaiErrors.ValidateArguments(arguments, OaiArgument.ResumptionToken))
                {
                    return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadArgumentExclusiveResumptionToken));
                }

                try
                {
                    IResumptionToken decodedResumptionToken = _resumptionTokenConverter.Decode(arguments.ResumptionToken);
                    if (decodedResumptionToken.ExpirationDate >= DateTime.UtcNow)
                    {
                        return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadResumptionToken));
                    }

                    ArgumentContainer resumptionTokenArguments = new ArgumentContainer(
                        verb.ToString(), decodedResumptionToken.MetadataPrefix, arguments.ResumptionToken, null,
                        _dateConverter.Encode(_configuration.Granularity, decodedResumptionToken.From),
                        _dateConverter.Encode(_configuration.Granularity, decodedResumptionToken.Until),
                        decodedResumptionToken.Set);

                    return(CreateListIdentifiersOrRecords(date, resumptionTokenArguments, verb, decodedResumptionToken));
                }
                catch (Exception)
                {
                    return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadResumptionToken));
                }
            }

            // Check if required metadata prefix is included in the request
            if (string.IsNullOrWhiteSpace(arguments.MetadataPrefix))
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadMetadataArgument));
            }

            // Check if metadata prefix is supported
            var metadataPrefix = _metadataFormatRepository.GetMetadataFormat(arguments.MetadataPrefix);

            if (metadataPrefix == null)
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.CannotDisseminateFormat));
            }

            var recordContainer = new RecordContainer();

            if (verb == OaiVerb.ListRecords)
            {
                recordContainer = _recordRepository.GetRecords(arguments, resumptionToken);
            }
            else
            {
                recordContainer = _recordRepository.GetIdentifiers(arguments, resumptionToken);
            }

            if (recordContainer == null || recordContainer.Records.Count() <= 0)
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.NoRecordsMatch));
            }

            IList <XElement> root = new List <XElement>();

            root.Add(CreateRequest(verb, arguments));

            XElement content = new XElement(verb.ToString());

            root.Add(content);

            foreach (var record in recordContainer.Records)
            {
                XElement recordElement = content;

                if (verb == OaiVerb.ListRecords)
                {
                    recordElement = new XElement("record");
                    content.Add(recordElement);
                }

                // Header
                if (record.Header != null)
                {
                    recordElement.Add(CreateHeaderXElement(record.Header));
                }
                // Metadata
                if (record.Metadata != null && verb == OaiVerb.ListRecords)
                {
                    recordElement.Add(CreateMetadataXElement(record.Metadata));
                }
            }

            if (recordContainer.ResumptionToken != null)
            {
                content.Add(_resumptionTokenConverter.ToXElement(recordContainer.ResumptionToken));
            }

            return(CreateXml(date, root.ToArray()));
        }
Beispiel #5
0
        private XDocument CreateGetRecord(DateTime date, ArgumentContainer arguments)
        {
            OaiVerb verb = OaiVerb.GetRecord;

            OaiArgument allowedArguments = OaiArgument.Identifier | OaiArgument.MetadataPrefix;

            if (!OaiErrors.ValidateArguments(arguments, allowedArguments, out XElement errorElement))
            {
                return(CreateErrorDocument(date, verb, arguments, errorElement));
            }

            // Check if required identifier is included in the request
            if (string.IsNullOrWhiteSpace(arguments.Identifier))
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadIdentifierArgument));
            }

            // Check if required metadata prefix is included in the request
            if (string.IsNullOrWhiteSpace(arguments.MetadataPrefix))
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.BadMetadataArgument));
            }

            // Check if metadata prefix is supported
            var metadataPrefix = _metadataFormatRepository.GetMetadataFormat(arguments.MetadataPrefix);

            if (metadataPrefix == null)
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.CannotDisseminateFormat));
            }

            Record record = _recordRepository.GetRecord(arguments.Identifier, arguments.MetadataPrefix);

            if (record == null)
            {
                return(CreateErrorDocument(date, verb, arguments, OaiErrors.IdDoesNotExist));
            }

            IList <XElement> root = new List <XElement>();

            root.Add(CreateRequest(verb, arguments));

            XElement content = new XElement(verb.ToString());

            root.Add(content);

            XElement recordElement = new XElement("record");

            content.Add(recordElement);

            // Header
            if (record.Header != null)
            {
                recordElement.Add(CreateHeaderXElement(record.Header));
            }
            // Metadata
            if (record.Metadata != null)
            {
                recordElement.Add(CreateMetadataXElement(record.Metadata));
            }

            return(CreateXml(date, root.ToArray()));
        }