Ejemplo n.º 1
0
        public async Task <bool> UnloadDataset(int datasetId, int fileId, string status = "UNLOADED")
        {
            try
            {
                var dataset = _datasetRepository.FindSingle(ds => ds.Id == datasetId, new List <string>()
                {
                    "Template", "Activity"
                });
                switch (dataset.Template.Code)
                {
                case "DM":
                    var subjectLoader = new SubjectLoader(_dataServiceUnit);
                    subjectLoader.UnloadSubjects(datasetId, fileId);
                    break;

                case "BS":
                    var sampleLoader = new BioSampleLoader(_dataServiceUnit);
                    sampleLoader.UnloadBioSamples(datasetId, fileId);
                    break;

                default:
                    var observationLoader = new ObservationLoader(_dataServiceUnit);
                    observationLoader.UnloadObservations(datasetId, fileId);
                    await _cacheService.GenerateAndCacheClinicalDTO(dataset.Activity.ProjectId);

                    break;
                }

                Debug.WriteLine("RECORD(s) SUCCESSFULLY DELETED FOR DATAFILE:" + fileId);
            }

            // in case an error hapens it returns false for success and therefore the main file would not be deleted. (try method)
            catch (Exception e)
            {
                Debug.WriteLine(e.Message);
                return(false);
            }

            //SINCE UNLOAD FILE CAN BE CALLED INDEPENDENTLY OF REMOVING FILE, NEED TO SET STATUS
            var file = _dataFileRepository.Get(fileId);

            file.State = status;
            _dataFileRepository.Update(file);
            _dataServiceUnit.Save();
            return(true);
        }
Ejemplo n.º 2
0
        public async Task <bool> LoadDataset(int datasetId, int fileId)
        {
            Dataset dataset = GetActivityDataset(datasetId);
            var     reload  = false;
            var     loaded  = false;

            var dataFile = _dataFileRepository.Get(fileId);

            if (dataFile.IsLoadedToDB)
            {
                reload = true;
            }

            try
            {
                switch (dataset.Template.Code)
                {
                case "DM":
                    var subjectLoader = new SubjectLoader(_dataServiceUnit);
                    loaded = await subjectLoader.LoadSubjects(dataset, fileId, reload);

                    break;

                case "BS":
                    var sampleLoader = new BioSampleLoader(_dataServiceUnit);
                    loaded = await sampleLoader.LoadBioSamples(dataset, fileId, reload);

                    break;

                case "CY":
                case "HD":
                    var hdDataLoader = new HDloader(_dataServiceUnit);
                    //loaded = await hdDataLoader.LoadHDdata(dataset,fileId, datasetId);
                    break;

                case "MX":
                    break;

                default:
                    var observationLoader = new ObservationLoader(this._dataServiceUnit);
                    loaded = await observationLoader.LoadObservations(dataset, fileId, reload);

                    if (loaded)
                    {
                        await _cacheService.GenerateAndCacheClinicalDTO(dataFile.ProjectId);
                    }
                    break;
                }


                if (loaded)
                {
                    dataFile.State        = "LOADED";
                    dataFile.IsLoadedToDB = true;
                    _dataFileRepository.Update(dataFile);
                    if (!dataset.DataFiles.Select(d => d.DatafileId).Contains(fileId))
                    {
                        //Adding a new datafile to this dataset
                        dataset.DataFiles.Add(new DatasetDatafile()
                        {
                            DatasetId = datasetId, DatafileId = dataFile.Id
                        });
                        _datasetRepository.Update(dataset);
                    }
                    _dataServiceUnit.Save();
                }

                if (!loaded && dataFile.State == "SAVED")
                {
                    _sdtmRepository.DeleteMany(s => s.DatafileId == fileId && s.DatasetId == datasetId);
                }
            }

            catch (Exception e)
            {
                Debug.WriteLine("Failed to load descriptors to SQL database", e.Message);
                await UnloadDataset(datasetId, fileId, "LOADING FAILED");
            }

            return(loaded);
        }