private DataStructureType GetDataStructureType(long id) { DataStructureManager dataStructureManager = new DataStructureManager(); try { DataStructure dataStructure = dataStructureManager.AllTypesDataStructureRepo.Get(id); if (dataStructure is StructuredDataStructure) { return(DataStructureType.Structured); } if (dataStructure is UnStructuredDataStructure) { return(DataStructureType.Unstructured); } return(DataStructureType.Structured); } finally { dataStructureManager.Dispose(); } }
public List <ListViewItemWithType> LoadDataStructureViewList() { DataStructureManager dsm = new DataStructureManager(); try { List <ListViewItemWithType> temp = new List <ListViewItemWithType>(); foreach (DataStructure dataStructure in dsm.AllTypesDataStructureRepo.Get()) { string title = dataStructure.Name; string type = ""; if (dataStructure is StructuredDataStructure) { type = "structured"; } if (dataStructure is UnStructuredDataStructure) { type = "unstructured"; } temp.Add(new ListViewItemWithType(dataStructure.Id, title, dataStructure.Description, type)); } return(temp.OrderBy(p => p.Title).ToList()); } finally { dsm.Dispose(); } }
public ActionResult Index(long DataStructureId = 0) { ViewBag.Title = PresentationModel.GetViewTitleForTenant("Data Structure Edit", this.Session.GetTenant()); DataStructureManager dsm = null; try { dsm = new DataStructureManager(); if (DataStructureId != 0 && dsm.StructuredDataStructureRepo.Get(DataStructureId) != null) { return(View(DataStructureId)); } else if (DataStructureId == 0) { return(View(DataStructureId)); } else { return(RedirectToAction("Index", "DataStructureSearch")); } } finally { dsm.Dispose(); } }
/// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> public DataStructureTree() { dataStructureTreeList = new List <DataStructureTreeList>(); DataStructureManager dataStructureManager = null; try { dataStructureManager = new DataStructureManager(); DataStructureTreeList treeList = new DataStructureTreeList(); if (dataStructureManager.StructuredDataStructureRepo.Get() != null) { treeList = new DataStructureTreeList(dataStructureManager.StructuredDataStructureRepo.Get()); } dataStructureTreeList.Add(treeList); if (dataStructureManager.UnStructuredDataStructureRepo.Get() != null) { treeList = new DataStructureTreeList(dataStructureManager.UnStructuredDataStructureRepo.Get()); } dataStructureTreeList.Add(treeList); } finally { dataStructureManager.Dispose(); } }
/// <summary> /// load list of variables based on the dataset id /// </summary> /// <param name="datasetId"></param> /// <returns></returns> public SelectList GetVariables(long datasetId) { if (datasetId <= 0) { throw new Exception("Id is missing."); } using (var datasetManager = new DatasetManager()) using (var dataStructureManager = new DataStructureManager()) { // load dataset and get datasturctureid var dataset = datasetManager.GetDataset(datasetId); if (dataset == null) { throw new Exception("Dataset with id " + datasetId + " not exist"); } var structure = dataStructureManager.StructuredDataStructureRepo.Get(dataset.DataStructure.Id); // check if datastrutcure is structured if (structure == null) { throw new Exception("Datastructure is not structured"); } if (structure.Variables.Any()) { // return list of vairables als selection list return(new SelectList(structure.Variables.Select(v => v.Label))); } } return(new SelectList(new List <string>())); }
//[MeasurePerformance] public static DataTable ConvertPrimaryDataToDatatable(DatasetManager datasetManager, DatasetVersion datasetVersion, string tableName = "", bool useLabelsAsColumnNames = false) { DataStructureManager dsm = new DataStructureManager(); try { DataTable dt = new DataTable(); if (string.IsNullOrEmpty(tableName)) { dt.TableName = "Primary data table"; } else { dt.TableName = tableName; } StructuredDataStructure sds = dsm.StructuredDataStructureRepo.Get(datasetVersion.Dataset.DataStructure.Id); var tupleIds = datasetManager.GetDatasetVersionEffectiveTupleIds(datasetVersion); if (tupleIds != null && tupleIds.Count > 0 && sds != null) { buildTheHeader(sds, useLabelsAsColumnNames, dt); buildTheBody(datasetManager, tupleIds, dt, sds, useLabelsAsColumnNames); } return(dt); } finally { dsm.Dispose(); } }
public FileResult downloadTemplate(long id) { if (id != 0) { DataStructureManager dataStructureManager = null; try { dataStructureManager = new DataStructureManager(); StructuredDataStructure dataStructure = new StructuredDataStructure(); dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(id); if (dataStructure != null) { ExcelTemplateProvider provider = new ExcelTemplateProvider("BExISppTemplate_Clean.xlsm"); string path = Path.Combine(AppConfiguration.DataPath, provider.CreateTemplate(dataStructure)); return(File(path, MimeMapping.GetMimeMapping(path), Path.GetFileName(path))); } } finally { dataStructureManager.Dispose(); } } return(File(Path.Combine(AppConfiguration.GetModuleWorkspacePath("RPM"), "Template", "BExISppTemplate_Clean.xlsm"), "application/xlsm", "Template_" + id + "_No_Data_Structure.xlsm")); }
/// <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)); }
/// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> /// <param name="dataStrctureId"></param> public void deleteTemplate(long dataStrctureId) { DataStructureManager DSM = new DataStructureManager(); StructuredDataStructure dataStructure = DSM.StructuredDataStructureRepo.Get(dataStrctureId); string path = ""; try { XmlNode resources = dataStructure.TemplatePaths.FirstChild; XmlNodeList resource = resources.ChildNodes; foreach (XmlNode x in resource) { path = Path.Combine(AppConfiguration.DataPath, x.Attributes.GetNamedItem("Path").Value); if (File.Exists(path)) { File.Delete(path); } } path = Path.Combine(AppConfiguration.DataPath, "DataStructures", dataStructure.Id.ToString()); if (Directory.Exists(path) && !(Directory.EnumerateFileSystemEntries(path).Any())) { Directory.Delete(path); } } catch { } }
//private FileStream loadFile (string file) //{ // if (File.Exists(file)) // return File.Open(file, FileMode.Open, FileAccess.ReadWrite); // else // return null; //} /// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> /// <param name="id"></param> public void CreateTemplate(long id) { DataStructureManager dataStructureManager = new DataStructureManager(); StructuredDataStructure dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(id); CreateTemplate(dataStructure); }
/// <summary> /// Add Datatuples to a Excel Template file /// </summary> /// <remarks></remarks> /// <seealso cref=""/> /// <param name="dataTuples"> Datatuples to add</param> /// <param name="filePath">Path of the excel template file</param> /// <param name="dataStructureId">Id of datastructure</param> /// <returns>List of Errors or null</returns> public List <Error> AddDataTuples(DatasetManager datasetManager, List <long> dataTuplesIds, string filePath, long dataStructureId) { if (File.Exists(filePath)) { using (DataStructureManager dataStructureManager = new DataStructureManager()) { dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId); // setup file Init(filePath, dataStructureId); // add header StructuredDataStructure sds = GetDataStructure(dataStructureId); AddHeader(sds); // iterate over all input rows DataTupleIterator tupleIterator = new DataTupleIterator(dataTuplesIds, datasetManager); foreach (var tuple in tupleIterator) { // add row and increment current index if (AddRow(tuple, rowIndex) && !tuple.Id.Equals(dataTuplesIds.Last())) { rowIndex += 1; } } // close the excel file Close(); } } return(ErrorMessages); }
public DataTable ConvertDatasetVersion(DatasetManager datasetManager, DatasetVersion datasetVersion, string tableName = "") { DataTable dt = new DataTable(); if (string.IsNullOrEmpty(tableName)) { dt.TableName = "Primary data table"; } else { dt.TableName = tableName; } using (DataStructureManager dsm = new DataStructureManager()) { StructuredDataStructure sds = dsm.StructuredDataStructureRepo.Get(datasetVersion.Dataset.DataStructure.Id); var tupleIds = datasetManager.GetDatasetVersionEffectiveTupleIds(datasetVersion); if (tupleIds != null && tupleIds.Count > 0 && sds != null) { buildTheHeader(sds, dt); buildTheBody(datasetManager, tupleIds, dt, sds); } } return(dt); }
/// <summary> /// add all rows of the given list to a file using the given datastructure /// </summary> /// <param name="rows"></param> /// <param name="filePath"></param> /// <param name="dataStructureId"></param> /// <returns></returns> public List <Error> AddData(DataRowCollection rows, string filePath, long dataStructureId) { if (File.Exists(filePath)) { using (DataStructureManager dataStructureManager = new DataStructureManager()) { dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId); if (rowIndex == 0) { rowIndex = 1; } // setup excel file Init(filePath, dataStructureId); // iterate over all input rows foreach (DataRow row in rows) { // add row and increment current index if (AddRow(row, rowIndex)) { rowIndex += 1; } } // close the excel file Close(); } } return(ErrorMessages); }
private string[] getUnits(long datastuctureId, string[] columns) { using (DataStructureManager datasetStructureManager = new DataStructureManager()) { List <string> units = new List <string>(); try { var sds = datasetStructureManager.StructuredDataStructureRepo.Get(datastuctureId); if (sds != null) { var varList = sds.Variables.ToList(); if (columns != null && columns.Count() > 0) { varList = varList.Where(v => columns.Contains(v.Label)).ToList(); } varList.ForEach(v => units.Add(v.Unit.Abbreviation)); } return(units.ToArray()); } finally { datasetStructureManager.Dispose(); } } }
public StructuredDataStructurePreviewModel fill(long dataStructureId) { using (DataStructureManager dataStructureManager = new DataStructureManager()) { StructuredDataStructure datastructure = dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId); VariablePreview variablePreview = new VariablePreview(); if (datastructure != null) { foreach (Variable v in DataStructureIO.getOrderedVariables(datastructure)) { v.Unit = v.Unit ?? new Unit(); v.DataAttribute = v.DataAttribute ?? new DataAttribute(); v.DataAttribute.DataType = v.DataAttribute.DataType ?? new DataType(); variablePreview = new VariablePreview(); variablePreview.Id = v.Id; variablePreview.Label = v.Label; variablePreview.Description = v.Description; variablePreview.isOptional = v.IsValueOptional; variablePreview.Unit = v.Unit.Name; variablePreview.DataType = v.DataAttribute.DataType.Name; variablePreview.SystemType = v.DataAttribute.DataType.SystemType; this.VariablePreviews.Add(variablePreview); } return(this); } else { return(new StructuredDataStructurePreviewModel()); } } }
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; } }
private static XmlDocument createOderNode(StructuredDataStructure structuredDataStructure) { DataStructureManager dsm = new DataStructureManager(); XmlDocument doc = (XmlDocument)structuredDataStructure.Extra; XmlNode order; if (doc == null) { doc = new XmlDocument(); XmlNode root = doc.CreateNode(XmlNodeType.Element, "extra", null); doc.AppendChild(root); } if (doc.GetElementsByTagName("order").Count == 0) { if (structuredDataStructure.Variables.Count > 0) { order = doc.CreateNode(XmlNodeType.Element, "order", null); foreach (Variable v in structuredDataStructure.Variables) { XmlNode variable = doc.CreateNode(XmlNodeType.Element, "variable", null); variable.InnerText = v.Id.ToString(); order.AppendChild(variable); } doc.FirstChild.AppendChild(order); structuredDataStructure.Extra = doc; dsm.UpdateStructuredDataStructure(structuredDataStructure); } } return(doc); }
/// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> /// <param name="variableIds"></param> /// <param name="dataStructureId"></param> /// <param name="path"></param> /// <param name="filename"></param> /// <returns></returns> public SpreadsheetDocument CreateTemplate(List <long> variableIds, long dataStructureId, string path, string filename) { DataStructureManager dataStructureManager = null; try { dataStructureManager = new DataStructureManager(); StructuredDataStructure dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId); if (dataStructure != null) { //List<Variable> variables = dataStructure.Variables.Where(p => variableIds.Contains(p.Id)).ToList(); //variables = getOrderedVariables(variables); return(CreateTemplate(variableIds, path, filename)); } else { return(null); } } finally { dataStructureManager.Dispose(); } }
public string CreateTemplate(StructuredDataStructure dataStructure) { DataStructureManager dataStructureManager = null; try { dataStructureManager = new DataStructureManager(); //List<Variable> variables = getOrderedVariables(dataStructure); string rgxPattern = "[<>?\":|\\\\/*]"; string rgxReplace = "-"; Regex rgx = new Regex(rgxPattern); string filename = filename = dataStructure.Id + "_" + rgx.Replace(dataStructure.Name, rgxReplace) + ".xlsm"; string path = Path.Combine("DataStructures", dataStructure.Id.ToString()); CreateTemplate(dataStructure.Variables.Select(p => p.Id).ToList(), path, filename); XmlDocument resources = new XmlDocument(); resources.LoadXml("<Resources><Resource Type=\"Excel\" Edition=\"2010\" Path=\"" + Path.Combine(path, filename) + "\"></Resource></Resources>"); dataStructure = this.GetUnitOfWork().GetReadOnlyRepository <StructuredDataStructure>().Get(dataStructure.Id); //Javad: This line should not be here, but I could not find where oes the dataStructure come from!! dataStructure.TemplatePaths = resources; dataStructureManager.UpdateStructuredDataStructure(dataStructure); return(Path.Combine(path, filename)); } finally { dataStructureManager.Dispose(); } }
private bool unitInUse(Unit unit) { DataStructureManager dataStructureManager = null; DataContainerManager dataAttributeManager = null; try { dataAttributeManager = new DataContainerManager(); dataStructureManager = new DataStructureManager(); bool inUse = false; if (unit.Name.ToLower() == "none") { inUse = true; } else if (dataAttributeManager.DataAttributeRepo.Query(d => d.Unit.Id.Equals(unit.Id)).Count() > 0) { inUse = true; } else if (dataStructureManager.VariableRepo.Query(d => d.Unit.Id.Equals(unit.Id)).Count() > 0) { inUse = true; } return(inUse); } finally { dataAttributeManager.Dispose(); dataStructureManager.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")); }
public DataStructureResultsModel fill(long[] previewIds, string saerchTerms) { DataStructureResultStruct dataStructureResult = new DataStructureResultStruct(); DataStructureManager dataStructureManager = null; try { dataStructureManager = new DataStructureManager(); foreach (DataStructure ds in getStucturedDataStructures(saerchTerms, dataStructureManager)) { dataStructureResult = new DataStructureResultStruct(); dataStructureResult.Id = ds.Id; dataStructureResult.Title = ds.Name; dataStructureResult.Description = ds.Description; if (ds.Datasets.Count > 0) { dataStructureResult.inUse = true; } dataStructureResult.Structured = true; if (previewIds != null && previewIds.Contains(ds.Id)) { dataStructureResult.Preview = true; } this.dataStructureResults.Add(dataStructureResult); } foreach (DataStructure ds in getUnStucturedDataStructures(saerchTerms, dataStructureManager)) { dataStructureResult = new DataStructureResultStruct(); dataStructureResult.Id = ds.Id; dataStructureResult.Title = ds.Name; dataStructureResult.Description = ds.Description; if (ds.Datasets.Count > 0) { dataStructureResult.inUse = true; } if (previewIds != null && previewIds.Contains(ds.Id)) { dataStructureResult.Preview = true; } this.dataStructureResults.Add(dataStructureResult); } return(this); } finally { dataStructureManager.Dispose(); } }
public List <Variable> getOrderedVariables(StructuredDataStructure structuredDataStructure) { DataStructureManager dsm = null; try { dsm = new DataStructureManager(); XmlDocument doc = (XmlDocument)structuredDataStructure.Extra; XmlNode order; if (doc == null) { doc = new XmlDocument(); XmlNode root = doc.CreateNode(XmlNodeType.Element, "extra", null); doc.AppendChild(root); } if (doc.GetElementsByTagName("order").Count == 0) { if (structuredDataStructure.Variables.Count > 0) { order = doc.CreateNode(XmlNodeType.Element, "order", null); foreach (Variable v in structuredDataStructure.Variables) { XmlNode variable = doc.CreateNode(XmlNodeType.Element, "variable", null); variable.InnerText = v.Id.ToString(); order.AppendChild(variable); } doc.FirstChild.AppendChild(order); structuredDataStructure.Extra = doc; dsm.UpdateStructuredDataStructure(structuredDataStructure); } } order = doc.GetElementsByTagName("order")[0]; List <Variable> orderedVariables = new List <Variable>(); if (structuredDataStructure.Variables.Count != 0) { foreach (XmlNode x in order) { foreach (Variable v in structuredDataStructure.Variables) { if (v.Id == Convert.ToInt64(x.InnerText)) { orderedVariables.Add(v); } } } } return(orderedVariables); } finally { dsm.Dispose(); } }
public ActionResult deleteDataStructure(long Id, string cssId = "") { MessageModel DataStructureDeleteValidation = MessageModel.validateDataStructureDelete(Id); if (DataStructureDeleteValidation.hasMessage) { return(PartialView("_messageWindow", DataStructureDeleteValidation)); } else { DataStructureManager dataStructureManager = null; MissingValueManager missingValueManager = null; try { dataStructureManager = new DataStructureManager(); missingValueManager = new MissingValueManager(); var structureRepo = dataStructureManager.GetUnitOfWork().GetReadOnlyRepository <StructuredDataStructure>(); StructuredDataStructure structuredDataStructure = structureRepo.Get(Id); if (structuredDataStructure != null) // Javad: This one retrieves the entity withough using it, and then the next line agian fetches the same! { DataStructureIO.deleteTemplate(structuredDataStructure.Id); foreach (Variable v in structuredDataStructure.Variables) { List <MissingValue> missingValues = missingValueManager.Repo.Query(mv => mv.Variable.Id.Equals(v.Id)).ToList(); foreach (MissingValue mv in missingValues) { missingValueManager.Delete(mv); } dataStructureManager.RemoveVariableUsage(v); } dataStructureManager.DeleteStructuredDataStructure(structuredDataStructure); LoggerFactory.LogData(structuredDataStructure.Id.ToString(), typeof(DataStructure).Name, Vaiona.Entities.Logging.CrudState.Deleted); } else { var unStructureRepo = dataStructureManager.GetUnitOfWork().GetReadOnlyRepository <UnStructuredDataStructure>(); UnStructuredDataStructure unStructuredDataStructure = unStructureRepo.Get(Id); dataStructureManager.DeleteUnStructuredDataStructure(unStructuredDataStructure); LoggerFactory.LogData(unStructuredDataStructure.Id.ToString(), typeof(DataStructure).Name, Vaiona.Entities.Logging.CrudState.Deleted); } return(PartialView("_message", new MessageModel() { Message = "DataStructure" + Id + "deleted", hasMessage = false, CssId = "deleted" })); } finally { dataStructureManager.Dispose(); missingValueManager.Dispose(); } } }
/// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> /// <param name="id"></param> /// <returns></returns> protected StructuredDataStructure GetDataStructure(long id) { if (dataStructure == null) { DataStructureManager dataStructureManager = new DataStructureManager(); dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(id); } return(dataStructure); }
/// <summary> /// /// </summary> /// <remarks></remarks> /// <seealso cref=""/> /// <param name="ID"></param> /// <param name="structured"></param> /// <returns></returns> public DataStructure GetDataStructureByID(long ID, bool structured) { this.structured = structured; if (structured) { return(this.GetDataStructureByID(ID)); } else { DataStructureManager dsm = null; try { dsm = new DataStructureManager(); UnStructuredDataStructure unStructuredDataStructure = dsm.UnStructuredDataStructureRepo.Get(ID); this.dataStructure = unStructuredDataStructure; if (this.dataStructure != null) { this.variableStructs = null; if (this.dataStructure.Datasets == null) { inUse = false; } else { if (this.dataStructure.Datasets.Count > 0) { inUse = true; //DatasetListElement datasetListElement = new DatasetListElement(); //DatasetManager dm = new DatasetManager(); //foreach (Dataset d in unStructuredDataStructure.Datasets) //{ // datasetListElement = new DatasetListElement(d.Id, XmlDatasetHelper.GetInformation(d,AttributeNames.title)); // datasets.Add(datasetListElement); //} } else { inUse = false; } } return(unStructuredDataStructure); } else { this.dataStructure = new StructuredDataStructure(); return(unStructuredDataStructure); } } finally { dsm.Dispose(); } } }
public DataStructurePreviewModel fill(long dataStructureId) { if (dataStructureId > 0) { DataStructureManager dataStructureManager = null; try { dataStructureManager = new DataStructureManager(); if (dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId) != null) { StructuredDataStructure dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId); VariablePreviewStruct variablePreview; this.Id = dataStructure.Id; this.Name = dataStructure.Name; this.Description = dataStructure.Description; if (dataStructure.Datasets.Count > 0) { this.inUse = true; } foreach (Variable v in DataStructureIO.getOrderedVariables(dataStructure)) { variablePreview = new VariablePreviewStruct().fill(v); this.VariablePreviews.Add(variablePreview); } } else if (dataStructureManager.UnStructuredDataStructureRepo.Get(dataStructureId) != null) { UnStructuredDataStructure dataStructure = dataStructureManager.UnStructuredDataStructureRepo.Get(dataStructureId); this.Id = dataStructure.Id; this.Name = dataStructure.Name; this.Description = dataStructure.Description; this.VariablePreviews = null; if (dataStructure.Datasets.Count > 0) { this.inUse = true; } } return(this); } finally { dataStructureManager.Dispose(); } } else { return(new DataStructurePreviewModel()); } }
private List <DataStructure> getStucturedDataStructures(string searchTerms, DataStructureManager dataStructureManager) { if (String.IsNullOrEmpty(searchTerms)) { return(dataStructureManager.StructuredDataStructureRepo.Get().Cast <DataStructure>().ToList()); } else { return(getSearchResult(dataStructureManager.StructuredDataStructureRepo.Get().Cast <DataStructure>().ToList(), searchTerms)); } }
//[RecordCall] //[LogExceptions] //[Diagnose] //[MeasurePerformance] private UiTestModel DynamicListToDataTable() { DataStructureManager dm = new DataStructureManager(); UiTestModel model = new UiTestModel(); model.DataTable = BexisDataHelper.ToDataTable <DataStructure>(dm.AllTypesDataStructureRepo.Get(), new List <string> { "Id", "Name", "Description", "CreationInfo" }); model.DataTable2 = model.DataTable; return(model); }
public JsonResult DisplayPattern(long id, string variable) { //id less then 1 is not possible so return empty string if (id <= 0) { return(Json("", JsonRequestBehavior.AllowGet)); } using (var datasetManager = new DatasetManager()) using (var dataStructureManager = new DataStructureManager()) using (var dataContainerManager = new DataContainerManager()) using (var dataTypeManager = new DataTypeManager()) { var dataset = datasetManager.GetDataset(id); if (dataset == null) { return(Json("", JsonRequestBehavior.AllowGet)); } var datastructureId = dataset.DataStructure.Id; var datastructure = dataStructureManager.StructuredDataStructureRepo.Get(datastructureId); var v = datastructure.Variables.Where(var => var.Label.ToLower().Equals(variable.ToLower())).FirstOrDefault(); //if variable not exit return false if (v == null) { return(Json("", JsonRequestBehavior.AllowGet)); } if (v.DataAttribute != null) { var attr = dataContainerManager.DataAttributeRepo.Get(v.DataAttribute.Id); if (attr.DataType.SystemType.Equals("DateTime")) { var dataType = dataTypeManager.Repo.Get(attr.DataType.Id); if (dataType != null && dataType.Extra != null) { DataTypeDisplayPattern dp = DataTypeDisplayPattern.Materialize(dataType.Extra); if (dp != null) { return(Json(dp.StringPattern, JsonRequestBehavior.AllowGet)); } } } } } return(Json("", JsonRequestBehavior.AllowGet)); }