/// <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();
}
}
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());
}
}
/// <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());
}
}
/// <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());
}
}
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());
}
}
/// <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());
}
}
/// <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>
/// Reinicio de contador - Número de Folio
/// </summary>
public async Task ReinicioContador()
{
if (DateTime.Now.Month != 1 && DateTime.Now.Month != 2 &&
DateTime.Now.Month != 12 && DateTime.Now.Month != 11)
{
return;
}
using (var modelo = new ISSSTEEntities())
{
if (DateTime.Now.Month == 12 || DateTime.Now.Month == 11)
{
var unidades = await(from a in modelo.UnidadAtencion
where a.ReiniciarContador == false
select a).ToListAsync();
foreach (var unidad in unidades)
{
unidad.ReiniciarContador = true;
}
await modelo.SaveChangesAsync();
}
else if (DateTime.Now.Month == 1 || DateTime.Now.Month == 2)
{
var unidades = (from a in modelo.UnidadAtencion
where a.ReiniciarContador
select a).ToList();
foreach (var unidad in unidades)
{
unidad.ReiniciarContador = false;
unidad.Contador = 1;
}
await modelo.SaveChangesAsync();
}
}
}
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());
}
}
/// <summary>
/// Actualización del lenguaje ciudadano
/// </summary>
/// <param name="SettingDetail"></param>
/// <returns></returns>
public async Task <int> ActualizacionLenguajeCiudadano(CatalogoResultDTO SettingDetail)
{
using (var modelo = new ISSSTEEntities())
{
var resultado =
await modelo.LenguajeCiudadano
.Where(S => S.LenguajeCiudadanoId == SettingDetail.CatalogoId)
.FirstOrDefaultAsync();
resultado.Region = SettingDetail.Concepto;
resultado.Concepto = SettingDetail.Valor;
return(await modelo.SaveChangesAsync());
}
}
/// <summary>
///
/// </summary>
/// <param name="DetalleTramiteUnidad"></param>
/// <returns></returns>
public async Task <int> AgregarOActualizarTramiteUnidadAtencion(TramiteUnidadAtencionDTO DetalleTramiteUnidad)
{
using (var modelo = new ISSSTEEntities())
{
var resultado = new TramiteUnidadAtencion
{
TramiteUnidadAtencionId = DetalleTramiteUnidad.TramiteUnidadAtencionId,
CatTipoTramiteId = DetalleTramiteUnidad.CatTipoTramiteId,
UnidadAtencionId = DetalleTramiteUnidad.UnidadAtencionId,
EsActivo = DetalleTramiteUnidad.EsActivo
};
modelo.TramiteUnidadAtencion.AddOrUpdate(resultado);
return(await modelo.SaveChangesAsync());
}
}
/// <summary>
/// Elimina el horario que haya sido removido de la lista
/// </summary>
/// <param name="SolicitudId"></param>
/// <param name="UnidadAtencionId"></param>
/// <param name="HorarioInicio"></param>
/// <param name="CatTipoDiaSemanaId"></param>
/// <param name="EsDiaEspecial"></param>
/// <returns></returns>
public async Task <int> EliminarHorarios(int?SolicitudId, int UnidadAtencionId, TimeSpan HorarioInicio,
int?CatTipoDiaSemanaId, bool EsDiaEspecial)
{
using (var context = new ISSSTEEntities())
{
var query = context.TramiteUnidadAtencion
.Where(S => S.UnidadAtencionId == UnidadAtencionId)
.AsQueryable();
// Si no se seleccciona un tramite, el horario sera agregado a todos los trámites existentes
if (SolicitudId.HasValue)
{
query = query.Where(H => H.CatTipoTramiteId == SolicitudId);
}
var tramitesUnidadesAtencion = query.ToList();
tramitesUnidadesAtencion.ForEach(Tu =>
{
var special =
context.Horario.FirstOrDefault(S => S.EsDiaEspecial == EsDiaEspecial &&
S.HoraInicio == HorarioInicio &&
S.CatTipoDiaSemanaId == CatTipoDiaSemanaId &&
S.TramiteUnidadAtencion.TramiteUnidadAtencionId ==
Tu.TramiteUnidadAtencionId);
if (special != null && special.Solicitud.Any())
{
special.EsActivo = false;
context.Horario.AddOrUpdate(special);
}
else
{
if (special != null)
{
context.Horario.Remove(special);
}
}
});
return(await context.SaveChangesAsync());
}
}
/// <summary>
/// Actualización / Inserción de un requisito
/// </summary>
/// <param name="DetalleRequisito"></param>
/// <returns></returns>
public async Task <int> SalvarActualizarRequisito(RequisitoDTO DetalleRequisito)
{
using (var modelo = new ISSSTEEntities())
{
var resultado = new Requisito
{
RequisitoId = DetalleRequisito.RequisitoId,
CatTipoTramiteId = DetalleRequisito.CatTipoTramiteId,
Descripcion = DetalleRequisito.Descripcion,
NombreDocumento = DetalleRequisito.NombreDocumento,
EsActivo = DetalleRequisito.EsActivo,
EsObligatorio = DetalleRequisito.EsObligatorio
};
modelo.Requisito.AddOrUpdate(resultado);
return(await modelo.SaveChangesAsync());
}
}
/// <summary>
///
/// </summary>
/// <param name="AsignacionesTramiteUnidad"></param>
/// <returns></returns>
public async Task <int> AsignacionesTramiteUnidad(AsignacionesTramiteUnidadDTO AsignacionesTramiteUnidad)
{
using (var modelo = new ISSSTEEntities())
{
AsignacionesTramiteUnidad.UnidadesAsignadas.ForEach(S =>
{
var asignacion = modelo.TramiteUnidadAtencion.FirstOrDefault(
Tu => Tu.CatTipoTramiteId == AsignacionesTramiteUnidad.CatTipoTramiteId &&
Tu.UnidadAtencionId == S.UnidadAtencionId);
if (asignacion != null)
{
asignacion.EsActivo = true;
}
else
{
var resultado = new TramiteUnidadAtencion
{
CatTipoTramiteId = AsignacionesTramiteUnidad.CatTipoTramiteId,
UnidadAtencionId = S.UnidadAtencionId,
EsActivo = true
};
modelo.TramiteUnidadAtencion.Add(resultado);
}
});
AsignacionesTramiteUnidad.UnidadesNoAsignadas.ForEach(S =>
{
var desasignar = modelo.TramiteUnidadAtencion
.Where(Tu => Tu.CatTipoTramiteId == AsignacionesTramiteUnidad.CatTipoTramiteId &&
Tu.UnidadAtencionId == S.UnidadAtencionId)
.ToList();
desasignar.ForEach(D => { D.EsActivo = false; });
});
return(await modelo.SaveChangesAsync());
}
}
public async Task <bool> DesbloquearUsuarioPorSolicitudId(int RequestId)
{
using (var context = new ISSSTEEntities())
{
var result = await context.Solicitud
.Where(sol => sol.SolicitudId == RequestId)
.Join(context.Involucrado,
Req => Req.SolicitudId, Inv => Inv.SolicitudId,
(Req, Inv) => Inv)
.Join(context.Persona,
Inv => Inv.PersonaId, Per => Per.PersonaId,
(Inv, Per) => new { inv = Inv, per = Per })
.Where(S => S.inv.CatTipoInvolucradoId == Enumeracion.EnumTipoInvolucrado.Paciente)
.FirstOrDefaultAsync();
result.per.EsUsuarioBloqueado = false;
result.per.FechaDesbloqueo = DateTime.Now;
await context.SaveChangesAsync();
return(true);
}
}
public async Task <int> GuardaDiasNoLaboralesOEspecialesAsync(List <HorarioDiaEspecialDTO> SpecialDays)
{
using (var context = new ISSSTEEntities())
{
SpecialDays.ForEach(Dia =>
{
if (!Dia.IsNonWorking && Dia.IsOverrided)
{
var diasEspecialNuevo = new DiaEspecial
{
EsActivo = true,
Fecha = Dia.Date,
Concepto = "sin Concepto"
};
var resultadoDiaEspecial = context.DiaEspecial.FirstOrDefault(S => S.Fecha == Dia.Date);
if (resultadoDiaEspecial == null)
{
context.DiaEspecial.Add(diasEspecialNuevo);
}
else
{
diasEspecialNuevo.DiaEspecialId = resultadoDiaEspecial.DiaEspecialId;
context.DiaEspecial.AddOrUpdate(diasEspecialNuevo);
}
}
else if (Dia.IsNonWorking)
{
var query = context.TramiteUnidadAtencion
.Where(S => S.UnidadAtencionId == Dia.DelegationId)
.AsQueryable();
// Si no se seleccciona un tramite, el horario sera agregado a todos los trámites existentes
if (Dia.RequestTypeId.HasValue)
{
query = query.Where(H => H.CatTipoTramiteId == Dia.RequestTypeId);
}
var tramitesUnidadesAtencion = query.ToList();
tramitesUnidadesAtencion.ForEach(Tu =>
{
var diaNoLaborable = new DiaNoLaborable
{
EsActivo = true,
Fecha = Dia.Date,
TramiteUnidadAtencionId = Tu.TramiteUnidadAtencionId
};
var resuldatoDia =
context.DiaNoLaborable.FirstOrDefault(
S => S.Fecha == Dia.Date &&
S.TramiteUnidadAtencionId == Tu.TramiteUnidadAtencionId);
if (resuldatoDia == null)
{
context.DiaNoLaborable.Add(diaNoLaborable);
}
else
{
diaNoLaborable.DiaNoLaborableId = resuldatoDia.DiaNoLaborableId;
context.DiaNoLaborable.AddOrUpdate(diaNoLaborable);
}
});
}
});
return(await context.SaveChangesAsync());
}
}
/// <summary>
///
/// </summary>
/// <param name="DetalleUnidadAtencion"></param>
/// <returns></returns>
/// <exception cref="QuejasMedicasException"></exception>
public async Task <int> AgregarOActualizar(UnidadAtencionDTO DetalleUnidadAtencion)
{
using (var modelo = new ISSSTEEntities())
{
var existeConcepto =
modelo.UnidadAtencion.FirstOrDefault(
S => S.Descripcion.Equals(DetalleUnidadAtencion.Descripcion) &&
S.UnidadAtencionId != DetalleUnidadAtencion.UnidadAtencionId);
if (existeConcepto != null)
{
throw new QuejasMedicasException(string.Format(EnumConstErrores.ErrorConceptoYaExiste,
"Nombre de la Unidad de Atencón"));
}
var resultado = new UnidadAtencion
{
UnidadAtencionId = DetalleUnidadAtencion.UnidadAtencionId,
Descripcion = DetalleUnidadAtencion.Descripcion,
Prefijo = DetalleUnidadAtencion.Prefijo,
Mascara = DetalleUnidadAtencion.Mascara,
EsActivo = DetalleUnidadAtencion.EsActivo,
CatTipoEntidadId = DetalleUnidadAtencion.CatTipoEntidadId
};
if (DetalleUnidadAtencion.DomicilioId != null && DetalleUnidadAtencion.DomicilioId != 0)
{
var domicilio = await modelo.Domicilio
.Where(S => S.DomicilioId == DetalleUnidadAtencion.DomicilioId)
.FirstOrDefaultAsync();
if (domicilio != null)
{
resultado.DomicilioId = DetalleUnidadAtencion.DomicilioId;
domicilio.Calle = DetalleUnidadAtencion.Calle;
domicilio.NumeroExterior = DetalleUnidadAtencion.NumeroExterior;
domicilio.NumeroInterior = DetalleUnidadAtencion.NumeroInterior;
domicilio.CodigoPostal = DetalleUnidadAtencion.CodigoPostal;
domicilio.Colonia = DetalleUnidadAtencion.Colonia;
domicilio.Municipio = DetalleUnidadAtencion.Municipio;
}
}
else
{
var domicilio = new Domicilio
{
Calle = DetalleUnidadAtencion.Calle,
NumeroExterior = DetalleUnidadAtencion.NumeroExterior,
NumeroInterior = DetalleUnidadAtencion.NumeroInterior,
CodigoPostal = DetalleUnidadAtencion.CodigoPostal,
Colonia = DetalleUnidadAtencion.Colonia,
Municipio = DetalleUnidadAtencion.Municipio,
EsActivo = true
};
modelo.Domicilio.Add(domicilio);
await modelo.SaveChangesAsync();
resultado.DomicilioId = domicilio.DomicilioId;
}
modelo.UnidadAtencion.AddOrUpdate(resultado);
return(await modelo.SaveChangesAsync());
}
}
