Example #1
0
        public ActionResult CreateMaterial(Guid?id)
        {
            MaterialRepository      repository      = new MaterialRepository(false);
            EXP_DrugDeclaration     drugDeclaration = null;
            CreateMaterialViewModel vm = new CreateMaterialViewModel()
            {
                DrugDeclarationId = id,
                Id = null
            };

            if (id.HasValue)
            {
                //EXP_Materials material = new EXP_Materials(){};
                drugDeclaration = repository.GetDrugDeclaration(d => d.Id == id).Include(d => d.sr_dosage_forms).First();
                if (drugDeclaration.DrugFormId != null)
                {
                    vm.DrugFormId   = drugDeclaration.DrugFormId;
                    vm.DrugFormName = drugDeclaration.sr_dosage_forms.name;

                    vm.IsNpp = repository.GetIsControlFormDrugDeclaration(id.Value);
                }
            }

            return(View(vm));
        }
Example #2
0
        public ActionResult UpdateTmcListChildrens([DataSourceRequest] DataSourceRequest request, TmcOffViewModel dictionary)
        {
            EXP_DrugDeclaration drugDeclaration = null;

            if (dictionary.RefExtertiseStatement != null)
            {
                drugDeclaration = db.EXP_DrugDeclaration
                                  .FirstOrDefault(d => d.Id == dictionary.RefExtertiseStatement.Value);
            }

            TmcOff tmcOff = db.TmcOffs.First(o => o.Id == dictionary.Id);

            tmcOff.StateType   = dictionary.StateType;
            tmcOff.CreatedDate = dictionary.CreatedDate;
            tmcOff.Count       = dictionary.Count;
            tmcOff.Note        = dictionary.Note;
            tmcOff.StateType   = dictionary.StateType;
            if (drugDeclaration != null)
            {
                tmcOff.ExpertiseStatementId      = dictionary.RefExtertiseStatement;
                tmcOff.ExpertiseStatementNumber  = drugDeclaration.Number;
                tmcOff.ExpertiseStatementTypeStr = drugDeclaration.EXP_DIC_Type.NameRu;
            }

            db.SaveChanges();

            var item = db.TmcOffViews.First(o => o.Id == tmcOff.Id);

            dictionary.CreatedEmployeeValue = item.CreatedEmployeeValue;
            return(Json(new[] { dictionary }.ToDataSourceResult(request, ModelState)));
        }
        /// <summary>
        /// Создание заявление
        /// </summary>
        /// <returns></returns>
        public ActionResult Create()
        {
            var model = new EXP_DrugDeclaration
            {
                OwnerId                 = UserHelper.GetCurrentEmployee().Id,
                Id                      = Guid.NewGuid(),
                EditorId                = UserHelper.GetCurrentEmployee().Id.ToString(),
                StatusId                = CodeConstManager.STATUS_DRAFT_ID,
                ExpDrugExportTrades     = new List <EXP_DrugExportTrade>(),
                ExpDrugPatents          = new List <EXP_DrugPatent>(),
                ExpDrugTypes            = new List <EXP_DrugType>(),
                ExpDrugProtectionDocs   = new List <EXP_DrugProtectionDoc>(),
                ExpDrugOtherCountries   = new List <EXP_DrugOtherCountry>(),
                ExpDrugOrganizationses  = new List <EXP_DrugOrganizations>(),
                ExpDrugDosages          = new List <EXP_DrugDosage>(),
                ExpDrugChangeTypes      = new List <EXP_DrugChangeType>(),
                ConclusionSafetyReports = new List <ConclusionSafetyReport>()
            };

            FillViewBag(model);
            return(View(model));
        }
        /// <summary>
        /// Получить код Страны и Типа заявления
        /// </summary>
        /// <param name="repository">Репозиторий</param>
        /// <param name="drugDeclaration">ИД Заявления</param>
        /// <param name="countryCode">Код страны</param>
        /// <param name="typeCode">Код типа</param>
        /// <param name="countryCodes">Коды стран </param>
        private void GetCountryCodeAndTypeCode(DirectionToPayRepository repository, EXP_DrugDeclaration drugDeclaration, out string countryCode, out string typeCode, ref List <string> countryCodes)
        {
            // Страна
            countryCode = string.Empty;
            if (drugDeclaration.EXP_DrugOrganizations != null)
            {
                foreach (var drugOrg in drugDeclaration.EXP_DrugOrganizations)
                {
                    var isManufacturer = repository.GetOrgManufactureTypes().Any(mt => mt.Id == drugOrg.OrgManufactureTypeDicId &&
                                                                                 mt.Code == Dictionary.OrgManufactureType.Manufacturer);
                    if (drugOrg.CountryDicId != null && isManufacturer)
                    {
                        var cCode = repository.GetCountryCode(drugOrg.CountryDicId.Value);
                        countryCodes.Add(cCode);
                        countryCode = cCode;
                    }
                }
            }

            // Тип заявления
            typeCode = drugDeclaration.EXP_DIC_Type.Code;
        }
Example #5
0
        protected void FillDeclarationControl(EXP_DrugDeclaration model)
        {
            model.EditorId            = UserHelper.GetCurrentEmployee().Id.ToString();
            model.ExpDrugExportTrades = new List <EXP_DrugExportTrade>();
            var exportTrades = model.EXP_DrugExportTrade.OrderBy(e => e.Id);

            foreach (var record in exportTrades)
            {
                model.ExpDrugExportTrades.Add(record);
            }

            model.ExpDrugPatents = new List <EXP_DrugPatent>();
            var expPatent = model.EXP_DrugPatent.OrderBy(e => e.Id);

            foreach (var record in expPatent)
            {
                model.ExpDrugPatents.Add(record);
            }

            model.ExpDrugTypes = new List <EXP_DrugType>();
            var expDrugType = model.EXP_DrugType.OrderBy(e => e.Id);

            foreach (var record in expDrugType)
            {
                model.ExpDrugTypes.Add(record);
            }

            /*     model.ExpDrugWrappings = new List<EXP_DrugWrapping>();
             *   var expDrugWrapping = model.EXP_DrugWrapping.OrderBy(e => e.Id);
             *   foreach (var record in expDrugWrapping)
             *   {
             *       model.ExpDrugWrappings.Add(record);
             *   }*/

            model.ExpDrugOtherCountries = new List <EXP_DrugOtherCountry>();
            var expDrugOtherCountries = model.EXP_DrugOtherCountry.OrderBy(e => e.Id);

            foreach (var record in expDrugOtherCountries)
            {
                model.ExpDrugOtherCountries.Add(record);
            }
            model.ExpDrugProtectionDocs = new List <EXP_DrugProtectionDoc>();
            var expDrugProtectionDocs = model.EXP_DrugProtectionDoc.OrderBy(e => e.Id);

            foreach (var record in expDrugProtectionDocs)
            {
                model.ExpDrugProtectionDocs.Add(record);
            }
            model.ExpDrugOrganizationses = new List <EXP_DrugOrganizations>();
            var expDrugOrganizationses = model.EXP_DrugOrganizations.OrderBy(e => e.Id);

            foreach (var record in expDrugOrganizationses)
            {
                model.ExpDrugOrganizationses.Add(record);
            }
            model.ExpDrugDosages = new List <EXP_DrugDosage>();
            var expDrugDosages = model.EXP_DrugDosage.OrderBy(e => e.Id);

            model.ConclusionSafetyReports = new List <ConclusionSafetyReport>();
            foreach (var record in expDrugDosages)
            {
                if (record.RegisterId > 0 && record.sr_register != null)
                {
                    record.ReestrNumber  = record.sr_register.reg_number + "/" + record.sr_register.reg_number_kz;
                    record.ReestrRegDate = record.sr_register.reg_date.ToShortDateString();
                    if (record.sr_register.expiration_date != null)
                    {
                        record.ReestrExpirationDate = record.sr_register.expiration_date.Value.ToShortDateString();
                    }
                    var reestrDrug = new ExternalRepository().GEtRegisterDrugById(record.RegisterId);
                    if (reestrDrug != null)
                    {
                        record.NumberNd = reestrDrug.nd_number;
                    }
                }
                record.ExpDrugWrappings = new List <EXP_DrugWrapping>();
                foreach (var expDrugWrapping in record.EXP_DrugWrapping)
                {
                    record.ExpDrugWrappings.Add(expDrugWrapping);
                }
                record.ExpDrugPrices = new List <EXP_DrugPrice>();
                foreach (var drugPrice in record.EXP_DrugPrice)
                {
                    record.ExpDrugPrices.Add(drugPrice);
                }
                model.ExpDrugDosages.Add(record);

                record.ExpDrugSubstances = new List <EXP_DrugSubstance>();

                for (var d = 0; d < record.EXP_DrugSubstance.Count; d++)
                {
                    record.ExpDrugSubstances.Add(record.EXP_DrugSubstance.ToList()[d]);
                    record.EXP_DrugSubstance.ToList()[d].ExpDrugSubstanceManufactures = new List <EXP_DrugSubstanceManufacture>();
                    foreach (var expDrugSubstanceManufacture in record.EXP_DrugSubstance.ToList()[d].EXP_DrugSubstanceManufacture)
                    {
                        record.EXP_DrugSubstance.ToList()[d].ExpDrugSubstanceManufactures.Add(expDrugSubstanceManufacture);
                    }
                }

                /*      foreach (var substance in record.EXP_DrugSubstance)
                 *    {
                 *        record.ExpDrugSubstances.Add(substance);
                 *
                 *    }*/

                if (model.StatusId > 6)
                {
                    model.ConclusionSafetyReports.Add(new SafetyreportRepository().ConclusionSafetyReportsFromDosage(record.Id, false));
                    model.ConclusionSafetyReports.Add(new SafetyreportRepository().ConclusionSafetyReportsFromDosage(record.Id, true));
                }
            }
            if (model.StatusId > 6)
            {
                var item = new SafetyreportRepository().ConclusionSafetyReportsFromFiles(model.Id, UserHelper.GetCurrentEmployee());
                foreach (var conclusionSafetyReport in item)
                {
                    model.ConclusionSafetyReports.Add(conclusionSafetyReport);
                }
            }
            if (model.ConclusionSafetyReports.Count > 0)
            {
                model.IsShowConclision = true;
            }
            model.ExpDrugChangeTypes = new List <EXP_DrugChangeType>();
            var changeTypes = model.EXP_DrugChangeType.OrderBy(e => e.Id);

            foreach (var record in changeTypes)
            {
                model.ExpDrugChangeTypes.Add(record);
            }

            /*  model.ExpDrugPrices = new List<EXP_DrugPrice>();
             * var expDrugPrices = model.EXP_DrugPrice.OrderBy(e => e.Id);
             * foreach (var record in expDrugPrices)
             * {
             *    model.ExpDrugPrices.Add(record);
             * }*/
            model.MethodUseIds =
                model.EXP_DrugUseMethod.Select(e => e.UseMethodsId.ToString(CultureInfo.InvariantCulture)).ToList();

            if (model.TypeId > 1)
            {
                if (model.TypeId == 3)
                {
                    model.IsShowChange = true;
                }
                else
                {
                    if (model.sr_register != null && model.sr_register.expiration_date != null)
                    {
                        if (model.TypeId != 2)
                        {
                            var t     = model.sr_register.expiration_date.Value - model.CreatedDate;
                            var month = t.TotalDays;

                            if (month > 90)
                            {
                                model.IsShowChange = true;
                            }
                        }
                    }
                }
            }

            var primaryEntity = new PrimaryEntity
            {
                EXP_DrugDeclaration = model,
                DrugDeclarationId   = model.ObjectId,
                Editor = UserHelper.GetCurrentEmployee(),
                ExpExpertiseStageRemarks = new List <EXP_ExpertiseStageRemark>(),
            };

            FillViewBag(model);
        }
Example #6
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));
        }
        private List <EXP_DirectionToPays_PriceList> CreateDefaultPriceLists(EXP_DrugDeclaration drugDeclaration)
        {
            var priceLists = new List <EXP_DirectionToPays_PriceList>();
            DirectionToPayRepository repository = new DirectionToPayRepository();
            decimal?price = 0;

            string        countryCode, typeCode;
            List <string> countryCodes = new List <string>();

            /*
             * // Страна
             *
             * if (drugDeclaration.EXP_DrugOrganizations != null)
             * {
             *  foreach (var drugOrg in drugDeclaration.EXP_DrugOrganizations)
             *  {
             *      if (drugOrg.CountryDicId != null)
             *      {
             *          var cCode = repository.GetCountryCode(drugOrg.CountryDicId.Value);
             *          countryCodes.Add(cCode);
             *          countryCode = cCode;
             *      }
             *  }
             * }
             *
             * // Тип заявления
             * string typeCode = drugDeclaration.EXP_DIC_Type.Code;
             */
            GetCountryCodeAndTypeCode(repository, drugDeclaration, out countryCode, out typeCode, ref countryCodes);

            if (typeCode == TypeCodeConts.Alteration)
            {
                return(priceLists);
            }

            // Тип ЛС
            var drugType = drugDeclaration.EXP_DrugType?.FirstOrDefault();

            if (drugType != null)
            {
                var drugMapping = repository.GetPriceListMappingByDrugFormCode(drugType.EXP_DIC_DrugType.Code);
                if (drugMapping != null)
                {
                    if (drugDeclaration.EXP_DrugDosage != null)
                    {
                        // Многокомпонентный или однокомпонентный
                        int activeLsCount = 0;
                        int packageCount  = 0;
                        foreach (var dosage in drugDeclaration.EXP_DrugDosage)
                        {
                            activeLsCount += dosage.EXP_DrugSubstance.Count;
                            packageCount  += dosage.EXP_DrugWrapping.Count;
                        }
                        // однокомпонентный
                        string priceListNumber = drugMapping.PriceListCode;
                        // Многокомпонентный
                        if (activeLsCount > 1)
                        {
                            priceListNumber = drugMapping.PriceListMulticomponentCode;
                        }

                        var priceList = repository.GetPriceList(p => p.Category == null && p.Number == priceListNumber)
                                        .FirstOrDefault();
                        if (priceList != null)
                        {
                            price = priceList.GetPrice(countryCode, typeCode);

                            priceLists.Add(new EXP_DirectionToPays_PriceList()
                            {
                                PriceListId = priceList.Id,
                                Count       = 1,
                                Price       = price,
                                Total       = 1 * price
                            });
                        }

                        // Дополнительно каждой лекарственной дозы
                        var dosageCount = drugDeclaration.EXP_DrugDosage.Count;
                        if (dosageCount > 1)
                        {
                            var priceListNumberDc  = priceListNumber + ".1";
                            var priceListAddDosage =
                                repository.GetPriceList(p => p.Category == null && p.Number == priceListNumberDc)
                                .FirstOrDefault();
                            if (priceListAddDosage != null)
                            {
                                price = priceListAddDosage.GetPrice(countryCode, typeCode);

                                priceLists.Add(new EXP_DirectionToPays_PriceList()
                                {
                                    PriceListId = priceListAddDosage.Id,
                                    Count       = dosageCount,
                                    Price       = price,
                                    Total       = dosageCount * price
                                });
                            }
                        }

                        // Дополнительно каждой фасовки
                        if (packageCount > 1)
                        {
                            var priceListNumberDc   = priceListNumber + ".2";
                            var priceListAddPackage =
                                repository.GetPriceList(p => p.Category == null && p.Number == priceListNumberDc)
                                .FirstOrDefault();
                            if (priceListAddPackage != null)
                            {
                                price = priceListAddPackage.GetPrice(countryCode, typeCode);

                                priceLists.Add(new EXP_DirectionToPays_PriceList()
                                {
                                    PriceListId = priceListAddPackage.Id,
                                    Count       = packageCount,
                                    Price       = price,
                                    Total       = packageCount * price
                                });
                            }
                        }
                    }
                }
            }

            return(priceLists);
        }
Example #8
0
        private bool ToNextStage(EXP_DrugDeclaration declaration, Guid?fromStageId, int[] nextStageIds, out string resultDescription)
        {
            resultDescription = null;
            string[] activeStageCodes = { EXP_DIC_StageStatus.New, EXP_DIC_StageStatus.InWork, EXP_DIC_StageStatus.InReWork };
            var      currentStage     = fromStageId != null?AppContext.EXP_ExpertiseStage.FirstOrDefault(e => e.Id == fromStageId)
                                            : AppContext.EXP_ExpertiseStage.FirstOrDefault(e => e.DeclarationId == declaration.Id && activeStageCodes.Contains(e.EXP_DIC_StageStatus.Code));

            var dosageIds = AppContext.EXP_DrugDosage.Where(e => e.DrugDeclarationId == declaration.Id)
                            .Select(e => e.Id)
                            .ToList();
            var stageStatusNew    = GetStageStatusByCode(EXP_DIC_StageStatus.New);
            var stageStatusRework = GetStageStatusByCode(EXP_DIC_StageStatus.InReWork);

            //закрываем предыдущий этап
            if (currentStage != null)
            {
                currentStage.StatusId    = GetStageStatusByCode(EXP_DIC_StageStatus.Completed).Id;
                currentStage.FactEndDate = DateTime.Now;
            }
            foreach (var nextStageId in nextStageIds)
            {
                if (!CanSendToStep(declaration.Id, fromStageId, nextStageId, out resultDescription))
                {
                    return(false);
                }
                //если имеется уже выполняющийся этап то продолжаем его дальше
                if (AppContext.EXP_ExpertiseStage.Any(e => e.DeclarationId == declaration.Id &&
                                                      e.StageId == nextStageId && e.EXP_DIC_StageStatus.Code != EXP_DIC_StageStatus.Completed && !e.IsHistory))
                {
                    continue;
                }
                var oldStage = AppContext.EXP_ExpertiseStage.FirstOrDefault(es => es.IsHistory == false &&
                                                                            es.DeclarationId == declaration.Id && es.StageId == nextStageId);
                if (oldStage == null)
                {
                    var daysOnStage = GetExpStageDaysOnExecution(declaration.TypeId, nextStageId);
                    var startDate   = DateTime.Now;
                    var newStage    = new EXP_ExpertiseStage()
                    {
                        Id            = Guid.NewGuid(),
                        DeclarationId = declaration.Id,
                        StageId       = nextStageId,
                        ParentStageId = currentStage != null ? (Guid?)currentStage.Id : null,
                        StatusId      = stageStatusNew.Id,
                        StartDate     = startDate,
                        EndDate       = daysOnStage != null ? (DateTime?)startDate.AddDays(daysOnStage.Value) : null
                    };
                    //todo брать руководителя цоз из настроек
                    newStage.Executors.Add(GetExecutorByDicStageId(nextStageId));
                    foreach (var dosageId in dosageIds)
                    {
                        newStage.EXP_ExpertiseStageDosage.Add(new EXP_ExpertiseStageDosage()
                        {
                            Id                 = Guid.NewGuid(),
                            DosageId           = dosageId,
                            EXP_ExpertiseStage = newStage
                        });
                    }
                    AppContext.EXP_ExpertiseStage.Add(newStage);
                }
                else
                {
                    var reworkStage = new EXP_ExpertiseStage()
                    {
                        Id            = Guid.NewGuid(),
                        DeclarationId = declaration.Id,
                        StageId       = nextStageId,
                        ParentStageId = currentStage != null ? (Guid?)currentStage.Id : null,
                        StatusId      = stageStatusRework.Id,
                        StartDate     = oldStage.StartDate,
                        EndDate       = oldStage.EndDate,
                        OtdIds        = oldStage.OtdIds,
                        OtdRemarks    = oldStage.OtdRemarks
                    };
                    reworkStage.Executors.AddRange(oldStage.Executors);
                    foreach (var dossageStage in oldStage.EXP_ExpertiseStageDosage)
                    {
                        var reworkDosage = new EXP_ExpertiseStageDosage()
                        {
                            Id                 = Guid.NewGuid(),
                            DosageId           = dossageStage.DosageId,
                            EXP_ExpertiseStage = reworkStage
                        };
                        foreach (var primaryFinalDoc in dossageStage.PrimaryFinalDocs)
                        {
                            var docClone = new EXP_ExpertisePrimaryFinalDoc(primaryFinalDoc);
                            docClone.Id = Guid.NewGuid();
                            docClone.EXP_ExpertiseStageDosage = reworkDosage;
                            docClone.DosageStageId            = reworkStage.Id;
                            reworkDosage.PrimaryFinalDocs.Add(docClone);
                        }
                        foreach (var pharmaceuticalFinalDoc in dossageStage.EXP_ExpertisePharmaceuticalFinalDoc)
                        {
                            var docClone = new EXP_ExpertisePharmaceuticalFinalDoc(pharmaceuticalFinalDoc);
                            docClone.Id = Guid.NewGuid();
                            docClone.EXP_ExpertiseStageDosage = reworkDosage;
                            docClone.DosageStageId            = reworkStage.Id;
                            reworkDosage.EXP_ExpertisePharmaceuticalFinalDoc.Add(docClone);
                        }
                        foreach (var pharmacologicalFinalDoc in dossageStage.EXP_ExpertisePharmacologicalFinalDoc)
                        {
                            var docClone = new EXP_ExpertisePharmacologicalFinalDoc(pharmacologicalFinalDoc);
                            docClone.Id = Guid.NewGuid();
                            docClone.EXP_ExpertiseStageDosage = reworkDosage;
                            docClone.DosageStageId            = reworkStage.Id;
                            reworkDosage.EXP_ExpertisePharmacologicalFinalDoc.Add(docClone);
                        }
                        foreach (var safetyreportFinalDoc in dossageStage.EXP_ExpertiseSafetyreportFinalDoc)
                        {
                            var docClone = new EXP_ExpertiseSafetyreportFinalDoc(safetyreportFinalDoc);
                            docClone.Id = Guid.NewGuid();
                            docClone.EXP_ExpertiseStageDosage = reworkDosage;
                            docClone.DosageStageId            = reworkStage.Id;
                            reworkDosage.EXP_ExpertiseSafetyreportFinalDoc.Add(docClone);
                        }
                        foreach (var analiseIndicator in dossageStage.EXP_DrugAnaliseIndicator)
                        {
                            var docClone = new EXP_DrugAnaliseIndicator(analiseIndicator);
                            docClone.Id = Guid.NewGuid();
                            docClone.EXP_ExpertiseStageDosage = reworkDosage;
                            docClone.DosageStageId            = reworkStage.Id;
                            reworkDosage.EXP_DrugAnaliseIndicator.Add(docClone);
                        }
                        reworkStage.EXP_ExpertiseStageDosage.Add(reworkDosage);
                    }
                    AppContext.EXP_ExpertiseStage.Add(reworkStage);
                    oldStage.IsHistory = true;
                }
            }
            AppContext.SaveChanges();
            return(true);
        }