/// <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);
}
void Start()
{
recordContainer = gameObject.GetComponent <RecordContainer> ();
GameObject
.FindObjectOfType <EventEmitterContainer> ()
.GetEventEmitter()
.RegisterHandler(this);
}
void Start()
{
// if not a local player but still exists in the game instance (and not the server)
// we want to return and not retrieve the record.
if (!isLocalPlayer && !isServer)
{
return;
}
recordContainer = GameObject.FindObjectOfType <RecordContainer> ();
profileContainer = gameObject.GetComponent <PlayerProfileContainer> ();
}
/// <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 void Init()
{
profile = new PlayerProfile("Jayden", Color.black);
gameRecordMock = Substitute.For <GameRecord> (
0, BackgroundSelector.RoomType.ROOM_DAY, DateTime.Now
);
messengerMock = Substitute.For <GameHistoryClientMessenger> (
null, null
);
GameObject holder = new GameObject();
subject = holder.AddComponent <RecordContainer> ();
subject.messenger = messengerMock;
subject.record = gameRecordMock;
}
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()));
}
public void SampleRecordRepository_GetRecords()
{
var expected1 = new RecordContainer()
{
Records = new List <Record>()
{
new Record()
{
Header = new RecordHeader()
{
Identifier = "11"
},
Metadata = new RecordMetadata()
{
Content = XElement.Parse($@"{DublinCoreMetadataConverterTest.OAI_DC_ROOT}
<dc:title>Title 1</dc:title>
<dc:creator>Owner 1</dc:creator>
<dc:contributor>Contributor 1</dc:contributor>
<dc:contributor>Contributor 1.1</dc:contributor>
<dc:date>2018-02-16T01:00:00Z</dc:date>
<dc:identifier>11</dc:identifier>
</oai_dc:dc>")
}
},
new Record()
{
Header = new RecordHeader()
{
Identifier = "12"
}
}
},
ResumptionToken = new ResumptionToken()
{
CompleteListSize = 5,
Cursor = 0,
Custom = new Dictionary <string, string>()
{
{ "offset", "12" }
}
}
};
var actual1 = _repository.GetRecords(new ArgumentContainer(OaiVerb.ListRecords.ToString()));
Assert.IsNotNull(actual1.ResumptionToken);
Assert.AreEqual(expected1.ResumptionToken.CompleteListSize, actual1.ResumptionToken.CompleteListSize);
Assert.AreEqual(expected1.ResumptionToken.Cursor, actual1.ResumptionToken.Cursor);
Assert.AreEqual(expected1.Records.ToList()[0].Header.Identifier, actual1.Records.ToList()[0].Header.Identifier);
Assert.AreEqual(expected1.Records.ToList()[1].Header.Identifier, actual1.Records.ToList()[1].Header.Identifier);
Assert.AreEqual(expected1.Records.ToList()[0].Metadata.Content.ToString(), actual1.Records.ToList()[0].Metadata.Content.ToString());
Assert.AreEqual(expected1.ResumptionToken.Custom["offset"], actual1.ResumptionToken.Custom["offset"]);
var expected2 = new RecordContainer()
{
Records = new List <Record>()
{
new Record()
{
Header = new RecordHeader()
{
Identifier = "13"
}
},
new Record()
{
Header = new RecordHeader()
{
Identifier = "14"
}
}
},
ResumptionToken = new ResumptionToken()
{
CompleteListSize = 5,
Cursor = 2,
Custom = new Dictionary <string, string>()
{
{ "offset", "14" }
}
}
};
var actual2 = _repository.GetRecords(new ArgumentContainer(OaiVerb.ListRecords.ToString()), actual1.ResumptionToken);
Assert.IsNotNull(actual2.ResumptionToken);
Assert.AreEqual(expected2.ResumptionToken.CompleteListSize, actual2.ResumptionToken.CompleteListSize);
Assert.AreEqual(expected2.ResumptionToken.Cursor, actual2.ResumptionToken.Cursor);
Assert.AreEqual(expected2.Records.ToList()[0].Header.Identifier, actual2.Records.ToList()[0].Header.Identifier);
Assert.AreEqual(expected2.Records.ToList()[1].Header.Identifier, actual2.Records.ToList()[1].Header.Identifier);
Assert.AreEqual(expected2.ResumptionToken.Custom["offset"], actual2.ResumptionToken.Custom["offset"]);
}
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);
}
