public List <ListViewItem> LoadMetadataStructureViewList()
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
try
{
IEnumerable <MetadataStructure> metadataStructureList = metadataStructureManager.Repo.Get();
List <ListViewItem> temp = new List <ListViewItem>();
foreach (MetadataStructure metadataStructure in metadataStructureList)
{
if (xmlDatasetHelper.IsActive(metadataStructure.Id) &&
xmlDatasetHelper.HasEntityType(metadataStructure.Id, "bexis.dlm.entities.data.dataset"))
{
string title = metadataStructure.Name;
temp.Add(new ListViewItem(metadataStructure.Id, title, metadataStructure.Description));
}
}
return(temp.OrderBy(p => p.Title).ToList());
}
finally
{
metadataStructureManager.Dispose();
}
}
public static List <LinkElementRootListItem> LoadSelectionList()
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
try
{
List <LinkElementRootListItem> tmp = new List <LinkElementRootListItem>();
//load System
LinkElementRootListItem li = new LinkElementRootListItem(0, "System", LinkElementType.System);
tmp.Add(li);
//load Metadata Strutcure
IEnumerable <MetadataStructure> metadataStructures = metadataStructureManager.Repo.Get();
foreach (var metadataStructure in metadataStructures)
{
li = new LinkElementRootListItem(
metadataStructure.Id,
metadataStructure.Name,
LinkElementType.MetadataStructure
);
tmp.Add(li);
}
return(tmp);
}
finally
{
metadataStructureManager.Dispose();
}
}
/// It is called once prior to executing any of the tests in a fixture.
/// Multiple methods can be marked. Order is not preserved.
/// Inheritance is supported, call sequence form the parents
public void OneTimeSetUp()
{
helper = new TestSetupHelper(WebApiConfig.Register, false);
var dsHelper = new DatasetHelper();
dsHelper.PurgeAllDatasets();
dsHelper.PurgeAllDataStructures();
dsHelper.PurgeAllResearchPlans();
// gerenate datasets
var mdm = new MetadataStructureManager();
StructuredDataStructure dataStructure = dsHelper.CreateADataStructure();
dataStructure.Should().NotBeNull("Failed to meet a precondition: a data strcuture is required.");
var rp = dsHelper.CreateResearchPlan();
rp.Should().NotBeNull("Failed to meet a precondition: a research plan is required.");
var mds = mdm.Repo.Query().First();
mds.Should().NotBeNull("Failed to meet a precondition: a metadata strcuture is required.");
DatasetManager datasetManager = new DatasetManager();
// because these tests are working on in-memory objects (datasets) only, there is no need to do the test app setup
_numberOfDatasets = 1000;
for (int i = 0; i < _numberOfDatasets; i++)
{
datasetManager.CreateEmptyDataset(dataStructure, rp, mds);
}
}
/// <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);
}
}
/// <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 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);
}
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();
}
}
public List <SearchMetadataNode> GetMetadataNodes()
{
if (_metadataNodes.Count > 0)
{
return(_metadataNodes);
}
else
{
using (MetadataStructureManager metadataStructureManager = new MetadataStructureManager())
{
List <long> ids = new List <long>();
ids = metadataStructureManager.Repo.Query().Select(p => p.Id).ToList();
foreach (long id in ids)
{
_metadataNodes.AddRange(GetAllXPathsOfSimpleAttributes(id));
}
_metadataNodes = _metadataNodes.Distinct().ToList();
_metadataNodes.Sort((x, y) => String.Compare(x.DisplayName, y.DisplayName));
return(_metadataNodes);
}
}
}
public List <ListItem> GetMetadataStructureList()
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
try
{
IEnumerable <MetadataStructure> metadataStructureList = metadataStructureManager.Repo.Get();
List <ListItem> temp = new List <ListItem>();
foreach (MetadataStructure metadataStructure in metadataStructureList)
{
if (xmlDatasetHelper.IsActive(metadataStructure.Id) &&
xmlDatasetHelper.HasEntityType(metadataStructure.Id, "BExIS.Emm.Entities.Event.Event"))
{
string title = metadataStructure.Name;
temp.Add(new ListItem(metadataStructure.Id, title));
}
}
return(temp.OrderBy(p => p.Name).ToList());
}
finally
{
metadataStructureManager.Dispose();
}
}
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 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 List<SearchMetadataNode> GetAllXPathsOfSimpleAttributes()
{
List<SearchMetadataNode> list = new List<SearchMetadataNode>();
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
// load metadatastructure with all packages and attributes
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID))
{
long metadataStrutureId = Convert.ToInt64(TaskManager.Bus[ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID]);
MetadataStructureManager msd = new MetadataStructureManager();
string title = msd.Repo.Get(metadataStrutureId).Name;
XmlMetadataWriter xmlMetadatWriter = new XmlMetadataWriter(XmlNodeMode.xPath);
XDocument metadataXml = xmlMetadatWriter.CreateMetadataXml(metadataStrutureId);
List<XElement> elements = metadataXml.Root.Descendants().Where(e=>e.HasElements.Equals(false)).ToList();
foreach(XElement element in elements )
{
list.Add(
new SearchMetadataNode(title, XExtentsions.GetAbsoluteXPath(element).Substring(1))
);
}
}
return list;
}
private string getStorePath(long datasetVersionId, string exportTo)
{
using (DatasetManager datasetManager = new DatasetManager())
using (MetadataStructureManager metadataStructureManager = new MetadataStructureManager())
{
DatasetVersion datasetVersion = datasetManager.GetDatasetVersion(datasetVersionId);
Dataset dataset = datasetManager.GetDataset(datasetVersionId);
string md_title = metadataStructureManager.Repo.Get(datasetVersion.Dataset.MetadataStructure.Id).Name;
string path;
int versionNr = datasetManager.GetDatasetVersionNr(datasetVersion);
if (string.IsNullOrEmpty(exportTo) || exportTo.ToLower().Equals("generic"))
{
path = IOHelper.GetDynamicStorePath(datasetVersion.Dataset.Id, versionNr, "metadata", ".xml");
}
else
{
path = IOHelper.GetDynamicStorePath(datasetVersion.Dataset.Id, versionNr, "metadata_" + exportTo, ".xml");
}
return(path);
}
}
private MetadataStructureManagerModel GetDefaultModel()
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
try
{
MetadataStructureManagerModel tmp = new MetadataStructureManagerModel();
//load all metadatastructure
IEnumerable <MetadataStructure> metadataStructures = metadataStructureManager.Repo.Get();
foreach (var metadataStructure in metadataStructures)
{
tmp.MetadataStructureModels.Add(convertToMetadataStructureModel(metadataStructure, metadataStructureManager));
}
if (tmp.MetadataStructureModels.Any())
{
tmp.MetadataStructureModels = tmp.MetadataStructureModels.OrderBy(m => m.Id).ToList();
}
return(tmp);
}
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 ActionResult CancelUpload()
{
TaskManager = (ImportMetadataStructureTaskManager)Session["Taskmanager"];
// delete created metadatastructure
#region delete mds
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.SCHEMA_NAME))
{
string schemaName = TaskManager.Bus[ImportMetadataStructureTaskManager.SCHEMA_NAME].ToString();
MetadataStructureManager msm = new MetadataStructureManager();
if (msm.Repo.Query(m => m.Name.Equals(schemaName)).Any())
{
MetadataStructure ms = msm.Repo.Query(m => m.Name.Equals(schemaName)).FirstOrDefault();
msm.Delete(ms);
}
}
#endregion
Session["Taskmanager"] = null;
TaskManager = null;
return RedirectToAction("ImportMetadataStructureWizard", "ImportMetadataStructure", new RouteValueDictionary { { "area", "DCM" } });
}
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 SheetSelectMetaData(int index)
{
MetadataStructureManager msm = new MetadataStructureManager();
try
{
TaskManager = (EasyUploadTaskManager)Session["TaskManager"];
//set current stepinfo based on index
if (TaskManager != null)
{
TaskManager.SetCurrent(index);
// remove if existing
TaskManager.RemoveExecutedStep(TaskManager.Current());
}
SelectMetaDataModel model = new SelectMetaDataModel();
//Load available metadata structures
IEnumerable <MetadataStructure> metadataStructureList = msm.Repo.Get();
foreach (MetadataStructure metadataStructure in metadataStructureList)
{
if (xmlDatasetHelper.IsActive(metadataStructure.Id) &&
xmlDatasetHelper.HasEntityType(metadataStructure.Id, "bexis.dlm.entities.data.dataset"))
{
model.AvailableMetadata.Add(new Tuple <long, string>(metadataStructure.Id, metadataStructure.Name));
}
}
//Sort the metadata structures
model.AvailableMetadata.Sort((md1, md2) => md1.Item1.CompareTo(md2.Item1));
//If there's already a selected Metadata schema, load its id into the model
if (TaskManager.Bus.ContainsKey(EasyUploadTaskManager.SCHEMA))
{
model.SelectedMetaDataId = Convert.ToInt64(TaskManager.Bus[EasyUploadTaskManager.SCHEMA]);
}
//if the title was changed at some point during the upload, load the title into the model
if (TaskManager.Bus.ContainsKey(EasyUploadTaskManager.DESCRIPTIONTITLE))
{
model.DescriptionTitle = Convert.ToString(TaskManager.Bus[EasyUploadTaskManager.DESCRIPTIONTITLE]);
}
//if it wasn't changed yet, the default title is the filename
else
{
model.DescriptionTitle = Convert.ToString(TaskManager.Bus[EasyUploadTaskManager.FILENAME]);
}
model.StepInfo = TaskManager.Current();
return(PartialView(model));
}
finally
{
msm.Dispose();
}
}
public ActionResult LoadMetaDataForm(SetupModel model)
{
if (model.SelectedMetadataStructureId == -1)
{
ModelState.AddModelError("SelectedMetadataStructureId", "Please select a metadata structure.");
}
if (ModelState.IsValid)
{
using (var metadataStructureManager = new MetadataStructureManager())
using (var entityManager = new EntityManager())
using (var researchPlanManager = new ResearchPlanManager())
{
var md = metadataStructureManager.Repo.Get(a => a.Id == model.SelectedMetadataStructureId).FirstOrDefault();
//get entitytype
var entityType = entityManager.FindByName("Publication");
if (md != null)
{
CreateTaskmanager taskManager = new CreateTaskmanager();
taskManager.AddToBus(CreateTaskmanager.METADATASTRUCTURE_ID, md.Id);
taskManager.AddToBus(CreateTaskmanager.SAVE_WITH_ERRORS, true);
taskManager.AddToBus(CreateTaskmanager.NO_IMPORT_ACTION, true);
taskManager.AddToBus(CreateTaskmanager.INFO_ON_TOP_TITLE, "Edit Publication");
taskManager.AddToBus(CreateTaskmanager.INFO_ON_TOP_DESCRIPTION, "<p>Here you can enter metadata for your new dataset. The form varies according to the metadata structure you selected in the first step. Mandatory fields are indicated with an red asterisk. You can add, remove, or re - order elements(e.g.multiple Creators) using the buttons at the right.</p>");
// get existing researchPlan
string researchPlanName = "Research plan";
ResearchPlan researchPlan = researchPlanManager.Repo.Get(r => researchPlanName.Equals(r.Title)).FirstOrDefault();
taskManager.AddToBus(CreateTaskmanager.RESEARCHPLAN_ID, researchPlan.Id);
//create unstructured datastructure
DataStructure dataStructure = CreateDataStructure("Publication") as UnStructuredDataStructure;
taskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_ID, dataStructure.Id);
HttpContext.Session["CreateDatasetTaskmanager"] = taskManager;
setAdditionalFunctions();
var view = this.Render("DCM", "Form", "StartMetadataEditor", new RouteValueDictionary()
{
});
return(Content(view.ToHtmlString(), "text/html"));
}
else
{
return(Content("Metadata structure not exsits"));
}
}
}
else
{
return(Content("Metadata structure not exsits"));
}
}
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 ActionResult CreateTestDatasets(int n)
{
DatasetManager datasetManager = new DatasetManager();
DataStructureManager dataStructureManager = new DataStructureManager();
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
ResearchPlanManager researchPlanManager = new ResearchPlanManager();
try
{
var structure = dataStructureManager.UnStructuredDataStructureRepo.Get(1);
var metadatastructure = metadataStructureManager.Repo.Get(1);
var researchplan = researchPlanManager.Repo.Get(1);
var xmlDatasetHelper = new XmlDatasetHelper();
var xmlMetadatWriter = new XmlMetadataWriter(XmlNodeMode.xPath);
var metadataXml = xmlMetadatWriter.CreateMetadataXml(metadatastructure.Id);
for (int i = 0; i < n; i++)
{
var dataset = datasetManager.CreateEmptyDataset(structure, researchplan, metadatastructure);
if (datasetManager.IsDatasetCheckedOutFor(dataset.Id, "test") || datasetManager.CheckOutDataset(dataset.Id, "test"))
{
DatasetVersion workingCopy = datasetManager.GetDatasetWorkingCopy(dataset.Id);
datasetManager.EditDatasetVersion(workingCopy, null, null, null);
datasetManager.CheckInDataset(dataset.Id, "", "test", ViewCreationBehavior.None);
workingCopy.Metadata = Xml.Helpers.XmlWriter.ToXmlDocument(metadataXml);
string xpath = xmlDatasetHelper.GetInformationPath(metadatastructure.Id, NameAttributeValues.title);
workingCopy.Metadata.SelectSingleNode(xpath).InnerText = i.ToString();
workingCopy.Title = i.ToString();
datasetManager.EditDatasetVersion(workingCopy, null, null, null);
datasetManager.CheckInDataset(dataset.Id, "", "test", ViewCreationBehavior.None);
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
datasetManager.Dispose();
dataStructureManager.Dispose();
metadataStructureManager.Dispose();
researchPlanManager.Dispose();
}
return(View("Index"));
}
//copy of BExIS.Modules.Ddm.UI.Controllers.DataController.Show (unchanged)
public ActionResult Show(long id, long version = 0)
{
//get the researchobject (cuurently called dataset) to get the id of a metadata structure
Dataset researcobject = this.GetUnitOfWork().GetReadOnlyRepository <Dataset>().Get(id);
long metadataStrutcureId = researcobject.MetadataStructure.Id;
using (MetadataStructureManager metadataStructureManager = new MetadataStructureManager())
{
string entityName = xmlDatasetHelper.GetEntityNameFromMetadatStructure(metadataStrutcureId, metadataStructureManager);
string entityType = xmlDatasetHelper.GetEntityTypeFromMetadatStructure(metadataStrutcureId, metadataStructureManager);
//ToDo in the entity table there must be the information
using (EntityManager entityManager = new EntityManager())
{
var entity = entityManager.Entities.Where(e => e.Name.Equals(entityName)).FirstOrDefault();
string moduleId = "";
Tuple <string, string, string> action = null;
string defaultAction = "ShowData";
if (entity != null && entity.Extra != null)
{
var node = entity.Extra.SelectSingleNode("extra/modules/module");
if (node != null)
{
moduleId = node.Attributes["value"].Value;
}
string modus = "show";
action = EntityViewerHelper.GetEntityViewAction(entityName, moduleId, modus);
}
if (action == null)
{
RedirectToAction(defaultAction, new { id, version });
}
try
{
if (version == 0)
{
return(RedirectToAction(action.Item3, action.Item2, new { area = action.Item1, id }));
}
else
{
return(RedirectToAction(action.Item3, action.Item2, new { area = action.Item1, id, version }));
}
}
catch
{
return(RedirectToAction(defaultAction, new { id, version }));
}
}
}
}
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();
}
}
public string Convert(long datasetVersionId)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
DatasetManager datasetManager = new DatasetManager();
SubmissionManager submissionManager = new SubmissionManager();
PublicationManager publicationManager = new PublicationManager();
try
{
DatasetVersion datasetVersion = datasetManager.GetDatasetVersion(datasetVersionId);
_broker = publicationManager.GetBroker(_broker.Id);
_dataRepo = publicationManager.GetRepository(_dataRepo.Id);
long datasetId = datasetVersion.Dataset.Id;
string name = datasetManager.GetDatasetVersion(datasetVersionId).Dataset.MetadataStructure.Name;
XmlDocument metadata = OutputMetadataManager.GetConvertedMetadata(datasetId,
TransmissionType.mappingFileExport, name, false);
// create links to the api calls of the primary data?
//add all to a zip
//save document and return filepath for download
string path = submissionManager.GetDirectoryPath(datasetId, _broker.Name);
string filename = submissionManager.GetFileNameForDataRepo(datasetId, datasetVersionId, _dataRepo.Name, "xml");
string filepath = Path.Combine(path, filename);
FileHelper.CreateDicrectoriesIfNotExist(path);
metadata.Save(filepath);
return(filepath);
}
finally
{
datasetManager.Dispose();
metadataStructureManager.Dispose();
publicationManager.Dispose();
}
}
public bool SchemaNameExist(string SchemaName)
{
MetadataStructureManager msm = new MetadataStructureManager();
if (msm.Repo.Get().Where(m => m.Name.ToLower().Equals(SchemaName.ToLower())).Count() > 0)
{
return(true);
}
else
{
return(false);
}
}
private static List <LinkElementModel> getChildrenFromMetadataPackageUsage(LinkElementModel model)
{
MetadataStructureManager msm = new MetadataStructureManager();
try
{
MetadataPackageUsage metadataPackageUsage = msm.PackageUsageRepo.Get(model.ElementId);
return(getChildrenFromMetadataPackage(metadataPackageUsage.MetadataPackage.Id, model.Position));
}
finally
{
msm.Dispose();
}
}
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();
}
}
public void CreateDatasetVersionTest()
{
long numberOfTuples = 1000;
var dm = new DatasetManager();
var rsm = new ResearchPlanManager();
var mdm = new MetadataStructureManager();
try
{
var dsHelper = new DatasetHelper();
StructuredDataStructure dataStructure = dsHelper.CreateADataStructure();
dataStructure.Should().NotBeNull("Failed to meet a precondition: a data strcuture is required.");
var rp = dsHelper.CreateResearchPlan();
rp.Should().NotBeNull("Failed to meet a precondition: a research plan is required.");
var mds = mdm.Repo.Query().First();
mds.Should().NotBeNull("Failed to meet a precondition: a metadata strcuture is required.");
Dataset dataset = dm.CreateEmptyDataset(dataStructure, rp, mds);
dataset = dsHelper.GenerateTuplesForDataset(dataset, dataStructure, numberOfTuples, "Javad");
dataset.Should().NotBeNull("The dataset tuple generation has failed!");
dm.CheckInDataset(dataset.Id, "for testing purposes 2", "Javad", ViewCreationBehavior.None);
//dm.SyncView(ds.Id, ViewCreationBehavior.Create);
//dm.SyncView(ds.Id, ViewCreationBehavior.Refresh);
dm.SyncView(dataset.Id, ViewCreationBehavior.Create | ViewCreationBehavior.Refresh);
dataset.Id.Should().BeGreaterThan(0, "Dataset was not persisted.");
dataset.LastCheckIOTimestamp.Should().NotBeAfter(DateTime.UtcNow, "The dataset's timestamp is wrong.");
dataset.DataStructure.Should().NotBeNull("Dataset must have a data structure.");
dataset.Status.Should().Be(DatasetStatus.CheckedIn, "Dataset must be in the CheckedIn status.");
dm.GetDatasetLatestVersionEffectiveTupleCount(dataset.Id).Should().Be(numberOfTuples);
dm.DatasetVersionRepo.Evict();
dm.DataTupleRepo.Evict();
dm.DatasetRepo.Evict();
dm.PurgeDataset(dataset.Id, true);
dsHelper.PurgeAllDataStructures();
}
finally
{
dm.Dispose();
rsm.Dispose();
mdm.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();
}
}
/// <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();
}
}
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 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);
}
public ActionResult DownloadSchema(long id)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(id);
string name = metadataStructure.Name;
string path = OutputMetadataManager.GetSchemaDirectoryPathFromMetadataStructure(id);
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;
}
public ActionResult ConvertSelectedDatasetVersion(string Id, string SelectedDatasetIds)
{
#region load Model
DatasetManager datasetManager = new DatasetManager();
datasetVersionIds = datasetManager.GetDatasetVersionLatestIds();
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(Convert.ToInt64(Id));
MetadataStructureModel model = new MetadataStructureModel(
metadataStructure.Id,
metadataStructure.Name,
metadataStructure.Description,
getDatasetVersionsDic(metadataStructure,datasetVersionIds),
IsExportAvailable(metadataStructure)
);
#endregion
#region convert
if (SelectedDatasetIds != null && SelectedDatasetIds!="")
{
string[] ids = SelectedDatasetIds.Split(',');
foreach (string id in ids)
{
string path = Export(Convert.ToInt64(id));
model.AddMetadataPath(Convert.ToInt64(id), path);
}
}
#endregion
return PartialView("_metadataStructureView",model);
}
public List<SearchMetadataNode> GetMetadataNodes()
{
if (_metadataNodes.Count > 0)
return _metadataNodes;
else
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
List<long> ids = new List<long>();
ids = metadataStructureManager.Repo.Query().Select(p => p.Id).ToList();
foreach (long id in ids)
{
_metadataNodes.AddRange(GetAllXPathsOfSimpleAttributes(id));
}
_metadataNodes = _metadataNodes.Distinct().ToList();
_metadataNodes.Sort((x,y)=>String.Compare(x.DisplayName,y.DisplayName));
return _metadataNodes;
}
}
//ToDo set this function to a other place because of reading a metadata structure ad create a list of all simple attribute with xpath and displayname is also important for other places as search designer
public List<SearchMetadataNode> GetAllXPathsOfSimpleAttributes(long id)
{
List<SearchMetadataNode> list = new List<SearchMetadataNode>();
// load metadatastructure with all packages and attributes
MetadataStructureManager msd = new MetadataStructureManager();
string title = msd.Repo.Get(id).Name;
XmlMetadataWriter xmlMetadatWriter = new XmlMetadataWriter(XmlNodeMode.xPath);
XDocument metadataXml = xmlMetadatWriter.CreateMetadataXml(id);
List<XElement> elements = metadataXml.Root.Descendants().Where(e => e.HasElements.Equals(false)).ToList();
foreach (XElement element in elements)
{
list.Add(
new SearchMetadataNode(title, XExtentsions.GetAbsoluteXPath(element).Substring(1))
);
}
return list;
}
public static string GetMappingFileName(long id, TransmissionType transmissionType, string name)
{
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 static string GetSchemaDirectoryPath(long datasetId)
{
try
{
DatasetManager datasetManager = new DatasetManager();
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
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;
}
public ActionResult Delete(long id)
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(id);
try
{
// delete local files
if (XmlSchemaManager.Delete(metadataStructure))
{
metadataStructureManager.Delete(metadataStructure);
}
}
catch (Exception ex)
{
return Json(ex.Message);
}
// delete links from search index
if (metadataStructureManager.Repo.Get(id) == null) return Json(true);
return Json(false);
}
//private StepModelHelper GetStepModelhelper(long usageId, int number)
//{
// TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
// if (TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATA_STEP_MODEL_HELPER))
// {
// return ((List<StepModelHelper>)TaskManager.Bus[CreateTaskmanager.METADATA_STEP_MODEL_HELPER]).Where(s => s.Usage.Id.Equals(usageId) && s.Number.Equals(number)).FirstOrDefault();
// }
// return null;
//}
//private int GetNumberOfUsageInStepModelHelper(long usageId)
//{
// TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
// if (TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATA_STEP_MODEL_HELPER))
// {
// return ((List<StepModelHelper>)TaskManager.Bus[CreateTaskmanager.METADATA_STEP_MODEL_HELPER]).Where(s => s.Usage.Id.Equals(usageId)).Count() - 1;
// }
// return 0;
//}
//private void GenerateModelsForChildrens(StepModelHelper modelHelper, long metadataStructureId)
//{
// foreach (StepModelHelper item in modelHelper.Childrens)
// {
// if (item.Childrens.Count() > 0)
// {
// GenerateModelsForChildrens(item, metadataStructureId);
// }
// if (item.Model == null)
// {
// BaseUsage u = LoadUsage(item.Usage);
// if (u is MetadataAttributeUsage || u is MetadataNestedAttributeUsage)
// {
// item.Model = MetadataCompoundAttributeModel.ConvertToModel(u, item.Number);
// ((MetadataCompoundAttributeModel)item.Model).ConvertMetadataAttributeModels(u, metadataStructureId, item.StepId);
// }
// if (u is MetadataPackageUsage)
// {
// item.Model = MetadataPackageModel.Convert(u, item.Number);
// ((MetadataPackageModel)item.Model).ConvertMetadataAttributeModels(u, metadataStructureId, item.StepId);
// }
// }
// }
//}
//private StepModelHelper GenerateModelsForChildrens(StepInfo stepInfo, long metadataStructureId)
//{
// StepModelHelper stepModelHelper = GetStepModelhelper(stepInfo.Id);
// if (stepModelHelper.Model == null)
// {
// if (stepModelHelper.Usage is MetadataPackageUsage)
// stepModelHelper.Model = CreatePackageModel(stepInfo.Id, false);
// if (stepModelHelper.Usage is MetadataNestedAttributeUsage)
// stepModelHelper.Model = CreateCompoundModel(stepInfo.Id, false);
// getChildModelsHelper(stepModelHelper);
// }
// return stepModelHelper;
//}
private BaseUsage LoadUsage(BaseUsage usage)
{
if (usage is MetadataPackageUsage)
{
MetadataStructureManager msm = new MetadataStructureManager();
return msm.PackageUsageRepo.Get(usage.Id);
}
if (usage is MetadataNestedAttributeUsage)
{
MetadataAttributeManager mam = new MetadataAttributeManager();
var x = from c in mam.MetadataCompoundAttributeRepo.Get()
from u in c.Self.MetadataNestedAttributeUsages
where u.Id == usage.Id //&& c.Id.Equals(parentId)
select u;
return x.FirstOrDefault();
}
if (usage is MetadataAttributeUsage)
{
MetadataPackageManager mpm = new MetadataPackageManager();
var q = from p in mpm.MetadataPackageRepo.Get()
from u in p.MetadataAttributeUsages
where u.Id == usage.Id // && p.Id.Equals(parentId)
select u;
return q.FirstOrDefault();
}
return usage;
}
private BaseUsage GetPackageUsage(long Id)
{
MetadataStructureManager mpm = new MetadataStructureManager();
return mpm.PackageUsageRepo.Get(Id);
}
private MetadataPackageModel CreatePackageModel(int stepId, bool validateIt)
{
StepInfo stepInfo = TaskManager.Get(stepId);
StepModelHelper stepModelHelper = GetStepModelhelper(stepId);
long metadataPackageId = stepModelHelper.Usage.Id;
long metadataStructureId = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.METADATASTRUCTURE_ID]);
MetadataStructureManager mdsManager = new MetadataStructureManager();
MetadataPackageManager mdpManager = new MetadataPackageManager();
MetadataPackageUsage mpu = (MetadataPackageUsage)LoadUsage(stepModelHelper.Usage);
MetadataPackageModel model = new MetadataPackageModel();
model = MetadataPackageModel.Convert(mpu, stepModelHelper.Number);
model.ConvertMetadataAttributeModels(mpu, metadataStructureId, stepId);
if (stepInfo.IsInstanze == false)
{
//get Instance
if (TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATA_XML))
{
XDocument xMetadata = (XDocument)TaskManager.Bus[CreateTaskmanager.METADATA_XML];
model.ConvertInstance(xMetadata, stepModelHelper.XPath);
}
}
else
{
if (stepModelHelper.Model != null)
{
model = (MetadataPackageModel)stepModelHelper.Model;
}
else
{
stepModelHelper.Model = model;
}
}
//if (validateIt)
//{
// //validate packages
// List<Error> errors = validateStep(stepModelHelper.Model);
// if (errors != null)
// model.ErrorList = errors;
// else
// model.ErrorList = new List<Error>();
//}
model.StepInfo = stepInfo;
return model;
}
private void AdvanceTaskManagerBasedOnExistingMetadata(long MetadataStructureId)
{
TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
List<MetadataPackageUsage> metadataPackageList = metadataStructureManager.GetEffectivePackages(MetadataStructureId).ToList();
List<StepModelHelper> stepModelHelperList = new List<StepModelHelper>();
if (TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATA_STEP_MODEL_HELPER))
{
TaskManager.Bus[CreateTaskmanager.METADATA_STEP_MODEL_HELPER] = stepModelHelperList;
}
else
{
TaskManager.Bus.Add(CreateTaskmanager.METADATA_STEP_MODEL_HELPER, stepModelHelperList);
}
TaskManager.StepInfos = new List<StepInfo>();
foreach (MetadataPackageUsage mpu in metadataPackageList)
{
//only add none optional usages
StepInfo si = new StepInfo(mpu.Label)
{
Id = TaskManager.GenerateStepId(),
parentTitle = mpu.MetadataPackage.Name,
Parent = TaskManager.Root,
IsInstanze = false,
};
TaskManager.StepInfos.Add(si);
StepModelHelper stepModelHelper = new StepModelHelper(si.Id, 1, mpu, "Metadata//" + mpu.Label.Replace(" ", string.Empty) + "[1]", null);
stepModelHelperList.Add(stepModelHelper);
si = LoadStepsBasedOnUsage(mpu, si, "Metadata//" + mpu.Label.Replace(" ", string.Empty) + "[1]", stepModelHelper);
TaskManager.Root.Children.Add(si);
TaskManager.Bus[CreateTaskmanager.METADATA_STEP_MODEL_HELPER] = stepModelHelperList;
}
TaskManager.Bus[CreateTaskmanager.METADATA_STEP_MODEL_HELPER] = stepModelHelperList;
Session["CreateDatasetTaskmanager"] = TaskManager;
}
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);
}
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 "";
}
private Dataset createDataset()
{
DataStructureManager dsManager = new DataStructureManager();
ResearchPlanManager rpManager = new ResearchPlanManager();
DatasetManager dm = new DatasetManager();
MetadataStructureManager mdsManager = new MetadataStructureManager();
MDS.MetadataStructure mds = mdsManager.Repo.Query().First();
Dataset ds = dm.CreateEmptyDataset(dsManager.StructuredDataStructureRepo.Get(1), rpManager.Repo.Get(1), mds);
return ds;
}
public long GenerateMetadataStructure(string nameOfStartNode,string schemaName)
{
if (!String.IsNullOrEmpty(schemaName))
SchemaName = schemaName;
string rootElementName = nameOfStartNode;
newXsdFilePath = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DCM"), "Metadata", schemaName, FileName);
#region prepare mappingFiles
#region intern to extern
// add schema to mappingfile
mappingFileInternalToExternal.Header.AddToSchemas(schemaName, "Metadata/" + schemaName + "/" + FileName);
#endregion
#region extern to intern
mappingFileExternalToInternal.Header.AddToDestination("Metadata");
mappingFileExternalToInternal.Header.AddToSchemas(schemaName, "Metadata/" + schemaName + "/" + FileName);
// id and name of metadatastructure fehlt
#endregion
#endregion
//List<MetadataAttribute> metadataAttributes = new List<MetadataAttribute>();
//metadataAttributes = GenerateAllMetadataAttributes();
List<XmlSchemaElement> elementsWithSimpleType = GetAllElementsTypeIsSimpleType();
List<XmlSchemaComplexType> complexTypesWithSimpleTypesAsChildrensOnly = GetAllComplextTypesWithSimpleTypesAsChildrens();
// create default
MetadataStructureManager mdsManager = new MetadataStructureManager();
MetadataPackageManager mdpManager = new MetadataPackageManager();
// create default metadataStructure
MetadataStructure test = null; //mdsManager.Repo.Get(p => p.Name == SchemaName).FirstOrDefault();
if (test == null) test = mdsManager.Create(SchemaName, SchemaName, "", "", null);
XmlSchemaObject root = new XmlSchemaElement();
string xpathFromRoot = "";
int count = 0;
foreach(XmlSchemaObject obj in Schema.Items)
{
if (obj is XmlSchemaElement)
{
count++;
if (count > 1)
{
throw new Exception("Root node is not able to declare");
}
}
}
foreach(XmlSchemaObject obj in Schema.Items)
{
if (obj is XmlSchemaElement)
root = (XmlSchemaElement)obj;
}
if (String.IsNullOrEmpty(nameOfStartNode))
{
XmlSchemaElement rootElement = (XmlSchemaElement)root;
mappingFileInternalToExternal.Header.AddToDestination(rootElement.Name, rootElement.Name);
rootElementName = rootElement.Name;
xpathFromRoot = rootElementName;
}
else
{
//XXX finde path from rootnode the defined root node
//XPath in mapping file needs to be complete based on the original xsd
xpathFromRoot = findPathFromRoot((XmlSchemaElement)root, nameOfStartNode, "");
root = Elements.Where(e => e.Name.ToLower().Equals(nameOfStartNode.ToLower())).FirstOrDefault();
if (root == null)
{
root = Groups.Where(g => g.Name.ToLower().Equals(nameOfStartNode.ToLower())).FirstOrDefault();
}
if (nameOfStartNode != "")
{
XmlSchemaElement rootElement = (XmlSchemaElement)root;
mappingFileInternalToExternal.Header.AddToDestination(nameOfStartNode, rootElement.Name);
}
}
List<XmlSchemaElement> childrenOfRoot = XmlSchemaUtility.GetAllElements(root, false, Elements);
List<XmlSchemaElement> packages = new List<XmlSchemaElement>();
if (XmlSchemaUtility.IsAllSimpleType(childrenOfRoot))
{
#region root with only simple type childrens
XmlSchemaGroup rootAsGroup = (XmlSchemaGroup)root;
MetadataPackage package = getExistingMetadataPackage(rootAsGroup.Name);
if (package == null)
{
package = mdpManager.Create(rootAsGroup.Name, GetDescription(rootAsGroup.Annotation), true);
createdPackagesDic.Add(package.Id, package.Name);
}
if (test.MetadataPackageUsages.Where(p => p.MetadataPackage == package).Count() <= 0)
{
string xpath = "Metadata/" + rootAsGroup.Name;
foreach (XmlSchemaElement child in childrenOfRoot)
{
//Debug.Writeline("packageChild : " + child.Name);
//Debug.Writeline("-->");
if (XmlSchemaUtility.IsSimpleType(child))
{
addMetadataAttributeToMetadataPackageUsage(package, child, xpath, rootAsGroup.Name);
}
else
{
List<string> parents = new List<string>();
parents.Add(rootAsGroup.Name);
MetadataCompoundAttribute compoundAttribute = get(child, parents, xpath, rootAsGroup.Name);
// add compound to package
addUsageFromMetadataCompoundAttributeToPackage(package, compoundAttribute, child);
}
}
mdsManager.AddMetadataPackageUsage(test, package, rootAsGroup.Name, GetDescription(rootAsGroup.Annotation), 1, 1);
}
#endregion
}
else
{
packages.AddRange(childrenOfRoot);
#region packages with complext types
#region create a basic package of SimpleAttributes from Root Node
// get all simpleTypes
// for the main package
List<XmlSchemaElement> simpleElements = XmlSchemaUtility.GetAllSimpleElements(packages);
string rootNodePackageUsage = "Basic";
string rootNodePackage = "BasicType";
string rootNodePackageDescription = "Attributes from the root node";
if (simpleElements.Count > 0)
{
MetadataPackage package = getExistingMetadataPackage(rootNodePackage);// = mdpManager.MetadataPackageRepo.Get(p => p.Name == rootNodePackage).FirstOrDefault();
if (package == null)
{
package = mdpManager.Create(rootNodePackage, rootNodePackageDescription, true);
createdPackagesDic.Add(package.Id, package.Name);
}
if (test.MetadataPackageUsages.Where(p => p.MetadataPackage == package).Count() <= 0)
{
foreach (XmlSchemaElement child in simpleElements)
{
if (XmlSchemaUtility.IsSimpleType(child))
{
addMetadataAttributeToMetadataPackageUsage(package, child,"Metadata/Basic/BasicType", xpathFromRoot);
}
}
mdsManager.AddMetadataPackageUsage(test, package, rootNodePackageUsage, rootNodePackageDescription, 1, 1);
}
}
#endregion
#region create Packages
List<XmlSchemaElement> otherElements = XmlSchemaUtility.GetAllComplexElements(packages);
foreach (XmlSchemaElement element in otherElements)
{
//Debug.Writeline("package : " + element.Name);
//Debug.Writeline("--------------------------");
string typeName = GetTypeOfName(element.Name);
string rootName = ((XmlSchemaElement)root).Name;
string xpathInternal = "Metadata/" + element.Name+"/"+typeName;
string xpathExternal = xpathFromRoot+"/" + element.Name;
if (!XmlSchemaUtility.IsSimpleType(element))
{
#region complexType
MetadataPackage package = getExistingMetadataPackage(element.Name);// = mdpManager.MetadataPackageRepo.Get(p => p.Name == element.Name).FirstOrDefault();
if (package == null)
{
package = mdpManager.Create(typeName, GetDescription(element.Annotation), true);
createdPackagesDic.Add(package.Id, package.Name);
}
// add package to structure
if (test.MetadataPackageUsages != null && test.MetadataPackageUsages.Where(p => p.Label.Equals(element.Name)).Count() > 0)
{
if (test.MetadataPackageUsages.Where(p => p.MetadataPackage == package).Count() <= 0)
{
List<XmlSchemaElement> childrens = XmlSchemaUtility.GetAllElements(element, false, Elements);
foreach (XmlSchemaElement child in childrens)
{
//Debug.Writeline("packageChild : " + child.Name);
//Debug.Writeline("-->");
if (XmlSchemaUtility.IsSimpleType(child))
{
addMetadataAttributeToMetadataPackageUsage(package, child, xpathInternal, xpathExternal);
}
else
{
List<string> parents = new List<string>();
parents.Add(element.Name);
MetadataCompoundAttribute compoundAttribute = get(child, parents, xpathInternal, xpathExternal);
// add compound to package
addUsageFromMetadataCompoundAttributeToPackage(package, compoundAttribute, child);
}
}
int min = 0;
if (element.MinOccurs > int.MinValue)
min = Convert.ToInt32(element.MinOccurs);
else
min = int.MinValue;
int max = 0;
if (element.MaxOccurs < int.MaxValue)
max = Convert.ToInt32(element.MaxOccurs);
else
max = int.MaxValue;
mdsManager.AddMetadataPackageUsage(test, package, element.Name, GetDescription(element.Annotation), min, max);
}
}
else
{
List<XmlSchemaElement> childrens = XmlSchemaUtility.GetAllElements(element, false, Elements);
foreach (XmlSchemaElement child in childrens)
{
if (XmlSchemaUtility.IsSimpleType(child))
{
addMetadataAttributeToMetadataPackageUsage(package, child, xpathInternal, xpathExternal);
}
else
{
List<string> parents = new List<string>();
parents.Add(element.Name);
MetadataCompoundAttribute compoundAttribute = get(child, parents, xpathInternal, xpathExternal);
// add compound to package
addUsageFromMetadataCompoundAttributeToPackage(package, compoundAttribute, child);
}
}
int min = 0;
if (element.MinOccurs > int.MinValue)
min = Convert.ToInt32(element.MinOccurs);
else
min = int.MinValue;
int max = 0;
if (element.MaxOccurs < int.MaxValue)
max = Convert.ToInt32(element.MaxOccurs);
else
max = int.MaxValue;
//check if element is a choice
if (!XmlSchemaUtility.IsChoiceType(element))
{
MetadataPackageUsage mpu = mdsManager.AddMetadataPackageUsage(test, package,
element.Name, GetDescription(element.Annotation), min, max);
}
else
{
// if mpu is a choice, add a info to extra
MetadataPackageUsage mpu = mdsManager.AddMetadataPackageUsage(test, package,
element.Name, GetDescription(element.Annotation), min, max,
XmlDatasetHelper.AddReferenceToXml(new XmlDocument(), "choice", "true", "elementType", @"extra/type"));
}
}
#endregion
}
}
#endregion
#endregion
}
if (!File.Exists(newXsdFilePath))
{
checkDirectory(newXsdFilePath);
MoveFile(xsdFilePath, newXsdFilePath);
}
#region store additionaly xsds
string tmpDestinationPath = Path.GetDirectoryName(newXsdFilePath);
string tmpSourcePath = Path.GetDirectoryName(xsdFilePath);
if (additionalFiles != null)
{
foreach (var filename in additionalFiles.Distinct())
{
MoveFile(Path.Combine(tmpSourcePath, filename), Path.Combine(tmpDestinationPath, filename));
}
}
#endregion
#region Generate Mapping File
string internalMetadataStructrueName = schemaName;
mappingFileExternalToInternal.Id = test.Id;
//generate mapping file Xml Document
generateXmlMappingFile(mappingFileInternalToExternal, internalMetadataStructrueName, FileName);
generateXmlMappingFile(mappingFileExternalToInternal, FileName, internalMetadataStructrueName, 1);
#endregion
return test.Id;
}
//
// 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();
}
public void Delete(string schemaName)
{
MetadataStructureManager mdsManager = new MetadataStructureManager();
// create default metadataStructure
MetadataStructure test = mdsManager.Repo.Get(p => p.Name == SchemaName).FirstOrDefault();
if (test != null) mdsManager.Delete(test);
}
public static GFBIOPangaeaFormularObject GetGFBIOPangaeaFormularObject(long datasetId)
{
DatasetManager datasetManager = new DatasetManager();
datasetManager.GetDataset(datasetId);
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();
string title = XmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.title);
string description = XmlDatasetHelper.GetInformation(datasetId, NameAttributeValues.description);
return gfbioPangaeaFormularObject;
}
/// <summary>
/// create a new dataset, check it out to create the first version, add a tuple to it.
/// </summary>
/// <returns></returns>
private Int64 createDatasetVersion()
{
DataStructureManager dsManager = new DataStructureManager();
ResearchPlanManager rpManager = new ResearchPlanManager();
DatasetManager dm = new DatasetManager();
MetadataStructureManager mdsManager = new MetadataStructureManager();
MDS.MetadataStructure mds = mdsManager.Repo.Query().First();
Dataset ds = dm.CreateEmptyDataset(dsManager.StructuredDataStructureRepo.Get(1), rpManager.Repo.Get(1), mds);
if (dm.IsDatasetCheckedOutFor(ds.Id, "Javad") || dm.CheckOutDataset(ds.Id, "Javad"))
{
DatasetVersion workingCopy = dm.GetDatasetWorkingCopy(ds.Id);
//DataTuple changed = dm.GetDatasetVersionEffectiveTuples(workingCopy).First();
//changed.VariableValues.First().Value = (new Random()).Next().ToString();
DataTuple dt = dm.DataTupleRepo.Get(1); // its sample data
List<DataTuple> tuples = new List<DataTuple>();
for (int i = 0; i < 10000; i++)
{
DataTuple newDt = new DataTuple();
newDt.XmlAmendments = dt.XmlAmendments;
newDt.XmlVariableValues = dt.XmlVariableValues; // in normal cases, the VariableValues are set and then Dematerialize is called
newDt.Materialize();
newDt.OrderNo = i;
//newDt.TupleAction = TupleAction.Created;//not required
//newDt.Timestamp = DateTime.UtcNow; //required? no, its set in the Edit
//newDt.DatasetVersion = workingCopy;//required? no, its set in the Edit
tuples.Add(newDt);
}
dm.EditDatasetVersion(workingCopy, tuples, null, null);
dm.CheckInDataset(ds.Id, "for testing purposes", "Javad");
dm.DatasetVersionRepo.Evict();
dm.DataTupleRepo.Evict();
dm.DatasetRepo.Evict();
workingCopy.PriliminaryTuples.Clear();
workingCopy = null;
}
var dsId = ds.Id;
ds = null;
return (dsId);
}
public static string GetSchemaDirectoryPathFromMetadataStructure(long metadataStructureId)
{
try
{
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure =
metadataStructureManager.Repo.Get(metadataStructureId);
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;
}
public ActionResult LoadMetadataStructureTab(long Id)
{
#region load Model
DatasetManager datasetManager = new DatasetManager();
// retrieves all the dataset version IDs which are in the checked-in state
datasetVersionIds = datasetManager.GetDatasetVersionLatestIds();
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(Id);
MetadataStructureModel model = new MetadataStructureModel(
metadataStructure.Id,
metadataStructure.Name,
metadataStructure.Description,
getDatasetVersionsDic(metadataStructure, datasetVersionIds),
IsExportAvailable(metadataStructure)
);
#endregion
return PartialView("_metadataStructureView",model);
}
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);
}
/// <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();
MetadataStructure metadataStructure = mdsManager.Repo.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);
xmlDoc = AddReferenceToMetadatStructure("entity", entity, 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);
}
public bool SchemaNameExist(string SchemaName)
{
MetadataStructureManager msm = new MetadataStructureManager();
if (msm.Repo.Get().Where(m => m.Name.ToLower().Equals(SchemaName.ToLower())).Count() == 0)
{
return false;
}
else
{
return true;
}
}
public long createDataset(string dataSetID, XmlDocument metadataXml, long metadataStructureId, DataStructure dataStructure, string researchPlanName)
{
Dataset dataset = new Dataset();
DatasetManager datasetManager = new DatasetManager();
DataStructureManager dataStructureManager = new DataStructureManager();
ResearchPlanManager researchPlanManager = new ResearchPlanManager();
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
PermissionManager permissionManager = new PermissionManager();
SubjectManager subjectManager = new SubjectManager();
// get existing researchPlan
ResearchPlan researchPlan = researchPlanManager.Repo.Get(r => researchPlanName.Equals(r.Title)).FirstOrDefault();
// get existing metadataStructure (created manualy by using edited Bexis1_XSD)
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(metadataStructureId);
// update verwendet, da bei unstructured structures im dataset constructor dataset(dataStructure) nullexception
dataset = datasetManager.CreateEmptyDataset(dataStructure, researchPlan, metadataStructure);
long datasetId = dataset.Id;
// dataPermission
List<string> usersWithDataPerm = new List<string>();
// create dataPermission for originalDatasetManager
string originalDatasetManager = metadataXml.SelectSingleNode("Metadata/general/general/originalDatasetManager/originalDatasetManager").InnerText;
User userODM = subjectManager.UsersRepo.Get(u => originalDatasetManager.Equals(u.FullName)).FirstOrDefault();
permissionManager.CreateDataPermission(userODM.Id, 1, dataset.Id, RightType.Create);
permissionManager.CreateDataPermission(userODM.Id, 1, dataset.Id, RightType.View);
permissionManager.CreateDataPermission(userODM.Id, 1, dataset.Id, RightType.Update);
permissionManager.CreateDataPermission(userODM.Id, 1, dataset.Id, RightType.Download);
usersWithDataPerm.Add(originalDatasetManager);
// create dataPermissions for metadataAuthor
string metadataAuthor = metadataXml.SelectSingleNode("Metadata/general/general/metadataCreator/metadataCreator").InnerText;
if (!usersWithDataPerm.Contains(metadataAuthor))
{
User userMA = subjectManager.UsersRepo.Get(u => metadataAuthor.Equals(u.FullName)).FirstOrDefault();
permissionManager.CreateDataPermission(userMA.Id, 1, dataset.Id, RightType.Create);
permissionManager.CreateDataPermission(userMA.Id, 1, dataset.Id, RightType.View);
permissionManager.CreateDataPermission(userMA.Id, 1, dataset.Id, RightType.Update);
permissionManager.CreateDataPermission(userMA.Id, 1, dataset.Id, RightType.Download);
usersWithDataPerm.Add(metadataAuthor);
}
// create dataPermissions for designatedDatasetManager
string designatedDatasetManager = metadataXml.SelectSingleNode("Metadata/general/general/designatedDatasetManager/contactType/designatedDatasetManagerName/designatedDatasetManagerName").InnerText;
if (!usersWithDataPerm.Contains(designatedDatasetManager))
{
User userDDM = subjectManager.UsersRepo.Get(u => designatedDatasetManager.Equals(u.FullName)).FirstOrDefault();
permissionManager.CreateDataPermission(userDDM.Id, 1, dataset.Id, RightType.Create);
permissionManager.CreateDataPermission(userDDM.Id, 1, dataset.Id, RightType.View);
permissionManager.CreateDataPermission(userDDM.Id, 1, dataset.Id, RightType.Update);
permissionManager.CreateDataPermission(userDDM.Id, 1, dataset.Id, RightType.Download);
usersWithDataPerm.Add(designatedDatasetManager);
}
// create dataPermissions for owners
XmlNodeList ownerNodes = metadataXml.SelectNodes("Metadata/general/general/owners/ownerType/owner/owner");
foreach (XmlNode ownerNode in ownerNodes)
{
string owner = ownerNode.InnerText;
if (!usersWithDataPerm.Contains(owner))
{
User userO = subjectManager.UsersRepo.Get(u => owner.Equals(u.FullName)).FirstOrDefault();
if (userO != null)
{
permissionManager.CreateDataPermission(userO.Id, 1, dataset.Id, RightType.Create);
permissionManager.CreateDataPermission(userO.Id, 1, dataset.Id, RightType.View);
permissionManager.CreateDataPermission(userO.Id, 1, dataset.Id, RightType.Update);
permissionManager.CreateDataPermission(userO.Id, 1, dataset.Id, RightType.Download);
usersWithDataPerm.Add(owner);
}
}
}
// integrate metadataXml to dataset
// checkOut
if (datasetManager.IsDatasetCheckedOutFor(datasetId, userODM.Name) || datasetManager.CheckOutDataset(datasetId, userODM.Name))
{
DatasetVersion workingCopy = datasetManager.GetDatasetWorkingCopy(datasetId); // get dataset
workingCopy.Metadata = metadataXml; // set metadata to dataset
datasetManager.EditDatasetVersion(workingCopy, null, null, null); // edit dataset
datasetManager.CheckInDataset(datasetId, "Metadata was submited.", userODM.Name); // check in
}
return dataset.Id;
}
//
// GET: /DIM/Admin/
public ActionResult Index()
{
ViewBag.Title = PresentationModel.GetViewTitleForTenant("Export Metadata", this.Session.GetTenant());
AdminModel model = new AdminModel();
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
IList<MetadataStructure> metadataStructures = metadataStructureManager.Repo.Get();
foreach(MetadataStructure metadataStructure in metadataStructures)
{
model.Add(metadataStructure);
}
return View(model);
}
public static GFBIODataCenterFormularObject GetGFBIODataCenterFormularObject(long datasetId)
{
DatasetManager datasetManager = new DatasetManager();
datasetManager.GetDataset(datasetId);
Dataset dataset = datasetManager.GetDataset(datasetId);
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
GFBIODataCenterFormularObject gfbioDataCenterFormularObject = new GFBIODataCenterFormularObject();
gfbioDataCenterFormularObject.ProjectId = 1;
gfbioDataCenterFormularObject.ProjectTitle = "Test Poject title";
gfbioDataCenterFormularObject.ProjectLabel = "Test Poject label";
gfbioDataCenterFormularObject.ProjectAbstract = "";
gfbioDataCenterFormularObject.UserId = 1;
gfbioDataCenterFormularObject.UserName = "******";
gfbioDataCenterFormularObject.UserEmail = "testEmail";
gfbioDataCenterFormularObject.DatasetAuthor = "TestAuthor";
gfbioDataCenterFormularObject.DatasetId = datasetId;
gfbioDataCenterFormularObject.DatasetVersion = datasetVersion.Id;
gfbioDataCenterFormularObject.DatasetTitle = XmlDatasetHelper.GetInformation(datasetId,NameAttributeValues.title);
gfbioDataCenterFormularObject.DatasetLabel = XmlDatasetHelper.GetInformation(datasetId,NameAttributeValues.title);
gfbioDataCenterFormularObject.DatasetDescription = XmlDatasetHelper.GetInformation(datasetId,NameAttributeValues.description);
gfbioDataCenterFormularObject.DatasetCollectionDate = datasetVersion.Dataset.LastCheckIOTimestamp;
MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(dataset.MetadataStructure.Id);
gfbioDataCenterFormularObject.MetadataSchemaName = metadataStructure.Name;
return gfbioDataCenterFormularObject;
}
private void testMetadataStructure()
{
MetadataStructureManager mdsManager = new MetadataStructureManager();
MetadataPackageManager mdpManager = new MetadataPackageManager();
MetadataAttributeManager mdaManager = new MetadataAttributeManager();
MetadataStructure root = mdsManager.Repo.Get(p => p.Name == "Root").FirstOrDefault();
if (root == null) root = mdsManager.Create("Root", "This is the root metadata structure", "", "", null);
MetadataStructure s1 = mdsManager.Repo.Get(p => p.Name == "S1").FirstOrDefault();
if (s1 == null) s1 = mdsManager.Create("S1", "This is S1 metadata structure", "", "", root);
MetadataStructure s11 = mdsManager.Repo.Get(p => p.Name == "S1.1").FirstOrDefault();
if (s11 == null) s11 = mdsManager.Create("S1.1", "This is S1.1 metadata structure", "", "", s1);
MetadataStructure s2 = mdsManager.Repo.Get(p => p.Name == "S2").FirstOrDefault();
if (s2 == null) s2 = mdsManager.Create("S2", "This is S2 metadata structure", "", "", root);
MetadataPackage p1 = mdpManager.MetadataPackageRepo.Get(p => p.Name == "P1").FirstOrDefault();
if (p1 == null) p1 = mdpManager.Create("P1", "Sample Package 1", true);
MetadataPackage p2 = mdpManager.MetadataPackageRepo.Get(p => p.Name == "P2").FirstOrDefault();
if (p2 == null) p2 = mdpManager.Create("P2", "Sample Package 2", true);
MetadataPackage p3 = mdpManager.MetadataPackageRepo.Get(p => p.Name == "P3").FirstOrDefault();
if (p3 == null) p3 = mdpManager.Create("P3", "Sample Package 3", true);
MetadataPackage p4 = mdpManager.MetadataPackageRepo.Get(p => p.Name == "P4").FirstOrDefault();
if (p4 == null) p4 = mdpManager.Create("P4", "Sample Package 4", true);
if (s1.MetadataPackageUsages.Where(p => p.MetadataPackage == p1).Count() <= 0)
mdsManager.AddMetadataPackageUsage(s1, p1, "P1 in S1", "", 0, 1);
if (s1.MetadataPackageUsages.Where(p => p.MetadataPackage == p2).Count() <= 0)
mdsManager.AddMetadataPackageUsage(s1, p2, "P2 in S1", "", 1, 1);
if (s11.MetadataPackageUsages.Where(p => p.MetadataPackage == p3).Count() <= 0)
mdsManager.AddMetadataPackageUsage(s11, p3, "P3 in S1.1", "", 0, 10);
if (s11.MetadataPackageUsages.Where(p => p.MetadataPackage == p4).Count() <= 0)
mdsManager.AddMetadataPackageUsage(s11, p4, "P4 in S1.1", "", 2, 5);
var usages = mdsManager.GetEffectivePackages(3);
}
