public MapearNegocio()
{
CreateMap <TrabajoDeUsuarioDtm, TrabajoDeUsuarioDto>()
.ForMember(dto => dto.Trabajo, dtm => dtm.MapFrom(x => x.Trabajo.Nombre))
.ForMember(dto => dto.Ejecutor, dtm => dtm.MapFrom(x => $"({x.Ejecutor.Login})- {x.Ejecutor.Nombre} {x.Ejecutor.Apellido}"))
.ForMember(dto => dto.Sometedor, dtm => dtm.MapFrom(x => $"({x.Sometedor.Login}) {x.Sometedor.Apellido} {x.Sometedor.Nombre}"))
.ForMember(dto => dto.Estado, dtm => dtm.MapFrom(x => TrabajoSometido.ToDto(x.Estado)));
CreateMap <TrabajoDeUsuarioDto, TrabajoDeUsuarioDtm>()
.ForMember(dtm => dtm.Ejecutor, dto => dto.Ignore())
.ForMember(dtm => dtm.Sometedor, dto => dto.Ignore())
.ForMember(dtm => dtm.Trabajo, dto => dto.Ignore())
.ForMember(dtm => dtm.Estado, dto => dto.MapFrom(x => TrabajoSometido.ToDtm(x.Estado)));
}
public static void Desbloquear(ContextoSe contexto, int idTrabajoDeUsuario)
{
var gestor = Gestor(contexto);
var tu = gestor.LeerRegistroPorId(idTrabajoDeUsuario, true, true, true, aplicarJoin: true);
try
{
if (tu.Estado != TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.Bloqueado))
{
throw new Exception($"El trabajo no se puede desbloquear, ha de estar en estado bloqueado y está en estado {TrabajoSometido.ToDto(tu.Estado)}");
}
tu.Estado = TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.Pendiente);
gestor.PersistirRegistro(tu, new ParametrosDeNegocio(enumTipoOperacion.Modificar));
GestorDeTrazasDeUnTrabajo.AnotarTraza(contexto, tu, $"Trabajo desbloqueado por el usuario {contexto.DatosDeConexion.Login}");
}
catch (Exception e)
{
GestorDeErroresDeUnTrabajo.AnotarError(contexto, tu, e);
GestorDeTrazasDeUnTrabajo.AnotarTraza(contexto, tu, $"El usuario {contexto.DatosDeConexion.Login} no ha podido desbloquear el trabajo");
throw;
}
}
public static void Resometer(ContextoSe contexto, int idTrabajoDeUsuario)
{
var gestor = Gestor(contexto);
var tu = gestor.LeerRegistroPorId(idTrabajoDeUsuario, true, true, true, aplicarJoin: true);
if (tu.Estado != TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.Error) &&
tu.Estado != TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.conErrores) &&
tu.Estado != TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.Terminado) &&
tu.Estado != TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.iniciado)
)
{
throw new Exception($"El trabajo no se puede resometer, ha de estar en estado terminado, iniciado, con errores o erroneo y está en estado {TrabajoSometido.ToDto(tu.Estado)}");
}
var tr = new TrabajoDeUsuarioDtm();
tr.IdSometedor = contexto.DatosDeConexion.IdUsuario;
tr.IdEjecutor = tu.IdEjecutor;
tr.IdTrabajo = tu.IdTrabajo;
tr.Estado = enumEstadosDeUnTrabajo.Pendiente.ToDtm();
tr.Planificado = DateTime.Now;
tr.Parametros = tu.Parametros;
Crear(contexto, tr);
}
private static void EjecutarTrabajo(EntornoDeTrabajo entorno)
{
try
{
var metodo = GestorDeTrabajosSometido.ValidarExisteTrabajoSometido(entorno.TrabajoSometido);
using (var contextoDelProceso = ContextoSe.ObtenerContexto(entorno.ContextoDelEntorno))
{
entorno.contextoDelProceso = contextoDelProceso;
metodo.Invoke(null, new object[] { entorno });
}
entorno.TrabajoDeUsuario.Estado = !entorno.HayErrores
? TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.Terminado)
: TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.conErrores);
entorno.ComunicarFinalizacion();
}
catch (Exception e)
{
entorno.TrabajoDeUsuario.Estado = TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.Error);
if (e.InnerException != null)
{
entorno.ComunicarError(e.InnerException);
throw e.InnerException;
}
entorno.ComunicarError(e);
throw;
}
finally
{
entorno.TrabajoDeUsuario.Terminado = DateTime.Now;
var parametros = new ParametrosDeNegocio(enumTipoOperacion.Modificar);
parametros.Parametros[EnumParametro.accion] = EnumParametroTu.terminando;
entorno.GestorDelEntorno.PersistirRegistro(entorno.TrabajoDeUsuario, parametros);
entorno.QuitarSemaforo($"Trabajo finalizado: {(entorno.TrabajoDeUsuario.Estado == TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.Terminado) ? "sin errores" : "con errores")}");
}
}
public static void Iniciar(ContextoSe contextoDelEntorno, int idTrabajoDeUsuario, bool iniciadoPorLaCola)
{
var gestorDelEntorno = Gestor(contextoDelEntorno);
var trabajoDeUsuarioDtm = gestorDelEntorno.LeerRegistroPorId(idTrabajoDeUsuario, true, true, true, aplicarJoin: false);
var entorno = new EntornoDeTrabajo(gestorDelEntorno, trabajoDeUsuarioDtm);
entorno.ProcesoIniciadoPorLaCola = iniciadoPorLaCola;
entorno.PonerSemaforo();
try
{
trabajoDeUsuarioDtm.Iniciado = DateTime.Now;
trabajoDeUsuarioDtm.Estado = TrabajoSometido.ToDtm(enumEstadosDeUnTrabajo.iniciado);
trabajoDeUsuarioDtm = entorno.GestorDelEntorno.PersistirRegistro(trabajoDeUsuarioDtm, new ParametrosDeNegocio(enumTipoOperacion.Modificar));
}
catch (Exception e)
{
entorno.AnotarError(e);
entorno.QuitarSemaforo("Iniciación cancelada");
throw;
}
EjecutarTrabajo(entorno);
}
public DescriptorDeTrabajosDeUsuario(ContextoSe contexto, ModoDescriptor modo)
: base(contexto: contexto
, controlador: nameof(TrabajosDeUsuarioController)
, vista: $"{nameof(TrabajosDeUsuarioController.CrudDeTrabajosDeUsuario)}"
, modo: modo
, rutaBase: "TrabajosSometido")
{
var opcion = new OpcionDeMenu <TrabajoDeUsuarioDto>(Mnt.ZonaMenu.Menu, AccionesDeTu.Iniciar, $"Ejecutar", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcion);
var opcionBloquear = new OpcionDeMenu <TrabajoDeUsuarioDto>(Mnt.ZonaMenu.Menu, AccionesDeTu.Bloquear, $"Bloquear", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcionBloquear);
var opcionDesbloquear = new OpcionDeMenu <TrabajoDeUsuarioDto>(Mnt.ZonaMenu.Menu, AccionesDeTu.Desbloquear, $"Desbloquear", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcionDesbloquear);
var opcionResometer = new OpcionDeMenu <TrabajoDeUsuarioDto>(Mnt.ZonaMenu.Menu, AccionesDeTu.Resometer, $"Resometer", enumModoDeAccesoDeDatos.Gestor);
Mnt.ZonaMenu.Menu.Add(opcionResometer);
AnadirOpcionDeDependencias(Mnt
, controlador: nameof(TrazasDeUnTrabajoController)
, vista: nameof(TrazasDeUnTrabajoController.CrudDeTrazasDeUnTrabajo)
, datosDependientes: nameof(TrazaDeUnTrabajoDto)
, navegarAlCrud: DescriptorDeMantenimiento <TrazaDeUnTrabajoDto> .NombreMnt
, nombreOpcion: "Traza"
, propiedadQueRestringe: nameof(TrabajoDeUsuarioDto.Id)
, propiedadRestrictora: nameof(TrazaDeUnTrabajoDto.IdTrabajoDeUsuario)
, "Consultar la traza del trabajo de usuario");
AnadirOpcionDeDependencias(Mnt
, controlador: nameof(ErroresDeUnTrabajoController)
, vista: nameof(ErroresDeUnTrabajoController.CrudDeErroresDeUnTrabajo)
, datosDependientes: nameof(ErrorDeUnTrabajoDto)
, navegarAlCrud: DescriptorDeMantenimiento <ErrorDeUnTrabajoDto> .NombreMnt
, nombreOpcion: "Errores"
, propiedadQueRestringe: nameof(TrabajoDeUsuarioDto.Id)
, propiedadRestrictora: nameof(ErrorDeUnTrabajoDto.IdTrabajoDeUsuario)
, "Consultar errores del trabajo de usuario");
new FiltroEntreFechas <TrabajoDeUsuarioDto>(bloque: Mnt.BloqueComun,
etiqueta: "Planificado",
propiedad: nameof(TrabajoDeUsuarioDto.Planificado),
ayuda: "trabajos planificados entre",
posicion: new Posicion()
{
fila = 0, columna = 0
});
new FiltroEntreFechas <TrabajoDeUsuarioDto>(bloque: Mnt.BloqueComun,
etiqueta: "Ejecutado entre",
propiedad: nameof(TrabajoDeUsuarioDto.Iniciado),
ayuda: "trabajos ejecutados entre",
posicion: new Posicion()
{
fila = 1, columna = 0
});
Dictionary <string, string> opciones = typeof(enumEstadosDeUnTrabajo).ToDiccionario((x) => TrabajoSometido.EnumeradoToDtm(x));
new ListaDeValores <TrabajoDeUsuarioDto>(Mnt.BloqueGeneral
, "Estado"
, "Seleccione el estado por el que filtrar"
, opciones
, nameof(TrabajoDeUsuarioDto.Estado)
, new Posicion()
{
fila = 0, columna = 1
});
Mnt.OrdenacionInicial = @$ "{nameof(TrabajoDeUsuarioDto.Planificado)}:planificado:{enumModoOrdenacion.descendente.Render()};
{nameof(TrabajoDeUsuarioDto.Iniciado)}:iniciado:{enumModoOrdenacion.ascendente.Render()}";
