private static string GetJson(string structRootPath)
{
Impersonator imp = null;
if (StorageUtility.NeedImpersonation(structRootPath))
{
imp = StorageUtility.GetImpersonator();
}
try
{
var structXml = Path.Combine(structRootPath, @"Metadata\Structure.xml");
var structure = MetadataStructure.GetFromFile(structXml);
//var dir = Path.GetDirectoryName(structXml);
//var jsonFile = Path.Combine(dir, "metadataAlias.json");
//structure.ToFile(jsonFile, false, true);
var jsonFile = JsonConvert.SerializeObject(structure.GetAliases(), Formatting.None);
return(jsonFile);
}
finally
{
if (imp != null)
{
imp.Dispose();
}
}
}
/// <summary>
/// Information in metadata is stored as xml
/// get back the vale of an attribute
/// e.g. title = "dataset title"
/// /// </summary>
/// <param name="datasetVersion"></param>
/// <param name="name"></param>
/// <returns></returns>
public string GetInformationFromVersion(long datasetVersionId, long metadataStructureId, NameAttributeValues name)
{
using (var unitOfWork = this.GetUnitOfWork())
using (DatasetManager dm = new DatasetManager())
using (MetadataStructureManager msm = new MetadataStructureManager())
{
if (datasetVersionId <= 0)
{
return(String.Empty);
}
if (metadataStructureId <= 0)
{
return(String.Empty);
}
MetadataStructure metadataStructure = msm.Repo.Get(metadataStructureId);
if ((XmlDocument)metadataStructure.Extra == null)
{
return(string.Empty);
}
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
XElement temp = XmlUtility.GetXElementByAttribute(nodeNames.nodeRef.ToString(), "name", name.ToString(),
xDoc);
string xpath = temp.Attribute("value").Value.ToString();
return(dm.GetMetadataValueFromDatasetVersion(datasetVersionId, xpath));
}
}
public static string GetMappingFileName(long id, TransmissionType transmissionType, string name)
{
using (MetadataStructureManager msm = new MetadataStructureManager())
{
MetadataStructure metadataStructure = msm.Repo.Get(id);
// get MetadataStructure
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
List <XElement> tmpList =
XmlUtility.GetXElementsByAttribute(nodeNames.convertRef.ToString(), new Dictionary <string, string>()
{
{ AttributeNames.name.ToString(), name },
{ AttributeNames.type.ToString(), transmissionType.ToString() }
}, xDoc).ToList();
if (tmpList.Count >= 1)
{
return(tmpList.FirstOrDefault().Attribute("value").Value.ToString());
}
return(null);
}
}
public string GetTransmissionInformation(long datasetVersionId, TransmissionType type, string name,
AttributeNames returnType = AttributeNames.value)
{
DatasetVersion datasetVersion = this.GetUnitOfWork().GetReadOnlyRepository <DatasetVersion>().Get(datasetVersionId);
Dataset dataset = this.GetUnitOfWork().GetReadOnlyRepository <Dataset>().Get(datasetVersion.Dataset.Id);
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(dataset.MetadataStructure.Id);
// get MetadataStructure
if (datasetVersion != null && dataset != null &&
metadataStructure != null && datasetVersion.Metadata != null && metadataStructure.Extra != null)
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)datasetVersion.Dataset.MetadataStructure.Extra);
Dictionary <string, string> queryDic = new Dictionary <string, string>();
queryDic.Add(AttributeNames.name.ToString(), name);
queryDic.Add(AttributeNames.type.ToString(), type.ToString());
IEnumerable <XElement> temp = XmlUtility.GetXElementsByAttribute(nodeNames.convertRef.ToString(), queryDic, xDoc);
string value = temp?.First().Attribute(returnType.ToString()).Value;
return(value);
}
return(string.Empty);
}
public static GFBIOPangaeaFormularObject GetGFBIOPangaeaFormularObject(long datasetId)
{
DatasetManager datasetManager = new DatasetManager();
try
{
Dataset dataset = datasetManager.GetDataset(datasetId);
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(dataset.MetadataStructure.Id);
GFBIOPangaeaFormularObject gfbioPangaeaFormularObject = new GFBIOPangaeaFormularObject();
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
string title = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.title);
string description = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.description);
return(gfbioPangaeaFormularObject);
}
finally
{
datasetManager.Dispose();
}
}
/// <summary>
/// returns a List of all transmission nodes in the metadataStructure
/// </summary>
/// <param name="metadatastrutcureId"></param>
/// <param name="name"></param>
/// <returns></returns>
public IEnumerable <string> GetAllTransmissionInformationFromMetadataStructure(long metadataStructureId, TransmissionType type,
AttributeNames returnType = AttributeNames.value)
{
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(metadataStructureId);
List <string> tmpList = new List <string>();
try
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
IEnumerable <XElement> temp = XmlUtility.GetXElementsByAttribute(nodeNames.convertRef.ToString(), AttributeNames.type.ToString(),
type.ToString(), xDoc);
foreach (var element in temp)
{
tmpList.Add(element.Attribute(returnType.ToString()).Value);
}
}
catch (Exception)
{
return(new List <string>());
}
return(tmpList);
}
private bool HasEntityTypeName(MetadataStructure metadataStructure, string entityName)
{
// get MetadataStructure
if (metadataStructure != null && metadataStructure.Extra != null)
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
IEnumerable <XElement> tmp = XmlUtility.GetXElementByNodeName(nodeNames.entity.ToString(), xDoc);
if (tmp.Any())
{
foreach (var entity in tmp)
{
string tmpEntityClassPath = "";
if (entity.HasAttributes && entity.Attribute("name") != null)
{
tmpEntityClassPath = entity.Attribute("name").Value.ToLower();
}
if (tmpEntityClassPath.Equals(entityName.ToLower()))
{
return(true);
}
}
}
}
return(false);
}
public bool IsActive(long metadataStructureId)
{
// get MetadataStructure
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(metadataStructureId);
if (metadataStructure.Extra != null)
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
XElement tmp = XmlUtility.GetXElementsByAttribute(nodeNames.parameter.ToString(), AttributeNames.name.ToString(),
NameAttributeValues.active.ToString(), xDoc).FirstOrDefault();
if (tmp != null)
{
try
{
return(Convert.ToBoolean(tmp.Attribute(AttributeNames.value.ToString()).Value));
}
catch (Exception)
{
return(false);
}
}
}
return(false);
}
public bool HasTransmission(long datasetid, TransmissionType type)
{
Dataset dataset = this.GetUnitOfWork().GetReadOnlyRepository <Dataset>().Get(datasetid);
DatasetManager dm = new DatasetManager();
try
{
DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(dataset);
// get MetadataStructure
if (datasetVersion != null && datasetVersion.Dataset != null &&
datasetVersion.Dataset.MetadataStructure != null &&
datasetVersion.Dataset.MetadataStructure.Extra != null &&
datasetVersion.Metadata != null)
{
MetadataStructure metadataStructure = datasetVersion.Dataset.MetadataStructure;
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)datasetVersion.Dataset.MetadataStructure.Extra);
IEnumerable <XElement> temp = XmlUtility.GetXElementsByAttribute(nodeNames.convertRef.ToString(), AttributeNames.type.ToString(),
type.ToString(), xDoc);
if (temp != null && temp.Any())
{
return(true);
}
}
return(false);
}
finally
{
dm.Dispose();
}
}
/// <summary>
/// Information in metadata is stored as xml
/// get back the vale of an attribute
/// e.g. title = "dataset title"
/// /// </summary>
/// <param name="datasetVersion"></param>
/// <param name="name"></param>
/// <returns></returns>
public string GetInformationFromVersion(long datasetVersionId, NameAttributeValues name)
{
using (var unitOfWork = this.GetUnitOfWork())
{
DatasetVersion datasetVersion = unitOfWork.GetReadOnlyRepository <DatasetVersion>().Get(datasetVersionId);
// get MetadataStructure
if (datasetVersion != null && datasetVersion.Dataset != null &&
datasetVersion.Dataset.MetadataStructure != null && datasetVersion.Metadata != null)
{
MetadataStructure metadataStructure = datasetVersion.Dataset.MetadataStructure;
if ((XmlDocument)metadataStructure.Extra != null)
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
XElement temp = XmlUtility.GetXElementByAttribute(nodeNames.nodeRef.ToString(), "name", name.ToString(),
xDoc);
string xpath = temp.Attribute("value").Value.ToString();
XmlNode node = datasetVersion.Metadata.SelectSingleNode(xpath);
string title = "";
if (node != null)
{
title = datasetVersion.Metadata.SelectSingleNode(xpath).InnerText;
}
return(title);
}
}
return(string.Empty);
}
}
public ActionResult DownloadSchema(long id)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
try
{
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(id);
string name = metadataStructure.Name;
string path = OutputMetadataManager.GetSchemaDirectoryPathFromMetadataStructure(id, metadataStructureManager);
ZipFile zip = new ZipFile();
if (Directory.Exists(path))
{
zip.AddDirectory(path);
}
MemoryStream stream = new MemoryStream();
zip.Save(stream);
stream.Position = 0;
var result = new FileStreamResult(stream, "application/zip")
{
FileDownloadName = name + ".zip"
};
return(result);
}
finally
{
metadataStructureManager.Dispose();
}
}
public bool HasEntity(long metadataStructureId, string name)
{
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(metadataStructureId);
// get MetadataStructure
if (metadataStructure != null && metadataStructure.Extra != null)
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
IEnumerable <XElement> tmp = XmlUtility.GetXElementByNodeName(nodeNames.entity.ToString(), xDoc);
if (tmp.Any())
{
foreach (var entity in tmp)
{
string tmpname = "";
if (entity.HasAttributes && entity.Attribute("name") != null)
{
tmpname = entity.Attribute("name").Value.ToLower();
}
if (tmpname.Equals(name.ToLower()))
{
return(true);
}
}
}
}
return(false);
}
public ActionResult Save(MetadataStructureModel metadataStructureModel)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
try
{
if (ModelState.IsValid)
{
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(metadataStructureModel.Id);
metadataStructure = updateMetadataStructure(metadataStructure, metadataStructureModel);
metadataStructureManager.Update(metadataStructure);
return(Json(true));
}
return(Json(false));
}
catch (Exception ex)
{
return(Json(ex.Message));
}
finally
{
metadataStructureManager.Dispose();
}
}
public ActionResult Delete(long id)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
try
{
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(id);
// delete local files
if (XmlSchemaManager.Delete(metadataStructure))
{
metadataStructureManager.Delete(metadataStructure);
}
if (metadataStructureManager.Repo.Get(id) == null)
{
return(Json(true));
}
return(Json(false));
}
catch (Exception ex)
{
return(Json(ex.Message));
}
finally
{
metadataStructureManager.Dispose();
}
}
public static string GetSchemaDirectoryPath(long datasetId)
{
using (DatasetManager datasetManager = new DatasetManager())
using (MetadataStructureManager metadataStructureManager = new MetadataStructureManager())
{
try
{
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(datasetVersion.Dataset.MetadataStructure.Id);
string path = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DCM"), "Metadata",
metadataStructure.Name);
if (!String.IsNullOrEmpty(path) && Directory.Exists(path))
{
return(path);
}
}
catch (Exception ex)
{
throw ex;
}
}
return(String.Empty);
}
/// <summary>
/// Return a value of the attribute from the incoming metadata
/// </summary>
/// <param name="datasetid"></param>
/// <param name="metadata"></param>
/// <param name="name"></param>
/// <returns></returns>
public string GetInformation(long datasetid, XmlDocument metadata, NameAttributeValues name)
{
using (var unitOfWork = this.GetUnitOfWork())
using (DatasetManager dm = new DatasetManager())
using (MetadataStructureManager msm = new MetadataStructureManager())
{
if (datasetid <= 0)
{
return(String.Empty);
}
var dataset = dm.GetDataset(datasetid);
MetadataStructure metadataStructure = msm.Repo.Get(dataset.MetadataStructure.Id);
if ((XmlDocument)metadataStructure.Extra == null)
{
return(string.Empty);
}
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
XElement temp = XmlUtility.GetXElementByAttribute(nodeNames.nodeRef.ToString(), "name", name.ToString(),
xDoc);
string xpath = temp.Attribute("value").Value.ToString();
string value = metadata.SelectSingleNode(xpath).InnerText;
return(string.IsNullOrWhiteSpace(value) ? "not available" : value);
}
}
public ActionResult LoadMetadataStructureTab(long Id)
{
#region load Model
DatasetManager datasetManager = new DatasetManager();
try
{
// retrieves all the dataset version IDs which are in the checked-in state
datasetVersionIds = datasetManager.GetDatasetVersionLatestIds();
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(Id);
MetadataStructureModel model = new MetadataStructureModel(
metadataStructure.Id,
metadataStructure.Name,
metadataStructure.Description,
getDatasetVersionsDic(metadataStructure, datasetVersionIds),
IsExportAvailable(metadataStructure)
);
#endregion
return(PartialView("_metadataStructureView", model));
}
finally
{
datasetManager.Dispose();
}
}
public ActionResult Save(MetadataStructureModel metadataStructureModel)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
DatasetManager datasetManager = new DatasetManager();
try
{
if (ModelState.IsValid)
{
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(metadataStructureModel.Id);
metadataStructure = updateMetadataStructure(metadataStructure, metadataStructureModel);
metadataStructureManager.Update(metadataStructure);
//update dsv title and description if there is a change
//ToDo check if there is a change in the xpaths
// update datasetversion
// get all datasetIds which using the metadata structure
var datasetIds = datasetManager.DatasetRepo.Query().Where(d => d.MetadataStructure.Id.Equals(metadataStructure.Id)).Select(d => d.Id);
if (datasetIds.Any())
{
//get all datasetversions of the dataset ids
var datasetVersionIds = datasetManager.DatasetVersionRepo.Query().Where(dsv => datasetIds.Contains(dsv.Dataset.Id)).Select(dsv => dsv.Id).ToList();
//load all titles & descriptions from versions
var allTitles = xmlDatasetHelper.GetInformationFromVersions(datasetVersionIds, metadataStructure.Id, NameAttributeValues.title);
var allDescriptions = xmlDatasetHelper.GetInformationFromVersions(datasetVersionIds, metadataStructure.Id, NameAttributeValues.description);
// update each datasetversion
foreach (var datasetVersionId in datasetVersionIds)
{
// load dataset version
var datasetVersion = datasetManager.GetDatasetVersion(datasetVersionId);
datasetVersion.Title = allTitles.ContainsKey(datasetVersion.Id) ? allTitles[datasetVersion.Id] : string.Empty;
datasetVersion.Description = allDescriptions.ContainsKey(datasetVersion.Id) ? allDescriptions[datasetVersion.Id] : string.Empty;
datasetManager.UpdateDatasetVersion(datasetVersion);
}
}
return(Json(true));
}
return(Json(false));
}
catch (Exception ex)
{
return(Json(ex.Message));
}
finally
{
metadataStructureManager.Dispose();
datasetManager.Dispose();
}
}
public static string CreateConvertedMetadata(long datasetId, TransmissionType type)
{
XmlDocument newXml;
DatasetManager datasetManager = new DatasetManager();
MetadataStructureManager metadataMetadataStructureManager = new MetadataStructureManager();
try
{
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
MetadataStructure metadataStructure = metadataMetadataStructureManager.Repo.Get(datasetVersion.Dataset.MetadataStructure.Id);
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
int versionNr = datasetManager.GetDatasetVersionNr(datasetVersion);
string mappingName = metadataStructure.Name;
string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName);
//if mapping file not exist
if (string.IsNullOrEmpty(mappingFileName))
{
return("");
}
string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName);
XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
xmlMapperManager.Load(pathMappingFile, "exporttest");
newXml = xmlMapperManager.Export(datasetVersion.Metadata, datasetVersion.Id, mappingName, true);
string title = datasetVersion.Title;
// store in content descriptor
string filename = "metadata";
if (String.IsNullOrEmpty(mappingName) || mappingName.ToLower() == "generic")
{
storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, filename, ".xml");
}
else
{
filename = "metadata_" + mappingName;
storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, filename,
".xml");
}
return(OutputDatasetManager.GetDynamicDatasetStorePath(datasetId, versionNr, filename, ".xml"));
}
catch (Exception ex)
{
throw ex;
}
finally
{
datasetManager.Dispose();
metadataMetadataStructureManager.Dispose();
}
}
private bool IsExportAvailable(MetadataStructure metadataStructure)
{
bool hasMappingFile = false;
XmlDocument doc = new XmlDocument();
doc.LoadXml(metadataStructure.Extra.OuterXml);
if (XmlUtility.GetXElementByNodeName("convertRef", XmlUtility.ToXDocument(doc)).Count() > 0)
{
hasMappingFile = true;
}
return(hasMappingFile);
}
/// <summary>
/// Sets the value of the node of the XmlDocument xmlDoc specified by the parameter "name" to the given value
/// </summary>
/// <param name="datasetVersion"></param>
/// <param name="xmlDoc"></param>
/// <param name="name"></param>
/// <param name="value"></param>
/// <returns></returns>
public XmlDocument SetInformation(DatasetVersion datasetVersion, XmlDocument xmlDoc, NameAttributeValues name, string value)
{
// get MetadataStructure
if (datasetVersion != null && datasetVersion.Dataset != null && datasetVersion.Dataset.MetadataStructure != null && datasetVersion.Metadata != null)
{
MetadataStructure metadataStructure = datasetVersion.Dataset.MetadataStructure;
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)datasetVersion.Dataset.MetadataStructure.Extra);
XElement temp = XmlUtility.GetXElementByAttribute(nodeNames.nodeRef.ToString(), "name", name.ToString(), xDoc);
string xpath = temp.Attribute("value").Value.ToString();
xmlDoc.SelectSingleNode(xpath).InnerText = value;
return(xmlDoc);
}
return(null);
}
public static GFBIODataCenterFormularObject GetGFBIODataCenterFormularObject(long datasetId)
{
DatasetManager datasetManager = new DatasetManager();
try
{
Dataset dataset = datasetManager.GetDataset(datasetId);
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
GFBIODataCenterFormularObject gfbioDataCenterFormularObject = new GFBIODataCenterFormularObject();
//gfbioDataCenterFormularObject.ProjectId = 1;
//gfbioDataCenterFormularObject.ProjectTitle = "Test Poject title";
//gfbioDataCenterFormularObject.ProjectLabel = "Test Poject label";
//gfbioDataCenterFormularObject.ProjectAbstract = "";
//gfbioDataCenterFormularObject.ProjectPi = "ProjectPi";
//gfbioDataCenterFormularObject.UserId = 1;
//gfbioDataCenterFormularObject.UserName = "******";
//gfbioDataCenterFormularObject.UserEmail = "testEmail";
//gfbioDataCenterFormularObject.DatasetAuthor = "TestAuthor";
gfbioDataCenterFormularObject.DatasetId = datasetId;
gfbioDataCenterFormularObject.DatasetVersion = datasetVersion.Id;
gfbioDataCenterFormularObject.License = "";
gfbioDataCenterFormularObject.DatasetTitle = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.title);
gfbioDataCenterFormularObject.DatasetLabel = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.title);
gfbioDataCenterFormularObject.DatasetDescription = xmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.description);
//gfbioDataCenterFormularObject.DatasetAuthors = new List<string>();
gfbioDataCenterFormularObject.DatasetCollectionTime = datasetVersion.Dataset.LastCheckIOTimestamp;
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(dataset.MetadataStructure.Id);
gfbioDataCenterFormularObject.MetadataSchemaName = metadataStructure.Name;
return(gfbioDataCenterFormularObject);
}
finally
{
datasetManager.Dispose();
}
}
/// <summary>
/// Information in metadata is stored as xml
/// get back the xpath of an attribute
/// e.g. title = metadata/dataset/title
/// </summary>
/// <param name="metadataStructure"></param>
/// <param name="name"></param>
/// <returns></returns>
public string GetInformationPath(long metadataStructureId, NameAttributeValues name)
{
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(metadataStructureId);
if ((XmlDocument)metadataStructure.Extra != null)
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
XElement temp = XmlUtility.GetXElementByAttribute(nodeNames.nodeRef.ToString(), "name", name.ToString(),
xDoc);
string xpath = temp.Attribute("value").Value.ToString();
return(xpath);
}
return("");
}
/// <summary>
/// </summary>
/// <param name="id"></param>
/// <param name="titlePath"></param>
/// <param name="descriptionPath"></param>
/// <param name="mappingFilePath"></param>
/// <param name="direction"></param>
private void StoreParametersToMetadataStruture(long id, string titlePath, string descriptionPath, string entity, string mappingFilePathImport, string mappingFilePathExport)
{
MetadataStructureManager mdsManager = new MetadataStructureManager();
EntityManager entityManager = new EntityManager();
try
{
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(id);
XmlDocument xmlDoc = new XmlDocument();
if (metadataStructure.Extra != null)
{
xmlDoc = (XmlDocument)metadataStructure.Extra;
}
// add title Node
xmlDoc = AddReferenceToMetadatStructure("title", titlePath, AttributeType.xpath.ToString(), "extra/nodeReferences/nodeRef", xmlDoc);
// add Description
xmlDoc = AddReferenceToMetadatStructure("description", descriptionPath, AttributeType.xpath.ToString(), "extra/nodeReferences/nodeRef", xmlDoc);
if (entityManager.EntityRepository.Get().Any(e => { return(e.Name != null && e.Name.Equals(entity)); }))
{
Entity e = entityManager.EntityRepository.Get().FirstOrDefault(x => x.Name != null && x.Name.Equals(entity));
if (e != null)
{
xmlDoc = AddReferenceToMetadatStructure(e.Name, e.EntityType.FullName, AttributeType.entity.ToString(), "extra/entity", xmlDoc);
}
}
// add mappingFilePath
xmlDoc = AddReferenceToMetadatStructure(metadataStructure.Name, mappingFilePathImport, "mappingFileImport", "extra/convertReferences/convertRef", xmlDoc);
xmlDoc = AddReferenceToMetadatStructure(metadataStructure.Name, mappingFilePathExport, "mappingFileExport", "extra/convertReferences/convertRef", xmlDoc);
//set active
xmlDoc = AddReferenceToMetadatStructure(NameAttributeValues.active.ToString(), true.ToString(), AttributeType.parameter.ToString(), "extra/parameters/parameter", xmlDoc);
metadataStructure.Extra = xmlDoc;
mdsManager.Update(metadataStructure);
}
finally
{
mdsManager.Dispose();
entityManager.Dispose();
}
}
public static LinkElementRootModel LoadFromMetadataStructure(long id, LinkElementPostion rootModelType, MappingManager mappingManager)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
try
{
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(id);
LinkElementRootModel model = new LinkElementRootModel(LinkElementType.MetadataStructure, id, metadataStructure.Name, rootModelType);
if (metadataStructure != null)
{
LinkElement metadataStructureLinkElement = mappingManager.GetLinkElement(metadataStructure.Id,
LinkElementType.MetadataStructure);
long metadataStructureLinkElementId = 0;
if (metadataStructureLinkElement != null)
{
metadataStructureLinkElementId = metadataStructureLinkElement.Id;
}
LinkElementModel LEModel = new LinkElementModel(
metadataStructureLinkElementId,
metadataStructure.Id,
LinkElementType.MetadataStructure,
metadataStructure.Name, "Metadata",
rootModelType,
LinkElementComplexity.Complex,
metadataStructure.Description);
foreach (var pUsage in metadataStructure.MetadataPackageUsages)
{
addUsageAsLinkElement(pUsage, "Metadata", model, LEModel);
}
model = CreateLinkElementContainerModels(model);
model.Id = id;
}
return(model);
}
finally
{
metadataStructureManager.Dispose();
}
}
public ActionResult Edit(long id)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
try
{
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(id);
MetadataStructureModel model = convertToMetadataStructureModel(metadataStructure, metadataStructureManager);
return(PartialView("_editMetadataStructureView", model));
}
finally
{
metadataStructureManager.Dispose();
}
}
public string GetEntityNameFromMetadatStructure(long metadataStructureId, MetadataStructureManager metadataStructureManager)
{
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(metadataStructureId);
// get MetadataStructure
if (metadataStructure != null && metadataStructure.Extra != null)
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
IEnumerable <XElement> tmp = XmlUtility.GetXElementByNodeName(nodeNames.entity.ToString(), xDoc);
if (tmp.Any())
{
return(tmp.First().Attribute("name").Value);
}
}
return(string.Empty);
}
private void createMetadataStructureRepoMaps()
{
PublicationManager publicationManager = new PublicationManager();
try
{
//set MetadataStructureToRepository for gbif and pensoft
long metadataStrutcureId = 0;
long repositoryId = 0;
//get id of metadatstructure
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
string metadatStrutcureName = "gbif";
if (metadataStructureManager.Repo.Get().Any(m => m.Name.ToLower().Equals(metadatStrutcureName)))
{
MetadataStructure metadataStructure =
metadataStructureManager.Repo.Get()
.FirstOrDefault(m => m.Name.ToLower().Equals(metadatStrutcureName));
if (metadataStructure != null)
{
metadataStrutcureId = metadataStructure.Id;
}
}
//get id of metadatstructure
string repoName = "pensoft";
if (publicationManager.RepositoryRepo.Get().Any(m => m.Name.ToLower().Equals(repoName)))
{
Repository repository =
publicationManager.RepositoryRepo.Get().FirstOrDefault(m => m.Name.ToLower().Equals(repoName));
if (repository != null)
{
repositoryId = repository.Id;
}
}
if (metadataStrutcureId > 0 && repositoryId > 0)
{
publicationManager.CreateMetadataStructureToRepository(metadataStrutcureId, repositoryId);
}
}
finally
{
publicationManager.Dispose();
}
}
public bool HasMetadataStructureTransmission(long metadataStructureId, TransmissionType type)
{
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(metadataStructureId);
// get MetadataStructure
if (metadataStructure != null && metadataStructure.Extra != null)
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
IEnumerable <XElement> temp = XmlUtility.GetXElementsByAttribute(nodeNames.convertRef.ToString(), AttributeNames.type.ToString(),
type.ToString(), xDoc);
if (temp != null && temp.Any())
{
return(true);
}
}
return(false);
}
public bool HasImportInformation(long metadataStructureId)
{
// get MetadataStructure
MetadataStructure metadataStructure = this.GetUnitOfWork().GetReadOnlyRepository <MetadataStructure>().Get(metadataStructureId);
if (metadataStructure.Extra != null)
{
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)metadataStructure.Extra);
IEnumerable <XElement> tmp = XmlUtility.GetXElementsByAttribute(nodeNames.convertRef.ToString(), AttributeNames.type.ToString(),
TransmissionType.mappingFileImport.ToString(), xDoc);
if (tmp.Any())
{
return(true);
}
}
return(false);
}
