public MODResultado CrearServicio(MODServicio servicio)
{
MODResultado resultado = new MODResultado();
try
{
if (servicio.IdServicio == 0 && ConfiguracionNegocio.Servicios.Any(x => x.Descripcion.ToUpper().Equals(servicio.Descripcion.ToUpper())))
{
resultado.Errores.Add("SERVICIOS.ERROR.NOMBREREPETIDO");
}
else
{
var data = FabricaDatos.CrearServicioDatos;
resultado = data.CrearServicio(servicio);
if (resultado.esValido)
{
ConfiguracionNegocio.RefrescarConfiguracion(Comun.Enumeradores.EnumTipoConfiguracion.servicios);
ConfiguracionNegocio.RefrescarConfiguracion(Comun.Enumeradores.EnumTipoConfiguracion.empresas);
/*********************auditoria*****************************/
IAuditoriaNegocio audit = FabricaNegocio.CrearAuditoriaNegocio;
object p = audit.CrearRastroAuditoria(EnumTipoAccionAuditoria.crear, servicio.IdServicio.ToString(), "Servicios", new MODServicio(), servicio, servicio.Usuario, servicio.Ip);
/**********************fin auditoria***********************/
}
}
}
catch (Exception e) {
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().FullName, Newtonsoft.Json.JsonConvert.SerializeObject(servicio), ErrorType.Error);
}
return(resultado);
}
public MODResultado Modificar(MODReporte reporte)
{
MODResultado resultado = new MODResultado();
try
{
var data = FabricaDatos.CrearReporteDatos;
resultado = data.Actualizar(reporte);
ConfiguracionNegocio.RefrescarConfiguracion(EnumTipoConfiguracion.reportes);
/*********************auditoria*****************************/
MODReporte anterior = ConfiguracionNegocio.Reportes.Where(x => x.Id == reporte.Id).FirstOrDefault();
IAuditoriaNegocio audit = FabricaNegocio.CrearAuditoriaNegocio;
audit.CrearRastroAuditoria(EnumTipoAccionAuditoria.actualizar, reporte.Id.ToString(), "Reporte", anterior, reporte, reporte.Usuario, reporte.Ip);
/**********************fin auditoria***********************/
}
catch (Exception e)
{
Log.WriteLog(e, "SIR.Negocio.Concretos.Reportes - Modificar",
String.Format(@"reporte:{0}", System.Text.Json.JsonSerializer.Serialize(reporte)),
ErrorType.Error);
resultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
return(resultado);
}
//[RastroAuditoria(EnumTipoAccionAuditoria.crear)]
public MODResultado CrearEmpresa(MODEmpresa empresa)
{
MODResultado resultado = new MODResultado();
try
{
if (empresa.IdEmpresa == 0 && ConfiguracionNegocio.Empresas.Any(x => x.RazonSocial.ToUpper().Equals(empresa.RazonSocial.ToUpper()) && x.Activo))
{
resultado.Errores.Add("EMPRESAS.ERROR.NOMBREREPETIDO");
}
else
{
var data = FabricaDatos.CrearEmpresaDatos;
resultado = data.CrearEmpresa(empresa);
if (resultado.esValido)
{
ConfiguracionNegocio.RefrescarConfiguracion(Comun.Enumeradores.EnumTipoConfiguracion.servicios);
ConfiguracionNegocio.RefrescarConfiguracion(Comun.Enumeradores.EnumTipoConfiguracion.empresas);
/*********************auditoria*****************************/
IAuditoriaNegocio audit = FabricaNegocio.CrearAuditoriaNegocio;
audit.CrearRastroAuditoria(EnumTipoAccionAuditoria.crear, empresa.IdEmpresa.ToString(), "Empresas", new MODEmpresa(), empresa, empresa.Usuario, empresa.Ip);
/**********************fin auditoria***********************/
}
}
}
catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().Namespace, Newtonsoft.Json.JsonConvert.SerializeObject(empresa), ErrorType.Error);
}
return(resultado);
}
public MODResultado CrearCategoria(MODCategoria categoria)
{
MODResultado resultado = new MODResultado();
try
{
if (categoria.Id == 0 && ConfiguracionNegocio.CategoriasFlujos.Any(x => x.Nombre.ToUpper().Equals(categoria.Nombre.ToUpper()) && x.Activo))
{
resultado.Errores.Add("EMPRESAS.ERROR.NOMBREREPETIDO");
}
else
{
var data = FabricaDatos.CrearFlujoTrabajoDatos;
resultado = data.CrearCategoria(categoria);
if (resultado.esValido)
{
ConfiguracionNegocio.RefrescarConfiguracion(Comun.Enumeradores.EnumTipoConfiguracion.categoriasFlujos);
/*********************auditoria*****************************/
IAuditoriaNegocio audit = FabricaNegocio.CrearAuditoriaNegocio;
MODResultado mODResultado = audit.CrearRastroAuditoria(EnumTipoAccionAuditoria.crear, categoria.Id.ToString(), "Categorias flujos", new MODCategoria(), categoria, categoria.Usuario, categoria.Ip);
/**********************fin auditoria***********************/
}
}
}
catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().FullName, Newtonsoft.Json.JsonConvert.SerializeObject(categoria), ErrorType.Error);
}
return(resultado);
}
public MODResultado InsertarArchivo(MOD_Carga_Archivo mOD_Carga_Archivo)
{
MODResultado mODResultado = new MODResultado();
try {
using (var conn = (SqlConnection)ObtenerConexionPrincipal())
{
var _cliente = conn.Query("StpCargaFormatos", new
{
accion = 1,
ID_FORMATO = mOD_Carga_Archivo.Id,
DESCRIPCION = mOD_Carga_Archivo.Descripcion,
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
if (!string.IsNullOrEmpty(_cliente.ERROR))
{
Log.WriteLog(new Exception(_cliente.Error), this.GetType().Namespace,
String.Format(@"Cliente:{0}", System.Text.Json.JsonSerializer.Serialize(mOD_Carga_Archivo)),
ErrorType.Error);
mODResultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
conn.Close();
}
}
catch
{
}
return(mODResultado);
}
public MODResultado Borrar(MODReporteFiltro reporte)
{
MODResultado resultado = new MODResultado();
try
{
using (var conn = (SqlConnection)ObtenerConexionPrincipal())
{
var _reporte = conn.Query("StpReporte", new
{
accion = 5,
IdReporte = reporte.Id,
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
conn.Close();
if (_reporte.IdReporte == 0)
{
resultado.Errores.Add("REPORTES.MENSAJES.ELIMINADONOVALIDO");
}
}
}
catch (Exception e)
{
Log.WriteLog(e, "SIR.Datos.Concretos.Reporte - Borrar",
String.Format(@"reporte:{0}", System.Text.Json.JsonSerializer.Serialize(reporte)),
ErrorType.Error);
resultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
return(resultado);
}
public MODResultado BorrarServicio(MODServicio servicio)
{
MODResultado resultado = new MODResultado();
try
{
var data = FabricaDatos.CrearServicioDatos;
resultado = data.BorrarServicio(servicio.IdServicio);
if (resultado.esValido)
{
/*********************auditoria*****************************/
MODServicio anterior = ConfiguracionNegocio.Servicios.Where(x => x.IdServicio == servicio.IdServicio).FirstOrDefault();
IAuditoriaNegocio audit = FabricaNegocio.CrearAuditoriaNegocio;
object p = audit.CrearRastroAuditoria(EnumTipoAccionAuditoria.borrar, servicio.IdServicio.ToString(), "Servicios", anterior, new MODServicio(), servicio.Usuario, servicio.Ip);
/**********************fin auditoria***********************/
ConfiguracionNegocio.RefrescarConfiguracion(Comun.Enumeradores.EnumTipoConfiguracion.servicios);
ConfiguracionNegocio.RefrescarConfiguracion(Comun.Enumeradores.EnumTipoConfiguracion.empresas);
/*********************auditoria*****************************/
}
}
catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().FullName, Newtonsoft.Json.JsonConvert.SerializeObject(servicio), ErrorType.Error);
}
return(resultado);
}
public MODResultado GuardarConf(List <Dictionary <string, object> > lista)
{
MODResultado grupos = new MODResultado();
using (var conn = ObtenerConexionPrincipal())
{
foreach (var accion in lista)
{
try
{
var parametros = new DynamicParameters();
parametros.Add("@accion", (1 == Convert.ToInt32(accion["accion"].ToString())) ? 7 : 8);
parametros.Add("@IdTarea", Convert.ToInt32(accion["IdTarea"].ToString()));
parametros.Add("@IdAccion", Convert.ToInt32(accion["IdAccion"].ToString()));
var res = conn.Query <dynamic>("StpFlujos", parametros, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
}
catch (Exception e)
{
grupos.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().FullName + "- GuardarConf",
String.Format(@"campos:{0} ", System.Text.Json.JsonSerializer.Serialize(accion)),
ErrorType.Error);
}
}
conn.Close();
}
return(grupos);
}
public MODResultado Cargar(MOD_Carga_Formato Formato)
{
MODResultado resultado = new MODResultado();
try
{
using (var conn = (SqlConnection)ObtenerConexionPrincipal())
{
var _cliente = conn.Query("StpCargaFormatos", new
{
Id_formato = Formato.Id,
Descripcion = Formato.detalle
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
if (!string.IsNullOrEmpty(_cliente.ERROR))
{
Log.WriteLog(new Exception(_cliente.Error), this.GetType().Namespace,
String.Format(@"Formato:{0}", System.Text.Json.JsonSerializer.Serialize(Formato)),
ErrorType.Error);
resultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
conn.Close();
}
}catch (Exception e)
{
Log.WriteLog(e, this.GetType().Namespace,
String.Format(@"reporte:{0}", System.Text.Json.JsonSerializer.Serialize(Formato)),
ErrorType.Error);
resultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
return(resultado);
}
public MODResultado EditarCategoria(MODCategoria categoria)
{
MODResultado resultado = new MODResultado();
try
{
var coneccion = this.ObtenerConexionPrincipal();
var a = coneccion.Query("StpFlujos", new
{
accion = 4,
Id = categoria.Id,
Nombre = categoria.Nombre
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
if (a == null)
{
resultado.Errores.Add("FLUJOS.ERRORES.CREAR");
}
}
catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().FullName, Newtonsoft.Json.JsonConvert.SerializeObject(categoria), ErrorType.Error);
}
return(resultado);
}
public MODResultado ProbarConeccion(MODOrigenDatos origen)
{
EnumBaseDatosOrigen dbtype = (EnumBaseDatosOrigen)origen.TipoOrigen;
string coneccion = "";
SqlConnectionStringBuilder builder = null;
Object parametros = null;
switch (dbtype)
{
case EnumBaseDatosOrigen.Oracle:
coneccion = Configuraciones.ObtenerConfiguracion("Conexiones", "ORA");
builder = new SqlConnectionStringBuilder(coneccion);
builder.DataSource = string.Format("{0}{1}{2}", origen.Servidor, (string.IsNullOrEmpty(origen.Puerto) && origen.Puerto != "0" ? ":" + origen.Puerto.ToString() : ""), (!string.IsNullOrEmpty(origen.Sid) ? "/" + origen.Sid : ""));
builder.UserID = origen.UsuarioBD;
builder.Password = origen.ClaveBD;
break;
case EnumBaseDatosOrigen.SqlServer:
coneccion = Configuraciones.ObtenerConfiguracion("Conexiones", EnumBaseDatos.SIR.ToString());
builder = new SqlConnectionStringBuilder(coneccion);
builder.DataSource = string.Format("{0}{1}", origen.Servidor, (string.IsNullOrEmpty(origen.Puerto) && origen.Puerto != "0" ? ":" + origen.Puerto.ToString() : ""));
builder.InitialCatalog = origen.Sid;
builder.UserID = origen.UsuarioBD;
builder.Password = origen.ClaveBD;
break;
}
MODResultado resultado = new MODResultado();
try
{
IDbConnection con = this.ObtenerConexion(builder.ConnectionString, dbtype);
if (!string.IsNullOrEmpty(origen.consulta))
{
var consulta = (CommandType.Text == (CommandType)origen.tipoMando) ? origen.consulta.ToLower().Replace("where", "where rownum = 1 and") : origen.consulta;
consulta = consulta.Replace("@periodo", "'" + DateTime.Now.ToString("yyyyMMdd") + "'");
var reader = con.ExecuteReader(consulta, parametros, commandType: (CommandType)origen.tipoMando);
var schema = reader.GetSchemaTable();
reader.Close();
List <MODCampos> campos = new List <MODCampos>();
foreach (DataRow row in schema.Rows)
{
campos.Add(new MODCampos
{
Nombre = row["ColumnName"].ToString(),
Largo = row["ColumnSize"].ToString(),
Ordinal = Convert.ToInt32(row["ColumnOrdinal"])
});
}
resultado.DatosAdicionales.Add("campos", JsonConvert.SerializeObject(campos));
}
}
catch (Exception exp)
{
resultado.Errores.Add(exp.Message);
Log.WriteLog(exp, this.GetType().FullName + "-" + nameof(ProbarConeccion),
String.Format(@"origen:{0}", System.Text.Json.JsonSerializer.Serialize(origen)),
ErrorType.Error);
}
return(resultado);
}
public MODResultado BorrarEmpresa(int idEmpresa)
{
MODResultado resultado = new MODResultado();
try
{
var coneccion = this.ObtenerConexionPrincipal();
var a = coneccion.Query <string>("StpEmpresas", new
{
accion = 5,
IdEmpresa = idEmpresa
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
if (a != null)
{
resultado.Errores.Add(a);
}
}
catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().Namespace, Newtonsoft.Json.JsonConvert.SerializeObject(new { idEmpresa = idEmpresa }), ErrorType.Error);
}
return(resultado);
}
public override MODResultado Ejecutar(ref LinkedListNode <MODTarea> tarea, MODReporte reporte, MODArchivo archivo)
{
MODResultado resultado = new MODResultado();
var _configuraicon = FabricaDatos.CrearConfiguracionOrigenDatos;
var _flujoTrabajo = FabricaDatos.CrearFlujoTrabajoDatos;
List <IDictionary <string, object> > error = null;
if (tarea.Value.ConfiguracionBD != null)
{
tarea.Value.ConfiguracionBD.Parametros = CrearParametros(tarea.Value.ConfiguracionBD, _flujo);
error = _configuraicon.Ejecutar(tarea.Value.ConfiguracionBD, reporte, ref resultado);
}
else if (!String.IsNullOrEmpty(tarea.Value.ConsultaFinal))
{
error = _flujoTrabajo.EjecutarScirpt(null, tarea.Value.ConsultaFinal, null);
}
if (error != null)
{
foreach (var e in error)
{
resultado.Errores.Add(e["error"].ToString());
}
}
return(resultado);
}
public MODResultado Registrar(MODReporte reporte)
{
MODResultado resultado = new MODResultado();
try
{
var data = FabricaDatos.CrearReporteDatos;
resultado = data.Registrar(reporte);
ConfiguracionNegocio.RefrescarConfiguracion(EnumTipoConfiguracion.reportes);
/*********************auditoria*****************************/
IAuditoriaNegocio audit = FabricaNegocio.CrearAuditoriaNegocio;
audit.CrearRastroAuditoria(EnumTipoAccionAuditoria.crear, reporte.Nombre, "Reporte", new MODReporte(), reporte, reporte.Usuario, reporte.Ip);
/**********************fin auditoria***********************/
}
catch (Exception e)
{
Log.WriteLog(e, "SIR.Negocio.Concretos.Reportes - Registrar",
String.Format(@"reporte:{0}", System.Text.Json.JsonSerializer.Serialize(reporte)),
ErrorType.Error);
resultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
return(resultado);
}
public override MODResultado Ejecutar(ref LinkedListNode <MODTarea> tarea, MODReporte reporte, MODArchivo archivo)
{
MODResultado resultado = new MODResultado();
var _configuraicon = FabricaDatos.CrearConfiguracionOrigenDatos;
var _flujoTrabajo = FabricaDatos.CrearFlujoTrabajoDatos;
tarea.Value.ConfiguracionBD.Parametros = new Dictionary <string, object>();
var _historico = new MODFlujoHistorico {
Periodo = FijarPeriodoPorPeriodicidad(_flujo.Periodo, _flujo.Periodicidad, _flujo.DatoPeriodo), Periodicidad = tarea.Value.Periodicidad
};
if (tarea.Value.ConfiguracionBD.TipoOrigen == Comun.Enumeradores.EnumBaseDatosOrigen.SqlServer && tarea.Value.ConfiguracionBD.Sid == "SIR2")
{
tarea.Value.ConfiguracionBD.Parametros.Add("periodo", _historico.StrPeriodo);
}
else
{
tarea.Value.ConfiguracionBD.Parametros.Add("periodo", _historico.StrPeriodoOracle);
}
tarea.Next.Value.Registros = _configuraicon.Ejecutar(tarea.Value.ConfiguracionBD, reporte, ref resultado);
if (tarea.Next.Value.Registros != null)
{
resultado = this.Registrar(tarea.Next, tarea.Value.Reporte);
}
if (!String.IsNullOrEmpty(tarea.Value.ConsultaFinal))
{
_flujoTrabajo.EjecutarScirpt(null, tarea.Value.ConsultaFinal, null);
}
return(resultado);
}
public MODResultado ConfirmarCorrecciones(string sql, List <Dictionary <string, object> > lista)
{
MODResultado grupos = new MODResultado();
using (var conn = ObtenerConexionPrincipal())
{
foreach (var accion in lista)
{
try
{
var parametros = new DynamicParameters();
parametros.Add("@ID_TABLA", accion["id_tabla"].ToString());
var res = conn.Query <dynamic>(sql, parametros, commandType: System.Data.CommandType.Text).FirstOrDefault();
}
catch (Exception e)
{
grupos.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().FullName + "- GuardarConf",
String.Format(@"campos:{0} ", System.Text.Json.JsonSerializer.Serialize(accion)),
ErrorType.Error);
}
}
conn.Close();
}
return(grupos);
}
public MODResultado CrearServicio(MODServicio servicio)
{
MODResultado resultado = new MODResultado();
try
{
var coneccion = this.ObtenerConexionPrincipal();
var ri = coneccion.Query("StpServicios", new {
accion = 3,
IdServicio = servicio.IdServicio,
Nombre = servicio.Nombre,
Descripcion = servicio.Descripcion
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
if (ri != null && ri.id != null)
{
coneccion.Query("StpServicios", new {
accion = 6,
idServicio = ri.id,
empresas = string.Join(",", servicio.Empresas.Select(x => x.IdEmpresa))
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
}
}
catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().Namespace, Newtonsoft.Json.JsonConvert.SerializeObject(servicio), ErrorType.Error);
}
return(resultado);
}
public MODResultado ActualizarServicio(MODServicio servicio)
{
MODResultado resultado = new MODResultado();
try
{
var coneccion = this.ObtenerConexionPrincipal();
var serv = coneccion.Query("StpServicios",
new {
accion = 4,
IdServicio = servicio.IdServicio,
Nombre = servicio.Nombre,
Descripcion = servicio.Descripcion
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
if (serv == null)
{
var a = coneccion.Query("StpServicios", new { accion = 6, IdServicio = servicio.IdServicio, empresas = string.Join(",", servicio.Empresas.Select(x => x.IdEmpresa)) }, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
if (a != null)
{
resultado.Errores.Add("SERVICIOS.ERRORES.EMPRESAS");
}
}
else
{
resultado.Errores.Add("SERVICIOS.ERRORES.CREAR");
}
}
catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().Namespace, Newtonsoft.Json.JsonConvert.SerializeObject(servicio), ErrorType.Error);
}
return(resultado);
}
public MODResultado CrearRastroAuditoria(MODRastroAuditoria rastro)
{
MODResultado resultado = new MODResultado();
try
{
var coneccion = this.ObtenerConexionPrincipal();
var a = coneccion.Query("StpAuditoria", new
{
accion = 3,
TipoAccionAuditoria = rastro.TipoAccionAuditoria,
ModeloDatos = rastro.ModeloDatos,
FechaAccion = rastro.FechaAccion,
CampoClaveID = rastro.CampoClaveID,
ValorAntes = rastro.ValorAntes,
ValorDespues = rastro.ValorDespues,
Cambios = rastro.Cambios,
Usuario = rastro.Usuario,
Ip = rastro.Ip
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
}catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().Namespace, Newtonsoft.Json.JsonConvert.SerializeObject(rastro), ErrorType.Error);
}
return(resultado);
}
public MODResultado Actualizar(MODReporte reporte)
{
MODResultado resultado = new MODResultado();
try
{
using (var conn = (SqlConnection)ObtenerConexionPrincipal())
{
var _reporte = conn.Query("StpReporte", new
{
accion = 2,
IdReporte = reporte.Id,
Descripcion = reporte.Nombre,
Norma = reporte.Descripcion,
Activo = reporte.Activo,
ActivoEmpresa = reporte.ActivoEmpresa,
IdEmpresa = reporte.IdEmpresa,
IdServicio = reporte.IdServicio,
EsReporte = reporte.EsReporte
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
if (_reporte.IdReporte == 0)
{
Log.WriteLog(new Exception(_reporte.Error), "SIR.Datos.Concretos.Reporte - Registrar",
String.Format(@"reporte:{0}", System.Text.Json.JsonSerializer.Serialize(reporte)),
ErrorType.Error);
resultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
else
{
reporte.campos.ForEach(x => {
x.IdEmpresa = reporte.IdEmpresa;
x.IdServicio = reporte.IdServicio;
x.IdReporte = _reporte.IdReporte;
});
List <MODCampos> _tablaCampos = new List <MODCampos>();
EstructuraTablaCampo(ref _tablaCampos);
var _tabla = ConvertirATabla(reporte.campos);
InsertarBloque(conn, "##CampoTemporal", _tablaCampos, _tabla);
conn.Query("StpReporte", new { accion = 3,
IdEmpresa = reporte.IdEmpresa,
IdServicio = reporte.IdServicio,
IdReporte = reporte.Id }, commandType: System.Data.CommandType.StoredProcedure);
conn.Close();
}
}
}
catch (Exception e)
{
Log.WriteLog(e, "SIR.Datos.Concretos.Reporte - Actualizar",
String.Format(@"reporte:{0}", System.Text.Json.JsonSerializer.Serialize(reporte)),
ErrorType.Error);
resultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
return(resultado);
}
public override MODResultado Ejecutar(ref LinkedListNode <MODTarea> tarea, MODReporte reporte, MODArchivo archivo)
{
MODResultado resultado = new MODResultado();
var data = FabricaDatos.CrearFlujoTrabajoDatos;
Dictionary <string, object> parametros = (Dictionary <string, object>)CrearParametros(tarea.Value.ConfiguracionBD, _flujo);
tarea.Next.Value.Registros = data.EjecutarScirpt(tarea.Value.Reporte.campos, tarea.Value.ConsultaFinal, parametros);
return(resultado);
}
private MODResultado Registrar(LinkedListNode <MODTarea> tarea, MODReporte reporte)
{
MODResultado resultado = new MODResultado();
var _configuraicon = FabricaDatos.CrearConfiguracionOrigenDatos;
reporte.campos = AdicionarCamposControl(reporte.campos);
tarea.Value.Registros = RegistrarCamposControl(tarea.Value.Registros, _flujo, tarea.Value.Id);
resultado = _configuraicon.ProcesarEstracion(tarea.Previous.Value.NombreTablaSIR, tarea.Value.Registros, reporte.campos);
return(resultado);
}
public override MODResultado Ejecutar(ref LinkedListNode <MODTarea> tarea, MODReporte reporte, MODArchivo archivo)
{
MODResultado resultado = new MODResultado();
var _configuraicon = FabricaDatos.CrearConfiguracionOrigenDatos;
reporte.campos = AdicionarCamposControl(reporte.campos);
tarea.Value.Registros = RegistrarCamposControl(tarea.Value.Registros, _flujo, tarea.Value.Id);
resultado = _configuraicon.ProcesarEstracion(tarea.Value.NombreTablaSIR, tarea.Value.Registros, reporte.campos);
AisgnarRegistros(ref tarea);
return(resultado);
}
public override MODResultado Ejecutar(ref LinkedListNode <MODTarea> tarea, MODReporte reporte, MODArchivo archivo)
{
MODResultado resultado = new MODResultado();
var data = FabricaDatos.CrearFlujoTrabajoDatos;
Dictionary <string, object> parametros = new Dictionary <string, object>();
var _historico = new MODFlujoHistorico {
Periodo = FijarPeriodoPorPeriodicidad(_flujo.Periodo, _flujo.Periodicidad, _flujo.DatoPeriodo), Periodicidad = _flujo.Periodicidad
};
parametros.Add("@periodo", _historico.StrPeriodo);
tarea.Next.Value.Registros = data.EjecutarScirpt(tarea.Value.Reporte.campos, tarea.Value.ConsultaFinal, parametros);
return(resultado);
}
public override MODResultado Ejecutar(ref LinkedListNode <MODTarea> tarea, MODReporte reporte, MODArchivo archivo)
{
MODResultado resultado = new MODResultado();
try
{
ExprParser ep = new ExprParser();
LambdaExpression lambda = null;
List <string> parametros_valores = null;
foreach (var registro in tarea.Value.Registros)
{
foreach (var _homolg in tarea.Value.Homologaciones)
{
if (_homolg.TipoReemplazo == Comun.Enumeradores.FlujoDeTrabajo.EnumTipoReemplazo.Constante)
{
registro[_homolg.NombreCampo] = ConvertirObjeto(_homolg.TipoCampo, _homolg.ValorSi);
}
else if (_homolg.TipoReemplazo == Comun.Enumeradores.FlujoDeTrabajo.EnumTipoReemplazo.Variable)
{
parametros_valores = new List <string>();
foreach (string _nombreCampo in _homolg.Condiciones.Select(y => y.Campo).Distinct())
{
parametros_valores.Add(registro[_nombreCampo].ToString());
}
lambda = ep.Parse(_homolg.Ecuacion);
if ((bool)ep.Run(lambda, parametros_valores.ToArray()))
{
registro[_homolg.NombreCampo] = ConvertirObjeto(_homolg.TipoCampo, _homolg.ValorSi);
}
else
{
string _posiblevalor = _homolg.ValorNo.Equals("@valorOriginal") ? registro[_homolg.NombreCampo].ToString() : _homolg.ValorNo;
registro[_homolg.NombreCampo] = ConvertirObjeto(_homolg.TipoCampo, _posiblevalor);
}
}
}
}
AisgnarRegistros(ref tarea);
}
catch (Exception e)
{
Log.WriteLog(e, "SIR.Negocio.Concretos.FlujoDeTrabajo.HomologarNegocio - Ejecutar",
String.Format(@"tarea:{0} - reporte:{1}", System.Text.Json.JsonSerializer.Serialize(tarea),
System.Text.Json.JsonSerializer.Serialize(reporte)),
ErrorType.Error);
resultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
return(resultado);
}
public MODResultado Historico(ref MODFlujoHistorico registro, EnumAccionBaseDatos enumAccion)
{
MODResultado resultado = new MODResultado();
try
{
using (var coneccion = ObtenerConexionPrincipal())
{
var _sp = coneccion.Query("StpFlujoHistorico", new
{
accion = (int)enumAccion,
IdHistorico = registro.Id,
IdEmpresa = registro.IdEmpresa,
IdServicio = registro.IdServicio,
IdElemento = registro.IdElemento,
TipoFlujo = (int)registro.TipoFlujo,
IdTarea = registro.IdTarea,
FechaCreacion = registro.TareaFechaCreacion,
FechaFinalizacion = registro.TareaFechaFinalizacion,
EsValido = registro.TareaEsValido,
DescripcionError = registro.DescripcionError,
IdFlujo = registro.IdFlujo,
Periodicidad = registro.Periodicidad,
Periodo = registro.Periodo,
EstadoFlujo = (int)registro.EstadoFlujo,
StrPeriodo = registro.StrPeriodo,
TareaProceso = registro.Proceso.ToString()
}, commandType: System.Data.CommandType.StoredProcedure).FirstOrDefault();
registro.Id = (int)_sp.IdHistorico;
resultado.DatosAdicionales.Add("Version", Convert.ToString(_sp.IdHistorico));
if (_sp.IdHistorico == 0)
{
Log.WriteLog(new Exception(_sp.Error), this.GetType().Namespace,
String.Format(@"reporte:{0}", System.Text.Json.JsonSerializer.Serialize(registro)),
ErrorType.Error);
resultado.Errores.Add("COMUNES.ERRORSERVICIO");
}
}
}
catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().Namespace,
Newtonsoft.Json.JsonConvert.SerializeObject(registro),
ErrorType.Error);
}
return(resultado);
}
public override MODResultado Ejecutar(ref LinkedListNode <MODTarea> tarea, MODReporte reporte, MODArchivo archivo)
{
MODResultado resultado = new MODResultado();
var _configuraicon = FabricaDatos.CrearConfiguracionOrigenDatos;
var _flujoTrabajo = FabricaDatos.CrearFlujoTrabajoDatos;
if (tarea.Value.Reporte != null && tarea.Value.ConfiguracionBD != null)
{
if (tarea.Value.ConfiguracionBD.consulta.Contains("@periodo"))
{
tarea.Value.ConfiguracionBD.Parametros = new Dictionary <string, object>();
var _historico = new MODFlujoHistorico {
Periodo = _flujo.Periodo, Periodicidad = tarea.Value.Periodicidad
};
tarea.Value.ConfiguracionBD.Parametros.Add("periodo", _historico.StrPeriodo);
}
tarea.Value.NombreTablaSIR = $"Temp_Combinacion_{tarea.Value.Reporte.Descripcion.Replace(" ", "_")}";
tarea.Next.Value.Registros = _configuraicon.Ejecutar(tarea.Value.ConfiguracionBD, reporte, ref resultado);
_flujoTrabajo.GenerarTablaTemporal(tarea.Value);
resultado = this.Registrar(tarea.Next, tarea.Value.Reporte);
}
if (!String.IsNullOrEmpty(tarea.Value.ConsultaFinal))
{
var _historico = new MODFlujoHistorico {
Periodo = _flujo.Periodo, Periodicidad = _flujo.Periodicidad
};
if (tarea.Value.ConsultaFinal.Contains("@periodo"))
{
tarea.Next.Value.Registros = _flujoTrabajo.EjecutarScirpt(reporte.campos, tarea.Value.ConsultaFinal, new Dictionary <string, object>()
{
{ "periodo", _historico.StrPeriodo }
});
}
else
{
tarea.Next.Value.Registros = _flujoTrabajo.EjecutarScirpt(reporte.campos, tarea.Value.ConsultaFinal, null);
}
}
if (tarea.Value.Reporte != null && tarea.Value.ConfiguracionBD != null)
{
_flujoTrabajo.EjecutarScirpt(null, $"DROP TABLE {tarea.Value.NombreTablaSIR}", null);
}
return(resultado);
}
public MODResultado InsertarArchivo(MOD_Carga_Archivo mOD_Carga_Archivo)
{
MODResultado resultado = new MODResultado();
try
{
var context = FabricaDatos.CargaArhivoDatos;
context.InsertarArchivo(mOD_Carga_Archivo);
}
catch
{
}
return(resultado);
}
public MODResultado CrearRastroAuditoria(EnumTipoAccionAuditoria Accion, string CampoClaveID, string modeloDatos, Object AnteriorObject, Object NuevoObject, string Usuario, string ip)
{
MODResultado resultado = new MODResultado();
try
{
// get the differance
CompareLogic compObjects = new CompareLogic();
compObjects.Config.MaxDifferences = 99;
compObjects.Config.TreatStringEmptyAndNullTheSame = true;
compObjects.Config.MaxStructDepth = 5;
ComparisonResult compResult = compObjects.Compare(AnteriorObject, NuevoObject);
List <DeltaAuditoria> DeltaList = new List <DeltaAuditoria>();
foreach (var change in compResult.Differences)
{
DeltaAuditoria delta = new DeltaAuditoria();
if (change.PropertyName != "" && change.PropertyName.Substring(0, 1) == ".")
{
delta.NombreCampo = change.PropertyName.Substring(1, change.PropertyName.Length - 1);
}
else
{
delta.NombreCampo = change.PropertyName;
}
delta.ValorAntes = change.Object1Value;
delta.ValorDespues = change.Object2Value;
DeltaList.Add(delta);
}
MODRastroAuditoria audit = new MODRastroAuditoria();
audit.TipoAccionAuditoria = Accion;
audit.ModeloDatos = modeloDatos;
audit.FechaAccion = DateTime.Now;
audit.CampoClaveID = CampoClaveID;
audit.ValorAntes = JsonConvert.SerializeObject(AnteriorObject);
audit.ValorDespues = JsonConvert.SerializeObject(NuevoObject);
audit.Cambios = JsonConvert.SerializeObject(DeltaList);
audit.Usuario = Usuario;
IAuditoriaDatos dal = FabricaDatos.CrearAuditoriaDatos;
resultado = dal.CrearRastroAuditoria(audit);
}
catch (Exception e)
{
resultado.Errores.Add(e.Message);
Log.WriteLog(e, this.GetType().Namespace, Newtonsoft.Json.JsonConvert.SerializeObject(new { Accion = Accion, CampoClaveID = CampoClaveID, modeloDatos = modeloDatos, AnteriorObject = AnteriorObject, NuevoObject = NuevoObject }), ErrorType.Error);
}
return(resultado);
}
public MODResultado GuardarConf(List <Dictionary <string, object> > lista)
{
MODResultado res = new MODResultado();
try
{
var data = FabricaDatos.CrearFlujoTrabajoDatos;
res = data.GuardarConf(lista);
}
catch (Exception e)
{
Log.WriteLog(e, this.GetType().FullName + " - ObtenerPasos",
String.Format(@"Lista:{0}", System.Text.Json.JsonSerializer.Serialize(lista)),
ErrorType.Error);
}
return(res);
}