/// <summary> /// Actualiza la base de datos bajo la entidad comunicada /// </summary> /// <param name="pAsunto"></param> /// <param name="conn"></param> /// <param name="trans"></param> public static void ActualizarEstadosPorAsunto(Entidades.Asunto pAsunto, SQLiteConnection conn, SQLiteTransaction trans) { // Eliminamos los estados de asunto EliminarEstadosPorAsunto(pAsunto, conn, trans); // Agregamos los estados cargados del asunto AddAllFromAsunto(pAsunto, conn, trans); }
/// <summary> /// Elimina un asunto de la base de datos /// Fecha de creación : 06/06/2018 /// Autor : Maximiliano Leiva /// </summary> /// <param name="pEntAsunto"></param> public void Remove(Entidades.Asunto pEntAsunto) { try { // Generamos un nuevo objeto de conexión using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena)) { // Realizamos la apertura de conexión c.Open(); // Disponemos la transacción para ser utilizada en el transcurso de la operación using (SQLiteTransaction t = c.BeginTransaction()) { // Eliminamos los estados guardados en base de datos EstadoAsunto.EliminarEstadosPorAsunto(pEntAsunto, c, t); // Preparamos la eliminación del asunto String strEliminarAsunto = "DELETE FROM ASUNTOS where numero=@Numero and operador=@Operador"; // Generamos el comando de eliminación using (SQLiteCommand cmdEliminarAsunto = new SQLiteCommand(strEliminarAsunto, c, t)) { // Agregamos los parametros al comando cmdEliminarAsunto.Parameters.Agregar("@Numero", pEntAsunto.Numero); cmdEliminarAsunto.Parameters.Agregar("@Operador", pEntAsunto.Oper.UserName); // Ejecutamos la eliminación por comando cmdEliminarAsunto.ExecuteNonQuery(); } // Impactamos el Commit t.Commit(); } } } catch (Exception) { throw new Exception("Ha ocurrido un error al eliminar el asunto"); } }
private void cboOperatorToLoad_Loaded(object sender, RoutedEventArgs e) { // Get Sender Object and set in combo ComboBox operatorCombo = sender as ComboBox; // Save itemsource to combobox operatorCombo.ItemsSource = lstOperatorForAssign; // Get asunto related to combo Entidades.Asunto asuntoRelated = getAsuntoByCombo(operatorCombo); if (asuntoRelated.Oper == null) { // Configure selected index to first operatorCombo.SelectedIndex = 0; } else { // If the asunto have already selected operator foreach (var operInList in lstOperatorForAssign) { if (operInList.Operator != null && operInList.Equals(asuntoRelated.Oper)) { operatorCombo.SelectedItem = operInList; } } } // Loads Selection Changed operatorCombo.SelectionChanged += cboOperatorToLoad_SelectionChanged; }
/// <summary> /// Sent asunto in batch to a cliente /// /// </summary> /// <param name="lstAsuntoToSent"></param> private async void SentAsuntoToOperator(List <Entidades.Asunto> lstAsuntoToSent) { try { await Task.Run(() => { try { if (lstAsuntoToSent.Count == 1) { // Get asunto to sent Entidades.Asunto asuntoToSent = lstAsuntoToSent[0]; // Sent callback to operator getCallback(asuntoToSent.Oper).EnviarAsunto(asuntoToSent); } else if (lstAsuntoToSent.Count > 1) { // Get operator from list Entidades.Operador operToSent = lstAsuntoToSent[0].Oper; // Sent a batch with the list of asuntos getCallback(operToSent).SentAsuntosBatch(lstAsuntoToSent); } } catch (Exception ex) { Log.Error("AsuntosPendingDelivery-SentAsunto", ex.Message); } }).TimeoutAfter(2000); } catch (TimeoutException) { } catch (Exception ex) { Log.Error("AsuntosPendingDelivery-SentAsunto", ex.Message); } }
/// <summary> /// Controla si al hacer hacer click en modificar del menu contextual hay algún elemento seleccionado y elimina llegado el caso de confirmación /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void mniEliminarAsunto_Click(object sender, RoutedEventArgs e) { if (dgListadoGeneral.SelectedItem != null) { if (Util.MsgBox.Consulta("¿Estás seguro de que deseas eliminar el asunto " + (dgListadoGeneral.SelectedItem as DataRowView)["num_asunto"].ToString()) == true) { try { // Generamos un objeto de lógica para procesar la solicitud de baja Logica.Asunto logAsunto = new Logica.Asunto(); // Generamos un nueva entidad de asunto que será cargada con los datos requieridos para que la baja se procese Entidades.Asunto entAsunto = new Entidades.Asunto() { Numero = (dgListadoGeneral.SelectedItem as DataRowView)["num_asunto"].ToString(), Oper = App.Current.Properties["user"] as Entidades.Operador }; // Procesamos el pedido de baja utilizando el objeto de lógica logAsunto.Remove(entAsunto); // Informamos que la baja fue procesada Util.MsgBox.Error("Se ha procesado la baja del asunto de manera correcta."); // Recargamos el resumen de tickets mensuales CargarResumenTicketsMensuales(); // Disponemos del objeto de ventana principal frmMainFrame ventPrincip = App.Current.MainWindow as frmMainFrame; // Actualizamos los asuntos diarios cargados ventPrincip.CargarAsuntosDiarios(); } catch (Exception ex) { Util.MsgBox.Error("No se ha podido completar la baja del asunto : " + ex.Message); } } } }
private void btnConfirm_Click(object sender, RoutedEventArgs e) { try { // Prepares new entity to travel to service Entidades.Asunto newAsunto = new Entidades.Asunto() { Numero = txtAsuntoNumber.Text, DescripcionBreve = txtShortDescription.Text, Oper = operatorToSent, isCreatedByBackoffice = true }; // Generates a new logic asunto object Logica.Asunto logAsunto = new Logica.Asunto(); // Gets operator logged on application Entidades.Operador backofficeOperator = App.Current.Properties["user"] as Entidades.Operador; // Calls a sent method logAsunto.SentAsuntoToOperator(backofficeOperator, newAsunto); // Set property on public property confirmedNewAsunto = newAsunto; // Sets result to true DialogResult = true; } catch (Exception ex) { Except.Throw(ex); } }
/// <summary> /// Método que determina si ya hay un asunto cargado en base que corresponda con el número de asunto y el operador /// </summary> /// <param name="pAsunto"></param> /// <returns></returns> public bool Exist(Entidades.Asunto pAsunto) { try { // Generamos un nuevo objeto de cadena de conexión using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena)) { c.Open(); String strConsultaAsunto = "SELECT 1 FROM asuntos WHERE numero=@Numero and operador=@Operador"; // Generamos el comando de consulta para la base de datos using (SQLiteCommand cmdConsultaAsunto = new SQLiteCommand(strConsultaAsunto, c)) { // Parametrizamos la consulta cmdConsultaAsunto.Parameters.Agregar("@Numero", pAsunto.Numero); cmdConsultaAsunto.Parameters.Agregar("@Operador", pAsunto.Oper.UserName); // Ejecutamos la consulta con un lector using (SQLiteDataReader rdrAsunto = cmdConsultaAsunto.ExecuteReader()) { if (rdrAsunto.Read()) { return(true); } return(false); } } } } catch (Exception) { throw new Exception("Ha ocurrido un error al recolectar la información dede la base de datos"); } }
/// <summary> /// Process a list passed on parameter and get from database coincidences /// </summary> /// <param name="lstAsuntoSource"></param> /// <returns></returns> private static List <Entidades.Asunto> getAssignedAndDuplicatedAsuntoList(List <Entidades.Asunto> lstAsuntoSource) { // Generate a new list to return in process List <Entidades.Asunto> lstDuplicatedAsuntos = new List <Entidades.Asunto>(); using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena)) { c.Open(); // Validates existence of asunto in assigned successfull list string strQueryValidateAssignedAsuntoBatch = "SELECT number, operator from asuntos_assigned_successful where number in (@AsuntoList)"; using (SQLiteCommand cmdQueryValidateAssignedAsuntoBatch = new SQLiteCommand(strQueryValidateAssignedAsuntoBatch, c)) { cmdQueryValidateAssignedAsuntoBatch.Parameters.Agregar("@AsuntoList", getNumberOfAsuntosOnlyFromListForDatabaseRead(lstAsuntoSource)); using (SQLiteDataReader rdrQueryValidateAssignedAsuntoBatch = cmdQueryValidateAssignedAsuntoBatch.ExecuteReader()) { while (rdrQueryValidateAssignedAsuntoBatch.Read()) { Entidades.Asunto asuntoFinded = new Entidades.Asunto() { Numero = rdrQueryValidateAssignedAsuntoBatch["number"].ToString(), Oper = new Entidades.Operador() { UserName = rdrQueryValidateAssignedAsuntoBatch["operator"].ToString() } }; // Add founded duplicate on the list lstDuplicatedAsuntos.Add(asuntoFinded); } } } } // Return processed list return(lstDuplicatedAsuntos); }
/// <summary> /// Increment by 1 by asunto passed on parameter /// </summary> /// <param name="prmAsuntoToFetch"></param> public void Increment(Entidades.Asunto prmAsuntoToFetch, bool refreshAverageAsuntoByHour = true) { try { validateInput(prmAsuntoToFetch); // Find specific balance on the list Entidades.Balance balance = getBalanceByAsunto(prmAsuntoToFetch); // DateTime to process in increment DateTime dateToIncrement; // If the asunto is assigned correctly if (prmAsuntoToFetch.isAssigned) { // Set date of increment on date of assignment dateToIncrement = prmAsuntoToFetch.AssignmentDate; // If the asunto is previously saved on temporaly list if (isLoadedOnTemporalyList(prmAsuntoToFetch)) { // Decrement value on temporaly location saved balance.Decrement(prmAsuntoToFetch.SendingDate); } } else { // If is not assigned means probably change status on program execution _lstOfTemporalyCountedAsuntos.Add(prmAsuntoToFetch); // Set va dateToIncrement = prmAsuntoToFetch.SendingDate; } // Increment balance finded balance.Increment(dateToIncrement); } catch (Exception ex) { throw ex; } }
private bool isAsuntoOwnerConnected(Entidades.Asunto asuntoToQuery) { return(lstOperatorMustConnected .ToList() .Exists( (operIterate) => operIterate.Operator.Status != Entidades.AvailabiltyStatus.Disconnected && operIterate.Operator.UserName == asuntoToQuery.Oper.UserName)); }
/// <summary> /// Modifica los estados de actuación en la base de datos /// Como las actuaciones relacionadas con asuntos pueden eliminarse los estados, y esto afecta a las actuaciones, se deben eliminar en primera instancia las actuaciones relacionadas y /// </summary> /// <param name="pAsunto"></param> /// <param name="conn"></param> /// <param name="trans"></param> public static void Modificar(Entidades.Asunto pAsunto, SQLiteConnection conn, SQLiteTransaction trans) { // Disponemos la variable de actuación separada para mejorar la legibilidad del código Entidades.Actuacion pActuacion = pAsunto.Actuacion; // Tenemos que recolectar de la base de datos las actuaciones relacionadas con el asunto, para que asi podamos eliminarlas y poder hacer el ingreso sin dejar actuaciones huerfanas Eliminar(pAsunto, conn, trans); // Se agrega las actuaciones modificadas Agregar(pAsunto, conn, trans); }
/// <summary> /// Modifica un asunto en la persistencia de la base de datos /// Fecha de creación : 12/06/2018 /// Autor : Maximiliano Leiva /// </summary> /// <param name="pAsunto"></param> public void Modify(Entidades.Asunto pAsunto) { try { datAsunto.Modify(pAsunto); } catch (Exception ex) { throw ex; } }
/// <summary> /// Add a asunto to the list /// </summary> /// <param name="asuntoToAdd"></param> public void Add(Entidades.Asunto asuntoToAdd) { bool isAsuntoAlreadyLoaded = _listOfAsuntoToDeliver.Exists(asunto => asunto.Equals(asuntoToAdd)); if (isAsuntoAlreadyLoaded) { throw new Exception(Error.ASUNTO_ALREADY_IN_DELIVER_LIST); } // Add the asunto to the list _listOfAsuntoToDeliver.Add(asuntoToAdd); }
/// <summary> /// Elimina un asunto de la base de datos aplicando reglas de negocio /// Fecha de creación : 06/06/2018 /// Autor : Maximiliano Leiva /// </summary> /// <param name="pAsunto"></param> public void Remove(Entidades.Asunto pAsunto) { try { datAsunto.Remove(pAsunto); } catch (Exception ex) { throw ex; } }
/// <summary> /// Determina si el asunto pasado por parametro ya esta cargado en base de datos /// </summary> /// <param name="pAsunto"></param> /// <returns></returns> public bool Exist(Entidades.Asunto pAsunto) { try { return(datAsunto.Exist(pAsunto)); } catch (Exception ex) { throw ex; } }
/// <summary> /// Agregamos un asunto a la base de datos aplicando previamente las reglas de negocio /// Fecha de creación : 06/06/2018 /// Autor : Maximiliano Leiva /// </summary> /// <param name="pAsunto"></param> public void Add(Entidades.Asunto pAsunto) { try { // Hacemos persistir la información datAsunto.Add(pAsunto); } catch (Exception ex) { throw ex; } }
private void validateInput(Entidades.Asunto prmAsuntoToFetch) { // Checks if the asunto is loaded with needeed values if (prmAsuntoToFetch.Oper.UserName == "" || prmAsuntoToFetch.AssignmentDate == null) { throw new Exception("the informed asunto is missing of datetime or username"); } // Check if the list is started correctly if (List == null) { throw new Exception("the list is not started correctly"); } }
/// <summary> /// Remove asunto from Queue /// </summary> /// <param name="asuntoToUnqueue"></param> private void RemovePending(Entidades.Asunto asuntoToUnqueue) { // Save date of asunto assignment asuntoToUnqueue.AssignmentDate = DateTime.Now; // Save pending information to list DeliverAsuntoList.Remove(asuntoToUnqueue); // Removemos el asunto de la base de respaldo SQL.Asunto.RemoveFromQueueAndSaveHistoricData(asuntoToUnqueue); // Sent update request to logged backoffice SentBalanceRefreshOnBackoffice(asuntoToUnqueue); // Stop sending pending asuntos StopSendAsuntosPending(); }
/// <summary> /// Consulta a la base de datos por los asuntos que corresponden al dia de la fecha /// Fecha de creación : 07/06/2018 /// Autor : Maximiliano Leiva /// </summary> /// <returns></returns> public List <Entidades.Asunto> GetCurrentDayList(Entidades.Operador pOper) { // Generamos la lista a devolver List <Entidades.Asunto> lstAsuntoDiario = new List <Entidades.Asunto>(); // Generamos el objeto de conexión despachable using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena)) { // Abrimos la conexión c.Open(); // Creamos el comando despachable using (SQLiteCommand cmdConsultaAsuntosDia = new SQLiteCommand(_consultaAsuntosDiarios, c)) { // Cargamos el parametro de operador cmdConsultaAsuntosDia.Parameters.Agregar("@Operador", pOper.UserName); // Ejecutamos el lector de asuntos using (SQLiteDataReader rdrLectorAsunto = cmdConsultaAsuntosDia.ExecuteReader()) { // Leemos los resultados obtenidos del lector while (rdrLectorAsunto.Read()) { // Generamos una nueva entidad de asunto, donde almacenaremos los diferentes estados recolectados Entidades.Asunto entAsuntoDiario = new Entidades.Asunto(); // Almacenamos el número y el operador sobre el asunto entAsuntoDiario.Oper = pOper; entAsuntoDiario.Numero = rdrLectorAsunto["numero"].ToString(); // Traemos los estados del asunto recorrido entAsuntoDiario.Estados = EstadoAsunto.TraerListaEstadosPorAsunto(entAsuntoDiario); // Consultamos si el asunto es reportable using (SQLiteCommand cmdAsuntoReportable = new SQLiteCommand(_consultaReportable, c)) { cmdAsuntoReportable.Parameters.Agregar("@Numero", rdrLectorAsunto["numero"].ToString()); cmdAsuntoReportable.Parameters.Agregar("@Operador", pOper.UserName); // Ejecutamos el lector y averiguamos si es verdadera la consulta using (SQLiteDataReader rdrReportable = cmdAsuntoReportable.ExecuteReader()) { // Si devuelve respuesta se asigna verdadero a reportable if (rdrReportable.Read()) { entAsuntoDiario.Reportable = true; } } } lstAsuntoDiario.Add(entAsuntoDiario); } } } } // Devolvemos la lista procesada return(lstAsuntoDiario); }
/// <summary> /// Add pending asunto to qeue /// </summary> /// <param name="asuntoToEnqueue"></param> private void AddPending(Entidades.Asunto asuntoToEnqueue) { // Add the asunto to distribution list DeliverAsuntoList.Add(asuntoToEnqueue); // Add to SQL Qeue SQL.Asunto.AddToQueue(asuntoToEnqueue); // Check if deliver pending asunto is in the list of asuntos without assignation. if (!asuntoToEnqueue.isCreatedByBackoffice) { lstAsuntoFromServiceUnassigned.RemoveAll(asunto => asunto.Numero == asuntoToEnqueue.Numero); } // When adds concludes, start deilvering task StartSendAsuntosPending(); }
/// <summary> /// Completamos la recepción de asuntos de parte del servicio. Se implementa en clase dedicada a la administración de entrega de asuntos pendientes /// </summary> /// <param name="asuntoToConfirm"></param> private void ConfirmAsuntoReceipt(Entidades.Asunto asuntoToConfirm) { try { lock (syncObject) { RemovePending(asuntoToConfirm); } } catch (Exception) { Log.Error(_asuntosPendingClassName, string.Format("error delivering asunto number {0} to {1}.", asuntoToConfirm.Numero, asuntoToConfirm.Oper)); } }
/// <summary> /// Ejecutamos una solicitud de eliminación de estados. Este metodo es de interface para conectar con métodos de otra clase /// </summary> /// <param name="pAsunto"></param> public static void EliminarEstadosPorAsunto(Entidades.Asunto pAsunto, SQLiteConnection conn, SQLiteTransaction trans) { // Preparamos el primer comando de eliminación String strDeleteEstadosAsunto = "DELETE FROM asuntos_estados where numero=@Numero and operador=@Operador"; // Generamos el comando de eliminación para resolver los estados en primera instancia using (SQLiteCommand cmdDeleteEstadosAsuntos = new SQLiteCommand(strDeleteEstadosAsunto, conn, trans)) { // Parametrizamos la consulta cmdDeleteEstadosAsuntos.Parameters.Agregar("@Numero", pAsunto.Numero); cmdDeleteEstadosAsuntos.Parameters.Agregar("@Operador", pAsunto.Oper.UserName); // Ejecutamos el Query cmdDeleteEstadosAsuntos.ExecuteNonQuery(); } }
/// <summary> /// Procesa la baja de una o varias actuaciones /// </summary> /// <param name="pAsunto"></param> /// <param name="conn"></param> /// <param name="trans"></param> public static void Eliminar(Entidades.Asunto pAsunto, SQLiteConnection conn, SQLiteTransaction trans) { // Parametrizamos el string que se utilizará para eliminar la actuación // Recolectamos los números de actuacion para poder eliminarlos también de actuaciones estados string sConsultaActuaciones = "SELECT numero FROM actuacion WHERE asunto_relacionado=@Asunto and operador=@Operador"; // Generamos un comando para realizar la lectura total de actuaciones relacionadas con el asunto using (SQLiteCommand cmdEliminarActuacion = new SQLiteCommand(sConsultaActuaciones, conn, trans)) { // Parametrizamos la consulta cmdEliminarActuacion.Parameters.Agregar("@Asunto", pAsunto.Numero); cmdEliminarActuacion.Parameters.Agregar("@Operador", pAsunto.Oper.UserName); // Ejecutamos el lector relacionado al comando using (SQLiteDataReader rdrActRelacionadas = cmdEliminarActuacion.ExecuteReader()) { // Generamos un listado de actuaciones donde almacenaremos los resultados recolectados List <Entidades.Actuacion> lstAct = new List <Entidades.Actuacion>(); // Leemos los resultados obtenidos while (rdrActRelacionadas.Read()) { // Generamos una nueva entidad de actuacion Entidades.Actuacion entAct = new Entidades.Actuacion() { Numero = rdrActRelacionadas["numero"].ToString(), Operador = pAsunto.Oper }; // Agregamos la entidad al listado lstAct.Add(entAct); } // Recorremos el listado de actuaciones foreach (Entidades.Actuacion entAct in lstAct) { // Eliminamos cada una de los estados de actuación relacionados EstadoActuacion.Eliminar(entAct, conn, trans); } } } string sCmdEliminarActuacion = "DELETE FROM actuacion where asunto_relacionado=@Numero and operador=@Operador"; // Generamos un comando que permitirá eliminar la actuación de la base de datos using (SQLiteCommand cmdEliminarActuacion = new SQLiteCommand(sCmdEliminarActuacion, conn, trans)) { // Parametrizamos la consulta cmdEliminarActuacion.Parameters.Agregar("@Numero", pAsunto.Numero); cmdEliminarActuacion.Parameters.Agregar("@Operador", pAsunto.Oper.UserName); // Ejecutamos el comando cmdEliminarActuacion.ExecuteNonQuery(); } }
/// <summary> /// Actualiza un asunto en base de datos /// Fecha de creación : 06/06/2018 /// Autor : Maximiliano Leiva /// </summary> /// <param name="pEntAsunto"></param> public void Modify(Entidades.Asunto pEntAsunto) { try { // Generamos el objeto de conexión using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena)) { // Abrimos la conexión c.Open(); // Iniciamos el sistema transaccional using (SQLiteTransaction t = c.BeginTransaction()) { // Generamos la cadena de caracteres que se utilizará para la actualización String strActualizarAsunto = "UPDATE asuntos SET descripcion_breve=@DescripcionBreve, grupo_derivado=@GrupoDerivado WHERE operador=@Operador and numero=@Numero"; // Generamos el comando de actualización using (SQLiteCommand cmdActualizarAsunto = new SQLiteCommand(strActualizarAsunto, c, t)) { // Parametrizamo la consulta cmdActualizarAsunto.Parameters.Agregar("@DescripcionBreve", pEntAsunto.DescripcionBreve); cmdActualizarAsunto.Parameters.Agregar("@GrupoDerivado", pEntAsunto.GrupoDerivado); cmdActualizarAsunto.Parameters.Agregar("@Operador", pEntAsunto.Oper.UserName); cmdActualizarAsunto.Parameters.Agregar("@Reportable", pEntAsunto.Reportable ? 1: 0); cmdActualizarAsunto.Parameters.Agregar("@Numero", pEntAsunto.Numero); // Ejecutamos la actualización cmdActualizarAsunto.ExecuteNonQuery(); } // Ejecutamos de la interfaz expuesta por EstadoAsunto para actulizar los estados EstadoAsunto.ActualizarEstadosPorAsunto(pEntAsunto, c, t); // Ejecutamos la interfaz expuesta por actuación para actualizarlas o eliminarlas if (pEntAsunto.Actuacion != null) { Actuacion.Modificar(pEntAsunto, c, t); } else // En el caso de que actuación venga como nulo, se eliminan todas las actuaciones relacionadas con el asunto (para evitar que queden actuaciones huerfanas) { Actuacion.Eliminar(pEntAsunto, c, t); } // Ejecutamos commit de la transacción t.Commit(); } } } catch (Exception) { throw new Exception("Ha ocurrido un error al ejecutar la actualización del asunto"); } }
/// <summary> /// Remueve un asunto de la base de datos de respaldo /// </summary> /// <param name="asunto"></param> public static void RemoveFromQueueAndSaveHistoricData(Entidades.Asunto asunto) { using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena)) { c.Open(); using (SQLiteTransaction t = c.BeginTransaction()) { using (SQLiteCommand cmdDeleteFromPendientes = getDeleteFromPendingCommand(c, t, asunto)) { cmdDeleteFromPendientes.ExecuteNonQuery(); } using (SQLiteCommand cmdInsertAssignedAsuntos = getInsertCommandToAsuntosAssignedSuccesful(c, t, asunto)) { cmdInsertAssignedAsuntos.ExecuteNonQuery(); } // When the registry is saved, proceed to calculate column to save // if all operations are successful, commit changes over database t.Commit(); } } }
/// <summary> /// Validates if the asunto sent exist on assigned history /// </summary> /// <param name="prmAsuntoToCheck"></param> /// <returns></returns> public static bool Validate(Entidades.Asunto prmAsuntoToCheck) { using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena)) { c.Open(); string sQueryCheckAsuntoExistence = "SELECT 1 from asuntos_assigned_successful where number=@Number and operator=@Operator"; using (SQLiteCommand cmdQueryCheckAsuntoExistence = new SQLiteCommand(sQueryCheckAsuntoExistence, c)) { cmdQueryCheckAsuntoExistence.Parameters.Agregar("@Number", prmAsuntoToCheck.Numero); cmdQueryCheckAsuntoExistence.Parameters.Agregar("@Operator", prmAsuntoToCheck.Oper.UserName); using (SQLiteDataReader rdrQueryCheckAsunto = cmdQueryCheckAsuntoExistence.ExecuteReader()) { if (!rdrQueryCheckAsunto.Read()) { return(true); } } } } return(false); }
/// <summary> /// Consulta a la base de datos si hay un asunto con los parametros que solicita /// Fecha de creación : 06/06/2018 /// Autor : Maximiliano Leiva /// </summary> /// <param name="pEntAsunto"></param> public Entidades.Asunto Get(Entidades.Asunto pEntAsunto) { // Generamos una entidad nueva que sera procesada Entidades.Asunto entAsunto = new Entidades.Asunto(); try { // Generamos un nuevo objeto de conexión using (SQLiteConnection c = new SQLiteConnection(Conexion.Cadena)) { // Abrimos la conexión c.Open(); String strConsultaAsunto = "SELECT descripcion_breve, grupo_derivado, reportable FROM asuntos where operador = @IdOperador and numero=@Numero"; using (SQLiteCommand cmdConsultaAsunto = new SQLiteCommand(strConsultaAsunto, c)) { cmdConsultaAsunto.Parameters.Agregar("@IdOperador", pEntAsunto.Oper.UserName); cmdConsultaAsunto.Parameters.Agregar("@Numero", pEntAsunto.Numero); using (SQLiteDataReader rdrConsultaAsunto = cmdConsultaAsunto.ExecuteReader()) { // Llemos los resultados obtenidos if (rdrConsultaAsunto.Read()) { if (!rdrConsultaAsunto.IsDBNull(1)) { entAsunto.GrupoDerivado.Id = rdrConsultaAsunto.GetInt32(1); } entAsunto.Numero = pEntAsunto.Numero; entAsunto.Oper = pEntAsunto.Oper; entAsunto.DescripcionBreve = rdrConsultaAsunto["descripcion_breve"].ToString(); entAsunto.Reportable = Convert.ToBoolean(rdrConsultaAsunto["reportable"]); entAsunto.Estados = EstadoAsunto.TraerListaEstadosPorAsunto(pEntAsunto); entAsunto.Actuacion = Actuacion.TraerActuaciones(entAsunto, c); } } } } } catch (Exception) { throw new Exception("Error en la recuperacion de información del asunto"); } // Devolvemos la entidad procesada return(entAsunto); }
/// <summary> /// Trae una actuación desde la base de datos /// </summary> /// <param name="pAsunto"></param> /// <param name="conn"></param> public static Entidades.Actuacion TraerActuaciones(Entidades.Asunto pAsunto, SQLiteConnection conn) { // Generamos el listado que luego devolveremos Entidades.Actuacion entActuacion = null; // Preparamos la cadena de caracteres para que sea usada en la consulta string strCmdConsultaActuacion = "SELECT numero, tipo, remedy_relacionado, grupo_asignado FROM actuacion WHERE asunto_relacionado=@AsuntoRelacionado and operador=@Operador"; // Disponemos del comando que ejecutara la consulta using (SQLiteCommand cmdConsultaActuacion = new SQLiteCommand(strCmdConsultaActuacion, conn)) { // Parametrizamos la consulta a ejecutar cmdConsultaActuacion.Parameters.Agregar("@AsuntoRelacionado", pAsunto.Numero); cmdConsultaActuacion.Parameters.Agregar("@Operador", pAsunto.Oper.UserName); // Ejecutamos el lector de datos sobre el comando generado using (SQLiteDataReader rdrActuacion = cmdConsultaActuacion.ExecuteReader()) { // Realizamos lectura sobre todos los resultados if (rdrActuacion.Read()) { // Generamos la entidad a agregar en el listado entActuacion = new Entidades.Actuacion() { Numero = rdrActuacion["numero"].ToString(), Grupo = new Entidades.GrupoResolutor() { Id = Convert.ToInt32(rdrActuacion["grupo_asignado"]) }, Tipo = new Entidades.ActuacionTipo() { Id = Convert.ToInt32(rdrActuacion["tipo"]) }, RemedyRelacionado = rdrActuacion["remedy_relacionado"].ToString() }; entActuacion.Operador = pAsunto.Oper; // Traemos los estados de actuación y lo cargamos sobre la entidad entActuacion.Estados = EstadoActuacion.TraerSegunActuacion(entActuacion, conn); } } } // Devolvemos el listado procesado return(entActuacion); }
private void cboOperatorToLoad_SelectionChanged(object sender, SelectionChangedEventArgs e) { // Obtenemos el valor del combo ComboBox operatorCombo = sender as ComboBox; // Gets current value of combo and cast to operator OperatorAsuntoDistribute oadSelected = operatorCombo.SelectedItem as OperatorAsuntoDistribute; // Gets selected file of dataGrid Entidades.Asunto selectedAsunto = dgAsuntosWithoutAssignation.SelectedItem as Entidades.Asunto; if (oadSelected.Operator != null) { // Save operator to selected selectedAsunto.Oper = oadSelected.Operator; } else { // Unselect operator selectedAsunto.Oper = null; } }
/// <summary> /// Trae un asunto desde la persistencia hacia la capa superior /// Fecha de creación : 06/06/2018 /// Autor : Maximiliano Leiva /// </summary> /// <param name="pNumeroAsunto"></param> public Entidades.Asunto Get(Entidades.Asunto pAsunto) { try { // Recolectamos el asunto desde la base de datos Entidades.Asunto asuntoRecolectado = datAsunto.Get(pAsunto); // El asunto viene con faltante de datos relativos a las propiedades especificas de los estados. Por tanto se carga asuntoRecolectado.Estados = getFullStatus(asuntoRecolectado.Estados); // Procedemos de la misma forma con los estados de actuación if (asuntoRecolectado.Actuacion != null) { asuntoRecolectado.Actuacion.Estados = getFullStatus(asuntoRecolectado.Actuacion.Estados); } // Devolvemos el asunto cargado return(asuntoRecolectado); } catch (Exception ex) { throw ex; } }