示例#1
0
        private static async Task <bool> UpdateDatabaseMeasurementsWithMeasurementData(ICollection <Measurement> measurements)
        {
            using (DescDBContext dBContext = new DescDBContext())
            {
                foreach (var measurement in measurements)
                {
                    var measurementExists = await dBContext.MeasurementDescriptions
                                            .Where(x => x.SectionInfo.ID == measurement.SectionInfo.ID)
                                            .Where(x => x.TextID == measurement.TextID)
                                            .Where(x => x.TestNumber == measurement.TestNumber)
                                            .Where(x => x.StartOffset == measurement.StartOffset && x.EndOffset == measurement.EndOffset)
                                            .FirstOrDefaultAsync().ConfigureAwait(true);


                    if (measurementExists != null)
                    {
                        foreach (var columnValuePair in measurement.MeasurementData)
                        {
                            if (!measurementExists.MeasurementData.Any(x => x.ColumnName == columnValuePair.ColumnName))
                            {
                                measurementExists.MeasurementData.Add(columnValuePair);
                            }
                        }

                        dBContext.Update(measurement);
                        await dBContext.SaveChangesAsync();

                        //dBContext.u
                    }
                }
            }


            return(true);
        }
示例#2
0
        public static async Task <bool> CheckForSectionAsync(DescDBContext dBContext, SectionInfo section)
        {
            bool recordExists;

            if (section.ID != 0)
            {
                recordExists = await dBContext.Sections
                               .Where(x => x.ID == section.ID)
                               .AnyAsync().ConfigureAwait(true);
            }
            else if (section.ParentTextID != "")
            {
                recordExists = await dBContext.Sections
                               .Where(x => x.ParentTextID == section.ParentTextID)
                               .AnyAsync().ConfigureAwait(true);
            }
            else if (section.ID == 0)
            {
                recordExists = await dBContext.Sections
                               .Where(x => section.Equals(x))
                               .AnyAsync().ConfigureAwait(true);
            }
            else
            {
                return(false);
            }

            return(recordExists);
        }
示例#3
0
        public static async Task <bool> AddSectionsToDatabaseAsync(DescDBContext dBContext, ICollection <SectionInfo> sections)
        {
            foreach (var section in sections)
            {
                var exists = await CheckForSectionAsync(dBContext, section).ConfigureAwait(true);

                if (exists)
                {
                    sections.Remove(section);
                }
            }


            try
            {
                using (DescDBContext dbContext = new DescDBContext())
                {
                    dbContext.AddRange(sections);
                    await dbContext.SaveChangesAsync().ConfigureAwait(true);

                    return(true);
                }
            }
            catch (Exception)
            {
                throw new Exception(string.Format("Error adding sections to database"));
            }
        }
示例#4
0
        public static void SendMeasurementsToDatabase(Dictionary <int, Measurement> MeasurementCache)
        {
            _ = MeasurementCache ?? throw new ArgumentNullException(nameof(MeasurementCache));

            DescDBContext context = null;

            try
            {
                context = new DescDBContext();
                //context.Configuration.AutoDetectChangesEnabled = false;

                int count           = 0;
                var measurementList = MeasurementCache.Values.Where(x => x.LithologicSubID.HasValue);
                for (int i = 0; i < measurementList.Count(); i = i + 100)
                {
                    var entityToInsert = measurementList.Skip(i).Take(100);
                    count   = 100;
                    context = AddMeasurementsToContext(context, entityToInsert, count, 100, true);
                }

                context.SaveChanges();
            }
            finally
            {
                if (context != null)
                {
                    context.Dispose();
                }
            }
        }
示例#5
0
        /// <summary>
        /// Attaches the corresponding descriptions for a measurement interval from the database to the measurement.
        /// </summary>
        /// <param name="dbContext">A DESCDatabase context</param>
        /// <param name="measurement">A measurement interval</param>
        /// <param name="columnNames">The description columns to return</param>
        /// <returns></returns>
        public static async Task <Measurement> MatchDescriptionForMeasurementAsync(DescDBContext dbContext, Measurement measurement, [Optional] ICollection <string> columnNames)
        {
            measurement.SectionInfo = measurement.SectionInfo ?? throw new Exception("Measurement does not have Section information");


            SectionInfo section = await dbContext.Sections.Where(x => measurement.SectionInfo.Equals(x))
                                  .FirstOrDefaultAsync().ConfigureAwait(true);

            if (section == null)
            {
                return(measurement);
            }

            var x = dbContext.LithologicDescriptions
                    .Where(description => description.SectionInfo.Equals(measurement.SectionInfo))
                    .Where(description => description.StartOffset <= measurement.StartOffset && description.EndOffset >= measurement.EndOffset);


            if (columnNames.Any())
            {
                x = x.Include(description => description.DescriptionColumnValues.Where(columnValuPair => columnNames.Contains(columnValuPair.ColumnName))
                              );
            }
            measurement.Descriptions = x.Select(g => g).ToHashSet();

            return(measurement);
        }
示例#6
0
        public static void SendLithologiesToDatabase(Dictionary <string, LithologicDescription> LithologyCache)
        {
            _ = LithologyCache ?? throw new ArgumentNullException(nameof(LithologyCache));

            DescDBContext context = null;

            try
            {
                context = new DescDBContext();
                //context.Configuration.AutoDetectChangesEnabled = false;

                int count = 0;

                var descriptionList = LithologyCache.Values.Where(x => !string.IsNullOrEmpty(x.LithologicID));

                // context.AddRange(descriptionList);

                for (int i = 0; i < descriptionList.Count(); i = i + 100)
                {
                    var entityToInsert = descriptionList.Skip(i).Take(100).ToList();
                    count   = 100;
                    context = AddLithologiesToContext(context, entityToInsert, count, 100, true);
                }

                context.SaveChanges();
            }
            finally
            {
                if (context != null)
                {
                    context.Dispose();
                }
            }
        }
示例#7
0
        public static async Task <bool> CheckForDescriptionAsync(DescDBContext dBContext, LithologicDescription description)
        {
            bool recordExists = await dBContext.LithologicDescriptions
                                .Where(x => x.SectionInfo.ID == description.SectionInfo.ID)
                                .Where(x => x.DescriptionReport == description.DescriptionReport) //Report names may change depending on how we name the files,
                                .Where(x => x.StartOffset == description.StartOffset && x.EndOffset == description.EndOffset)
                                .AnyAsync().ConfigureAwait(true);

            return(recordExists);
        }
示例#8
0
 public static async Task <ICollection <string> > GetUniquePrincipalLithologies()
 {
     using (DescDBContext dbContext = new DescDBContext())
     {
         return(await dbContext.DescriptionColumnValuePairs
                .Where(x => x.CorrectedColumnName == "Principal Lithology")
                .Select(x => x.Value)
                .Distinct()
                .ToListAsync().ConfigureAwait(true));
     }
 }
示例#9
0
 public static async Task <ICollection <string> > GetColumnNamesWhichContainsString(string lookupSet)
 {
     using (DescDBContext dbContext = new DescDBContext())
     {
         return(await dbContext.DescriptionColumnValuePairs
                .Where(x => x.ColumnName.Contains(lookupSet, StringComparison.CurrentCulture))
                .Select(x => x.ColumnName)
                .Distinct()
                .ToListAsync().ConfigureAwait(true));
     }
 }
示例#10
0
        public static void AttemptAtSQLRaw()
        {
            List <LithologicDescription> IrregularOffsets = new List <LithologicDescription>();

            using (DescDBContext dbContext = new DescDBContext())
            {
                IrregularOffsets = dbContext.LithologicDescriptions
                                   .FromSqlRaw(@"SELECT * FROM [DESCDatabase].[dbo].[LithologicDescriptions] t1 WHERE t1.StartOffset > t1.EndOffset")
                                   .ToList();
            }
        }
示例#11
0
        private static DescDBContext AddMeasurementsToContext(DescDBContext context, IEnumerable <Measurement> measurements, int count, int commitCount, bool recreateContext)
        {
            context.AddRange(measurements);

            //Detach all child records which already have been added otherwise I get the following error
            // Cannot insert explicit value for identity column in table ... when IDENTITY_INSERT is set to OFF.
            //Measurements can only get descriptions and subintervals which have already been loaded
            foreach (var measurement in measurements)
            {
                //try detaching only the subinterval
                // context.Entry(measurement.LithologicSubinterval).State = Microsoft.EntityFrameworkCore.EntityState.Detached;
                //context.Entry(measurement.LithologicDescription).State = Microsoft.EntityFrameworkCore.EntityState.Detached;

                context.Entry(measurement.LithologicDescription).State = Microsoft.EntityFrameworkCore.EntityState.Unchanged;

                foreach (LithologicSubinterval subInterval in measurement.LithologicDescription.LithologicSubintervals)
                {
                    if (measurement.LithologicSubinterval.ID != 0)
                    {
                        context.Entry(subInterval).State = Microsoft.EntityFrameworkCore.EntityState.Unchanged;
                    }
                }

                if (measurement.LithologicSubinterval.ID != 0)
                {
                    context.Entry(measurement.LithologicSubinterval).State = Microsoft.EntityFrameworkCore.EntityState.Unchanged;
                }

                //DescriptionColumnValuePairs are tracked and accessed via the measurement's LithologicSubinterval property
                foreach (DescriptionColumnValuePair entry in measurement.LithologicDescription.DescriptionColumnValues)
                {
                    context.Entry(entry).State = Microsoft.EntityFrameworkCore.EntityState.Unchanged;
                }

                if (measurement.SectionInfo.ID != 0)
                {
                    context.Entry(measurement.SectionInfo).State = Microsoft.EntityFrameworkCore.EntityState.Unchanged;
                }
            }

            if (count % commitCount == 0)
            {
                context.SaveChanges();
                if (recreateContext)
                {
                    context.Dispose();
                    context = new DescDBContext();
                }
            }

            return(context);
        }
示例#12
0
        public static async Task <bool> AddDescriptionsToDataBaseAsync(DescDBContext dbContext, ICollection <LithologicDescription> descriptions)
        {
            try
            {
                dbContext.AttachRange(descriptions);
                await dbContext.SaveChangesAsync();

                return(true);
            }
            catch (Exception ex)
            {
                throw new Exception("Error adding descriptions to database context.");
            }
        }
示例#13
0
        /// <summary>
        /// Gets a collection of LithologicDescriptions from a corrected file.
        /// </summary>
        /// <param name="filename"></param>
        /// <param name="columnIdentifiers"></param>
        /// <returns></returns>
        public static async Task <ICollection <LithologicDescription> > GetDescriptionsFromFileAsync(string filename, [Optional] IntervalHierarchyNames columnIdentifiers)
        {
            columnIdentifiers = columnIdentifiers ?? new IntervalHierarchyNames()
            {
                Expedition    = "Expedition_VP",
                Site          = "Site_VP",
                Hole          = "Hole_VP",
                Core          = "Core_VP",
                Type          = "Type_VP",
                Section       = "Section_VP",
                Half          = "SectionHalf_VP",
                TopOffset     = "TopOffset_VP",
                BottomOffset  = "BottomOffset_VP",
                ArchiveTextID = "ArchiveSectionTextID_VP",
                WorkingTextID = "WorkingSectionTextID_VP",
                ParentTextID  = "ParentSectionTextID_VP"
            };

            IODPDataTable iODPDataTable = Importer.ImportDataTableFromFile(filename, columnIdentifiers);

            ICollection <LithologicDescription> descriptions = new HashSet <LithologicDescription>();

            using (DescDBContext dbContext = new DescDBContext())
            {
                try
                {
                    foreach (DataRow row in iODPDataTable.DataTable.Rows)
                    {
                        SectionInfo           section     = new SectionInfo(Importer.GetHierarchyValuesFromDataRow(row, columnIdentifiers));
                        LithologicDescription description = new LithologicDescription();
                        // description.SectionInfo = section;
                        description.SectionInfo = await DatabaseWorkflowHandler.GetSectionInfoFromDatabaseForIntervalAsync(dbContext, section).ConfigureAwait(true);

                        description.LithologicID      = row["LithologicID_VP"].ToString();
                        description.DataRow           = row;
                        description.DescriptionReport = row["Filename_VP"].ToString();;
                        description.StartOffset       = double.TryParse(row[columnIdentifiers.TopOffset].ToString(), out double startOffset) ? startOffset : -1;
                        description.EndOffset         = double.TryParse(row[columnIdentifiers.BottomOffset].ToString(), out double endOffset) ? endOffset : -1;

                        descriptions.Add(description);
                    }
                }
                catch (Exception)
                {
                    throw new Exception("Error creating lithologic description from data row");
                }
            }

            return(descriptions);
        }
示例#14
0
        public static async Task <bool> AddMeasurementsToDataBaseAsync(DescDBContext dbContext, ICollection <Measurement> measurements)
        {
            try
            {
                dbContext.AttachRange(measurements);
                await dbContext.SaveChangesAsync();

                return(true);
            }
            catch (Exception ex)
            {
                Log.Warning(ex.Message);
                throw new Exception("Error adding measurements to database context.");
            }
        }
示例#15
0
 public static async Task <ICollection <Measurement> > GetMeasurementIDsForLithology(string principalLithology)
 {
     using (DescDBContext dbContext = new DescDBContext())
     {
         return(await dbContext.LithologicDescriptions
                .Include(x => x.DescriptionColumnValues
                         .Where(x => x.CorrectedColumnName == "Principal Lithology")
                         .Where(x => x.Value == principalLithology))
                .Include(x => x.LithologicSubintervals)
                .ThenInclude(x => x.Measurements
                             .Where(x => x.InstrumentSystem == "GRA" || x.InstrumentSystem == "MAD"))
                .SelectMany(x => x.LithologicSubintervals)
                .SelectMany(x => x.Measurements)
                .Take(1000)
                .ToListAsync().ConfigureAwait(true));
     }
 }
示例#16
0
        private static DescDBContext AddToContext <TEntity>(DescDBContext context, IEnumerable <TEntity> entities, int count, int commitCount, bool recreateContext) where TEntity : class
        {
            context.AddRange(entities);


            if (count % commitCount == 0)
            {
                context.SaveChanges();
                if (recreateContext)
                {
                    context.Dispose();
                    context = new DescDBContext();
                }
            }

            return(context);
        }
示例#17
0
        public static async Task <bool> GetDescriptionsForMeasurment(string InstrumentSystem, ICollection <string> DescriptionColumns)
        {
            // ICollection<Measurement> measurements;

            using (DescDBContext dbContext = new DescDBContext())
            {
                var measurements = await dbContext.MeasurementDescriptions
                                   .Include(x => x.LithologicSubintervals)
                                   .ThenInclude(x => x.LithologicDescription)
                                   .ThenInclude(x => x.DescriptionColumnValues.Where(x => DescriptionColumns.Contains(x.ColumnName)))
                                   .Where(x => x.InstrumentSystem == InstrumentSystem)
                                   .Take(100)
                                   .Select(x => x)
                                   .ToListAsync().ConfigureAwait(true);
            }

            return(true);
        }
示例#18
0
        /// <summary>
        /// Parses a file into Measurements, checks the database for existence, if records are new uploads to database.
        /// </summary>
        /// <param name="filename"></param>
        /// <param name="columnIdentifiers"></param>
        /// <returns></returns>
        private static async Task <bool> UploadMeasurementsFromFileToDatabaseAsync(string filename, [Optional] IntervalHierarchyNames columnIdentifiers)
        {
            var measurements = await MeasurementHandler.GetMeasurementsFromFileAsync(filename, columnIdentifiers).ConfigureAwait(true);

            ICollection <Measurement> measurementsToRemove = new HashSet <Measurement>();

            using (DescDBContext dBContext = new DescDBContext())
            {
                foreach (var measurement in measurements)
                {
                    var measurementExists = await DatabaseWorkflowHandler.FindMeasurementInDatabase(dBContext, measurement).ConfigureAwait(true);

                    if (measurementExists)
                    {
                        measurementsToRemove.Add(measurement);
                    }
                }
            }

            foreach (var measurement in measurementsToRemove)
            {
                measurements.Remove(measurement);
            }


            if (measurements.Count == 0)
            {
                return(false);
            }

            bool isDataUploaded;

            foreach (var measurement in measurements)
            {
                measurement.MeasurementData.Clear(); //Not uploading measurement report data at the moment
            }

            using (DescDBContext dbContext = new DescDBContext())
            {
                isDataUploaded = await DatabaseWorkflowHandler.AddMeasurementsToDataBaseAsync(dbContext, measurements).ConfigureAwait(true);
            }

            return(isDataUploaded);
        }
示例#19
0
        public static async Task <int> GetMeasurementIDAsync(DescDBContext dbContext, Measurement measurement)
        {
            var record = await dbContext.MeasurementDescriptions
                         .Where(x => x.SectionInfo.ID == measurement.SectionInfo.ID)
                         .Where(x => x.TextID == measurement.TextID)
                         .Where(x => x.TestNumber == measurement.TestNumber)
                         .Where(x => x.InstrumentSystem == measurement.InstrumentSystem)
                         .Where(x => x.StartOffset == measurement.StartOffset && x.EndOffset == measurement.EndOffset)
                         .FirstOrDefaultAsync().ConfigureAwait(true);

            if (record != null)
            {
                return(record.ID);
            }
            else
            {
                return(-1);
            }
        }
示例#20
0
        /// <summary>
        /// T
        /// </summary>
        /// <param name="descriptionsToTake">The number of records to create intervals for before the dbContext is disposed</param>
        /// <returns></returns>
        public static async Task <bool> CreateSubIntervalsForDescriptions(int descriptionsToTake)
        {
            //Do this expedition by expedition, after expedition measurements have been uploaded, this would only need to be called once

            try
            {
                using (DescDBContext dbContext = new DescDBContext())
                {
                    var descriptions = dbContext.LithologicDescriptions
                                       .Include(x => x.SectionInfo)
                                       .Include(x => x.LithologicSubintervals)
                                       .ThenInclude(x => x.SectionInfo)
                                       .Include(x => x.LithologicSubintervals)
                                       .ThenInclude(x => x.LithologicDescription)           //The object graph, I want to add subintervals to a description, and add sectioninfo and description references to those subintervals
                                                                                            // .Where(x => x.SectionInfo.Expedition == expedition)
                                       .Where(x => x.LithologicSubintervals.Any() == false) //The description should not have subintervals generated for it yet.
                                                                                            //  .Where (x=>x.SectionInfo.Expedition == expedition)
                                       .Where(x => x.EndOffset > x.StartOffset)             //There are some descriptions that have incorrectly entered start and end offsets
                                       .Take(descriptionsToTake)
                                       .ToHashSet();

                    if (descriptions.Any() == false)
                    {
                        return(false);
                    }

                    foreach (var description in descriptions)
                    {
                        description.GenerateSubintervals();
                    }

                    dbContext.AttachRange(descriptions);   //I can use Attach, but the objects are being tracked presently, SaveChanges should work just fine
                    dbContext.SaveChanges();
                }
            }
            catch (Exception ex)
            {
                throw new Exception("Error generating subintervals for descriptions.");
            }

            return(true);
        }
示例#21
0
        public static async Task <bool> FindMeasurementInDatabase(DescDBContext dbContext, Measurement measurement)
        {
            //TODO: Throw an error if the measurement doesn't have a sectioninfo ID

            bool recordExists = await dbContext.MeasurementDescriptions
                                .Where(x => x.SectionInfo.ID == measurement.SectionInfo.ID)
                                .Where(x => x.TextID == measurement.TextID)
                                .Where(x => x.TestNumber == measurement.TestNumber)
                                .Where(x => x.StartOffset == measurement.StartOffset && x.EndOffset == measurement.EndOffset)
                                .AnyAsync().ConfigureAwait(true);


            if (recordExists)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
示例#22
0
        private static DescDBContext AddLithologiesToContext(DescDBContext context, IEnumerable <LithologicDescription> descriptions, int count, int commitCount, bool recreateContext)
        {
            context.AddRange(descriptions);

            //Detach all child records which already have been added otherwise I get the following error
            // Cannot insert explicit value for identity column in table 'Sections' when IDENTITY_INSERT is set to OFF.
            foreach (var description in descriptions)
            {
                if (description.SectionInfo.ID != 0)
                {
                    context.Entry(description.SectionInfo).State = Microsoft.EntityFrameworkCore.EntityState.Unchanged;
                }

                foreach (LithologicSubinterval subInterval in description.LithologicSubintervals)
                {
                    //Detach subintervals already added (and have non-zero primary keys)
                    if (subInterval.ID != 0)
                    {
                        context.Entry(subInterval).State = Microsoft.EntityFrameworkCore.EntityState.Unchanged;
                    }
                    //Detach subinterval sectioninfo already added (and have non-zero primary keys)
                    if (subInterval.SectionInfo.ID != 0)
                    {
                        context.Entry(subInterval.SectionInfo).State = Microsoft.EntityFrameworkCore.EntityState.Unchanged;
                    }
                }
            }

            if (count % commitCount == 0)
            {
                context.SaveChanges();
                if (recreateContext)
                {
                    context.Dispose();
                    context = new DescDBContext();
                }
            }

            return(context);
        }
示例#23
0
        private static async Task <bool> UploadDescriptionsFromFileToDatabaseAsync(string filename, [Optional] IntervalHierarchyNames columnIdentifiers)
        {
            var descriptions = await DescriptionHandler.GetDescriptionsFromFileAsync(filename, columnIdentifiers).ConfigureAwait(true);


            try
            {
                using (DescDBContext dBContext = new DescDBContext())
                {
                    foreach (var description in descriptions)
                    {
                        if (await DatabaseWorkflowHandler.CheckForDescriptionAsync(dBContext, description).ConfigureAwait(true))
                        {
                            descriptions.Remove(description);
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }


            if (descriptions.Count == 0)
            {
                return(false);
            }

            bool isDataUploaded;

            using (DescDBContext dbContext = new DescDBContext())
            {
                isDataUploaded = await DatabaseWorkflowHandler.AddDescriptionsToDataBaseAsync(dbContext, descriptions).ConfigureAwait(true);
            }

            return(isDataUploaded);
        }
示例#24
0
 public static async Task <ICollection <Mashup> > GetMeasurementsWithDrillingDisturbances(string instrumentReport)
 {
     using (DescDBContext descDBContext = new DescDBContext())
     {
         return(await descDBContext.MeasurementDescriptions
                .Where(x => x.InstrumentSystem == "GRA")
                .Include(x => x.LithologicSubintervals
                         .Where(x => x.LithologicDescription
                                .DescriptionColumnValues
                                .Any(x => x.ColumnName == "Drilling disturbance type" || x.ColumnName == "Drilling disturbance intensity")))
                .ThenInclude(x => x.LithologicDescription
                             .DescriptionColumnValues
                             .Where(x => x.ColumnName == "Drilling disturbance type" || x.ColumnName == "Drilling disturbance intensity"))
                .SelectMany(measurement => measurement.LithologicSubintervals, (measurement, subinterval) => new { measurement.ID, subinterval })
                .SelectMany(x => x.subinterval.LithologicDescription.DescriptionColumnValues,
                            (x, columnvalues) => new Mashup {
             MeasurementID = x.ID, LithologicSubID = x.subinterval.ID, ColumnValuePairID = columnvalues.ID, ColumnName = columnvalues.ColumnName, ColumnValue = columnvalues.Value
         })
                .Where(x => x.ColumnName == "Drilling disturbance type" || x.ColumnName == "Drilling disturbance intensity")
                .Select(x => x)
                .ToListAsync().ConfigureAwait(true));
     }
 }
示例#25
0
        /// <summary>
        /// Asynchronously gets a collection of IODP measurements from a .csv file.
        /// </summary>
        /// <param name="filename">The .csv file location</param>
        /// <param name="columnIdentifiers">Optional parameter which specifies the file's column names</param>
        /// <returns>A collection of measurements</returns>
        public static async Task <ICollection <Measurement> > GetMeasurementsFromFileAsync(string filename, [Optional] IntervalHierarchyNames columnIdentifiers)
        {
            columnIdentifiers = columnIdentifiers ?? new IntervalHierarchyNames()
            {
                Expedition    = "Exp",
                Site          = "Site",
                Hole          = "Hole",
                Core          = "Core",
                Type          = "Type",
                Section       = "Sect",
                Half          = "A/W",
                TopOffset     = "Offset (cm)",
                BottomOffset  = "Offset (cm)",
                ArchiveTextID = "ArchiveSectionTextID_VP",
                WorkingTextID = "WorkingSectionTextID_VP",
                ParentTextID  = "ParentSectionTextID_VP",
                SampleID      = "Sample",
                TextID        = "Text ID",
                TestNumber    = "Test No.",
            };

            //TODO: need to get this some other way
            string InstrumentSystem = Importer.GetFileNameWithoutExtension(filename);

            if (InstrumentSystem == "CARB" || InstrumentSystem == "ICP")
            {
                columnIdentifiers.TopOffset    = "Top offset on section (cm)";
                columnIdentifiers.BottomOffset = "Bot offset on section (cm)";
            }

            IODPDataTable iODPDataTable = Importer.ImportDataTableFromFile(filename, columnIdentifiers);

            ICollection <Measurement> measurements = new HashSet <Measurement>();

            try
            {
                foreach (DataRow row in iODPDataTable.DataTable.Rows)
                {
                    IntervalHierarchyValues parsedValues = Importer.GetHierarchyValuesFromDataRow(row, columnIdentifiers);

                    Measurement measurement = new Measurement();
                    measurement.SectionInfo      = new SectionInfo(parsedValues); //Creating a SectionInfo here that will be used to find the one stored in the DB.
                    measurement.DataRow          = row;
                    measurement.InstrumentReport = "";
                    measurement.InstrumentSystem = InstrumentSystem;
                    measurement.TextID           = parsedValues.TextID;
                    measurement.TestNumber       = parsedValues.TestNumber;
                    measurement.StartOffset      = double.TryParse(row[columnIdentifiers.TopOffset].ToString(), out double startOffset) ? startOffset : -1;
                    measurement.EndOffset        = double.TryParse(row[columnIdentifiers.BottomOffset].ToString(), out double endOffset) ? endOffset : -1;

                    measurements.Add(measurement);
                }
            }
            catch (Exception)
            {
                throw new Exception("Error creating measurement from data row");
            }

            using (DescDBContext dbContext = new DescDBContext())
            {
                string[] expeditions = measurements.Select(x => x.SectionInfo.Expedition).Distinct().ToArray();

                ICollection <SectionInfo> sections;
                try
                {
                    sections = await DatabaseWorkflowHandler.GetAllSectionsFromDatabaseForExpeditionAsync(dbContext, expeditions).ConfigureAwait(false);
                }
                catch (Exception)
                {
                    throw new Exception("Could not get sections from the database");
                }


                foreach (var measurement in measurements)
                {
                    measurement.SectionInfo = DatabaseWorkflowHandler.GetSectionInfoFromCollection(sections, measurement.SectionInfo);
                }

                return(measurements);
            }
        }
示例#26
0
        public static async Task <ICollection <Measurement> > GetDescriptionsForMeasurementAsync(DescDBContext dBContext, IEnumerable <Measurement> measurements, [Optional] ICollection <string> columnNames)
        {
            var userTasks = new List <Task <Measurement> >();

            foreach (var measurement in measurements)
            {
                userTasks.Add(MatchDescriptionForMeasurementAsync(dBContext, measurement, columnNames));
            }

            return(await Task.WhenAll(userTasks).ConfigureAwait(true));
        }
示例#27
0
        public static async Task <ICollection <LithologicDescription>[]> GetDescriptionsWithinMeasurementIntervalAsync(DescDBContext dBContext, IEnumerable <Measurement> measurements, [Optional] ICollection <string> columnNames)
        {
            var userTasks = new List <Task <ICollection <LithologicDescription> > >();

            foreach (var measurement in measurements)
            {
                userTasks.Add(GetDescriptionsWithinMeasurementIntervalAsync(dBContext, measurement, columnNames));
            }

            return(await Task.WhenAll(userTasks).ConfigureAwait(true));
        }
示例#28
0
        private static async Task <bool> GetMeasurementsForSubIntervals(int skip, int take)
        {
            Console.Clear();

            using (DescDBContext dbContext = new DescDBContext())
            {
                var measurements = dbContext.MeasurementDescriptions
                                   .Where(x => x.ID > 14221456 - 1) //Enable this to start attributing descriptions after a certain ID, it's useful if adding new measurements
                                   .Include(x => x.SectionInfo)
                                   .Include(x => x.LithologicSubintervals)
                                   .Skip(skip)
                                   .Take(take)
                                   .Select(x => x)
                                   .ToHashSet();


                foreach (var measurement in measurements)
                {
                    Console.WriteLine(string.Format("Measurement ID: {0}", measurement.ID.ToString()));


                    List <LithologicSubinterval> matchingSubintervals;
                    try
                    {
                        matchingSubintervals = await dbContext.LithologicSubintervals
                                               .Include(x => x.SectionInfo)
                                               .Where(subinterval => subinterval.SectionInfo.ID == measurement.SectionInfo.ID)
                                               .Where(description =>
                                                      (measurement.StartOffset >= description.StartOffset && measurement.StartOffset <= description.EndOffset) || //Finds an interval in which the measurement falls in part
                                                      (measurement.EndOffset >= description.StartOffset && measurement.EndOffset <= description.EndOffset))
                                               .ToListAsync().ConfigureAwait(true);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine("Error finding subintervals for measurement");
                        continue;
                    }

                    if (matchingSubintervals.Count == 0)
                    {
                        continue;
                    }

                    try
                    {
                        foreach (var subinterval in matchingSubintervals)
                        {
                            //Add only if it doesn't contain the subinterval
                            if (!measurement.LithologicSubintervals.Contains(subinterval))
                            {
                                measurement.LithologicSubintervals.Add(subinterval);
                                Console.WriteLine(string.Format("Added Subinterval ID: {0}", subinterval.ID.ToString()));
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(string.Format("Error adding Subintervals for Measurement: {0}", measurement.ID.ToString()));
                        Console.WriteLine(ex.Message);
                        Console.WriteLine(ex.StackTrace);
                    }
                }
                ;

                await dbContext.SaveChangesAsync().ConfigureAwait(true);
            }

            return(true);
        }
示例#29
0
        public static async Task <bool> GetMeasurementIDForMeasurementFile(string file, string exportFilePath)
        {
            ICollection <Measurement> measurements = await MeasurementHandler.GetMeasurementsFromFileAsync(file).ConfigureAwait(true);

            using (DescDBContext dBContext = new DescDBContext())
            {
                foreach (var measurement in measurements)
                {
                    measurement.ID = await DatabaseWorkflowHandler.GetMeasurementIDAsync(dBContext, measurement).ConfigureAwait(true);
                }
            }

            //Column Names
            HashSet <string> columns = measurements.First().MeasurementData.Select(x => x.ColumnName).ToHashSet();


            //Check if all measurements have the same Columns
            foreach (var measurement in measurements)
            {
                var compareColumns = measurement.MeasurementData.Select(x => x.ColumnName).ToHashSet();
                if (!columns.SetEquals(compareColumns))
                {
                    return(false);
                }
            }


            //TODO: Construct new Datatable

            using (DataTable dataTable = new DataTable())
            {
                foreach (var column in columns)
                {
                    dataTable.Columns.Add(column);
                }
                dataTable.Columns.Add("MeasurementID").SetOrdinal(0);


                int currentRow = 0;
                foreach (var measurement in measurements)
                {
                    dataTable.ImportRow(measurement.DataRow);
                    var row = dataTable.Rows[currentRow];
                    row.BeginEdit();
                    row["MeasurementID"] = measurement.ID;
                    row.EndEdit();

                    currentRow++;
                }

                //AddID column


                //Export measurements to File

                Importer.ExportDataTableAsNewFile(exportFilePath, dataTable);
            }



            return(true);
        }
示例#30
0
 /// <summary>
 /// Asynchronously gets a SectionInfo from the databse for a given measurement or lithologic description interval
 /// </summary>
 /// <param name="dbContext">A DESCDatabase context</param>
 /// <param name="interval">An interval</param>
 /// <returns>A single SectionInfo</returns>
 public static async Task <SectionInfo> GetSectionInfoFromDatabaseForIntervalAsync(DescDBContext dbContext, SectionInfo section)
 {
     return(await dbContext.Sections.Where(record =>
                                           record.Expedition == section.Expedition &&
                                           record.Site == section.Site &&
                                           record.Hole == section.Hole &&
                                           record.Core == section.Core &&
                                           record.Type == section.Type &&
                                           record.Section == section.Section).FirstOrDefaultAsync().ConfigureAwait(true));
 }