/// <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); }