/// <summary>
/// Selected File store din the BUS
/// </summary>
/// <param name="SelectFileUploader"></param>
/// <returns></returns>
public ActionResult SelectFileProcess(HttpPostedFileBase SelectFileUploader)
{
ImportMetadataStructureTaskManager TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
if (SelectFileUploader != null)
{
//data/datasets/1/1/
string dataPath = AppConfiguration.DataPath; //Path.Combine(AppConfiguration.WorkspaceRootPath, "Data");
string storepath = Path.Combine(dataPath, "Temp", GetUsernameOrDefault());
// if folder not exist
if (!Directory.Exists(storepath))
{
Directory.CreateDirectory(storepath);
}
string path = Path.Combine(storepath, SelectFileUploader.FileName);
SelectFileUploader.SaveAs(path);
TaskManager.AddToBus(ImportMetadataStructureTaskManager.FILEPATH, path);
TaskManager.AddToBus(ImportMetadataStructureTaskManager.FILENAME, SelectFileUploader.FileName);
TaskManager.AddToBus(ImportMetadataStructureTaskManager.EXTENTION, SelectFileUploader.FileName.Split('.').Last());
Session["TaskManager"] = TaskManager;
}
//return RedirectToAction("UploadWizard");
return(Content(""));
}
public ActionResult Summary(int index)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
//set current stepinfo based on index
if (TaskManager != null)
{
TaskManager.SetCurrent(index);
}
SummaryModel model = new SummaryModel(TaskManager.Current());
model.StepInfo = TaskManager.Current();
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ROOT_NODE))
{
model.RootName = TaskManager.Bus[ImportMetadataStructureTaskManager.ROOT_NODE].ToString();
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.SCHEMA_NAME))
{
model.SchemaName = TaskManager.Bus[ImportMetadataStructureTaskManager.SCHEMA_NAME].ToString();
}
return(PartialView(model));
}
public List <SearchMetadataNode> GetAllXPathsOfSimpleAttributes()
{
using (IUnitOfWork unitOfWork = this.GetUnitOfWork())
{
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]);
string title = unitOfWork.GetReadOnlyRepository <MetadataStructure>().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);
}
}
public JsonResult SetSchemaName(string name)
{
if (String.IsNullOrEmpty(name))
{
return(Json("A Metadata structure must have a name.", JsonRequestBehavior.AllowGet));
}
if (!RegExHelper.IsFilenameValid(name))
{
return(Json("Name : \" " + name + " \" is invalid. These special characters are not allowed : \\/:*?\"<>|", JsonRequestBehavior.AllowGet));
}
if (SchemaNameExist(name))
{
return(Json("A Metadata structure with this name already exist. Please choose a other name.", JsonRequestBehavior.AllowGet));
}
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.SCHEMA_NAME))
{
TaskManager.Bus[ImportMetadataStructureTaskManager.SCHEMA_NAME] = name;
}
else
{
TaskManager.Bus.Add(ImportMetadataStructureTaskManager.SCHEMA_NAME, name);
}
return(Json(true, JsonRequestBehavior.AllowGet));
}
public ActionResult ImportMetadataStructureWizard()
{
ViewBag.Title = PresentationModel.GetViewTitleForTenant("Import Metadata Structure", this.Session.GetTenant());
Session["TaskManager"] = null;
TaskManager = null;
if (TaskManager == null)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
}
if (TaskManager == null)
{
try
{
string path = "";
path = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DCM"), "ImportMetadataStructureTaskInfo.xml");
XmlDocument xmlTaskInfo = new XmlDocument();
xmlTaskInfo.Load(path);
TaskManager = ImportMetadataStructureTaskManager.Bind(xmlTaskInfo);
Session["TaskManager"] = TaskManager;
}
catch (Exception e)
{
ModelState.AddModelError(String.Empty, e.Message);
}
}
return(View((ImportMetadataStructureTaskManager)Session["TaskManager"]));
}
public ActionResult ReadSource(int index)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
//set current stepinfo based on index
if (TaskManager != null)
{
TaskManager.SetCurrent(index);
TaskManager.RemoveExecutedStep(TaskManager.Current());
TaskManager.Current().notExecuted = true;
}
ReadSourceModel model = new ReadSourceModel(TaskManager.Current());
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.IS_GENERATE))
{
model.IsGenerated = (bool)TaskManager.Bus[ImportMetadataStructureTaskManager.IS_GENERATE];
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ROOT_NODE))
{
model.RootNode = TaskManager.Bus[ImportMetadataStructureTaskManager.ROOT_NODE].ToString();
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.SCHEMA_NAME))
{
model.SchemaName = TaskManager.Bus[ImportMetadataStructureTaskManager.SCHEMA_NAME].ToString();
}
return(PartialView(model));
}
public ActionResult SelectAFile(int index)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
//set current stepinfo based on index
if (TaskManager != null)
{
TaskManager.SetCurrent(index);
}
//Get Bus infomations
SelectFileViewModel model = new SelectFileViewModel();
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.FILENAME))
{
model.SelectedFileName = TaskManager.Bus[ImportMetadataStructureTaskManager.FILENAME].ToString();
}
//get datastuctureType
model.SupportedFileExtentions = ImportMetadataStructureWizardHelper.GetExtentionList();
//Get StepInfo
model.StepInfo = TaskManager.Current();
model.serverFileList = GetServerFileList();
return(PartialView(model));
}
public ActionResult ReadSource(object[] data)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
ReadSourceModel model = new ReadSourceModel(TaskManager.Current());
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.IS_GENERATE))
{
TaskManager.Current().SetValid(true);
TaskManager.Current().SetStatus(StepStatus.success);
}
else
{
ModelState.AddModelError("", "Please click generate button.");
}
if (TaskManager.Current().IsValid())
{
TaskManager.AddExecutedStep(TaskManager.Current());
TaskManager.GoToNext();
Session["TaskManager"] = TaskManager;
ActionInfo actionInfo = TaskManager.Current().GetActionInfo;
return(RedirectToAction(actionInfo.ActionName, actionInfo.ControllerName, new RouteValueDictionary {
{ "area", actionInfo.AreaName }, { "index", TaskManager.GetCurrentStepInfoIndex() }
}));
}
return(PartialView(model));
}
public ActionResult Summary(object[] data)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
return(PartialView());
}
private List <SearchMetadataNode> GetMetadataNodes()
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
if (TaskManager != null && !TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ALL_METADATA_NODES))
{
TaskManager.AddToBus(ImportMetadataStructureTaskManager.ALL_METADATA_NODES, GetAllXPathsOfSimpleAttributes());
}
return((List <SearchMetadataNode>)TaskManager.Bus[ImportMetadataStructureTaskManager.ALL_METADATA_NODES]);
}
public ActionResult Save(ParametersModel model)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
long metadatstructureId = Convert.ToInt64(TaskManager.Bus[ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID]);
model.MetadataNodes = GetMetadataNodes();
model.StepInfo = TaskManager.Current();
model.StepInfo.notExecuted = false;
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.TITLE_NODE))
{
TaskManager.Bus[ImportMetadataStructureTaskManager.TITLE_NODE] = model.TitleNode;
}
else
{
TaskManager.Bus.Add(ImportMetadataStructureTaskManager.TITLE_NODE, model.TitleNode);
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.DESCRIPTION_NODE))
{
TaskManager.Bus[ImportMetadataStructureTaskManager.DESCRIPTION_NODE] = model.DescriptionNode;
}
else
{
TaskManager.Bus.Add(ImportMetadataStructureTaskManager.DESCRIPTION_NODE, model.DescriptionNode);
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE))
{
TaskManager.Bus[ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE] = model.EntityType;
}
else
{
TaskManager.Bus.Add(ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE, model.EntityType);
}
string mappingFilePathImport = TaskManager.Bus[ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_IMPORT].ToString();
string mappingFilePathExport = TaskManager.Bus[ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_EXPORT].ToString();
try
{
StoreParametersToMetadataStruture(metadatstructureId, model.TitleNode, model.EntityType, model.DescriptionNode, mappingFilePathImport, mappingFilePathExport);
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
return(PartialView("SetParameters", model));
}
/// <summary>
/// returns true if Extention in the Bus will supported
/// </summary>
/// <param name="taskManager"></param>
/// <returns></returns>
private bool IsSupportedExtention(ImportMetadataStructureTaskManager taskManager)
{
if (taskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.EXTENTION))
{
string ext = taskManager.Bus[ImportMetadataStructureTaskManager.EXTENTION].ToString();
if (ImportMetadataStructureWizardHelper.GetExtentionList().Contains(ext.ToLower()))
{
return(true);
}
}
return(false);
}
public ActionResult SetEntityName(string name)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE))
{
TaskManager.Bus[ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE] = name;
}
else
{
TaskManager.Bus.Add(ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE, name);
}
return(null);
}
public ActionResult SetRootNode(string name)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ROOT_NODE))
{
TaskManager.Bus[ImportMetadataStructureTaskManager.ROOT_NODE] = name;
}
else
{
TaskManager.Bus.Add(ImportMetadataStructureTaskManager.ROOT_NODE, name);
}
return(Content(""));
}
public ActionResult SetParameters(int index)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
long metadatstructureId = 0;
ParametersModel model = new ParametersModel();
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID))
{
metadatstructureId = Convert.ToInt64(TaskManager.Bus[ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID]);
//set current stepinfo based on index
if (TaskManager != null)
{
TaskManager.SetCurrent(index);
}
model.MetadataNodes = GetMetadataNodes();
model.Entities = GetEntityList();
}
else
{
ModelState.AddModelError("", "MetadataStructure not exist");
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.TITLE_NODE))
{
model.TitleNode = GetDisplayName((string)TaskManager.Bus[ImportMetadataStructureTaskManager.TITLE_NODE]);
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.DESCRIPTION_NODE))
{
model.DescriptionNode =
GetDisplayName((string)TaskManager.Bus[ImportMetadataStructureTaskManager.DESCRIPTION_NODE]);
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE))
{
model.EntityType = TaskManager.Bus[ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE].ToString();
}
model.StepInfo = TaskManager.Current();
model.StepInfo.notExecuted = true;
return(PartialView(model));
}
private void LoadXSDSchema(string username)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
string path = TaskManager.Bus[ImportMetadataStructureTaskManager.FILEPATH].ToString();
//open schema
XmlSchemaManager xmlSchemaManager = new XmlSchemaManager();
xmlSchemaManager.Load(path, username);
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.XML_SCHEMA_MANAGER))
{
TaskManager.Bus[ImportMetadataStructureTaskManager.XML_SCHEMA_MANAGER] = xmlSchemaManager;
}
else
{
TaskManager.Bus.Add(ImportMetadataStructureTaskManager.XML_SCHEMA_MANAGER, xmlSchemaManager);
}
}
/// <summary>
/// Selected File from server and store into BUS
/// </summary>
/// <param name="SelectFileUploader"></param>
/// <returns></returns>
public ActionResult SelectFileFromServerProcess(string fileName)
{
ImportMetadataStructureTaskManager TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
if (fileName != null)
{
//string path = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DCM"), "ServerFiles",fileName);
//data/datasets/1/1/
string dataPath = AppConfiguration.DataPath; //Path.Combine(AppConfiguration.WorkspaceRootPath, "Data");
string path = Path.Combine(dataPath, "Temp", GetUsernameOrDefault(), fileName);
TaskManager.AddToBus(ImportMetadataStructureTaskManager.FILEPATH, path);
TaskManager.AddToBus(ImportMetadataStructureTaskManager.FILENAME, fileName);
TaskManager.AddToBus(ImportMetadataStructureTaskManager.EXTENTION, "." + fileName.Split('.').Last());
Session["TaskManager"] = TaskManager;
}
//return RedirectToAction("UploadWizard");
return(Content(""));
}
public ActionResult SelectAFile(object[] data)
{
SelectFileViewModel model = new SelectFileViewModel();
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
if (data != null)
{
TaskManager.AddToBus(data);
}
model.StepInfo = TaskManager.Current();
TaskManager.Current().SetValid(false);
if (TaskManager != null)
{
// is path of FileStream exist
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.FILEPATH))
{
if (IsSupportedExtention(TaskManager))
{
try
{
//check if file exist and add to taskmanager
string filePath = TaskManager.Bus[ImportMetadataStructureTaskManager.FILEPATH].ToString();
if (FileHelper.FileExist(filePath))
{
TaskManager.Current().SetValid(true);
TaskManager.Current().SetStatus(StepStatus.success);
}
else
{
model.ErrorList.Add(new Error(ErrorType.Other, "Cannot access FileStream on server."));
}
}
catch
{
model.ErrorList.Add(new Error(ErrorType.Other, "Cannot access FileStream on server."));
}
try
{
LoadXSDSchema(GetUsernameOrDefault());
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
model.ErrorList.Add(new Error(ErrorType.Other, "Can not find any dependent files to the selected schema. Please upload missing files to server and try it again."));
TaskManager.Current().SetValid(false);
}
if (TaskManager.Current().IsValid())
{
TaskManager.AddExecutedStep(TaskManager.Current());
TaskManager.GoToNext();
Session["TaskManager"] = TaskManager;
ActionInfo actionInfo = TaskManager.Current().GetActionInfo;
return(RedirectToAction(actionInfo.ActionName, actionInfo.ControllerName, new RouteValueDictionary {
{ "area", actionInfo.AreaName }, { "index", TaskManager.GetCurrentStepInfoIndex() }
}));
}
}
else
{
model.ErrorList.Add(new Error(ErrorType.Other, "File is not supported."));
}
}
else
{
model.ErrorList.Add(new Error(ErrorType.Other, "No FileStream selected or submitted."));
}
}
model.serverFileList = GetServerFileList();
model.SupportedFileExtentions = ImportMetadataStructureWizardHelper.GetExtentionList();
return(PartialView(model));
}
public ActionResult GenerateMS()
{
//open schema
XmlSchemaManager xmlSchemaManager = new XmlSchemaManager();
string root = "";
string schemaName = "";
long metadataStructureid = 0;
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ROOT_NODE))
{
root = TaskManager.Bus[ImportMetadataStructureTaskManager.ROOT_NODE].ToString();
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.SCHEMA_NAME))
{
schemaName = TaskManager.Bus[ImportMetadataStructureTaskManager.SCHEMA_NAME].ToString();
}
string path = TaskManager.Bus[ImportMetadataStructureTaskManager.FILEPATH].ToString();
//path = @"https://code.ecoinformatics.org/code/eml/tags/RELEASE_EML_2_1_1/eml.xsd";
ReadSourceModel model = new ReadSourceModel(TaskManager.Current());
model.SchemaName = schemaName;
model.RootNode = root;
if (!RegExHelper.IsFilenameValid(schemaName))
{
model.ErrorList.Add(new Error(ErrorType.Other,
"Name : \" " + schemaName + " \" is invalid. These special characters are not allowed : \\/:*?\"<>|"));
}
else
{
try
{
//file.WriteLine("check schema exist");
if (SchemaNameExist(schemaName))
{
model.ErrorList.Add(new Error(ErrorType.Other,
"A Metadata structure with this name already exist. Please choose a other name."));
}
else
if (String.IsNullOrEmpty(schemaName))
{
model.ErrorList.Add(new Error(ErrorType.Other, "A Metadata structure must have a name."));
}
else
{
xmlSchemaManager.Load(path, GetUserNameOrDefault());
}
if (!String.IsNullOrEmpty(model.RootNode) && !xmlSchemaManager.Elements.Any(e => e.Name.Equals(model.RootNode)))
{
model.ErrorList.Add(new Error(ErrorType.Other, "Root node not exist"));
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
model.ErrorList.Add(new Error(ErrorType.Other, "Can not create metadatastructure."));
throw ex;
}
if (model.ErrorList.Count == 0)
{
try
{
metadataStructureid = xmlSchemaManager.GenerateMetadataStructure(root, schemaName);
}
catch (Exception ex)
{
xmlSchemaManager.Delete(schemaName);
ModelState.AddModelError("", ex.Message);
model.ErrorList.Add(new Error(ErrorType.Other, "Can not create metadatastructure."));
}
}
TaskManager.AddToBus(ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_IMPORT,
xmlSchemaManager.mappingFileNameImport);
TaskManager.AddToBus(ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_EXPORT,
xmlSchemaManager.mappingFileNameExport);
model.StepInfo.notExecuted = false;
if (model.ErrorList.Count == 0)
{
model.IsGenerated = true;
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.IS_GENERATE))
{
TaskManager.Bus[ImportMetadataStructureTaskManager.IS_GENERATE] = true;
}
else
{
TaskManager.Bus.Add(ImportMetadataStructureTaskManager.IS_GENERATE, true);
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID))
{
TaskManager.Bus[ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID] = metadataStructureid;
}
else
{
TaskManager.Bus.Add(ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID, metadataStructureid);
}
}
}
return(PartialView("ReadSource", model));
}
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();
var deleted = msm.Delete(ms);
if (deleted)
{
//delete xsds
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.SCHEMA_NAME))
{
schemaName = RegExHelper.GetCleanedFilename(schemaName);
string directoryPath = Path.Combine(AppConfiguration.GetModuleWorkspacePath("Dcm"), "Metadata", schemaName);
if (Directory.Exists(directoryPath))
{
Directory.Delete(directoryPath, true);
}
}
//delete mappingfiles
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_IMPORT))
{
string filepath = Path.Combine(AppConfiguration.GetModuleWorkspacePath("Dim"), TaskManager.Bus[ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_IMPORT].ToString());
if (FileHelper.FileExist(filepath))
{
FileHelper.Delete(filepath);
}
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_EXPORT))
{
string filepath = Path.Combine(AppConfiguration.GetModuleWorkspacePath("Dim"), TaskManager.Bus[ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_EXPORT].ToString());
if (FileHelper.FileExist(filepath))
{
FileHelper.Delete(filepath);
}
}
}
}
}
#endregion
Session["Taskmanager"] = null;
TaskManager = null;
return(RedirectToAction("ImportMetadataStructureWizard", "ImportMetadataStructure", new RouteValueDictionary {
{ "area", "DCM" }
}));
}
public ActionResult RefreshTaskList()
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
return(PartialView("_taskListView", TaskManager.GetStatusOfStepInfos()));
}
public ActionResult RefreshNavigation()
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
return(PartialView("_wizardNav", TaskManager));
}
public ActionResult SetParameters(int?index, string name = null)
{
TaskManager = (ImportMetadataStructureTaskManager)Session["TaskManager"];
ParametersModel model = new ParametersModel();
model.StepInfo = TaskManager.Current();
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.TITLE_NODE) &&
TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.DESCRIPTION_NODE) &&
TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE))
{
long id = Convert.ToInt64((TaskManager.Bus[ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID]));
string mappingFilePathImport = TaskManager.Bus[ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_IMPORT].ToString();
string mappingFilePathExport = TaskManager.Bus[ImportMetadataStructureTaskManager.MAPPING_FILE_NAME_EXPORT].ToString();
string titleXpath = TaskManager.Bus[ImportMetadataStructureTaskManager.TITLE_NODE].ToString();
string descriptionXpath = TaskManager.Bus[ImportMetadataStructureTaskManager.DESCRIPTION_NODE].ToString();
string entity = TaskManager.Bus[ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE].ToString();
model.TitleNode = GetMetadataNodes().First(p => p.XPath.Equals(titleXpath)).DisplayName;
model.DescriptionNode = GetMetadataNodes().First(p => p.XPath.Equals(descriptionXpath)).DisplayName;
model.EntityType = TaskManager.Bus[ImportMetadataStructureTaskManager.ENTITY_TYPE_NODE].ToString();
TaskManager.Current().SetValid(true);
try
{
StoreParametersToMetadataStruture(id, titleXpath, descriptionXpath, entity, mappingFilePathImport, mappingFilePathExport);
}
catch (Exception ex)
{
TaskManager.Current().SetValid(false);
ModelState.AddModelError("", ex.Message);
}
}
else
{
//set existing parameter
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.TITLE_NODE))
{
model.TitleNode = GetMetadataNodes().First(p => p.XPath.Equals(TaskManager.Bus[ImportMetadataStructureTaskManager.TITLE_NODE].ToString())).DisplayName;
}
;
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.DESCRIPTION_NODE))
{
model.DescriptionNode = GetMetadataNodes().First(p => p.XPath.Equals(TaskManager.Bus[ImportMetadataStructureTaskManager.DESCRIPTION_NODE].ToString())).DisplayName;
}
;
TaskManager.Current().SetValid(false);
ModelState.AddModelError("", "Please select the missing field");
}
if (TaskManager.Current().IsValid())
{
TaskManager.Current().SetStatus(StepStatus.success);
TaskManager.AddExecutedStep(TaskManager.Current());
TaskManager.GoToNext();
Session["TaskManager"] = TaskManager;
ActionInfo actionInfo = TaskManager.Current().GetActionInfo;
return(RedirectToAction(actionInfo.ActionName, actionInfo.ControllerName, new RouteValueDictionary {
{ "area", actionInfo.AreaName }, { "index", TaskManager.GetCurrentStepInfoIndex() }
}));
}
if (TaskManager.Bus.ContainsKey(ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID))
{
long metadatstructureId = Convert.ToInt64(TaskManager.Bus[ImportMetadataStructureTaskManager.METADATASTRUCTURE_ID]);
model.MetadataNodes = GetMetadataNodes();
model.Entities = GetEntityList();
model.StepInfo.notExecuted = true;
}
return(PartialView(model));
}
