public void GetDatasetVersionEffectiveDataTuples_CalledOlderVersionWithPaging_ReturnListOfAbstractTuples()
{
//Arrange
DatasetManager datasetManager = null;
int pageSize = 4;
int pageNumber = 2;
try
{
datasetManager = new DatasetManager();
var latestDatasetVersionId = datasetManager.GetDatasetLatestVersionId(datasetId);
//get latest datatupleid before create a new dataset and data
using (var uow = this.GetUnitOfWork())
{
var latestDataTuple = uow.GetReadOnlyRepository <DataTuple>().Get().LastOrDefault();
var firstDataTuple = uow.GetReadOnlyRepository <DataTuple>().Get().Where(dt => dt.DatasetVersion.Id.Equals(latestDatasetVersionId)).FirstOrDefault();
if (latestDataTuple != null)
{
latestDataTupleId = latestDataTuple.Id;
}
if (firstDataTuple != null)
{
firstDataTupleId = firstDataTuple.Id;
}
}
var dataset = datasetManager.GetDataset(datasetId);
dataset = dsHelper.UpdateOneTupleForDataset(dataset, (StructuredDataStructure)dataset.DataStructure, firstDataTupleId, 1, datasetManager);
datasetManager.CheckInDataset(dataset.Id, "for testing datatuples with versions", username, ViewCreationBehavior.None);
dataset = dsHelper.UpdateOneTupleForDataset(dataset, (StructuredDataStructure)dataset.DataStructure, latestDataTupleId, 2, datasetManager);
datasetManager.CheckInDataset(dataset.Id, "for testing datatuples with versions", username, ViewCreationBehavior.None);
//Act
List <DatasetVersion> datasetversions = datasetManager.GetDatasetVersions(datasetId).OrderBy(d => d.Timestamp).ToList();
var resultAll = datasetManager.GetDatasetVersionEffectiveTuples(datasetversions.ElementAt(datasetversions.Count - 2));
List <long> comapreIds = resultAll.OrderBy(dt => dt.OrderNo).Skip(pageNumber * pageSize).Take(pageSize).Select(dt => dt.Id).ToList();
var result = datasetManager.GetDatasetVersionEffectiveTuples(datasetversions.ElementAt(datasetversions.Count - 2), pageNumber, pageSize); // get datatuples from the one before the latest
var resultIds = result.Select(dt => dt.Id).ToList();
//Assert
Assert.That(comapreIds, Is.EquivalentTo(resultIds));
}
finally
{
datasetManager.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;
}
}
private List <string> FindDatasetPerformers(DatasetManager dm, long datasetId) //latest version
{
var dsvs = dm.GetDatasetVersions(datasetId);
string performer;
List <string> performerUsernames = new List <string>();
foreach (var d in dsvs)
{
performer = d.ModificationInfo.Performer;
if (performer != null && !performerUsernames.Contains(performer))
{
performerUsernames.Add(performer);
}
}
return(performerUsernames);
}
//copy of BExIS.Modules.Ddm.UI.Controllers.DataController.getVersionsSelectList
private SelectList getVersionsSelectList(long id, DatasetManager datasetManager)
{
List <SelectListItem> tmp = new List <SelectListItem>();
List <DatasetVersion> dsvs = datasetManager.GetDatasetVersions(id).OrderByDescending(d => d.Timestamp).ToList();
dsvs.ForEach(d => tmp.Add(
new SelectListItem()
{
Text = (dsvs.Count - dsvs.IndexOf(d)) + " " + getVersionInfo(d),
Value = "" + (dsvs.Count - dsvs.IndexOf(d))
}
));
return(new SelectList(tmp, "Value", "Text"));
}
public void GetDataTuples_WhenCalledOneOlderVersion_ReturnIQueryableOfAbstractTuples()
{
//Arrange
DatasetManager datasetManager = null;
try
{
datasetManager = new DatasetManager();
//get latest datatupleid before create a new dataset and data
using (var uow = this.GetUnitOfWork())
{
var latestDataTuple = uow.GetReadOnlyRepository <DataTuple>().Get().LastOrDefault();
if (latestDataTuple != null)
{
latestDataTupleId = latestDataTuple.Id;
}
}
var dataset = datasetManager.GetDataset(datasetId);
dataset = dsHelper.UpdateOneTupleForDataset(dataset, (StructuredDataStructure)dataset.DataStructure, latestDataTupleId, 1, datasetManager);
datasetManager.CheckInDataset(dataset.Id, "for testing datatuples with versions", username, ViewCreationBehavior.None);
//Act
List <DatasetVersion> datasetversions = datasetManager.GetDatasetVersions(datasetId).OrderBy(d => d.Timestamp).ToList();
var result = datasetManager.GetDataTuples(datasetversions.ElementAt(datasetversions.Count - 2).Id); // get datatuples from the one before the latest
//Assert
Assert.That(result.Count(), Is.EqualTo(10));
}
finally
{
datasetManager.Dispose();
}
}
public ActionResult dqSync()
{
using (var dm = new DatasetManager())
{
List <long> datasetIds = dm.GetDatasetLatestIds(); //get latest
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
DataStructureManager dsm = new DataStructureManager();
try
{
//datasetManager.SyncView(datasetIds, ViewCreationBehavior.Create | ViewCreationBehavior.Refresh);
// if the viewData has a model error, the redirect forgets about it.
string pathPerformers = @"C:\Data\DatasetQualities\Performers.csv";
StreamWriter writerPerformers = new StreamWriter(pathPerformers);
string pathPerformerDataset = @"C:\Data\DatasetQualities\PerformerDataset.csv";
StreamWriter writerPerformerDataset = new StreamWriter(pathPerformerDataset);
string pathComparison = @"C:\Data\DatasetQualities\Comparison.csv";
StreamWriter writerComparison = new StreamWriter(pathComparison);
string pathDatasets = @"C:\Data\DatasetQualities\datasetInfo.csv";
StreamWriter writerDatasets = new StreamWriter(pathDatasets);
string pathVariable = @"C:\Data\DatasetQualities\Variables.csv";
StreamWriter writerVariable = new StreamWriter(pathVariable);
string pathFiles = @"C:\Data\DatasetQualities\Files.csv";
StreamWriter writerFiles = new StreamWriter(pathFiles);
string variableHeader = "datasetId,VarLabel,varType,varDescription,varUse,varMissing";
writerVariable.WriteLine(variableHeader);
string performer;
List <string> performerDataset = new List <string>();
Dictionary <string, int> performerCount = new Dictionary <string, int>();
List <int> metadataRates = new List <int>();
int allValidMetadas = 0;
//int publicDatasets = 0; //could not get result
//int restrictedDatasets = 0; //could not get result
List <int> dsDescLength = new List <int>();
List <int> dstrDescLength = new List <int>();
List <int> dstrUsage = new List <int>();
List <int> datasetSizeTabular = new List <int>();
List <int> datasetRows = new List <int>();
List <int> datasetCols = new List <int>();
List <double> datasetSizeFiles = new List <double>(); //all files in all datasets
List <int> datasetFileNumber = new List <int>();
List <int> sizeTabular = new List <int>(); //collect size, column number, and row number for one dataset
int fileDatasets = 0;
int tabularDatasets = 0;
int fileNumber = 0;
List <double> datasetTotalSize = new List <double>(); //total file size of each dataset
List <double> sizeFile = new List <double>(); ///////////////////////////
foreach (long datasetId in datasetIds)
{
DatasetVersion datasetLatestVersion = dm.GetDatasetLatestVersion(datasetId); //get last dataset versions
DataStructure dataStr = dsm.AllTypesDataStructureRepo.Get(datasetLatestVersion.Dataset.DataStructure.Id); //get data structure
#region performers
List <string> pers = new List <string>();
var dsvs = dm.GetDatasetVersions(datasetId);
foreach (var d in dsvs)
{
performer = d.ModificationInfo.Performer;
if (performer != null && !pers.Contains(performer))
{
pers.Add(performer); //a list of performers
}
}
foreach (var p in pers)
{
writerPerformerDataset.WriteLine(p + "," + datasetId); //fill the file PerformerDataset with a list of 'performer,datasetId'
if (performerCount.ContainsKey(p))
{
performerCount[p] += 1;
}
else
{
performerCount.Add(p, 1);
}
}
#endregion
#region allValidmetadatas
long metadataStructureId = dm.DatasetRepo.Get(datasetId).MetadataStructure.Id;
int validMetadata = 0;
if (datasetLatestVersion.StateInfo != null)
{
validMetadata = DatasetStateInfo.Valid.ToString().Equals(datasetLatestVersion.StateInfo.State) ? 1 : 0; //1:valid; 0:invalid.
}
else
{
validMetadata = 0;
}
if (validMetadata == 1) //count how many datasets have valid metadata
{
allValidMetadas += 1;
}
#endregion
#region metadataRates
XmlDocument metadata = datasetLatestVersion.Metadata;
string xmlFrag = metadata.OuterXml;
List <int> metaInfo = new List <int>();
NameTable nt = new NameTable();
XmlNamespaceManager nsmgr = new XmlNamespaceManager(nt);
// Create the XmlParserContext.
XmlParserContext context = new XmlParserContext(null, nsmgr, null, XmlSpace.None);
// Create the reader.
XmlTextReader reader = new XmlTextReader(xmlFrag, XmlNodeType.Element, context);
int countMetaAttr = 0;
int countMetaComplition = 0;
// Parse the XML and display each node.
while (reader.Read())
{
//XmlTextReader myReader = reader;
if (reader.NodeType == XmlNodeType.Element)
{
if (reader.HasAttributes && reader.GetAttribute("type") == "MetadataAttribute")
{
countMetaAttr += 1;
reader.Read();
if (reader.NodeType == XmlNodeType.Text)
{
string text = reader.Value;
countMetaComplition += 1;
}
}
}
}
// Close the reader.
reader.Close();
int rate = (countMetaComplition * 100) / countMetaAttr; //percentage of all metadata fields contains information
metadataRates.Add(rate);
#endregion
////find how many public dataset exist
//int publicRights = entityPermissionManager.GetRights(null, 1, datasetId); //1:public; 0:restricted
//if (publicRights == 1) { publicDatasets += 1; }
//if (publicRights == 0) { restrictedDatasets += 1; }
///issue here is that when a dataset has an empty dataset description field, the datasetLatestVersion.Description has the "not available" as value.
int datasetLatestVersionDescriptionLength = 0;
if (datasetLatestVersion.Description == "not available")
{
dsDescLength.Add(0);
}
else
{
dsDescLength.Add(datasetLatestVersion.Description.Length); //get dataset description length
datasetLatestVersionDescriptionLength = datasetLatestVersion.Description.Length;
}
dstrDescLength.Add(datasetLatestVersion.Dataset.DataStructure.Description.Length); //get data structure description length
dstrUsage.Add(dataStr.Datasets.Count() - 1); //data structure is used in how many other datasets (doesn't contain the current one)
string type = "file";
if (dataStr.Self.GetType() == typeof(StructuredDataStructure))
{
type = "tabular";
} //get dataset type
int colNum = 0;
int rowNum = 0;
#region tabular dataset
if (type == "tabular")
{
tabularDatasets += 1;
try
{
DataTable table = dm.GetLatestDatasetVersionTuples(datasetId, true);
DataRowCollection rowss = table.Rows;
DataColumnCollection columns = table.Columns;
StructuredDataStructure sds = dsm.StructuredDataStructureRepo.Get(datasetLatestVersion.Dataset.DataStructure.Id); //get data structure
var variables = sds.Variables; //get variables
//sizeTabular[1] = variables.Count; //columns.Count - 4;
//if (sizeTabular[1] < 0) //if data structure has not been designed.
//{
// sizeTabular[1] = 0;
//}
//sizeTabular[2] = rowss.Count;
//sizeTabular[0] = sizeTabular[1] * sizeTabular[2];
colNum = variables.Count;
rowNum = rowss.Count;
#region variables
int columnNumber = -1; //First four columns are added from system.
if (variables.Count() > 0)
{
foreach (var variable in variables)
{
columnNumber += 1;
//string missingValue = variable.MissingValue; //MISSING VALUE
List <string> missingValues = new List <string>(); //creat a list contains missing values
DataTable missTable = new DataTable();
foreach (var missValue in variable.MissingValues) //if data is equal missing value
{
missingValues.Add(missValue.Placeholder);
}
var varUse = variable.DataAttribute.UsagesAsVariable.Count() - 1;
string varType = variable.DataAttribute.DataType.SystemType;
int varMissing = 100; //suppose 100% is completed
try
{
if (rowss.Count > 0)
{
int missing = rowss.Count;
foreach (DataRow row in rowss)
{
var value = row.ItemArray[columnNumber]; //.ToString();
if (value == null || missingValues.Contains(value.ToString())) //check if cell is emty or contains a missing value
{
missing -= 1;
}
}
varMissing = 100 * missing / rowss.Count; //% of existing values
}
else
{
varMissing = 0;
}
}
catch
{
varMissing = 0;
}
string variableLine = datasetId + "," //0: dataset Id
+ variable.Label + "," //1: variable name
+ varType + "," //2: data type
+ variable.Description.Count() + "," //3: variable description length
+ varUse + "," //4: variable usage
+ varMissing; //5: % completed
writerVariable.WriteLine(variableLine);
}
}
#endregion
}
catch
{
colNum = 0;
rowNum = 0;
//sizeTabular.Add(0);
//sizeTabular.Add(0);
//sizeTabular.Add(0);
}
datasetSizeTabular.Add(colNum * rowNum); //sizeTabular[0]);
datasetCols.Add(colNum); // sizeTabular[1]); //column number
datasetRows.Add(rowNum); // sizeTabular[2]); //row number
}
#endregion
#region file dataset
else if (type == "file")
{
fileDatasets += 1;
List <ContentDescriptor> contentDescriptors = datasetLatestVersion.ContentDescriptors.ToList();
fileNumber = contentDescriptors.Count;
//datasetFileNumber.Add(fileNumber);
//sizeFile.Add(fileNumber);
int fileNum = 0;
double totalSize = 0;
string fileInDataset = "";
if (contentDescriptors.Count > 0)
{
foreach (ContentDescriptor cd in contentDescriptors)
{
if (cd.Name.ToLower().Equals("unstructureddata"))
{
fileNum += 1;
string uri = cd.URI;
String path = Server.UrlDecode(uri);
path = Path.Combine(AppConfiguration.DataPath, path);
try
{
Stream fileStream = System.IO.File.OpenRead(path);
FileStream fs = fileStream as FileStream;
if (fs != null)
{
FileInformation fileInfo = new FileInformation(fs.Name.Split('\\').LastOrDefault(), MimeMapping.GetMimeMapping(fs.Name), (uint)fs.Length, uri);
totalSize += fileInfo.Size;
fileInDataset = datasetId + "," + fileInfo.Name.Split('.')[0] + "," + fileInfo.Name.Split('.')[1].ToLower() + "," + fileInfo.Size; //datasetId,file name,file extension,file size
writerFiles.WriteLine(fileInDataset);
}
}
catch
{
datasetSizeFiles.Add(0); //file size
}
}
}
datasetFileNumber.Add(fileNum);
datasetTotalSize.Add(totalSize);
}
else
{
datasetFileNumber.Add(0);
datasetTotalSize.Add(0);
}
}
#endregion
//[0]datasetId, [1]dataType, [2]IsValid, [3]metadataComplitionRate,
//[4]datasetDescLength, [5]dataStrDescrLength, [6]DataStrUsage,
//[7]columns, [8]rows, [9]file numbers, [10]file sizes, [11]performers
string datasetInfo = datasetId + ";" + type + ";" + validMetadata + ";" + rate + ";"
+ datasetLatestVersionDescriptionLength + ";"
+ datasetLatestVersion.Dataset.DataStructure.Description.Length + ";"
+ (dataStr.Datasets.Count() - 1);
if (type == "tabular")
{
datasetInfo = datasetInfo + ";" + datasetCols.Last() //column number
+ ";" + datasetRows.Last() //row number
+ ";0;0"; //file number and size
}
if (type == "file")
{
datasetInfo = datasetInfo + ";0;0" //column and row number
+ ";" + datasetFileNumber.Last() //sizeFile[0] //file number
+ ";" + datasetTotalSize.Last(); //sizeFile[1]; //total size
}
string prfmrs = "";
foreach (string p in pers)
{
prfmrs = prfmrs + FindPerformerNameFromUsername(p) + ",";
}
prfmrs.Remove(prfmrs.Length - 1, 1);
datasetInfo = datasetInfo + ";" + prfmrs;
writerDatasets.WriteLine(datasetInfo);
}
writerDatasets.Close();
#region performersInFile
//write a list of 'performer,activity' in Performers.csv
foreach (string p in performerCount.Keys)
{
string l = p + "," + performerCount[p];
writerPerformers.WriteLine(l);
}
// performer activities
int performerMin = performerCount.Values.Min();
int performerMax = performerCount.Values.Max();
List <int> performerActivities = new List <int>();
foreach (int s in performerCount.Values)
{
performerActivities.Add(s);
}
double performerMedian = medianCalc(performerActivities);
string performerCompare = "performersActivity," + performerMin + "," + performerMedian + "," + performerMax;
writerComparison.WriteLine(performerCompare); //performersActivity
writerPerformers.Close();
writerPerformerDataset.Close();
#endregion
#region datasetInfo in file
#endregion //datasetInfo in file
#region compare in file
string m = "metadataRates," + metadataRates.Min() + "," + medianCalc(metadataRates) + "," + metadataRates.Max();
writerComparison.WriteLine(m);
string allValids = "allValidMetadas," + allValidMetadas;
writerComparison.WriteLine(allValids);
//string pd = "publicDatasets," + publicDatasets;
//string rd = "restrictedDatasets," + restrictedDatasets;
//writerComparison.WriteLine(pd);
//writerComparison.WriteLine(rd);
string datasetDescriptionLength = "datasetDescriptionLength," + dsDescLength.Min() + "," + medianCalc(dsDescLength) + "," + dsDescLength.Max();
string dataStrDescriptionLength = "dataStrDescriptionLength," + dstrDescLength.Min() + "," + medianCalc(dstrDescLength) + "," + dstrDescLength.Max();
string dataStrUsage = "dataStrUsage," + dstrUsage.Min() + "," + medianCalc(dstrUsage) + "," + dstrUsage.Max();
writerComparison.WriteLine(datasetDescriptionLength);
writerComparison.WriteLine(dataStrDescriptionLength);
writerComparison.WriteLine(dataStrUsage);
string typeDataset = "type," + (tabularDatasets + fileDatasets) + "," + tabularDatasets + "," + fileDatasets;
writerComparison.WriteLine(typeDataset);
string cols = "datasetColNumber," + datasetCols.Min() + "," + medianCalc(datasetCols) + "," + datasetCols.Max();
string rows = "datasetRowNumber," + datasetRows.Min() + "," + medianCalc(datasetRows) + "," + datasetRows.Max();
string fileNums = "";
string fileSizes = "";
string totalFileSize = "";
//if (datasetFileNumber.Count > 0)
//{
fileNums = "datasetFileNumber," + datasetFileNumber.Min() + "," + medianCalc(datasetFileNumber) + "," + datasetFileNumber.Max();
//fileSizes = "datasetSizeFiles," + datasetSizeFiles.Min() + "," + medianCalc(datasetSizeFiles) + "," + datasetSizeFiles.Max();
totalFileSize = "datasetTotalSizeFiles," + datasetTotalSize.Min() + "," + medianCalc(datasetTotalSize) + "," + datasetTotalSize.Max();
//}
//else
//{
// fileNums = "datasetFileNumber," + 0 + "," + 0 + "," + 0;
// //fileSizes = "datasetSizeFiles," + 0 + "," + 0 + "," + 0;
// totalFileSize = "datasetTotalSizeFiles," + 0 + "," + 0 + "," + 0;
//}
writerComparison.WriteLine(cols);
writerComparison.WriteLine(rows);
writerComparison.WriteLine(fileNums);
writerComparison.WriteLine(fileSizes);
writerComparison.WriteLine(totalFileSize);
#endregion
writerComparison.Close();
//writerDatasets.Close();
writerVariable.Close();
writerFiles.Close();
return(View());
//return RedirectToAction("Index", new { area = "dqm" });
}
catch (Exception ex)
{
ViewData.ModelState.AddModelError("", $@"'{ex.Message}'");
return(RedirectToAction("dqError", new { area = "dqm" }));
}
}
}
//copy of BExIS.Modules.Ddm.UI.Controllers.DataController.ShowData (adapted)
public ActionResult Index(long id, int version = 0)
{
DatasetManager dm = new DatasetManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
try
{
DatasetVersion dsv;
ShowDataModel model = new ShowDataModel();
string title = "";
long metadataStructureId = -1;
long dataStructureId = -1;
long researchPlanId = 1;
long versionId = 0;
string dataStructureType = DataStructureType.Structured.ToString();
bool downloadAccess = false;
bool requestExist = false;
bool requestAble = false;
bool latestVersion = false;
string isValid = "no";
XmlDocument metadata = new XmlDocument();
if (dm.IsDatasetCheckedIn(id))
{
//get latest version
if (version == 0)
{
versionId = dm.GetDatasetLatestVersionId(id); // check for zero value
//get current version number
version = dm.GetDatasetVersions(id).OrderBy(d => d.Timestamp).Count();
latestVersion = true;
}
// get specific version
else
{
versionId = dm.GetDatasetVersions(id).OrderBy(d => d.Timestamp).Skip(version - 1).Take(1).Select(d => d.Id).FirstOrDefault();
latestVersion = versionId == dm.GetDatasetLatestVersionId(id);
}
dsv = dm.DatasetVersionRepo.Get(versionId); // this is needed to allow dsv to access to an open session that is available via the repo
if (dsv.StateInfo != null)
{
isValid = DatasetStateInfo.Valid.ToString().Equals(dsv.StateInfo.State) ? "yes" : "no";
}
metadataStructureId = dsv.Dataset.MetadataStructure.Id;
//MetadataStructureManager msm = new MetadataStructureManager();
//dsv.Dataset.MetadataStructure = msm.Repo.Get(dsv.Dataset.MetadataStructure.Id);
title = dsv.Title;
dataStructureId = dsv.Dataset.DataStructure.Id;
researchPlanId = dsv.Dataset.ResearchPlan.Id;
metadata = dsv.Metadata;
// check if the user has download rights
downloadAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), id, RightType.Read);
//// check if a reuqest of this dataset exist
//if (!downloadAccess)
//{
// requestExist = HasOpenRequest(id);
// if (UserExist() && HasRequestMapping(id)) requestAble = true;
//}
dataStructureType = DataStructureType.Unstructured.ToString();
ViewBag.Title = PresentationModel.GetViewTitleForTenant("Show Data : " + title, this.Session.GetTenant());
}
else
{
ModelState.AddModelError(string.Empty, "Publication is just in processing.");
}
model = new ShowDataModel()
{
Id = id,
Version = version,
VersionSelect = version,
VersionId = versionId,
LatestVersion = latestVersion,
Title = title,
MetadataStructureId = metadataStructureId,
DataStructureId = dataStructureId,
ResearchPlanId = researchPlanId,
ViewAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), id, RightType.Read),
GrantAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), id, RightType.Grant),
DataStructureType = dataStructureType,
DownloadAccess = downloadAccess,
RequestExist = requestExist,
RequestAble = requestAble
};
//set metadata in session
Session["ShowDataMetadata"] = metadata;
ViewData["VersionSelect"] = getVersionsSelectList(id, dm);
ViewData["isValid"] = isValid;
return(View(model));
}
finally
{
dm.Dispose();
entityPermissionManager.Dispose();
}
}
private ShowPublishDataModel getShowPublishDataModel(long datasetId, long datasetVersionId = -1)
{
PublicationManager publicationManager = new PublicationManager();
DatasetManager datasetManager = new DatasetManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
ShowPublishDataModel model = new ShowPublishDataModel();
try
{
Dataset dataset = datasetManager.GetDataset(datasetId);
List <Broker> Brokers = GetBrokers(dataset.MetadataStructure.Id, publicationManager);
model.Brokers = Brokers.Select(b => b.Name).ToList();
model.DatasetId = datasetId;
//Todo Download Rigths -> currently set read rigths for this case
model.DownloadRights = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, "Dataset",
typeof(Dataset), datasetId, RightType.Read);
model.EditRights = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, "Dataset",
typeof(Dataset), datasetId, RightType.Write);
List <long> versions = new List <long>();
if (datasetVersionId == -1)
{
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
datasetVersionId = datasetVersion.Id;
versions = datasetManager.GetDatasetVersions(datasetId).Select(d => d.Id).ToList();
if (datasetVersion.StateInfo != null)
{
model.MetadataIsValid = DatasetStateInfo.Valid.ToString().Equals(datasetVersion.StateInfo.State) ? true : false;
}
}
//todo check if datasetversion id is correct
List <Publication> publications =
publicationManager.PublicationRepo.Get().Where(p => versions.Contains(p.DatasetVersion.Id)).ToList();
foreach (var pub in publications)
{
Broker broker = publicationManager.BrokerRepo.Get(pub.Broker.Id);
Repository repo = null;
if (pub.Repository != null)
{
repo = publicationManager.RepositoryRepo.Get(pub.Repository.Id);
}
string dataRepoName = repo == null ? "" : repo.Name;
List <string> repos =
GetRepos(dataset.MetadataStructure.Id, broker.Id, publicationManager).Select(r => r.Name).ToList();
model.Publications.Add(new PublicationModel()
{
Broker = new BrokerModel(broker.Name, repos, broker.Link),
DataRepo = dataRepoName,
DatasetVersionId = pub.DatasetVersion.Id,
CreationDate = pub.Timestamp,
ExternalLink = pub.ExternalLink,
FilePath = pub.FilePath,
Status = pub.Status,
});
}
return(model);
}
finally
{
publicationManager.Dispose();
datasetManager.Dispose();
entityPermissionManager.Dispose();
}
}
