Example #1
0
        /// <summary>
        /// retorna medicamentos de unevento determinado y
        /// </summary>
        /// <param name="patientId"></param>
        /// <param name="medicalEventId"></param>
        /// <returns></returns>
        public static PatientMedicament_ViewList RetrivePatientMedicaments(int patientId, int medicalEventId, bool includePermanets)
        {
            PatientMedicament_ViewList list = new PatientMedicament_ViewList();

            using (Health.Back.BE.HealthEntities dc = new Health.Back.BE.HealthEntities(Common.CnnString_Entities))
            {
                var list_db = dc.PatientMedicament_View.Where(
                    p => p.PatientId.Equals(patientId) &&
                    p.MedicalEventId.Equals(medicalEventId)
                    );

                if (includePermanets)
                {
                    var list_Permanent_db = dc.PatientMedicament_View.Where(
                        p => p.PatientId.Equals(patientId) &&
                        !p.MedicalEventId.Equals(medicalEventId) &&
                        (p.Status.Equals((int)MedicamentStatus.Permanente) && p.Enabled
                        ));

                    foreach (PatientMedicament_View patientMedicament_db in list_Permanent_db)
                    {
                        list.Add((PatientMedicament_ViewBE)patientMedicament_db);
                    }
                }
                foreach (PatientMedicament_View patientMedicament_db in list_db)
                {
                    list.Add((PatientMedicament_ViewBE)patientMedicament_db);
                }
            }
            return(list);
        }
Example #2
0
        public override RetrivePatientMedicamentsRes Execute(RetrivePatientMedicamentsReq pServiceRequest)
        {
            RetrivePatientMedicamentsRes wRes = new RetrivePatientMedicamentsRes();
            PatientMedicament_ViewList   wPatientMedicament_ViewBE = new PatientMedicament_ViewList();

            if (pServiceRequest.BusinessData.RetriveHistory)
            {
                wRes.BusinessData = PatientsDAC.RetrivePatientMedicamentsAlls(pServiceRequest.BusinessData.PatientId);
                return(wRes);
            }
            else
            {
                if (pServiceRequest.BusinessData.MedicalEventId.HasValue)
                {
                    wPatientMedicament_ViewBE = PatientsDAC.RetrivePatientMedicaments(pServiceRequest.BusinessData.PatientId, pServiceRequest.BusinessData.MedicalEventId.Value, true);
                }
                else
                {
                    wPatientMedicament_ViewBE = PatientsDAC.RetrivePatientMedicaments(pServiceRequest.BusinessData.PatientId);
                }
            }

            DateTime currentDate = Fwk.HelperFunctions.DateFunctions.GetStartDateTime(DateTime.Now);

            if (wPatientMedicament_ViewBE.Count != 0)
            {
                wRes.BusinessData = new PatientMedicament_ViewList();
            }

            //Realizar aqui actualizacion de medicacion NO permanente que sobrepaso dias resetados por el medico. Enabled = FALSE
            foreach (PatientMedicament_ViewBE item in wPatientMedicament_ViewBE)
            {
                ///Ignorar si la consulta es por id . Por que si viene el id del requetst es por que se esta creando en este momento
                if (!(pServiceRequest.BusinessData.MedicalEventId.HasValue && item.MedicalEventId.Equals(pServiceRequest.BusinessData.MedicalEventId)))
                {
                    if (currentDate > Fwk.HelperFunctions.DateFunctions.GetStartDateTime(item.CreatedDate).AddDays(item.DaysCount) && !item.Status.Equals((int)MedicamentStatus.Permanente))
                    {
                        PatientsDAC.DisablePatientMedicaments(item.PatientMedicamentId, Guid.Parse(pServiceRequest.ContextInformation.UserId), MedicamentStatus.Finalizado);
                        //wRes.BusinessData.Remove(item);
                    }
                    else
                    {
                        wRes.BusinessData.Add(item);
                    }
                }
                else
                {
                    wRes.BusinessData.Add(item);
                }
            }

            return(wRes);
        }
Example #3
0
        /// <summary>
        /// Retorna todos los medicamentos asignados al Patient
        /// No importa si fueron suspendidos
        /// </summary>
        /// <param name="patientId"></param>
        /// <returns></returns>
        public static PatientMedicament_ViewList RetrivePatientMedicamentsAlls(int patientId)
        {
            PatientMedicament_ViewList list = new PatientMedicament_ViewList();

            using (Health.Back.BE.HealthEntities dc = new Health.Back.BE.HealthEntities(Common.CnnString_Entities))
            {
                var list_db = dc.PatientMedicament_View.Where(
                    p => p.PatientId.Equals(patientId));

                foreach (PatientMedicament_View patientMedicament_db in list_db)
                {
                    list.Add((PatientMedicament_ViewBE)patientMedicament_db);
                }
            }
            return(list);
        }
        public override RetrivePatientAppoimentsRes Execute(RetrivePatientAppoimentsReq pServiceRequest)
        {
            RetrivePatientAppoimentsRes wRes = new RetrivePatientAppoimentsRes();
            PatientMedicament_ViewList  wPatientMedicament_ViewBE = new PatientMedicament_ViewList();

            wRes.BusinessData = PatientsDAC.Retrive_Appointment(pServiceRequest.BusinessData.PatientId, pServiceRequest.BusinessData.StartDate, pServiceRequest.BusinessData.Status);

            //DateTime currentDate = Fwk.HelperFunctions.DateFunctions.GetStartDateTime(DateTime.Now);

            if (wPatientMedicament_ViewBE.Count != 0)
            {
                wRes.BusinessData = new Patient_Appointments_ViewList();
            }

            return(wRes);
        }
Example #5
0
        /// <summary>
        /// Retorna medicamentos que el Patient toma regularmente
        /// La medicacion debe estar no suspendida y vigente
        /// Tambien retorna medicacion actual temporal (Esto falta desarrollar)
        /// </summary>
        /// <param name="patientId"></param>
        /// <returns></returns>
        public static PatientMedicament_ViewList RetrivePatientMedicaments(int patientId)
        {
            PatientMedicament_ViewList list = new PatientMedicament_ViewList();

            using (Health.Back.BE.HealthEntities dc = new Health.Back.BE.HealthEntities(Common.CnnString_Entities))
            {
                var list_db = dc.PatientMedicament_View.Where(
                    p => p.PatientId.Equals(patientId) &&
                    !p.Status.Equals((int)MedicamentStatus.Suspendido) &&
                    !p.Status.Equals((int)MedicamentStatus.Finalizado) &&
                    !p.Status.Equals((int)MedicamentStatus.Deshabilitado) &&
                    p.Enabled.Equals(true)
                    );

                foreach (PatientMedicament_View patientMedicament_db in list_db)
                {
                    list.Add((PatientMedicament_ViewBE)patientMedicament_db);
                }
            }
            return(list);
        }
        /// <summary>
        /// Carga Dominios relacionados entre al objeto _RelatedDomains que esta bindiado a la grilla
        /// </summary>
        void Populate(out Exception ex)
        {
            ex = null;

            try
            {
                _PatientAllergy             = ServiceCalls.GetPatientAllergy(ServiceCalls.CurrentPatient.PatientId);
                _PatientMedicament_ViewList = ServiceCalls.RetrivePatientMedicaments(ServiceCalls.CurrentPatient.PatientId, null);
                _MedicalEventAlert_ViewList = ServiceCalls.RetriveMedicalEventAlert(ServiceCalls.CurrentPatient.PatientId, null, false);
                if (MedicalEvent == null)
                {
                    MedicalEvent = new MedicalEventBE();
                    MedicalEvent.MedicalEventId = -1;
                    if (this._Appointment != null)
                    {
                        MedicalEvent.AppointmentId = this._Appointment.AppointmentId;
                    }


                    MedicalEvent.ProfesionalId       = ServiceCalls.CurrentProfesional.IdProfesional;
                    MedicalEvent.IdEspesialidad      = ServiceCalls.CurrentProfesional.IdEspecialidad.Value;
                    MedicalEvent.PatientId           = ServiceCalls.CurrentPatient.PatientId;
                    MedicalEvent.PatientMedicaments  = _PatientMedicament_ViewList;
                    MedicalEvent.HealthInstitutionId = ServiceCalls.CurrentHealthInstitution.HealthInstitutionId;

                    MedicalEvent.MedicalEventId = ServiceCalls.CreateMedicalEvent(MedicalEvent);
                }
                else
                {
                    MedicalEvent.PatientMedicaments = _PatientMedicament_ViewList;
                }
            }
            catch (Exception err)
            {
                err.Source = "Origen de datos";
                ex         = err;
            }
        }
Example #7
0
         /// <summary>
         /// Retorna todos los medicamentos asignados al Patient
         /// No importa si fueron suspendidos 
         /// </summary>
         /// <param name="patientId"></param>
         /// <returns></returns>
         public static PatientMedicament_ViewList RetrivePatientMedicamentsAlls(int patientId)
         {
             PatientMedicament_ViewList list = new PatientMedicament_ViewList();
             using (Health.Back.BE.HealthEntities dc = new Health.Back.BE.HealthEntities(Common.CnnString_Entities))
             {
                 var list_db = dc.PatientMedicament_View.Where(
                     p => p.PatientId.Equals(patientId)                  );

                 foreach (PatientMedicament_View patientMedicament_db in list_db)
                 {
                     list.Add((PatientMedicament_ViewBE)patientMedicament_db);
                 }

             }
             return list;
         }
Example #8
0
        /// <summary>
        /// retorna medicamentos de unevento determinado y
        /// </summary>
        /// <param name="patientId"></param>
        /// <param name="medicalEventId"></param>
        /// <returns></returns>
        public static PatientMedicament_ViewList RetrivePatientMedicaments(int patientId, int medicalEventId, bool includePermanets)
        {
            PatientMedicament_ViewList list = new PatientMedicament_ViewList();
            using (Health.Back.BE.HealthEntities dc = new Health.Back.BE.HealthEntities(Common.CnnString_Entities))
            {
                var list_db = dc.PatientMedicament_View.Where(
                    p => p.PatientId.Equals(patientId)
                    && p.MedicalEventId.Equals(medicalEventId)
                    );

                if (includePermanets)
                {
                    var list_Permanent_db = dc.PatientMedicament_View.Where(
                    p => p.PatientId.Equals(patientId)
                         && !p.MedicalEventId.Equals(medicalEventId)
                    && (p.Status.Equals((int)MedicamentStatus.Permanente) && p.Enabled
                    ));

                    foreach (PatientMedicament_View patientMedicament_db in list_Permanent_db)
                    {
                        list.Add((PatientMedicament_ViewBE)patientMedicament_db);
                    }

                }
                foreach (PatientMedicament_View patientMedicament_db in list_db)
                {
                    list.Add((PatientMedicament_ViewBE)patientMedicament_db);
                }

            }
            return list;
        }
Example #9
0
        /// <summary>
        /// Retorna medicamentos que el Patient toma regularmente
        /// La medicacion debe estar no suspendida y vigente
        /// Tambien retorna medicacion actual temporal (Esto falta desarrollar)
        /// </summary>
        /// <param name="patientId"></param>
        /// <returns></returns>
        public static PatientMedicament_ViewList RetrivePatientMedicaments(int patientId)
        {
            PatientMedicament_ViewList list = new PatientMedicament_ViewList();
            using (Health.Back.BE.HealthEntities dc = new Health.Back.BE.HealthEntities(Common.CnnString_Entities))
            {
                var list_db = dc.PatientMedicament_View.Where(
                    p => p.PatientId.Equals(patientId)
                    &&  !p.Status.Equals((int)MedicamentStatus.Suspendido)
                    && !p.Status.Equals((int)MedicamentStatus.Finalizado)
                    && !p.Status.Equals((int)MedicamentStatus.Deshabilitado)
                    && p.Enabled.Equals(true)
                    );

                foreach (PatientMedicament_View patientMedicament_db in list_db)
                {
                    list.Add((PatientMedicament_ViewBE)patientMedicament_db);
                }

            }
            return list;
        }
        /// <summary>
        /// Carga Dominios relacionados entre al objeto _RelatedDomains que esta bindiado a la grilla
        /// </summary>
        void Populate(out Exception ex)
        {
            ex = null;

            try
            {
                _PatientAllergy = Controller.GetPatientAllergy(Controller.CurrentPatient.PatientId);
                _PatientMedicament_ViewList = Controller.RetrivePatientMedicaments(Controller.CurrentPatient.PatientId, null);
                _MedicalEventAlert_ViewList = Controller.RetriveMedicalEventAlert(Controller.CurrentPatient.PatientId,null, false);
                if (MedicalEvent == null)
                {
                    MedicalEvent = new MedicalEventBE();
                    MedicalEvent.MedicalEventId = -1;
                    if (this._Appointment != null)
                        MedicalEvent.AppointmentId = this._Appointment.AppointmentId;


                    MedicalEvent.ProfesionalId = Controller.CurrentProfesional.IdProfesional;
                    MedicalEvent.IdEspesialidad = Controller.CurrentProfesional.IdEspecialidad.Value;
                    MedicalEvent.PatientId = Controller.CurrentPatient.PatientId;
                    MedicalEvent.PatientMedicaments = _PatientMedicament_ViewList;
                    MedicalEvent.HealthInstitutionId = Controller.CurrentHealthInstitution.HealthInstitutionId;

                    MedicalEvent.MedicalEventId = Controller.CreateMedicalEvent(MedicalEvent);
                }
                else
                {
                    MedicalEvent.PatientMedicaments = _PatientMedicament_ViewList;
                }

            }
            catch (Exception err)
            {
                err.Source = "Origen de datos";
                ex = err;
            }
        }