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));
}
