/// <summary>
/// Consulta sobre la base de datos por el listado de estados asuntos cargados segun el asunto pasado por parametro
/// Fecha de creación : 06/06/2018
/// Autor : Maximiliano Leiva
/// </summary>
/// <param name="pEntAsunto"></param>
/// <returns></returns>
public static List <Entidades.Estado> TraerListaEstadosPorAsunto(Entidades.Asunto pEntAsunto)
{
// Generamos la lista vacía a devolver
List <Entidades.Estado> lstEstadoAsunto = new List <Entidades.Estado>();
// Generamos un nuevo objeto de conexión
using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena))
{
// Abrimos la conexión de la base de datos
c.Open();
// Disponemos de la cadena que realizará la consulta
String strConsultaEstados = "SELECT fechaHora, detalle, ord, tipo FROM asuntos_estados WHERE numero=@Numero and operador=@Operador order by ord ASC";
using (SQLiteCommand cmdConsultaEstados = new SQLiteCommand(strConsultaEstados, c))
{
// Parametrizamos la consulta
cmdConsultaEstados.Parameters.Agregar("@Numero", pEntAsunto.Numero);
cmdConsultaEstados.Parameters.Agregar("@Operador", pEntAsunto.Oper.UserName);
// Leemos los resultados obtenidos
using (SQLiteDataReader rdrAsuntoEstados = cmdConsultaEstados.ExecuteReader())
{
while (rdrAsuntoEstados.Read())
{
Entidades.Estado estadoLeido = new Entidades.Estado();
Entidades.TipoEstado estadoLeidoTipo = new Entidades.TipoEstado();
estadoLeido.FechaHora = Convert.ToDateTime(rdrAsuntoEstados["fechaHora"]);
estadoLeido.Detalle = rdrAsuntoEstados["detalle"].ToString();
estadoLeido.Ord = Convert.ToInt32(rdrAsuntoEstados["ord"]);
estadoLeidoTipo.Id = Convert.ToInt32(rdrAsuntoEstados["tipo"]);
estadoLeido.Tipo = estadoLeidoTipo;
lstEstadoAsunto.Add(estadoLeido);
}
}
}
}
// Devolvemos la lista procesada.
return(lstEstadoAsunto);
}
/// <summary>
/// Devuelve un listado con tipos de estado de asunto
/// </summary>
/// <returns>Listado de tipos de estado de asunto</returns>
public List <Entidades.TipoEstado> TraerTipoEstado()
{
// Preparamos el objeto a devolver
List <Entidades.TipoEstado> lstTipoEstado = new List <Entidades.TipoEstado>();
// Generamos el objeto de conexión
using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena))
{
// Abrimos la conexión
c.Open();
String sConsultaTipoEstado = @" SELECT id,descripcion, requiere_detalle, inicio_habilitado, unico, corte_ciclo, requiere_actuacion, gestion
FROM estado_tipo
";
// Disponemos del comando de lectura
using (SQLiteCommand cmdLecturaTipoEstado = new SQLiteCommand(sConsultaTipoEstado, c))
{
// Disponemos del objeto de lecutra para recorrer los elementos obtenido de base de datos
using (SQLiteDataReader rdrLecturaTipoEstado = cmdLecturaTipoEstado.ExecuteReader())
{
// Leemos los resultados obtenidos
while (rdrLecturaTipoEstado.Read())
{
// Generamos la entidad que utilizaremos durante el transcurso del aplicativo
Entidades.TipoEstado entTipoEstado = new Entidades.TipoEstado();
entTipoEstado.Id = Convert.ToInt32(rdrLecturaTipoEstado["id"]);
entTipoEstado.Descripcion = rdrLecturaTipoEstado["descripcion"].ToString();
entTipoEstado.RequiereDetalle = Convert.ToBoolean(rdrLecturaTipoEstado["requiere_detalle"]);
entTipoEstado.InicioHabilitado = Convert.ToBoolean(rdrLecturaTipoEstado["inicio_habilitado"]);
entTipoEstado.CorteCiclo = Convert.ToBoolean(rdrLecturaTipoEstado["corte_ciclo"]);
entTipoEstado.RequiereActuacion = ObtenerRequerimientoActuacion(rdrLecturaTipoEstado["requiere_actuacion"].ToString());
entTipoEstado.Unico = Convert.ToBoolean(rdrLecturaTipoEstado["unico"]);
List <Entidades.TipoEstado> lstRelacionesTipo = new List <Entidades.TipoEstado>();
#region almacenamiento_relaciones_tipo
// Nota: Es posible que haya que refactorizar esta porción de código. Si la logica de negocio va a requerir mas información que solo el número de ID y la descripción, es posible que tipos de estados deban ser cargados completamente dependiendo de la necesidad de la aplicación.
// Una refactorización posible sería unicamente cagar el listado de estados desde la logica, y luego logica procese un pedido a la base de datos solicitando unicamente los ID destino de cada foreach de tipo revisado. Una vez recolectado los IDs se recorre el listado de estados cargado y se almacenan las entidades dentro del listado de permitidos
// Se debe recorrer las relaciones vinculadas y permitidas con cada uno de los tipos de estados
String sRelacionesAsunto = "SELECT tipo_destino_id, tipo_destino_descripcion FROM VistaTiposRelacionesAdmitidas WHERE tipo_origen_id=@Id";
using (SQLiteCommand cmdLecturaRelacionesEstado = new SQLiteCommand(sRelacionesAsunto, c))
{
// Parametrizamos el comando
cmdLecturaRelacionesEstado.Parameters.Add(new SQLiteParameter()
{
ParameterName = "@Id",
Value = entTipoEstado.Id,
DbType = System.Data.DbType.Int32
});
// Preparamos el lector de relaciones vinculadas con el ID actual
using (SQLiteDataReader rdrLectorRelaciones = cmdLecturaRelacionesEstado.ExecuteReader())
{
while (rdrLectorRelaciones.Read())
{
// Generamos una entidad que almacenara solo el id y la descripción del id
Entidades.TipoEstado entRelTipo = new Entidades.TipoEstado()
{
Id = Convert.ToInt32(rdrLectorRelaciones["tipo_destino_id"]),
Descripcion = rdrLectorRelaciones["tipo_destino_descripcion"].ToString()
};
// Almacenamos el ID dentro del listado de relaciones
lstRelacionesTipo.Add(entRelTipo);
}
}
}
#endregion
entTipoEstado.RelacionesPermitidas = lstRelacionesTipo;
entTipoEstado.Gestion = new Entidades.Gestion()
{
Id = Convert.ToInt32(rdrLecturaTipoEstado["gestion"])
};
lstTipoEstado.Add(entTipoEstado);
}
}
}
}
// Rellenamos el listado de relaciones de cada uno de los tipos de estados con sus datos completos
foreach (Entidades.TipoEstado tipoEstado in lstTipoEstado)
{
for (int i = 0; i < tipoEstado.RelacionesPermitidas.Count; i++)
{
tipoEstado.RelacionesPermitidas[i] = lstTipoEstado.Find((te) => te.Id == tipoEstado.RelacionesPermitidas[i].Id);
}
}
// Lo devolvemos luego de procesarlo
return(lstTipoEstado);
}
/// <summary>
/// Trae los asuntos del día y los procesa para que la capa de presentación pueda disponer de ellos
/// Fecha de creación : 07/06/2018
/// Autor : Maximiliano Leiva
/// </summary>
/// <param name="pOper">Operador que quiere recolectar sus asuntos del día</param>
/// <returns></returns>
public List <Entidades.AsuntoDiario> getCurrentDayList(Entidades.Operador pOper)
{
try
{
// Generamos un listado de asuntos diarios que sera devuelto en el proceso
List <Entidades.AsuntoDiario> lstAsuntoDiario = new List <Entidades.AsuntoDiario>();
// Traemos el listado de asuntos del día
List <Entidades.Asunto> lstAsuntos = datAsunto.GetCurrentDayList(pOper);
#region proceso_asuntos_tiempo
// Recorremos el listado de asuntos
foreach (Entidades.Asunto asunto in lstAsuntos)
{
// Generamos un nuevo asunto diario
Entidades.AsuntoDiario asunto_diario = new Entidades.AsuntoDiario();
// Almacenamos el número de asunto sobre la entidad
asunto_diario.Numero = asunto.Numero;
// Obtenemos el maximo orden del listado
int iOrdMax = asunto.Estados.Select((asEst) => asEst.Ord).ToArray().Max();
// Obtenemos el tipo de estado almacenado con el orden máximo
Entidades.TipoEstado tipoEstadoMaxOrd = TipoEstado.TraerCompleto(asunto.Estados.Find((et) => et.Ord == iOrdMax).Tipo);
// Obtenemos el string correspondiente del tipo de estado
String strDescripcionEstado = tipoEstadoMaxOrd.Descripcion;
// Almacenamos el nombre del estado con ordenMaximo
asunto_diario.UltimoEstado = strDescripcionEstado;
if (asunto.Reportable && !tipoEstadoMaxOrd.CorteCiclo)
{
// Disponemos un acumulador de minutos para almacenar los datos de reportables
int iMinutos = 0;
for (int i = 0; i < asunto.Estados.Count; i++)
{
bool bCorte = false;
DateTime dtInicio = asunto.Estados[i].FechaHora;
for (int j = i + 1; j < asunto.Estados.Count && !bCorte; j++)
{
// Si la suma de i + 1 supera el conteo total de estados no se procesa
// Determinamos si el tipo de estado cargado en el asunto es de tipo corte
if (j < asunto.Estados.Count && TipoEstado.EsCorteCiclo(asunto.Estados[j].Tipo))
{
// Detenemos el bucle posterior cambiando el estado de corte
bCorte = true;
// Seteamos el valor del tiempo almacenado en el estado indicado
DateTime dtCorte = asunto.Estados[j].FechaHora;
// Obtenemos la diferencia en tiempo
TimeSpan dtDiff = dtCorte.Subtract(dtInicio);
// Almacenamos la diferencia en minutos
iMinutos = iMinutos + Convert.ToInt16(dtDiff.TotalMinutes);
// Asignamos el valor siguiente de I al valor de J sumado uno para continuar ciclando
i = j;
}
}
if (i + 1 == asunto.Estados.Count)
{
// TimeSpan de tiempo relacionado con el actual
TimeSpan diffTiempoActual = DateTime.Now.Subtract(dtInicio);
iMinutos = iMinutos + Convert.ToInt16(diffTiempoActual.TotalMinutes);
}
}
// Agregamos el procesamiento de minutos a la entidad generada
asunto_diario.TiempoReportable = iMinutos;
}
// Agregamos la entidad generada al listado de asuntos diarios
lstAsuntoDiario.Add(asunto_diario);
}
#endregion
// Devolvemos el listado de asuntos diarios procesados
return(lstAsuntoDiario);
}
catch (Exception ex)
{
throw ex;
}
}
public static List <Entidades.TipoEstado> TraerEstadosPermitidos(List <Entidades.Estado> pLstEstado, int pIntOrdenSeleccionada, bool actuacion = false)
{
// Generamos la entidad listado
List <Entidades.TipoEstado> lstTipoEstadoPermitido = new List <Entidades.TipoEstado>();
// Comprobamos si el listado viene cargado con información o si por el contrario esta nulo
if (pLstEstado != null)
{
if (pIntOrdenSeleccionada == 1)
{
lstTipoEstadoPermitido.AddRange(_listadoTiposEstados.FindAll((tpe) => tpe.InicioHabilitado));
}
else
{
// Obtenemos el estado previo si es que existe y Recolectamos el TipoEstado del listado proveniente de la base para corroborar de que este correctamente cargado
Entidades.TipoEstado tpePrevio = pLstEstado.Find((tipoEstado) => tipoEstado.Ord == pIntOrdenSeleccionada - 1).Tipo;
tpePrevio = _listadoTiposEstados.Find((previo) => previo.Id == tpePrevio.Id);
// Para evitar errores de nulos en caso de que no haya un estado posterior, filtramos el resultado
if (pLstEstado.Select((ea) => ea.Ord).ToArray().Max() <= pIntOrdenSeleccionada)
{
lstTipoEstadoPermitido = tpePrevio.RelacionesPermitidas;
}
else
{
// Obtenemos el estado posterior si es que existe y Recolectamos el TipoEstado del listado proveniente de la base para corroborar de que este correctamente cargado
Entidades.TipoEstado tpePosterior = pLstEstado.Find((tipoEstado) => tipoEstado.Ord == pIntOrdenSeleccionada + 1).Tipo;
tpePosterior = _listadoTiposEstados.Find((posterior) => tpePosterior.Id == posterior.Id);
// Dejamos una variable disponible para ir almacenando los permitidos posteriores
List <Entidades.TipoEstado> lstTiposPosterioresPermitidos = new List <Entidades.TipoEstado>();
// Recorremos los resultados almacenados para encontrar el tipo estado que sea aceptado por estado posterior
foreach (var tiposEstados in _listadoTiposEstados)
{
if (tiposEstados.RelacionesPermitidas.Exists((tpe) => tpe.Id == tpePosterior.Id))
{
lstTiposPosterioresPermitidos.Add(tiposEstados);
}
}
// Teniendo en cuenta el estado previo completamos el listado de tipos
lstTipoEstadoPermitido.AddRange(tpePrevio.RelacionesPermitidas);
// Tenemos que remover del listado los estados que no sean permitidos por el estado siguiente
foreach (Entidades.TipoEstado estadoRelacionado in tpePrevio.RelacionesPermitidas)
{
if (!lstTiposPosterioresPermitidos.Exists((tipoPosterior) => tipoPosterior.Id == estadoRelacionado.Id))
{
lstTipoEstadoPermitido.Remove(estadoRelacionado);
}
}
}
}
}
if (actuacion)
{
// Recorremos el listado de estados permitidos para determinar cuales son actuacion
lstTipoEstadoPermitido = lstTipoEstadoPermitido.FindAll((tpe) => tpe.Gestion.Id == 2);
}
else
{
lstTipoEstadoPermitido = lstTipoEstadoPermitido.FindAll((tpe) => tpe.Gestion.Id == 1);
}
// Luego de procesar el listado lo devolvemos
return(lstTipoEstadoPermitido);
}
/// <summary>
/// Devuelve un tipo de estado con todas sus propiedades cargadas correctamente en base a un id del tipo de estado
/// </summary>
/// <para><param name="pTipoEstado"> : Tipo estado con propiedades faltantes de cargar </param></para>
/// <returns>Se carga completamente la entidad y se la devuelve con toda su información cargada</returns>
public static Entidades.TipoEstado TraerCompleto(Entidades.TipoEstado pTipoEstado)
{
return(_listadoTiposEstados.Find((tipEst) => tipEst.Id == pTipoEstado.Id));
}
/// <summary>
/// Devuelve si el estado pasado por parametros es de tipo corte de ciclo
/// Fecha de creación : 08/06/2018
/// Autor : Maximiliano Leiva
/// </summary>
/// <param name="entTipoEstado"></param>
/// <returns></returns>
public static bool EsCorteCiclo(Entidades.TipoEstado entTipoEstado)
{
return(_listadoTiposEstados.Find((tipoEstado) => tipoEstado.Id == entTipoEstado.Id).CorteCiclo);
}
