public XmlDocument createMetadata(string dataSetID, string filePath, string DataBase, ref List<string> variableNames, ref string fileType)
{
string path_mappingFile = filePath + @"\bexis_metadata_mapping.xml";
// query Bexis1 metadata from DB
XmlDocument metadataBexis1 = getMetadataXml(dataSetID, DataBase);
// Get variable names
XmlNamespaceManager xnm = new XmlNamespaceManager(metadataBexis1.NameTable);
xnm.AddNamespace("bgc", "http://www.bgc-jena.mpg.de");
XmlNodeList variables = metadataBexis1.SelectNodes("bgc:metaProfile/bgc:data/bgc:dataStructure/bgc:variables/bgc:variable/bgc:name", xnm);
foreach (XmlNode variable in variables)
{
variableNames.Add(variable.InnerText);
}
// is this data structure structured?
XmlNode dataFileType = metadataBexis1.SelectSingleNode("bgc:metaProfile/bgc:data/bgc:fileType", xnm);
fileType = dataFileType.InnerText;
// XML mapper + mapping file
XmlMapperManager xmlMapperManager = new XmlMapperManager();
xmlMapperManager.Load(path_mappingFile, "BExIS");
// generate Bpp metadata
XmlDocument metadataBpp = xmlMapperManager.Generate(metadataBexis1, 99);
return metadataBpp;
}
public static XmlDocument GetConvertedMetadata(long datasetId, TransmissionType type, string mappingName, bool storing = true)
{
XmlDocument newXml;
try
{
DatasetManager datasetManager = new DatasetManager();
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
string mappingFileName = XmlDatasetHelper.GetTransmissionInformation(datasetVersion, type, mappingName);
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 = XmlDatasetHelper.GetInformation(datasetVersion, NameAttributeValues.title);
// store in content descriptor
if (storing)
{
if(String.IsNullOrEmpty(mappingName) || mappingName.ToLower() == "generic")
storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, "metadata", ".xml");
else
storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, "metadata_"+ mappingName, ".xml");
}
}
catch (Exception ex)
{
throw ex;
}
return newXml;
}
public static string IsValideAgainstSchema(long datasetId, TransmissionType type, string mappingName)
{
try
{
DatasetManager datasetManager = new DatasetManager();
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
string mappingFileName = XmlDatasetHelper.GetTransmissionInformation(datasetVersion, type, mappingName);
string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName);
XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
xmlMapperManager.Load(pathMappingFile, "exporttest");
XmlDocument tmp = GetConvertedMetadata(datasetId, type, mappingName, false);
string path = Path.Combine(AppConfiguration.DataPath, "Temp", "System", "convertedMetadata.xml");
if (FileHelper.FileExist(path))
FileHelper.Delete(path);
FileHelper.CreateDicrectoriesIfNotExist(Path.GetDirectoryName(path));
tmp.Save(path);
XmlDocument metadataForImport = new XmlDocument();
metadataForImport.Load(path);
return xmlMapperManager.Validate(metadataForImport);
}
catch (Exception ex)
{
return ex.Message;
}
}
public ActionResult LoadExternalXml()
{
string validationMessage = "";
if (TaskManager == null) TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
if (TaskManager != null &&
TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATASTRUCTURE_ID) &&
TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATA_IMPORT_XML_FILEPATH))
{
//xml metadata for import
string metadataForImportPath = (string)TaskManager.Bus[CreateTaskmanager.METADATA_IMPORT_XML_FILEPATH];
if (FileHelper.FileExist(metadataForImportPath))
{
XmlDocument metadataForImport = new XmlDocument();
metadataForImport.Load(metadataForImportPath);
// metadataStructure ID
long metadataStructureId = (Int64)TaskManager.Bus[CreateTaskmanager.METADATASTRUCTURE_ID];
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
string metadataStructrueName = metadataStructureManager.Repo.Get(metadataStructureId).Name;
// loadMapping file
string path_mappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), XmlMetadataImportHelper.GetMappingFileName(metadataStructureId, TransmissionType.mappingFileImport, metadataStructrueName));
// XML mapper + mapping file
XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.ExternToIntern);
xmlMapperManager.Load(path_mappingFile, "IDIV");
// generate intern metadata without internal attributes
XmlDocument metadataResult = xmlMapperManager.Generate(metadataForImport, 1, true);
// generate intern template metadata xml with needed attribtes
XmlMetadataWriter xmlMetadatWriter = new XmlMetadataWriter(BExIS.Xml.Helpers.XmlNodeMode.xPath);
XDocument metadataXml = xmlMetadatWriter.CreateMetadataXml(metadataStructureId,
XmlUtility.ToXDocument(metadataResult));
XmlDocument metadataXmlTemplate = XmlMetadataWriter.ToXmlDocument(metadataXml);
// set attributes FROM metadataXmlTemplate TO metadataResult
XmlDocument completeMetadata = XmlMetadataImportHelper.FillInXmlValues(metadataResult,
metadataXmlTemplate);
TaskManager.AddToBus(CreateTaskmanager.METADATA_XML, completeMetadata);
//LoadMetadata(long datasetId, bool locked= false, bool created= false, bool fromEditMode = false, bool resetTaskManager = false, XmlDocument newMetadata=null)
return RedirectToAction("ImportMetadata", "Form",
new {metadataStructureId = metadataStructureId});
}
}
return Content("Error Message :"+validationMessage);
}
public ActionResult ValidateExternalXml()
{
string validationMessage = "";
if (TaskManager == null) TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
if (TaskManager != null &&
TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATASTRUCTURE_ID) &&
TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATA_IMPORT_XML_FILEPATH))
{
//xml metadata for import
string metadataForImportPath = (string)TaskManager.Bus[CreateTaskmanager.METADATA_IMPORT_XML_FILEPATH];
if (FileHelper.FileExist(metadataForImportPath))
{
XmlDocument metadataForImport = new XmlDocument();
metadataForImport.Load(metadataForImportPath);
// metadataStructure DI
long metadataStructureId = (Int64)TaskManager.Bus[CreateTaskmanager.METADATASTRUCTURE_ID];
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
string metadataStructrueName = metadataStructureManager.Repo.Get(metadataStructureId).Name;
// loadMapping file
string path_mappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), XmlMetadataImportHelper.GetMappingFileName(metadataStructureId, TransmissionType.mappingFileImport, metadataStructrueName));
// XML mapper + mapping file
XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.ExternToIntern);
xmlMapperManager.Load(path_mappingFile, "IDIV");
validationMessage = xmlMapperManager.Validate(metadataForImport);
}
}
return Content(validationMessage);
}
//
// GET: /DIM/Import/
public ActionResult Index()
{
//xml metadata for import
string metadataForImportPath = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), "MetadataIDIV_EXAMPLE.xml");
XmlDocument metadataForImport = new XmlDocument();
metadataForImport.Load(metadataForImportPath);
// metadataStructure DI
long metadataStructureId = 3;
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
string metadataStructrueName = metadataStructureManager.Repo.Get(metadataStructureId).Name;
// loadMapping file
string path_mappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), XmlMetadataImportHelper.GetMappingFileName(metadataStructureId, TransmissionType.mappingFileImport, metadataStructrueName));
// XML mapper + mapping file
XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
xmlMapperManager.Load(path_mappingFile, "IDIV");
// generate intern metadata
XmlDocument metadataResult = xmlMapperManager.Generate(metadataForImport,1);
// generate intern template
XmlMetadataWriter xmlMetadatWriter = new XmlMetadataWriter(BExIS.Xml.Helpers.XmlNodeMode.xPath);
XDocument metadataXml = xmlMetadatWriter.CreateMetadataXml(metadataStructureId);
XmlDocument metadataXmlTemplate = XmlMetadataWriter.ToXmlDocument(metadataXml);
XmlDocument completeMetadata = XmlMetadataImportHelper.FillInXmlAttributes(metadataResult, metadataXmlTemplate);
// create Dataset
//load datastructure
DataStructureManager dsm = new DataStructureManager();
ResearchPlanManager rpm = new ResearchPlanManager();
MetadataStructureManager msm = new MetadataStructureManager();
DatasetManager dm = new DatasetManager();
Dataset dataset = dm.CreateEmptyDataset(dsm.UnStructuredDataStructureRepo.Get(1), rpm.Repo.Get(1), msm.Repo.Get(3));
if (dm.IsDatasetCheckedOutFor(dataset.Id, GetUsernameOrDefault()) || dm.CheckOutDataset(dataset.Id, GetUsernameOrDefault()))
{
DatasetVersion workingCopy = dm.GetDatasetWorkingCopy(dataset.Id);
workingCopy.Metadata = completeMetadata;
string title = XmlDatasetHelper.GetInformation(workingCopy, NameAttributeValues.title);
if (String.IsNullOrEmpty(title)) title = "No Title available.";
dm.EditDatasetVersion(workingCopy, null, null, null);
dm.CheckInDataset(dataset.Id, "Metadata was submited.", GetUsernameOrDefault());
// add security
if (GetUsernameOrDefault() != "DEFAULT")
{
PermissionManager pm = new PermissionManager();
SubjectManager sm = new SubjectManager();
BExIS.Security.Entities.Subjects.User user = sm.GetUserByName(GetUsernameOrDefault());
foreach (RightType rightType in Enum.GetValues(typeof(RightType)).Cast<RightType>())
{
pm.CreateDataPermission(user.Id, 1, dataset.Id, rightType);
}
}
}
return View();
}
private string Export(long datasetVersionId)
{
DatasetManager datasetManager = new DatasetManager();
DatasetVersion datasetVersion = datasetManager.GetDatasetVersion(datasetVersionId);
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(datasetVersion.Dataset.MetadataStructure.Id);
string fileName = getMappingFileName(datasetVersion, TransmissionType.mappingFileExport, metadataStructure.Name);
string path_mapping_file = "";
try
{
path_mapping_file = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), fileName);
xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
xmlMapperManager.Load(path_mapping_file, GetUsernameOrDefault());
return xmlMapperManager.Export(datasetVersion.Metadata,datasetVersion.Id, fileName);
}
catch(Exception ex)
{
return ex.Message;
}
return "";
}
public string TransferPublications()
{
string xsdPath = Path.Combine(AppConfiguration.DataPath, "Temp", "Administrator");
PublicationManager pms = new PublicationManager();
MetadataCreator metadataCreator = new MetadataCreator();
//Import MetaDataStructure
string schemaFile = xsdPath + @"\publication.xsd";
//open schema
XmlSchemaManager xmlSchemaManager = new XmlSchemaManager();
string userName = "******";
xmlSchemaManager.Load(schemaFile, userName);
long metadataStructureId = 0;
try
{
metadataStructureId = metadataCreator.importMetadataStructure(schemaFile, userName, schemaFile, "Publication", "Metadata/publicationDetails/publicationDetails/title/title", "Metadata/publicationDetails/publicationDetails/information/information");// xmlSchemaManager.GenerateMetadataStructure("publication", "publication");
}
catch (Exception ex)
{
xmlSchemaManager.Delete("publication");
return "Couldn't create publication metadatastructure!";
}
//Create an empty publication
MetadataStructureManager msm = new MetadataStructureManager();
MetadataStructure metadataStructure = msm.Repo.Get(metadataStructureId);
XmlDocument metadataXmlTemplate = BExIS.Xml.Helpers.XmlMetadataWriter.ToXmlDocument(metadataCreator.createXmlTemplate(metadataStructureId));
var publicationsMetaData = metadataCreator.getPublicationsMetadataXml(DataBase);
var xmlMapperManager = new XmlMapperManager();
string filePath = AppConfiguration.GetModuleWorkspacePath("BMM");
string path_mappingFile = filePath + @"\bexis_publication_metadata_mapping.xml";
foreach (var publicationMetaData in publicationsMetaData)
{
var pc = pms.CreateEmptyPublication(metadataStructure);
var publicationId = pc.Id;
if (pms.IsPublicationCheckedOutFor(publicationId, userName) || pms.CheckOutPublication(publicationId, userName))
{
PublicationVersion workingCopy = pms.GetPublicationWorkingCopy(publicationId);
// XML mapper + mapping file
xmlMapperManager.Load(path_mappingFile, "Publication");
XmlDocument metadataBpp = xmlMapperManager.Generate(publicationMetaData.MetaDataXml, 99);
metadataBpp = metadataCreator.fillInXmlAttributes(metadataBpp, metadataXmlTemplate);
workingCopy.Metadata = metadataBpp;
foreach (var pbContent in publicationMetaData.PublicationContentDescriptors)
{
string storePath = Path.Combine(AppConfiguration.DataPath, "Publications", publicationId.ToString());
storePath = Path.Combine(storePath, publicationId.ToString() + "_" + workingCopy.VersionNo.ToString() + "_" + pbContent.Name);
File.Move(pbContent.URI, storePath);
pbContent.URI = storePath;
pbContent.PublicationVersion = workingCopy;
workingCopy.PublicationContentDescriptors.Add(pbContent);
}
pms.CheckInPublication(publicationId, "Metadata was submited.", userName);
}
}
return "";
}
