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