コード例 #1
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();
                    }
                }
            }
        }
コード例 #2
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();
            }
        }
コード例 #3
0
        public DataStructurePreviewModel fill(long dataStructureId)
        {
            if (dataStructureId > 0)
            {
                DataStructureManager dataStructureManager = null;
                try
                {
                    dataStructureManager = new DataStructureManager();
                    if (dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId) != null)
                    {
                        StructuredDataStructure dataStructure = dataStructureManager.StructuredDataStructureRepo.Get(dataStructureId);
                        VariablePreviewStruct   variablePreview;

                        this.Id          = dataStructure.Id;
                        this.Name        = dataStructure.Name;
                        this.Description = dataStructure.Description;

                        if (dataStructure.Datasets.Any())
                        {
                            DatasetManager datasetManager = null;
                            try
                            {
                                datasetManager = new DatasetManager();
                                foreach (Dataset d in dataStructure.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();
                            }
                        }

                        foreach (Variable v in DataStructureIO.getOrderedVariables(dataStructure))
                        {
                            variablePreview = new VariablePreviewStruct().fill(v);
                            this.VariablePreviews.Add(variablePreview);
                        }
                    }
                    else if (dataStructureManager.UnStructuredDataStructureRepo.Get(dataStructureId) != null)
                    {
                        UnStructuredDataStructure dataStructure = dataStructureManager.UnStructuredDataStructureRepo.Get(dataStructureId);

                        this.Id               = dataStructure.Id;
                        this.Name             = dataStructure.Name;
                        this.Description      = dataStructure.Description;
                        this.VariablePreviews = null;

                        if (dataStructure.Datasets.Any())
                        {
                            this.inUse = true;
                        }
                    }
                    return(this);
                }
                finally
                {
                    dataStructureManager.Dispose();
                }
            }
            else
            {
                return(new DataStructurePreviewModel());
            }
        }