예제 #1
0
        public List <ListViewItem> LoadDatasetVersionViewList(DataStructureType dataStructureType)
        {
            EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
            DataStructureManager    dataStructureManager    = new DataStructureManager();
            DatasetManager          dm = new DatasetManager();

            try
            {
                List <long> datasetIds = entityPermissionManager.GetKeys(GetUsernameOrDefault(), "Dataset", typeof(Dataset), RightType.Write).ToList();

                List <ListViewItem> tempStructured   = new List <ListViewItem>();
                List <ListViewItem> tempUnStructured = new List <ListViewItem>();

                var DatasetVersions = dm.GetDatasetLatestVersions(datasetIds, false);

                foreach (var dsv in DatasetVersions)
                {
                    if (dsv.Dataset.DataStructure.Self.GetType().Equals(typeof(StructuredDataStructure)))
                    {
                        tempStructured.Add(new ListViewItem(dsv.Dataset.Id, dsv.Title));
                    }
                    else
                    {
                        tempUnStructured.Add(new ListViewItem(dsv.Dataset.Id, dsv.Title));
                    }
                }

                if (dataStructureType.Equals(DataStructureType.Structured))
                {
                    return(tempStructured.OrderBy(p => p.Title).ToList());
                }
                else
                {
                    return(tempUnStructured.OrderBy(p => p.Title).ToList());
                }
            }
            finally
            {
                entityPermissionManager.Dispose();
                dataStructureManager.Dispose();
                dm.Dispose();
            }
        }
예제 #2
0
        public ActionResult FlipDateTime(long id, long variableid)
        {
            DatasetManager datasetManager = new DatasetManager();

            try
            {
                DatasetVersion     dsv          = datasetManager.GetDatasetLatestVersion(id);
                IEnumerable <long> datatupleIds = datasetManager.GetDatasetVersionEffectiveTupleIds(dsv);

                foreach (var tid in datatupleIds)
                {
                    DataTuple dataTuple = datasetManager.DataTupleRepo.Get(tid);
                    dataTuple.Materialize();
                    bool needUpdate = false;

                    foreach (var vv in dataTuple.VariableValues)
                    {
                        string systemType = vv.DataAttribute.DataType.SystemType;
                        if (systemType.Equals(typeof(DateTime).Name) && vv.VariableId.Equals(variableid))
                        {
                            string value = vv.Value.ToString();
                            vv.Value = flip(value, out needUpdate);
                        }
                    }

                    if (needUpdate)
                    {
                        dataTuple.Dematerialize();
                        datasetManager.UpdateDataTuple(dataTuple);
                    }
                }
            }
            catch (Exception ex)
            {
            }
            finally
            {
                datasetManager.Dispose();
            }

            return(RedirectToAction("Index"));
        }
예제 #3
0
        public static string IsValideAgainstSchema(long datasetId, TransmissionType type, string mappingName)
        {
            DatasetManager datasetManager = new DatasetManager();

            try
            {
                XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();

                DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);

                string mappingFileName = xmlDatasetHelper.GetTransmissionInformation(datasetVersion.Id, type, mappingName);
                string pathMappingFile = Path.Combine(AppConfiguration.GetModuleWorkspacePath("DIM"), mappingFileName);

                XmlMapperManager xmlMapperManager = new XmlMapperManager(TransactionDirection.InternToExtern);
                xmlMapperManager.Load(pathMappingFile, "exporttest");

                XmlDocument tmp = GetConvertedMetadata(datasetId, type, mappingName, false);

                string path = Path.Combine(AppConfiguration.DataPath, "Temp", "System", "convertedMetadata.xml");

                if (FileHelper.FileExist(path))
                {
                    FileHelper.Delete(path);
                }

                FileHelper.CreateDicrectoriesIfNotExist(Path.GetDirectoryName(path));

                tmp.Save(path);
                XmlDocument metadataForImport = new XmlDocument();
                metadataForImport.Load(path);

                return(xmlMapperManager.Validate(metadataForImport));
            }
            catch (Exception ex)
            {
                return(ex.Message);
            }
            finally
            {
                datasetManager.Dispose();
            }
        }
예제 #4
0
        public void GetDataTuples_WhenCalledForLatestVersionComplete_ReturnIQueryable()
        {
            //Arrange
            DatasetManager datasetManager = new DatasetManager();

            try
            {
                //Act
                DatasetVersion datasetversion = datasetManager.GetDatasetLatestVersion(datasetId);
                var            result         = datasetManager.GetDataTuples(datasetversion.Id);
                int            c = datasetManager.GetDataTuplesCount(datasetversion.Id);
                //Assert
                Assert.That(result.Count(), Is.EqualTo(numberOfTuples));
                Assert.That(c, Is.EqualTo(result.Count()));
            }
            finally
            {
                datasetManager.Dispose();
            }
        }
예제 #5
0
        public string EarliestDatestamp()
        {
            DatasetManager datasetManager = new DatasetManager();

            try
            {
                var    firstdsv = datasetManager.DatasetVersionRepo.Get().OrderBy(dsv => dsv.Timestamp).FirstOrDefault();
                string format   = API.Common.Enums.Granularity.DateTime.Replace("'", "");

                if (firstdsv != null)
                {
                    return(firstdsv.Timestamp.ToString(format));
                }

                return("");
            }
            finally
            {
                datasetManager.Dispose();
            }
        }
예제 #6
0
        // GET: Test
        public ActionResult Index(long id = -1)
        {
            DatasetManager datasetManager = new DatasetManager();

            try
            {
                //get all
                var x = MappingUtils.GetAllMatchesInSystem(1, LinkElementType.MetadataNestedAttributeUsage);
                // get all where value = david
                x = MappingUtils.GetAllMatchesInSystem(1, LinkElementType.MetadataNestedAttributeUsage, "David");

                // get value from metadata over the system
                // partytpe person - attr firstname

                long            partyCustomtAttr = 1;
                LinkElementType type             = LinkElementType.PartyCustomType;

                long datasetId = id;

                DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(datasetId);

                List <string> tmp = MappingUtils.GetValuesFromMetadata(partyCustomtAttr, type,
                                                                       datasetVersion.Dataset.MetadataStructure.Id, XmlUtility.ToXDocument(datasetVersion.Metadata));

                tmp = MappingUtils.GetValuesFromMetadata(Convert.ToInt64(Key.Keyword), LinkElementType.Key,
                                                         datasetVersion.Dataset.MetadataStructure.Id, XmlUtility.ToXDocument(datasetVersion.Metadata));

                tmp = MappingUtils.GetValuesFromMetadata(Convert.ToInt64(Key.Author), LinkElementType.Key,
                                                         datasetVersion.Dataset.MetadataStructure.Id, XmlUtility.ToXDocument(datasetVersion.Metadata));

                tmp = MappingUtils.GetValuesFromMetadata(Convert.ToInt64(Key.Title), LinkElementType.Key,
                                                         datasetVersion.Dataset.MetadataStructure.Id, XmlUtility.ToXDocument(datasetVersion.Metadata));

                return(View("Index"));
            }
            finally
            {
                datasetManager.Dispose();
            }
        }
예제 #7
0
        /// <summary>
        /// Get a html file of the data structure from a dataset
        /// </summary>
        /// <param name="id">dataset id</param>
        /// <returns>html file</returns>
        public ActionResult GetDataStructureAsHtmlFile(long id)
        {
            DatasetManager       dm  = new DatasetManager();
            DataStructureManager dsm = new DataStructureManager();

            try
            {
                using (var uow = this.GetUnitOfWork())
                {
                    long           dsId          = dm.GetDatasetLatestVersion(id).Id;
                    DatasetVersion ds            = uow.GetUnitOfWork().GetReadOnlyRepository <DatasetVersion>().Get(dsId);
                    DataStructure  dataStructure = null;
                    if (ds != null)
                    {
                        dataStructure = uow.GetReadOnlyRepository <DataStructure>().Get(ds.Dataset.DataStructure.Id);
                    }

                    if (dataStructure != null && dataStructure.Self is StructuredDataStructure)
                    {
                        SimpleDataStructureModel model = new SimpleDataStructureModel((StructuredDataStructure)dataStructure.Self);

                        string htmlPage = PartialView("SimpleDataStructure", model).RenderToString();
                        byte[] content  = Encoding.ASCII.GetBytes(htmlPage);

                        return(File(content, "text/html", "dataStructure.html"));
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dm.Dispose();
                dsm.Dispose();
            }

            return(null);
        }
        public int CountEntities()
        {
            using (var uow = this.GetUnitOfWork())
            {
                DatasetManager           dm = new DatasetManager();
                MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
                XmlDatasetHelper         xmlDatasetHelper         = new XmlDatasetHelper();
                var entities = new List <EntityStoreItem>();
                int count    = 0;

                try
                {
                    List <long> metadataStructureIds = metadataStructureManager.Repo.Query().Select(m => m.Id).ToList();

                    List <long> metadataSturctureIdsForDatasets = new List <long>();
                    metadataStructureIds.ForEach(m => xmlDatasetHelper.HasEntity(m, _entityName));

                    foreach (var msid in metadataStructureIds)
                    {
                        var datasetIds = new List <long>();
                        // get all datasets based on metadata data structure id

                        datasetIds = dm.DatasetRepo.Query(d => d.MetadataStructure.Id.Equals(msid)).Select(d => d.Id).ToList();
                        count     += datasetIds.Count;
                    }

                    return(count);
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    dm.Dispose();
                    metadataStructureManager.Dispose();
                }
            }
        }
예제 #9
0
        public string GetTitleById(long id)
        {
            using (var uow = this.GetUnitOfWork())
            {
                var dm = new DatasetManager();

                try
                {
                    var dsv = dm.GetDatasetLatestVersion(id);

                    return(dsv.Title);
                }
                catch
                {
                    return(String.Empty);
                }
                finally
                {
                    dm.Dispose();
                }
            }
        }
예제 #10
0
        public int CountVersions(long id)
        {
            DatasetManager dm = new DatasetManager();

            try
            {
                var datasetIds    = dm.GetDatasetLatestIds();
                var datasetHelper = new XmlDatasetHelper();

                int version = dm.GetDataset(id).Versions.Count;

                return(version);
            }
            catch (Exception ex)
            {
                return(0);
            }
            finally
            {
                dm.Dispose();
            }
        }
예제 #11
0
        public void GetDatasetVersionEffectiveDataTuples_PageOfDataTuplesFromLatestVersion_ReturnListOfAbstractTuples()
        {
            //Arrange
            DatasetManager datasetManager = new DatasetManager();

            int pagesize = (int)(numberOfTuples / 4);
            int page     = 2;

            try
            {
                //Act
                DatasetVersion datasetversion = datasetManager.GetDatasetLatestVersion(datasetId);
                var            result         = datasetManager.GetDatasetVersionEffectiveTuples(datasetversion, page, pagesize);

                //Assert
                Assert.That(result.Count(), Is.EqualTo(pagesize));
            }
            finally
            {
                datasetManager.Dispose();
            }
        }
예제 #12
0
        public string GetEntityName(long datasetid)
        {
            DatasetManager           datasetManager           = new DatasetManager();
            MetadataStructureManager metadataStructureManager = new MetadataStructureManager();

            try
            {
                Dataset dataset = datasetManager.GetDataset(datasetid);

                // get MetadataStructure
                if (dataset != null)
                {
                    return(GetEntityNameFromMetadatStructure(dataset.MetadataStructure.Id));
                }
                return(string.Empty);
            }
            finally
            {
                datasetManager.Dispose();
                metadataStructureManager.Dispose();
            }
        }
예제 #13
0
        public IEnumerable <ApiSimpleDatasetModel> Get()
        {
            DatasetManager datasetManager = new DatasetManager();
            List <ApiSimpleDatasetModel> datasetModels = new List <ApiSimpleDatasetModel>();

            try
            {
                IEnumerable <long> datasetIds = datasetManager.DatasetRepo.Get().Select(d => d.Id);

                foreach (long id in datasetIds)
                {
                    Dataset tmpDataset = datasetManager.GetDataset(id);
                    ApiSimpleDatasetModel datasetModel = new ApiSimpleDatasetModel();
                    datasetModel.Id = tmpDataset.Id;

                    DatasetVersion[] tmpVersions = tmpDataset.Versions.OrderBy(ds => ds.Timestamp).ToArray();

                    for (int i = 0; i < tmpVersions.Length; i++)
                    {
                        DatasetVersion dsv = tmpVersions.ElementAt(i);
                        ApiSimpleDatasetVersionModel datasetVersionModel = new ApiSimpleDatasetVersionModel()
                        {
                            Id     = dsv.Id,
                            Number = i + 1
                        };

                        datasetModel.Versions.Add(datasetVersionModel);
                    }

                    datasetModels.Add(datasetModel);
                }

                return(datasetModels);
            }
            finally
            {
                datasetManager.Dispose();
            }
        }
예제 #14
0
        public ActionResult CountRows(long id)
        {
            int number = 0;

            using (DatasetManager dm = new DatasetManager())
            {
                try
                {
                    if (id > 0)
                    {
                        Dataset ds = dm.GetDataset(id);
                        number = ds.DataStructure.Self is StructuredDataStructure?dm.GetDatasetLatestVersionEffectiveTupleCount(ds) : 0;
                    }

                    return(Json(number, JsonRequestBehavior.AllowGet));
                }
                finally
                {
                    dm.Dispose();
                }
            }
        }
예제 #15
0
        public List <EntityStoreItem> GetEntities()
        {
            using (var uow = this.GetUnitOfWork())
            {
                DatasetManager dm = new DatasetManager();

                try
                {
                    var datasetIds    = dm.GetDatasetLatestIds();
                    var datasetHelper = new XmlDatasetHelper();

                    var entities = datasetIds.Select(id => new EntityStoreItem()
                    {
                        Id = id, Title = datasetHelper.GetInformation(id, NameAttributeValues.title)
                    });
                    return(entities.ToList());
                }
                finally
                {
                    dm.Dispose();
                }
            }
        }
예제 #16
0
        /// <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();
            }
        }
예제 #17
0
        public void DeleteDatasetTest()
        {
            var dm  = new DatasetManager();
            var rsm = new ResearchPlanManager();
            var mdm = new MetadataStructureManager();

            try
            {
                var dsHelper = new DatasetHelper();
                StructuredDataStructure dataStructure = dsHelper.CreateADataStructure();
                dataStructure.Should().NotBeNull("Failed to meet a precondition: a data strcuture is required.");

                var rp = dsHelper.CreateResearchPlan();
                rp.Should().NotBeNull("Failed to meet a precondition: a research plan is required.");

                var mds = mdm.Repo.Query().First();
                mds.Should().NotBeNull("Failed to meet a precondition: a metadata strcuture is required.");

                Dataset dataset = dm.CreateEmptyDataset(dataStructure, rp, mds);
                dm.DeleteDataset(dataset.Id, "Javad", false);

                dataset.Should().NotBeNull();
                dataset.Id.Should().BeGreaterThan(0, "Dataset is not persisted.");
                dataset.LastCheckIOTimestamp.Should().NotBeAfter(DateTime.UtcNow, "The dataset's timestamp is wrong.");
                dataset.DataStructure.Should().NotBeNull("Dataset must have a data structure.");
                dataset.Status.Should().Be(DatasetStatus.Deleted, "Dataset must be in Deleted status.");

                dm.PurgeDataset(dataset.Id);
                dsHelper.PurgeAllDataStructures();
            }
            finally
            {
                dm.Dispose();
                rsm.Dispose();
                mdm.Dispose();
            }
        }
예제 #18
0
        public ActionResult SimpleDataStructure(long id)
        {
            DatasetManager       dm  = new DatasetManager();
            DataStructureManager dsm = new DataStructureManager();

            try
            {
                using (var uow = this.GetUnitOfWork())
                {
                    long           dsId          = dm.GetDatasetLatestVersion(id).Id;
                    DatasetVersion ds            = uow.GetUnitOfWork().GetReadOnlyRepository <DatasetVersion>().Get(dsId);
                    DataStructure  dataStructure = null;
                    if (ds != null)
                    {
                        dataStructure = uow.GetReadOnlyRepository <DataStructure>().Get(ds.Dataset.DataStructure.Id);
                    }

                    if (dataStructure != null && dataStructure.Self is StructuredDataStructure)
                    {
                        SimpleDataStructureModel model = new SimpleDataStructureModel((StructuredDataStructure)dataStructure.Self);

                        return(PartialView("SimpleDataStructure", model));
                    }
                }

                return(null);
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                dm.Dispose();
                dsm.Dispose();
            }
        }
예제 #19
0
        //[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();
            }
        }
예제 #20
0
        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();
            }
        }
예제 #21
0
        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())));
        }
예제 #22
0
        public List <int> Get()
        {
            List <int>     structuredIds = new List <int>();
            DatasetManager dm            = new DatasetManager();

            try
            {
                var datasetIds = dm.GetDatasetLatestIds();

                foreach (int id in datasetIds)
                {
                    DatasetVersion datasetVersion = dm.GetDatasetLatestVersion(id);
                    if (datasetVersion.Dataset.DataStructure.Self is StructuredDataStructure)
                    {
                        structuredIds.Add(id);
                    }
                }
                return(structuredIds);
            }
            finally
            {
                dm.Dispose();
            }
        }
예제 #23
0
        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();
            }
        }
예제 #24
0
        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();
            }
        }
예제 #25
0
        public void fillDatasetList()
        {
            DatasetListElement datasetListElement = new DatasetListElement();
            DatasetManager     dm = null;

            datasets = new List <DatasetListElement>();

            try
            {
                dm = new DatasetManager();
                XmlDatasetHelper xmlDatasetHelper = new XmlDatasetHelper();


                foreach (var item in dm.GetDatasetLatestVersions(dataStructure.Id, true))
                {
                    datasetListElement = new DatasetListElement(item.Key, xmlDatasetHelper.GetInformation(item.Value.Id, NameAttributeValues.title));
                    datasets.Add(datasetListElement);
                }
            }
            finally
            {
                dm.Dispose();
            }
        }
예제 #26
0
        //[MeasurePerformance]
        //temporary solution: norman
        //For original solution, look into Aquadiva Code
        public List <Error> FinishUpload(EasyUploadTaskManager taskManager)
        {
            DataStructureManager dsm = new DataStructureManager();
            DatasetManager       dm  = new DatasetManager();
            DataContainerManager dam = new DataContainerManager();
            //SubjectManager sm = new SubjectManager();
            EntityPermissionManager entityPermissionManager = new EntityPermissionManager();

            List <Error> temp = new List <Error>();

            try
            {
                using (IUnitOfWork unitOfWork = this.GetUnitOfWork())
                {
                    // initialize all necessary manager

                    DataTuple[] rows = null;

                    //First, try to validate - if there are errors, return immediately
                    string       JsonArray        = TaskManager.Bus[EasyUploadTaskManager.SHEET_JSON_DATA].ToString();
                    List <Error> ValidationErrors = ValidateRows(JsonArray);
                    if (ValidationErrors.Count != 0)
                    {
                        temp.AddRange(ValidationErrors);
                        return(temp);
                    }

                    string timestamp = DateTime.UtcNow.ToString("r");
                    string title     = Convert.ToString(TaskManager.Bus[EasyUploadTaskManager.FILENAME]);

                    if (TaskManager.Bus.ContainsKey(EasyUploadTaskManager.DESCRIPTIONTITLE))
                    {
                        string tmp = Convert.ToString(TaskManager.Bus[EasyUploadTaskManager.DESCRIPTIONTITLE]);
                        if (!String.IsNullOrWhiteSpace(tmp))
                        {
                            title = Convert.ToString(TaskManager.Bus[EasyUploadTaskManager.DESCRIPTIONTITLE]);
                        }
                    }

                    StructuredDataStructure   sds         = null;
                    List <VariableIdentifier> identifiers = new List <VariableIdentifier>(); //Used in Excel reader
                    //Try to find an exact matching datastructure
                    Boolean foundReusableDataStructure = false;

                    List <RowModel> headers = (List <RowModel>)TaskManager.Bus[EasyUploadTaskManager.ROWS];

                    //For some reason, MappedHeaders might be in a different order in this list than what's indicated by its IDs - to prevent mismatching, sort the headers
                    headers.Sort((m1, m2) => m1.Index.CompareTo(m2.Index));

                    List <StructuredDataStructure> allDatastructures = dsm.StructuredDataStructureRepo.Get().ToList();
                    foreach (StructuredDataStructure existingStructure in allDatastructures)
                    {
                        if (!foundReusableDataStructure)
                        {
                            //For now a datastructure is considered an exact match if it contains variables with
                            //the same names (labels), datatypes and units in the correct order
                            List <Variable> variablesOfExistingStructure = existingStructure.Variables.ToList();
                            foundReusableDataStructure = true;
                            if (variablesOfExistingStructure.Count != headers.Count)
                            {
                                foundReusableDataStructure = false;
                            }
                            else
                            {
                                for (int i = 0; i < variablesOfExistingStructure.Count; i++)
                                {
                                    Variable exVar         = variablesOfExistingStructure.ElementAt(i);
                                    RowModel currentHeader = headers.ElementAt(i);
                                    if (exVar.Label != currentHeader.Name ||
                                        exVar.Unit.Id != currentHeader.SelectedUnit.UnitId ||
                                        exVar.DataAttribute.DataType.Id != currentHeader.SelectedDataType.DataTypeId)
                                    {
                                        foundReusableDataStructure = false;
                                    }
                                }
                            }
                            if (foundReusableDataStructure)
                            {
                                sds = existingStructure;
                                foreach (Variable exVar in variablesOfExistingStructure)
                                {
                                    VariableIdentifier vi = new VariableIdentifier
                                    {
                                        name = exVar.Label,
                                        id   = exVar.Id
                                    };
                                    identifiers.Add(vi);
                                }
                            }
                        }
                    }

                    if (!foundReusableDataStructure)
                    {
                        sds = dsm.CreateStructuredDataStructure(title, title + " " + timestamp, "", "", DataStructureCategory.Generic);
                    }

                    TaskManager.AddToBus(EasyUploadTaskManager.DATASTRUCTURE_ID, sds.Id);
                    TaskManager.AddToBus(EasyUploadTaskManager.DATASTRUCTURE_TITLE, title + " " + timestamp);

                    if (!TaskManager.Bus.ContainsKey(EasyUploadTaskManager.DATASET_TITLE))
                    {
                        TaskManager.AddToBus(EasyUploadTaskManager.DATASET_TITLE, title);
                        TaskManager.AddToBus(EasyUploadTaskManager.TITLE, title);
                    }

                    MetadataStructure metadataStructure = null;
                    if (TaskManager.Bus.ContainsKey(EasyUploadTaskManager.SCHEMA))
                    {
                        long metadataStructureId = Convert.ToInt64(TaskManager.Bus[EasyUploadTaskManager.SCHEMA]);
                        metadataStructure = unitOfWork.GetReadOnlyRepository <MetadataStructure>()
                                            .Get(m => m.Id == metadataStructureId).FirstOrDefault();
                    }
                    else
                    {
                        //Default option but shouldn't happen because previous steps can't be finished without selecting the metadata-structure
                        metadataStructure = unitOfWork.GetReadOnlyRepository <MetadataStructure>()
                                            .Get(m => m.Name.ToLower().Contains("eml")).FirstOrDefault();
                    }
                    ResearchPlan rp = unitOfWork.GetReadOnlyRepository <ResearchPlan>().Get().FirstOrDefault();
                    TaskManager.AddToBus(EasyUploadTaskManager.RESEARCHPLAN_ID, rp.Id);
                    TaskManager.AddToBus(EasyUploadTaskManager.RESEARCHPLAN_TITLE, rp.Title);

                    #region Progress Information

                    if (TaskManager.Bus.ContainsKey(EasyUploadTaskManager.CURRENTPACKAGESIZE))
                    {
                        TaskManager.Bus[EasyUploadTaskManager.CURRENTPACKAGESIZE] = 0;
                    }
                    else
                    {
                        TaskManager.Bus.Add(EasyUploadTaskManager.CURRENTPACKAGESIZE, 0);
                    }

                    if (TaskManager.Bus.ContainsKey(EasyUploadTaskManager.CURRENTPACKAGE))
                    {
                        TaskManager.Bus[EasyUploadTaskManager.CURRENTPACKAGE] = 0;
                    }
                    else
                    {
                        TaskManager.Bus.Add(EasyUploadTaskManager.CURRENTPACKAGE, 0);
                    }

                    #endregion Progress Information

                    if (!foundReusableDataStructure)
                    {
                        #region Set Variables and information for new DataStructure

                        XmlDocument xmldoc       = new XmlDocument();
                        XmlElement  extraElement = xmldoc.CreateElement("extra");
                        XmlElement  orderElement = xmldoc.CreateElement("order");

                        //Sorting necessary to prevent problems when inserting the tuples
                        headers.OrderBy(r => r.Index);

                        var dataTypeRepo      = unitOfWork.GetReadOnlyRepository <DataType>();
                        var unitRepo          = unitOfWork.GetReadOnlyRepository <Unit>();
                        var dataAttributeRepo = unitOfWork.GetReadOnlyRepository <DataAttribute>();

                        List <DataAttribute> allDataAttributes = dataAttributeRepo.Get().ToList();

                        foreach (RowModel header in headers)
                        {
                            int i = headers.IndexOf(header);

                            DataType dataType            = dataTypeRepo.Get(header.SelectedDataType.DataTypeId);
                            Unit     CurrentSelectedUnit = unitRepo.Get(header.SelectedUnit.UnitId);

                            DataAttribute CurrentDataAttribute = new DataAttribute();
                            //If possible, map the chosen variable name, unit and datatype to an existing DataAttribute (Exact match)
                            DataAttribute existingDataAttribute = allDataAttributes.Where(da => da.Name.ToLower().Equals(TrimAndLimitString(header.SelectedDataAttribute.Name).ToLower()) &&
                                                                                          da.Unit.Dimension == CurrentSelectedUnit.Dimension).FirstOrDefault();
                            if (existingDataAttribute != null)
                            {
                                CurrentDataAttribute = existingDataAttribute;
                            }
                            else
                            {
                                //No matching DataAttribute => Create a new one
                                CurrentDataAttribute = dam.CreateDataAttribute(TrimAndLimitString(header.Name), header.Name, header.SelectedDataAttribute.Description, false, false, "", MeasurementScale.Categorial, DataContainerType.ReferenceType, "", dataType, CurrentSelectedUnit, null, null, null, null, null, null);
                            }

                            Variable           newVariable = dsm.AddVariableUsage(sds, CurrentDataAttribute, true, header.Name, "", "", "", CurrentSelectedUnit);
                            VariableIdentifier vi          = new VariableIdentifier
                            {
                                name = newVariable.Label,
                                id   = newVariable.Id
                            };
                            identifiers.Add(vi);

                            XmlElement newVariableXml = xmldoc.CreateElement("variable");
                            newVariableXml.InnerText = Convert.ToString(newVariable.Id);

                            orderElement.AppendChild(newVariableXml);
                        }
                        extraElement.AppendChild(orderElement);
                        xmldoc.AppendChild(extraElement);

                        sds.Extra       = xmldoc;
                        sds.Name        = "generated import structure " + timestamp;
                        sds.Description = "automatically generated structured data structure by user " + GetUsernameOrDefault() + " for file " + title + " on " + timestamp;

                        #endregion Set Variables and information for new DataStructure
                    }

                    Dataset ds = null;
                    ds = dm.CreateEmptyDataset(sds, rp, metadataStructure);

                    long datasetId = ds.Id;
                    long sdsId     = sds.Id;

                    if (dm.IsDatasetCheckedOutFor(datasetId, GetUsernameOrDefault()) || dm.CheckOutDataset(datasetId, GetUsernameOrDefault()))
                    {
                        DatasetVersion    dsv = dm.GetDatasetWorkingCopy(datasetId);
                        long              METADATASTRUCTURE_ID = metadataStructure.Id;
                        XmlMetadataWriter xmlMetadatWriter     = new XmlMetadataWriter(XmlNodeMode.xPath);
                        XDocument         metadataX            = xmlMetadatWriter.CreateMetadataXml(METADATASTRUCTURE_ID);
                        XmlDocument       metadataXml          = XmlMetadataWriter.ToXmlDocument(metadataX);
                        dsv.Metadata = metadataXml;
                        try
                        {
                            dsv.Metadata = xmlDatasetHelper.SetInformation(dsv, metadataXml, NameAttributeValues.title, title);
                            dsv.Title    = title;
                        }
                        catch (NullReferenceException ex)
                        {
                            //Reference of the title node is missing
                            throw new NullReferenceException("The extra-field of this metadata-structure is missing the title-node-reference!");
                        }
                        dm.EditDatasetVersion(dsv, null, null, null);
                    }

                    #region security

                    // add security
                    if (GetUsernameOrDefault() != "DEFAULT")
                    {
                        foreach (RightType rightType in Enum.GetValues(typeof(RightType)).Cast <RightType>())
                        {
                            //The user gets full permissions
                            // add security
                            if (GetUsernameOrDefault() != "DEFAULT")
                            {
                                entityPermissionManager.Create <User>(GetUsernameOrDefault(), "Dataset", typeof(Dataset), ds.Id, Enum.GetValues(typeof(RightType)).Cast <RightType>().ToList());
                            }
                        }
                    }

                    #endregion security

                    #region excel reader

                    int packageSize  = 100000;
                    int numberOfRows = 0;
                    //HACK ?
                    TaskManager.Bus[EasyUploadTaskManager.CURRENTPACKAGESIZE] = packageSize;

                    int counter = 0;

                    dm.CheckOutDatasetIfNot(ds.Id, GetUsernameOrDefault()); // there are cases, the dataset does not get checked out!!
                    if (!dm.IsDatasetCheckedOutFor(ds.Id, GetUsernameOrDefault()))
                    {
                        throw new Exception(string.Format("Not able to checkout dataset '{0}' for  user '{1}'!", ds.Id, GetUsernameOrDefault()));
                    }

                    DatasetVersion workingCopy = dm.GetDatasetWorkingCopy(ds.Id);

                    counter++;
                    TaskManager.Bus[EasyUploadTaskManager.CURRENTPACKAGE] = counter;

                    //rows = reader.ReadFile(Stream, TaskManager.Bus[TaskManager.FILENAME].ToString(), oldSds, (int)id, packageSize).ToArray();

                    List <string> selectedDataAreaJsonArray   = (List <string>)TaskManager.Bus[EasyUploadTaskManager.SHEET_DATA_AREA];
                    string        selectedHeaderAreaJsonArray = TaskManager.Bus[EasyUploadTaskManager.SHEET_HEADER_AREA].ToString();
                    List <int[]>  areaDataValuesList          = new List <int[]>();
                    foreach (string area in selectedDataAreaJsonArray)
                    {
                        areaDataValuesList.Add(JsonConvert.DeserializeObject <int[]>(area));
                    }
                    int[] areaHeaderValues = JsonConvert.DeserializeObject <int[]>(selectedHeaderAreaJsonArray);

                    Orientation orientation = 0;

                    switch (TaskManager.Bus[EasyUploadTaskManager.SHEET_FORMAT].ToString())
                    {
                    case "LeftRight":
                        orientation = Orientation.rowwise;
                        break;

                    case "Matrix":
                        //orientation = Orientation.matrix;
                        break;

                    default:
                        orientation = Orientation.columnwise;
                        break;
                    }

                    String worksheetUri = null;
                    //Get the Uri to identify the correct worksheet
                    if (TaskManager.Bus.ContainsKey(EasyUploadTaskManager.ACTIVE_WOKSHEET_URI))
                    {
                        worksheetUri = TaskManager.Bus[EasyUploadTaskManager.ACTIVE_WOKSHEET_URI].ToString();
                    }

                    int batchSize = (new Object()).GetUnitOfWork().PersistenceManager.PreferredPushSize;
                    int batchnr   = 1;
                    foreach (int[] areaDataValues in areaDataValuesList)
                    {
                        //First batch starts at the start of the current data area
                        int currentBatchStartRow = areaDataValues[0] + 1;
                        while (currentBatchStartRow <= areaDataValues[2] + 1) //While the end of the current data area has not yet been reached
                        {
                            //End row is start row plus batch size
                            int currentBatchEndRow = currentBatchStartRow + batchSize;

                            //Set the indices for the reader
                            EasyUploadFileReaderInfo fri = new EasyUploadFileReaderInfo
                            {
                                DataStartRow = currentBatchStartRow,
                                //End row is either at the end of the batch or the end of the marked area
                                //DataEndRow = (currentBatchEndRow > areaDataValues[2] + 1) ? areaDataValues[2] + 1 : currentBatchEndRow,
                                DataEndRow = Math.Min(currentBatchEndRow, areaDataValues[2] + 1),
                                //Column indices as marked in a previous step
                                DataStartColumn = areaDataValues[1] + 1,
                                DataEndColumn   = areaDataValues[3] + 1,

                                //Header area as marked in a previous step
                                VariablesStartRow    = areaHeaderValues[0] + 1,
                                VariablesStartColumn = areaHeaderValues[1] + 1,
                                VariablesEndRow      = areaHeaderValues[2] + 1,
                                VariablesEndColumn   = areaHeaderValues[3] + 1,

                                Offset      = areaDataValues[1],
                                Orientation = orientation
                            };
                            //Create a new reader each time because the reader saves ALL tuples it read and therefore the batch processing wouldn't work
                            EasyUploadExcelReader reader = new EasyUploadExcelReader(sds, fri);
                            // open file
                            Stream = reader.Open(TaskManager.Bus[EasyUploadTaskManager.FILEPATH].ToString());

                            //Set variable identifiers because they might differ from the variable names in the file
                            reader.setSubmittedVariableIdentifiers(identifiers);

                            //Read the rows and convert them to DataTuples
                            rows = reader.ReadFile(Stream, TaskManager.Bus[EasyUploadTaskManager.FILENAME].ToString(), fri, (int)datasetId, worksheetUri);

                            //After reading the rows, add them to the dataset
                            if (rows != null)
                            {
                                dm.EditDatasetVersion(workingCopy, rows.ToList(), null, null);
                                numberOfRows += rows.Count();
                            }

                            //Close the Stream so the next ExcelReader can open it again
                            Stream.Close();

                            //Debug information
                            int lines   = (areaDataValues[2] + 1) - (areaDataValues[0] + 1);
                            int batches = lines / batchSize;
                            batchnr++;

                            //Next batch starts after the current one
                            currentBatchStartRow = currentBatchEndRow + 1;
                        }
                    }

                    #endregion excel reader

                    //set modification
                    workingCopy.ModificationInfo = new EntityAuditInfo()
                    {
                        Performer  = GetUsernameOrDefault(),
                        Comment    = "Data",
                        ActionType = AuditActionType.Create
                    };

                    dm.EditDatasetVersion(workingCopy, null, null, null);

                    dm.CheckInDataset(ds.Id, "Import " + numberOfRows + " rows", GetUsernameOrDefault());

                    //Reindex search
                    if (this.IsAccessible("DDM", "SearchIndex", "ReIndexSingle"))
                    {
                        this.Run("DDM", "SearchIndex", "ReIndexSingle", new RouteValueDictionary()
                        {
                            { "id", datasetId }
                        });
                    }

                    TaskManager.AddToBus(EasyUploadTaskManager.DATASET_ID, ds.Id);

                    return(temp);
                }
            }
            catch (Exception ex)
            {
                temp.Add(new Error(ErrorType.Other, "An error occured during the upload. " +
                                   "Please try again later. If this problem keeps occuring, please contact your administrator."));
                return(temp);
            }
            finally
            {
                dsm.Dispose();
                dm.Dispose();
                dam.Dispose();
                //sm.Dispose();
                entityPermissionManager.Dispose();
            }
        }
예제 #27
0
        private HttpResponseMessage getData(long id, int variableId, string token)
        {
            DatasetManager          datasetManager          = new DatasetManager();
            UserManager             userManager             = new UserManager();
            EntityPermissionManager entityPermissionManager = new EntityPermissionManager();
            EntityManager           entityManager           = new EntityManager();
            DataStructureManager    dataStructureManager    = null;

            bool isPublic = false;

            try
            {
                // if a dataset is public, then the api should also return data if there is no token for a user

                #region is public
                dataStructureManager = new DataStructureManager();

                long?entityTypeId = entityManager.FindByName(typeof(Dataset).Name)?.Id;
                entityTypeId = entityTypeId.HasValue ? entityTypeId.Value : -1;

                isPublic = entityPermissionManager.Exists(null, entityTypeId.Value, id);

                #endregion is public

                if (!isPublic && String.IsNullOrEmpty(token))

                {
                    var request = Request.CreateResponse();
                    request.Content = new StringContent("Bearer token not exist.");

                    return(request);
                }

                User user = userManager.Users.Where(u => u.Token.Equals(token)).FirstOrDefault();

                if (isPublic || user != null)
                {
                    if (isPublic || entityPermissionManager.HasEffectiveRight(user.Name, typeof(Dataset), id, RightType.Read))
                    {
                        XmlDatasetHelper  xmlDatasetHelper    = new XmlDatasetHelper();
                        OutputDataManager ioOutputDataManager = new OutputDataManager();

                        Dataset        dataset        = datasetManager.GetDataset(id);
                        DatasetVersion datasetVersion = datasetManager.GetDatasetLatestVersion(id);

                        string title = datasetVersion.Title;

                        // check the data sturcture type ...
                        if (datasetVersion.Dataset.DataStructure.Self is StructuredDataStructure)
                        {
                            object stats = new object();

                            DataTable dt = new DataTable("Varibales");

                            List <ApiDataStatisticModel> dataStatisticModels = new List <ApiDataStatisticModel>();
                            if (variableId == -1)
                            {
                                StructuredDataStructure structuredDataStructure = dataStructureManager.StructuredDataStructureRepo.Get(datasetVersion.Dataset.DataStructure.Id);
                                List <string>           varIds = new List <string>();
                                foreach (Variable vs in structuredDataStructure.Variables)
                                {
                                    varIds.Add("var" + vs.Id);
                                }
                                dt = GetDuplicates(id, varIds);
                            }
                            else
                            {
                            }
                            //dt.Strip();


                            dt.TableName = id + "_data";

                            DatasetModel model = new DatasetModel();
                            model.DataTable = dt;

                            var    response = Request.CreateResponse(HttpStatusCode.OK);
                            string resp     = JsonConvert.SerializeObject(model);

                            response.Content = new StringContent(resp, System.Text.Encoding.UTF8, "application/json");
                            response.Content.Headers.ContentType = new MediaTypeHeaderValue("application/json");

                            return(response);
                        }
                        else
                        {
                            return(Request.CreateResponse());
                        }
                    }
                    else // has rights?
                    {
                        var request = Request.CreateResponse();
                        request.Content = new StringContent("User has no read right.");

                        return(request);
                    }
                }
                else
                {
                    var request = Request.CreateResponse();
                    request.Content = new StringContent("User is not available.");

                    return(request);
                }
            }
            catch (Exception e)
            {
                throw e;
            }
            finally
            {
                datasetManager.Dispose();
                userManager.Dispose();
                entityPermissionManager.Dispose();
                entityManager.Dispose();
                dataStructureManager.Dispose();
            }
        }
        public List <EntityStoreItem> GetEntities(int skip, int take)
        {
            bool withPaging = (take > 0);


            using (var uow = this.GetUnitOfWork())
            {
                DatasetManager           dm = new DatasetManager();
                MetadataStructureManager metadataStructureManager = new MetadataStructureManager();
                XmlDatasetHelper         xmlDatasetHelper         = new XmlDatasetHelper();
                var entities = new List <EntityStoreItem>();

                try
                {
                    List <long> metadataStructureIds = metadataStructureManager.Repo.Query().Select(m => m.Id).ToList();

                    List <long> metadataSturctureIdsForDatasets = new List <long>();
                    metadataSturctureIdsForDatasets = metadataStructureIds.Where(m => xmlDatasetHelper.HasEntity(m, _entityName)).ToList();

                    foreach (var msid in metadataSturctureIdsForDatasets)
                    {
                        var datasetIds = new List <long>();
                        // get all datasets based on metadata data structure id
                        if (withPaging)
                        {
                            datasetIds = dm.DatasetRepo
                                         .Query(d => d.MetadataStructure.Id.Equals(msid))
                                         .Skip(skip)
                                         .Take(take)
                                         .Select(d => d.Id).ToList();
                        }
                        else
                        {
                            datasetIds = dm.DatasetRepo.Query(d => d.MetadataStructure.Id.Equals(msid)).Select(d => d.Id).ToList();
                        }


                        if (!datasetIds.Any())
                        {
                            continue;
                        }

                        // create tuples based on dataset id list, and get latest version of each dataset

                        List <DatasetVersion> datasetVersions = dm.GetDatasetLatestVersions(datasetIds, false);
                        foreach (var dsv in datasetVersions)
                        {
                            var e = new EntityStoreItem()
                            {
                                Id      = dsv.Dataset.Id,
                                Title   = dsv.Title,
                                Version = dm.GetDatasetVersionCount(dsv.Dataset.Id)
                            };

                            entities.Add(e);
                        }
                    }

                    return(entities.ToList());
                }
                catch (Exception ex)
                {
                    throw ex;
                }
                finally
                {
                    dm.Dispose();
                    metadataStructureManager.Dispose();
                }
            }
        }
예제 #29
0
        public DataStructureResultsModel fill(long[] previewIds, string saerchTerms, bool structured = true, bool unstructured = true)
        {
            DataStructureResultStruct dataStructureResult = new DataStructureResultStruct();

            DataStructureManager dataStructureManager = null;
            DatasetManager       datasetManager       = null;

            try
            {
                dataStructureManager = new DataStructureManager();
                datasetManager       = new DatasetManager();

                using (IUnitOfWork uow = this.GetBulkUnitOfWork())
                {
                    if (structured)
                    {
                        foreach (DataStructure ds in getStucturedDataStructures(saerchTerms, dataStructureManager))
                        {
                            dataStructureResult             = new DataStructureResultStruct();
                            dataStructureResult.Id          = ds.Id;
                            dataStructureResult.Title       = ds.Name;
                            dataStructureResult.Description = ds.Description;

                            foreach (Dataset d in ds.Datasets)
                            {
                                if (datasetManager.RowAny(d.Id, uow))
                                {
                                    dataStructureResult.inUse = true;
                                    break;
                                }

                                // currently not working

                                /* else
                                 * {
                                 *  foreach (DatasetVersion dv in d.Versions)
                                 *  {
                                 *      if (datasetManager.GetDatasetVersionEffectiveTuples(dv).Any())
                                 *      {
                                 *          dataStructureResult.inUse = true;
                                 *          break;
                                 *      }
                                 *  }
                                 * }*/
                            }

                            dataStructureResult.Structured = true;

                            if (previewIds != null && previewIds.Contains(ds.Id))
                            {
                                dataStructureResult.Preview = true;
                            }

                            this.dataStructureResults.Add(dataStructureResult);
                        }
                    }
                }
                if (unstructured)
                {
                    foreach (DataStructure ds in getUnStucturedDataStructures(saerchTerms, dataStructureManager))
                    {
                        dataStructureResult             = new DataStructureResultStruct();
                        dataStructureResult.Id          = ds.Id;
                        dataStructureResult.Title       = ds.Name;
                        dataStructureResult.Description = ds.Description;

                        if (ds.Datasets.Count > 1) // Allow to edit, if only one file is linked to it
                        {
                            dataStructureResult.inUse = true;
                        }

                        if (previewIds != null && previewIds.Contains(ds.Id))
                        {
                            dataStructureResult.Preview = true;
                        }

                        this.dataStructureResults.Add(dataStructureResult);
                    }
                }
                return(this);
            }
            finally
            {
                dataStructureManager.Dispose();
                datasetManager.Dispose();
            }
        }
예제 #30
0
        public DataStructureResultStruct(long dataStructureId)
        {
            using (DataStructureManager dataStructureManager = new DataStructureManager())
            {
                StructuredDataStructure structuredDataStructure = dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId);
                if (structuredDataStructure != null)
                {
                    this.Id          = structuredDataStructure.Id;
                    this.Title       = structuredDataStructure.Name;
                    this.Description = structuredDataStructure.Description;
                    this.inUse       = false;

                    DatasetManager datasetManager = null;
                    try
                    {
                        datasetManager = new DatasetManager();
                        foreach (Dataset d in structuredDataStructure.Datasets)
                        {
                            if (datasetManager.RowAny(d.Id))
                            {
                                this.inUse = true;
                                break;
                            }
                            else
                            {
                                foreach (DatasetVersion dv in d.Versions)
                                {
                                    if (datasetManager.GetDatasetVersionEffectiveTuples(dv).Any())
                                    {
                                        this.inUse = true;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    finally
                    {
                        datasetManager.Dispose();
                    }

                    this.Structured = true;
                    this.Preview    = false;
                }
                else
                {
                    UnStructuredDataStructure unStructuredDataStructure = dataStructureManager.UnStructuredDataStructureRepo.Get(dataStructureId);
                    if (unStructuredDataStructure != null)
                    {
                        this.Id          = unStructuredDataStructure.Id;
                        this.Title       = unStructuredDataStructure.Name;
                        this.Description = unStructuredDataStructure.Description;

                        if (unStructuredDataStructure.Datasets != null && unStructuredDataStructure.Datasets.Any())
                        {
                            this.inUse = true;
                        }
                        else
                        {
                            this.inUse = false;
                        }

                        this.Structured = false;
                        this.Preview    = false;
                    }
                    else
                    {
                        new DataStructureResultStruct();
                    }
                }
            }
        }