/// <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));
}
public ActionResult Reset()
{
//public ActionResult LoadMetadata(long datasetId, bool locked = false, bool created = false, bool fromEditMode = false, bool resetTaskManager = false, XmlDocument newMetadata = null)
TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
if (TaskManager != null)
{
DatasetManager dm = new DatasetManager();
long datasetid = -1;
bool resetTaskManager = true;
XmlDocument metadata = null;
bool editmode = false;
bool created = false;
if (TaskManager.Bus.ContainsKey(CreateTaskmanager.ENTITY_ID))
{
datasetid = Convert.ToInt64(TaskManager.Bus[CreateTaskmanager.ENTITY_ID]);
}
if (datasetid > -1 && dm.IsDatasetCheckedIn(datasetid))
{
metadata = dm.GetDatasetLatestMetadataVersion(datasetid);
editmode = true;
created = true;
}
return(RedirectToAction("LoadMetadata", "Form", new { area = "Dcm", entityId = datasetid, locked = false, created = created, fromEditMode = editmode, resetTaskManager = resetTaskManager, newMetadata = metadata }));
}
return(RedirectToAction("StartMetadataEditor", "Form"));
}
public JsonResult IsDatasetCheckedIn(long id)
{
DatasetManager dm = new DatasetManager();
if (id != -1 && dm.IsDatasetCheckedIn(id))
{
return(Json(true));
}
else
{
return(Json(false));
}
}
public ActionResult AddSelectedDatasetToBus(string id)
{
DatasetManager datasetManager = new DatasetManager();
try
{
ChooseDatasetViewModel model = new ChooseDatasetViewModel();
long datasetId = Convert.ToInt64(id);
Dataset dataset = datasetManager.GetDataset(datasetId);
DatasetVersion datasetVersion;
if (datasetManager.IsDatasetCheckedIn(datasetId))
{
addSelectedDatasetToBus(datasetId);
}
else
{
model.ErrorList.Add(new Error(ErrorType.Dataset, "Dataset is not checked in."));
}
Session["TaskManager"] = TaskManager;
//create Model
model.StepInfo = TaskManager.Current();
if ((List <ListViewItem>)Session["DatasetVersionViewList"] != null)
{
model.DatasetsViewList = (List <ListViewItem>)Session["DatasetVersionViewList"];
}
if (TaskManager.Bus.ContainsKey(TaskManager.DATASET_TITLE) && TaskManager.Bus[TaskManager.DATASET_TITLE] != null)
{
model.DatasetTitle = TaskManager.Bus[TaskManager.DATASET_TITLE].ToString();
}
model.SelectedDatasetId = Convert.ToInt32(id);
return(PartialView("SpecifyDataset", model));
}
finally
{
datasetManager.Dispose();
}
}
/// <summary>
///
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="id"></param>
/// <returns></returns>
public String GetTitle(long id)
{
if (DatasetManager.IsDatasetCheckedIn(id))
{
DatasetVersion datasetVersion = DatasetManager.GetDatasetLatestVersion(id);
// get MetadataStructure
MetadataStructure metadataStructure = datasetVersion.Dataset.MetadataStructure;
XDocument xDoc = XmlUtility.ToXDocument((XmlDocument)datasetVersion.Dataset.MetadataStructure.Extra);
XElement temp = XmlUtility.GetXElementByAttribute("nodeRef", "name", "title", xDoc);
string xpath = temp.Attribute("value").Value.ToString();
string title = datasetVersion.Metadata.SelectSingleNode(xpath).InnerText;
return(title);
}
return("NoTitleAvailable");
}
private void SetParametersToTaskmanager(long datasetId)
{
if (TaskManager == null)
{
TaskManager = (TaskManager)Session["TaskManager"];
}
#region set dataset id & dataset title
if (datasetId > 0)
{
try
{
long datasetid = Convert.ToInt64(datasetId);
TaskManager.AddToBus(TaskManager.DATASET_ID, datasetid);
// get title
using (DatasetManager dm = new DatasetManager())
{
string title = "";
// is checkedIn?
if (dm.IsDatasetCheckedIn(datasetid))
{
var dsv = dm.GetDatasetLatestVersion(datasetid);
title = dsv.Title;
}
TaskManager.AddToBus(TaskManager.DATASET_TITLE, title);
}
}
catch (Exception ex)
{
throw ex;
}
}
#endregion set dataset id & dataset title
}
/// <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);
var dataset = dm.GetDataset(datasetid);
if (!dm.IsDatasetCheckedIn(datasetid))
{
return(string.Empty);
}
var versionId = dm.GetDatasetLatestVersionId(datasetid);
return(GetInformationFromVersion(versionId, dataset.MetadataStructure.Id, name));
}
finally
{
dm.Dispose();
}
}
//[MeasurePerformance]
public ActionResult _CustomPrimaryDataBinding(GridCommand command, int datasetID)
{
GridModel model = new GridModel();
Session["Filter"] = command;
DatasetManager dm = new DatasetManager();
try
{
if (dm.IsDatasetCheckedIn(datasetID))
{
DatasetVersion dsv = dm.GetDatasetLatestVersion(datasetID);
// commented by Javad. Now the new API is called
//List<AbstractTuple> dataTuples = dm.GetDatasetVersionEffectiveTuples(dsv, command.Page - 1,
// command.PageSize);
//DataTable table = SearchUIHelper.ConvertPrimaryDataToDatatable(dsv, dataTuples);
DataTable table = dm.GetLatestDatasetVersionTuples(dsv.Dataset.Id, command.Page - 1, command.PageSize);
Session["gridTotal"] = dm.GetDatasetVersionEffectiveTupleCount(dsv);
model = new GridModel(table);
model.Total = Convert.ToInt32(Session["gridTotal"]); // (int)Session["gridTotal"];
}
else
{
ModelState.AddModelError(String.Empty, "Dataset is just in processing.");
}
return(View(model));
}
finally
{
dm.Dispose();
}
}
private void SetParametersToTaskmanager(long datasetId)
{
if (TaskManager == null)
{
TaskManager = (TaskManager)Session["TaskManager"];
}
#region set dataset id & dataset title
if (datasetId > 0)
{
try
{
long datasetid = Convert.ToInt64(datasetId);
TaskManager.AddToBus(TaskManager.DATASET_ID, datasetid);
// get title
DatasetManager dm = new DatasetManager();
string title = "";
// is checkedIn?
if (dm.IsDatasetCheckedIn(datasetid))
{
title = xmlDatasetHelper.GetInformationFromVersion(dm.GetDatasetLatestVersion(datasetid).Id,
NameAttributeValues.title);
}
TaskManager.AddToBus(TaskManager.DATASET_TITLE, title);
}
catch (Exception ex)
{
throw ex;
}
}
#endregion set dataset id & dataset title
}
public List <ListViewItem> LoadDatasetViewList()
{
List <ListViewItem> temp = new List <ListViewItem>();
DatasetManager datasetManager = new DatasetManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
//get all datasetsid where the current userer has access to
UserManager userManager = new UserManager();
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
try
{
List <long> datasetIds = entityPermissionManager.GetKeys(GetUsernameOrDefault(), "Dataset",
typeof(Dataset), RightType.Write);
foreach (long id in datasetIds)
{
if (datasetManager.IsDatasetCheckedIn(id))
{
string title = xmlDatasetHelper.GetInformation(id, NameAttributeValues.title);
string description = xmlDatasetHelper.GetInformation(id, NameAttributeValues.description);
temp.Add(new ListViewItem(id, title, description));
}
}
return(temp.OrderBy(p => p.Title).ToList());
}
finally
{
datasetManager.Dispose();
entityPermissionManager.Dispose();
userManager.Dispose();
}
}
public ActionResult _CustomDataStructureBinding(GridCommand command, long datasetID)
{
DataStructureManager dsm = new DataStructureManager();
DatasetManager dm = new DatasetManager();
try
{
long id = datasetID;
if (dm.IsDatasetCheckedIn(id))
{
DatasetVersion ds = dm.GetDatasetLatestVersion(id);
if (ds != null)
{
StructuredDataStructure sds = dsm.StructuredDataStructureRepo.Get(ds.Dataset.DataStructure.Id);
dsm.StructuredDataStructureRepo.LoadIfNot(sds.Variables);
//StructuredDataStructure sds = (StructuredDataStructure)(ds.Dataset.DataStructure.Self);
SearchUIHelper suh = new SearchUIHelper();
DataTable table = suh.ConvertStructuredDataStructureToDataTable(sds);
return(View(new GridModel(table)));
}
}
else
{
ModelState.AddModelError(String.Empty, "Dataset is just in processing.");
}
}
finally
{
dm.Dispose();
dsm.Dispose();
}
return(View(new GridModel(new DataTable())));
}
private List <DatasetVersionModel> getDatasetVersionsDic(MetadataStructure metadataStructure, List <long> datasetVersionIds)
{
List <DatasetVersionModel> datasetVersions = new List <DatasetVersionModel>();
DatasetManager datasetManager = new DatasetManager();
try
{
using (var uow = this.GetUnitOfWork())
{
// gets all the dataset versions that their Id is in the datasetVersionIds and they are using a specific metadata structure as indicated by metadataStructure parameter
var q = uow.GetReadOnlyRepository <DatasetVersion>().Get(p => datasetVersionIds.Contains(p.Id) &&
p.Dataset.MetadataStructure.Id.Equals(metadataStructure.Id)).Distinct();
foreach (DatasetVersion datasetVersion in q)
{
if (datasetManager.IsDatasetCheckedIn(datasetVersion.Dataset.Id))
{
uow.GetReadOnlyRepository <DatasetVersion>().Load(datasetVersion.ContentDescriptors);
datasetVersions.Add(
new DatasetVersionModel
{
DatasetVersionId = datasetVersion.Id,
DatasetId = datasetVersion.Dataset.Id,
Title = datasetVersion.Title,
MetadataDownloadPath = OutputMetadataManager.GetMetadataPath(datasetVersion.ContentDescriptors)
});
}
}
return(datasetVersions);
}
}
finally
{
datasetManager.Dispose();
}
}
public ActionResult StoreSelectedDatasetSetup(SetupModel model)
{
CreateTaskmanager TaskManager = (CreateTaskmanager)Session["CreateDatasetTaskmanager"];
DatasetManager datasetManager = new DatasetManager();
XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();
try
{
if (model == null)
{
model = GetDefaultModel();
return(PartialView("Index", model));
}
model = LoadLists(model);
if (ModelState.IsValid)
{
TaskManager.AddToBus(CreateTaskmanager.METADATASTRUCTURE_ID, model.SelectedMetadataStructureId);
TaskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_ID, model.SelectedDataStructureId);
// set datastructuretype
TaskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_TYPE, GetDataStructureType(model.SelectedDataStructureId));
//dataset is selected
if (model.SelectedDatasetId != 0 && model.SelectedDatasetId != -1)
{
if (datasetManager.IsDatasetCheckedIn(model.SelectedDatasetId))
{
DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(model.SelectedDatasetId);
TaskManager.AddToBus(CreateTaskmanager.RESEARCHPLAN_ID,
datasetVersion.Dataset.ResearchPlan.Id);
TaskManager.AddToBus(CreateTaskmanager.ENTITY_TITLE,
xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title));
// set datastructuretype
TaskManager.AddToBus(CreateTaskmanager.DATASTRUCTURE_TYPE,
GetDataStructureType(model.SelectedDataStructureId));
// set MetadataXml From selected existing Dataset
XDocument metadata = XmlUtility.ToXDocument(datasetVersion.Metadata);
SetXml(metadata);
}
else
{
ModelState.AddModelError(string.Empty, "Dataset is just in processing");
}
}
else
{
ResearchPlanManager rpm = new ResearchPlanManager();
TaskManager.AddToBus(CreateTaskmanager.RESEARCHPLAN_ID, rpm.Repo.Get().First().Id);
}
return(RedirectToAction("StartMetadataEditor", "Form"));
}
return(View("Index", model));
}
finally
{
datasetManager.Dispose();
}
}
public List <ListViewItem> LoadDatasetVersionViewList(DataStructureType dataStructureType)
{
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
DataStructureManager dataStructureManager = new DataStructureManager();
DatasetManager dm = new DatasetManager();
try
{
ICollection <long> datasetIDs = new List <long>();
datasetIDs = entityPermissionManager.GetKeys(GetUsernameOrDefault(), "Dataset", typeof(Dataset), RightType.Write).ToList();
Dictionary <long, XmlDocument> dmtemp = new Dictionary <long, XmlDocument>();
dmtemp = dm.GetDatasetLatestMetadataVersions();
List <ListViewItem> temp = new List <ListViewItem>();
if (dataStructureType.Equals(DataStructureType.Structured))
{
List <StructuredDataStructure> list = dataStructureManager.StructuredDataStructureRepo.Get().ToList();
foreach (StructuredDataStructure sds in list)
{
sds.Materialize();
foreach (Dataset d in sds.Datasets)
{
if (dm.IsDatasetCheckedIn(d.Id))
{
if (datasetIDs.Contains(d.Id))
{
temp.Add(new ListViewItem(d.Id,
xmlDatasetHelper.GetInformationFromVersion(dm.GetDatasetLatestVersion(d).Id,
NameAttributeValues.title)));
}
}
}
}
}
else
{
List <UnStructuredDataStructure> list = dataStructureManager.UnStructuredDataStructureRepo.Get().ToList();
foreach (UnStructuredDataStructure sds in list)
{
foreach (Dataset d in sds.Datasets)
{
if (datasetIDs.Contains(d.Id))
{
if (dm.IsDatasetCheckedIn(d.Id))
{
DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(d);
temp.Add(new ListViewItem(d.Id,
xmlDatasetHelper.GetInformationFromVersion(datasetVersion.Id, NameAttributeValues.title)));
}
}
}
}
}
return(temp.OrderBy(p => p.Title).ToList());
}
finally
{
entityPermissionManager.Dispose();
dataStructureManager.Dispose();
dm.Dispose();
}
}
/// <summary>
/// test unique of primary keys on a dataset
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="datasetId"></param>
/// <param name="primaryKeys"></param>
/// <returns></returns>
////[MeasurePerformance]
public Boolean IsUnique(long datasetId, List <long> primaryKeys)
{
DatasetManager datasetManager = new DatasetManager();
try
{
Hashtable hashtable = new Hashtable();
// load data
Dataset dataset = datasetManager.GetDataset(datasetId);
DatasetVersion datasetVersion;
List <long> dataTupleIds = new List <long>();
if (datasetManager.IsDatasetCheckedIn(datasetId))
{
datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
#region load all datatuples first
int size = 10000;
int counter = 0;
IEnumerable <AbstractTuple> dataTuples;
do
{
dataTuples = datasetManager.GetDatasetVersionEffectiveTuples(datasetVersion, counter, size);
//byte[] pKey;
string pKey;
foreach (DataTuple dt in dataTuples)
{
//pKey = getPrimaryKeysAsByteArray(dt, primaryKeys);
pKey = getPrimaryKeysAsString(dt, primaryKeys);
if (pKey.Count() > 0)
{
try
{
//Debug.WriteLine(pKey +" : " +Utility.ComputeKey(pKey));
hashtable.Add(pKey, "");
//hashtable.Add(pKey, 0);
}
catch
{
return(false);
}
}
}
counter++;
}while (dataTuples.Count() >= (size * counter));
#endregion
}
else
{
throw new Exception("Dataset is not checked in.");
}
return(true);
}
finally
{
datasetManager.Dispose();
}
}
// GET: DQ
public ActionResult ShowDQ(long datasetId, long versionId)
{
DQModels dqModel = new DQModels();
Dictionary <string, string> datasetInfo = new Dictionary <string, string>();
List <performer> performers = new List <performer>();
List <varVariable> varVariables = new List <varVariable>();
Dictionary <string, double> datasetSize = new Dictionary <string, double>();
DatasetManager dm = new DatasetManager();
DataStructureManager dsm = new DataStructureManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
PartyManager pm = new PartyManager();
UserManager um = new UserManager();
DatasetVersion dsv = new DatasetVersion();
UserManager userManager = new UserManager();
// data quality files
try
{
string pathPerformerDataset = @"C:\Data\DatasetQualities\PerformerDataset.csv";
StreamReader readerPerformerDataset = new StreamReader(pathPerformerDataset);
}
catch (Exception ex)
{ }
//////////////////////////////////////////////////////////////////////////
DatasetVersion currentDatasetVersion = dm.GetDatasetVersion(versionId); //Current dataset version
DataStructure currentDataStr = dsm.AllTypesDataStructureRepo.Get(currentDatasetVersion.Dataset.DataStructure.Id); //current data structure
var currentUser = userManager.FindByNameAsync(GetUsernameOrDefault()).Result; //Find current user
//Find the dataset Type
string currentDatasetType = "file";
if (currentDataStr.Self.GetType() == typeof(StructuredDataStructure))
{
currentDatasetType = "tabular";
}
dqModel.type = currentDatasetType;
#region performers
#region dataset's performers
try
{
string pathPerformerDataset = @"C:\Data\DatasetQualities\PerformerDataset.csv";
StreamReader readerPerformerDataset = new StreamReader(pathPerformerDataset);
string pathPerformers = @"C:\Data\DatasetQualities\Performers.csv";
StreamReader readerPerformers = new StreamReader(pathPerformers);
string performerLine;
List <string> pfs = new List <string>();
List <performer> ps = new List <performer>();
while ((performerLine = readerPerformerDataset.ReadLine()) != null)
{
string[] s = performerLine.Split(',');
if (long.Parse(s[1]) == datasetId)
{
pfs.Add(s[0]);
}
}
while ((performerLine = readerPerformers.ReadLine()) != null)
{
string[] s = performerLine.Split(',');
if (pfs.Contains(s[0]))
{
performer p = new performer();
p.performerName = FindPerformerNameFromUsername(um, s[0]); //find performer name
p.performerRate = int.Parse(s[1]);
List <long> pfIds = FindDatasetsFromPerformerUsername(dm, um, s[0]); //Find all datasets in wich the username is involved.
p.DatasetIds = pfIds;
ps.Add(p);
}
}
dqModel.performers = ps;
readerPerformerDataset.Close();
readerPerformers.Close();
}
catch (Exception ex)
{
}
#endregion
#endregion //performers
//dqModel.isPublic = entityPermissionManager.GetRights(null, 1, datasetId); //check if dataset is public
//check the read permission for current dataset
bool rPermission = entityPermissionManager.HasEffectiveRight(currentUser.UserName, typeof(Dataset), datasetId, Security.Entities.Authorization.RightType.Read); //find if user has read permission
if (rPermission == true) //has read permission or public = readable
{
dqModel.readable = 1;
}
else
{
dqModel.readable = 0;
} //cannot read
//Check if the current metadata is valid
if (currentDatasetVersion.StateInfo != null)
{
dqModel.isValid = DatasetStateInfo.Valid.ToString().Equals(currentDatasetVersion.StateInfo.State) ? 1 : 0; //1:valid; 0:invalid.
}
else
{
dqModel.isValid = 0;
}
List <long> datasetIds = dm.GetDatasetLatestIds();
dqModel.allDatasets = datasetIds.Count;
List <int> metadataRates = new List <int>();
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>();
double datasetSizeFile = new double();
List <int> datasetFileNumber = new List <int>();
List <int> restrictions = new List <int>();
int fileNumber = 0;
List <int> sizeTabular = new List <int>(); //collect size, column number, and row number for one dataset
int publicDatasets = 0;
int restrictedDatasets = 0;
int fileDatasets = 0;
int tabularDatasets = 0;
int rpTrue = 0;
int rp;
int validMetadata = 0;
int allValidMetadas = 0;
foreach (long Id in datasetIds) //for each dataset
{
if (dm.IsDatasetCheckedIn(Id))
{
DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(Id); //get last dataset versions
//If user has read permission
rPermission = entityPermissionManager.HasEffectiveRight(currentUser.UserName, typeof(Dataset), Id, Security.Entities.Authorization.RightType.Read);
if (rPermission == true) //has read permission or public = readable
{
rp = 1;
rpTrue += 1;
}
else
{
rp = 0;
} //cannot read
}
}
dqModel.allReadables = rpTrue;
string pathDatasetInfo = @"C:\Data\DatasetQualities\datasetInfo.csv";
StreamReader readerDatasetInfo = new StreamReader(pathDatasetInfo);
List <datasetInformation> datasetsInformation = new List <datasetInformation>();
try
{
string lineDatasetInfo;
while ((lineDatasetInfo = readerDatasetInfo.ReadLine()) != null)
{
string[] dsInf = lineDatasetInfo.Split(';');
datasetInformation datasetInformation = new datasetInformation();
long id = long.Parse(dsInf[0]);
datasetInformation.datasetId = id;
datasetInformation.title = dm.GetDatasetLatestVersion(id).Title;
rPermission = entityPermissionManager.HasEffectiveRight(currentUser.UserName, typeof(Dataset), id, Security.Entities.Authorization.RightType.Read);
if (rPermission == true)
{
datasetInformation.readable = 1;
}
if (rPermission == false)
{
datasetInformation.readable = 0;
}
datasetInformation.type = dsInf[1];
datasetInformation.metadataValidation = int.Parse(dsInf[2]);
datasetInformation.metadataComplition = int.Parse(dsInf[3]);
datasetInformation.descriptionLength = int.Parse(dsInf[4]);
datasetInformation.structureDescriptionLength = int.Parse(dsInf[5]);
datasetInformation.structureUsage = int.Parse(dsInf[6]);
datasetInformation.columnNumber = int.Parse(dsInf[7]);
datasetInformation.rowNumber = int.Parse(dsInf[8]);
datasetInformation.fileNumber = int.Parse(dsInf[9]);
datasetInformation.datasetSizeFile = double.Parse(dsInf[10]);
string[] pfrms = dsInf[11].Split(',');
List <string> performerNames = new List <string>();
foreach (string p in pfrms)
{
performerNames.Add(p);
}
datasetInformation.performerNames = performerNames;
datasetsInformation.Add(datasetInformation);
if (datasetId == id)
{
dqModel.metadataComplition.requiredFields = int.Parse(dsInf[2]);
dqModel.metadataComplition.totalFields = int.Parse(dsInf[3]);
dqModel.datasetDescriptionLength.currentDescriptionLength = int.Parse(dsInf[4]);
dqModel.dataStrDescriptionLength.currentDescriptionLength = int.Parse(dsInf[5]);
dqModel.dataStrUsage.currentDataStrUsage = int.Parse(dsInf[6]);
dqModel.columnNumber = datasetInformation.columnNumber;
dqModel.rowNumber = datasetInformation.rowNumber;
dqModel.fileNumber = datasetInformation.fileNumber;
dqModel.datasetTotalSize.currentTotalSize = datasetInformation.datasetSizeFile;
}
}
}
catch
{
}
dqModel.datasetsInformation = datasetsInformation;
readerDatasetInfo.Close();
//CURRENT DATASET VERSION
//dqModel.metadataComplition.totalFields = GetMetadataRate(currentDatasetVersion); //current dataset version: metadata rate
//dqModel.metadataComplition.requiredFields = 100; //Need to calculate: metadataStructureId = dsv.Dataset.MetadataStructure.Id;
//dqModel.datasetDescriptionLength.currentDescriptionLength = currentDatasetVersion.Description.Length; // Current dataset vesion: dataset description length
//dqModel.dataStrDescriptionLength.currentDescriptionLength = currentDatasetVersion.Dataset.DataStructure.Description.Length; // Current dataset version: data structure description length
//dqModel.dataStrUsage.currentDataStrUsage = currentDataStr.Datasets.Count() - 1; // Current dataset version: how many times the data structure is used in other datasets
#region comparision
try
{
string pathComparison = @"C:\Data\DatasetQualities\Comparison.csv";
StreamReader readerComparison = new StreamReader(pathComparison);
string infoline;
List <int> infos = new List <int>();
while ((infoline = readerComparison.ReadLine()) != null)
{
string[] s = infoline.Split(',');
if (s[0] == "performersActivity")
{
dqModel.performersActivity.minActivity = int.Parse(s[1]);
dqModel.performersActivity.medianActivity = int.Parse(s[2]);
dqModel.performersActivity.maxActivity = int.Parse(s[3]);
}
else if (s[0] == "type")
{
dqModel.allDatasets = int.Parse(s[1]);
dqModel.tabularDatasets = int.Parse(s[2]);
dqModel.fileDatasets = int.Parse(s[3]);
}
else if (s[0] == "metadataRates")
{
dqModel.metadataComplition.minRate = int.Parse(s[1]);
dqModel.metadataComplition.medianRate = int.Parse(s[2]);
dqModel.metadataComplition.maxRate = int.Parse(s[3]);
}
else if (s[0] == "allValidMetadas")
{
dqModel.allValids = int.Parse(s[1]);
}
else if (s[0] == "datasetDescriptionLength")
{
dqModel.datasetDescriptionLength.minDescriptionLength = int.Parse(s[1]);
dqModel.datasetDescriptionLength.medianDescriptionLength = int.Parse(s[2]);
dqModel.datasetDescriptionLength.maxDescriptionLength = int.Parse(s[3]);
}
else if (s[0] == "dataStrDescriptionLength")
{
dqModel.dataStrDescriptionLength.minDescriptionLength = int.Parse(s[1]);
dqModel.dataStrDescriptionLength.medianDescriptionLength = int.Parse(s[2]);
dqModel.dataStrDescriptionLength.maxDescriptionLength = int.Parse(s[3]);
}
else if (s[0] == "dataStrUsage")
{
dqModel.dataStrUsage.minDataStrUsage = int.Parse(s[1]);
dqModel.dataStrUsage.medianDataStrUsage = int.Parse(s[2]);
dqModel.dataStrUsage.maxDataStrUsage = int.Parse(s[3]);
}
else if (s[0] == "datasetColNumber")
{
dqModel.datasetColNumber.minColNumber = int.Parse(s[1]);
dqModel.datasetColNumber.medianColNumber = int.Parse(s[2]);
dqModel.datasetColNumber.maxColNumber = int.Parse(s[3]);
}
else if (s[0] == "datasetRowNumber")
{
dqModel.datasetRowNumber.minRowNumber = int.Parse(s[1]);
dqModel.datasetRowNumber.medianRowNumber = int.Parse(s[2]);
dqModel.datasetRowNumber.maxRowNumber = int.Parse(s[3]);
}
else if (s[0] == "datasetFileNumber")
{
dqModel.datasetFileNumber.minFileNumber = int.Parse(s[1]);
dqModel.datasetFileNumber.medianFileNumber = int.Parse(s[2]);
dqModel.datasetFileNumber.maxFileNumber = int.Parse(s[3]);
}
else if (s[0] == "datasetTotalSizeFiles")
{
dqModel.datasetTotalSize.minSizeFile = double.Parse(s[1]);
dqModel.datasetTotalSize.medianSizeFile = double.Parse(s[2]);
dqModel.datasetTotalSize.maxSizeFile = double.Parse(s[3]);
}
}
readerComparison.Close();
}
catch (Exception ex)
{
}
#endregion
///////////////////////////////////////////////////////////////////////
#region TABULAR FORMAT DATASET
//If it is a tabular format dataset
if (currentDatasetType == "tabular")
{
string pathVariables = @"C:\Data\DatasetQualities\Variables.csv";
StreamReader readerVariables = new StreamReader(pathVariables);
string varLine;
while ((varLine = readerVariables.ReadLine()) != null)
{
string[] varDetail = varLine.Split(',');
if (varDetail[0] == datasetId.ToString())
{
varVariable v = new varVariable();
v.varLabel = varDetail[1];
v.varType = varDetail[2];
v.varDescription = varDetail[3];
v.varUsage = int.Parse(varDetail[4]);
v.missing = int.Parse(varDetail[5]);
varVariables.Add(v);
}
}
dqModel.varVariables = varVariables;
readerVariables.Close();
}
// string serverName = "http://*****:*****@"C:\Data\DatasetQualities\Files.csv";
try
{
StreamReader readerFiles = new StreamReader(pathFiles);
while ((fileLine = readerFiles.ReadLine()) != null)
{
string[] fileDetail = fileLine.Split(',');
if (fileDetail[0] == datasetId.ToString())
{
fileInformation f = new fileInformation();
f.fileName = fileDetail[1];
f.fileFormat = fileDetail[2];
double d = Convert.ToDouble(fileDetail[3]);
f.fileSize = d;
filesInformations.Add(f);
}
}
readerFiles.Close();
}
catch
{
}
dqModel.filesInformation = filesInformations;
}
//if (currentDatasetVersion != null)
//{
// List<ContentDescriptor> contentDescriptors = currentDatasetVersion.ContentDescriptors.ToList();
// double totalSize = 0;
// if (contentDescriptors.Count > 0)
// {
// foreach (ContentDescriptor cd in contentDescriptors)
// {
// if (cd.Name.ToLower().Equals("unstructureddata"))
// {
// fileInformation fileInformation = new fileInformation();
// string uri = cd.URI;
// //get the file path
// try
// {
// String path = Server.UrlDecode(uri);
// path = Path.Combine(AppConfiguration.DataPath, path);
// Stream fileStream = System.IO.File.OpenRead(path);
// if (fileStream != null)
// {
// FileStream fs = fileStream as FileStream;
// if (fs != null)
// {
// //get file information
// FileInformation fileInfo = new FileInformation(fs.Name.Split('\\').LastOrDefault(), MimeMapping.GetMimeMapping(fs.Name), (uint)fs.Length, uri);
// fileInformation.fileName = fileInfo.Name.Split('.')[0]; //file name
// fileInformation.fileFormat = fileInfo.Name.Split('.')[1].ToLower(); //file extension
// fileInformation.fileSize = fileInfo.Size; //file size
// totalSize += fileInfo.Size;
// }
// }
// }
// catch
// {
// }
// filesInformation.Add(fileInformation);
// }
//}
//}
//dqModel.fileNumber = contentDescriptors.Count;
//dqModel.datasetTotalSize.currentTotalSize = totalSize;
//}
//dqModel.filesInformation = filesInformation;
//}
#endregion
return(PartialView(dqModel));
}
/// <summary>
/// test unique of primary keys on a dataset
/// </summary>
/// <remarks></remarks>
/// <seealso cref=""/>
/// <param name="datasetId"></param>
/// <param name="primaryKeys"></param>
/// <returns></returns>
////[MeasurePerformance]
public Boolean IsUnique2(long datasetId, List <long> primaryKeys)
{
DatasetManager datasetManager = new DatasetManager();
try
{
Hashtable hashtable = new Hashtable();
// load data
Dataset dataset = datasetManager.GetDataset(datasetId);
DatasetVersion datasetVersion;
List <long> dataTupleIds = new List <long>();
if (datasetManager.IsDatasetCheckedIn(datasetId))
{
datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);
#region load all datatuples first
int size = 10000;
int counter = 0;
IEnumerable <long> dataTuplesIds;
dataTuplesIds = datasetManager.GetDatasetVersionEffectiveTupleIds(datasetVersion);
IEnumerable <long> currentIds;
DataTuple dt;
do
{
currentIds = dataTupleIds.Skip(counter * size).Take(size);
//byte[] pKey;
string pKey;
foreach (long dtId in currentIds)
{
dt = datasetManager.DataTupleRepo.Query(d => d.Id.Equals(dtId)).FirstOrDefault();
//pKey = getPrimaryKeysAsByteArray(dt, primaryKeys);
pKey = pKey = getPrimaryKeysAsStringFromXml(dt, primaryKeys);
if (pKey.Count() > 0)
{
try
{
//Debug.WriteLine(pKey +" : " +Utility.ComputeKey(pKey));
hashtable.Add(pKey, "");
//hashtable.Add(pKey, 0);
}
catch
{
return(false);
}
}
}
counter++;
}while (currentIds.Count() >= (size * counter));
#endregion
}
else
{
throw new Exception("Dataset is not checked in.");
}
return(true);
}
finally
{
datasetManager.Dispose();
}
}
public ActionResult ShowData(long id)
{
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;
XmlDocument metadata = new XmlDocument();
if (dm.IsDatasetCheckedIn(id))
{
long versionId = dm.GetDatasetLatestVersionId(id); // check for zero value
dsv = dm.DatasetVersionRepo.Get(versionId); // this is needed to allow dsv to access to an open session that is available via the repo
metadataStructureId = dsv.Dataset.MetadataStructure.Id;
//MetadataStructureManager msm = new MetadataStructureManager();
//dsv.Dataset.MetadataStructure = msm.Repo.Get(dsv.Dataset.MetadataStructure.Id);
title = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.title); // this function only needs metadata and extra fields, there is no need to pass the version to it.
dataStructureId = dsv.Dataset.DataStructure.Id;
researchPlanId = dsv.Dataset.ResearchPlan.Id;
metadata = dsv.Metadata;
ViewBag.Title = PresentationModel.GetViewTitleForTenant("Show Data : " + title, this.Session.GetTenant());
}
else
{
ModelState.AddModelError(string.Empty, "Dataset is just in processing.");
}
model = new ShowDataModel()
{
Id = id,
Title = title,
MetadataStructureId = metadataStructureId,
DataStructureId = dataStructureId,
ResearchPlanId = researchPlanId,
ViewAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, "Dataset", typeof(Dataset), id, RightType.Read),
GrantAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, "Dataset", typeof(Dataset), id, RightType.Grant)
};
//set metadata in session
Session["ShowDataMetadata"] = metadata;
return(View(model));
}
finally
{
dm.Dispose();
entityPermissionManager.Dispose();
}
}
/// <summary>
/// create a model to fill the table of My Dataset
/// </summary>
/// <remarks></remarks>
/// <seealso cref="ShowMyDatasets"/>
/// <param>NA</param>
/// <returns>model</returns>
public ActionResult _CustomMyDatasetBinding()
{
DataTable model = new DataTable();
ViewData["PageSize"] = 10;
ViewData["CurrentPage"] = 1;
#region header
List <HeaderItem> headerItems = CreateHeaderItems();
ViewData["DefaultHeaderList"] = headerItems;
#endregion
model = CreateDataTable(headerItems);
DatasetManager datasetManager = new DatasetManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
UserManager userManager = new UserManager();
EntityManager entityManager = new EntityManager();
try
{
var entity = entityManager.FindByName("Dataset");
var user = userManager.FindByNameAsync(GetUsernameOrDefault()).Result;
List <long> gridCommands = datasetManager.GetDatasetLatestIds();
gridCommands.Skip(Convert.ToInt16(ViewData["CurrentPage"])).Take(Convert.ToInt16(ViewData["PageSize"]));
foreach (long datasetId in gridCommands)
{
//get permissions
int rights = entityPermissionManager.GetEffectiveRights(user?.Id, entity.Id, datasetId);
if (rights > 0)
{
DataRow dataRow = model.NewRow();
Object[] rowArray = new Object[8];
if (datasetManager.IsDatasetCheckedIn(datasetId))
{
//long versionId = datasetManager.GetDatasetLatestVersionId (datasetId); // check for zero value
//DatasetVersion dsv = datasetManager.DatasetVersionRepo.Get(versionId);
DatasetVersion dsv = datasetManager.GetDatasetLatestVersion(datasetId);
//MetadataStructureManager msm = new MetadataStructureManager();
//dsv.Dataset.MetadataStructure = msm.Repo.Get(dsv.Dataset.MetadataStructure.Id);
string title = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.title);
string description = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.description);
rowArray[0] = Convert.ToInt64(datasetId);
rowArray[1] = title;
rowArray[2] = description;
}
else
{
rowArray[0] = Convert.ToInt64(datasetId);
rowArray[1] = "";
rowArray[2] = "Dataset is just in processing.";
}
rowArray[3] = (rights & (int)RightType.Read) > 0 ? "✔" : "✘";
rowArray[4] = (rights & (int)RightType.Write) > 0 ? "✔" : "✘";
rowArray[5] = (rights & (int)RightType.Delete) > 0 ? "✔" : "✘";
rowArray[6] = (rights & (int)RightType.Download) > 0 ? "✔" : "✘";
rowArray[7] = (rights & (int)RightType.Grant) > 0 ? "✔" : "✘";
dataRow = model.NewRow();
dataRow.ItemArray = rowArray;
model.Rows.Add(dataRow);
}
}
return(View(new GridModel(model)));
}
finally
{
datasetManager.Dispose();
entityPermissionManager.Dispose();
entityManager.Dispose();
userManager.Dispose();
}
}
//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();
}
}
public ActionResult ShowPrimaryData(long datasetID, int versionId)
{
Session["Filter"] = null;
Session["Columns"] = null;
Session["DownloadFullDataset"] = false;
ViewData["DownloadOptions"] = null;
IOUtility iOUtility = new IOUtility();
DatasetManager dm = new DatasetManager();
DataStructureManager dsm = new DataStructureManager();
//permission download
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
try
{
if (dm.IsDatasetCheckedIn(datasetID))
{
// get latest or other datasetversion
DatasetVersion dsv = dm.GetDatasetVersion(versionId);
bool latestVersion = versionId == dm.GetDatasetLatestVersionId(datasetID);
DataStructure ds = dsm.AllTypesDataStructureRepo.Get(dsv.Dataset.DataStructure.Id);
// TODO: refactor Download Right not existing, so i set it to read
bool downloadAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), datasetID, RightType.Read);
bool editRights = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name, typeof(Dataset), datasetID, RightType.Write);
//TITLE
string title = dsv.Title;
if (ds.Self.GetType() == typeof(UnStructuredDataStructure))
{
if (this.IsAccessible("MMM", "ShowMultimediaData", "multimediaData") && ConfigurationManager.AppSettings["useMultimediaModule"].ToLower().Equals("true"))
{
return(RedirectToAction("multimediaData", "ShowMultimediaData", new RouteValueDictionary {
{ "area", "MMM" }, { "datasetID", datasetID }, { "versionId", versionId }, { "entityType", "Publication" }
}));
}
else
{
return
(PartialView(ShowPrimaryDataModel.Convert(datasetID,
versionId,
title,
ds,
SearchUIHelper.GetContantDescriptorFromKey(dsv, "unstructuredData"),
downloadAccess,
iOUtility.GetSupportedAsciiFiles(),
latestVersion,
editRights)));
}
}
}
else
{
ModelState.AddModelError(string.Empty, "Dataset is just in processing.");
}
return(PartialView(null));
}
catch (Exception ex)
{
throw ex;
}
finally
{
dm.Dispose();
dsm.Dispose();
entityPermissionManager.Dispose();
}
}
//[MeasurePerformance]
public ActionResult ShowPrimaryData(long datasetID)
{
Session["Filter"] = null;
Session["Columns"] = null;
Session["DownloadFullDataset"] = false;
ViewData["DownloadOptions"] = null;
DatasetManager dm = new DatasetManager();
DataStructureManager dsm = new DataStructureManager();
//permission download
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
try
{
if (dm.IsDatasetCheckedIn(datasetID))
{
//long versionId = dm.GetDatasetLatestVersionId(datasetID); // check for zero value
//DatasetVersion dsv = dm.DatasetVersionRepo.Get(versionId);
DatasetVersion dsv = dm.GetDatasetLatestVersion(datasetID);
StructuredDataStructure sds = dsm.StructuredDataStructureRepo.Get(dsv.Dataset.DataStructure.Id);
DataStructure ds = dsm.AllTypesDataStructureRepo.Get(dsv.Dataset.DataStructure.Id);
// TODO: refactor Download Right not existing, so i set it to read
bool downloadAccess = entityPermissionManager.HasEffectiveRight(HttpContext.User.Identity.Name,
"Dataset", typeof(Dataset), datasetID, RightType.Read);
//TITLE
string title = xmlDatasetHelper.GetInformationFromVersion(dsv.Id, NameAttributeValues.title);
if (ds.Self.GetType() == typeof(StructuredDataStructure))
{
//ToDO Javad: 18.07.2017 -> replaced to the new API for fast retrieval of the latest version
//
//List<AbstractTuple> dataTuples = dm.GetDatasetVersionEffectiveTuples(dsv, 0, 100);
//DataTable table = SearchUIHelper.ConvertPrimaryDataToDatatable(dsv, dataTuples);
DataTable table = dm.GetLatestDatasetVersionTuples(dsv.Dataset.Id, 0, 100);
Session["gridTotal"] = dm.GetDatasetVersionEffectiveTupleCount(dsv);
return(PartialView(ShowPrimaryDataModel.Convert(datasetID, title, sds, table, downloadAccess)));
//return PartialView(new ShowPrimaryDataModel());
}
if (ds.Self.GetType() == typeof(UnStructuredDataStructure))
{
return
(PartialView(ShowPrimaryDataModel.Convert(datasetID, title, ds,
SearchUIHelper.GetContantDescriptorFromKey(dsv, "unstructuredData"), downloadAccess)));
}
}
else
{
ModelState.AddModelError(string.Empty, "Dataset is just in processing.");
}
return(PartialView(null));
}
finally
{
dm.Dispose();
dsm.Dispose();
entityPermissionManager.Dispose();
}
}
/// <summary>
/// create a model to fill the table of My Dataset
/// </summary>
/// <remarks></remarks>
/// <seealso cref="ShowMyDatasets"/>
/// <param>NA</param>
/// <returns>model</returns>
public ActionResult _CustomMyDatasetBinding()
{
DataTable model = new DataTable();
ViewData["PageSize"] = 10;
ViewData["CurrentPage"] = 1;
#region header
List <HeaderItem> headerItems = CreateHeaderItems();
ViewData["DefaultHeaderList"] = headerItems;
#endregion header
model = CreateDataTable(headerItems);
DatasetManager datasetManager = new DatasetManager();
EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
UserManager userManager = new UserManager();
EntityManager entityManager = new EntityManager();
try
{
var entity = entityManager.FindByName("Dataset");
var user = userManager.FindByNameAsync(GetUsernameOrDefault()).Result;
List <long> gridCommands = datasetManager.GetDatasetLatestIds();
gridCommands.Skip(Convert.ToInt16(ViewData["CurrentPage"])).Take(Convert.ToInt16(ViewData["PageSize"]));
List <DatasetVersion> datasetVersions = datasetManager.GetDatasetLatestVersions(gridCommands, false);
foreach (var dsv in datasetVersions)
{
var datasetId = dsv.Dataset.Id;
//get permissions
int rights = entityPermissionManager.GetEffectiveRights(user?.Id, entity.Id, datasetId);
if (rights > 0)
{
DataRow dataRow = model.NewRow();
Object[] rowArray = new Object[8];
string isValid = "no";
if (datasetManager.IsDatasetCheckedIn(datasetId))
{
string title = dsv.Title;
string description = dsv.Description;
if (dsv.StateInfo != null)
{
isValid = DatasetStateInfo.Valid.ToString().Equals(dsv.StateInfo.State) ? "yes" : "no";
}
rowArray[0] = Convert.ToInt64(datasetId);
rowArray[1] = title;
rowArray[2] = description;
}
else
{
rowArray[0] = Convert.ToInt64(datasetId);
rowArray[1] = "";
rowArray[2] = "Dataset is just in processing.";
}
rowArray[3] = (rights & (int)RightType.Read) > 0 ? "✔" : "✘";
rowArray[4] = (rights & (int)RightType.Write) > 0 ? "✔" : "✘";
rowArray[5] = (rights & (int)RightType.Delete) > 0 ? "✔" : "✘";
//rowArray[6] = (rights & (int)RightType.Download) > 0 ? "✔" : "✘";
rowArray[6] = (rights & (int)RightType.Grant) > 0 ? "✔" : "✘";
rowArray[7] = isValid;
dataRow = model.NewRow();
dataRow.ItemArray = rowArray;
model.Rows.Add(dataRow);
}
}
return(View(new GridModel(model)));
}
catch (Exception ex)
{
throw ex;
}
finally
{
datasetManager.Dispose();
entityPermissionManager.Dispose();
entityManager.Dispose();
userManager.Dispose();
}
}
private void indexPrimaryData(long id, List <XmlNode> categoryNodes, ref Document dataset, string docId, XmlDocument metadataDoc)
{
DatasetManager dm = new DatasetManager();
DataStructureManager dsm = new DataStructureManager();
if (!dm.IsDatasetCheckedIn(id))
{
return;
}
DatasetVersion dsv = dm.GetDatasetLatestVersion(id);
StructuredDataStructure sds = dsm.StructuredDataStructureRepo.Get(dsv.Dataset.DataStructure.Id);
if (sds == null)
{
return;
}
indexStructureDataStructcure(sds, ref dataset, docId);
if (!includePrimaryData)
{
return;
}
try
{
{
// Javad: check if the dataset is "checked-in". If yes, then use the paging version of the GetDatasetVersionEffectiveTuples method
// number of tuples for the for loop is also available via GetDatasetVersionEffectiveTupleCount
// a proper fetch (page) size can be obtained by calling dm.PreferedBatchSize
int fetchSize = dm.PreferedBatchSize;
long tupleSize = dm.GetDatasetVersionEffectiveTupleCount(dsv);
long noOfFetchs = tupleSize / fetchSize + 1;
for (int round = 0; round < noOfFetchs; round++)
{
List <string> primaryDataStringToindex = null;
using (DataTable table = dm.GetLatestDatasetVersionTuples(dsv.Dataset.Id, round, fetchSize))
{
primaryDataStringToindex = getAllStringValuesFromTable(table); // should take the table
table.Dispose();
}
foreach (XmlNode category in categoryNodes)
{
String primitiveType = category.Attributes.GetNamedItem("primitive_type").Value;
String lucene_name = category.Attributes.GetNamedItem("lucene_name").Value;
String analysing = category.Attributes.GetNamedItem("analysed").Value;
float boosting = Convert.ToSingle(category.Attributes.GetNamedItem("boost").Value);
var toAnalyse = Lucene.Net.Documents.Field.Index.NOT_ANALYZED;
if (analysing.ToLower().Equals("yes"))
{
toAnalyse = Lucene.Net.Documents.Field.Index.ANALYZED;
}
if (category.Attributes.GetNamedItem("type").Value.Equals("primary_data_field"))
{
if (primaryDataStringToindex != null && primaryDataStringToindex.Count > 0)
{
foreach (string pDataValue in primaryDataStringToindex)
// Loop through List with foreach
{
Field a = new Field("category_" + lucene_name, pDataValue,
Lucene.Net.Documents.Field.Store.NO, toAnalyse);
a.Boost = boosting;
dataset.Add(a);
dataset.Add(new Field("ng_" + lucene_name, pDataValue,
Lucene.Net.Documents.Field.Store.YES, Lucene.Net.Documents.Field.Index.ANALYZED));
dataset.Add(new Field("ng_all", pDataValue, Lucene.Net.Documents.Field.Store.YES,
Lucene.Net.Documents.Field.Index.ANALYZED));
writeAutoCompleteIndex(docId, lucene_name, pDataValue);
writeAutoCompleteIndex(docId, "ng_all", pDataValue);
}
}
}
}
}
}
}
catch (Exception ex)
{
throw ex;
}
finally
{
dm.Dispose();
dsm.Dispose();
}
}
