private void addSelectedDatasetToBus(long datasetId) { using (DatasetManager datasetManager = new DatasetManager()) using (ResearchPlanManager rpm = new ResearchPlanManager()) { 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, datasetVersion.Title); ResearchPlan rp = rpm.Repo.Get(datasetVersion.Dataset.ResearchPlan.Id); TaskManager.AddToBus(TaskManager.RESEARCHPLAN_ID, rp.Id); TaskManager.AddToBus(TaskManager.RESEARCHPLAN_TITLE, rp.Title); } }
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(); } }
public void EditDatasetVersion_DeleteADataTupleAfterUpdate_ReturnUpdatedVersion() { Dataset dataset; DatasetVersion latest; using (DatasetManager datasetManager = new DatasetManager()) { //Arrange dataset = datasetManager.GetDataset(datasetId); latest = datasetManager.GetDatasetLatestVersion(datasetId); //update the dataset dataset = dsHelper.UpdateAnyTupleForDataset(dataset, dataset.DataStructure as StructuredDataStructure, datasetManager); datasetManager.CheckInDataset(datasetId, "for testing update all datatuple", username, ViewCreationBehavior.None); } using (DatasetManager datasetManager = new DatasetManager()) { try { latest = datasetManager.GetDatasetLatestVersion(datasetId); int before = datasetManager.GetDataTuplesCount(latest.Id); var tuple = datasetManager.GetDataTuples(latest.Id).LastOrDefault(); //Act if (datasetManager.IsDatasetCheckedOutFor(datasetId, "David") || datasetManager.CheckOutDataset(datasetId, "David")) { DatasetVersion workingCopy = datasetManager.GetDatasetWorkingCopy(datasetId); List <AbstractTuple> deleteTuples = new List <AbstractTuple>(); deleteTuples.Add(tuple); workingCopy = datasetManager.EditDatasetVersion(workingCopy, null, null, deleteTuples.Select(d => d.Id).ToList()); datasetManager.CheckInDataset(datasetId, "delete one datatuple for testing", username, ViewCreationBehavior.None); } latest = datasetManager.GetDatasetLatestVersion(datasetId); int after = datasetManager.GetDataTuplesCount(latest.Id); //Assert Assert.That(before, Is.GreaterThan(after)); } catch (Exception ex) { throw ex; } } }
public void TransformDatatupleToJson() { //Arrange DatasetManager datasetManager = new DatasetManager(); try { //Act DatasetVersion datasetversion = datasetManager.GetDatasetLatestVersion(datasetId); var result = datasetManager.GetDatasetVersionEffectiveTuples(datasetversion); foreach (var dt in result) { dt.Materialize(); dt.Dematerialize(); } var newDts = result.Cast <DataTuple>(); foreach (var dt in newDts) { //dt.Materialize2(); //dt.Dematerialize2(); // convert variablevalues 1 to json } //Assert Assert.That(result.Count(), Is.EqualTo(numberOfTuples)); foreach (var dt in newDts) { for (int i = 0; i < dt.VariableValues.Count; i++) { var vv1 = dt.VariableValues.ElementAt(i); //var vv2 = dt.VariableValues2.ElementAt(i); //Assert.That(vv1.DataAttribute.Id , Is.EqualTo(vv2.DataAttribute.Id)); //Assert.That(vv1.Note, Is.EqualTo(vv2.Note)); //Assert.That(vv1.ObtainingMethod, Is.EqualTo(vv2.ObtainingMethod)); //Assert.That(vv1.ParameterValues, Is.EqualTo(vv2.ParameterValues)); //Assert.That(vv1.ResultTime, Is.EqualTo(vv2.ResultTime)); //Assert.That(vv1.SamplingTime, Is.EqualTo(vv2.SamplingTime)); //Assert.That(vv1.Tuple.Id, Is.EqualTo(vv2.Tuple.Id)); //Assert.That(vv1.Value, Is.EqualTo(vv2.Value)); //Assert.That(vv1.Variable.Id, Is.EqualTo(vv2.Variable.Id)); //Assert.That(vv1.VariableId, Is.EqualTo(vv2.VariableId)); } } } catch (Exception ex) { throw (ex); } finally { datasetManager.Dispose(); } }
private ApiDatasetAttachmentsModel GetApiDatasetAttachmentsModel(long id, DatasetManager dm) { ApiDatasetAttachmentsModel model = new ApiDatasetAttachmentsModel(); DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(id); if (datasetVersion != null && datasetVersion.ContentDescriptors != null) { model.DatasetId = id; foreach (var cd in datasetVersion.ContentDescriptors) { if (cd != null && cd.URI.ToLower().Contains("attachments")) { ApiSimpleAttachmentModel attachmentModel = new ApiSimpleAttachmentModel(); attachmentModel.Id = cd.Id; attachmentModel.Name = cd.Name; attachmentModel.MimeType = cd.MimeType; model.Attachments.Add(attachmentModel); } } return(model); } return(null); }
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 string GenerateAsciiFile(long id, string title, string mimeType, string[] visibleColumns) { string ext = ""; string path = ""; DatasetManager datasetManager = new DatasetManager(); try { DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(id); AsciiWriter writer = new AsciiWriter(TextSeperator.comma); // Javad: It is better to have a list of tuple IDs and pass it to the AddDataTuples method. // This method is using a special iterator to reduce the number of queries. 18.11.2016 List <long> datatuples = new List <long>(); //GetFilteredDataTuples(datasetVersion); long datastuctureId = datasetVersion.Dataset.DataStructure.Id; path = generateDownloadFile(id, datasetVersion.Id, datastuctureId, "data", ext, writer); if (visibleColumns != null) { writer.VisibleColumns = visibleColumns; } writer.AddDataTuples(datasetManager, datatuples, path, datastuctureId); return(path); } finally { datasetManager.Dispose(); } }
public static string GetSchemaDirectoryPath(long datasetId) { using (DatasetManager datasetManager = new DatasetManager()) using (MetadataStructureManager metadataStructureManager = new MetadataStructureManager()) { try { DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId); MetadataStructure metadataStructure = metadataStructureManager.Repo.Get(datasetVersion.Dataset.MetadataStructure.Id); string path = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DCM"), "Metadata", metadataStructure.Name); if (!String.IsNullOrEmpty(path) && Directory.Exists(path)) { return(path); } } catch (Exception ex) { throw ex; } } return(String.Empty); }
public ActionResult Delete(long datasetId, String fileName) { using (var dm = new DatasetManager()) { var filePath = Path.Combine(AppConfiguration.DataPath, "Datasets", datasetId.ToString(), "Attachments", fileName); FileHelper.Delete(filePath); var dataset = dm.GetDataset(datasetId); var datasetVersion = dm.GetDatasetLatestVersion(dataset); var contentDescriptor = datasetVersion.ContentDescriptors.FirstOrDefault(item => item.Name == fileName); if (contentDescriptor == null) { throw new Exception("There is not any content descriptor having file name '" + fileName + "'. "); } datasetVersion.ContentDescriptors.Remove(contentDescriptor); datasetVersion.ModificationInfo = new EntityAuditInfo() { Performer = GetUsernameOrDefault(), Comment = "Attachment", ActionType = AuditActionType.Delete }; dm.EditDatasetVersion(datasetVersion, null, null, null); dm.CheckInDataset(dataset.Id, fileName, GetUsernameOrDefault(), ViewCreationBehavior.None); } return(RedirectToAction("showdata", "data", new { area = "ddm", id = datasetId })); }
public JsonResult PrepareTxtData(long id) { if (hasUserRights(id, RightType.Read)) { string ext = ".txt"; DatasetManager datasetManager = new DatasetManager(); try { DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(id); AsciiWriter writer = new AsciiWriter(TextSeperator.comma); OutputDataManager ioOutputDataManager = new OutputDataManager(); string title = getTitle(writer.GetTitle(id)); string path = ""; string message = string.Format("dataset {0} version {1} was downloaded as txt.", id, datasetVersion.Id); // if filter selected if (filterInUse()) { #region generate a subset of a dataset String[] visibleColumns = null; if (Session["Columns"] != null) { visibleColumns = (String[])Session["Columns"]; } path = ioOutputDataManager.GenerateAsciiFile(id, title, "text/plain", visibleColumns); LoggerFactory.LogCustom(message); #endregion generate a subset of a dataset } else { path = ioOutputDataManager.GenerateAsciiFile(id, title, "text/plain"); LoggerFactory.LogCustom(message); } return(Json(true, JsonRequestBehavior.AllowGet)); } catch (Exception ex) { return(Json(ex.Message, JsonRequestBehavior.AllowGet)); } finally { datasetManager.Dispose(); } } else { return(Json("User has no rights.", JsonRequestBehavior.AllowGet)); } }
/// <summary> /// returns a value of a metadata node /// </summary> /// <param name="datasetVersion"></param> /// <param name="name"></param> /// <returns></returns> public IEnumerable <string> GetAllTransmissionInformation(long datasetid, TransmissionType type, AttributeNames returnType = AttributeNames.value) { Dataset dataset = this.GetUnitOfWork().GetReadOnlyRepository <Dataset>().Get(datasetid); DatasetManager dm = new DatasetManager(); try { DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(dataset); // get MetadataStructure if (datasetVersion != null && datasetVersion.Dataset != null && datasetVersion.Dataset.MetadataStructure != null && datasetVersion.Dataset.MetadataStructure.Extra != null && datasetVersion.Metadata != null) { return(GetAllTransmissionInformationFromMetadataStructure(datasetVersion.Dataset.MetadataStructure.Id, type, returnType)); } return(null); } finally { dm.Dispose(); } }
public ActionResult ShowPreviewDataStructure(long datasetID) { DatasetManager dm = new DatasetManager(); DataStructureManager dsm = new DataStructureManager(); try { using (var uow = this.GetUnitOfWork()) { long dsId = dm.GetDatasetLatestVersion(datasetID).Id; DatasetVersion ds = uow.GetUnitOfWork().GetReadOnlyRepository <DatasetVersion>().Get(dsId); DataStructure dataStructure = uow.GetReadOnlyRepository <DataStructure>().Get(ds.Dataset.DataStructure.Id); long id = (long)datasetID; Tuple <DataStructure, long> m = new Tuple <DataStructure, long>( dataStructure, id ); return(PartialView("_previewDatastructure", m)); } } catch (Exception ex) { throw ex; } }
// GET: DQManager public ActionResult Index() { DatasetManager dm = new DatasetManager(); //dataset manager ManageDQ manageModel = new ManageDQ(); //DatasetVersion dsv = new DatasetVersion(); //dataset version manager List <long> datasetIds = dm.GetDatasetLatestIds(); //get latest //List<List<long>> matrixId = new List<List<long>>(); List <dataset> datasets = new List <dataset>(); foreach (long Id in datasetIds) //for each dataset { dataset ds = new dataset(); ds.Id = Id; ds.title = dm.GetDatasetLatestVersion(Id).Title; //List<DatasetVersion> datasetVersions = dm.GetDatasetVersions(Id); //List<long> versionIds = new List<long>(); //for (int i = 0; i < datasetVersions.Count; ++i) //{ // long versionId = datasetVersions[i].Id; // versionIds.Add(versionId); //} ////matrixId.Add(versions); //ds.versionIds = versionIds; datasets.Add(ds); } //manageModel.matrixId = matrixId; manageModel.datasets = datasets; return(View(manageModel)); }
public bool HasTransmission(long datasetid, TransmissionType type) { Dataset dataset = this.GetUnitOfWork().GetReadOnlyRepository <Dataset>().Get(datasetid); DatasetManager dm = new DatasetManager(); try { DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(dataset); // get MetadataStructure if (datasetVersion != null && datasetVersion.Dataset != null && datasetVersion.Dataset.MetadataStructure != null && datasetVersion.Dataset.MetadataStructure.Extra != null && datasetVersion.Metadata != null) { MetadataStructure metadataStructure = datasetVersion.Dataset.MetadataStructure; XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)datasetVersion.Dataset.MetadataStructure.Extra); IEnumerable <XElement> temp = XmlUtility.GetXElementsByAttribute(nodeNames.convertRef.ToString(), AttributeNames.type.ToString(), type.ToString(), xDoc); if (temp != null && temp.Any()) { return(true); } } return(false); } finally { dm.Dispose(); } }
public static string GenerateDataStructure(long datasetId) { string path = ""; try { DatasetManager datasetManager = null; try { datasetManager = new DatasetManager(); DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId); DataStructureDataTable dataStructureDataTable = new DataStructureDataTable(datasetId); // store in content descriptor path = storeGeneratedFilePathToContentDiscriptor(datasetId, datasetVersion, "datastructure", ".txt"); } finally { datasetManager.Dispose(); } } catch (Exception ex) { throw ex; } return(path); }
/// <summary> /// Return a metadata as html file from a datasetversion /// </summary> /// <param name="id"></param> /// <returns></returns> public ActionResult GetMetadataAsHtmlFile(long id) { DatasetManager dm = new DatasetManager(); try { using (var uow = this.GetUnitOfWork()) { long dsId = dm.GetDatasetLatestVersion(id).Id; DatasetVersion ds = uow.GetUnitOfWork().GetReadOnlyRepository <DatasetVersion>().Get(dsId); XmlDocument document = OutputMetadataManager.GetConvertedMetadata(id, TransmissionType.mappingFileExport, ds.Dataset.MetadataStructure.Name); string htmlPage = PartialView("SimpleMetadata", document).RenderToString(); byte[] content = Encoding.ASCII.GetBytes(htmlPage); return(File(content, "text/html", "metadata.html")); } } catch (Exception ex) { throw ex; } finally { dm.Dispose(); } }
/// <summary> /// THE ACTIONRESULT FOR SHOW DATASET LIST VIEW /// </summary> /// <param name="datasetIds"></param> /// <param name="performerName"></param> /// <returns></returns> public ActionResult ShowDatasetList() { ExternalLink dsModel = new ExternalLink(); List <datasetInfo> datasetInfos = new List <datasetInfo>(); DatasetManager dm = new DatasetManager(); DataStructureManager dsm = new DataStructureManager(); List <long> datasetIds = dm.GetDatasetLatestIds(); foreach (long Id in datasetIds) { if (dm.IsDatasetCheckedIn(Id)) { DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(Id); //get last dataset versions datasetInfo datasetInfo = new datasetInfo(); datasetInfo.title = datasetVersion.Title; DataStructure dataStr = dsm.AllTypesDataStructureRepo.Get(datasetVersion.Dataset.DataStructure.Id); string type = "file"; if (dataStr.Self.GetType() == typeof(StructuredDataStructure)) { type = "tabular"; } datasetInfo.type = type; datasetInfo.Id = Id; datasetInfos.Add(datasetInfo); } } dsModel.datasetInfos = datasetInfos; return(View(dsModel)); }
// get header public Header GetHeader(long id) { if (id <= 0) { return(null); } DatasetManager datasetManager = new DatasetManager(); try { DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(id); DateTime lastModified = datasetVersion.Timestamp; Header header = new Header(); header.OAI_Identifier = ConvertToOaiId(id); header.OAI_Set = AppConfiguration.ApplicationName; // ToDo what is a oai_set? header.Datestamp = lastModified; //Date Last Modified; header.Deleted = false; header.OAIDataProviderId = -1; return(header); } finally { datasetManager.Dispose(); } }
public JsonResult PrepareExcelData(long id) { if (hasUserRights(id, RightType.Read)) { string ext = ".xlsm"; DatasetManager datasetManager = new DatasetManager(); try { DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(id); ExcelWriter writer = new ExcelWriter(); string title = getTitle(writer.GetTitle(id)); string path = ""; string message = string.Format("dataset {0} version {1} was downloaded as excel.", id, datasetVersion.Id); // if filter selected if (filterInUse()) { #region generate a subset of a dataset //ToDo filter datatuples LoggerFactory.LogCustom(message); #endregion generate a subset of a dataset } //filter not in use else { OutputDataManager outputDataManager = new OutputDataManager(); path = outputDataManager.GenerateExcelFile(id, title); LoggerFactory.LogCustom(message); } return(Json(true, JsonRequestBehavior.AllowGet)); } catch (Exception ex) { return(Json(ex.Message, JsonRequestBehavior.AllowGet)); } finally { datasetManager.Dispose(); } } else { return(Json("User has no rights.", JsonRequestBehavior.AllowGet)); } }
public void EditDatasetVersion_DeleteADataTuple_ReturnUpdatedVersion() { DatasetManager datasetManager = new DatasetManager(); try { //Arrange DatasetVersion latest = datasetManager.GetDatasetLatestVersion(datasetId); int before = datasetManager.GetDataTuplesCount(latest.Id); var tuple = datasetManager.GetDataTuples(latest.Id).LastOrDefault(); //Act if (datasetManager.IsDatasetCheckedOutFor(datasetId, "David") || datasetManager.CheckOutDataset(datasetId, "David")) { DatasetVersion workingCopy = datasetManager.GetDatasetWorkingCopy(datasetId); List <DataTuple> deleteTuples = new List <DataTuple>(); deleteTuples.Add(tuple as DataTuple); workingCopy = datasetManager.EditDatasetVersion(workingCopy, null, null, deleteTuples.Select(d => d.Id).ToList()); datasetManager.CheckInDataset(datasetId, "delete one datatuple for testing", username, ViewCreationBehavior.None); } latest = datasetManager.GetDatasetLatestVersion(datasetId); int after = datasetManager.GetDataTuplesCount(latest.Id); //Assert Assert.That(before, Is.GreaterThan(after)); } catch (Exception ex) { throw ex; } finally { datasetManager.Dispose(); } }
[TestCase(2)] // primary key as double public void GetSplitDatatuples_AllDataTuplesEdited_SameNumberOfDatatuples(int primaryKeyIndex) { Dataset dataset; DatasetVersion latest; List <DataTuple> incoming = new List <DataTuple>(); int count = 0; int expectedCount = 0; List <long> datatupleFromDatabaseIds = new List <long>(); using (DatasetManager datasetManager = new DatasetManager()) { //Arrange dataset = datasetManager.GetDataset(datasetId); latest = datasetManager.GetDatasetLatestVersion(datasetId); datatupleFromDatabaseIds = datasetManager.GetDatasetVersionEffectiveTupleIds(latest); //get updated tuples as incoming datatuples incoming = dsHelper.GetUpdatedDatatuples(latest, dataset.DataStructure as StructuredDataStructure, datasetManager); //because of updateing all datatuples the incoming number is should be equal then the existing one expectedCount = incoming.Count; } try { List <long> primaryKeys = new List <long>(); //get primarykey ids // var 1 = int = 1 // var 2 = string = 2 // var 3 = double = 3 // var 4 = boolean = 4 // var 5 = datetime = 5 List <long> varIds = ((StructuredDataStructure)dataset.DataStructure).Variables.Select(v => v.Id).ToList(); primaryKeys.Add(varIds.ElementAt(primaryKeyIndex)); //Act Dictionary <string, List <DataTuple> > splittedDatatuples = new Dictionary <string, List <DataTuple> >(); UploadHelper uploadhelper = new UploadHelper(); splittedDatatuples = uploadhelper.GetSplitDatatuples(incoming, primaryKeys, null, ref datatupleFromDatabaseIds); //Assert int newCount = splittedDatatuples["new"].Count; int editCount = splittedDatatuples["edit"].Count; Assert.That(newCount, Is.EqualTo(0)); Assert.That(editCount, Is.EqualTo(expectedCount)); } catch (Exception ex) { throw ex; } }
// 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 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 void GetDataTuples_CallOlderVersionAfterTwoUpdates_ReturnIQueryable() { List <long> datatupleIds; try { //Arrange using (var datasetManager = new DatasetManager()) { var dataset = datasetManager.GetDataset(datasetId); var datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId); Assert.IsNotNull(dataset); Assert.IsNotNull(datasetVersion); //get latest datatupleid before create a new dataset and data using (var uow = this.GetUnitOfWork()) { datatupleIds = uow.GetReadOnlyRepository <DataTuple>().Get().Where(dt => dt.DatasetVersion.Id.Equals(datasetVersion.Id)).Select(dt => dt.Id).ToList(); } dataset = dsHelper.UpdateOneTupleForDataset(dataset, (StructuredDataStructure)dataset.DataStructure, datatupleIds[0], 1000, datasetManager); datasetManager.CheckInDataset(dataset.Id, "for testing datatuples with versions", username, ViewCreationBehavior.None); dataset = dsHelper.UpdateOneTupleForDataset(dataset, (StructuredDataStructure)dataset.DataStructure, datatupleIds[1], 2000, datasetManager); datasetManager.CheckInDataset(dataset.Id, "for testing datatuples with versions", username, ViewCreationBehavior.None); } //Act using (var datasetManager = new DatasetManager()) { List <DatasetVersion> datasetversions = datasetManager.GetDatasetVersions(datasetId).OrderBy(d => d.Timestamp).ToList(); Assert.That(datasetversions.Count, Is.EqualTo(3)); foreach (var dsv in datasetversions) { int c = datasetManager.GetDataTuplesCount(dsv.Id); var result = datasetManager.GetDataTuples(dsv.Id); // get datatuples from the one before the latest int cm = result.Count(); Assert.That(c, Is.EqualTo(10)); Assert.That(c, Is.EqualTo(result.Count())); } } } catch (Exception ex) { throw ex; } }
public Dataset UpdateAnyTupleForDataset(Dataset dataset, StructuredDataStructure dataStructure) { dataset.Status.Should().Be(DatasetStatus.CheckedIn); dataset.Should().NotBeNull(); DatasetManager dm = new DatasetManager(); try { DatasetVersion dsv = dm.GetDatasetLatestVersion(dataset.Id); var datatuples = dm.GetDataTuples(dsv.Id); if (dm.IsDatasetCheckedOutFor(dataset.Id, "David") || dm.CheckOutDataset(dataset.Id, "David")) { dataset.Status.Should().Be(DatasetStatus.CheckedOut, "Dataset must be in Checkedout status."); DatasetVersion workingCopy = dm.GetDatasetWorkingCopy(dataset.Id); List <DataTuple> editedTuples = new List <DataTuple>(); foreach (var dataTuple in datatuples) { var vv = dataTuple.VariableValues.Where(v => v.VariableId.Equals(dataStructure.Variables.Skip(4).First().Id)).FirstOrDefault(); if (vv != null) { vv.Value = DateTime.Now.ToString(); } dataTuple.Dematerialize(); dataTuple.Should().NotBeNull(); //dataTuple.XmlVariableValues.Should().NotBeNull(); dataTuple.Materialize(); editedTuples.Add((DataTuple)dataTuple); } dm.EditDatasetVersion(workingCopy, null, editedTuples, null); dataset.Status.Should().Be(DatasetStatus.CheckedOut, "Dataset must be in Checkedout status."); } return(dataset); } catch (Exception ex) { return(null); } finally { dm.Dispose(); } }
public void GetSplitDatatuples_CombinedPrimaryKeyOneUpdatedDataTuple_ExpectedNumberOfEditDatatuples() { Dataset dataset; DatasetVersion latest; List <DataTuple> incoming = new List <DataTuple>(); int count = 0; int expectedCount = 0; List <long> datatupleFromDatabaseIds = new List <long>(); //setup the primary key conbination List <int> primaryKeysIndex = new List <int> { 0, 2 }; List <long> primaryKeyIds = new List <long>(); using (DatasetManager datasetManager = new DatasetManager()) { //Arrange dataset = datasetManager.GetDataset(datasetId); latest = datasetManager.GetDatasetLatestVersion(datasetId); datatupleFromDatabaseIds = datasetManager.GetDatasetVersionEffectiveTupleIds(latest); foreach (var dtid in datatupleFromDatabaseIds) { var datatuple = datasetManager.DataTupleRepo.Get(dtid); datatuple.Materialize(); incoming.Add(datatuple); } //updated last datatuple in text dsHelper.GetUpdatedDatatuple(incoming.Last(), 1); //get varids of primary key combination List <long> allVarIds = ((StructuredDataStructure)dataset.DataStructure).Variables.Select(v => v.Id).ToList(); foreach (int pkIndex in primaryKeysIndex) { primaryKeyIds.Add(allVarIds.ElementAt(pkIndex)); } //Act Dictionary <string, List <DataTuple> > splittedDatatuples = new Dictionary <string, List <DataTuple> >(); UploadHelper uploadhelper = new UploadHelper(); splittedDatatuples = uploadhelper.GetSplitDatatuples(incoming, primaryKeyIds, null, ref datatupleFromDatabaseIds); //Assert Assert.That(splittedDatatuples["new"].Count, Is.EqualTo(0)); Assert.That(splittedDatatuples["edit"].Count, Is.EqualTo(1)); } }
/// <summary> /// /// </summary> /// <param name="datasetid"></param> /// <param name="name"></param> /// <returns></returns> public string GetInformation(long datasetid, NameAttributeValues name) { DatasetManager dm = new DatasetManager(); try { DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(datasetid); return(GetInformationFromVersion(datasetVersion.Id, name)); } finally { dm.Dispose(); } }
/// <summary> /// Information in metadata is stored as xml /// get back the vale of an attribute /// e.g. title = "dataset title" /// </summary> /// <param name="dataset"></param> /// <param name="name"></param> /// <returns></returns> public string GetInformation(Dataset dataset, NameAttributeValues name) { DatasetManager dm = new DatasetManager(); try { DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(dataset); return(GetInformationFromVersion(datasetVersion.Id, dataset.MetadataStructure.Id, name)); } finally { dm.Dispose(); } }
public static XmlDocument GetConvertedMetadata(long datasetId, TransmissionType type, string mappingName, bool storing = true) { using (DatasetManager datasetManager = new DatasetManager()) { XmlDocument newXml; try { DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId); XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper(); string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName); // no mapping files with mappingName exist if (string.IsNullOrEmpty(mappingFileName)) { return(null); } 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 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); } }
// GET: api/Metadata/5 // HttpResponseMessage response = new HttpResponseMessage { Content = new StringContent(doc.innerXml, Encoding.UTF8,"application/xml") }; public HttpResponseMessage Get(int id) { DatasetManager dm = new DatasetManager(); try { string convertTo = ""; try { convertTo = this.Request.GetQueryNameValuePairs().FirstOrDefault(p => "format".Equals(p.Key, StringComparison.InvariantCultureIgnoreCase)).Value; } catch (Exception ex) { } DatasetVersion dsv = dm.GetDatasetLatestVersion(id); XmlDocument xmldoc = dsv.Metadata; if (string.IsNullOrEmpty(convertTo)) { //return xmldoc; HttpResponseMessage response = new HttpResponseMessage { Content = new StringContent(xmldoc.InnerXml, Encoding.UTF8, "application/xml") }; return(response); } else { try { XmlDocument newXmlDoc = OutputMetadataManager.GetConvertedMetadata(id, TransmissionType.mappingFileExport, convertTo); HttpResponseMessage response = new HttpResponseMessage { Content = new StringContent(newXmlDoc.InnerXml, Encoding.UTF8, "application/xml") }; return(response); } catch (Exception ex) { return(null); } } } finally { dm.Dispose(); } }