public Stream GetAdminCiudadAll(byte idDepartamento)
        {
            try
            {
                var db = new CoomuceEntities();

                var max = db.Ciudad.Max(r => r.idCiudad);

                var res = db.Ciudad
                    .Where(r => r.idDepartamento == idDepartamento)
                    .Select(r => new
                    {
                        r.idDepartamento,
                        r.idCiudad,
                        r.codigoCiudad,
                        r.nombreCiudad
                    })
                    .ToList();

                return gen.EscribirJson(new { data = res, identity = max, total = res.Count, success = true });
            }
            catch (Exception ex)
            {
                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream GetAdminUsuarioAll()
        {
            try
            {
                var db = new CoomuceEntities();

                var res = db.Usuario
                    .Select(r => new
                    {
                        r.idUsuario,
                        r.idTipoIdentificacion,
                        r.TipoIdentificacion.nombreTipoIdentificacion,
                        r.identificacionUsuario,
                        r.primerApellidoUsuario,
                        r.segundoApellidoUsuario,
                        r.primerNombreUsuario,
                        r.segundoNombreUsuario,
                        r.emailUsuario,
                        r.celularUsuario,
                        r.idRol,
                        r.Rol.nombreRol,
                        r.esTemporalUsuario,
                        r.estaHabilitadoUsuario
                    })
                    .ToList();

                return gen.EscribirJson(new { data = res, total = res.Count, success = true });
            }
            catch (Exception ex)
            {
                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream GetAdminPermisosRolAll(byte idRol)
        {
            try
            {
                var db = new CoomuceEntities();

                var res = db.RolMenu
                    .Where(r => r.idRol == idRol)
                    .Select(r => new
                    {
                        r.idRol,
                        r.Rol.nombreRol,
                        r.idMenu,
                        r.Menu.nombreMenu,
                        r.habilitadoRolMenu
                    })
                    .ToList();

                return gen.EscribirJson(new { data = res, total = res.Count, success = true });
            }
            catch (Exception ex)
            {
                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream SeguridadOlvidoContraseña(string username)
        {
            try
            {
                var db = new CoomuceEntities();

                // obtengo los datos del usuario
                var info = db.Usuario
                           .Where(r => r.loginUsuario.Equals(username))
                           .FirstOrDefault();

                bool credencialesEnviadas = false;

                // verifico si existe el usuario
                if (info != null)
                {
                    credencialesEnviadas = gen.EnviarCorreo(info, 1);
                }

                return(gen.EscribirJson(new
                {
                    message = (credencialesEnviadas ? Mensajes.CredencialesEnviadas : Mensajes.CredencialesNoEnviadas),
                    success = true
                }));
            }
            catch (Exception ex)
            {
                return(gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false }));
            }
        }
        public Stream AdminConfiguracionGeneralU(ConfiguracionGeneral datos)
        {
            try
            {
                var db = new CoomuceEntities();

                var itemConf = db.ConfiguracionGeneral
                        .Where(r => r.idConfiguracionGeneral.Equals(datos.idConfiguracionGeneral))
                        .FirstOrDefault();

                itemConf.tiempoInactividadConfiguracionGeneral = datos.tiempoInactividadConfiguracionGeneral;
                itemConf.salarioConfiguracionGeneral = datos.salarioConfiguracionGeneral;
                itemConf.emailSalienteConfiguracionGeneral = datos.emailSalienteConfiguracionGeneral;
                itemConf.pswEmailConfiguracionGeneral = datos.pswEmailConfiguracionGeneral;
                itemConf.ccConfiguracionGeneral = datos.ccConfiguracionGeneral;
                itemConf.csConfiguracionGeneral = datos.csConfiguracionGeneral;
                itemConf.hostConfiguracionGeneral = datos.hostConfiguracionGeneral;
                itemConf.portConfiguracionGeneral = datos.portConfiguracionGeneral;
                itemConf.sslConfiguracionGeneral = datos.sslConfiguracionGeneral;

                db.SaveChanges();

                return gen.EscribirJson(new { message = Mensajes.Guardar, success = true });
            }
            catch (Exception ex)
            {
                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream GetMainMenu(byte idRol)
        {
            try
            {
                var db = new CoomuceEntities();

                var res = db.RolMenu
                          .Where(r => r.idRol == idRol && r.habilitadoRolMenu == true)
                          .OrderBy(r => r.Menu.ordenMenu)
                          .Select(r => new obj
                {
                    idMenu      = r.Menu.idMenu,
                    idPadreMenu = r.Menu.idPadreMenu,
                    nomMenu     = r.Menu.nombreMenu,
                    iconoMenu   = r.Menu.iconoMenu,
                    idDomVista  = r.Menu.Vista.idDomVista,
                    idVista     = r.Menu.Vista.rutaVista
                })
                          .ToList();

                var menu = ConstruirMenu.Contruir(null, res);

                return(gen.EscribirJson(new { children = menu, message = Mensajes.MenuConstruido, success = true }));
            }
            catch (Exception ex)
            {
                return(gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false }));
            }
        }
Exemple #7
0
        public bool EnviarCorreo(Usuario datos, byte tipo)
        {
            try
            {
                var db = new CoomuceEntities();

                var cfg = db.ConfiguracionGeneral.FirstOrDefault();

                var ccc = db.ConfiguracionCuerpoCorreo.Where(r => r.tipoConfiguracionCuerpoCorreo == tipo).FirstOrDefault();

                MailMessage mail = new MailMessage();

                // correo destino
                mail.From = new MailAddress(cfg.emailSalienteConfiguracionGeneral);

                // correo origen
                mail.To.Add(datos.emailUsuario);

                // copia de correo
                mail.CC.Add(new MailAddress(cfg.ccConfiguracionGeneral));

                // asunto correo
                mail.Subject = ccc.tituloConfiguracionCuerpoCorreo;

                // contenido correo
                mail.Body = string.Format(ccc.mensajeConfiguracionCuerpoCorreo,
                                          datos.primerNombreUsuario, datos.segundoNombreUsuario, datos.primerApellidoUsuario, datos.segundoApellidoUsuario,
                                          datos.loginUsuario, datos.passwordUsuario);

                // en formato html
                mail.IsBodyHtml = true;

                // prioridad de correo
                mail.Priority = MailPriority.Normal;

                SmtpClient smtp = new SmtpClient();

                // credenciales de autenticación
                smtp.Credentials = new NetworkCredential(cfg.emailSalienteConfiguracionGeneral, cfg.pswEmailConfiguracionGeneral);

                // host y puerto
                smtp.Host = cfg.hostConfiguracionGeneral;
                //smtp.Port = cfg.portConfiguracionGeneral;
                smtp.Port = 587;

                // ssl
                smtp.EnableSsl = true;

                smtp.Send(mail);

                return(true);
            }
            catch
            {
                return(false);
            }
        }
        public Stream GetAdminConfiguracionCuerpoCorreoAll(byte tipo)
        {
            try
            {
                var db = new CoomuceEntities();

                var res = db.ConfiguracionCuerpoCorreo.Where(r => r.tipoConfiguracionCuerpoCorreo == tipo).ToList();

                return gen.EscribirJson(new { data = res, total = res.Count, success = true });
            }
            catch (Exception ex)
            {
                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream GetAdminConfiguracionGeneralAll()
        {
            try
            {
                var db = new CoomuceEntities();

                var res = db.ConfiguracionGeneral.ToList();

                return gen.EscribirJson(new { data = res, total = res.Count, success = true });
            }
            catch (Exception ex)
            {
                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream AdminPermisosRolCUD(List<RolMenu> nuevos, List<RolMenu> viejos, List<RolMenu> eliminados)
        {
            var db = new CoomuceEntities();
            var transaction = db.Database.BeginTransaction();

            try
            {
                // hay datos para eliminar?
                if (eliminados.Count > 0)
                {
                    // marcar registros para eliminar
                    eliminados.ForEach(e => db.Entry(e).State = EntityState.Deleted);

                    // eliminar registros
                    db.RolMenu.RemoveRange(eliminados);
                }

                // hay datos para actualizar?
                if (viejos.Count > 0)
                {
                    viejos.ForEach(v => db.Entry(v).State = EntityState.Modified);
                }

                // hay datos para adicionar?
                if (nuevos.Count > 0)
                {
                    // agregar rango de nuevos registros
                    db.RolMenu.AddRange(nuevos);
                }

                // guardo datos y confirmo transacción
                db.SaveChanges();
                transaction.Commit();

                return gen.EscribirJson(new { message = Mensajes.Guardar, success = true });
            }
            catch (Exception ex)
            {
                transaction.Rollback();

                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream GetAdminMenuAll()
        {
            try
            {
                var db = new CoomuceEntities();

                var res = db.Menu
                    .Select(r => new
                    {
                        r.idMenu,
                        r.nombreMenu
                    })
                    .ToList();

                return gen.EscribirJson(new { data = res, total = res.Count, success = true });
            }
            catch (Exception ex)
            {
                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream AdminUsuarioReenviarCredencial(int idUsuario)
        {
            try
            {
                var db = new CoomuceEntities();

                // obtengo datos de usuario
                var info = db.Usuario
                    .Where(r => r.idUsuario.Equals(idUsuario))
                    .FirstOrDefault();

                // enviar correo
                var credencialesEnviadas = gen.EnviarCorreo(info, 1);

                return gen.EscribirJson(new { message = (credencialesEnviadas ? Mensajes.CredencialesEnviadas : Mensajes.CredencialesNoEnviadas), success = true });
            }
            catch (Exception ex)
            {
                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream AdminConfiguracionCuerpoCorreoU(ConfiguracionCuerpoCorreo datos)
        {
            try
            {
                var db = new CoomuceEntities();

                var itemConf = db.ConfiguracionCuerpoCorreo
                        .Where(r => r.idConfiguracionCuerpoCorreo.Equals(datos.idConfiguracionCuerpoCorreo))
                        .FirstOrDefault();

                itemConf.tituloConfiguracionCuerpoCorreo = datos.tituloConfiguracionCuerpoCorreo;
                itemConf.mensajeConfiguracionCuerpoCorreo = datos.mensajeConfiguracionCuerpoCorreo;

                db.SaveChanges();

                return gen.EscribirJson(new { message = Mensajes.Guardar, success = true });
            }
            catch (Exception ex)
            {
                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }
        public Stream SeguridadCambiarContraseña(string username, string password, string newpassword)
        {
            try
            {
                var db = new CoomuceEntities();

                // obtengo los datos del usuario
                var info = db.Usuario
                           .Where(r => r.loginUsuario.Equals(username) && r.passwordUsuario.Equals(password))
                           .FirstOrDefault();

                // verifico si existe el usuario
                if (info == null)
                {
                    return(gen.EscribirJson(new { message = Mensajes.UsuarioIncorrecto, success = false }));
                }

                info.passwordUsuario = newpassword;

                RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider();
                byte[] data = new byte[5];
                provider.GetBytes(data);
                info.passwordSaltUsuario = Convert.ToBase64String(data);

                info.passwordHashUsuario = FormsAuthentication.HashPasswordForStoringInConfigFile(info.passwordUsuario + info.passwordSaltUsuario, "SHA1");

                info.esTemporalUsuario     = false;
                info.estaHabilitadoUsuario = true;

                db.SaveChanges();

                return(gen.EscribirJson(new { message = Mensajes.UsuarioCambiarContraseña, success = true }));
            }
            catch (Exception ex)
            {
                return(gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false }));
            }
        }
        public Stream SeguridadReingresar(string username, string password)
        {
            try
            {
                var db = new CoomuceEntities();

                // obtengo los datos del usuario
                var info = db.Usuario
                           .Where(r => r.loginUsuario.Equals(username))
                           .FirstOrDefault();

                if (!info.passwordUsuario.Equals(password))
                {
                    return(gen.EscribirJson(new { message = Mensajes.UsuarioClaveIncorrecta, success = false }));
                }

                return(gen.EscribirJson(new { message = Mensajes.UsuarioReingresado, success = true }));
            }
            catch (Exception ex)
            {
                return(gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false }));
            }
        }
        public Stream SeguridadAutenticar(string username, string password)
        {
            try
            {
                var db = new CoomuceEntities();

                // obtengo los datos del usuario
                var info = db.Usuario
                           .Where(r => r.loginUsuario.Equals(username) && r.passwordUsuario.Equals(password))
                           .FirstOrDefault();

                // verifico si existe el usuario
                if (info == null)
                {
                    return(gen.EscribirJson(new { message = Mensajes.UsuarioIncorrecto, success = false }));
                }

                // verifico si el usuario tiene clave temporal
                if (info.esTemporalUsuario)
                {
                    return(gen.EscribirJson(new { message = Mensajes.UsuarioClaveTemporal, esTemporal = true, success = true }));
                }

                // verifico si el usuario se encuentra activo
                if (!info.estaHabilitadoUsuario)
                {
                    return(gen.EscribirJson(new { message = Mensajes.UsuarioInactivo, success = false }));
                }

                // obtengo el tiempo de inactividad
                var cfg = db.ConfiguracionGeneral
                          .Select(r => new
                {
                    r.tiempoInactividadConfiguracionGeneral,
                    r.salarioConfiguracionGeneral
                })
                          .FirstOrDefault();

                var datos = new DatosSeguridad()
                {
                    idUsuario     = info.idUsuario,
                    loginUsuario  = info.loginUsuario,
                    nombreUsuario = string.Format("{0}{1}{2}{3}",
                                                  info.primerApellidoUsuario, (string.IsNullOrEmpty(info.segundoApellidoUsuario) ? " ": " " + info.segundoApellidoUsuario + " "),
                                                  info.primerNombreUsuario, (string.IsNullOrEmpty(info.segundoNombreUsuario) ? "" : " " + info.segundoNombreUsuario)),
                    nombreUsuarioFormato = string.Format("{0}{1}{2}{3}{4}",
                                                         info.primerApellidoUsuario, (string.IsNullOrEmpty(info.segundoApellidoUsuario) ? " " : " " + info.segundoApellidoUsuario), "<br />",
                                                         info.primerNombreUsuario, (string.IsNullOrEmpty(info.segundoNombreUsuario) ? "" : " " + info.segundoNombreUsuario)),
                    idRol             = info.idRol,
                    nombreRol         = info.Rol.nombreRol,
                    tiempoInactividad = cfg.tiempoInactividadConfiguracionGeneral,
                    salarioMinimo     = cfg.salarioConfiguracionGeneral
                };

                return(gen.EscribirJson(new { data = datos, message = Mensajes.UsuarioAutenticado, success = true }));
            }
            catch (Exception ex)
            {
                return(gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false }));
            }
        }
        public Stream AdminUsuarioCUD(List<Usuario> nuevos, List<Usuario> viejos, List<Usuario> eliminados)
        {
            var db = new CoomuceEntities();
            var transaction = db.Database.BeginTransaction();

            try
            {
                // hay datos para eliminar?
                if (eliminados.Count > 0)
                {
                    // marcar registros para eliminar
                    eliminados.ForEach(e => db.Entry(e).State = EntityState.Deleted);

                    // eliminar registros
                    db.Usuario.RemoveRange(eliminados);
                }

                // hay datos para actualizar?
                if (viejos.Count > 0)
                {
                    // obtengo los id's de los items editados
                    var listaId = viejos.Select(v => v.idUsuario).ToList();

                    // obtengo los items editados
                    var itemEditar = db.Usuario.Where(r => listaId.Contains(r.idUsuario)).ToList();

                    // obtengo los datos editados
                    itemEditar.ForEach(r =>
                    {
                        var v = viejos.Where(i => i.idUsuario == r.idUsuario).FirstOrDefault();

                        r.idTipoIdentificacion = v.idTipoIdentificacion;
                        r.identificacionUsuario = v.identificacionUsuario;
                        r.primerApellidoUsuario = v.primerApellidoUsuario;
                        r.segundoApellidoUsuario = v.segundoApellidoUsuario;
                        r.primerNombreUsuario = v.primerNombreUsuario;
                        r.segundoNombreUsuario = v.segundoNombreUsuario;
                        r.emailUsuario = v.emailUsuario;
                        r.celularUsuario = v.celularUsuario;
                        r.idRol = v.idRol;
                        r.estaHabilitadoUsuario = v.estaHabilitadoUsuario;
                    });
                }

                // hay datos para adicionar?
                if (nuevos.Count > 0)
                {
                    foreach (var item in nuevos)
                    {
                        // obtener login de usuario
                        string loginUsuario = string.Format("{0}{1}{2}",
                            item.primerNombreUsuario.Substring(0, 1),
                            item.primerApellidoUsuario.Replace(" ", ""),
                            (string.IsNullOrEmpty(item.segundoApellidoUsuario) ? "" : item.segundoApellidoUsuario.Substring(0, 1)));

                        // verificar si hay un usuario con el mismo login
                        var existenLogin = db.Usuario
                            .Where(r => r.loginUsuario.Substring(0, loginUsuario.Length).Equals(loginUsuario))
                            .Count();

                        // se encontro usuarios con el mismo login?
                        if (existenLogin > 0)
                        {
                            existenLogin++;

                            loginUsuario += existenLogin.ToString();
                        }
                        item.loginUsuario = loginUsuario;

                        // se genera la contraseña
                        item.passwordUsuario = Membership.GeneratePassword(12, 0);
                        RNGCryptoServiceProvider provider = new RNGCryptoServiceProvider();
                        byte[] data = new byte[5];
                        provider.GetBytes(data);
                        item.passwordSaltUsuario = Convert.ToBase64String(data);

                        item.passwordHashUsuario = FormsAuthentication.HashPasswordForStoringInConfigFile(item.passwordUsuario + item.passwordSaltUsuario, "SHA1");
                    }

                    // agregar rango de nuevos registros
                    db.Usuario.AddRange(nuevos);
                }

                // guardo datos y confirmo transacción
                db.SaveChanges();
                transaction.Commit();

                // hay nuevos datos?, si es asi enviamos los correos con las claves de acceso
                if (nuevos.Count > 0)
                {
                    foreach (var item in nuevos)
                    {
                        bool credencialesEnviadas = false;

                        credencialesEnviadas = gen.EnviarCorreo(item, 0);
                    }
                }

                return gen.EscribirJson(new { message = Mensajes.Guardar, success = true });
            }
            catch (Exception ex)
            {
                transaction.Rollback();

                return gen.EscribirJson(new { message = string.Format(Mensajes.Error, ex.Message), success = false });
            }
        }