public static XElement Encode(Metadata dublinCore, string granularity)
{
// The DatetimeFormat for OAI-PMH is only valid when it is like this YYYY.MM.DD
// but c# ist not understanding YYYY ->it must replaced with yyyy & DD -> dd
granularity = granularity.Replace('Y', 'y');
granularity = granularity.Replace('D', 'd');
return(new XElement(MlNamespaces.oaiDc + "dc",
new XAttribute(XNamespace.Xmlns + "oai_dc", MlNamespaces.oaiDc),
new XAttribute(XNamespace.Xmlns + "dc", MlNamespaces.dcNs),
new XAttribute(XNamespace.Xmlns + "xsi", MlNamespaces.dcXsi),
new XAttribute(MlNamespaces.dcXsi + "schemaLocation", MlNamespaces.dcSchemaLocation),
/* content */
MlEncode.Element(MlNamespaces.dcNs + "title", dublinCore.Title),
MlEncode.Element(MlNamespaces.dcNs + "creator", dublinCore.Creator),
MlEncode.Element(MlNamespaces.dcNs + "subject", dublinCore.Subject),
MlEncode.Element(MlNamespaces.dcNs + "description", dublinCore.Description),
MlEncode.Element(MlNamespaces.dcNs + "publisher", dublinCore.Publisher),
MlEncode.Element(MlNamespaces.dcNs + "contributor", dublinCore.Contributor),
!dublinCore.Date.HasValue ? null
: new XElement(MlNamespaces.dcNs + "date",
dublinCore.Date.Value.ToUniversalTime().ToString(granularity)),
MlEncode.Element(MlNamespaces.dcNs + "type", dublinCore.Type),
MlEncode.Element(MlNamespaces.dcNs + "format", dublinCore.Format),
MlEncode.Element(MlNamespaces.dcNs + "identifier", dublinCore.Identifier),
MlEncode.Element(MlNamespaces.dcNs + "source", dublinCore.Source),
MlEncode.Element(MlNamespaces.dcNs + "language", dublinCore.Language),
MlEncode.Element(MlNamespaces.dcNs + "relation", dublinCore.Relation),
MlEncode.Element(MlNamespaces.dcNs + "coverage", dublinCore.Coverage),
MlEncode.Element(MlNamespaces.dcNs + "rights", dublinCore.Rights)
));
}
private static XElement[] GetListRecords(List <RecordQueryResult> records, bool isAbout)
{
return((from rec in records
select new XElement("record",
MlEncode.HeaderItem(rec.Header, Properties.granularity),
MlEncode.Metadata(rec.Metadata, Properties.granularity),
isAbout ? MlEncode.About(rec.About, Properties.granularity) : null
)).ToArray());
}
/* Xml / Metadata operations */
public static IEnumerable <string> ReverseNames(string value)
{
foreach (var xElName in MlEncode.Element("el", value))
{
string normalName = string.Empty;
string[] splitNames = xElName.Value.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries);
for (int i = splitNames.Length - 1; i >= 0; i--)
{
normalName += splitNames[i].Trim() + (i == 0 ? "" : " ");
}
yield return(normalName);
}
}
private static XElement EncodeOne(Metadata provenance, string granularity)
{
return(new XElement("originDescription",
new XAttribute("harvestDate",
DateInGranularity(provenance.AdditionalDateTime1, provenance.AdditionalBool2, granularity)),
new XAttribute("altered",
!provenance.AdditionalBool1.HasValue ? bool.FalseString.ToLower() :
provenance.AdditionalBool1.Value.ToString().ToLower()),
MlEncode.Element("baseUrl", provenance.Source),
MlEncode.Element("identifier", provenance.Identifier),
new XAttribute("datestamp",
DateInGranularity(provenance.Date, provenance.AdditionalBool3, granularity)),
MlEncode.Element("metadataNamespace", provenance.Format)
));
}
public static XDocument ListSets(string resumptionToken, bool isRoundtrip, List <XElement> errorList)
{
List <XElement> errors = errorList;
if (!Properties.supportSets)
{
errors.Add(MlErrors.noSetHierarchy);
}
bool isResumption = !String.IsNullOrEmpty(resumptionToken);
if (isResumption && !isRoundtrip)
{
if (!(Properties.resumptionTokens.ContainsKey(resumptionToken) &&
Properties.resumptionTokens[resumptionToken].Verb == "ListSets" &&
Properties.resumptionTokens[resumptionToken].ExpirationDate >= DateTime.UtcNow))
{
errors.Insert(0, MlErrors.badResumptionArgument);
}
if (errors.Count == 0)
{
return(ListSets(resumptionToken, true, new List <XElement>()));
}
}
XElement request = new XElement("request",
new XAttribute("verb", "ListSets"),
isResumption ? new XAttribute("resumptionToken", resumptionToken) : null,
Properties.baseURL);
if (errors.Count > 0)
{
errors.Insert(0, request); /* add request on the first position, that it will be diplayed before errors */
return(CreateXml(errors.ToArray()));
}
OAIHelper oaiHelper = new OAIHelper();
var sets = oaiHelper.GetAllSets();
bool isCompleted = isResumption ?
Properties.resumptionTokens[resumptionToken].Cursor + sets.Count ==
Properties.resumptionTokens[resumptionToken].CompleteListSize :
false;
XElement list = new XElement("ListSets",
from s in sets
select new XElement("set",
new XElement("setSpec", s.Spec),
new XElement("setName", s.Name),
String.IsNullOrEmpty(s.Description) ? null
: new XElement("setDescription", s.Description),
MlEncode.SetDescription(s.AdditionalDescriptions, Properties.granularity)),
isResumption ? /* add resumption token or not */
MlEncode.ResumptionToken(Properties.resumptionTokens[resumptionToken], resumptionToken, isCompleted)
: null);
if (isResumption)
{
if (isCompleted)
{
Properties.resumptionTokens.Remove(resumptionToken);
}
else
{
Properties.resumptionTokens[resumptionToken].Cursor =
Properties.resumptionTokens[resumptionToken].Cursor + sets.Count;
}
}
return(CreateXml(new XElement[] { request, list }));
}
private static XElement[] GetListIdentifiers(List <RecordQueryResult> records)
{
return((from rec in records
select MlEncode.HeaderItem(rec.Header, Properties.granularity)).ToArray());
}
public static XDocument ListIdentifiersOrRecords(
string verb,
string from,
string until,
string metadataPrefix,
string set,
string resumptionToken,
bool isRoundtrip,
List <XElement> errorList,
bool?loadAbout)
{
List <XElement> errors = errorList;
DateTime? fromDate = DateTime.MinValue;
DateTime? untilDate = DateTime.MaxValue;
/* VERB */
bool isRecord = false;
if (String.IsNullOrEmpty(verb) || !(verb == "ListIdentifiers" || verb == "ListRecords"))
{
errors.Add(MlErrors.badVerbArgument);
}
else
{
isRecord = verb == "ListRecords";
}
/* FROM */
bool isFrom = !String.IsNullOrEmpty(from);
fromDate = MlDecode.SafeDateTime(from);
if (isFrom && fromDate == null)
{
errors.Add(MlErrors.badFromArgument);
}
/* UNTIL */
bool isUntil = !String.IsNullOrEmpty(until);
untilDate = MlDecode.SafeDateTime(until);
if (isUntil && untilDate == null)
{
errors.Add(MlErrors.badUntilArgument);
}
if (isFrom && isUntil && fromDate > untilDate)
{
errors.Add(MlErrors.badFromAndUntilArgument);
}
// if both dates exist, they should be in the same format
if (!string.IsNullOrEmpty(from) && !string.IsNullOrEmpty(until))
{
if (from.Count() != until.Count())
{
errors.Add(MlErrors.badFromAndUntilFormatArgument);
}
}
if (fromDate == null)
{
fromDate = new DateTime(1900, 1, 1);
}
if (until == null)
{
untilDate = DateTime.Now;
}
if (untilDate != null)
{
untilDate = ((DateTime)untilDate).AddMilliseconds(999);
}
/* METADATA PREFIX */
bool isPrefixOk = !String.IsNullOrEmpty(metadataPrefix);
/* SETS */
bool isSet = !String.IsNullOrEmpty(set);
if (isSet && !Properties.supportSets)
{
errors.Add(MlErrors.noSetHierarchy);
}
/* RESUMPTION TOKEN */
bool isResumption = !String.IsNullOrEmpty(resumptionToken);
if (isResumption && !isRoundtrip)
{
if (isFrom || isUntil || isPrefixOk || isSet)
{
errors.Add(MlErrors.badResumptionArgumentOnly);
}
if (!(Properties.resumptionTokens.ContainsKey(resumptionToken) &&
Properties.resumptionTokens[resumptionToken].Verb == verb &&
Properties.resumptionTokens[resumptionToken].ExpirationDate >= DateTime.UtcNow))
{
errors.Insert(0, MlErrors.badResumptionArgument);
}
if (errors.Count == 0)
{
return(ListIdentifiersOrRecords(
verb,
Properties.resumptionTokens[resumptionToken].From.HasValue ?
Properties.resumptionTokens[resumptionToken].From.Value.ToUniversalTime().ToString(Properties.granularity) : null,
Properties.resumptionTokens[resumptionToken].Until.HasValue ?
Properties.resumptionTokens[resumptionToken].Until.Value.ToUniversalTime().ToString(Properties.granularity) : null,
Properties.resumptionTokens[resumptionToken].MetadataPrefix,
Properties.resumptionTokens[resumptionToken].Set,
resumptionToken,
true,
errors,
loadAbout));
}
}
if (!isPrefixOk) /* Check if the only required attribute is included in the request */
{
errors.Add(MlErrors.badMetadataArgument);
}
else if (FormatList.Prefix2Int(metadataPrefix) == 0)
{
errors.Add(MlErrors.cannotDisseminateFormat);
}
bool isAbout = loadAbout.HasValue ? loadAbout.Value : Properties.loadAbout;
XElement request = new XElement("request",
new XAttribute("verb", verb),
isFrom ? new XAttribute("from", from) : null,
isUntil ? new XAttribute("until", until) : null,
isPrefixOk ? new XAttribute("metadataPrefix", metadataPrefix) : null,
isSet ? new XAttribute("set", set) : null,
isResumption ? new XAttribute("resumptionToken", resumptionToken) : null,
Properties.baseURL);
if (errors.Count > 0)
{
errors.Insert(0, request); /* add request on the first position, that it will be diplayed before errors */
return(CreateXml(errors.ToArray()));
}
var records = new List <RecordQueryResult>();
List <string> sets = Common.Helper.GetAllSets(set);
var formatNum = FormatList.Prefix2Int(metadataPrefix);
EntityManager entityManager = new EntityManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
DatasetManager datasetManager = new DatasetManager();
OAIHelper oaiHelper = new OAIHelper();
try
{
//1. Get list of all datasetids which shoudl be harvested -
// ToDo use also the existing parameters like from date
long?entityTypeId = entityManager.FindByName(typeof(Dataset).Name)?.Id;
entityTypeId = entityTypeId.HasValue ? entityTypeId.Value : -1;
// get all datasetids with the last modify date
List <long> dsvIds = datasetManager.GetDatasetVersionLatestIds();
// ToDo to get all datasets with the last modfied date, the datasetversionrepo of the dataset manager is used, but its many wrong because of session problem in the past
List <long> datasetIds = datasetManager.GetDatasetLatestIds();
datasetIds = datasetManager.DatasetVersionRepo.Query(dsv =>
dsvIds.Contains(dsv.Id) &&
dsv.Timestamp >= fromDate &&
dsv.Timestamp <= untilDate
).Select(dsv => dsv.Dataset.Id).ToList();
//2. Generate a list of headers
var recordsQuery = new List <Header>();
foreach (long id in datasetIds)
{
if (entityPermissionManager.Exists(null, entityTypeId.Value, id))
{
recordsQuery.Add(oaiHelper.GetHeader(id));
}
}
if (isSet)
{
recordsQuery = recordsQuery.Where(h => h.OAI_Set.Equals(AppConfiguration.ApplicationName)).ToList();
}
int recordsCount = recordsQuery.Count();
if (recordsCount == 0)
{
return(CreateXml(new XElement[] { request, MlErrors.noRecordsMatch }));
}
else if (isRoundtrip)
{
Properties.resumptionTokens[resumptionToken].CompleteListSize = recordsCount;
recordsQuery = recordsQuery.AsEnumerable().Skip(
Properties.resumptionTokens[resumptionToken].Cursor.Value).Take(
isRecord ? Properties.maxRecordsInList : Properties.maxIdentifiersInList).ToList();
}
else if ((isRecord ? Properties.resumeListRecords : Properties.resumeListIdentifiers) &&
(isRecord ? recordsCount > Properties.maxRecordsInList
: recordsCount > Properties.maxIdentifiersInList))
{
resumptionToken = Common.Helper.CreateGuid();
isResumption = true;
Properties.resumptionTokens.Add(resumptionToken,
new ResumptionToken()
{
Verb = verb,
From = isFrom ? fromDate : null,
Until = isUntil ? untilDate : null,
MetadataPrefix = metadataPrefix,
Set = set,
ExpirationDate = DateTime.UtcNow.Add(Properties.expirationTimeSpan),
CompleteListSize = recordsCount,
Cursor = 0
});
recordsQuery = recordsQuery.AsEnumerable().Take(
isRecord ? Properties.maxRecordsInList : Properties.maxIdentifiersInList).ToList();
}
/* get data from database */
//var recGroup = (from rec in recordsQuery
// join omd in context.ObjectMetadata on rec.HeaderId equals omd.ObjectId
// join mdt in context.Metadata on omd.MetadataId equals mdt.MetadataId
// group new { OmdMetaType = omd.MetadataType, OaiMetaData = mdt } by rec into grp
// select grp).ToList();
/* distribute data into logical units */
foreach (var header in recordsQuery)
{
long id = oaiHelper.ConvertToId(header.OAI_Identifier);
//ToDo add about to the RecordQueryResult object, currently its only null
records.Add(new RecordQueryResult(header, oaiHelper.GetMetadata(id, metadataPrefix), null));
}
}
finally
{
datasetManager.Dispose();
entityPermissionManager.Dispose();
}
bool isCompleted = isResumption ?
Properties.resumptionTokens[resumptionToken].Cursor + records.Count >=
Properties.resumptionTokens[resumptionToken].CompleteListSize :
false;
XElement list = new XElement(verb,
isRecord ?
GetListRecords(records, isAbout) :
GetListIdentifiers(records),
isResumption ? /* add resumption token or not */
MlEncode.ResumptionToken(Properties.resumptionTokens[resumptionToken], resumptionToken, isCompleted)
: null);
if (isResumption)
{
if (isCompleted)
{
Properties.resumptionTokens.Remove(resumptionToken);
}
else
{
Properties.resumptionTokens[resumptionToken].Cursor =
Properties.resumptionTokens[resumptionToken].Cursor + records.Count;
}
}
return(CreateXml(new XElement[] { request, list }));
}
public static XDocument GetRecord(string identifier, string metadataPrefix, List <XElement> errorList, bool?loadAbout, Tenant tenant = null)
{
List <XElement> errors = errorList;
bool isIdentifier = !String.IsNullOrEmpty(identifier);
if (!isIdentifier)
{
errors.Add(MlErrors.badIdentifierArgument);
}
bool isPrefixOk = !String.IsNullOrEmpty(metadataPrefix);
if (!isPrefixOk)
{
errors.Add(MlErrors.badMetadataArgument);
}
else if (FormatList.Prefix2Int(metadataPrefix) == 0)
{
errors.Add(MlErrors.cannotDisseminateFormat);
isPrefixOk = false;
}
bool isAbout = loadAbout.HasValue ? loadAbout.Value : Properties.loadAbout;
RecordQueryResult record = null;
if (isIdentifier && isPrefixOk)
{
OAIHelper helper = new OAIHelper();
long datasetId = helper.ConvertToId(identifier);
Header header = helper.GetHeader(datasetId);
if (header == null)
{
errors.Add(MlErrors.idDoesNotExist);
}
else
{
record = new RecordQueryResult(header, helper.GetMetadata(datasetId, metadataPrefix));
// ToDo Check About in the documentaion of oai-pmh
record.About = null;
if (record == null || record.Metadata == null)
{
errors.Add(MlErrors.cannotDisseminateRecordFormat);
}
}
}
XElement request = new XElement("request",
new XAttribute("verb", "GetRecord"),
isIdentifier ? new XAttribute("identifier", identifier) : null,
isPrefixOk ? new XAttribute("metadataPrefix", metadataPrefix) : null,
Properties.baseURL);
if (errors.Count > 0)
{
errors.Insert(0, request); /* add request on the first position, that it will be diplayed before errors */
return(CreateXml(errors.ToArray()));
}
XElement theRecord = new XElement("GetRecord",
new XElement("record",
MlEncode.HeaderItem(record.Header, Properties.granularity),
MlEncode.Metadata(record.Metadata, Properties.granularity)),
isAbout ? MlEncode.About(record.About, Properties.granularity) : null);
return(CreateXml(new XElement[] { request, theRecord }));
}
public static XElement Encode(Metadata panSimple, string granularity)
{
// The DatetimeFormat for OAI-PMH is only valid when it is like this YYYY.MM.DD
// but c# ist not understanding YYYY ->it must replaced with yyyy & DD -> dd
granularity = granularity.Replace('Y', 'y');
granularity = granularity.Replace('D', 'd');
XElement Element = new XElement(MlNamespaces.psNs + "dataset",
/*Namespaces*/
new XAttribute(XNamespace.Xmlns + "dc", MlNamespaces.dcNs),
new XAttribute(XNamespace.Xmlns + "xsi", MlNamespaces.psXsi),
/* content */
/*Subject*/
MlEncode.Element(MlNamespaces.dcNs + "title", panSimple.Title),
MlEncode.Element(MlNamespaces.dcNs + "creator", panSimple.Creator),
MlEncode.Element(MlNamespaces.dcNs + "subject", panSimple.Subject),
!panSimple.Date.HasValue ? null
: new XElement(MlNamespaces.dcNs + "date",
panSimple.Date.Value.ToUniversalTime().ToString(granularity)),
MlEncode.Element(MlNamespaces.dcNs + "type", panSimple.Type),
MlEncode.Element(MlNamespaces.dcNs + "format", panSimple.Format),
MlEncode.Element(MlNamespaces.dcNs + "identifier", panSimple.Identifier),
MlEncode.Element(MlNamespaces.dcNs + "source", panSimple.Source),
MlEncode.Element(MlNamespaces.dcNs + "language", panSimple.Language),
MlEncode.Element(MlNamespaces.dcNs + "coverage", panSimple.Coverage),
MlEncode.Element(MlNamespaces.dcNs + "rights", panSimple.Rights),
/*PanSimple Extentions*/
MlEncode.Element(MlNamespaces.psNs + "keyword", panSimple.Keyword),
MlEncode.Element(MlNamespaces.psNs + "parameter", panSimple.Parameter),
MlEncode.Element(MlNamespaces.psNs + "method", panSimple.Method),
MlEncode.Element(MlNamespaces.psNs + "sensor", panSimple.Sensor),
MlEncode.Element(MlNamespaces.psNs + "feature", panSimple.Feature),
MlEncode.Element(MlNamespaces.psNs + "taxonomy", panSimple.Taxonomy),
MlEncode.Element(MlNamespaces.psNs + "platform", panSimple.Platform),
MlEncode.Element(MlNamespaces.psNs + "project", panSimple.Project),
MlEncode.Element(MlNamespaces.psNs + "habitat", panSimple.Habitat),
MlEncode.Element(MlNamespaces.psNs + "stratigraphy", panSimple.Stratigraphy),
MlEncode.Element(MlNamespaces.psNs + "pangaea-tech-keyword", panSimple.PangaeaTechKeyword),
/*Links*/
new XElement(MlNamespaces.psNs + "linkage",
new XAttribute("type", "metadata"),
new XAttribute("accessRestricted", "false"),
panSimple.AddtionalData[Metadata.METADATA_URL].ToString()),
new XElement(MlNamespaces.psNs + "linkage",
new XAttribute("type", "data"),
new XAttribute("accessRestricted", "false"),
panSimple.AddtionalData[Metadata.DATA_URL].ToString()),
/*relinks*/
MlEncode.Element(MlNamespaces.psNs + "parentIdentifer", panSimple.Relation),
MlEncode.Element(MlNamespaces.psNs + "additionalContent", panSimple.Description),
MlEncode.Element(MlNamespaces.psNs + "dataCenter", panSimple.Publisher),
MlEncode.Element(MlNamespaces.psNs + "pricipalInvestigator", panSimple.Contributor),
/*Converage*/
new XElement(MlNamespaces.psNs + "coverage",
MlEncode.Element(MlNamespaces.psNs + "northBoundLatitude",
panSimple.CoverageComplex.NorthBoundLatitude == 0 ? null : panSimple.CoverageComplex.NorthBoundLatitude.ToString()),
MlEncode.Element(MlNamespaces.psNs + "westBoundLongitude",
panSimple.CoverageComplex.WestBoundLongitude == 0 ? null : panSimple.CoverageComplex.WestBoundLongitude.ToString()),
MlEncode.Element(MlNamespaces.psNs + "southhBoundLatitude",
panSimple.CoverageComplex.SouthBoundLatitude == 0 ? null : panSimple.CoverageComplex.SouthBoundLatitude.ToString()),
MlEncode.Element(MlNamespaces.psNs + "eastBoundLongitude",
panSimple.CoverageComplex.EastBoundLongitude == 0 ? null : panSimple.CoverageComplex.EastBoundLongitude.ToString()),
MlEncode.Element(MlNamespaces.psNs + "location", panSimple.CoverageComplex.Location),
MlEncode.Element(MlNamespaces.psNs + "minEvelation", panSimple.CoverageComplex.MinElevation),
MlEncode.Element(MlNamespaces.psNs + "maxEvelation", panSimple.CoverageComplex.MaxElevation),
MlEncode.Element(MlNamespaces.psNs + "StartDate", panSimple.CoverageComplex.StartDate),
MlEncode.Element(MlNamespaces.psNs + "EndData", panSimple.CoverageComplex.EndDate))
);
XAttribute attr = new XAttribute(XNamespace.Xmlns + "ps", MlNamespaces.psNs);
Element.Add(attr);
return(Element);
}
