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