public static IEnumerable <Metadata> MetaList(IList <XElement> metaList)
{
if (metaList == null || metaList.Count == 0)
{
yield break;
}
foreach (var item in metaList)
{
switch (item.Name.LocalName)
{
case "oai_dc":
yield return(DublinCore.Decode(item));
break;
case "provenance":
yield return(Provenance.Decode(item));
break;
case "pan_simple":
yield return(PanSimple.Decode(item));
break;
// TODO: Add format here
default:
break;
}
}
}
public static IEnumerable <XElement> MetaList(string containerName, IList <Metadata> metaList, string granularity)
{
if (string.IsNullOrEmpty(containerName) || metaList == null || metaList.Count == 0 || string.IsNullOrEmpty(granularity))
{
yield break;
}
foreach (var metaItem in metaList)
{
switch (FormatList.Int2Format(metaItem.MdFormat))
{
case Enums.MetadataFormats.DublinCore:
yield return(new XElement(containerName, DublinCore.Encode(metaItem, granularity)));
break;
case Enums.MetadataFormats.PanSimple:
yield return(new XElement(containerName, PanSimple.Encode(metaItem, granularity)));
break;
case Enums.MetadataFormats.Provenance:
yield return(new XElement(containerName, Provenance.Encode(metaItem, granularity)));
break;
// TODO: Add format here
case Enums.MetadataFormats.None:
default:
break;
}
}
}
public static XElement Metadata(string containerName, Metadata metadata, string granularity)
{
if (string.IsNullOrEmpty(containerName) || metadata == null || string.IsNullOrEmpty(granularity))
{
return(null);
}
switch (FormatList.Int2Format(metadata.MdFormat))
{
case Enums.MetadataFormats.DublinCore:
return(new XElement(containerName, DublinCore.Encode(metadata, granularity)));
case Enums.MetadataFormats.PanSimple:
return(new XElement(containerName, PanSimple.Encode(metadata, granularity)));
case Enums.MetadataFormats.Provenance:
return(new XElement(containerName, Provenance.Encode(metadata, granularity)));
// TODO: Add format here
case Enums.MetadataFormats.None:
default:
return(null);
}
}
public byte[] CreateReport(DublinCore citation, List <RepositoryItemMetadata> items, RepositoryClientBase client)
{
// Get identification for all the DDI variables in the item list.
var variableIDs = items
.Where(x => x.ItemType == DdiItemType.Variable)
.Select(x => x.CompositeId)
.ToIdentifierCollection();
// Fetch all the variables.
var allVariables = client.GetItems(variableIDs)
.OfType <Variable>();
// Use the Colectica.Reporting MigraDoc helper to create a PDF that
// simply lists all variables with their names, labels, and types.
var document = new Document();
document.Info.Title = "Sample Variable Summary";
// Add a title.
var section = document.AddSection();
var paragraph = section.AddParagraph(citation.Title.Best);
paragraph.Format.Font.Bold = true;
// Create the report helper.
ReportContext context = new ReportContext();
var builder = new ItemBuilderBase(document, context);
// Make a list with one item for each variable.
builder.DefineList();
foreach (var variable in allVariables)
{
string lineText = $"{variable.ItemName.Best} - {variable.Label.Best} - {variable.RepresentationType}";
builder.AddListItem(lineText);
}
// Render the PDF and return it.
var pdfRenderer = new PdfDocumentRenderer(true);
pdfRenderer.Document = document;
pdfRenderer.RenderDocument();
using (var stream = new MemoryStream())
{
pdfRenderer.Save(stream, true);
var fileContents = stream.ToArray();
return(fileContents);
}
}
public static Metadata Metadata(XElement metadata, string format)
{
if (metadata == null || string.IsNullOrEmpty(format))
{
return(null);
}
switch (format)
{
case "oai_dc":
return(DublinCore.Decode(metadata));
case "provenance":
return(Provenance.Decode(metadata));
case "pan_simple":
return(PanSimple.Decode(metadata));
// TODO: Add format here
default: return(null);
}
}
public static MetaDataItem[] GetXmpData(string filename)
{
if (PageUtils.IsRunningOnMono())
{
return(new MetaDataItem[0]);
}
List <MetaDataItem> ret = new List <MetaDataItem>();
try
{
Xmp xmp = Xmp.FromFile(filename, XmpFileMode.ReadOnly);
DublinCore dc = new DublinCore(xmp);
if (dc.Contributor.Count > 0)
{
foreach (string con in dc.Contributor)
{
ret.Add(new MetaDataItem("Xmp:Contributor", cleanXmpString(con)));
} // foreach
}
if (dc.Coverage != null)
{
ret.Add(new MetaDataItem("Xmp:Coverage", cleanXmpString(dc.Coverage)));
}
if (dc.Creator.Count > 0)
{
foreach (string s in dc.Creator)
{
ret.Add(new MetaDataItem("Xmp:Creator", cleanXmpString(s)));
}
}
if (dc.Date.Count > 0)
{
foreach (DateTime dt in dc.Date)
{
ret.Add(new MetaDataItem("Xmp:Date", (dt)));
}
}
if (dc.Description != null && dc.Description.DefaultValue != null)
{
ret.Add(new MetaDataItem("Xmp:Description", cleanXmpString(dc.Description.DefaultValue)));
}
if (dc.Format != null)
{
ret.Add(new MetaDataItem("Xmp:Format", cleanXmpString(dc.Format)));
}
if (dc.Language.Count > 0)
{
foreach (string lang in dc.Language)
{
ret.Add(new MetaDataItem("Xmp:Language", cleanXmpString(lang)));
}
}
if (dc.Publisher.Count > 0)
{
foreach (string pub in dc.Publisher)
{
ret.Add(new MetaDataItem("Xmp:Publisher", cleanXmpString(pub)));
}
}
if (dc.Relation.Count > 0)
{
foreach (string rel in dc.Relation)
{
ret.Add(new MetaDataItem("Xmp:Relation", cleanXmpString(rel)));
}
}
if (dc.Rights != null && dc.Rights.DefaultValue != null)
{
ret.Add(new MetaDataItem("Xmp:Rights", (dc.Rights.DefaultValue)));
}
if (dc.Source != null)
{
ret.Add(new MetaDataItem("Xmp:Source", cleanXmpString(dc.Source)));
}
if (dc.Subject.Count > 0)
{
foreach (string sub in dc.Subject)
{
ret.Add(new MetaDataItem("Xmp:Subject", cleanXmpString(sub)));
}
}
if (dc.Title != null && dc.Title.DefaultValue != null)
{
ret.Add(new MetaDataItem("Xmp:Title", (dc.Title.DefaultValue)));
}
if (dc.Type != null)
{
ret.Add(new MetaDataItem("Xmp:Type", cleanXmpString(dc.Type)));
}
}
catch (DllNotFoundException dllEx)
{
throw dllEx;
}
catch (Exception ex)
{
Console.Write(ex.Message);
}
return(ret.ToArray());
}
public bool CanCreateReport(DublinCore citation, List <RepositoryItemMetadata> items) => items.Any(x => x.ItemType == DdiItemType.Variable);
