public static RNUsuario Acceso(string usuario, string pass, out bool snAcceso)
{
RNUsuario logeado = new RNUsuario();
ctrlUsuario Usuario = null;
RNPerfil perfil = new RNPerfil();
using (var ctx = new LBInventoryEntities())
{
//var pass = Encriptacion.Encrypt(pass, true);
Usuario = ctx.ctrlUsuario.Where(x => x.Usuario == usuario && x.Password == pass).FirstOrDefault();
if (Usuario != null)
{
//Validar si el usuario tiene un perfil asignado, de lo contrario, no se le permite el acceso
var perfiles = perfil.ObtenerPerfilesUsuario(Usuario.Id);
if (perfiles.Count > 0)
{
snAcceso = true;
}
else
{
snAcceso = false;
}
logeado.Obtener(Usuario.Id);
}
else
{
snAcceso = false;
}
}
return(logeado);
}
public static List <RNTipoConexion> Obtener()
{
RNTipoConexion tipo = null;
List <RNTipoConexion> RNTipos = new List <RNTipoConexion>();
try
{
using (var ctx = new LBInventoryEntities())
{
var catTipos = ctx.catTipoConexion.ToList();
foreach (var item in catTipos)
{
tipo = llenarRNTipoConexion(item);
RNTipos.Add(tipo);
}
}
}
catch (Exception)
{
RNTipos = new List <RNTipoConexion>();
}
return(RNTipos);
}
public ctrlUsuario Obtener(int id)
{
var ctrlUsuario = new ctrlUsuario();
try
{
if (id == 0)
{
ctrlUsuario = new ctrlUsuario();
}
else
{
using (var ctx = new LBInventoryEntities())
{
ctrlUsuario = ctx.ctrlUsuario
.Include("relUsuarioPerfil")
.Where(x => x.Id == id).SingleOrDefault();
if (ctrlUsuario != null)
{
ctrlUsuario.Password = null;
}
else
{
ctrlUsuario = new ctrlUsuario();
}
}
}
}
catch (Exception e)
{
throw;
}
return(ctrlUsuario);
}
public static bool GuardarImportadora(string empresa, bool snComer, out string msg)
{
bool error = false;
try
{
ctrlConexion conexion = llenaCtrlConexion(Obtener(empresa));
conexion.SNComercializadora = false;
conexion.SNImportadora = true;
using (var ctx = new LBInventoryEntities())
{
ctx.Configuration.ValidateOnSaveEnabled = false;
var eComer = ctx.Entry(conexion).State = System.Data.Entity.EntityState.Modified;
ctx.SaveChanges();
}
msg = "";
error = true;
}
catch (Exception e)
{
msg = e.Message;
}
return(error);
}
protected DbConnection ObtenerConexion(int numEmpresa)
{
ctrlConexion ctrlConexion = new ctrlConexion();
string Conexion = "";
try
{
//1.-Obetenemos los parametros de conexion que estan configurados en la BD
using (var ctx = new LBInventoryEntities())
{
//Depende del usuario, solo debe cargar los usuario segun el perfil y la sucursal
ctrlConexion = ctx.ctrlConexion.Where(x => x.SNActivo == true && x.NumEmpresa == numEmpresa).FirstOrDefault();
}
if (ctrlConexion != null)
{
//creamos la cadena de conexion
string user = ctrlConexion.Usuario;
string password = ctrlConexion.Pass;
string dataBase = ctrlConexion.BaseDatos;
string dataSource = ctrlConexion.Servidor;
string puerto = ctrlConexion.Puerto.ToString();
numEmpresa = ctrlConexion.NumEmpresa;
nombreEmpresa = ctrlConexion.Empresa;
RFC = ctrlConexion.RFC;
TelefonoEmpresa = ctrlConexion.Telefono;
SNComercializadora = ctrlConexion.SNComercializadora;
SNImportadora = ctrlConexion.SNImportadora;
//Validamos el tipo de manejador SQL o FireBird
if (ctrlConexion.TipoConexionId == Parametros.IdTipoConexion.Firebird)
{
Conexion = string.Format(ConfigurationManager.ConnectionStrings["SAEFB"].ConnectionString, user, password, dataBase, dataSource, puerto);
FBConexion = new FbConnection(Conexion);
return(FBConexion);
}
else
{
Conexion = string.Format(ConfigurationManager.ConnectionStrings["SAESQL"].ConnectionString, user, password, dataBase, dataSource);
SQLConexion = new SqlConnection(Conexion);
return(SQLConexion);
}
}
else
{
Conexion = "";
}
return(null);
}
catch (Exception e)
{
return(null);
throw;
}
}
public ResponseModel QuitarPerfil(int idUsuario, int idPerfil)
{
ResponseModel rm = new ResponseModel();
relUsuarioPerfil relUsuarioPerfil = new relUsuarioPerfil();
try
{
using (var ctx = new LBInventoryEntities())
{
relUsuarioPerfil = ctx.relUsuarioPerfil.Where(x => x.PerfilId == idPerfil && x.UsuarioId == idUsuario).SingleOrDefault();
ctx.Entry(relUsuarioPerfil).State = EntityState.Deleted;
ctx.SaveChanges();
}
rm.SetResponse(true, "Perfil desasignado correctamente");
}
catch (Exception ex)
{
rm.SetResponse(false, "Error al intentar desasignar el perfil" + ex.Message);
}
return(rm);
}
public static RNConfiguracion Obtener(string empresa)
{
RNConfiguracion configuracion = null;
try
{
using (var ctx = new LBInventoryEntities())
{
var ctrlConexion = ctx.ctrlConexion
.Include("catTipoConexion")
.Where(x => x.Empresa.Equals(empresa)).FirstOrDefault();
configuracion = llenaRNConfiguracion(ctrlConexion);
}
}
catch (Exception)
{
configuracion = new RNConfiguracion();
}
return(configuracion);
}
public RNConfiguracion Obtener(int ConexionId)
{
RNConfiguracion configuracion = null;
try
{
using (var ctx = new LBInventoryEntities())
{
var ctrlConexion = ctx.ctrlConexion
.Include("catTipoConexion")
.Where(x => x.Id == ConexionId).FirstOrDefault();
configuracion = llenaRNConfiguracion(ctrlConexion);
}
}
catch (Exception)
{
configuracion = new RNConfiguracion();
}
return(configuracion);
}
public static List <RNConfiguracion> Listar()
{
List <RNConfiguracion> configuracions = new List <RNConfiguracion>();
try
{
using (var ctx = new LBInventoryEntities())
{
var con = ctx.ctrlConexion.ToList();
foreach (var c in con)
{
configuracions.Add(llenaRNConfiguracion(c));
}
}
}
catch (Exception E)
{
throw;
}
return(configuracions);
}
public List <RNPerfil> Listar()
{
List <catPerfil> catPerfiles = new List <catPerfil>();
List <RNPerfil> perfiles = new List <RNPerfil>();
RNPerfil RNPerfil = new RNPerfil();
try
{
using (var ctx = new LBInventoryEntities())
{
catPerfiles = ctx.catPerfil.ToList();
}
foreach (var p in catPerfiles)
{
perfiles.Add(llenarRNPerfil(p));
}
}
catch (Exception)
{
perfiles = new List <RNPerfil>();
}
return(perfiles);
}
public RNUsuario llenarRNUsuario(ctrlUsuario ctrlUsuario)
{
RNUsuario usuario = new RNUsuario();
usuario.catPerfil = new List <RNPerfil>();
RNPerfil per = new RNPerfil();
usuario.Id = ctrlUsuario.Id;
usuario.Usuario = ctrlUsuario.Usuario;
usuario.Nombre = ctrlUsuario.Nombre;
usuario.SNActivo = ctrlUsuario.SNActivo;
usuario.CveVendedor = ctrlUsuario.CveVendedor;
using (var ctx = new LBInventoryEntities())
{
foreach (var item in ctx.relUsuarioPerfil.Include("CatPerfil").Where(x => x.UsuarioId == ctrlUsuario.Id))
{
per = new RNPerfil();
per.Id = item.PerfilId;
per.Perfil = item.catPerfil.Perfil;
usuario.catPerfil.Add(per);
}
}
return(usuario);
}
public List <RNUsuario> Listar()
{
List <RNUsuario> usuarios = new List <RNUsuario>();
ctrlUsuario ctrlUsuario = new ctrlUsuario();
List <ctrlUsuario> ctrlUsuarios = new List <ctrlUsuario>();
try
{
using (var ctx = new LBInventoryEntities())
{
ctx.Configuration.LazyLoadingEnabled = false;
ctrlUsuarios = ctx.ctrlUsuario.Include("relUsuarioPerfil").ToList();
foreach (var item in ctrlUsuarios)
{
usuarios.Add(llenarRNUsuario(item));
}
}
}
catch (Exception)
{
throw;
}
return(usuarios);
}
public List <RNPerfil> ObtenerPerfilesUsuario(int idUsuario)
{
List <relUsuarioPerfil> relperfiles = new List <relUsuarioPerfil>();
List <RNPerfil> perfiles = new List <RNPerfil>();
try
{
using (var ctx = new LBInventoryEntities())
{
relperfiles = ctx.relUsuarioPerfil.
Include("catPerfil")
.Where(x => x.UsuarioId == idUsuario).ToList();
}
foreach (var p in relperfiles)
{
perfiles.Add(llenarRNPerfil(p.catPerfil));
}
}
catch (Exception)
{
perfiles = new List <RNPerfil>();
}
return(perfiles);
}
public ResponseModel AsignarPerfil(int idUsuario, int idPerfil)
{
ResponseModel rm = new ResponseModel();
relUsuarioPerfil relUsuarioPerfil = new relUsuarioPerfil();
try
{
relUsuarioPerfil.PerfilId = idPerfil;
relUsuarioPerfil.UsuarioId = idUsuario;
using (var ctx = new LBInventoryEntities())
{
ctx.Entry(relUsuarioPerfil).State = EntityState.Added;
ctx.SaveChanges();
}
rm.SetResponse(true, "Perfil asignado correctamente");
rm.function = "CargarPerfiles";
rm.funcParams = idUsuario.ToString();
}
catch (Exception ex)
{
rm.SetResponse(false, "Error al intentar asignar el perfil" + ex.Message);
}
return(rm);
}
public ResponseModel Guardar()
{
ctrlUsuario ctrlUsuario = new ctrlUsuario();
var rm = new ResponseModel();
try
{
ctrlUsuario = llenarCtrlUsuario(this);
using (var ctx = new LBInventoryEntities())
{
ctx.Configuration.ValidateOnSaveEnabled = false;
var eUsuario = ctx.Entry(ctrlUsuario);
if (ctrlUsuario.Id == 0)
{
//verificamos si el nombre de usuario ya esta en uso
if (ctx.ctrlUsuario.Where(x => x.Usuario == this.Usuario).Count() > 0)
{
rm.SetResponse(false, "Nombre de Usuario existente, favor de usar otro");
return(rm);
}
eUsuario.State = EntityState.Added;
}
else
{
eUsuario.State = EntityState.Modified;
eUsuario.Property(x => x.Usuario).IsModified = false;
}
//Verifica si el password viene en nulo
if (ctrlUsuario.Password == null || ctrlUsuario.Password == "")
{
eUsuario.Property(x => x.Password).IsModified = false;
}
else
{
var passMD5 = Encriptacion.Encrypt(ctrlUsuario.Password, true);
ctrlUsuario.Password = passMD5;
}
if (catPerfil != null && catPerfil.Count > 0)
{
var perfiles = ctx.relUsuarioPerfil.Where(x => x.UsuarioId == eUsuario.Entity.Id).ToList();
foreach (var per in perfiles)
{
if (per.UsuarioId == Id)
{
QuitarPerfil(Id, per.PerfilId);
}
}
foreach (var per in catPerfil)
{
relUsuarioPerfil relUsuarioPerfil = new relUsuarioPerfil();
relUsuarioPerfil.PerfilId = per.Id;
relUsuarioPerfil.UsuarioId = eUsuario.Entity.Id;
eUsuario.Entity.relUsuarioPerfil.Add(relUsuarioPerfil);
}
}
ctx.SaveChanges();
rm.SetResponse(true, "Usuario Guardado con exito!");
rm.function = "Obtener";
rm.funcParams = ctrlUsuario.Id.ToString();
}
}
catch (DbEntityValidationException ex)
{
rm.SetResponse(false, "Error al guardar el Usuario " + ex.Message);
}
catch (Exception ex)
{
rm.SetResponse(false, "Error al guardar el Usuario " + ex.Message);
}
return(rm);
}
