Ejemplo n.º 1
0
        public List <object> Obtener(Administradores admin, Usuarios objUsuario)
        {
            List <object> objetos = new List <object>();
            Administrador adminst = new Administrador
            {
                IdAdministrador = admin.IdAdministrador,
                Dni             = admin.Dni,
                Nombres         = admin.Nombres,
                ApellidoPaterno = admin.ApellidoPaterno,
                ApellidoMaterno = admin.ApellidoMaterno,
                Direccion       = admin.Direccion,
                Edad            = admin.Edad,
                Sexo            = admin.Sexo,
                Profesion       = admin.Profesion,
                FechaNacimiento = admin.FechaNacimiento,
                Telefono        = admin.Telefono,
            };

            objetos.Add(adminst);
            var fecha = adminst.FechaNacimiento.ToString("dd/MM/yyyy");

            objetos.Add(fecha);
            Usuario usuario = new Usuario
            {
                IdUsuario     = objUsuario.IdUsuario,
                NombreUsuario = objUsuario.NombreUsuario,
                Contraseña    = objUsuario.Contraseña,
                TipoUsuario   = objUsuario.TipoUsuario,
                Correo        = objUsuario.Correo
            };

            objetos.Add(usuario);
            return(objetos);
        }
Ejemplo n.º 2
0
        public HttpResponseMessage Put(ModelAdministradorAtualizacao modelAdministradorAtualizacao)
        {
            if (ModelState.IsValid)
            {
                Administradores administrador = appServicesAdministrador.PesquisaAdministradorPorLoginSenhaApp(modelAdministradorAtualizacao.Login, CriptographyPassword.CriptografarSenha(modelAdministradorAtualizacao.Senha));
                if (administrador != null)
                {
                    administrador.Nome          = modelAdministradorAtualizacao.Nome;
                    administrador.Sobrenome     = modelAdministradorAtualizacao.Sobrenome;
                    administrador.Descricao     = modelAdministradorAtualizacao.Descricao;
                    administrador.DataAlteracao = DateTime.Now;
                    administrador = DataConvertions <Administradores> .AdministradorDataAllConvertion(administrador);

                    appServicesAdministrador.AtualizarApp(administrador);
                    return(Request.CreateResponse(HttpStatusCode.OK, "Administrador " + modelAdministradorAtualizacao.Nome + " atualizado com sucesso."));
                }
                return(null);
            }
            else
            {
                var listagemErros = new List <string>();
                foreach (var state in ModelState)
                {
                    foreach (var e in state.Value.Errors)
                    {
                        listagemErros.Add(e.ErrorMessage);
                    }
                }
                return(Request.CreateResponse(HttpStatusCode.Forbidden, listagemErros));
            }
        }
Ejemplo n.º 3
0
        public string Actualizar(Usuario usuario, Administrador admin)
        {
            string          strMensaje     = "Error";
            IRepository     repository     = new Model.Repository();
            Usuarios        UpdatePaciente = repository.FindEntity <Usuarios>(c => c.IdUsuario == usuario.IdUsuario);
            string          strPass        = CryproHelper.ComputeHash(usuario.Contraseña, CryproHelper.Supported_HA.SHA512, null);
            Administradores objUsuID       = repository.FindEntity <Administradores>(c => c.IdUsuario == UpdatePaciente.IdUsuario);

            if (objUsuID != null)
            {
                UpdatePaciente.NombreUsuario = usuario.NombreUsuario;
                UpdatePaciente.Contraseña    = strPass;
                UpdatePaciente.Correo        = usuario.Correo;
                repository.Update(UpdatePaciente);

                objUsuID.Dni             = admin.Dni;
                objUsuID.Nombres         = admin.Nombres;
                objUsuID.ApellidoPaterno = admin.ApellidoPaterno;
                objUsuID.ApellidoMaterno = admin.ApellidoMaterno;
                objUsuID.Direccion       = admin.Direccion;
                objUsuID.Edad            = admin.Edad;
                objUsuID.Sexo            = admin.Sexo;
                objUsuID.Profesion       = admin.Profesion;
                objUsuID.FechaNacimiento = Convert.ToDateTime(admin.FechaNacimiento);
                objUsuID.Telefono        = admin.Telefono;
                repository.Update(objUsuID);

                strMensaje = "Se actualizo sus datos";
            }
            return(strMensaje);
        }
Ejemplo n.º 4
0
        public async Task <IActionResult> Edit(int id, [Bind("Id,Nome,Login,Senha")] Administradores administradores)
        {
            if (id != administradores.Id)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(administradores);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!AdministradoresExists(administradores.Id))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(administradores));
        }
Ejemplo n.º 5
0
        private void botonEliminar_Click(object sender, EventArgs e)
        {
            string dato   = textID.Text;
            int    id_num = Int32.Parse(dato);

            string mensaje = "Estas seguro de eliminar este registro";


            using (MindfullnessEntities mind = new MindfullnessEntities())
            {
                try
                {
                    Administradores query = (from d in mind.Administradores
                                             where d.id == id_num
                                             select d).First();
                    var result = MessageBox.Show(mensaje, "Eliminar", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);

                    if (result == DialogResult.Yes)
                    {
                        mind.Administradores.Remove(query);
                        mind.SaveChanges();
                        MessageBox.Show("Registro eliminado exitosamente");
                        mostrarLista();
                    }
                }
                catch (InvalidOperationException Ex)
                {
                    MessageBox.Show("Registro no encontrado", "Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
                    Console.WriteLine("Ha fallado" + Ex);
                }
            }
        }
Ejemplo n.º 6
0
        /// <summary>
        /// Metodo para eliminar un admin
        /// </summary>
        public void EliminarAdmin()
        {
            Administradores admin = ObtenerAdministradorSeleccionado();

            if (admin != null)
            {
                if (admin.id == FormLogin.adminLogeado.id)
                {
                    MessageBox.Show("Usa otro administrador para eliminar tu rol", "Eliminar", MessageBoxButtons.OK, MessageBoxIcon.Information);
                }
                else
                {
                    if (MessageBox.Show("Quieres eliminar el administrador seleccionado?", "Eliminar", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
                    {
                        String mensaje = Base_de_Datos.ORM_Admin.DeleteAdmin(ObtenerAdministradorSeleccionado());

                        if (mensaje.Equals(""))
                        {
                            MessageBox.Show("Administrador eliminado", "Eliminar", MessageBoxButtons.OK, MessageBoxIcon.Information);
                        }
                        else
                        {
                            MessageBox.Show("No se ha podido eliminar el administrador: " + mensaje, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        }

                        MostrarAdmins();
                    }
                }
            }
        }
Ejemplo n.º 7
0
 public HttpResponseMessage Delete(ModelAdministradorExclusao modelAdministradorExclusao)
 {
     if (ModelState.IsValid)
     {
         Administradores administrador = appServicesAdministrador.PesquisaAdministradorPorLoginSenhaApp(modelAdministradorExclusao.Login, CriptographyPassword.CriptografarSenha(modelAdministradorExclusao.Senha));
         if (administrador != null)
         {
             appServicesAdministrador.ExcluirApp(administrador);
             return(Request.CreateResponse(HttpStatusCode.OK, "Administrador " + modelAdministradorExclusao.Nome + " excluido com sucesso."));
         }
         return(null);
     }
     else
     {
         var listagemErros = new List <string>();
         foreach (var state in ModelState)
         {
             foreach (var e in state.Value.Errors)
             {
                 listagemErros.Add(e.ErrorMessage);
             }
         }
         return(Request.CreateResponse(HttpStatusCode.Forbidden, listagemErros));
     }
 }
Ejemplo n.º 8
0
 public HttpResponseMessage GetValueBySobrenome(string sobrenome)
 {
     if (!String.IsNullOrEmpty(sobrenome))
     {
         ModelPesquisaAdministradorPorSobrenome modelPesquisaAdministradorPorSobrenome = new ModelPesquisaAdministradorPorSobrenome();
         modelPesquisaAdministradorPorSobrenome.Sobrenome = sobrenome;
         if (ModelState.IsValid)
         {
             Administradores administrador = appServicesAdministrador.PesquisaAdministradorPorSobrenomeApp(modelPesquisaAdministradorPorSobrenome.Sobrenome.ToLower());
             if (administrador != null)
             {
                 return(Request.CreateResponse(HttpStatusCode.OK, administrador));
             }
             return(null);
         }
         return(null);
     }
     else
     {
         var listagemErros = new List <string>();
         foreach (var state in ModelState)
         {
             foreach (var e in state.Value.Errors)
             {
                 listagemErros.Add(e.ErrorMessage);
             }
         }
         return(Request.CreateResponse(HttpStatusCode.Forbidden, listagemErros));
     }
 }
Ejemplo n.º 9
0
        public ActionResult AgregarNuevo(Administradores a)
        {
            if (!ModelState.IsValid)
            {
                AdminReference.AdminServiceClient sr     = new AdminReference.AdminServiceClient();
                IEnumerable <SelectListItem>      cambio = sr.MostrarDeptos().Select(c => new SelectListItem {
                    Text = c.Nombre
                });
                ViewBag.Depos = cambio;
                return(View(a));
            }
            try
            {
                AdminReference.AdminServiceClient sr = new AdminReference.AdminServiceClient();
                AdminReference.Administradores    ad = new AdminReference.Administradores();
                ad.AdminID      = a.AdminID;
                ad.Nombre       = a.Nombre;
                ad.Apellido     = a.Apellido;
                ad.Departamento = a.Departamento.ToString();
                ad.Email        = a.Email;
                ad.Usuario      = a.Usuario;
                ad.Password     = a.Password;
                sr.AgregarNuevo(ad);

                return(RedirectToAction("SuperLogeado", "Home"));
            }
            catch (Exception e)
            {
                ModelState.AddModelError("", "Verifique los campos incorrectos");
                return(View(a));
            }
        }
Ejemplo n.º 10
0
 public HttpResponseMessage GetValueByLoginSenha(string login, string senha)
 {
     if (!String.IsNullOrEmpty(login) && !String.IsNullOrEmpty(senha))
     {
         ModelPesquisaAdministradorPorLoginSenha modelPesquisaAdministradorPorLoginSenha = new ModelPesquisaAdministradorPorLoginSenha();
         modelPesquisaAdministradorPorLoginSenha.Login = login;
         modelPesquisaAdministradorPorLoginSenha.Senha = CriptographyPassword.CriptografarSenha(senha);
         if (ModelState.IsValid)
         {
             Administradores administrador = appServicesAdministrador.PesquisaAdministradorPorLoginSenhaApp(modelPesquisaAdministradorPorLoginSenha.Login.ToLower(), modelPesquisaAdministradorPorLoginSenha.Senha);
             if (administrador != null)
             {
                 return(Request.CreateResponse(HttpStatusCode.OK, administrador));
             }
             return(null);
         }
         return(null);
     }
     else
     {
         var listagemErros = new List <string>();
         foreach (var state in ModelState)
         {
             foreach (var e in state.Value.Errors)
             {
                 listagemErros.Add(e.ErrorMessage);
             }
         }
         return(Request.CreateResponse(HttpStatusCode.Forbidden, listagemErros));
     }
 }
Ejemplo n.º 11
0
        private void botonAdd_Click(object sender, EventArgs e)
        {
            using (MindfullnessEntities mind = new MindfullnessEntities())
            {
                Administradores adm = new Administradores
                {
                    nombre     = textNombre.Text,
                    apellido   = textApellido.Text,
                    contrasena = textPass.Text,
                    cargo      = textCargo.Text,
                    correo     = textCorreo.Text,
                    edad       = Int32.Parse(textEdad.Text)
                };

                string mensaje = "Estas seguro de agregar a: " + textNombre.Text + " " + textApellido.Text + " como admnistrador";
                var    result  = MessageBox.Show(mensaje, "Agregar administrador", MessageBoxButtons.OKCancel, MessageBoxIcon.Information);
                if (result == DialogResult.OK)
                {
                    mind.Administradores.Add(adm);
                    mind.SaveChanges();

                    MessageBox.Show("Se ha registrado con exito");
                }
            }
            textNombre.Clear();
            textApellido.Clear();
            textPass.Clear();
            textCorreo.Clear();
            textEdad.Clear();
            textCargo.Clear();
        }
Ejemplo n.º 12
0
        public IHttpActionResult PutAdministradores(byte id, Administradores administradores)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            if (id != administradores.id)
            {
                return(BadRequest());
            }

            db.Entry(administradores).State = EntityState.Modified;

            try
            {
                db.SaveChanges();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!AdministradoresExists(id))
                {
                    return(NotFound());
                }
                else
                {
                    throw;
                }
            }

            return(StatusCode(HttpStatusCode.NoContent));
        }
Ejemplo n.º 13
0
 /// <summary>
 ///  Constructor parametrizado para modificar un admin
 /// </summary>
 /// <param name="_administrador"></param>
 public FormAdmin(Administradores _administrador)
 {
     InitializeComponent();
     administrador = _administrador;
     modificar     = true;
     HabilitarModificarContrasena();
 }
Ejemplo n.º 14
0
        public HttpResponseMessage Post(ModelAdministradorCadastro modelAdministradorCadastro)
        {
            if (ModelState.IsValid)
            {
                Administradores administrador = Mapper.Map <ModelAdministradorCadastro, Administradores>(modelAdministradorCadastro);
                administrador.DataCadastro  = DateTime.Now;
                administrador.DataAlteracao = DateTime.Now;
                administrador.Senha         = CriptographyPassword.CriptografarSenha(administrador.Senha);
                administrador = DataConvertions <Administradores> .AdministradorDataAllConvertion(administrador);

                appServicesAdministrador.InserirApp(administrador);
                return(Request.CreateResponse(HttpStatusCode.OK, "Administrador " + modelAdministradorCadastro.Nome + " cadastrado com sucesso."));
            }
            else
            {
                var listagemErros = new List <string>();
                foreach (var state in ModelState)
                {
                    foreach (var e in state.Value.Errors)
                    {
                        listagemErros.Add(e.ErrorMessage);
                    }
                }
                return(Request.CreateResponse(HttpStatusCode.Forbidden, listagemErros));
            }
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Prueba de loguearse con el email y contraseña de los TextBoxs. Si es correcto,
        /// accede a la app, si es incorrecto muestra el mensaje de error
        /// </summary>
        private void intentarLogin()
        {
            Administradores admin = Base_de_Datos.ORM_Admin.SelectAdminLogin(textBoxEmail.Text, textBoxContrasenya.Text);

            if (admin == null)
            {
                valido = false;
                labelIncorrectos.Visible = true;
            }
            else
            {
                adminLogeado = new Administradores();

                adminLogeado.superadmin  = admin.superadmin;
                adminLogeado.id          = admin.id;
                adminLogeado.nombre      = admin.nombre;
                adminLogeado.apellidos   = admin.apellidos;
                adminLogeado.email       = admin.email;
                adminLogeado.contrasenya = admin.contrasenya;
                adminLogeado.Eventos     = admin.Eventos;
                adminLogeado.Comunidades = admin.Comunidades;

                valido = true;

                Hide();
                FormMenu formMenu = new FormMenu();
                labelIncorrectos.Visible = false;
                formMenu.ShowDialog();
                textBoxEmail.Clear();
                textBoxContrasenya.Clear();
                Show();
            }
        }
Ejemplo n.º 16
0
        public string Post([FromUri] Administradores admin)
        {
            try
            {
                AdminReference.AdminServiceClient service = new AdminReference.AdminServiceClient();
                AdminReference.Administradores    insert  = new AdminReference.Administradores();

                insert.AdminID              = insert.AdminID;
                insert.Apellido             = admin.Apellido;
                insert.CargarReportes       = admin.CargarReportes;
                insert.CrearAdmin           = (bool)admin.CrearAdmin;
                insert.Departamento         = admin.Departamento;
                insert.Email                = admin.Email;
                insert.EnviarNotificaciones = (bool)admin.EnviarNotificaciones;
                insert.Nombre               = admin.Nombre.ToString();
                insert.Password             = admin.Password;
                insert.Permisos             = (bool)admin.Permisos;
                insert.Usuario              = admin.Usuario;
                insert.Rol       = admin.Rol;
                insert.Bloqueado = admin.Bloqueado;
                return(service.AgregarNuevo(insert));
            }
            catch (Exception ex) {
                return("No se pudo completar la operación: " + ex.ToString());
            }
        }
 public ActionResult Bloquear(string id)
 {
     if (Session["UsuarioLogeado"] != null)
     {
         AdminReference.AdminServiceClient sr = new AdminReference.AdminServiceClient();
         Administradores ad = new Administradores();
         foreach (var item in sr.BuscarAdministrador(id))
         {
             ad.AdminID              = item.AdminID;
             ad.Nombre               = item.Nombre;
             ad.Apellido             = item.Apellido;
             ad.Departamento         = item.Departamento;
             ad.Email                = item.Email;
             ad.Usuario              = item.Usuario;
             ad.Password             = item.Password;
             ad.CrearAdmin           = item.CrearAdmin;
             ad.Permisos             = item.Permisos;
             ad.Rol                  = item.Rol;
             ad.CargarReportes       = (bool)item.CargarReportes;
             ad.EnviarNotificaciones = item.EnviarNotificaciones;
             ad.Bloqueado            = (bool)item.Bloqueado;
         }
         return(PartialView(ad));
     }
     else
     {
         return(RedirectToAction("Index", "Acceso"));
     }
 }
Ejemplo n.º 18
0
        //delete
        public static String DeleteAdmin(Administradores admin)
        {
            String result = "";

            ORM.bd.Administradores.Remove(admin);

            result = ORM.SaveChanges();

            return(result);
        }
Ejemplo n.º 19
0
 public static Administradores AdministradorDataAllConvertion(Administradores administrador)
 {
     if (administrador != null)
     {
         administrador.Nome      = administrador.Nome.Trim().ToLower();
         administrador.Sobrenome = administrador.Sobrenome.Trim().ToLower();
         administrador.Login     = administrador.Login.Trim().ToLower();
         return(administrador);
     }
     return(null);
 }
Ejemplo n.º 20
0
        public async Task <IActionResult> Create([Bind("Id,Nome,Login,Senha")] Administradores administradores)
        {
            if (ModelState.IsValid)
            {
                _context.Add(administradores);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(administradores));
        }
Ejemplo n.º 21
0
        public IHttpActionResult PostAdministradores(Administradores administradores)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            db.Administradores.Add(administradores);
            db.SaveChanges();

            return(CreatedAtRoute("DefaultApi", new { id = administradores.id }, administradores));
        }
        public bool IsEmpty(Administradores administradores)
        {
            if (administradores.nombre.Equals("") || administradores.contraseña.Equals(""))

            {
                return(false);
            }
            else
            {
                return(true);
            }
        }
Ejemplo n.º 23
0
 public static void ActualizarSessionAdmin(Usuarios Usuario, Administradores admin)
 {
     HttpContext.Current.Session["Usuario_Id"]      = Usuario.IdUsuario;
     HttpContext.Current.Session["TipoUsuario"]     = Usuario.TipoUsuario;
     HttpContext.Current.Session["NombreUsuario"]   = Usuario.NombreUsuario;
     HttpContext.Current.Session["Contraseña"]      = Usuario.Contraseña;
     HttpContext.Current.Session["Id"]              = admin.IdAdministrador;
     HttpContext.Current.Session["Sexo"]            = admin.Sexo;
     HttpContext.Current.Session["Dni"]             = admin.Dni;
     HttpContext.Current.Session["Nombres"]         = admin.Nombres;
     HttpContext.Current.Session["ApellidoPaterno"] = admin.ApellidoPaterno;
     HttpContext.Current.Session["ApellidoMaterno"] = admin.ApellidoMaterno;
 }
        public ActionResult EditarAdministrador(Administradores admin)
        {
            if (!ModelState.IsValid)
            {
                AdminReference.AdminServiceClient sr = new AdminReference.AdminServiceClient();

                IEnumerable <SelectListItem> items = sr.MostrarDeptos().Select
                                                     (
                    c => new SelectListItem
                {
                    Text = c.Nombre
                }
                                                     );
                ViewBag.Depos = items;
                ModelState.AddModelError("", "Verifique los campos incorrectos");
                return(View(admin));
            }
            try
            {
                AdminReference.AdminServiceClient sr     = new AdminReference.AdminServiceClient();
                AdminReference.Administradores    toEdit = new AdminReference.Administradores();
                toEdit.AdminID              = admin.AdminID;
                toEdit.Nombre               = admin.Nombre;
                toEdit.Apellido             = admin.Apellido;
                toEdit.Departamento         = admin.Departamento.ToString();
                toEdit.Email                = admin.Email;
                toEdit.Usuario              = admin.Usuario;
                toEdit.Password             = EncriptarContraseña(admin.Password);
                toEdit.ConfirmarPassword    = EncriptarContraseña(admin.ConfirmPassword);
                toEdit.CargarReportes       = admin.CargarReportes;
                toEdit.EnviarNotificaciones = admin.EnviarNotificaciones;
                toEdit.Permisos             = admin.Permisos;
                toEdit.CrearAdmin           = admin.CrearAdmin;
                toEdit.Bloqueado            = admin.Bloqueado;
                if (admin.Permisos || admin.CrearAdmin)
                {
                    toEdit.Rol = "SuperAdministrador";
                }
                else
                {
                    toEdit.Rol = "Administrador";
                }
                sr.EditarAdministrador(toEdit);
                return(RedirectToAction("GestionAdministradores"));
            }
            catch (Exception e)
            {
                ModelState.AddModelError("", "Verifique los campos incorrectos");
                return(View(admin));
            }
        }
Ejemplo n.º 25
0
        public IHttpActionResult DeleteAdministradores(byte id)
        {
            Administradores administradores = db.Administradores.Find(id);

            if (administradores == null)
            {
                return(NotFound());
            }

            db.Administradores.Remove(administradores);
            db.SaveChanges();

            return(Ok(administradores));
        }
Ejemplo n.º 26
0
        /// <summary>
        /// Metodo que devuelve el admin que hayamos seleccionado
        /// </summary>
        /// <returns></returns>
        public Administradores ObtenerAdministradorSeleccionado()
        {
            Administradores administrador = null;

            if (AdministradoresExistentes())
            {
                administrador = (Administradores)dataGridViewAdmins.SelectedRows[0].DataBoundItem;
            }
            else
            {
                MessageBox.Show("No hay administradores", "Error", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }

            return(administrador);
        }
                public IActionResult Create(Administradores cust)
                
        {
                        if(ModelState.IsValid)
                         {
                                AdministradoresRepository.Add(cust);
                                return RedirectToAction("Index");

                            
            }
                        return View(cust);

             
                        
        }
Ejemplo n.º 28
0
        public static Administradores SelectAdminLogin(String email, String pw)
        {
            Administradores admin    = null;
            String          password = encriptarContrasenya(pw);

            try
            {
                admin = (from a in ORM.bd.Administradores
                         where a.email.Equals(email) && a.contrasenya.Equals(password)
                         select a).First();
            }
            catch (InvalidOperationException) {}

            return(admin);
        }
Ejemplo n.º 29
0
 private void btnEliminar_Click(object sender, EventArgs e)
 {
     using (BibliotecaEntities4 db = new BibliotecaEntities4())
     {
         admi                 = db.Administradores.Where(buscarID => buscarID.Id_Admin == IDAdmin).First();
         admi.Usuario         = txtUsuario.Text;
         admi.Contraseña      = txtContraseña.Text;
         admi.Id_Lector       = IDLector;
         admi.estado          = 1;
         db.Entry(admi).State = System.Data.Entity.EntityState.Modified;
         db.SaveChanges();
         Limpiar();
         frmPrincipal.admin.CargarDatos();
         this.Close();
     }
 }
Ejemplo n.º 30
0
        //update
        public static String UpdateAdmin(Administradores _admin)
        {
            String          result = "";
            Administradores admin  = ORM.bd.Administradores.Find(_admin.id);

            admin.nombre      = _admin.nombre;
            admin.apellidos   = _admin.apellidos;
            admin.email       = _admin.email;
            admin.contrasenya = encriptarContrasenya(_admin.contrasenya);
            admin.superadmin  = _admin.superadmin;
            admin.Comunidades = _admin.Comunidades;


            result = ORM.SaveChanges();

            return(result);
        }