Example #1
0
        // dataset service
        public bool LoadHDdDdata(int datasetId, int fileId /*, int referencFromHdId*/)
        {
            _observationRepository.DeleteMany(d => d.DatasetId == datasetId);
            var dataset  = GetActivityDataset(datasetId);
            var dataFile = _dataFileRepository.Get(fileId);
            var filePath = dataFile.Path + "\\" + dataFile.FileName;

            var dataTable = _fileService.ReadOriginalFile(filePath);

            var sampleList = _biosampleRepository.FindAll(s => s.DatasetId == datasetId).ToList();
            var scos       = sampleList.ToDictionary(co => co.BiosampleStudyId);

            var obsReadyToInsert = new List <Observation>();

            foreach (DataRow row in dataTable.Rows)
            {
                for (int index = 0; index < dataTable.Columns.Count; index++)
                {
                    if (index == 0)
                    {
                        continue;
                    }
                    else
                    {
                        var column = dataTable.Columns[index];
                        var obs    = new Observation();
                        // Fill an Observation
                        var value = new NumericalValue();
                        value.Value    = double.Parse(row[column.ColumnName].ToString());
                        value.Property = new PropertyDescriptor();
                        {
                            value.Property.Description = dataset.Template.Description;
                            value.Property.ObsClass    = dataset.Template.Class;
                            value.Property.Name        = dataset.TemplateId;
                        }
                        //   value.Unit = ??
                        obs.ObservedValue = value;                                                             // Observed Value which includes in it the VALUE and its PROPERTY

                        // ****** FOR NOW WE USE THE FOLLOWING TILL WE HAVE THE FEATURE referencFromHdId ******
                        obs.SubjectOfObservationName = column.ColumnName;                                      // sample name (HERE IS THE FILE NAME)
                        //obs.SubjectOfObservationId = column.ColumnName;                                    // sampleID     (here is the file name)
                        // ******

                        //   obs.SubjectOfObservationName = scos[column.ColumnName].BiosampleStudyId;      // sample Name
                        //   obs.SubjectOfObservationId = scos[column.ColumnName].Id.ToString();           // sample ID
                        //   obs.StudyId = scos[column.ColumnName].StudyId;                                // study ID
                        obs.FeatureName = row[0].ToString();                                                   // feature name
                        // obs.FeatureId =;  Not implemented yet                                           // feature ID
                        obs.DatafileId = dataFile.Id;
                        obs.DatasetId  = datasetId;
                        obs.ActivityId = dataset.ActivityId;
                        obs.ProjectId  = dataset.Activity.ProjectId;
                        obs.Id         = Guid.NewGuid();

                        obsReadyToInsert.Add(obs);
                        //   observationsTotal.Add(obs);

                        if (obsReadyToInsert.Count % ((dataTable.Columns.Count) - 1) == 0)
                        {
                            _observationRepository.InsertMany(obsReadyToInsert);
                            obsReadyToInsert.Clear();
                        }
                    }
                }
            }
            if (obsReadyToInsert.Count > 0)
            {
                Debug.WriteLine("Created Observations are NOT Equal to measured values in the file please check!!");
            }

            dataFile.State        = "LOADED";
            dataFile.IsLoadedToDB = true;
            _dataFileRepository.Update(dataFile);
            _dataContext.Save();
            return(true);
        }
Example #2
0
        internal bool LoadHDdata(int datasetId, int fileId, DataTable dataTable)
        {
            var dataset  = _datasetRepository.FindSingle(d => d.Id == datasetId);
            var dataFile = _dataFileRepository.Get(fileId);

            //if (!dataFile.State.ToLower().Equals("new"))
            //{
            //    /**
            //     * Replacing previously loaded file
            //     * Remove file from collection before reloading it
            //     */
            //    _observationRepository.DeleteMany(s => s.DatafileId == fileId && s.DatasetId == datasetId);
            //    Debug.WriteLine("RECORD(s) SUCCESSFULLY DELETED FOR DATASET:" + datasetId + " ,DATAFILE:" + fileId);
            //}

            var projectId    = dataFile.ProjectId;
            var observations = new List <Observation>();
            var totalLoaded  = 0.0;
            var prop         = new PropertyDescriptor()
            {
                Name        = "CONC",
                ProjectId   = projectId,
                Description = "Concentration",
                ObsClass    = "ASSAYMEASURES",
                Id          = 99
            };

            try
            {
                foreach (DataRow row in dataTable.Rows)
                {
                    var obs = new Observation();

                    obs.FeatureName = row["FEAT"]?.ToString();
                    // obs.SubjectOfObservationId = row["SPECIMEN"]?.ToString();
                    obs.SubjectOfObservationName = row["SPECIMEN"]?.ToString();
                    double val;
                    if (double.TryParse(row["OBSVAL"]?.ToString(), out val))
                    {
                        obs.ObservedValue = new NumericalValue()
                        {
                            Property = prop,
                            Unit     = row["OBSVALU"]?.ToString(),
                            Value    = val
                        }
                    }
                    ;
                    else
                    {
                        obs.ObservedValue = new MissingValue()
                        {
                            Property = prop
                        };
                    }
                    obs.Id         = Guid.NewGuid();
                    obs.DatasetId  = datasetId;
                    obs.ActivityId = dataset.ActivityId;
                    obs.DatafileId = fileId;
                    obs.ProjectId  = projectId;


                    observations.Add(obs);

                    if (observations.Count % 500 == 0)
                    {
                        _observationRepository.InsertMany(observations);
                        totalLoaded   += observations.Count;
                        dataFile.State = Math.Round(totalLoaded / dataTable.Rows.Count * 100).ToString("##");

                        _dataFileRepository.Update(dataFile);
                        _dataContext.Save();
                        observations.Clear();
                    }
                }
                _observationRepository.InsertMany(observations);
                Debug.WriteLine(dataTable.Rows.Count + " RECORD(s) SUCCESSFULLY ADDED FOR DATASET:" + datasetId + " ,DATAFILE:" + fileId);
            }
            catch (Exception)
            {
                dataFile.State        = "FAILED";
                dataFile.IsLoadedToDB = false;
                _dataFileRepository.Update(dataFile);
                _dataContext.Save();
                return(false);
            }


            dataFile.State        = "LOADED";
            dataFile.IsLoadedToDB = true;
            _dataFileRepository.Update(dataFile);
            _dataContext.Save();
            return(true);
        }