public string Encode(IResumptionToken resumptionToken)
{
IList <string> properties = new List <string>();
if (!string.IsNullOrWhiteSpace(resumptionToken.MetadataPrefix))
{
properties.Add(EncodeOne("metadataPrefix", resumptionToken.MetadataPrefix));
}
if (resumptionToken.From.HasValue)
{
properties.Add(EncodeOne("from", _dateConverter.Encode(_configuration.Granularity, resumptionToken.From)));
}
if (resumptionToken.Until.HasValue)
{
properties.Add(EncodeOne("until", _dateConverter.Encode(_configuration.Granularity, resumptionToken.Until)));
}
if (!string.IsNullOrWhiteSpace(resumptionToken.Set))
{
properties.Add(EncodeOne("set", resumptionToken.Set));
}
foreach (var custom in resumptionToken.Custom)
{
if (_configuration.ResumptionTokenCustomParameterNames.Contains(custom.Key))
{
properties.Add(EncodeOne(custom.Key, custom.Value));
}
}
return(HttpUtility.UrlEncode(string.Join("&", properties.ToArray())));
}
public void ResumptionTokenConverter_Decode()
{
string token = "from=1987-02-16T00%3a00%3a00Z&until=2018-02-16T00%3a00%3a00Z&metadataPrefix=oai_dc" +
"&set=test123&expirationDate=2019-02-16T00%3a00%3a00Z&completeListSize=123&cursor=321&placeholder=123&test=123";
IResumptionToken actual = _converter.Decode(token);
IResumptionToken expected = new ResumptionToken()
{
From = new DateTime(1987, 2, 16, 0, 0, 0, DateTimeKind.Utc),
Until = new DateTime(2018, 2, 16, 0, 0, 0, DateTimeKind.Utc),
MetadataPrefix = "oai_dc",
Set = "test123",
ExpirationDate = new DateTime(2019, 2, 16, 0, 0, 0, DateTimeKind.Utc),
CompleteListSize = 123,
Cursor = 321
};
expected.Custom["placeholder"] = "123";
Assert.AreEqual(expected.From.Value.Kind, actual.From.Value.Kind);
Assert.AreEqual(expected.From, actual.From);
Assert.AreEqual(expected.Until.Value.Kind, actual.Until.Value.Kind);
Assert.AreEqual(expected.Until, actual.Until);
Assert.AreEqual(expected.MetadataPrefix, actual.MetadataPrefix);
Assert.AreEqual(expected.Set, actual.Set);
Assert.AreEqual(expected.ExpirationDate.Value.Kind, actual.ExpirationDate.Value.Kind);
Assert.AreEqual(expected.ExpirationDate, actual.ExpirationDate);
Assert.AreEqual(expected.CompleteListSize, actual.CompleteListSize);
Assert.AreEqual(expected.Cursor, actual.Cursor);
Assert.AreEqual(expected.Custom["placeholder"], actual.Custom["placeholder"]);
Assert.IsFalse(actual.Custom.ContainsKey("test"));
}
/// <summary>
/// Obtiene los records del repositorio en función de los argumentos pasados
/// </summary>
/// <param name="arguments">Parámetros de la consulta</param>
/// <param name="resumptionToken">Token de reanudación</param>
/// <returns></returns>
public RecordContainer GetRecords(ArgumentContainer arguments, IResumptionToken resumptionToken = null)
{
RecordContainer container = new RecordContainer();
DateTime inicio = DateTime.MinValue;
if (_dateConverter.TryDecode(arguments.From, out DateTime from))
{
inicio = from;
}
HashSet <string> ids = GetCurriculumsIDs(inicio, _configOAI_PMH_CVN.GetXML_CVN_Repository());
List <CVN> listCVN = new List <CVN>();
foreach (string id in ids)
{
DateTime date = DateTime.UtcNow.AddDays(-100 + int.Parse(id));
if (date > inicio)
{
listCVN.Add(GetCurriculum(id, arguments.Verb == OaiVerb.ListIdentifiers.ToString(), _configOAI_PMH_CVN.GetXML_CVN_Repository()));
}
}
if (arguments.Verb == OaiVerb.ListIdentifiers.ToString())
{
container.Records = listCVN.Select(r => ToIdentifiersRecord(r));
}
else
{
container.Records = listCVN.Select(r => ToRecord(r, arguments.MetadataPrefix));
}
container.Records = container.Records.Where(x => x.Header.Datestamp > inicio).ToList();
return(container);
}
/// <summary>
/// Obtiene los sets del repositorio en función de los argumentos pasados
/// </summary>
/// <param name="arguments">Parámetros de la consulta</param>
/// <param name="resumptionToken">Token de reanudación</param>
/// <returns></returns>
public SetContainer GetSets(ArgumentContainer arguments, IResumptionToken resumptionToken = null)
{
SetContainer container = new SetContainer();
IQueryable<Set> sets = _sets.AsQueryable().OrderBy(s => s.Name);
int totalCount = sets.Count();
container.Sets = sets.Take(_configuration.PageSize);
return container;
}
/// <summary>
/// Obtiene los records del repositorio en función de los argumentos pasados
/// </summary>
/// <param name="arguments">Parámetros de la consulta</param>
/// <param name="resumptionToken">Token de reanudación</param>
/// <returns></returns>
public RecordContainer GetRecords(ArgumentContainer arguments, IResumptionToken resumptionToken = null)
{
RecordContainer container = new RecordContainer();
DateTime inicio = DateTime.MinValue;
if (_dateConverter.TryDecode(arguments.From, out DateTime from))
{
inicio = from;
}
List <XML> listxml = new List <XML>();
Random r = new Random();
if (arguments.Verb == OaiVerb.ListIdentifiers.ToString())
{
//ListIdentifiers
HashSet <string> files = GetXMLFiles(arguments.Set);
foreach (string file in files)
{
//Cogemos aleatoriamente el 50% de los ficheros encontrados
if (r.Next(100) < 50)
{
listxml.Add(GetXML(file));
}
}
container.Records = listxml.Select(r => ToIdentifiersRecord(r));
}
else
{
//ListRecords
HashSet <string> files = GetXMLFiles(arguments.Set);
foreach (string file in files)
{
//Cogemos aleatoriamente el 50% de los ficheros encontrados
if (r.Next(100) < 50)
{
listxml.Add(GetXML(file));
}
}
container.Records = listxml.Select(r => ToRecord(r, arguments.MetadataPrefix));
}
container.Records = container.Records.Where(x => x.Header.Datestamp > inicio).ToList();
return(container);
}
public XElement ToXElement(IResumptionToken resumptionToken)
{
XElement root = new XElement("resumptionToken", Encode(resumptionToken));
if (resumptionToken.ExpirationDate.HasValue)
{
root.Add(new XAttribute("expirationDate", _dateConverter.Encode(_configuration.Granularity, resumptionToken.ExpirationDate)));
}
if (resumptionToken.CompleteListSize.HasValue)
{
root.Add(new XAttribute("completeListSize", resumptionToken.CompleteListSize.Value));
}
if (resumptionToken.Cursor.HasValue)
{
root.Add(new XAttribute("cursor", resumptionToken.Cursor.Value));
}
return(root);
}
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()));
}
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()));
}
/// <summary>
/// Obtiene los identificadores del repositorio en función de los argumentos pasados
/// </summary>
/// <param name="arguments">Parámetros de la consulta</param>
/// <param name="resumptionToken">Token de reanudación</param>
/// <returns></returns>
public RecordContainer GetIdentifiers(ArgumentContainer arguments, IResumptionToken resumptionToken = null)
{
return(GetRecords(arguments, resumptionToken));
}
public RecordContainer GetRecords(ArgumentContainer arguments, IResumptionToken resumptionToken = null)
{
RecordContainer container = new RecordContainer();
IQueryable <SampleRecord> records = _records.AsQueryable().OrderBy(r => r.Id);
int totalCount = records.Count();
if (resumptionToken != null)
{
if (resumptionToken.From.HasValue)
{
records = records.Where(r => r.Date >= resumptionToken.From.Value);
}
if (resumptionToken.Until.HasValue)
{
records = records.Where(r => r.Date <= resumptionToken.Until.Value);
}
if (resumptionToken.Custom.ContainsKey("offset") && resumptionToken.Custom.TryGetValue("offset", out string offset))
{
if (int.TryParse(offset, out int parsedOffset))
{
records = records.Where(r => r.Id > parsedOffset);
}
}
}
ResumptionToken newResumptionToken = null;
if (records.Count() > _configuration.PageSize)
{
newResumptionToken = new ResumptionToken();
container.ResumptionToken = newResumptionToken;
if (_dateConverter.TryDecode(arguments.From, out DateTime from))
{
newResumptionToken.From = from;
}
if (_dateConverter.TryDecode(arguments.Until, out DateTime until))
{
newResumptionToken.Until = until;
}
newResumptionToken.MetadataPrefix = arguments.MetadataPrefix;
newResumptionToken.Set = arguments.Set;
if (_configuration.ExpirationTimeSpan.HasValue)
{
newResumptionToken.ExpirationDate = DateTime.UtcNow.Add(_configuration.ExpirationTimeSpan.Value);
}
newResumptionToken.CompleteListSize = totalCount;
newResumptionToken.Cursor = 0;
}
records = records.Take(_configuration.PageSize);
if (newResumptionToken != null)
{
if (resumptionToken != null)
{
// Increase the cursor value
newResumptionToken.Cursor = resumptionToken.Cursor.HasValue ?
resumptionToken.Cursor.Value + _configuration.PageSize : _configuration.PageSize;
}
// Add custom offset value
var lastRecord = records.LastOrDefault();
if (lastRecord != null)
{
newResumptionToken.Custom.Add("offset", lastRecord.Id.ToString());
}
}
container.Records = records.Select(r => ToRecord(r));
return(container);
}
