public CommandStatus Handle(AsistenciaUpdateCommand command)
{
AsistenciaUpdateData cmdData = new AsistenciaUpdateData();
AsistenciaUpdateCommandHandler cmdHandler = new AsistenciaUpdateCommandHandler(cmdData);
return(cmdHandler.Handle(command));
}
static void WriteDataJefeGrupo(IMessageHandling proxy)
{
// I Parte inicialmente no hay incidencias, se crean 4 nuevas en las asistencias guardadas
//_asist01.IncidenciaCausaIncidencia = 2;
//_asist01.IncidenciaObservacion = "Primera Incidencia adicionada.";
//_asist02.IncidenciaCausaIncidencia = 4;
//_asist02.IncidenciaObservacion = "Segunda Incidencia adicionada.";
//_asist03.IncidenciaCausaIncidencia = 7;
//_asist03.IncidenciaObservacion = "Tercera Incidencia adicionada.";
//_asist04.IncidenciaCausaIncidencia = 9;
//_asist04.IncidenciaObservacion = "Cuarta Incidencia adicionada.";
// II Parte Ya existen incidencias, se modifican
// SE borra la primera y se actualizan 2da y tercera
//_asist01.IncidenciaCausaIncidencia = 0;
//_asist02.IncidenciaCausaIncidencia = 2;
//_asist02.IncidenciaObservacion = "Segunda Incidencia MODIFICADA 3.";
////_asist03.IncidenciaCausaIncidencia = 1;
////_asist03.IncidenciaObservacion = "Tercera Incidencia MODIFICADA.";
//_asistencias = new Collection<Asistencia>();
//_asistencias.Add(_asist01);
//_asistencias.Add(_asist02);
// III Parte Se crea de nuevo la primera
_asist01.IncidenciaCausaId = 2;
_asist01.IncidenciaObservacion = "Primera Incidencia adicionada.";
// Comando de actualizacion
AsistenciaUpdateCommand asistCmd = new AsistenciaUpdateCommand(_asistencias, _incidencias);
var status = proxy.Handle(asistCmd);
bool Success = status.GetType() == typeof(Success);
if (Success)
{
Console.WriteLine("Comando Ejecutado con éxito.");
}
else
{
Console.WriteLine("Comando fallido. Error: " + (status as Failure).Errormessage);
}
}
public void In_AsistenciaUpdateCommand(AsistenciaUpdateCommand command)
{
try
{
AsistenciaUpdateData cmdData = new AsistenciaUpdateData();
AsistenciaUpdateCommandHandler cmdHandler = new AsistenciaUpdateCommandHandler(cmdData);
Out_AsistenciaUpdateCommandResult(cmdHandler.Handle(command));
}
catch (Exception)
{
throw;
}
}
/*
* internal static void AsignarIncidencia()
* {
* // mostrar form modal
* _incidAsignForm.EditMode = UserRoleEnum.JefeDepartamento;
* var ret = _incidAsignForm.ShowDialog(_editForm);
*
* // actualizar valores
* if (ret != DialogResult.OK)
* return;
*
* string obs = _incidAsignForm.tbObserv.Text;
* string causaDesc = _incidAsignForm.cmbCausas.Text;
* int causaId = (int) _incidAsignForm.cmbCausas.SelectedValue;
*
* // crear nueva incidencia
* Incidencia inc = new Incidencia();
* inc.CausaId = causaId;
* inc.Observacion = obs;
* inc.State = EntityState.Added;
*
* //Asistencia data;
* DataGridViewRow row = _editForm.dgvAsistencia.SelectedRows[0];
* Asistencia asist = (Asistencia)row.DataBoundItem;
*
* asist.IncidenciaRef = inc;
* asist.IncidenciaObservacion = obs;
* asist.IncidenciaCausaId = causaId;
* asist.IncidenciaCausaDesc = causaDesc;
* asist.State = EntityState.Modified;
*
* // Existe alternativa de usar BindingList<T>
* bdsAsistencias.ResetBindings(false);
*
* }
*
* internal static void AsignarIncidenciaGrupo()
* {
* // pasar datos a form bdsTodosDepartamentos
* _incidAsignForm.chlbSelEmpleado.DataSource = bdsSelectEmpleados;
*
* // mostrar form modal
* _incidAsignForm.EditMode = UserRoleEnum.Supervisor;
* var ret = _incidAsignForm.ShowDialog(_editForm);
*
* // actualizar valores
* if (ret != DialogResult.OK)
* return;
*
* string obs = _incidAsignForm.tbObserv.Text;
* string causaDesc = _incidAsignForm.cmbCausas.Text;
* int causaId = (int)_incidAsignForm.cmbCausas.SelectedValue;
*
* // crear nueva incidencia
* Incidencia newInc = new Incidencia();
* newInc.CausaId = causaId;
* newInc.Observacion = obs;
* newInc.State = EntityState.Added;
*
* DataGridViewRow row = _editForm.dgvAsistencia.SelectedRows[0];
* Asistencia data = (Asistencia)row.DataBoundItem;
*
* // obtener clave fecha de Asistencia
* //data.FechaId bdsAsistencias bdsSelectEmpleados
*
* // para cada empleado seleccoinado en lista
* // buscar asistencias por clave fecha
* // incorporar incidencia
*
* foreach (var empl in _incidAsignForm.chlbSelEmpleado.CheckedItems)
* {
* var colAsist = (empl as Empleado).Asistencias.Where(asist => asist.FechaId == data.FechaId);
*
* foreach (var asist in colAsist)
* {
* asist.IncidenciaRef = newInc;
* asist.IncidenciaObservacion = obs;
* asist.IncidenciaCausaId = causaId;
* asist.IncidenciaCausaDesc = causaDesc;
* asist.State = EntityState.Modified;
* }
* }
*
* bdsAsistencias.ResetBindings(false);
* }
*
* internal static void EliminarIncidencia()
* {
* Asistencia data;
* Incidencia inc;
*
* foreach (DataGridViewRow row in _editForm.dgvAsistencia.SelectedRows)
* {
* data = (Asistencia)row.DataBoundItem;
*
* if (data.IncidenciaRef != null)
* {
* inc = data.IncidenciaRef;
* // Marcar para eliminar objeto Incidencia.
* inc.State = EntityState.Deleted;
*
* // Almacenar ref en coleccion de actualizacion
* colIncidencias.Add(inc);
*
* // Marcar objeto Asistencia para actualizacion.
* // Hacer cero Id de referencia a Incidencia
* data.IncidenciaId = 0;
* data.State = EntityState.Modified;
* // Borrar campos.
* data.IncidenciaCausaId = 0;
* data.IncidenciaObservacion = string.Empty;
* // Refrescar datos en lista.
* bdsAsistencias.ResetBindings(false);
* }
* }
* }
*/
#endregion
internal static void ActualizarAsistencias()
{
const string methodName = "ActualizarAsistencias";
try
{
Log.WriteEntry(ClassName, methodName, TraceEventType.Information, "Ejecutando Actualizar Asistencias.");
Collection <Asistencia> colAsist = new Collection <Asistencia>();
Collection <Empleado> colEmpleados = bdsTodosEmpleados.DataSource as Collection <Empleado>;
// implementacion sin LINQ
foreach (var empl in colEmpleados)
{
foreach (var asi in empl.Asistencias)
{
colAsist.Add(asi);
}
}
// Seleccionando solo las que se modificaron.
var modAsist = colAsist.Where(asi => asi.State != EntityState.Unchanged);
colAsist = new Collection <Asistencia>(modAsist.ToArray());
// Comando de actualizacion
AsistenciaUpdateCommand asistCmd = new AsistenciaUpdateCommand(colAsist, colIncidencias);
var status = _proxy.Handle(asistCmd);
bool Success = status.GetType() == typeof(Success);
if (Success)
{
colIncidencias = new Collection <Incidencia>();
Log.WriteEntry(ClassName, methodName, TraceEventType.Information, "Actualizar Asistencias terminado con éxito.");
MessageBox.Show("Actualizar Asistencias terminado con éxito.");
}
else
{
Log.WriteEntry(ClassName, methodName, TraceEventType.Error, string.Format("Comando fallido. Error: {0}", (status as Failure).Errormessage));
MessageBox.Show("Actualizar Asistencias terminado con Error.");
}
}
catch (Exception ex)
{
Log.WriteEntry(ClassName, methodName, TraceEventType.Error, string.Format("Error: {0}", ex.Message));
}
}
/// <summary>
/// Realiza la salva de modificaciones de Asistencia al servidor de forma asíncrona.
/// </summary>
internal static bool ActualizarAsistencias()
{
const string methodName = "ActualizarAsistencias";
try
{
Log.WriteEntry(ClassName, methodName, TraceEventType.Information, "Ejecutando Actualizar Asistencias.");
EsperaPorTarea(TipoEspera.Actualizacion);
List <Asistencia> concat = new List <Asistencia>();
Collection <Empleado> colTodosEmpleados = bdsTodosEmpleados.DataSource as Collection <Empleado>;
// Crear lista de asistencias modificadas de todos los empleados
var colAsistencias = colTodosEmpleados.Select(e => e.Asistencias);
foreach (var col in colAsistencias)
{
concat = concat.Concat(col.Where(asi => asi.State != EntityState.Unchanged).ToList()).ToList();
}
var updCol = new Collection <Asistencia>(concat.ToArray());
// Comando de actualizacion
AsistenciaUpdateCommand asistCmd = new AsistenciaUpdateCommand(updCol, colIncidencias);
// Realizar la consulta y termina la ejecucion secuencial
// Se continua al recibir respuesta del server en In_AsistenciaUpdateCommandResult
Out_AsistenciaUpdateCommand(asistCmd);
return(true);
}
catch (Exception ex)
{
Log.WriteEntry(ClassName, methodName, TraceEventType.Error, string.Format("Error: {0}", ex.Message));
return(false);
}
}
// nueva implementacion en base a la original
/* Comprobar todos los casos ************* IncidenciaId
*
* Para gestionar Incidencias y Asistencias
*
* La Entidad Asistencia tiene una Propiedad CausaIncidenciaId que indica el tipo de Incidencia, redundante.
* y una propiedad IncidenciaId que es PK id de la Incidencia.
*
* La propiedad IncidenciaId se crea en el servidor (al INSERTar nueva Incidencia) y no se modifica en GUI
* Las propiedades CausaIncidenciaId se puede modificar en la GUI.
*
* Propiedad Prop Referencia Accion
* CausaIncidenciaId IncidenciaId
* 0 0 Ignorar, no hay cambios
* 0 Not 0 Delete, se ha eliminado la Incidencia de la Asistencia. Actualizar Asistencia, Eliminar Incidencia (obtener ent por referencia y eliminar de la db por Id)
* Not 0 0 Insert, se ha añadido la Incidencia a la Asistencia. Crear nueva ent Incidencia, insertar (se actualiza Id). Copiar id en propiedad de Asistencia y Actualizar Asistencia en db.
* Not 0 Not 0 Posible Update, se puede hacer update o comparar valores
*/
/*
* public CommandStatus HandleY(AsistenciaUpdateCommand command)
* {
* try
* {
* int causa;
* int incidenciaRef;
* bool esPropiedadCero, esReferenciaNull;
*
* Collection<Asistencia> colAssist = new Collection<Asistencia>();
* Collection<Incidencia> colIncid = new Collection<Incidencia>();
*
*
* // recorrer las asistencias y comparar propiedad y referencia
*
* foreach (var asistencia in command.Asistencias)
* {
* causa = asistencia.IncidenciaCausaIncidencia;
* incidenciaRef = asistencia.IncidenciaId;
*
* esPropiedadCero = (causa == 0);
* esReferenciaNull = (incidenciaRef == 0);
*
* // Sin cambios, ignorar y continuar ciclo
* if (esPropiedadCero && esReferenciaNull)
* continue;
*
* // Eliminar Incidencia
* if (esPropiedadCero && !esReferenciaNull)
* {
* asistencia.IncidenciaId = 0;
* asistencia.State = EntityState.Modified;
* colAssist.Add(asistencia);
* // primero actualizar entidad asistencia para no violar foreign key constraint
* // al hacer cero la prop, se escribe DbNull en record
*
* //incidenciaRef.State = EntityState.Deleted;
* //colIncid.Add(incidenciaRef);
* }
*
* // Insertar Nueva Incidencia
* if (!esPropiedadCero && esReferenciaNull)
* {
* // Se crea la entidad y se inserta el registro en DB primero,
* //para obtenr su Id y actualizar Asistencia relacionada
* Incidencia newInc = _data.InsertarNuevaIncidencia(asistencia.IncidenciaCausaIncidencia, asistencia.IncidenciaObservacion);
*
* asistencia.IncidenciaId = newInc.Id;
* asistencia.State = EntityState.Modified;
* colAssist.Add(asistencia);
* }
*
* // Posible actualizacion
* if (!esPropiedadCero && !esReferenciaNull)
* {
* bool cambioCausa, cambioObs;
*
* //cambioCausa = (asistencia.IncidenciaCausaIncidencia != incidenciaRef.CausaId);
* //cambioObs = (asistencia.IncidenciaObservacion != incidenciaRef.Observacion);
*
* if (cambioCausa || cambioObs)
* {
* Console.WriteLine("Coinciden Asist Incidencia Id y Referencia Id: " + (asistencia.IncidenciaId == incidenciaRef.Id));
* // actualizando propiedades de incidencia con valores en Asistencia modificados en GUI
* incidenciaRef.CausaId = asistencia.IncidenciaCausaIncidencia;
* incidenciaRef.Observacion = asistencia.IncidenciaObservacion;
*
* incidenciaRef.State = EntityState.Modified;
* colIncid.Add(incidenciaRef);
* }
* }
* }
*
*
* // fin ciclos, escribir colecciones
* bool ret = _data.ActualizarAsistencias(colAssist);
* if (!ret)
* return new Failure("Error actualizando Asistencias");
*
*
* ret = _data.ActualizarIncidencias(colIncid);
* if (!ret)
* return new Failure("Error actualizando Incidencias");
*
*
* return new Success();
* }
* catch (Exception ex)
* {
* // Log, Notify
* return new Failure(ex.Message);
* }
*
*
*
* }
*/
// nueva implementacion
public CommandStatus Handle(AsistenciaUpdateCommand command)
{
bool ret;
try
{
// Iniciar transaccion
//_data.BeginTransaction();
Collection <Incidencia> colIncid;
Collection <Asistencia> colAsist;
// Procesar Incidencias Insertadas Crear nuevas
var IncidInserted = command.Asistencias.Select(ast => ast.IncidenciaRef).Where(inci => inci != null && inci.State == EntityState.Added);
var AsistIncidInserted = command.Asistencias.Select(ast => ast).Where(ast => ast.IncidenciaRef != null && ast.IncidenciaRef.State == EntityState.Added);
colIncid = new Collection <Incidencia>(IncidInserted.ToArray());
colAsist = new Collection <Asistencia>(AsistIncidInserted.ToArray());
// Aqui las nuevas incidencias reciben Id
ret = _data.ActualizarIncidencias(colIncid);
if (!ret)
{
return(new Failure("Error actualizando Incidencias Insert"));
}
foreach (var asi in colAsist)
{
asi.IncidenciaId = asi.IncidenciaRef.Id;
}
// Actualizar Asistencias, se guarda la Inc Id recien creada
ret = _data.ActualizarAsistencias(colAsist);
if (!ret)
{
return(new Failure("Error actualizando Asistencias Incidencias Insert"));
}
// No es necesario IMplementar Update para Incidencias
// Procesar Asistencias con Incidencias Eliminadas
// Obtener lista de Asistencias con referencia a Incidencia No NULL y Incidencia estado Deleted
var AsistIncDeleted = command.Asistencias.Select(ast => ast).Where(ast => ast.IncidenciaRef != null && ast.IncidenciaRef.State == EntityState.Deleted);
//colIncid = new Collection<Incidencia>(IncidDeleted.ToArray());
colAsist = new Collection <Asistencia>(AsistIncDeleted.ToArray());
// Actualizar Asistencias, se borra FK
ret = _data.ActualizarAsistencias(colAsist);
if (!ret)
{
return(new Failure("Error actualizando Asistencias Inc Delete"));
}
// Actualizar Incidencias, se borra si no hay mas ref a PK
//ret = _data.ActualizarIncidencias(command.Incidencias);
//if (!ret)
// return new Failure("Error actualizando Incidencias Delete");
// Ciclo para cada inc marcada borrada
colIncid = new Collection <Incidencia>();
// comprobar asis.id inc.id
foreach (var inc in command.Incidencias)
{
if (_data.ComprobarAsistenciaFK_Incidencia(inc.Id))
{
colIncid.Add(inc);
}
}
ret = _data.ActualizarIncidencias(colIncid);
if (!ret)
{
return(new Failure("Error actualizando Incidencias Delete"));
}
// Terminar transaccion
//_data.CommitTransaction();
return(new Success());
}
catch (Exception ex)
{
// Cancelar transaccion
//_data.RollbackTransaction();
//Log, Notify...
return(new Failure(ex.Message));
}
}
