/// <summary>
        ///     Catálogo de entidades
        /// </summary>
        /// <returns></returns>
        public List <DuplaValoresDTO> GetUadyCs(int CatTipoTramiteId)
        {
            List <DuplaValoresDTO> duplaValoresDto;

            using (var modelo = new ISSSTEEntities())
            {
                duplaValoresDto = CatTipoTramiteId != 0
                    ? (from a in modelo.UnidadAtencion
                       join b in modelo.TramiteUnidadAtencion on a.UnidadAtencionId equals b.UnidadAtencionId
                       where a.EsActivo && b.EsActivo && b.CatTipoTramiteId == CatTipoTramiteId
                       select new DuplaValoresDTO
                {
                    Id = b.TramiteUnidadAtencionId,
                    Valor = a.Descripcion
                }).OrderBy(O => O.Valor)
                                  .ToList()
                    : (from a in modelo.UnidadAtencion
                       join b in modelo.TramiteUnidadAtencion on a.UnidadAtencionId equals b.UnidadAtencionId
                       where a.EsActivo
                       select new DuplaValoresDTO
                {
                    Id = a.UnidadAtencionId,
                    Valor = a.Descripcion
                }).OrderBy(O => O.Valor)
                                  .ToList();

                duplaValoresDto = duplaValoresDto.GroupBy(X => X.Id).Select(Y => Y.FirstOrDefault()).ToList();
            }
            return(duplaValoresDto);
        }
        public async Task <int> DeleteNonLaboraleOEspecialDaysAsync(HorarioDiaEspecialDTO DiaNoLaborableOEspecial)
        {
            using (var context = new ISSSTEEntities())
            {
                if (DiaNoLaborableOEspecial.IsNonWorking) // Es dia no laborable
                {
                    var query = context.TramiteUnidadAtencion
                                .Where(S => S.UnidadAtencionId == DiaNoLaborableOEspecial.DelegationId)
                                .AsQueryable();

                    // Si no se seleccciona un tramite, el horario sera agregado a todos los trámites existentes
                    if (DiaNoLaborableOEspecial.RequestTypeId.HasValue)
                    {
                        query = query.Where(H => H.CatTipoTramiteId == DiaNoLaborableOEspecial.RequestTypeId);
                    }

                    var tramitesUnidadesAtencion = query.ToList();

                    tramitesUnidadesAtencion.ForEach(Tu =>
                    {
                        var diaNoLaboral =
                            context.DiaNoLaborable.FirstOrDefault(
                                S => S.Fecha == DiaNoLaborableOEspecial.Date &&
                                S.TramiteUnidadAtencionId == Tu.TramiteUnidadAtencionId);

                        if (diaNoLaboral != null)
                        {
                            context.DiaNoLaborable.Remove(diaNoLaboral);
                        }
                    });
                }
                else
                {
                    //Es dia especial
                    var diaEspecial = context.DiaEspecial.FirstOrDefault(S => S.Fecha == DiaNoLaborableOEspecial.Date);

                    if (diaEspecial != null)
                    {
                        if (!diaEspecial.Horario.Any())
                        {
                            context.DiaEspecial.Remove(diaEspecial);
                        }
                        else
                        {
                            diaEspecial.EsActivo = false;
                            context.DiaEspecial.AddOrUpdate(diaEspecial);
                        }

                        diaEspecial.Horario.ToList()
                        .ForEach(HorarioDiaEspecial =>
                        {
                            HorarioDiaEspecial.EsActivo = false;
                            context.Horario.AddOrUpdate(HorarioDiaEspecial);
                        });
                    }
                }

                return(await context.SaveChangesAsync());
            }
        }
Exemple #3
0
        /// <summary>
        ///     Cancelación automática de las citas que no se llevaron a cabo
        ///     Idealmente, el día anterior
        ///     Caso 1. Citas del dia anterior
        ///     Caso 2. Citas del dia, anteriores a la hora actual
        ///     Caso 3. Citas del dia, iguales a la hora actual y menores al minuto actual
        /// </summary>
        public async Task CancelacionAutomaticaDelDia()
        {
            using (var modelo = new ISSSTEEntities())
            {
                var fechaHoy = DateTime.Now;

                var citas = await(from c in modelo.Solicitud
                                  where (((DbFunctions.TruncateTime(c.FechaCita).Value < DbFunctions.TruncateTime(fechaHoy).Value) ||
                                          (DbFunctions.TruncateTime(c.FechaCita).Value == DbFunctions.TruncateTime(fechaHoy).Value &&
                                           c.Horario.HoraInicio.Hours < fechaHoy.Hour) ||
                                          (DbFunctions.TruncateTime(c.FechaCita).Value == DbFunctions.TruncateTime(fechaHoy).Value &&
                                           c.Horario.HoraInicio.Hours == fechaHoy.Hour &&
                                           c.Horario.HoraInicio.Minutes <= fechaHoy.Minute)) &&
                                         c.EsActivo &&
                                         c.CatTipoEdoCitaId == Enumeracion.EnumTipoEdoCita.Pendiente)
                                  select c).ToListAsync();


                foreach (var cita in citas)
                {
                    cita.CatTipoEdoCitaId = Enumeracion.EnumTipoEdoCita.NoAsistio;
                }

                await modelo.SaveChangesAsync();
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="CatalogoReques"></param>
        /// <param name="EsActivo"></param>
        /// <returns></returns>
        public async Task <PagedInformationDTO <UnidadAtencionDTO> > ConsultaConceptos(CatalogoRequestDTO CatalogoReques,
                                                                                       bool?EsActivo)
        {
            var paginado = CatalogoReques.Paginado;

            var pageInfo = new PagedInformationDTO <UnidadAtencionDTO>
            {
                SetElementosPorPagina = paginado.PageSize,
                CurrentPage           = paginado.CurrentPage,
                QueryString           = paginado.QueryString
            };

            using (var modelo = new ISSSTEEntities())
            {
                var requestsQuery = (from a in modelo.UnidadAtencion
                                     join b in modelo.Domicilio on a.DomicilioId equals b.DomicilioId into ab
                                     from res in ab.DefaultIfEmpty()
                                     select new UnidadAtencionDTO
                {
                    UnidadAtencionId = a.UnidadAtencionId,
                    Descripcion = a.Descripcion,
                    EsActivo = a.EsActivo,
                    CatTipoEntidadId = a.CatTipoEntidadId,
                    Contador = a.Contador,
                    Prefijo = a.Prefijo,
                    Mascara = a.Mascara,
                    ReiniciarContador = a.ReiniciarContador,
                    DomicilioId = res == null ? default(int) : res.DomicilioId,
                    Calle = res == null ? string.Empty : res.Calle,
                    NumeroExterior = res == null ? string.Empty : res.NumeroExterior,
                    NumeroInterior = res == null ? string.Empty : res.NumeroInterior,
                    CodigoPostal = res == null ? default(int) : res.CodigoPostal,
                    Colonia = res == null ? string.Empty : res.Colonia,
                    Municipio = res == null ? string.Empty : res.Municipio
                }).AsQueryable();

                if (EsActivo.HasValue)
                {
                    requestsQuery = requestsQuery.Where(R => R.EsActivo == EsActivo);
                }

                if (!string.IsNullOrEmpty(pageInfo.GetFiltroBusqueda))
                {
                    requestsQuery = requestsQuery
                                    .Where(R => R.Descripcion.ToLower().Contains(pageInfo.GetFiltroBusqueda.ToLower()));
                }

                var requestCount = requestsQuery;

                pageInfo.ResultCount = await requestCount.CountAsync();

                pageInfo.ResultList = await requestsQuery
                                      .OrderByDescending(R => R.UnidadAtencionId)
                                      .Skip(pageInfo.GetElementosPorPagina * (pageInfo.GetCurrentPage - 1))
                                      .Take(pageInfo.GetElementosPorPagina)
                                      .ToListAsync();
            }

            return(pageInfo);
        }
Exemple #5
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="UnidadMedicaDto"></param>
        /// <returns></returns>
        /// <exception cref="QuejasMedicasException"></exception>
        public async Task <int> AgregarOActualizarUnidadMedica(UnidadMedicaDTO UnidadMedicaDto)
        {
            using (var modelo = new ISSSTEEntities())
            {
                var existeConcepto =
                    modelo.UnidadMedica.FirstOrDefault(S => S.Descripcion.Equals(UnidadMedicaDto.Descripcion) &&
                                                       S.UnidadMedicaId != UnidadMedicaDto.UnidadMedicaId);

                if (existeConcepto != null)
                {
                    throw new QuejasMedicasException(string.Format(EnumConstErrores.ErrorConceptoYaExiste,
                                                                   "nombre de la unidad médica"));
                }

                var resultado = new UnidadMedica
                {
                    UnidadMedicaId   = UnidadMedicaDto.UnidadMedicaId,
                    Descripcion      = UnidadMedicaDto.Descripcion,
                    UnidadAtencionId = UnidadMedicaDto.UnidadAtencionId,
                    EsActivo         = UnidadMedicaDto.EsActivo
                };

                modelo.UnidadMedica.AddOrUpdate(resultado);

                return(await modelo.SaveChangesAsync());
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="DetalleEstadoCita"></param>
        /// <returns></returns>
        /// <exception cref="QuejasMedicasException"></exception>
        public async Task <int> AgregarOActualizarCatTipoEdoCita(CatTipoEdoCitaDTO DetalleEstadoCita)
        {
            using (var modelo = new ISSSTEEntities())
            {
                var existeConcepto =
                    modelo.CatTipoEdoCita.FirstOrDefault(
                        S => S.Concepto.Equals(DetalleEstadoCita.Concepto) &&
                        S.CatTipoEdoCitaId != DetalleEstadoCita.CatTipoEdoCitaId);

                if (existeConcepto != null)
                {
                    throw new QuejasMedicasException(string.Format(EnumConstErrores.ErrorConceptoYaExiste,
                                                                   "Nombre del Estado de la cita"));
                }

                var resultado = new CatTipoEdoCita
                {
                    CatTipoEdoCitaId = DetalleEstadoCita.CatTipoEdoCitaId,
                    Concepto         = DetalleEstadoCita.Concepto,
                    Semaforo         = DetalleEstadoCita.Semaforo,
                    EsActivo         = DetalleEstadoCita.EsActivo
                };

                modelo.CatTipoEdoCita.AddOrUpdate(resultado);

                return(await modelo.SaveChangesAsync());
            }
        }
Exemple #7
0
        /// <summary>
        ///     Obtiene el detalle de una cita
        /// </summary>
        /// <param name="CitaDto"></param>
        /// <returns></returns>
        public CitaDTO GetCita(CitaDTO CitaDto, bool CualquierEstado = false)
        {
            using (var modelo = new ISSSTEEntities())
            {
                if (!string.IsNullOrEmpty(CitaDto.NumeroFolio) && CitaDto.SolicitudId == 0)
                {
                    CancelacionAutomatica(CitaDto.NumeroFolio, modelo, CitaDto.SolicitudId);

                    var consulta = (from c in modelo.Solicitud
                                    where c.EsActivo && c.NumeroFolio == CitaDto.NumeroFolio &&
                                    c.EsActivo
                                    select c).AsQueryable();

                    if (!CualquierEstado)
                    {
                        consulta = consulta.Where(c => c.CatTipoEdoCitaId == Enumeracion.EnumTipoEdoCita.Pendiente);
                    }

                    var resultado = consulta.FirstOrDefault();

                    if (resultado != null)
                    {
                        CitaDto.SolicitudId = consulta.FirstOrDefault().SolicitudId;
                    }
                }

                CitaDto =
                    (from c in modelo.Solicitud
                     join tu in modelo.TramiteUnidadAtencion on c.TramiteUnidadAtencionId equals tu
                     .TramiteUnidadAtencionId
                     join ua in modelo.UnidadAtencion on tu.UnidadAtencionId equals ua.UnidadAtencionId
                     join sd in modelo.CatTipoEntidad on ua.CatTipoEntidadId equals sd.CatTipoEntidadId
                     where c.SolicitudId == CitaDto.SolicitudId && c.EsActivo
                     select new CitaDTO
                {
                    NumeroFolio = c.NumeroFolio,
                    Fecha = c.FechaCita,
                    HoraInicio = c.Horario.HoraInicio.ToString(),
                    Unidad_Atencion = ua.Descripcion,
                    SolicitudId = c.SolicitudId,
                    Unidad_Medica = c.UnidadMedica.Descripcion,
                    DomicilioId = ua.DomicilioId,
                    CatTipoTramiteId = tu.CatTipoTramiteId,
                    Estado = sd.Concepto
                }).FirstOrDefault();

                if (CitaDto != null)
                {
                    GetDomicilio(CitaDto.DomicilioId, CitaDto);
                    CitaDto.Promovente = ConsultaPersona(CitaDto.SolicitudId, modelo,
                                                         Enumeracion.EnumTipoInvolucrado.Promovente);
                    CitaDto.Paciente = ConsultaPersona(CitaDto.SolicitudId, modelo,
                                                       Enumeracion.EnumTipoInvolucrado.Paciente);
                    var requisitoDao = new RequisitoDAO();
                    CitaDto.Requisitos = requisitoDao.ConsultaRequisitos(CitaDto.CatTipoTramiteId);
                }

                return(CitaDto);
            }
        }
Exemple #8
0
        /// <summary>
        ///     Consulta de una persona
        /// </summary>
        /// <param name="SolicitudId"></param>
        /// <param name="Modelo"></param>
        /// <param name="CatTipoInvolucradoId"></param>
        /// <returns></returns>
        private PersonaDTO ConsultaPersona(int SolicitudId, ISSSTEEntities Modelo, int CatTipoInvolucradoId)
        {
            var personaDto = (from c in Modelo.Solicitud
                              join I in Modelo.Involucrado on c.SolicitudId equals I.SolicitudId
                              where I.CatTipoInvolucradoId == CatTipoInvolucradoId &&
                              c.SolicitudId == SolicitudId && I.EsActivo
                              select new PersonaDTO
            {
                Nombre = I.Persona.Nombre,
                Paterno = I.Persona.Paterno,
                Materno = I.Persona.Materno,
                CURP = I.Persona.CURP,
                EsMasculino = I.Persona.EsMasculino,
                FechaNacimiento = I.Persona.FechaNacimiento,
                PersonaId = I.Persona.PersonaId,
                Lada = I.Persona.Lada,
                TelFijo = I.Persona.Telefono,
                TelMovil = I.Persona.TelefonoMovil,
                CorreoElectronico = I.Persona.Correo
            }).FirstOrDefault();

            if (personaDto != null)
            {
                personaDto.EsMasculino     = Utilerias.GetSexo(personaDto.CURP);
                personaDto.FechaNacimiento = Utilerias.GetFechaNacimiento(personaDto.CURP);
            }
            return(personaDto);
        }
Exemple #9
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="DetalleTramite"></param>
        /// <returns></returns>
        /// <exception cref="QuejasMedicasException"></exception>
        public async Task <int> AgregarOActualizarCatTipoTramite(CatTipoTramiteDTO DetalleTramite)
        {
            using (var modelo = new ISSSTEEntities())
            {
                var existeConcepto =
                    modelo.CatTipoTramite.FirstOrDefault(
                        S => S.Concepto.Equals(DetalleTramite.Concepto) &&
                        S.CatTipoTramiteId != DetalleTramite.CatTipoTramiteId);

                if (existeConcepto != null)
                {
                    throw new QuejasMedicasException(
                              string.Format(EnumConstErrores.ErrorConceptoYaExiste, "Nombre del trámite"));
                }

                var resultado = new CatTipoTramite
                {
                    CatTipoTramiteId = DetalleTramite.CatTipoTramiteId,
                    Concepto         = DetalleTramite.Concepto,
                    Semaforo         = DetalleTramite.Semaforo,
                    Homoclave        = DetalleTramite.HomoClave,
                    EsActivo         = DetalleTramite.EsActivo
                };

                modelo.CatTipoTramite.AddOrUpdate(resultado);

                return(await modelo.SaveChangesAsync());
            }
        }
Exemple #10
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="RequestTypeId"></param>
        /// <param name="DelegationsIds"></param>
        /// <returns></returns>
        public async Task <IEnumerable <DelegacionDTO> > GetDelegationsByConfig(int RequestTypeId, int[] DelegationsIds)
        {
            List <DelegacionDTO> delegations = new List <DelegacionDTO>();

            using (var context = new ISSSTEEntities())
            {
                var delegationResult = context.TramiteUnidadAtencion
                                       .Where(S => S.EsActivo && S.CatTipoTramiteId == RequestTypeId)
                                       .AsQueryable();

                if (!DelegationsIds.Contains(-1))
                {
                    delegationResult = delegationResult.Where(D => DelegationsIds.Contains(D.UnidadAtencionId));
                }

                var result = delegationResult.Select(S => S.UnidadAtencion);

                delegations = await result
                              .Select(D => new DelegacionDTO {
                    DelegacionId = D.UnidadAtencionId, Descripcion = D.Descripcion
                })
                              .ToListAsync();
            }

            return(delegations);
        }
Exemple #11
0
        /// <summary>
        ///     Secciones de consulta - Información general
        /// </summary>
        /// <param name="CatTipoTramiteId"></param>
        /// <param name="EsPrincipal"></param>
        /// <returns></returns>
        public PromoventeDTO ConsultaListado(int CatTipoTramiteId, bool EsPrincipal)
        {
            var promoventeDto = new PromoventeDTO();

            using (var modelo = new ISSSTEEntities())
            {
                if (EsPrincipal)
                {
                    promoventeDto.SeccionPrincipal = SeccionPrincipal(CatTipoTramiteId, modelo, true);
                    if (promoventeDto.SeccionPrincipal != null)
                    {
                        foreach (var t in promoventeDto.SeccionPrincipal)
                        {
                            t.Detalle = DetalleSeccion(modelo, t.SeccionId);
                        }
                    }
                }
                else
                {
                    promoventeDto.SeccionSecundaria = SeccionPrincipal(CatTipoTramiteId, modelo, false);
                    if (promoventeDto.SeccionSecundaria != null)
                    {
                        foreach (var t in promoventeDto.SeccionSecundaria)
                        {
                            t.Detalle = DetalleSeccion(modelo, t.SeccionId);
                        }
                    }
                }

                promoventeDto.Requisitos = RequisitosPorTipoTramiteId(modelo, CatTipoTramiteId);
            }
            return(promoventeDto);
        }
        /// <summary>
        ///     Búsqueda predictiva sobre las UADyCS y unidades médicas
        ///     Tiene prioridad las unidades médicas sobre las UADyCS
        /// </summary>
        /// <param name="Concepto"></param>
        /// <param name="IdCatTipoTramite"></param>
        /// <returns></returns>
        public CalendarioDTO GetBusqueda(string Concepto, int IdCatTipoTramite)
        {
            var calendarioDto = new CalendarioDTO();

            Concepto = Concepto.ToUpper();
            using (var modelo = new ISSSTEEntities())
            {
                var primerOcurrencia = (from a in modelo.UnidadMedica
                                        join b in modelo.TramiteUnidadAtencion
                                        on a.UnidadAtencionId equals b.UnidadAtencionId
                                        where a.Descripcion.ToUpper().Contains(Concepto) &&
                                        b.CatTipoTramiteId == IdCatTipoTramite
                                        select new DuplaValoresDTO
                {
                    Id = b.TramiteUnidadAtencionId,
                    IdAux = a.UnidadMedicaId
                }).FirstOrDefault() ?? (from a in modelo.UnidadAtencion
                                        join b in modelo.TramiteUnidadAtencion
                                        on a.UnidadAtencionId equals b.UnidadAtencionId
                                        where a.Descripcion.ToUpper().Contains(Concepto) &&
                                        b.CatTipoTramiteId == IdCatTipoTramite
                                        select new DuplaValoresDTO
                {
                    Id = b.TramiteUnidadAtencionId
                }).FirstOrDefault();

                if (primerOcurrencia != null)
                {
                    calendarioDto.TramiteUnidadAtencionId = primerOcurrencia.Id;
                    calendarioDto.UnidadMedicaId          = primerOcurrencia.IdAux;
                }
            }
            return(calendarioDto);
        }
        /// <summary>
        ///     Obtiene los dias no laborables programados por tramite/unidad administrativa
        /// </summary>
        /// <param name="SolicitudId"></param>
        /// <param name="UnidadAtencionId"></param>
        /// <returns></returns>
        public async Task <List <HorarioDiaEspecialDTO> > ObtenerDiasNoLaborablesAsync(int?SolicitudId,
                                                                                       int UnidadAtencionId)
        {
            using (var context = new ISSSTEEntities())
            {
                var query = context.DiaNoLaborable.AsQueryable();

                if (SolicitudId.HasValue)
                {
                    query = query.Where(H => H.TramiteUnidadAtencion.CatTipoTramiteId == SolicitudId);
                }

                var resultado = query.Where(R => R.EsActivo &&
                                            R.TramiteUnidadAtencion.UnidadAtencion.UnidadAtencionId ==
                                            UnidadAtencionId)
                                .GroupBy(S => new { S.Fecha })
                                .Select(
                    S => new HorarioDiaEspecialDTO
                {
                    Date         = S.Key.Fecha,
                    DelegationId = UnidadAtencionId,
                    IsNonWorking = true
                }
                    );

                return(await resultado.OrderBy(R => R.Date).ToListAsync());
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="TramiteUnidadAtencionId"></param>
        /// <returns></returns>
        public string GetBusquedaHorarioUadyCs(int TramiteUnidadAtencionId)
        {
            var fecha    = "";
            var contador = 0;

            using (var modelo = new ISSSTEEntities())
            {
                var fechaComienzo = DateTime.Now;
                var Dias          = Enumeracion.EnumVarios.DiasSeleccionables;
                while (contador <= Dias)
                {
                    var diaSemana = (int)fechaComienzo.DayOfWeek;

                    if (diaSemana != Enumeracion.EnumVarios.Sabado && diaSemana != Enumeracion.EnumVarios.Domingo)
                    {
                        var diaNoLaborable = (from a in modelo.DiaNoLaborable
                                              where a.TramiteUnidadAtencionId == TramiteUnidadAtencionId &&
                                              a.Fecha.Day == fechaComienzo.Day &&
                                              a.Fecha.Month == fechaComienzo.Month &&
                                              a.Fecha.Year == fechaComienzo.Year
                                              select a).Count();
                        if (diaNoLaborable == 0)
                        {
                            contador++;
                        }
                    }
                    if (contador == Dias)
                    {
                        fecha = "" + fechaComienzo.Year + "," + fechaComienzo.Month + "," + fechaComienzo.Day;
                    }
                    fechaComienzo = fechaComienzo.AddDays(1);
                }
            }
            return(fecha);
        }
        /// <summary>
        ///     Búsqueda de horarios por día
        /// </summary>
        /// <param name="Concepto"></param>
        /// <param name="TramiteUnidadAtencionId"></param>
        /// <returns></returns>
        public List <HorarioDTO> GetBusquedaDia(string Concepto, int TramiteUnidadAtencionId)
        {
            using (var modelo = new ISSSTEEntities())
            {
                var fecha = DateTime.Parse(Concepto);
                var hoy   = DateTime.Now;

                var horariosDisponibles = (from b in modelo.Horario
                                           where b.EsActivo && b.EsDiaEspecial &&
                                           b.DiaEspecial.Fecha.Day == fecha.Day &&
                                           b.DiaEspecial.Fecha.Month == fecha.Month &&
                                           b.DiaEspecial.Fecha.Year == fecha.Year &&
                                           b.TramiteUnidadAtencionId == TramiteUnidadAtencionId && b.EsActivo
                                           select new HorarioDTO
                {
                    HoraInicio = b.HoraInicio,
                    HorarioId = b.HorarioId,
                    Capacidad = b.Capacidad
                }).ToList();

                if (horariosDisponibles.Count == 0)
                {
                    var dia = (int)fecha.DayOfWeek;
                    horariosDisponibles = (from b in modelo.Horario
                                           where b.EsActivo && !b.EsDiaEspecial &&
                                           b.CatTipoDiaSemanaId == dia &&
                                           b.TramiteUnidadAtencionId == TramiteUnidadAtencionId
                                           select new HorarioDTO
                    {
                        HoraInicio = b.HoraInicio,
                        HorarioId = b.HorarioId,
                        Capacidad = b.Capacidad
                    }).OrderBy(B => B.HoraInicio)
                                          .ToList();
                }

                horariosDisponibles = horariosDisponibles.Select(F =>
                {
                    F.Capacidad -= (from a in modelo.Solicitud
                                    where a.TramiteUnidadAtencionId == TramiteUnidadAtencionId &&
                                    a.FechaCita.Day == fecha.Day && a.FechaCita.Month == fecha.Month &&
                                    a.FechaCita.Year == fecha.Year &&
                                    a.HorarioId == F.HorarioId && a.EsActivo
                                    select a).Count();

                    if (hoy.Day == fecha.Day && hoy.Month == fecha.Month && hoy.Year == fecha.Year &&
                        F.HoraInicio.Hours <= hoy.Hour)
                    {
                        F.Capacidad = 0;
                    }

                    return(F);
                })
                                      .ToList();

                horariosDisponibles = horariosDisponibles.Where(F => F.Capacidad > 0).ToList();

                return(horariosDisponibles);
            }
        }
        /// <summary>
        ///     Obtiene los horarios programados por tramite/unidad administrativa
        /// </summary>
        /// <param name="SolicitudId"></param>
        /// <param name="UnidadAtencionId"></param>
        /// <returns></returns>
        public async Task <List <HorarioApiDTO> > ObtenerHorariosAsync(int?SolicitudId, int UnidadAtencionId)
        {
            using (var context = new ISSSTEEntities())
            {
                var query = context.Horario.Include(S => S.CatTipoDiaSemana)
                            .AsQueryable();

                if (SolicitudId.HasValue)
                {
                    query = query.Where(S => S.TramiteUnidadAtencion.CatTipoTramiteId == SolicitudId);
                }

                query = query.Where(S => !S.EsDiaEspecial && S.EsActivo &&
                                    S.TramiteUnidadAtencion.UnidadAtencionId.Equals(UnidadAtencionId));

                var result = query
                             .GroupBy(S => new { S.CatTipoDiaSemana.CatTipoDiaSemanaId, S.HoraInicio })
                             .Select(
                    S => new HorarioApiDTO
                {
                    //ScheduleId = s.HorarioId,
                    DelegationId = UnidadAtencionId,
                    Time         = S.Key.HoraInicio,
                    //WeekDay = s.Where(d => d.CatTipoDiaSemana.CatTipoDiaSemanaId==s.Key.CatTipoDiaSemanaId).FirstOrDefault().CatTipoDiaSemana.Dia,
                    WeekdayId = S.Key.CatTipoDiaSemanaId,
                    Capacity  = S.FirstOrDefault() != null ? S.FirstOrDefault().Capacidad : default(int)
                }
                    );

                return(await result.OrderBy(R => R.WeekdayId).ThenBy(R => R.Time).ToListAsync());
            }
        }
Exemple #17
0
        /// <summary>
        ///     Se agrega al paciente
        /// </summary>
        /// <param name="GeneralCitaDto"></param>
        /// <param name="Modelo"></param>
        /// <returns></returns>
        private Persona AddPaciente(GeneralCitaDTO GeneralCitaDto, ISSSTEEntities Modelo)
        {
            var persona = (from a in Modelo.Persona
                           where a.CURP == GeneralCitaDto.CURPPaciente &&
                           a.Nombre == GeneralCitaDto.NombrePaciente &&
                           a.Paterno == GeneralCitaDto.Apellido1Paciente
                           //&& a.Materno == GeneralCitaDto.Apellido2Paciente
                           select a).FirstOrDefault() ?? new Persona();

            persona.Nombre          = GeneralCitaDto.NombrePaciente;
            persona.Paterno         = GeneralCitaDto.Apellido1Paciente;
            persona.Materno         = GeneralCitaDto.Apellido2Paciente;
            persona.CURP            = GeneralCitaDto.CURPPaciente;
            persona.Correo          = GeneralCitaDto.CorreoPaciente;
            persona.Telefono        = GeneralCitaDto.TelefonoPaciente;
            persona.TelefonoMovil   = GeneralCitaDto.CelularPaciente;
            persona.EsActivo        = true;
            persona.Lada            = GeneralCitaDto.LadaPaciente;
            persona.Edad            = Utilerias.GetEdad(GeneralCitaDto.CURPPaciente);
            persona.EsMasculino     = Utilerias.GetSexo(GeneralCitaDto.CURPPaciente);
            persona.FechaNacimiento = Utilerias.GetFechaNacimiento(GeneralCitaDto.CURPPaciente);

            if (persona.PersonaId == 0)
            {
                Modelo.Persona.Add(persona);
            }
            Modelo.SaveChanges();
            return(persona);
        }
Exemple #18
0
 /// <summary>
 ///     Descripción asociado a un tipo de trámite
 /// </summary>
 /// <param name="CatTipoTramiteId"></param>
 /// <returns></returns>
 public string ConceptoTipoTramite(int CatTipoTramiteId)
 {
     using (var modelo = new ISSSTEEntities())
     {
         return((from a in modelo.CatTipoTramite
                 where a.EsActivo && a.CatTipoTramiteId == CatTipoTramiteId
                 select a.Concepto).FirstOrDefault());
     }
 }
        public async Task <int> GuardarHorariosDiasEspecialesAsync(List <HorarioDiaEspecialDTO> HorariosDiasEspeciales)
        {
            using (var context = new ISSSTEEntities())
            {
                HorariosDiasEspeciales.ForEach(NuevoDiaEspecial =>
                {
                    var query = context.TramiteUnidadAtencion
                                .Where(S => S.UnidadAtencionId == NuevoDiaEspecial.DelegationId)
                                .AsQueryable();

                    // Si no se seleccciona un tramite, el horario sera agregado a todos los trámites existentes
                    if (NuevoDiaEspecial.RequestTypeId.HasValue)
                    {
                        query = query.Where(H => H.CatTipoTramiteId == NuevoDiaEspecial.RequestTypeId);
                    }

                    var tramitesUnidadesAtencion = query.ToList();

                    tramitesUnidadesAtencion.ForEach(Tu =>
                    {
                        var firstOrDefault = context.DiaEspecial.FirstOrDefault(S => S.Fecha == NuevoDiaEspecial.Date);
                        if (firstOrDefault != null)
                        {
                            var horarioNuevo = new Horario
                            {
                                //HorarioId = nuevoDiaEspecial.DiaEspecialDTOScheduleId,
                                Capacidad = NuevoDiaEspecial.Capacity,
                                EsActivo  = true,
                                TramiteUnidadAtencionId = Tu.TramiteUnidadAtencionId,
                                CatTipoDiaSemanaId      = null,
                                HoraInicio    = NuevoDiaEspecial.Time,
                                EsDiaEspecial = true,
                                DiaEspecialId = firstOrDefault.DiaEspecialId
                            };

                            var resultadoHorarioDia =
                                context.Horario.FirstOrDefault(
                                    S => S.HoraInicio.Equals(NuevoDiaEspecial.Time) && S.EsDiaEspecial &&
                                    S.TramiteUnidadAtencionId == Tu.TramiteUnidadAtencionId);

                            //Si ya existe el horario especial no es agregado
                            if (resultadoHorarioDia == null)
                            {
                                context.Horario.Add(horarioNuevo);
                            }
                            else
                            {
                                horarioNuevo.HorarioId = resultadoHorarioDia.HorarioId;
                                context.Horario.AddOrUpdate(horarioNuevo);
                            }
                        }
                    });
                });

                return(await context.SaveChangesAsync());
            }
        }
Exemple #20
0
        /// <summary>
        ///     Obtención del domicilio asociado a una TUA
        /// </summary>
        public void GetDomicilio(int?DomicilioId, CitaDTO CitaDto)
        {
            int tramiteUnidadAtencionId = CitaDto.TramiteUnidadAtencionId;

            using (var modelo = new ISSSTEEntities())
            {
                if (DomicilioId != null && DomicilioId == 0)
                {
                    DomicilioId =
                        (from tu in modelo.TramiteUnidadAtencion
                         join ua in modelo.UnidadAtencion on tu.UnidadAtencionId equals ua.UnidadAtencionId
                         where tu.TramiteUnidadAtencionId == tramiteUnidadAtencionId
                         select ua.DomicilioId).FirstOrDefault();
                }

                if (DomicilioId != null && DomicilioId != 0)
                {
                    var domicilio = (from a in modelo.Domicilio
                                     where a.DomicilioId == DomicilioId
                                     select a).FirstOrDefault();

                    if (domicilio != null)
                    {
                        CitaDto.CodigoPostal   = domicilio.CodigoPostal ?? 0;
                        CitaDto.Colonia        = domicilio.Colonia;
                        CitaDto.Municipio      = domicilio.Municipio;
                        CitaDto.Calle          = domicilio.Calle;
                        CitaDto.NumeroExterior = domicilio.NumeroExterior;
                        CitaDto.NumeroInterior = domicilio.NumeroInterior;

                        string valor = "" + CitaDto.CodigoPostal;
                        switch (valor.Length)
                        {
                        case 1: valor = "0000" + valor; break;

                        case 2: valor = "000" + valor; break;

                        case 3: valor = "00" + valor; break;

                        case 4: valor = "0" + valor; break;
                        }
                        CitaDto.CodPostal = valor;

                        var entidad = (from tu in modelo.TramiteUnidadAtencion
                                       join ua in modelo.UnidadAtencion on tu.UnidadAtencionId equals ua.UnidadAtencionId
                                       where tu.TramiteUnidadAtencionId == tramiteUnidadAtencionId
                                       select ua.CatTipoEntidad.Concepto).FirstOrDefault();

                        if (!string.IsNullOrEmpty(entidad))
                        {
                            CitaDto.Estado = entidad;
                        }
                    }
                }
            }
        }
Exemple #21
0
 /// <summary>
 ///     Requisitos de un tipo de tramite
 /// </summary>
 /// <param name="Modelo"></param>
 /// <param name="CatTipoTramiteId"></param>
 /// <returns></returns>
 private List <RequisitoDTO> RequisitosPorTipoTramiteId(ISSSTEEntities Modelo, int CatTipoTramiteId)
 {
     return((from a in Modelo.Requisito
             where a.EsActivo && a.CatTipoTramiteId == CatTipoTramiteId
             select new RequisitoDTO
     {
         NombreDocumento = a.NombreDocumento,
         Descripcion = a.Descripcion
     }).ToList());
 }
Exemple #22
0
        /// <summary>
        ///     Agenda de una cita
        /// </summary>
        /// <param name="GeneralCitaDto"></param>
        /// <returns></returns>
        public string AgendarCita(GeneralCitaDTO GeneralCitaDto)
        {
            using (var modelo = new ISSSTEEntities())
            {
                using (var modeloTransaction = modelo.Database.BeginTransaction())
                {
                    try
                    {
                        var fecha     = Convert.ToDateTime(GeneralCitaDto.FechaFinal);
                        var horarioId = GeneralCitaDto.HorarioId;

                        var conteoCitas = (from a in modelo.Solicitud
                                           where a.TramiteUnidadAtencionId ==
                                           GeneralCitaDto.TramiteUnidadAtencionId &&
                                           a.FechaCita.Year == fecha.Year &&
                                           a.FechaCita.Month == fecha.Month &&
                                           a.FechaCita.Day == fecha.Day &&
                                           a.HorarioId == horarioId &&
                                           a.EsActivo
                                           select a).Count();

                        var capacidadCita = (from a in modelo.Horario
                                             where a.TramiteUnidadAtencionId ==
                                             GeneralCitaDto.TramiteUnidadAtencionId &&
                                             a.HorarioId == horarioId
                                             select a.Capacidad).FirstOrDefault();

                        if (capacidadCita > conteoCitas)
                        {
                            var numeroFolio = GetNumeroFolio(GeneralCitaDto);

                            var solicitud = AddSolicitud(numeroFolio, horarioId, fecha, GeneralCitaDto, modelo);
                            var persona1  = GeneralCitaDto.EsRepresentante
                                ? AddPaciente(GeneralCitaDto, modelo)
                                : AddPromovente(GeneralCitaDto, modelo);
                            var persona2 = AddPromovente(GeneralCitaDto, modelo);
                            AddInvolucrado(modelo, solicitud.SolicitudId, persona1.PersonaId,
                                           Enumeracion.EnumTipoInvolucrado.Paciente);
                            AddInvolucrado(modelo, solicitud.SolicitudId, persona2.PersonaId,
                                           Enumeracion.EnumTipoInvolucrado.Promovente);

                            modeloTransaction.Commit();
                            return(solicitud.NumeroFolio);
                        }
                        return(Enumeracion.EnumVarios.Prefijo +
                               Enumeracion.MensajesServidor[Enumeracion.EnumConstErrores.CupoExcedido]);
                    }
                    catch (Exception ex)
                    {
                        modeloTransaction.Rollback();
                        throw;
                    }
                }
            }
        }
        /// <summary>
        ///     Guarda los horarios por tramite/unidad administrativa
        /// </summary>
        /// <param name="Horarios"></param>
        /// <returns></returns>
        public async Task <int> GuardarHorariosAsync(List <Schedule> Horarios)
        {
            using (var context = new ISSSTEEntities())
            {
                Horarios.ForEach(Horario =>
                {
                    var query = context.TramiteUnidadAtencion
                                .Where(S => S.UnidadAtencionId == Horario.DelegationId)
                                .AsQueryable();

                    // Si no se seleccciona un tramite, el horario sera agregado a todos los trámites existentes
                    if (Horario.RequestTypeId.HasValue)
                    {
                        query = query.Where(H => H.CatTipoTramiteId == Horario.RequestTypeId);
                    }

                    var tramitesUnidadesAtencion = query.ToList();

                    tramitesUnidadesAtencion.ForEach(Tu =>
                    {
                        var horarioNuevo =
                            new Horario
                        {
                            EsActivo = true,
                            TramiteUnidadAtencionId = Tu.TramiteUnidadAtencionId,
                            CatTipoDiaSemanaId      = Horario.WeekdayId,
                            HoraInicio    = Horario.Time,
                            EsDiaEspecial = false,
                            Capacidad     = Horario.Capacity
                        };


                        var resultadoHorario =
                            context.Horario.FirstOrDefault(
                                S => S.HoraInicio.Equals(Horario.Time) && S.CatTipoDiaSemanaId == Horario.WeekdayId &&
                                S.TramiteUnidadAtencionId == Tu.TramiteUnidadAtencionId);

                        //Si ya existe el horario no es agregado
                        if (resultadoHorario == null)
                        {
                            context.Horario.Add(horarioNuevo);
                        }
                        else
                        {
                            horarioNuevo.HorarioId = resultadoHorario.HorarioId;
                            context.Horario.AddOrUpdate(horarioNuevo);
                        }
                    });
                });


                return(await context.SaveChangesAsync());
            }
        }
Exemple #24
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="SettingDetail"></param>
        /// <returns></returns>
        public async Task <int> SaveCatSysConfiguracion(CatalogoResultDTO SettingDetail)
        {
            using (var modelo = new ISSSTEEntities())
            {
                var resultado = await modelo.CatSysConfiguracion
                                .Where(S => S.CatSysConfiguracionId == SettingDetail.CatalogoId)
                                .FirstOrDefaultAsync();

                resultado.Valor = SettingDetail.Valor;
                return(await modelo.SaveChangesAsync());
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="CatTipoTramiteId"></param>
        /// <returns></returns>
        public string GetHomoClave(int CatTipoTramiteId)
        {
            using (var modelo = new ISSSTEEntities())
            {
                var homoclave = (from c in modelo.CatTipoTramite
                                 where c.CatTipoTramiteId == CatTipoTramiteId
                                 select c.Homoclave
                                 ).FirstOrDefault();

                return(homoclave);
            }
        }
Exemple #26
0
        public async Task <int> ActulizarEstadoCita(int SolicitudId, int StatusId)
        {
            using (var context = new ISSSTEEntities())
            {
                var result = await context.Solicitud
                             .Where(S => S.SolicitudId == SolicitudId)
                             .FirstOrDefaultAsync();

                result.CatTipoEdoCitaId = StatusId;

                return(await context.SaveChangesAsync());
            }
        }
Exemple #27
0
        /// <summary>
        ///     Agregar involucrados
        /// </summary>
        /// <param name="Modelo"></param>
        /// <param name="SolicitudId"></param>
        /// <param name="PersonaId"></param>
        /// <param name="CatTipoPersona"></param>
        private void AddInvolucrado(ISSSTEEntities Modelo, int SolicitudId, int PersonaId, int CatTipoPersona)
        {
            var involucrado = new Involucrado
            {
                EsActivo             = true,
                SolicitudId          = SolicitudId,
                CatTipoInvolucradoId = CatTipoPersona,
                PersonaId            = PersonaId
            };

            Modelo.Involucrado.Add(involucrado);
            Modelo.SaveChanges();
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="IdCatTipoTramite"></param>
        /// <returns></returns>
        public string GetFormatoTramite(int IdCatTipoTramite)
        {
            var    rutaLog = GetValorConfiguracion(Enumeracion.EnumSysConfiguracion.RutaArchivos);
            string formaPdf;

            using (var modelo = new ISSSTEEntities())
            {
                formaPdf = (from a in modelo.CatTipoTramite
                            where a.CatTipoTramiteId == IdCatTipoTramite
                            select a.FormatoUniversal).FirstOrDefault();
            }
            return(string.IsNullOrEmpty(formaPdf) ? "" : Path.Combine(rutaLog, formaPdf));
        }
Exemple #29
0
        public async Task <List <EstadoCitaDTO> > ObtenerStatusCita()
        {
            using (var context = new ISSSTEEntities())
            {
                var resuldato = await context.CatTipoEdoCita
                                .Select(S => new EstadoCitaDTO {
                    Concepto = S.Concepto, EstadoCitaId = S.CatTipoEdoCitaId
                })
                                .ToListAsync();

                return(resuldato);
            }
        }
Exemple #30
0
        /// <summary>
        ///
        /// </summary>
        /// <returns></returns>
        public async Task <IEnumerable <DiaSemanaDTO> > ObtenerDiasSemanaAsync()
        {
            using (var context = new ISSSTEEntities())
            {
                var resultado = await context.CatTipoDiaSemana
                                .Where(S => S.EsActivo)
                                .Select(S => new DiaSemanaDTO {
                    CatTipoDiaSemanaId = S.CatTipoDiaSemanaId, Dia = S.Dia
                })
                                .ToListAsync();

                return(resultado);
            }
        }