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 MODResultado EditarCategoria(MODCategoria categoria)
{
MODResultado resultado = new MODResultado();
try
{
if (categoria.Id != 0 && ConfiguracionNegocio.CategoriasFlujos.Any(x => x.Nombre.ToUpper().Equals(categoria.Nombre.ToUpper()) && x.Id != categoria.Id && x.Activo))
{
resultado.Errores.Add("EMPRESAS.ERROR.NOMBREREPETIDO");
}
else
{
var data = FabricaDatos.CrearFlujoTrabajoDatos;
resultado = data.EditarCategoria(categoria);
if (resultado.esValido)
{
/*********************auditoria*****************************/
MODCategoria anterior = ConfiguracionNegocio.CategoriasFlujos.Where(x => x.Id == categoria.Id).FirstOrDefault();
IAuditoriaNegocio audit = FabricaNegocio.CrearAuditoriaNegocio;
audit.CrearRastroAuditoria(EnumTipoAccionAuditoria.actualizar, categoria.Id.ToString(), "Categorias Flujos", anterior, categoria, categoria.Usuario, categoria.Ip);
/**********************fin auditoria***********************/
ConfiguracionNegocio.RefrescarConfiguracion(Comun.Enumeradores.EnumTipoConfiguracion.categoriasFlujos);
}
}
}
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 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);
}
private void EliminarEmpleados(RadGrid pGrid)
{
XElement vXmlEmpleado = new XElement("EMPLEADOS");
ConfiguracionNegocio nConfiguracion = new ConfiguracionNegocio();
int vIdConfiguracionNotificado;
foreach (GridDataItem item in pGrid.SelectedItems)
{
vIdConfiguracionNotificado = int.Parse(item.GetDataKeyValue("ID_CONFIGURACION_NOTIFICADO").ToString());
vXmlEmpleado.Add(new XElement("EMPLEADO", new XAttribute("ID_CONFIGURACION_NOTIFICADO", vIdConfiguracionNotificado)));
}
E_RESULTADO vResultado = nConfiguracion.EliminaConfiguracionNotificado(vXmlEmpleado.ToString());
string vMensaje = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;
UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: "");
pGrid.Rebind();
if (vResultado.CL_TIPO_ERROR.ToString() == "SUCCESSFUL")
{
List <E_BAJA_IMPORTANTE_EO> LstEmpleadoBajaImportante = new List <E_BAJA_IMPORTANTE_EO>();
RotacionPersonalNegocio nBaja = new RotacionPersonalNegocio();
E_BAJA_IMPORTANTE_EO bBajaNotificado = new E_BAJA_IMPORTANTE_EO();
LstEmpleadoBajaImportante = nBaja.ObtieneEmpleadoImportante().ToList();
bBajaNotificado = LstEmpleadoBajaImportante.Where(w => w.CL_TIPO_NOTIFICACION == "BAJANOTIFICADO").FirstOrDefault();
if (bBajaNotificado != null)
{
EnviarCorreoImportate(bBajaNotificado.CL_CORREO_ELECTRONICO, bBajaNotificado.NB_EMPLEADO_COMPLETO);
}
}
}
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);
}
//[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);
}
//protected void grdBajaCapturista_NeedDataSource(object sender, Telerik.Web.UI.GridNeedDataSourceEventArgs e)
//{
// ConfiguracionNegocio nConfiguracion = new ConfiguracionNegocio();
// // grdBajaCapturista.DataSource = nConfiguracion.ObteneConfiguracionEvaluacionOrganizacional("BAJACAPTURISTA");
//}
protected void grdBajaNotificado_NeedDataSource(object sender, Telerik.Web.UI.GridNeedDataSourceEventArgs e)
{
ConfiguracionNegocio nConfiguracion = new ConfiguracionNegocio();
grdBajaNotificado.DataSource = nConfiguracion.ObteneConfiguracionEvaluacionOrganizacional("BAJANOTIFICADO");
if (nConfiguracion.ObteneConfiguracionEvaluacionOrganizacional("BAJANOTIFICADO").Count() > 0)
{
btnAltaEmpleadoBajaNotificado.Enabled = false;
}
else
{
btnAltaEmpleadoBajaNotificado.Enabled = true;
}
}
private void agregarEmpleados(List <E_SELECTOR_EMPLEADO> pListaSelector, string pCltipoNotificacion)
{
ConfiguracionNegocio nConfiguracion = new ConfiguracionNegocio();
XElement vXmlEmpleados = new XElement("EMPLEADOS");
foreach (E_SELECTOR_EMPLEADO str in pListaSelector)
{
vXmlEmpleados.Add(new XElement("EMPLEADO", new XAttribute("ID_EMPLEADO", str.idEmpleado)));
}
var vResultado = nConfiguracion.InsertaConfiguracionNotificado(vXmlEmpleados.ToString(), pCltipoNotificacion, vClUsuario, vNbPrograma);
string vMensaje = vResultado.MENSAJE.Where(w => w.CL_IDIOMA.Equals(vClIdioma.ToString())).FirstOrDefault().DS_MENSAJE;
UtilMensajes.MensajeResultadoDB(rwmMensaje, vMensaje, vResultado.CL_TIPO_ERROR, pCallBackFunction: "");
}
protected void rgBajaReplica_NeedDataSource(object sender, GridNeedDataSourceEventArgs e)
{
ConfiguracionNegocio nConfiguracion = new ConfiguracionNegocio();
rgBajaReplica.DataSource = nConfiguracion.ObteneConfiguracionEvaluacionOrganizacional("BAJAREPLICA");
if (nConfiguracion.ObteneConfiguracionEvaluacionOrganizacional("BAJAREPLICA").Count() > 0)
{
btnAgregarEncargado.Enabled = false;
}
else
{
btnAgregarEncargado.Enabled = true;
}
}
//protected void grdCapturaResultados_NeedDataSource(object sender, Telerik.Web.UI.GridNeedDataSourceEventArgs e)
//{
// ConfiguracionNegocio nConfiguracion = new ConfiguracionNegocio();
// grdCapturaResultados.DataSource = nConfiguracion.ObteneConfiguracionEvaluacionOrganizacional("CAPTURISTA");
//}
protected void grdRecepcionMensajes_NeedDataSource(object sender, Telerik.Web.UI.GridNeedDataSourceEventArgs e)
{
ConfiguracionNegocio nConfiguracion = new ConfiguracionNegocio();
grdRecepcionMensajes.DataSource = nConfiguracion.ObteneConfiguracionEvaluacionOrganizacional("IMPORTANTE");
if (nConfiguracion.ObteneConfiguracionEvaluacionOrganizacional("IMPORTANTE").Count() > 0)
{
btnAgregarImportante.Enabled = false;
}
else
{
btnAgregarImportante.Enabled = true;
}
}
public void CerrarSession([FromBody] LoginRequestModel filtro)
{
if (!string.IsNullOrEmpty(filtro.Username))
{
var usrlogin = ConfiguracionNegocio.Logueos.Where(x => x.UserName == filtro.Username).FirstOrDefault();
var aud = FabricaNegocio.CrearAuditoriaNegocio;
var usr = new MODLoginUsuario();
aud.CrearRastroAuditoria(Comun.Enumeradores.EnumTipoAccionAuditoria.logout, usrlogin.IdUsuario.ToString(), "Autenticacion", usr, usrlogin, filtro.Username, filtro.Ip);
ConfiguracionNegocio.SessionUsuario(new Comun.Entidades.UsuarioPerfil.MODLoginUsuario
{
UserName = filtro.Username,
IP = filtro.Ip
}, Comun.Enumeradores.EnumSession._cierre);
}
}
public MODResultado Registrar(MODFlujo registro)
{
MODResultado resultado = new MODResultado();
try
{
var data = FabricaDatos.CrearFlujoTrabajoDatos;
registro.Tareas.ToList().ForEach(x =>
{
if (x.IdReporte != 0)
{
x.Reporte = ConfiguracionNegocio.Reportes.FirstOrDefault(y => y.Id == x.IdReporte);
}
if (x.Proceso == EnumProceso.Obtener)
{
x.NombreTablaSIR = string.Format(@"TB_{0}_{1}_{2}", registro.Elemento.Replace(" ", "_").ToUpper(), registro.NombreEmpresa.Replace(" ", "_").ToUpper(), !String.IsNullOrEmpty(x.ConfiguracionBD.NombreTabla) ? x.ConfiguracionBD.NombreTabla.Replace(" ", "_").ToUpper() : x.ConfiguracionBD.Nombre.Replace(" ", "_").ToUpper());
}
else if (x.Proceso == EnumProceso.Registrar)
{
x.NombreTablaSIR = string.Format(@"TB_{0}_{1}_{2}", registro.Elemento.Replace(" ", "_").ToUpper(),
registro.NombreEmpresa.Replace(" ", "_").ToUpper(),
x.Reporte.Nombre.Replace(" ", "_").ToUpper()
);
}
});
resultado = data.Registrar(registro);
if (resultado.esValido)
{
ConfiguracionNegocio.RefrescarConfiguracion(EnumTipoConfiguracion.flujo);
/*********************auditoria*****************************/
IAuditoriaNegocio audit = FabricaNegocio.CrearAuditoriaNegocio;
MODResultado mODResultado = audit.CrearRastroAuditoria(EnumTipoAccionAuditoria.crear,
registro.codigo_Externo.ToString(), "flujos", new MODFlujo(), registro, registro.Usuario, registro.Ip);
/**********************fin auditoria***********************/
}
}
catch (Exception e)
{
Log.WriteLog(e, "SIR.Negocio.Concretos.FlujoDeTrabajo.FlujoTrabajoNegocio - Registrar",
JsonSerializer.Serialize(registro),
ErrorType.Error);
resultado.Errores.Add(e.Message);
}
return(resultado);
}
public MODResultado CrearEmpresa([FromBody] MODEmpresa empresa)
{
if (ConfiguracionNegocio.SessionUsuario(new Comun.Entidades.UsuarioPerfil.MODLoginUsuario
{
IdUsuario = empresa.IdUsuario,
UserName = empresa.Usuario,
IP = empresa.Ip
}, Comun.Enumeradores.EnumSession._peticion))
{
IEmpresasNegocio negocio = FabricaNegocio.CrearEmpresaNegocio;
return(negocio.CrearEmpresa(empresa));
}
return(new MODResultado {
CodigoRespuesta = System.Net.HttpStatusCode.BadRequest, Errores = new List <string> {
"LOGIN.RTA007"
}
});
}
public MODResultado ModificarClientesExcluidos([FromBody] MOD_Cliente_Excluido cliente)
{
if (ConfiguracionNegocio.SessionUsuario(new Comun.Entidades.UsuarioPerfil.MODLoginUsuario
{
IdUsuario = cliente.IdUsuario,
UserName = cliente.Usuario,
IP = cliente.Ip
}, Comun.Enumeradores.EnumSession._peticion))
{
var context = FabricaNegocio.CrearClienteExcluido;
return(context.Modificar(cliente));
}
return(new MODResultado {
CodigoRespuesta = System.Net.HttpStatusCode.BadRequest, Errores = new List <string> {
"LOGIN.RTA007"
}
});
}
public Resultado <List <TipoComponente> > ConsultarComponentePorProdcuto(string codigoTipo)
{
Resultado <List <TipoComponente> > resultado = new Resultado <List <TipoComponente> >();
try
{
resultado.Ejecuto = true;
resultado.Objeto = ConfiguracionNegocio.ConsultarComponentePorProdcuto(codigoTipo);
}
catch (Exception exception)
{
resultado.Ejecuto = false;
resultado.Mensaje = exception.Message;
resultado.Objeto = null;
}
return(resultado);
}
public Resultado <Paginacion <List <DescuentoConfiguracion> > > ConsultaDescuentoConfiguracion(Paginacion <DescuentoConfiguracion> paginacion)
{
Resultado <Paginacion <List <DescuentoConfiguracion> > > resultado = new Resultado <Paginacion <List <DescuentoConfiguracion> > >();
try
{
resultado.Ejecuto = true;
resultado.Objeto = ConfiguracionNegocio.ConsultaDescuentoConfiguracion(paginacion);
}
catch (Exception exception)
{
resultado.Ejecuto = false;
resultado.Mensaje = exception.Message;
resultado.Objeto = null;
}
return(resultado);
}
public Resultado <List <TipoAtencion> > ConsultaTipoAtenciones()
{
Resultado <List <TipoAtencion> > resultado = new Resultado <List <TipoAtencion> >();
try
{
resultado.Ejecuto = true;
resultado.Objeto = ConfiguracionNegocio.ConsultaTipoAtenciones();
}
catch (Exception exception)
{
resultado.Ejecuto = false;
resultado.Mensaje = exception.Message;
resultado.Objeto = null;
}
return(resultado);
}
public MODResultado ActualizarServicio(MODServicio servicio)
{
if (ConfiguracionNegocio.SessionUsuario(new Comun.Entidades.UsuarioPerfil.MODLoginUsuario
{
IdUsuario = servicio.IdUsuario,
UserName = servicio.Usuario,
IP = servicio.Ip
}, Comun.Enumeradores.EnumSession._peticion))
{
IServicioNegocio negocio = FabricaNegocio.CrearServicioNegocio;
return(negocio.ActualizarServicio(servicio));
}
return(new MODResultado {
CodigoRespuesta = System.Net.HttpStatusCode.BadRequest, Errores = new List <string> {
"LOGIN.RTA007"
}
});
}
protected void ActualizarLicencia()
{
UtilLicencias nLicencia = new UtilLicencias();
E_RESULTADO vResultado = nLicencia.generaClaves(ContextoApp.Licencia.clCliente, vClUsuario, vNbPrograma);
string vMensaje = vResultado.MENSAJE.FirstOrDefault().DS_MENSAJE;
SPE_OBTIENE_S_CONFIGURACION_Result vConfiguracionLicencia = new SPE_OBTIENE_S_CONFIGURACION_Result();
ConfiguracionNegocio oConfiguracion = new ConfiguracionNegocio();
vConfiguracionLicencia = oConfiguracion.obtieneConfiguracionGeneral();
if (vConfiguracionLicencia.CL_LICENCIAMIENTO == null)
{
nLicencia.generaXmlLicencias(vConfiguracionLicencia.CL_CLIENTE, vConfiguracionLicencia.CL_PASS_WS, "Web Service", "Web Service");
nLicencia.insertaXmlIdentificacion(vConfiguracionLicencia.CL_CLIENTE, vConfiguracionLicencia.CL_PASS_WS, "Web Service", "Web Service");
vConfiguracionLicencia = oConfiguracion.obtieneConfiguracionGeneral();
}
ContextoApp.Licencia.clCliente = vConfiguracionLicencia.CL_CLIENTE;
ContextoApp.Licencia.clEmpresa = vConfiguracionLicencia.CL_EMPRESA;
ContextoApp.Licencia.clLicencia = vConfiguracionLicencia.CL_LICENCIAMIENTO;
ContextoApp.Licencia.clPassWs = vConfiguracionLicencia.CL_PASS_WS;
ContextoApp.Licencia.feCreacion = vConfiguracionLicencia.FE_CREACION;
ContextoApp.Licencia.objAdicional = vConfiguracionLicencia.OBJ_ADICIONAL;
Crypto desencripta = new Crypto();
string keyPassword = vConfiguracionLicencia.CL_PASS_WS.Substring(0, 16);
string cadenaDesencriptadaLic = desencripta.descifrarTextoAES(vConfiguracionLicencia.CL_LICENCIAMIENTO, vConfiguracionLicencia.CL_CLIENTE, vConfiguracionLicencia.FE_CREACION, "SHA1", 22, keyPassword, 256);
string cadenaDesencriptadaObj = desencripta.descifrarTextoAES(vConfiguracionLicencia.OBJ_ADICIONAL, vConfiguracionLicencia.CL_CLIENTE, vConfiguracionLicencia.FE_CREACION, "SHA1", 22, keyPassword, 256);
XElement XmlConfiguracionLicencia = XElement.Parse(cadenaDesencriptadaLic);
XElement XmlConfiguracionCliente = XElement.Parse(cadenaDesencriptadaObj);
List <E_LICENCIA> lstLicencia = XmlConfiguracionCliente.Descendants("LICENCIA").Select(x => new E_LICENCIA
{
CL_CLIENTE = UtilXML.ValorAtributo <string>(x.Attribute("CL_CLIENTE")),
CL_SISTEMA = UtilXML.ValorAtributo <string>(x.Attribute("CL_SISTEMA")),
CL_EMPRESA = UtilXML.ValorAtributo <string>(x.Attribute("CL_EMPRESA")),
CL_MODULO = UtilXML.ValorAtributo <string>(x.Attribute("CL_MODULO")),
NO_RELEASE = UtilXML.ValorAtributo <string>(x.Attribute("NO_RELEASE")),
FE_INICIO = UtilXML.ValorAtributo <string>(x.Attribute("FE_INICIO")),
FE_FIN = UtilXML.ValorAtributo <string>(x.Attribute("FE_FIN")),
NO_VOLUMEN = UtilXML.ValorAtributo <string>(x.Attribute("NO_VOLUMEN"))
}).ToList();
ContextoApp.IDP.LicenciaIntegracion.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "IDP", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
ContextoApp.FYD.LicenciaFormacion.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "FYD", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
ContextoApp.EO.LicenciaED.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "ED", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
ContextoApp.EO.LicenciaCL.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "CL", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
ContextoApp.EO.LicenciaRDP.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "RDP", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
ContextoApp.MPC.LicenciaMetodologia.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "MPC", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
ContextoApp.RP.LicenciaReportes.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "RP", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
ContextoApp.CI.LicenciaConsultasInteligentes.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "CI", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
ContextoApp.PDE.LicenciaPuntoEncuentro.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "PDE", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
ContextoApp.ANOM.LicenciaAccesoModulo.MsgActivo = (nLicencia.validaLicencia(vConfiguracionLicencia.CL_CLIENTE, "SIGEIN", vConfiguracionLicencia.CL_EMPRESA, "NOMINA", "5.00", "Sistema", "Web Service", XmlConfiguracionLicencia, XmlConfiguracionCliente).MENSAJE.FirstOrDefault().DS_MENSAJE);
if (lstLicencia.Count > 0)
{
ContextoApp.InfoEmpresa.Volumen = int.Parse(lstLicencia.FirstOrDefault().NO_VOLUMEN);
if (ContextoApp.IDP.LicenciaIntegracion.MsgActivo == "1" || ContextoApp.FYD.LicenciaFormacion.MsgActivo == "1" || ContextoApp.EO.LicenciaED.MsgActivo == "1" ||
ContextoApp.EO.LicenciaCL.MsgActivo == "1" || ContextoApp.EO.LicenciaRDP.MsgActivo == "1" ||
ContextoApp.MPC.LicenciaMetodologia.MsgActivo == "1" || ContextoApp.RP.LicenciaReportes.MsgActivo == "1" || ContextoApp.CI.LicenciaConsultasInteligentes.MsgActivo == "1" ||
ContextoApp.PDE.LicenciaPuntoEncuentro.MsgActivo == "1" || ContextoApp.ANOM.LicenciaAccesoModulo.MsgActivo == "1")
{
ContextoApp.InfoEmpresa.MsgSistema = "1";
}
else
{
ContextoApp.InfoEmpresa.MsgSistema = "El cliente actual no cuenta con licencias.";
}
}
}
public async Task <LoginResponse> Login([FromBody] LoginRequestModel prmLogin)
{
LoginResponse respuesta = null;
string codigoMensaje = "COMUNES.ERRORSERVICIO";
IUsuarioNegocio usuarioNegocio = FabricaNegocio.CrearUsuarioNegocio;
try
{
if (String.IsNullOrEmpty(prmLogin.Username) || String.IsNullOrEmpty(prmLogin.Password))
{
respuesta = new LoginResponse(HttpStatusCode.BadRequest, "LOGIN.RTA004");
}
else
{
var usuarioExterno = await usuarioNegocio.ValidarUsuarioServicioExterno(prmLogin.Username, prmLogin.Password, false);
bool usuarioOk = usuarioExterno.Item1;
codigoMensaje = usuarioExterno.Item2;
if (usuarioOk)
{
var usuarioBD = usuarioNegocio.ObtenerUsuario(prmLogin.Username);
if (usuarioBD != null)
{
if (usuarioBD.Activo)
{
respuesta = new LoginResponse(usuarioBD, this.GenerateTokenJWT(prmLogin.Username));
var usrLogin = new Comun.Entidades.UsuarioPerfil.MODLoginUsuario {
IdUsuario = usuarioBD.IdUsuario,
UserName = usuarioBD.UserName,
IP = prmLogin.Ip,
Token = respuesta.Token
};
if (ConfiguracionNegocio.SessionUsuario(usrLogin, Comun.Enumeradores.EnumSession._inicio))
{
usuarioNegocio.ActualizarUltimaFechaLogin(prmLogin.Username);
}
else
{
respuesta = new LoginResponse(HttpStatusCode.BadRequest, "LOGIN.RTA006");
}
var aud = FabricaNegocio.CrearAuditoriaNegocio;
var usr = new MODLoginUsuario();
aud.CrearRastroAuditoria(Comun.Enumeradores.EnumTipoAccionAuditoria.login, usuarioBD.IdUsuario.ToString(), "Autenticacion", usr, usrLogin, prmLogin.Username, prmLogin.Ip);
}
else
{
respuesta = new LoginResponse(HttpStatusCode.BadRequest, "LOGIN.RTA005");
}
}
else
{
respuesta = new LoginResponse(HttpStatusCode.BadRequest, "LOGIN.RTA003");
}
}
else
{
respuesta = new LoginResponse(HttpStatusCode.BadRequest, codigoMensaje);
}
}
}
catch (Exception ex)
{
Log.WriteLog(ex, "AutenticacionController.Login", JsonSerializer.Serialize(prmLogin), ErrorType.Error);
respuesta = new LoginResponse(HttpStatusCode.InternalServerError, codigoMensaje);
}
return(respuesta);
}
