예제 #1
0
        protected void FillViewBag(EXP_DrugDeclaration model)
        {
            var drugPrimaryRepo = new DrugPrimaryRepository();

            ViewData["ContractList"] =
                new SelectList(new ContractRepository(false).GetActiveContractListWithInfo(model.OwnerId), "Id",
                               "ContractInfo", model.ContractId);
            var repository = new ReadOnlyDictionaryRepository();

            ViewData["AccelerationTypeList"] = new SelectList(repository.GetAccelerationTypes(), "Id",
                                                              "NameRu", model.AccelerationTypeId);

            ViewData["TypeList"] = new SelectList(repository.GetDicTypes(), "Id",
                                                  "NameRu", model.TypeId);

            if (model.RegisterId > 0 && model.sr_register != null)
            {
                model.ReestrNumber  = model.sr_register.reg_number + "/" + model.sr_register.reg_number_kz;
                model.ReestrRegDate = model.sr_register.reg_date.ToShortDateString();
                if (model.sr_register.expiration_date != null)
                {
                    model.ReestrExpirationDate = model.sr_register.expiration_date.Value.ToShortDateString();
                }
                var reestrDrug = new ExternalRepository().GEtRegisterDrugById(model.RegisterId);
                if (reestrDrug != null)
                {
                    model.NumberNd = reestrDrug.nd_number;
                }
            }

            if (model.ExpDrugChangeTypes.Count == 0)
            {
                model.ExpDrugChangeTypes.Add(new EXP_DrugChangeType());
            }
            if (model.ExpDrugProtectionDocs.Count == 0)
            {
                model.ExpDrugProtectionDocs.Add(new EXP_DrugProtectionDoc());
            }
            if (model.ExpDrugOtherCountries.Count == 0)
            {
                model.ExpDrugOtherCountries.Add(new EXP_DrugOtherCountry());
            }
            if (model.ExpDrugExportTrades.Count == 0)
            {
                model.ExpDrugExportTrades.Add(new EXP_DrugExportTrade());
            }
            if (model.ExpDrugPatents.Count == 0)
            {
                model.ExpDrugPatents.Add(new EXP_DrugPatent());
            }
            if (model.ExpDrugTypes.Count == 0)
            {
                model.ExpDrugTypes.Add(new EXP_DrugType());
            }

            /*  if (model.ExpDrugWrappings.Count == 0)
             * {
             *    model.ExpDrugWrappings.Add(new EXP_DrugWrapping());
             * }*/

            if (model.ExpDrugOrganizationses.Count == 0)
            {
                model.ExpDrugOrganizationses.Add(new EXP_DrugOrganizations());
            }
            if (model.ExpDrugDosages.Count == 0)
            {
                model.ExpDrugDosages.Add(new EXP_DrugDosage());
            }

            /*if (model.ExpDrugPrices.Count == 0)
             * {
             *  model.ExpDrugPrices.Add(new EXP_DrugPrice());
             * }*/
            var externalRepository = new ExternalRepository();
            var countries          = externalRepository.GetCounties().ToArray();

            ViewData["Counties"] = new SelectList(countries, "Id", "name", 0);
            for (var i = 0; i < model.ExpDrugExportTrades.Count; i++)
            {
                ViewData["Counties" + i] = new SelectList(countries, "Id", "name",
                                                          model.ExpDrugExportTrades[i].CountryId);
            }

            var types     = repository.GetDrugType().ToArray();
            var typeKinds = repository.GetDrugTypeKinds().ToArray();

            ViewData["DrugTypes"]     = new SelectList(types, "Id", "NameRu", 0);
            ViewData["DrugTypeKinds"] = new SelectList(typeKinds, "Id", "NameRu", 0);
            for (var i = 0; i < model.ExpDrugTypes.Count; i++)
            {
                ViewData["DrugTypes" + i]     = new SelectList(types, "Id", "NameRu", model.ExpDrugTypes[i].DrugTypeId);
                ViewData["DrugTypeKinds" + i] = new SelectList(typeKinds, "Id", "NameRu",
                                                               model.ExpDrugTypes[i].DrugTypeKind);
            }

            model.AtcCodeses = externalRepository.GetAtcList();

            var methods = externalRepository.GetUseMethods();

            model.MethodUseList = new MultiSelectList(methods, "id", "name", model.MethodUseIds);

            /*  ViewData["SaleTypeList"] = new SelectList(repository.GetSaleType(), "Id",
             *    "NameRu", model.SaleTypeId);*/

            var measures = externalRepository.GetMeasures();

            ViewData["MeasureList"] = new SelectList(measures, "Id",
                                                     "name", null);
            var wrappingTypes = repository.GetWrappingTypes().ToArray();
            var boxes         = externalRepository.GetBoxes().ToArray();

            ViewData["WrappingTypes"]     = new SelectList(wrappingTypes, "Id", "NameRu", 0);
            ViewData["Boxes"]             = new SelectList(boxes, "id", "name", 0);
            ViewData["MeasureShortList"]  = new SelectList(measures, "id", "short_name", 0);
            ViewData["SizeMeasureList"]   = new SelectList(measures, "id", "short_name", 0);
            ViewData["VolumeMeasureList"] = new SelectList(measures, "id", "short_name", 0);

            var booleans = repository.GetBooleanList();

            ViewData["Booleans"] = new SelectList(booleans, "IsSign", "NameRu", false);

            var origins        = repository.GetOrigins().ToArray();
            var plantKinds     = repository.GetPlantKinds().ToArray();
            var normDocs       = repository.GetExpDicNormDocFarms().ToArray();
            var substanceTypes = externalRepository.GetSubstanceTypes().ToArray();

            ViewData["SubstanceTypes"]       = new SelectList(substanceTypes, "Id", "name", null);
            ViewData["Origins"]              = new SelectList(origins, "Id", "NameRu", null);
            ViewData["NormDocs"]             = new SelectList(normDocs, "Id", "NameRu", null);
            ViewData["PlantKinds"]           = new SelectList(plantKinds, "Id", "NameRu", null);
            ViewData["IsControlList"]        = new SelectList(booleans, "IsSign", "NameRu", null);
            ViewData["IsPoisonList"]         = new SelectList(booleans, "IsSign", "NameRu", null);
            ViewData["SubstanceCounties"]    = new SelectList(countries, "Id", "name", 0);
            ViewData["SubstanceMeasureList"] = new SelectList(measures, "id", "short_name", 0);
            var sales = repository.GetSaleType().ToList();

            ViewData["SaleTypeList"] = new SelectList(sales, "Id", "NameRu", null);
            ViewData["BestBeforeMeasureTypeList"] = new SelectList(measures, "id", "short_name",
                                                                   null);
            ViewData["AppPeriodMixMeasureList"] = new SelectList(measures, "id", "short_name",
                                                                 null);
            ViewData["AppPeriodOpenMeasureList"] = new SelectList(measures, "id", "short_name",
                                                                  null);



            var drugDeclarationRepository = new DrugDeclarationRepository();

            for (var i = 0; i < model.ExpDrugDosages.Count; i++)
            {
                var dosage = model.ExpDrugDosages[i];
                if (dosage.ExpDrugWrappings == null || dosage.ExpDrugWrappings.Count == 0)
                {
                    dosage.ExpDrugWrappings = new List <EXP_DrugWrapping> {
                        new EXP_DrugWrapping()
                    };
                }
                if (dosage.ExpDrugSubstances == null || dosage.ExpDrugSubstances.Count == 0)
                {
                    dosage.ExpDrugSubstances = new List <EXP_DrugSubstance> {
                        new EXP_DrugSubstance()
                        {
                            ExpDrugSubstanceManufactures = new List <EXP_DrugSubstanceManufacture>()
                            {
                                new EXP_DrugSubstanceManufacture()
                            }
                        }
                    };
                }
                if (dosage.ExpDrugPrices == null)
                {
                    dosage.ExpDrugPrices = new List <EXP_DrugPrice>();
                }

                ViewData["MeasureList" + dosage.Id] = new SelectList(measures, "Id", "name",
                                                                     model.ExpDrugDosages[i].DosageMeasureTypeId);
                ViewData["SaleTypeList" + dosage.Id] = new SelectList(sales, "Id", "NameRu", model.ExpDrugDosages[i].SaleTypeId);
                ViewData["BestBeforeMeasureTypeList" + dosage.Id] = new SelectList(measures, "id", "short_name",
                                                                                   model.ExpDrugDosages[i].BestBeforeMeasureTypeDicId);
                ViewData["AppPeriodMixMeasureList" + dosage.Id] = new SelectList(measures, "id", "short_name",
                                                                                 model.ExpDrugDosages[i].AppPeriodMixMeasureDicId);
                ViewData["AppPeriodOpenMeasureList" + dosage.Id] = new SelectList(measures, "id", "short_name",
                                                                                  model.ExpDrugDosages[i].AppPeriodOpenMeasureDicId);
                for (var j = 0; j < dosage.ExpDrugWrappings.Count; j++)
                {
                    var wrap = dosage.ExpDrugWrappings[j];
                    ViewData["WrappingTypes" + wrap.Id] = new SelectList(wrappingTypes, "Id", "NameRu",
                                                                         wrap.WrappingTypeId);
                    ViewData["Boxes" + wrap.Id]           = new SelectList(boxes, "Id", "name", wrap.WrappingKindId);
                    ViewData["SizeMeasureList" + wrap.Id] = new SelectList(measures, "Id", "short_name",
                                                                           wrap.SizeMeasureId);
                    ViewData["VolumeMeasureList" + wrap.Id] = new SelectList(measures, "Id", "short_name",
                                                                             wrap.VolumeMeasureId);
                }

                for (var j = 0; j < dosage.ExpDrugPrices.Count; j++)
                {
                    var price = dosage.ExpDrugPrices[j];
                    model.ExpDrugDosages[i].ExpDrugPrices[j].PrimaryText      = drugDeclarationRepository.GetNameByWrappingNames(price.PrimaryValue);
                    model.ExpDrugDosages[i].ExpDrugPrices[j].SecondaryText    = drugDeclarationRepository.GetNameByWrappingNames(price.SecondaryValue);
                    model.ExpDrugDosages[i].ExpDrugPrices[j].IntermediateText = drugDeclarationRepository.GetNameByWrappingNames(price.IntermediateValue);
                }

                for (var j = 0; j < dosage.ExpDrugSubstances.Count; j++)
                {
                    var id = dosage.ExpDrugSubstances[j].Id.ToString();
                    dosage.ExpDrugSubstances[j].CategoryName = GetCategoryName(dosage.ExpDrugSubstances[j].sr_substances);
                    dosage.ExpDrugSubstances[j].CategoryPos  = dosage.ExpDrugSubstances[j].sr_substances?.category_pos;
                    ViewData["SubstanceTypes" + id]          = new SelectList(substanceTypes, "Id", "name",
                                                                              dosage.ExpDrugSubstances[j].SubstanceTypeId);
                    ViewData["Origins" + id]    = new SelectList(origins, "Id", "NameRu", dosage.ExpDrugSubstances[j].OriginId);
                    ViewData["NormDocs" + id]   = new SelectList(normDocs, "Id", "NameRu", dosage.ExpDrugSubstances[j].NormDocFarmId);
                    ViewData["PlantKinds" + id] = new SelectList(plantKinds, "Id", "NameRu",
                                                                 dosage.ExpDrugSubstances[j].PlantKindId);
                    ViewData["SubstanceMeasureList" + id] = new SelectList(measures, "Id", "short_name",
                                                                           dosage.ExpDrugSubstances[j].MeasureId);

                    /*          ViewData["SubstanceCounties" + id] = new SelectList(countries, "Id", "name",
                     *            dosage.ExpDrugSubstances[j].CountryId);*/
                    ViewData["IsControlList" + id] = new SelectList(booleans, "IsSign", "NameRu",
                                                                    dosage.ExpDrugSubstances[j].IsControl);
                    ViewData["IsPoisonList" + id] = new SelectList(booleans, "IsSign", "NameRu",
                                                                   dosage.ExpDrugSubstances[j].IsPoison);

                    /*  ViewData["SubstanceCounties" + i] = new SelectList(countries, "Id", "name",
                     *    dosage.ExpDrugSubstances[j].CountryId);*/
                    if (dosage.ExpDrugSubstances[j].ExpDrugSubstanceManufactures != null)
                    {
                        for (var k = 0; k < dosage.ExpDrugSubstances[j].ExpDrugSubstanceManufactures.Count; k++)
                        {
                            ViewData[
                                "SubstanceCounties" + dosage.ExpDrugSubstances[j].ExpDrugSubstanceManufactures[k].Id
                            ] =
                                new SelectList(countries, "Id", "name",
                                               dosage.ExpDrugSubstances[j].ExpDrugSubstanceManufactures[k].CountryId);
                        }
                    }
                    else
                    {
                        dosage.ExpDrugSubstances[j].ExpDrugSubstanceManufactures =
                            new List <EXP_DrugSubstanceManufacture> {
                            new EXP_DrugSubstanceManufacture()
                        };
                    }
                }
            }



            ViewData["IsGrlsList"] = new SelectList(booleans, "IsSign", "NameRu", model.IsGrls);
            ViewData["IsGmpList"]  = new SelectList(booleans, "IsSign", "NameRu", model.IsGmp);

            var manufactures = repository.GetManufactureTypeList();

            ViewData["ManufactureTypeList"] = new SelectList(manufactures, "Id", "NameRu", model.ManufactureTypeId);

            /*    ViewData["BestBeforeMeasureTypeList"] = new SelectList(measures, "id", "short_name",
             *      model.BestBeforeMeasureTypeDicId);
             *  ViewData["AppPeriodMixMeasureList"] = new SelectList(measures, "id", "short_name",
             *      model.AppPeriodMixMeasureDicId);
             *  ViewData["AppPeriodOpenMeasureList"] = new SelectList(measures, "id", "short_name",
             *      model.AppPeriodOpenMeasureDicId);
             */
            for (var i = 0; i < model.ExpDrugOtherCountries.Count; i++)
            {
                ViewData["OtherCounties" + i] = new SelectList(countries, "Id", "name",
                                                               model.ExpDrugOtherCountries[i].CountryId);
            }

            var orgManufactureTypes = repository.GetDictionaries(CodeConstManager.DIC_ORG_MANUFACTURE_TYPE);
            var countyDics          = repository.GetDictionaries(CodeConstManager.DIC_COUNTRY_TYPE);
            var opfTypeDics         = repository.GetDictionaries(CodeConstManager.DIC_OPF_TYPE);

            ViewData["OrgManufactureTypes"] = new SelectList(orgManufactureTypes, "Id", "Name", null);
            ViewData["CountryDics"]         = new SelectList(countyDics, "Id", "Name", null);
            ViewData["OpfTypeDics"]         = new SelectList(opfTypeDics, "Id", "Name", null);

            for (var i = 0; i < model.ExpDrugOrganizationses.Count; i++)
            {
                var id = model.ExpDrugOrganizationses[i].Id.ToString();
                ViewData["OrgManufactureTypes" + id] = new SelectList(orgManufactureTypes, "Id", "name",
                                                                      model.ExpDrugOrganizationses[i].OrgManufactureTypeDicId);
                ViewData["CountryDics" + id] = new SelectList(countyDics, "Id", "name",
                                                              model.ExpDrugOrganizationses[i].CountryDicId);
                ViewData["OpfTypeDics" + id] = new SelectList(opfTypeDics, "Id", "name",
                                                              model.ExpDrugOrganizationses[i].OpfTypeDicId);
                var manufacture = repository.GetDictionaryById(CodeConstManager.DIC_ORG_MANUFACTURE_TYPE,
                                                               model.ExpDrugOrganizationses[i].OrgManufactureTypeDicId);
                if (manufacture != null)
                {
                    model.ExpDrugOrganizationses[i].ManufactureName = manufacture.Name;
                }
            }
            var changeTypes = repository.GetDicChangeTypes().ToArray();

            ViewData["ChangeTypes"] = new SelectList(changeTypes, "Id", "Code", 0);
            for (var i = 0; i < model.ExpDrugChangeTypes.Count; i++)
            {
                ViewData["ChangeTypes" + i] = new SelectList(changeTypes, "Id", "Code",
                                                             model.ExpDrugChangeTypes[i].ChangeTypeId);
            }

            var markList = drugPrimaryRepo.GetPrimaryMarkList(model.Id, null);

            var remarkTypes = repository.GetRemarkTypes().ToArray();

            ViewData["RemarkTypes" + model.Id] = new SelectList(remarkTypes, "Id", "NameRu",
                                                                null);
            model.ExpExpertiseStageRemarks = new List <EXP_ExpertiseStageRemark>();
            foreach (var expDrugPrimaryRemark in markList)
            {
                model.ExpExpertiseStageRemarks.Add(expDrugPrimaryRemark);
            }

            if (model.ExpExpertiseStageRemarks.Count == 0)
            {
                model.ExpExpertiseStageRemarks.Add(new EXP_ExpertiseStageRemark());
            }
            else
            {
                model.IsShowRemark = true;
            }

            foreach (var expDrugPrimaryRemark in model.ExpExpertiseStageRemarks)
            {
                ViewData["RemarkTypes" + model.Id + "_" + expDrugPrimaryRemark.Id] = new SelectList(remarkTypes,
                                                                                                    "Id", "NameRu",
                                                                                                    expDrugPrimaryRemark.RemarkTypeId);
            }
            ViewBag.PaymentOverdue = model.EXP_DirectionToPays.Any(e => e.Type == 1 &&
                                                                   e.Status.Code == Dictionary.ExpDirectionToPayStatus.PaymentExpired);
            model.Letters = new List <EXP_DrugCorespondence>(drugPrimaryRepo.GetDrugCorespondences(model.Id, true));
        }
예제 #2
0
        public void SetDrugReestr(Guid modelId, long dosageId, int?reestrId)
        {
            var drugTypes = new Dictionary <int, int>();

            drugTypes.Add(1, 1);   //Лекарственный препарат
            drugTypes.Add(2, 2);   //Иммунобиологический препарат
            drugTypes.Add(3, 3);   //Лекарственное растительное сырье (сборы)
            drugTypes.Add(4, 4);   //Гомеопатический препарат
            drugTypes.Add(6, 5);   //Лекарственная субстанция
            drugTypes.Add(7, 6);   //Лекарственный балк-продукт
            drugTypes.Add(8, 7);   //Иммунобиологический балк-продукт
            drugTypes.Add(9, 8);   //Радиопрепарат
            drugTypes.Add(10, 9);  //Не фармакопейное лекарственное растительное сырье
            drugTypes.Add(11, 10); //Лекарственный препарат биологического происхождения

            var monufactureType = new Dictionary <int, string>();

            monufactureType.Add(1, "1");  //Производитель
            monufactureType.Add(2, "2");  //Держатель лицензии
                                          //            monufactureType.Add(3, "1"); //Дистрибьютор
            monufactureType.Add(4, "4");  //Предприятие-упаковщик
            monufactureType.Add(5, "5");  //Заявитель
                                          //            monufactureType.Add(6, "1"); //Производитель субстанции
                                          //            monufactureType.Add(7, "1"); //Разработчик
                                          //            monufactureType.Add(8, "3"); //Владелец регистрационного удостоверения
            monufactureType.Add(9, "7");  //Выпускающий контроль
            monufactureType.Add(10, "3"); //Держатель регистрационного удостоверения

            var model = AppContext.EXP_DrugDeclaration.FirstOrDefault(e => e.Id == modelId);

            if (model == null)
            {
                return;
            }
            var drug   = new ExternalRepository().GEtRegisterDrugById(reestrId);
            var reestr = new ExternalRepository().GetReestrById(reestrId.Value);

            if (!string.IsNullOrEmpty(model.NameRu))
            {
                model.NameRu = reestr.name;
            }
            if (!string.IsNullOrEmpty(model.NameKz))
            {
                model.NameKz = reestr.name_kz;
            }
            if (!string.IsNullOrEmpty(model.ConcentrationRu))
            {
                model.ConcentrationRu = drug.concentration;
            }
            if (!string.IsNullOrEmpty(model.ConcentrationKz))
            {
                model.ConcentrationKz = drug.concentration_kz;
            }
            if (model.AtxId == null)
            {
                model.AtxId = drug.atc_id;
            }
            if (model.MnnId == null)
            {
                model.MnnId = drug.int_name_id;
            }
            if (model.DrugFormId == null)
            {
                model.DrugFormId = drug.dosage_form_id;
            }

            if (drugTypes.ContainsKey(drug.drug_type_id))
            {
                if (model.EXP_DrugType.Count == 0)
                {
                    var type = new EXP_DrugType();
                    type.DrugTypeId = drugTypes[drug.drug_type_id];
                    model.EXP_DrugType.Add(type);
                }
                else
                {
                    model.EXP_DrugType.First().DrugTypeId = drugTypes[drug.drug_type_id];
                }
            }
            if (drug.sr_register_use_methods.Count > 0)
            {
                var usemethod = model.EXP_DrugUseMethod.Select(e => e.UseMethodsId) ?? new List <int>();
//                AppContext.EXP_DrugUseMethod.RemoveRange(model.EXP_DrugUseMethod);
                foreach (var drugSrRegisterUseMethod in drug.sr_register_use_methods)
                {
                    if (!usemethod.Contains(drugSrRegisterUseMethod.use_method_id))
                    {
                        var useMethod = new EXP_DrugUseMethod {
                            UseMethodsId = drugSrRegisterUseMethod.use_method_id
                        };
                        model.EXP_DrugUseMethod.Add(useMethod);
                    }
                }
            }
            var repository          = new ReadOnlyDictionaryRepository();
            var orgManufactureTypes = repository.GetDictionaries(CodeConstManager.DIC_ORG_MANUFACTURE_TYPE);
            var countyDics          = repository.GetDictionaries(CodeConstManager.DIC_COUNTRY_TYPE).OrderBy(x => x.Name);

            if (reestr.sr_register_producers.Count > 0)
            {
                AppContext.EXP_DrugOrganizations.RemoveRange(model.EXP_DrugOrganizations);
                foreach (var registerProducer in reestr.sr_register_producers)
                {
                    var producer = new EXP_DrugOrganizations();
                    if (registerProducer.sr_producers != null)
                    {
                        producer.NameRu = registerProducer.sr_producers.name;
                        producer.NameEn = registerProducer.sr_producers.name_eng;
                        producer.NameKz = registerProducer.sr_producers.name_kz;
                        producer.Bin    = registerProducer.sr_producers.bin;

                        if (monufactureType.ContainsKey(registerProducer.sr_producers.type_id))
                        {
                            var orgManufactureType =
                                orgManufactureTypes.FirstOrDefault(
                                    e => e.Code == monufactureType[registerProducer.sr_producers.type_id]);
                            if (orgManufactureType != null)
                            {
                                producer.OrgManufactureTypeDicId = orgManufactureType.Id;
                            }
                        }
                    }
                    if (registerProducer.sr_countries != null)
                    {
                        var country =
                            countyDics.FirstOrDefault(
                                e => e.Name.ToLower() == registerProducer.sr_countries.name.ToLower());
                        if (country != null)
                        {
                            producer.CountryDicId = country.Id;
                        }
                    }
                    model.EXP_DrugOrganizations.Add(producer);
                }
            }
            if (reestr.sr_register_substances.Count > 0)
            {
                EXP_DrugDosage dosage;
                if (dosageId == 0)
                {
                    dosage = new EXP_DrugDosage
                    {
                        ConcentrationRu = drug.concentration,
                        ConcentrationKz = drug.concentration_kz,
                    };
                }
                else
                {
                    dosage = AppContext.EXP_DrugDosage.FirstOrDefault(e => e.Id == dosageId);
                    AppContext.EXP_DrugSubstance.RemoveRange(dosage.EXP_DrugSubstance);
                    AppContext.EXP_DrugPrice.RemoveRange(dosage.EXP_DrugPrice);
                    AppContext.EXP_DrugWrapping.RemoveRange(dosage.EXP_DrugWrapping);
                }

                /*  foreach (var expDrugDosage in model.EXP_DrugDosage)
                 * {
                 *    AppContext.EXP_DrugSubstance.RemoveRange(expDrugDosage.EXP_DrugSubstance);
                 *    AppContext.EXP_DrugPrice.RemoveRange(expDrugDosage.EXP_DrugPrice);
                 *    AppContext.EXP_DrugWrapping.RemoveRange(expDrugDosage.EXP_DrugWrapping);
                 * }
                 * AppContext.EXP_DrugDosage.RemoveRange(model.EXP_DrugDosage);
                 */

                if (drug.dosage_value != null)
                {
                    dosage.Dosage = drug.dosage_value.Value;
                }
                dosage.DosageMeasureTypeId = drug.dosage_measure_id;
                dosage.RegisterId          = reestrId;

                foreach (var reestrSrRegisterSubstance in reestr.sr_register_substances)
                {
                    var substance = new EXP_DrugSubstance
                    {
                        SubstanceId     = reestrSrRegisterSubstance.substance_id,
                        SubstanceTypeId = reestrSrRegisterSubstance.substance_type_id,
                        CountryId       = reestrSrRegisterSubstance.country_id,
                        MeasureId       = reestrSrRegisterSubstance.measure_id
                    };
                    if (reestrSrRegisterSubstance.substance_count != null)
                    {
                        substance.SubstanceCount = reestrSrRegisterSubstance.substance_count.ToString();
                    }
                    dosage.EXP_DrugSubstance.Add(substance);
                }

                foreach (var registerBoxes in reestr.sr_register_boxes)
                {
                    var wrapping = new EXP_DrugWrapping()
                    {
                        WrappingKindId  = registerBoxes.box_id,
                        VolumeMeasureId = registerBoxes.volume_measure_id,
                        CountUnit       = registerBoxes.unit_count,
                        Note            = registerBoxes.description,
                    };

                    if (registerBoxes.volume != null)
                    {
                        wrapping.WrappingVolume = double.Parse(registerBoxes.volume.ToString());
                    }
                    if (!string.IsNullOrEmpty(registerBoxes.box_size))
                    {
                        double size;
                        if (double.TryParse(registerBoxes.box_size, out size))
                        {
                            wrapping.WrappingSize = size;
                        }
                    }
                    dosage.EXP_DrugWrapping.Add(wrapping);
                }
                if (dosage.Id == 0)
                {
                    model.EXP_DrugDosage.Add(dosage);
                }
            }
            try
            {
                AppContext.SaveChanges();
            }
            catch (DbEntityValidationException e)
            {
                foreach (var eve in e.EntityValidationErrors)
                {
                    Console.WriteLine("Entity of type \"{0}\" in state \"{1}\" has the following validation errors:",
                                      eve.Entry.Entity.GetType().Name, eve.Entry.State);
                    foreach (var ve in eve.ValidationErrors)
                    {
                        Console.WriteLine("- Property: \"{0}\", Error: \"{1}\"",
                                          ve.PropertyName, ve.ErrorMessage);
                    }
                }
                throw;
            }
        }