private void CargarCamposAsunto(Entidades.Asunto entAsunto)
{
txtNumAsunto.Text = entAsunto.Numero;
txtDescBreveAsuntoEstado.Text = entAsunto.DescripcionBreve;
dgListadoEstados.ItemsSource = entAsunto.Estados;
chkEstadoReportable.IsChecked = entAsunto.Reportable;
}
/// <summary>
/// Sent confirmation to UI Backoffice of adding a new asunto
/// </summary>
/// <param name="prmAsuntoSented"></param>
private async void SentBalanceRefreshOnBackoffice(Entidades.Asunto prmAsuntoSented)
{
// Validate if the backoffice is logged in
if (connectedBackoffice == null)
{
return;
}
try {
await Task.Run(() =>
{
try {
// Using Callback of asunto sent information for backoffice client
connectedBackoffice.Callback.AsuntoProcessCompleted(prmAsuntoSented);
}
catch (Exception ex) {
Log.Error("MainService", "error sending confirmation to backoffice: " + ex.Message);
}
}).TimeoutAfter(Config.BACKOFFICE_TIMEOUT);
}
catch (TimeoutException) {
// The current logged backoffice is not responding, removing from the service
connectedBackoffice = null;
Log.Info("MainService", "the backoffice is not responding, closing connection...");
}
catch (Exception ex) {
Log.Error("MainService", "there is an error processing callback sent" + ex.Message);
}
}
private void btnEliminarAsuntoDiario_Click(object sender, RoutedEventArgs e)
{
// Consulta de eliminación
if (Util.MsgBox.Consulta("¿Está seguro que desea eliminar el asunto " + (dgAsuntosDia.SelectedItem as Entidades.AsuntoDiario).Numero + "?") == true)
{
try
{
// Generamos un nuevo objeto lógica de asunto
Logica.Asunto logAsunto = new Logica.Asunto();
// Generamos la entidad a eliminar
Entidades.Asunto entAsunto = new Entidades.Asunto()
{
Numero = (dgAsuntosDia.SelectedItem as Entidades.AsuntoDiario).Numero,
Oper = App.Current.Properties["user"] as Entidades.Operador
};
// Procesamos la entidad y la eliminamos
logAsunto.Remove(entAsunto);
// Cargamos los asuntos diarios nuevamente.
CargarAsuntosDiarios();
// Cargamos el listado general
pagListadogeneral.ActualizarListado();
}
catch (Exception ex)
{
Util.MsgBox.Error("Ha ocurrido un error al intentar eliminar el asunto de la base : " + ex.Message);
}
}
}
private void txtNumAsunto_TextChanged(object sender, TextChangedEventArgs e)
{
// Si se comprueba que el número de asunto tiene el largo maximo del textbox (indica que esta completo)
if (txtNumAsunto.Text.Length == txtNumAsunto.MaxLength && txtNumAsunto.IsEnabled)
{
// Comprobamos que ls validaciones sean correctas para poder avanzar con la consulta a la base de datos
if (Validador.EsValido(txtNumAsunto))
{
try
{
// Generamos un objeto de logica asunto para averiguar si el asunto está cargado
Logica.Asunto logAsunto = new Logica.Asunto();
// Generamos un asunto que contenga solo este número cargado
Entidades.Asunto entAsunto = new Entidades.Asunto()
{
Numero = txtNumAsunto.Text, Oper = App.Current.Properties["user"] as Entidades.Operador
};
// Ejecutamos la consulta a la base de datos con el valor del campo cargado
if (logAsunto.Exist(entAsunto))
{
if (Util.MsgBox.Consulta("El asunto " + txtNumAsunto.Text + " se encuentra cargado. ¿Deseas traer el asunto guardado?") == true)
{
// Traemos el asunto y todos sus campos en la página de asuntos.
GestionarModificacionAsunto(txtNumAsunto.Text);
}
}
}
catch (Exception ex)
{
Util.MsgBox.Error("Ha ocurrido un error al traer la información de la base de datos: " + ex.Message);
}
}
}
}
public bool Equals(Asunto asuntoToCompare)
{
if (Numero == asuntoToCompare.Numero && Oper.UserName == asuntoToCompare.Oper.UserName)
{
return(true);
}
return(false);
}
public Asunto(Asunto duplicateAsunto)
{
Numero = duplicateAsunto.Numero;
Oper = duplicateAsunto.Oper;
Actuacion = duplicateAsunto.Actuacion;
Reportable = duplicateAsunto.Reportable;
GrupoDerivado = duplicateAsunto.GrupoDerivado;
DescripcionBreve = duplicateAsunto.DescripcionBreve;
Estados = duplicateAsunto.Estados;
}
private void ResetearCamposAsuntos()
{
txtNumAsunto.Text = "";
txtDescBreveAsuntoEstado.Text = "";
chkEstadoReportable.IsChecked = false;
dgListadoEstados.ItemsSource = null;
bModificando = false;
dgListadoEstados.Items.Refresh();
entAsunto = null;
VentanaPadre.pagActuacion.ResetearCampos();
}
async void IServicioCallback.EnviarAsunto(Entidades.Asunto a)
{
try {
// Duplicates entity for confirmation
Entidades.Asunto entNewAsunto = new Entidades.Asunto(a);
callbackInteraction.EnviarAsunto(entNewAsunto);
await prepareProxy();
proxy.AsuntoReceiptCompleted(a);
}
catch (Exception ex) {
Except.Throw(ex);
}
}
private void generateInitialStatusOfAsunto(Entidades.Asunto a)
{
if (a.Estados == null)
{
a.Estados = new List <Estado>();
}
a.Estados.Add(new Estado()
{
Ord = 1,
Detalle = "Nuevo asunto asignado",
FechaHora = DateTime.Now,
Tipo = Logica.TipoEstado.TraerEstadoAsuntoInicialNormal()
});
}
/// <summary>
/// Modifica un asunto en el listado de asuntos
/// </summary>
/// <param name="entAsunto"></param>
public void ModificarAsunto(Entidades.Asunto entAsunto)
{
try
{
// Generamos un objeto de lógica de asunto
Logica.Asunto logAsunto = new Logica.Asunto();
// Modificamos el asunto procesado
logAsunto.Modify(entAsunto);
// Enviamos el mensaje de actualización
Util.MsgBox.Error("Se ha actualizado un asunto de manera correcta.");
// Actualizamos el listado de asuntos
VentanaPadre.pagListadogeneral.ActualizarListado();
// Actualizamos los asuntos diarios
VentanaPadre.CargarAsuntosDiarios();
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Carga un asunto en el listado de asuntos
/// </summary>
/// <param name="pEntAsunto"></param>
public void CargarAsunto(Entidades.Asunto pEntAsunto)
{
try
{
// Generamos un objeto de logica asunto
Logica.Asunto logAsunto = new Logica.Asunto();
// Procesamos el pedido de alta
logAsunto.Add(pEntAsunto);
// Mostramos un mensaje de exito en solicitud
Util.MsgBox.Error("Se ha cargado el asunto de manera correcta");
// Actualizamos el listado de asuntos cargados
VentanaPadre.pagListadogeneral.ActualizarListado();
// Actualizamos el listado de asuntos diarios
VentanaPadre.CargarAsuntosDiarios();
}
catch (Exception ex)
{
throw ex;
}
}
// Si no hay una entidad generada, la generamos para que se pueda utilizar durante la aplicación
private void GenerarNuevaEntidad()
{
try
{
// Generamos la nueva entidad
entAsunto = new Entidades.Asunto();
entAsunto.Oper = App.Current.Properties["user"] as Entidades.Operador;
entAsunto.Estados = new List <Entidades.Estado>();
Entidades.Estado entEstadoAsunto = new Entidades.Estado()
{
Detalle = "Nuevo asunto",
FechaHora = DateTime.Now,
Ord = 1,
Tipo = Logica.TipoEstado.TraerEstadoAsuntoInicialNormal()
};
entAsunto.Estados.Add(entEstadoAsunto);
dgListadoEstados.ItemsSource = entAsunto.Estados;
}
catch (Exception ex)
{
throw ex;
}
}
/// <summary>
/// Interfaz abierta para poder recibir peticiones de modificación
/// </summary>
/// <param name="pSNumero"></param>
public bool GestionarModificacionAsunto(String pSNumero)
{
try
{
// Si el procedimiento llega a completarse correctamente se procesa el descartado del asunto
if (DescartarModificacionesAsunto())
{
HabilitarCampos();
ModificandoAsunto = true;
// Generamos un objeto lógica asunto para procesar la extraccion de información del asunto
Logica.Asunto logAsunto = new Logica.Asunto();
// Recuperamos la información del asunto y la almacenamos en la entidad
entAsunto = new Entidades.Asunto()
{
Numero = pSNumero,
Oper = App.Current.Properties["user"] as Entidades.Operador
};
entAsunto = logAsunto.Get(entAsunto);
// Cargamos los campos correspondientes
CargarCamposAsunto(entAsunto);
// Cargamos los datos correspondientes a la actuación si la entidad viene cargada
if (entAsunto.Actuacion != null)
{
VentanaPadre.pagActuacion.CargarActuacion(entAsunto.Actuacion);
}
// Devolvemos una respuesta positiva al proceso
return(true);
}
return(false);
}
catch (Exception ex)
{
Util.MsgBox.Error("Ha ocurrido un error al intentar recuperar el asunto " + pSNumero + ". Detalle : " + ex.Message);
return(false);
}
}
void IServicioCallback.AsuntoProcessCompleted(Entidades.Asunto a)
{
callbackInteraction.AsuntoProcessCompleted(a);
}
/// <summary>
/// Sent to the service an asunto to deliver
/// </summary>
/// <param name="prmBackofficeSender">Backoffice who sends asunto</param>
/// <param name="prmAsuntoToSent">Asunto to send</param>
public async Task SentAsuntoToOperator(Entidades.Operador prmBackofficeSender, Entidades.Asunto prmAsuntoToSent)
{
try {
// Manage status of the proxy
await HandleProxy();
proxy.SentAsuntoToOperator(prmBackofficeSender, prmAsuntoToSent);
}
catch (Exception ex) {
Except.Throw(ex);
}
}
public void EnviarAsunto(Entidades.Asunto a)
{
newAsuntoFromService(a);
}
