コード例 #1
0
ファイル: Pool.cs プロジェクト: sundersb/invox
        /// <summary>
        /// Получить услуги для события
        /// </summary>
        IEnumerable <ServiceAux> LoadServices(RecourseAux ra, Model.Event evt)
        {
            DbCommand command = null;

            switch (ra.InternalReason)
            {
            case InternalReason.AmbTreatment:
            case InternalReason.DayHosp:
            case InternalReason.SurgeryDayHosp:
                command = selectServicesTreatment;
                break;

            case InternalReason.Stage1:
                command = selectServicesStage1;
                break;

            case InternalReason.Stage2:
                command = selectServicesStage2;
                break;

            case InternalReason.Prof:
                command = selectServicesProf;
                break;

            case InternalReason.Other:
            case InternalReason.BriefTreatment:
            case InternalReason.DispRegister:
            case InternalReason.Emergency:
            case InternalReason.Diagnostics:
                command = selectServicesByDate;
                string d = ra.Date.ToString("MM/dd/yyyy").Replace('.', '/');
                command.Parameters[3].Value = d;
                break;
            }

            if (command != null)
            {
                command.Parameters[0].Value = string.Format("{0,6}", ra.PersonId);
                command.Parameters[1].Value = ra.Department;
                command.Parameters[2].Value = ra.InitialDiagnosis;
                return(aService.Load(command));
            }
            else
            {
                return(null);
            }
        }
コード例 #2
0
ファイル: ServiceAux.cs プロジェクト: sundersb/invox
        /// <summary>
        /// Установить даты начала и окончания услуги и количество услуг
        /// </summary>
        /// <param name="service">Услуга, которую требуется обновить</param>
        void SetDates(Model.Service service, RecourseAux ra)
        {
            if (BedDays <= 1)
            {
                Quantity         = 1;
                service.DateFrom = service.DateTill = Date;
            }
            else
            {
                service.DateTill = Date;
#if GKP3
                // Since we are apriori polyclinic
                service.DateFrom = Date.WorkingDaysBefore(BedDays, true);
#else
                bool dayHospital = ra.InternalReason == InternalReason.DayHosp || ra.InternalReason == InternalReason.SurgeryDayHosp;
                service.DateFrom = Date.WorkingDaysBefore(Quantity, dayHospital);
#endif
            }
        }
コード例 #3
0
ファイル: ServiceAux.cs プロジェクト: sundersb/invox
        /// <summary>
        /// Преобразовать данный объект в модель услуги
        /// </summary>
        /// <param name="ra">Вспомогательный объект законченного случая</param>
        public Model.Service ToService(RecourseAux ra)
        {
            Model.Service result = new Model.Service();

            result.Identity         = ServiceId;
            result.Unit             = ra.Unit;
            result.InterventionKind = InterventionKind;
            result.Child            = ra.Child;

            SetDates(result, ra);

            result.Diagnosis      = ra.MainDiagnosis;
            result.ServiceCode    = ServiceCode;
            result.Quantity       = Quantity;
            result.Tariff         = Tariff;
            result.Total          = Total;
            result.SpecialityCode = SpecialityCode;
            result.DoctorCode     = DoctorCode;
            result.Incomplete     = Incomplete;
            result.Refusal        = Refusal;

            return(result);
        }
コード例 #4
0
ファイル: Pool.cs プロジェクト: sundersb/invox
        /// <summary>
        /// Загрузить события для законченного случая
        /// </summary>
        /// <remarks>
        /// В настоящий момент одному законченному случаю соответствует одно события (т.к. нет
        /// внутрибольничных переводов). Здесь также загружаются услуги для события и обновляются
        /// поля законченного случая данными, которые удалось получить на этом этапе.
        /// </remarks>
        List <Model.Event> LoadEvents(Model.Recourse rec, RecourseAux ra, Model.OrderSection section)
        {
            // Extract single event from the RecourseAux:
            List <Model.Event> result = new List <Model.Event>();

            Model.Event evt = ra.ToEvent(rec, section);
            result.Add(evt);

            // Load auxilliary service records and service models
            List <ServiceAux> ss = LoadServices(ra, evt).Distinct(new ServiceComparer()).OrderBy(s => s.Date).ToList();

            if (ra.InternalReason == InternalReason.SurgeryDayHosp &&
                ss.Count(s => s.ServiceCode == ra.ServiceCode) > 1)
            {
                // Fix for:
                // Два случая ЦАХ у одного пациента с одним и тем же диагнозом
                //  будут выгружены как два случая, но в каждом ВСЕ услуги из обеих госпитализаций

                // Get main service
                ServiceAux sa = ss.FirstOrDefault(s => s.Date == ra.Date && s.ServiceCode == ra.ServiceCode);

                if (sa != null)
                {
                    // Get hospitalization dates
                    DateTime till = sa.Date;
                    DateTime from = till.WorkingDaysBefore(sa.BedDays, true);

                    // Select only services with relevant dates
                    IEnumerable <ServiceAux> sas = ss.Where(s => s.Date <= till && s.Date >= from);
                    ra.UpdateMedicalAid(rec, sas.Last());
                    evt.Services = sas.Select(s => s.ToService(ra)).ToList();

                    // ...supposedly at least one services is selected: the main one
                }
                else
                {
                    ra.UpdateMedicalAid(rec, ss.Last());
                    evt.Services = ss.Select(s => s.ToService(ra)).ToList();
                }
            }
            else
            {
                ra.UpdateMedicalAid(rec, ss.Last());
                evt.Services = ss.Select(s => s.ToService(ra)).ToList();
            }

            // 20190902 - Блядский вид медицинского вмешательства
            if (ra.InternalReason == InternalReason.SurgeryDayHosp)
            {
                Model.Service service = evt.Services.FirstOrDefault(s => s.ServiceCode / 100000 == 3);
                if (service != null)
                {
                    string interventionKind = GetInterventionKind(service.ServiceCode);
                    if (!string.IsNullOrEmpty(interventionKind))
                    {
                        evt.Services.ForEach(s => s.InterventionKind = interventionKind);
                    }
                }
            }

            // Код врача и специальности должны соответствовать закрывающей записи,
            // приводим в соответствие из ra (где было изменено в UpdateMedicalAid())
            evt.SpecialityCode = ra.SpecialityCode;
            evt.DoctorCode     = ra.DoctorCode;

            if (rec.IsHospitalization)
            {
                // Update profile-shifting transfer and total of the bed days
                ServiceAux serv = ss.Where(s => s.Transfer == Model.Transfer.Transferred).FirstOrDefault();

                // Turn transfer to ProfileShift if there has been bed profile change:
                if (serv != null &&
                    ss.GroupBy(s => s.BedProfile).Count() > 1)
                {
                    serv.Transfer = Model.Transfer.ProfileShift;
                }
                evt.BedDays = ss.Select(s => s.BedDays).Sum();
            }

            // Event dates
            if (ra.InternalReason == InternalReason.Stage1 || ra.InternalReason == InternalReason.Prof)
            {
                evt.DateTill = evt.Services.Max(s => s.DateTill);

                // For DD1 - start of the recourse is an antropometry
                ServiceAux sa = ss.Where(s => s.IsAntropometry()).FirstOrDefault();
                if (sa != null)
                {
                    evt.DateFrom = sa.Date;
                }
                else
                {
                    evt.DateFrom = ss.Min(s => s.Date);
                }

#if FOMS1
            }
            else if (ra.InternalReason == InternalReason.Prof)
            {
                // Work around error "Код способа оплаты не соответствует периоду лечения;
                // Цель обращения не соответствует способу оплаты медицинской помощи"
                // Prof events within a single day are discarded with this error
                evt.DateFrom = ra.Date.ShiftDays(-1);

                if (evt.DateFrom == ra.Date)
                {
                    evt.DateTill = ra.Date.ShiftDays(1);
                    Model.Service s = evt.Services.First();
                    if (s != null)
                    {
                        s.DateFrom = evt.DateTill;
                        s.DateTill = evt.DateTill;
                    }
                }
                else
                {
                    evt.DateTill = ra.Date;
                }
#endif
            }
            else
            {
                // For other cases service with minimal date (mayhap hospitalization - reason why not ss.Min())
                // 2 этап - пустая выборка
                try {
                    evt.DateFrom = evt.Services.Min(s => s.DateFrom);
                } catch (Exception e) {
                    Logger.Log(e.Message + string.Format(" - повод {0}, услуга {1}, S.RECID {2}", ra.InternalReason, ra.ServiceCode, ra.ServiceId));
                }
                evt.DateTill = evt.Services.Max(s => s.DateTill);
            }

#if FOMS
            // Задолбал ФОМС с их дурацкими ошибками: дд раз в 2 года ставит "неправильные даты", если дата начала и окончания не совпадают
            // В подушевой услуге ставим даты начала и окончания как во всем закрытом случае

            // 20190417 Хрен там, теперь не только обрезанная ДД
            Model.Service ser = evt.Services.FirstOrDefault(s => s.ServiceCode / 10000 == 5);
            if (ser != null)
            {
                ser.DateFrom = evt.DateFrom;
                ser.DateTill = evt.DateTill;
            }
#endif

            // May change evt and ra's MainDiagnosis:
            ra.FindConcurrentDiagnoses(evt, ss, section);

            // Service diagnosis as recorse's in case of diagnostics
            if (ra.InternalReason == InternalReason.Diagnostics)
            {
                evt.Services.ForEach(s => s.Diagnosis = ra.MainDiagnosis);
            }

            evt.ComplicationDiagnoses = ServiceAux.GetComplicationDiagnoses(ss);

            // Statistic code
            if (!string.IsNullOrEmpty(ra.MainDiagnosis) && ra.MainDiagnosis.First() != 'Z')
            {
                StatisticCode[] sc = ss
                                     .Select(s => s.StatisticCode)
                                     .Where(s => s > StatisticCode.None && s < StatisticCode.Dispensary)
                                     .ToArray();

                if (sc != null && sc.Count() > 0)
                {
                    evt.StatisticsCode = (((int)sc.Max()) - 1).ToString();
                }
                else
                {
                    evt.StatisticsCode = Dict.StatisticsCode.Instance.Get(ra.MainDiagnosis);
                }
            }

            // Профиль МП случая - по профилю закрывающей записи
            rec.Profile = ss.OrderBy(s => s.Date).Last().AidProfile;

            // Other Event fields which can be taken from the services
            evt.Tariff = evt.Services.Sum(s => s.Tariff);
            evt.Total  = evt.Services.Sum(s => s.Total);

            evt.PrimaryDiagnosis = ss.Max(s => s.PrimaryDiagnosis);
            evt.FirstIdentified  = ss.Any(s => s.FirstIdentified);

            if (ra.InternalReason == InternalReason.DispRegister)
            {
                evt.DispensarySupervision = ss.Max(s => s.DispensarySupervision);
                if (evt.DispensarySupervision == Model.DispensarySupervision.None)
                {
                    evt.DispensarySupervision = Model.DispensarySupervision.Observed;
                }
            }
            else if (section == Model.OrderSection.D3)
            {
                // 20190430 - D3 section: disp supervision is explicit
                evt.DispensarySupervision = ss.Max(s => s.DispensarySupervision);
                // Диагнозы на R ФОМС считает подлежащими Д-учету
                if (evt.DispensarySupervision < Model.DispensarySupervision.Observed ||
                    evt.DispensarySupervision > Model.DispensarySupervision.NotSubject)
                {
                    if ("ZY".Contains(evt.MainDiagnosis.First()))
                    {
                        evt.DispensarySupervision = Model.DispensarySupervision.NotSubject;
                    }
                    else
                    {
                        if (evt.FirstIdentified)
                        {
                            evt.DispensarySupervision = Model.DispensarySupervision.Taken;
                        }
                        else
                        {
                            evt.DispensarySupervision = Model.DispensarySupervision.Observed;
                        }
                    }
                }
            }

            evt.ConcurrentMesCode = ss.Max(s => s.ConcurrentMesCode);

            var d2 = ss.Where(s => s.Transfer != Model.Transfer.None);
            if (d2 != null && d2.Count() > 0)
            {
                evt.Transfer = d2.Min(s => s.Transfer);
            }

            // Other Recourse fields -"-
            rec.UnitShift   = ss.Any(s => s.Transfer == Model.Transfer.ProfileShift);
            rec.BirthWeight = ss.Max(s => s.BirthWeight);

            rec.DateFrom = evt.DateFrom;
            rec.DateTill = evt.DateTill;
            rec.Total    = evt.Total;
            rec.BedDays  = evt.BedDays;

            if (RecourseAux.NeedsDirection(rec))
            {
                // Extract directed-from in case when it is needed
                rec.DirectedFrom = ss.Max(s => s.DirectedFrom);
                if (string.IsNullOrEmpty(rec.DirectedFrom))
                {
                    // TODO: LPU code from local to federal
                    rec.DirectedFrom = Options.LpuCode;
                }
                rec.DirectionDate = rec.DateFrom;
            }

            return(result);
        }