public List <EntityStoreItem> GetVersionsById(long id) { DatasetManager dm = new DatasetManager(); List <EntityStoreItem> tmp = new List <EntityStoreItem>(); try { var datasetIds = dm.GetDatasetLatestIds(); var datasetHelper = new XmlDatasetHelper(); var versions = dm.GetDataset(id).Versions.OrderBy(v => v.Timestamp).ToList(); foreach (var v in versions) { tmp.Add(new EntityStoreItem() { Id = v.Id, Title = datasetHelper.GetInformationFromVersion(v.Id, NameAttributeValues.title), Version = versions.IndexOf(v) + 1, CommitComment = "(" + v.Timestamp.ToString("dd.MM.yyyy HH:mm") + "): " + v.ChangeDescription }); } return(tmp); } catch (Exception ex) { return(tmp); } finally { dm.Dispose(); } }
private void addSelectedDatasetToBus(long datasetId) { DatasetManager datasetManager = new DatasetManager(); try { TaskManager = (TaskManager)Session["TaskManager"]; if (datasetManager.GetDatasetVersionEffectiveTupleCount(datasetManager.GetDatasetLatestVersion(datasetId)) > 0) { TaskManager.AddToBus("DatasetStatus", "edit"); } else { TaskManager.AddToBus("DatasetStatus", "new"); } DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId); TaskManager.AddToBus(TaskManager.DATASET_ID, datasetId); //Add Metadata to Bus //TITLE TaskManager.AddToBus(TaskManager.DATASET_TITLE, xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title)); ResearchPlanManager rpm = new ResearchPlanManager(); ResearchPlan rp = rpm.Repo.Get(datasetVersion.Dataset.ResearchPlan.Id); TaskManager.AddToBus(TaskManager.RESEARCHPLAN_ID, rp.Id); TaskManager.AddToBus(TaskManager.RESEARCHPLAN_TITLE, rp.Title); } finally { datasetManager.Dispose(); } }
// GET: api/data/5 /// <summary> /// In addition to the id, it is possible to have projection and selection criteria passed to the action via query string parameters /// </summary> /// <param name="id">Dataset Id</param> /// <returns></returns> /// <remarks> The action accepts the following additional parameters via the query string /// 1: projection: is a comman separated list of ids that determines which variables of the dataset version tuples should take part in the result set /// 2: selection: is a logical expression that filters the tuples of the chosen dataset. The expression should have been written against the variables of the dataset only. /// logical operators, nesting, precedence, and SOME functions should be supported. /// /api/data/6?header=TimeUTC,D8CO1_1&filter=TimeUTC<5706000 /// </remarks> public HttpResponseMessage Get(int id) { string projection = this.Request.GetQueryNameValuePairs().FirstOrDefault(p => "header".Equals(p.Key, StringComparison.InvariantCultureIgnoreCase)).Value; string selection = this.Request.GetQueryNameValuePairs().FirstOrDefault(p => "filter".Equals(p.Key, StringComparison.InvariantCultureIgnoreCase)).Value; DatasetManager datasetManager = new DatasetManager(); try { OutputDataManager ioOutputDataManager = new OutputDataManager(); DatasetVersion version = datasetManager.GetDatasetLatestVersion(id); string title = xmlDatasetHelper.GetInformationFromVersion(version.Id, NameAttributeValues.title); // check the data sturcture type ... if (version.Dataset.DataStructure.Self is StructuredDataStructure) { // apply selection and projection //var tuples = dm.GetDatasetVersionEffectiveTuples(version); DataTable dt = OutputDataManager.ConvertPrimaryDataToDatatable(datasetManager, version, title, true); if (!string.IsNullOrEmpty(selection)) { dt = OutputDataManager.SelectionOnDataTable(dt, selection); } if (!string.IsNullOrEmpty(projection)) { // make the header names upper case to make them case insensitive dt = OutputDataManager.ProjectionOnDataTable(dt, projection.ToUpper().Split(',')); } DatasetModel model = new DatasetModel(); model.DataTable = dt; var response = Request.CreateResponse(); response.Content = new ObjectContent(typeof(DatasetModel), model, new DatasetModelCsvFormatter(model.DataTable.TableName)); //set headers on the "response" return(response); //return model; } else { return(Request.CreateResponse()); } } finally { datasetManager.Dispose(); } }
public static DatasetGridRowModel Convert(DatasetVersion datasetVersion, bool isPublic) { XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper(); return(new DatasetGridRowModel() { Id = datasetVersion.Dataset.Id, Title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title), IsPublic = isPublic }); }
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(); string mappingName = metadataStructure.Name; string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName); string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName); XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern); xmlMapperManager.Load(pathMappingFile, "exporttest"); newXml = xmlMapperManager.Export(datasetVersion.Metadata, datasetVersion.Id, mappingName, true); string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.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, datasetVersion.Id, filename, ".xml")); } catch (Exception ex) { throw ex; } finally { datasetManager.Dispose(); metadataMetadataStructureManager.Dispose(); } return(""); }
public static XmlDocument GetConvertedMetadata(long datasetId, TransmissionType type, string mappingName, bool storing = true) { XmlDocument newXml; DatasetManager datasetManager = new DatasetManager(); try { DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId); XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper(); string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName); string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName); XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern); xmlMapperManager.Load(pathMappingFile, "exporttest"); newXml = xmlMapperManager.Export(datasetVersion.Metadata, datasetVersion.Id, mappingName, true); string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title); // store in content descriptor if (storing) { if (String.IsNullOrEmpty(mappingName) || mappingName.ToLower() == "generic") { storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, "metadata", ".xml"); } else { storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, "metadata_" + mappingName, ".xml"); } } } catch (Exception ex) { throw ex; } return(newXml); }
private List <DatasetVersionModel> getDatasetVersionsDic(MetadataStructure metadataStructure, List <long> datasetVersionIds) { List <DatasetVersionModel> datasetVersions = new List <DatasetVersionModel>(); DatasetManager datasetManager = new DatasetManager(); try { using (var uow = this.GetUnitOfWork()) { // gets all the dataset versions that their Id is in the datasetVersionIds and they are using a specific metadata structure as indicated by metadataStructure parameter var q = uow.GetReadOnlyRepository <DatasetVersion>().Get(p => datasetVersionIds.Contains(p.Id) && p.Dataset.MetadataStructure.Id.Equals(metadataStructure.Id)).Distinct(); foreach (DatasetVersion datasetVersion in q) { if (datasetManager.IsDatasetCheckedIn(datasetVersion.Dataset.Id)) { uow.GetReadOnlyRepository <DatasetVersion>().Load(datasetVersion.ContentDescriptors); datasetVersions.Add( new DatasetVersionModel { DatasetVersionId = datasetVersion.Id, DatasetId = datasetVersion.Dataset.Id, Title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title), MetadataDownloadPath = OutputMetadataManager.GetMetadataPath(datasetVersion.ContentDescriptors) }); } } return(datasetVersions); } } finally { datasetManager.Dispose(); } }
/// <summary> /// create a model to fill the table of My Dataset /// </summary> /// <remarks></remarks> /// <seealso cref="ShowMyDatasets"/> /// <param>NA</param> /// <returns>model</returns> public ActionResult _CustomMyDatasetBinding() { DataTable model = new DataTable(); ViewData["PageSize"] = 10; ViewData["CurrentPage"] = 1; #region header List <HeaderItem> headerItems = CreateHeaderItems(); ViewData["DefaultHeaderList"] = headerItems; #endregion model = CreateDataTable(headerItems); DatasetManager datasetManager = new DatasetManager(); EntityPermissionManager entityPermissionManager = new EntityPermissionManager(); UserManager userManager = new UserManager(); EntityManager entityManager = new EntityManager(); try { var entity = entityManager.FindByName("Dataset"); var user = userManager.FindByNameAsync(GetUsernameOrDefault()).Result; List <long> gridCommands = datasetManager.GetDatasetLatestIds(); gridCommands.Skip(Convert.ToInt16(ViewData["CurrentPage"])).Take(Convert.ToInt16(ViewData["PageSize"])); foreach (long datasetId in gridCommands) { //get permissions int rights = entityPermissionManager.GetEffectiveRights(user?.Id, entity.Id, datasetId); if (rights > 0) { DataRow dataRow = model.NewRow(); Object[] rowArray = new Object[8]; if (datasetManager.IsDatasetCheckedIn(datasetId)) { //long versionId = datasetManager.GetDatasetLatestVersionId (datasetId); // check for zero value //DatasetVersion dsv = datasetManager.DatasetVersionRepo.Get(versionId); DatasetVersion dsv = datasetManager.GetDatasetLatestVersion(datasetId); //MetadataStructureManager msm = new MetadataStructureManager(); //dsv.Dataset.MetadataStructure = msm.Repo.Get(dsv.Dataset.MetadataStructure.Id); string title = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.title); string description = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.description); rowArray[0] = Convert.ToInt64(datasetId); rowArray[1] = title; rowArray[2] = description; } else { rowArray[0] = Convert.ToInt64(datasetId); rowArray[1] = ""; rowArray[2] = "Dataset is just in processing."; } rowArray[3] = (rights & (int)RightType.Read) > 0 ? "✔" : "✘"; rowArray[4] = (rights & (int)RightType.Write) > 0 ? "✔" : "✘"; rowArray[5] = (rights & (int)RightType.Delete) > 0 ? "✔" : "✘"; rowArray[6] = (rights & (int)RightType.Download) > 0 ? "✔" : "✘"; rowArray[7] = (rights & (int)RightType.Grant) > 0 ? "✔" : "✘"; dataRow = model.NewRow(); dataRow.ItemArray = rowArray; model.Rows.Add(dataRow); } } return(View(new GridModel(model))); } finally { datasetManager.Dispose(); entityPermissionManager.Dispose(); entityManager.Dispose(); userManager.Dispose(); } }
public ActionResult ShowData(long id) { DatasetManager dm = new DatasetManager(); EntityPermissionManager entityPermissionManager = new EntityPermissionManager(); try { DatasetVersion dsv; ShowDataModel model = new ShowDataModel(); string title = ""; long metadataStructureId = -1; long dataStructureId = -1; long researchPlanId = 1; XmlDocument metadata = new XmlDocument(); if (dm.IsDatasetCheckedIn(id)) { long versionId = dm.GetDatasetLatestVersionId(id); // check for zero value dsv = dm.DatasetVersionRepo.Get(versionId); // this is needed to allow dsv to access to an open session that is available via the repo metadataStructureId = dsv.Dataset.MetadataStructure.Id; //MetadataStructureManager msm = new MetadataStructureManager(); //dsv.Dataset.MetadataStructure = msm.Repo.Get(dsv.Dataset.MetadataStructure.Id); title = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.title); // this function only needs metadata and extra fields, there is no need to pass the version to it. dataStructureId = dsv.Dataset.DataStructure.Id; researchPlanId = dsv.Dataset.ResearchPlan.Id; metadata = dsv.Metadata; ViewBag.Title = PresentationModel.GetViewTitleForTenant("Show Data : " + title, this.Session.GetTenant()); } else { ModelState.AddModelError(string.Empty, "Dataset is just in processing."); } model = new ShowDataModel() { Id = id, Title = title, MetadataStructureId = metadataStructureId, DataStructureId = dataStructureId, ResearchPlanId = researchPlanId, ViewAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, "Dataset", typeof(Dataset), id, RightType.Read), GrantAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, "Dataset", typeof(Dataset), id, RightType.Grant) }; //set metadata in session Session["ShowDataMetadata"] = metadata; return(View(model)); } finally { dm.Dispose(); entityPermissionManager.Dispose(); } }
public List <ListViewItem> LoadDatasetVersionViewList(DataStructureType dataStructureType) { EntityPermissionManager entityPermissionManager = new EntityPermissionManager(); DataStructureManager dataStructureManager = new DataStructureManager(); DatasetManager dm = new DatasetManager(); try { ICollection <long> datasetIDs = new List <long>(); datasetIDs = entityPermissionManager.GetKeys(GetUsernameOrDefault(), "Dataset", typeof(Dataset), RightType.Write).ToList(); Dictionary <long, XmlDocument> dmtemp = new Dictionary <long, XmlDocument>(); dmtemp = dm.GetDatasetLatestMetadataVersions(); List <ListViewItem> temp = new List <ListViewItem>(); if (dataStructureType.Equals(DataStructureType.Structured)) { List <StructuredDataStructure> list = dataStructureManager.StructuredDataStructureRepo.Get().ToList(); foreach (StructuredDataStructure sds in list) { sds.Materialize(); foreach (Dataset d in sds.Datasets) { if (dm.IsDatasetCheckedIn(d.Id)) { if (datasetIDs.Contains(d.Id)) { temp.Add(new ListViewItem(d.Id, xmlDatasetHelper.GetInformationFromVersion(dm.GetDatasetLatestVersion(d).Id, NameAttributeValues.title))); } } } } } else { List <UnStructuredDataStructure> list = dataStructureManager.UnStructuredDataStructureRepo.Get().ToList(); foreach (UnStructuredDataStructure sds in list) { foreach (Dataset d in sds.Datasets) { if (datasetIDs.Contains(d.Id)) { if (dm.IsDatasetCheckedIn(d.Id)) { DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(d); temp.Add(new ListViewItem(d.Id, xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title))); } } } } } return(temp.OrderBy(p => p.Title).ToList()); } finally { entityPermissionManager.Dispose(); dataStructureManager.Dispose(); dm.Dispose(); } }
public async Task <ActionResult> SendDataToDataRepo(long datasetId, string datarepo) { PublicationManager publicationManager = new PublicationManager(); DatasetManager datasetManager = new DatasetManager(); try { string zipfilepath = ""; if (Session["ZipFilePath"] != null) { zipfilepath = Session["ZipFilePath"].ToString(); } DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId); Publication publication = publicationManager.GetPublication() .Where( p => p.DatasetVersion.Id.Equals(datasetVersion.Id) && p.Broker.Name.ToLower().Equals(datarepo.ToLower())) .FirstOrDefault(); if (publication == null) { //ToDo [SUBMISSION] -> create broker specfic function // check case for gfbio if (datarepo.ToLower().Contains("gfbio")) { #region GFBIO //SubmissionManager publishingManager = new SubmissionManager(); //publishingManager.Load(); //DataRepository dataRepository = publishingManager.DataRepositories.Where(d => d.Name.Equals(datarepo)).FirstOrDefault(); Broker broker = publicationManager.GetBroker() .Where(b => b.Name.ToLower().Equals(datarepo.ToLower())) .FirstOrDefault(); if (broker != null) { //Store ro in db string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title); publicationManager.CreatePublication(datasetVersion, broker, title, 0, zipfilepath, "", "no status available"); //sendToGFBIO(broker, datasetId, datasetVersion, zipfilepath); } #endregion } if (datarepo.ToLower().Contains("pensoft")) { #region pensoft Broker broker = publicationManager.BrokerRepo.Get() .Where(b => b.Name.ToLower().Equals(datarepo.ToLower())) .FirstOrDefault(); Repository repository = publicationManager.RepositoryRepo.Get() .Where(b => b.Name.ToLower().Equals(datarepo.ToLower())) .FirstOrDefault(); string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title); publicationManager.CreatePublication(datasetVersion, broker, repository, title, 0, zipfilepath, "", "no status available"); #endregion } if (datarepo.ToLower().Equals("generic")) { #region GENERIC Broker broker = publicationManager.BrokerRepo.Get() .Where(b => b.Name.ToLower().Equals(datarepo.ToLower())) .FirstOrDefault(); string title = xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title); publicationManager.CreatePublication(datasetVersion, broker, title, 0, zipfilepath, "", "created"); #endregion } } else { Json("Publication exist."); } } catch (Exception ex) { return(Json(ex.Message)); } finally { publicationManager.Dispose(); datasetManager.Dispose(); } return(Json(true)); }
/// <summary> /// Submit a Dataset based on the imformations /// in the CreateTaskManager /// </summary> public long SubmitDataset(bool valid) { #region create dataset DatasetManager dm = new DatasetManager(); DataStructureManager dsm = new DataStructureManager(); ResearchPlanManager rpm = new ResearchPlanManager(); XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper(); string title = ""; long datasetId = 0; bool newDataset = true; try { TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"]; if (TaskManager.Bus.ContainsKey(CreateTaskmanager.DATASTRUCTURE_ID) && TaskManager.Bus.ContainsKey(CreateTaskmanager.RESEARCHPLAN_ID) && TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATASTRUCTURE_ID)) { // for e new dataset if (!TaskManager.Bus.ContainsKey(CreateTaskmanager.ENTITY_ID)) { long datastructureId = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.DATASTRUCTURE_ID]); long researchPlanId = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.RESEARCHPLAN_ID]); long metadataStructureId = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.METADATASTRUCTURE_ID]); DataStructure dataStructure = dsm.StructuredDataStructureRepo.Get(datastructureId); //if datastructure is not a structured one if (dataStructure == null) { dataStructure = dsm.UnStructuredDataStructureRepo.Get(datastructureId); } ResearchPlan rp = rpm.Repo.Get(researchPlanId); MetadataStructureManager msm = new MetadataStructureManager(); MetadataStructure metadataStructure = msm.Repo.Get(metadataStructureId); var ds = dm.CreateEmptyDataset(dataStructure, rp, metadataStructure); datasetId = ds.Id; // add security if (GetUsernameOrDefault() != "DEFAULT") { EntityPermissionManager entityPermissionManager = new EntityPermissionManager(); entityPermissionManager.Create <User>(GetUsernameOrDefault(), "Dataset", typeof(Dataset), ds.Id, Enum.GetValues(typeof(RightType)).Cast <RightType>().ToList()); } } else { datasetId = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.ENTITY_ID]); newDataset = false; } TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"]; if (dm.IsDatasetCheckedOutFor(datasetId, GetUsernameOrDefault()) || dm.CheckOutDataset(datasetId, GetUsernameOrDefault())) { DatasetVersion workingCopy = dm.GetDatasetWorkingCopy(datasetId); if (TaskManager.Bus.ContainsKey(CreateTaskmanager.METADATA_XML)) { XDocument xMetadata = (XDocument)TaskManager.Bus[CreateTaskmanager.METADATA_XML]; workingCopy.Metadata = Xml.Helpers.XmlWriter.ToXmlDocument(xMetadata); } //set status if (workingCopy.StateInfo == null) { workingCopy.StateInfo = new Vaiona.Entities.Common.EntityStateInfo(); } if (valid) { workingCopy.StateInfo.State = DatasetStateInfo.Valid.ToString(); } else { workingCopy.StateInfo.State = DatasetStateInfo.NotValid.ToString(); } title = xmlDatasetHelper.GetInformationFromVersion(workingCopy.Id, NameAttributeValues.title); if (string.IsNullOrEmpty(title)) { title = "No Title available."; } TaskManager.AddToBus(CreateTaskmanager.ENTITY_TITLE, title);//workingCopy.Metadata.SelectNodes("Metadata/Description/Description/Title/Title")[0].InnerText); TaskManager.AddToBus(CreateTaskmanager.ENTITY_ID, datasetId); dm.EditDatasetVersion(workingCopy, null, null, null); dm.CheckInDataset(datasetId, "Metadata was submited.", GetUsernameOrDefault(), ViewCreationBehavior.None); //add to index // ToDo check which SearchProvider it is, default luceneprovider // BUG: invalid call to ddm method // TODO: mODULARITY ->Call DDM Reindex /* * <Export tag="internalApi" id="SearchIndex" * title="Reindex Search" description="Reindex Search" icon="" * controller="SearchIndex" action="Get" * extends="" /> */ // WORKAROUND: do not reindex //ISearchProvider provider = IoCFactory.Container.ResolveForSession<ISearchProvider>() as ISearchProvider; //provider?.UpdateSingleDatasetIndex(datasetId, IndexingAction.CREATE); if (this.IsAccessibale("DDM", "SearchIndex", "ReIndexSingle")) { var x = this.Run("DDM", "SearchIndex", "ReIndexSingle", new RouteValueDictionary() { { "id", datasetId } }); } LoggerFactory.LogData(datasetId.ToString(), typeof(Dataset).Name, Vaiona.Entities.Logging.CrudState.Created); if (newDataset) { var es = new EmailService(); es.Send(MessageHelper.GetCreateDatasetHeader(), MessageHelper.GetCreateDatasetMessage(datasetId, title, GetUsernameOrDefault()), ConfigurationManager.AppSettings["SystemEmail"] ); } else { var es = new EmailService(); es.Send(MessageHelper.GetUpdateDatasetHeader(), MessageHelper.GetUpdateDatasetMessage(datasetId, title, GetUsernameOrDefault()), ConfigurationManager.AppSettings["SystemEmail"] ); } } return(datasetId); } } catch (Exception ex) { var es = new EmailService(); es.Send(MessageHelper.GetUpdateDatasetHeader(), ex.Message, ConfigurationManager.AppSettings["SystemEmail"] ); } finally { dm.Dispose(); rpm.Dispose(); dsm.Dispose(); } #endregion create dataset return(-1); }
public ActionResult StoreSelectedDatasetSetup(SetupModel model) { CreateTaskmanager TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"]; DatasetManager datasetManager = new DatasetManager(); XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper(); try { if (model == null) { model = GetDefaultModel(); return(PartialView("Index", model)); } model = LoadLists(model); if (ModelState.IsValid) { TaskManager.AddToBus(CreateTaskmanager.METADATASTRUCTURE_ID, model.SelectedMetadataStructureId); TaskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_ID, model.SelectedDataStructureId); // set datastructuretype TaskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_TYPE, GetDataStructureType(model.SelectedDataStructureId)); //dataset is selected if (model.SelectedDatasetId != 0 && model.SelectedDatasetId != -1) { if (datasetManager.IsDatasetCheckedIn(model.SelectedDatasetId)) { DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(model.SelectedDatasetId); TaskManager.AddToBus(CreateTaskmanager.RESEARCHPLAN_ID, datasetVersion.Dataset.ResearchPlan.Id); TaskManager.AddToBus(CreateTaskmanager.ENTITY_TITLE, xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title)); // set datastructuretype TaskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_TYPE, GetDataStructureType(model.SelectedDataStructureId)); // set MetadataXml From selected existing Dataset XDocument metadata = XmlUtility.ToXDocument(datasetVersion.Metadata); SetXml(metadata); } else { ModelState.AddModelError(string.Empty, "Dataset is just in processing"); } } else { ResearchPlanManager rpm = new ResearchPlanManager(); TaskManager.AddToBus(CreateTaskmanager.RESEARCHPLAN_ID, rpm.Repo.Get().First().Id); } return(RedirectToAction("StartMetadataEditor", "Form")); } return(View("Index", model)); } finally { datasetManager.Dispose(); } }