Esempio n. 1
0
        static public bool Delete(EGH01DB.IDBContext dbcontext, EmergencyClass emergency_class)
        {
            bool rc = false;

            using (SqlCommand cmd = new SqlCommand("EGH.DeleteEmergencyClass", dbcontext.connection))
            {
                cmd.CommandType = CommandType.StoredProcedure;
                {
                    SqlParameter parm = new SqlParameter("@КодТипаАварии", SqlDbType.Int);
                    parm.Value = emergency_class.type_code;
                    cmd.Parameters.Add(parm);
                }

                {
                    SqlParameter parm = new SqlParameter("@exitrc", SqlDbType.Int);
                    parm.Direction = ParameterDirection.ReturnValue;
                    cmd.Parameters.Add(parm);
                }
                try
                {
                    cmd.ExecuteNonQuery();
                    rc = (int)cmd.Parameters["@exitrc"].Value > 0;
                }
                catch (Exception e)
                {
                    rc = false;
                };
            }

            return(rc);
        }
Esempio n. 2
0
        static public bool Create(EGH01DB.IDBContext dbcontext, EmergencyClass emergency_class)
        {
            bool rc = false;

            using (SqlCommand cmd = new SqlCommand("EGH.CreateEmergencyClass", dbcontext.connection))
            {
                cmd.CommandType = CommandType.StoredProcedure;
                {
                    int new_type_code = 0;
                    if (GetNextCode(dbcontext, out new_type_code))
                    {
                        emergency_class.type_code = new_type_code;
                    }
                    SqlParameter parm = new SqlParameter("@КодТипаАварии", SqlDbType.Int);
                    parm.Value = emergency_class.type_code;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@НаименованиеТипаАварии", SqlDbType.NVarChar);
                    parm.Value = emergency_class.name;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@МинМасса", SqlDbType.Real);
                    parm.Value = emergency_class.minmass;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@МаксМасса", SqlDbType.Real);
                    parm.Value = emergency_class.maxmass;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@exitrc", SqlDbType.Int);
                    parm.Direction = ParameterDirection.ReturnValue;
                    cmd.Parameters.Add(parm);
                }
                try
                {
                    cmd.ExecuteNonQuery();
                    rc = (int)cmd.Parameters["@exitrc"].Value > 0;
                }
                catch (Exception e)
                {
                    rc = false;
                };
            }
            return(rc);
        }
        public ActionResult EmergencyClassUpdate(EmergencyClassView ecv)
        {
            ORTContext db = null;

            ViewBag.EGHLayout = "ORT.EmergencyClass";
            ActionResult view     = View("Index");
            string       menuitem = this.HttpContext.Request.Params["menuitem"] ?? "Empty";

            try
            {
                db = new ORTContext();
                if (menuitem.Equals("EmergencyClass.Update.Update"))
                {
                    int    type_code = ecv.type_code;
                    string name      = ecv.name;

                    string strminmass = this.HttpContext.Request.Params["minmass"] ?? "Empty";
                    float  minmass;
                    Helper.FloatTryParse(strminmass, out minmass);

                    string strmaxmass = this.HttpContext.Request.Params["maxmass"] ?? "Empty";
                    float  maxmass;
                    Helper.FloatTryParse(strmaxmass, out maxmass);


                    EmergencyClass scm = new EGH01DB.Types.EmergencyClass(type_code, name, minmass, maxmass);
                    if (EGH01DB.Types.EmergencyClass.Update(db, scm))
                    {
                        view = View("EmergencyClass", db);
                    }
                }
                else if (menuitem.Equals("EmergencyClass.Update.Cancel"))
                {
                    view = View("EmergencyClass", db);
                }
            }
            catch (RGEContext.Exception e)
            {
                ViewBag.msg = e.message;
            }
            catch (Exception e)
            {
                ViewBag.msg = e.Message;
            }

            return(view);
        }
Esempio n. 4
0
        static public bool GetByMass(EGH01DB.IDBContext dbcontext, float mass, out EmergencyClass emergency_class)
        {
            bool rc = false;

            emergency_class = new EmergencyClass();
            using (SqlCommand cmd = new SqlCommand("EGH.GetEmergencyClassByMass", dbcontext.connection))
            {
                cmd.CommandType = CommandType.StoredProcedure;
                {
                    SqlParameter parm = new SqlParameter("@Масса", SqlDbType.Float);
                    parm.Value = mass;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@exitrc", SqlDbType.Int);
                    parm.Direction = ParameterDirection.ReturnValue;
                    cmd.Parameters.Add(parm);
                }
                try
                {
                    cmd.ExecuteNonQuery();
                    SqlDataReader reader = cmd.ExecuteReader();
                    if (reader.Read())
                    {
                        int    code = (int)reader["КодТипаАварии"];
                        string name = (string)reader["НаименованиеТипаАварии"];
                        float  min  = (float)reader["МинМасса"];
                        float  max  = (float)reader["МаксМасса"];
                        if (rc = (int)cmd.Parameters["@exitrc"].Value > 0)
                        {
                            emergency_class = new EmergencyClass(code, name, min, max);
                        }
                    }
                    reader.Close();
                }
                catch (Exception e)
                {
                    rc = false;
                };
            }
            return(rc);
        }
Esempio n. 5
0
 public RehabilitationMethod(int type_code, RiskObjectType riskobjecttype,
                             CadastreType cadastretype, PetrochemicalCategories petrochemicalcategory,
                             EmergencyClass emergencyclass, PenetrationDepth penetrationdepth,
                             SoilPollutionCategories soilpollutioncategories, bool waterachieved,
                             WaterPollutionCategories waterpollutioncategories, WaterProtectionArea waterprotectionarea,
                             SoilCleaningMethod soilcleaningmethod, WaterCleaningMethod watercleaningmethod)
 {
     this.type_code                = type_code;
     this.riskobjecttype           = riskobjecttype;
     this.cadastretype             = cadastretype;
     this.petrochemicalcategory    = petrochemicalcategory;
     this.emergencyclass           = emergencyclass;
     this.penetrationdepth         = penetrationdepth;
     this.soilpollutioncategories  = soilpollutioncategories;
     this.waterachieved            = waterachieved;
     this.waterpollutioncategories = waterpollutioncategories;
     this.waterprotectionarea      = waterprotectionarea;
     this.soilcleaningmethod       = soilcleaningmethod;
     this.watercleaningmethod      = watercleaningmethod;
 }
        public ActionResult EmergencyClass()
        {
            ORTContext   db   = null;
            ActionResult view = View("Index");

            ViewBag.EGHLayout = "ORT.EmergencyClass";
            string menuitem = this.HttpContext.Request.Params["menuitem"] ?? "Empty";

            try
            {
                db          = new ORTContext();
                ViewBag.msg = "Соединение с базой данных установлено";
                view        = View("EmergencyClass", db);

                if (menuitem.Equals("EmergencyClass.Create"))
                {
                    view = View("EmergencyClassCreate");
                }
                else if (menuitem.Equals("EmergencyClass.Delete"))
                {
                    string type_code = this.HttpContext.Request.Params["type_code"];
                    if (type_code != null)
                    {
                        int c = 0;
                        if (int.TryParse(type_code, out c))
                        {
                            EGH01DB.Types.EmergencyClass scm = new EGH01DB.Types.EmergencyClass();
                            if (EGH01DB.Types.EmergencyClass.GetByCode(db, c, out scm))
                            {
                                view = View("EmergencyClassDelete", scm);
                            }
                        }
                    }
                }
                else if (menuitem.Equals("EmergencyClass.Update"))
                {
                    string type_code = this.HttpContext.Request.Params["type_code"];

                    if (type_code != null)
                    {
                        int c = 0;
                        if (int.TryParse(type_code, out c))
                        {
                            EmergencyClass scm = new EGH01DB.Types.EmergencyClass();

                            if (EGH01DB.Types.EmergencyClass.GetByCode(db, c, out scm))
                            {
                                view = View("EmergencyClassUpdate", scm);
                            }
                        }
                    }
                }
                else if (menuitem.Equals("EmergencyClass.Excel"))
                {
                    EGH01DB.Types.EmergencyClassList list = new EGH01DB.Types.EmergencyClassList(db);
                    XmlNode     node  = list.toXmlNode();
                    XmlDocument doc   = new XmlDocument();
                    XmlNode     nnode = doc.ImportNode(node, true);
                    doc.AppendChild(nnode);
                    doc.Save(Server.MapPath("~/App_Data/EmergencyClass.xml"));
                    view = View("Index");
                    view = File(Server.MapPath("~/App_Data/EmergencyClass.xml"), "text/plain", "Классификация аварий.xml");
                }
            }
            catch (RGEContext.Exception e)
            {
                ViewBag.msg = e.message;
            }
            catch (Exception e)
            {
                ViewBag.msg = e.Message;
            }

            return(view);
        }
Esempio n. 7
0
        static public bool GetByParm(EGH01DB.IDBContext dbcontext,
                                     int riskobjecttypecode,
                                     int cadastretypecode,
                                     int petrochemicalcategorytypecode,
                                     int emergencyclasstypecode,
                                     int penetrationdepthtypecode,
                                     int soilpollutioncategoriestypecode,
                                     bool waterachieved,
                                     int waterpollutioncategoriestypecode,
                                     int waterprotectionareatypecode,
                                     out RehabilitationMethod rehabilitation_method)
        {
            bool rc = false;

            rehabilitation_method = new RehabilitationMethod();
            using (SqlCommand cmd = new SqlCommand("EGH.GetListRehabilitationMethodOnParam", dbcontext.connection))
            {
                cmd.CommandType = CommandType.StoredProcedure;

                {
                    SqlParameter parm = new SqlParameter("@ТипТехногенногоОбъекта", SqlDbType.Int);
                    parm.Value = riskobjecttypecode;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@НазначениеЗемель", SqlDbType.Int);
                    parm.Value = cadastretypecode;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@КатегорияНефтепродукта", SqlDbType.Int);
                    parm.Value = petrochemicalcategorytypecode;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@КлассификацияАварий", SqlDbType.Int);
                    parm.Value = emergencyclasstypecode;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@КатегорияПроникновенияНефтепродукта", SqlDbType.Int);
                    parm.Value = penetrationdepthtypecode;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@КатегорияЗагрязненияГрунта", SqlDbType.Int);
                    parm.Value = soilpollutioncategoriestypecode;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@ДостижениеГоризонтаГрунтовыхВод", SqlDbType.Bit);
                    parm.Value = waterachieved;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@КатегорияЗагрязненияГрунтовыхВод", SqlDbType.Int);
                    parm.Value = waterpollutioncategoriestypecode;
                    cmd.Parameters.Add(parm);
                }
                {
                    SqlParameter parm = new SqlParameter("@КатегорияВодоохраннойТерритории", SqlDbType.Int);
                    parm.Value = waterprotectionareatypecode;
                    cmd.Parameters.Add(parm);
                }

                {
                    SqlParameter parm = new SqlParameter("@exitrc", SqlDbType.Int);
                    parm.Direction = ParameterDirection.ReturnValue;
                    cmd.Parameters.Add(parm);
                }
                try
                {
                    cmd.ExecuteNonQuery();
                    SqlDataReader reader = cmd.ExecuteReader();
                    if (reader.Read())
                    {
                        int code = (int)reader["КодКлассификатора"];

                        int            risk_object_type_code = (int)reader["ТипТехногенногоОбъекта"];
                        string         risk_object_type_name = (string)reader["НаименованиеТипаТехногенногоОбъекта"];
                        RiskObjectType risk_object_type      = new RiskObjectType(risk_object_type_code, risk_object_type_name);

                        int          cadastre_type_code            = (int)reader["НазначениеЗемель"];
                        string       cadastre_type_name            = (string)reader["НаименованиеНазначенияЗемель"];
                        float        cadastre_type_pdk_coef        = (float)reader["ПДК"];
                        float        cadastre_type_water_pdk_coef  = (float)reader["ПДКводы"];
                        string       cadastre_type_ground_doc_name = (string)reader["НормДокументЗемля"];
                        string       cadastre_type_water_doc_name  = (string)reader["НормДокументВода"];
                        CadastreType cadastre_type = new CadastreType(cadastre_type_code, cadastre_type_name, cadastre_type_pdk_coef,
                                                                      cadastre_type_water_pdk_coef, cadastre_type_ground_doc_name, cadastre_type_water_doc_name);

                        int    petrochemical_category_type_code        = (int)reader["КатегорияНефтепродукта"];
                        string petrochemical_category_name             = (string)reader["KN_НаименованиеКатегорииНефтепродукта"];
                        PetrochemicalCategories petrochemical_category = new PetrochemicalCategories(petrochemical_category_type_code, petrochemical_category_name);

                        int            emergency_class_type_code = (int)reader["КлассификацияАварий"];
                        string         emergency_class_name      = (string)reader["KA_НаименованиеТипаАварии"];
                        float          emergency_class_min       = (float)reader["KA_МинМасса"];
                        float          emergency_class_max       = (float)reader["KA_МаксМасса"];
                        EmergencyClass emergency_class           = new EmergencyClass(emergency_class_type_code, emergency_class_name, emergency_class_min, emergency_class_max);

                        int              penetration_depth_type_code = (int)reader["КатегорияПроникновенияНефтепродукта"];
                        string           penetration_depth_name      = (string)reader["PN_НаименованиеТипаКатегории"];
                        float            penetration_depth_min       = (float)reader["PN_МинДиапазон"];
                        float            penetration_depth_max       = (float)reader["PN_МаксДиапазон"];
                        PenetrationDepth penetration_depth           = new PenetrationDepth(penetration_depth_type_code, penetration_depth_name, penetration_depth_min, penetration_depth_max);

                        int                     soil_pollution_categories_type_code          = (int)reader["КатегорияЗагрязненияГрунта"];
                        string                  soil_pollution_categories_name               = (string)reader["GP_НаименованиеКатегорииЗагрязненияГрунта"];
                        float                   soil_pollution_categories_min                = (float)reader["GP_МинДиапазон"];
                        float                   soil_pollution_categories_max                = (float)reader["GP_МаксДиапазон"];
                        int                     soil_pollution_categories_cadastre_type_code = (int)reader["GP_КодНазначенияЗемель"];
                        CadastreType            soil_pollution_categories_cadastre_type      = new CadastreType(soil_pollution_categories_cadastre_type_code);
                        SoilPollutionCategories soilpollution_categories = new SoilPollutionCategories(soil_pollution_categories_type_code,
                                                                                                       soil_pollution_categories_name,
                                                                                                       soil_pollution_categories_min,
                                                                                                       soil_pollution_categories_max,
                                                                                                       soil_pollution_categories_cadastre_type);
                        bool                     water_achieved = (bool)reader["ДостижениеГоризонтаГрунтовыхВод"];
                        int                      water_pollution_categories_type_code          = (int)reader["КатегорияЗагрязненияГрунтовыхВод"];
                        string                   water_pollution_categories_name               = (string)reader["WG_НаименованиеКатегорииЗагрязненияГВ"];
                        float                    water_pollution_categories_min                = (float)reader["WG_МинДиапазон"];
                        float                    water_pollution_categories_max                = (float)reader["WG_МаксДиапазон"];
                        int                      water_pollution_categories_cadastre_type_code = (int)reader["WG_КодНазначенияЗемель"];
                        CadastreType             water_pollution_categories_cadastre_type      = new CadastreType(water_pollution_categories_cadastre_type_code);
                        WaterPollutionCategories water_pollution_categories = new WaterPollutionCategories(water_pollution_categories_type_code,
                                                                                                           water_pollution_categories_name,
                                                                                                           water_pollution_categories_min,
                                                                                                           water_pollution_categories_max,
                                                                                                           water_pollution_categories_cadastre_type);
                        int    water_protection_area_type_code    = (int)reader["КатегорияВодоохраннойТерритории"];
                        string water_protection_area_name         = (string)reader["WT_НаименованиеКатегории"];
                        WaterProtectionArea water_protection_area = new WaterProtectionArea(water_protection_area_type_code, water_protection_area_name);

                        int                soil_cleaning_method_type_code = (int)reader["КатегорияМЛЗагрязненияПГ"];
                        string             soil_cleaning_method_name      = (string)reader["PG_ОписаниеМетода"];
                        SoilCleaningMethod soil_cleaning_method           = new SoilCleaningMethod(soil_cleaning_method_type_code, soil_cleaning_method_name);

                        int    water_cleaning_method_type_code    = (int)reader["КатегорияМЛЗагрязненияГВ"];
                        string water_cleaning_method_name         = (string)reader["PW_ОписаниеМетода"];
                        WaterCleaningMethod water_cleaning_method = new WaterCleaningMethod(water_cleaning_method_type_code, water_cleaning_method_name);

                        if (rc = (int)cmd.Parameters["@exitrc"].Value > 0)
                        {
                            rehabilitation_method = new RehabilitationMethod(code,
                                                                             risk_object_type,
                                                                             cadastre_type,
                                                                             petrochemical_category,
                                                                             emergency_class,
                                                                             penetration_depth,
                                                                             soilpollution_categories,
                                                                             water_achieved,
                                                                             water_pollution_categories,
                                                                             water_protection_area,
                                                                             soil_cleaning_method,
                                                                             water_cleaning_method);
                        }
                    }
                    reader.Close();
                }
                catch (Exception e)
                {
                    rc = false;
                };
            }
            return(true);
        }