Ejemplo n.º 1
0
        public bool DeleteWellWorkoverQueryCheckReferences(int wellWorkoverQueryId)
        {
            try
            {
                using (var db = new QueryBuilderEntities())
                {
                    if (db.WellWorkoverQueries.Count(m => m.WellWorkoverQueryId == wellWorkoverQueryId) > 0)
                    {
                        return(false);
                    }

                    var myObj = db.WellWorkoverQueries.Where(s => s.WellWorkoverQueryId == wellWorkoverQueryId).ToList();
                    if (!myObj.Any())
                    {
                        return(false);
                    }
                    db.WellWorkoverQueries.Remove(myObj[0]);
                    var txx = db.SaveChanges();
                    return(txx > 0);
                }
            }
            catch (Exception ex)
            {
                ErrorLogger.LogEror(ex.StackTrace, ex.Source, ex.Message);
                return(false);
            }
        }
Ejemplo n.º 2
0
        public long AddIncidentQueryCheckDuplicate(IncidentQuery incidentQuery)
        {
            try
            {
                if (incidentQuery == null)
                {
                    return(-2);
                }
                using (var db = new QueryBuilderEntities())
                {
                    if (db.IncidentQueries.Any())
                    {
                        if (db.IncidentQueries.Count(m => m.IncidentQueryName.ToLower().Trim().Replace(" ", "") == incidentQuery.IncidentQueryName.ToLower().Trim().Replace(" ", "")) > 0)
                        {
                            return(-4);
                        }
                    }

                    var processedIncidentQuery = db.IncidentQueries.Add(incidentQuery);
                    db.SaveChanges();
                    return(processedIncidentQuery.IncidentQueryId);
                }
            }
            catch (Exception ex)
            {
                ErrorLogger.LogEror(ex.StackTrace, ex.Source, ex.Message);
                return(0);
            }
        }
        public long AddWellCompletionQueryCheckDuplicate(WellCompletionQuery wellCompletionQuery)
        {
            try
            {
                if (wellCompletionQuery == null)
                {
                    return(-2);
                }
                using (var db = new QueryBuilderEntities())
                {
                    if (db.WellCompletionQueries.Any())
                    {
                        if (db.WellCompletionQueries.Count(m => m.WellId == wellCompletionQuery.WellId &&
                                                           m.CompanyId == wellCompletionQuery.CompanyId &&
                                                           (m.StartDate != null && m.StartDate.Value.Year == wellCompletionQuery.StartDate.Value.Year && wellCompletionQuery.StartDate != null) &&
                                                           (m.EndDate != null && m.EndDate.Value.Year == wellCompletionQuery.EndDate.Value.Year && wellCompletionQuery.EndDate != null) &&
                                                           m.EquipmentId == wellCompletionQuery.EquipmentId &&
                                                           m.TerrainId == wellCompletionQuery.TerrainId &&
                                                           m.ZoneId == wellCompletionQuery.ZoneId &&
                                                           m.CompletionTypeId == wellCompletionQuery.CompletionTypeId &&
                                                           m.WellClassId == wellCompletionQuery.WellClassId &&
                                                           m.WellTypeId == wellCompletionQuery.WellTypeId
                                                           ) > 0)
                        {
                            return(-3);
                        }

                        if (db.WellCompletionQueries.Count(m => m.WellCompletionQueryName.ToLower().Trim().Replace(" ", "") == wellCompletionQuery.WellCompletionQueryName.ToLower().Trim().Replace(" ", "")
                                                           ) > 0)
                        {
                            return(-4);
                        }
                    }

                    var processedWellCompletionQuery = db.WellCompletionQueries.Add(wellCompletionQuery);
                    db.SaveChanges();
                    return(processedWellCompletionQuery.WellCompletionQueryId);
                }
            }
            catch (Exception ex)
            {
                ErrorLogger.LogEror(ex.StackTrace, ex.Source, ex.Message);
                return(0);
            }
        }
        public long AddProductionQueryCheckDuplicate(ProductionQuery productionQuery)
        {
            try
            {
                if (productionQuery == null)
                {
                    return(-2);
                }
                using (var db = new QueryBuilderEntities())
                {
                    if (db.ProductionQueries.Any())
                    {
                        if (db.ProductionQueries.Count(m => (m.ProductId == productionQuery.ProductId &&
                                                             m.CompanyId == productionQuery.CompanyId &&
                                                             m.FieldId == productionQuery.FieldId &&
                                                             (m.StartDate != null && m.StartDate.Value.Year == productionQuery.StartDate.Value.Year && productionQuery.StartDate != null) &&
                                                             (m.EndDate != null && m.EndDate.Value.Year == productionQuery.EndDate.Value.Year && productionQuery.EndDate != null) &&
                                                             m.BlockId == productionQuery.BlockId)
                                                       ) > 0)
                        {
                            return(-3);
                        }

                        if (db.ProductionQueries.Count(m => m.ProductionQueryName.ToLower().Trim().Replace(" ", "") == productionQuery.ProductionQueryName.ToLower().Trim().Replace(" ", "")
                                                       ) > 0)
                        {
                            return(-4);
                        }
                    }

                    var processedProductionQuery = db.ProductionQueries.Add(productionQuery);
                    db.SaveChanges();
                    return(processedProductionQuery.ProductionQueryId);
                }
            }
            catch (Exception ex)
            {
                ErrorLogger.LogEror(ex.StackTrace, ex.Source, ex.Message);
                return(0);
            }
        }
Ejemplo n.º 5
0
        public long AddFieldQueryCheckDuplicate(FieldQuery fieldQuery)
        {
            try
            {
                if (fieldQuery == null)
                {
                    return(-2);
                }
                using (var db = new QueryBuilderEntities())
                {
                    if (db.FieldQueries.Any())
                    {
                        if (db.FieldQueries.Count(m => m.ZoneId == fieldQuery.ZoneId &&
                                                  m.CompanyId == fieldQuery.CompanyId &&
                                                  m.TerrainId == fieldQuery.TerrainId &&
                                                  m.ZoneId == fieldQuery.ZoneId
                                                  ) > 0)
                        {
                            return(-3);
                        }

                        if (db.FieldQueries.Count(m => m.FieldQueryName.ToLower().Trim().Replace(" ", "") == fieldQuery.FieldQueryName.ToLower().Trim().Replace(" ", "")
                                                  ) > 0)
                        {
                            return(-4);
                        }
                    }

                    var processedFieldQuery = db.FieldQueries.Add(fieldQuery);
                    db.SaveChanges();
                    return(processedFieldQuery.FieldQueryId);
                }
            }
            catch (Exception ex)
            {
                ErrorLogger.LogEror(ex.StackTrace, ex.Source, ex.Message);
                return(0);
            }
        }