public MensajeDto EliminarUsuarios(int id)
        {
            using (var context = new ArchivosEntities()) {
                MensajeDto mensajeDto = null;
                var usuarioDb = context.Usuarios
                   .Where(u => u.UsuarioID == id)
                   .FirstOrDefault();
                if (usuarioDb == null) {
                    return new MensajeDto() {
                        Error = true,
                        MensajeDelProceso = "El usuario ID : " + id + " no existe en la base de datos"
                    };
                }

                context.Usuarios.Remove(usuarioDb);

                mensajeDto = AgregarModificar.Hacer(context, mensajeDto);
                if (mensajeDto != null) { return mensajeDto; }

                return new MensajeDto() {
                    Error = false,
                    MensajeDelProceso = "Se elimino el usuario : " + id
                };
            }
        }
        public MensajeDto CargarUsuarios(UsuarioDto uDto)
        {
            if (uDto.UsuarioID > 0) {
                return EditarUsuario(uDto);
            }
            using (var context = new ArchivosEntities()) {
                if (context.AspNetUsers
                    .Where(u => u.Email == uDto.CorreoElectronico)
                    .Count() <= 0) {
                    return new MensajeDto() {
                        Error = true,
                        MensajeDelProceso = "No existe un registro del correo del usuario, FAVOR REGISTRARSE PRIMERO"
                    };
                }
                MensajeDto mensajeDto = null;
                var usuarioDb = new Usuario();
                usuarioDb.NombreUsuario = uDto.NombreUsuario;
                usuarioDb.CorreoElectronico = uDto.CorreoElectronico;
                usuarioDb.UserID = Guid.Parse(context.AspNetUsers
                    .Where(u => u.Email == uDto.CorreoElectronico).First().Id);

                context.Usuarios.Add(usuarioDb);

                mensajeDto = AgregarModificar.Hacer(context, mensajeDto);
                if (mensajeDto != null) { return mensajeDto; }

                uDto.UsuarioID = usuarioDb.UsuarioID;

                return new MensajeDto() {
                    Error = false,
                    MensajeDelProceso = "Se cargo el usuario : " + uDto.UsuarioID,
                    ObjetoDto = uDto
                };
            }
        }
 public List<LugareDto> ListadoLugares()
 {
     using (var context = new ArchivosEntities()) {
         var listado = context.Lugares
             .Select(s => new LugareDto() {
                 LugarID = s.LugarID,
                 NombreLugar = s.NombreLugar
             }).ToList();
         return listado;
     }
 }
 public List<UsuarioDto> ListadoUsuarios()
 {
     using (var context = new ArchivosEntities()) {
         var listado = context.Usuarios
             .Select(s => new UsuarioDto() {
                 UsuarioID = s.UsuarioID,
                 NombreUsuario = s.NombreUsuario,
                 CorreoElectronico = s.CorreoElectronico
             }).ToList();
         return listado;
     }
 }
 public List<DocumentoDto> ListadoDocumentos(string rutaDestino)
 {
     using (var context = new ArchivosEntities()) {
         var listado = context.Documentos
             .Select(s => new DocumentoDto() {
                 Nombre = s.Nombre
             }).ToList();
         listado.ForEach(delegate(DocumentoDto dDto) {
             this.RecuperarDocumento(dDto.Nombre, rutaDestino);
             string[] archivo = dDto.Nombre.Split('.');
             dDto.Extension = archivo[archivo.Length - 1];
         });
         return listado;
     }
 }
        public MensajeDto CargarLugar(LugareDto lDto)
        {
            if (lDto.LugarID > 0) {
                return EditarLugar(lDto);
            }
            using (var context = new ArchivosEntities()) {
                MensajeDto mensajeDto = null;
                var lugareDb = new Lugare();
                lugareDb.NombreLugar = lDto.NombreLugar;

                context.Lugares.Add(lugareDb);

                mensajeDto = AgregarModificar.Hacer(context, mensajeDto);
                if (mensajeDto != null) { return mensajeDto; }
                lDto.LugarID = lugareDb.LugarID;

                return new MensajeDto() {
                    Error = false,
                    MensajeDelProceso = "Se cargo el lugar : " + lDto.LugarID,
                    ObjetoDto = lDto
                };
            }
        }
        private MensajeDto EditarLugar(LugareDto lDto)
        {
            using (var context = new ArchivosEntities()) {
                MensajeDto mensajeDto = null;
                var lugareDb = context.Lugares
                    .Where(l => l.LugarID == lDto.LugarID).FirstOrDefault();
                if (lugareDb == null) {
                     return new MensajeDto() {
                        Error = true,
                        MensajeDelProceso = "No existe el lugar con id " + lDto.LugarID
                    };
                }
                lugareDb.NombreLugar = lDto.NombreLugar;
                context.Entry(lugareDb).State = System.Data.Entity.EntityState.Modified;
                mensajeDto = AgregarModificar.Hacer(context, mensajeDto);
                if (mensajeDto != null) { return mensajeDto; }

                return new MensajeDto() {
                    Error = false,
                    MensajeDelProceso = "Se Edito el lugar : " + lDto.LugarID,
                    ObjetoDto = lDto
                };
            }
        }
        public MensajeDto EliminarLugar(int id)
        {
            using (var context = new ArchivosEntities()) {
                MensajeDto mensajeDto = null;
                var lugareDb = context.Lugares
                    .Where(l => l.LugarID == id).FirstOrDefault();
                if (lugareDb == null) {
                    return new MensajeDto() {
                        Error = true,
                        MensajeDelProceso = "No existe el lugar con id " + id
                    };
                }

                context.Lugares.Remove(lugareDb);

                mensajeDto = AgregarModificar.Hacer(context, mensajeDto);
                if (mensajeDto != null) { return mensajeDto; }

                return new MensajeDto() {
                    Error = false,
                    MensajeDelProceso = "Se elimino el lugar : " + id
                };
            }
        }
        private MensajeDto EditarUsuario(UsuarioDto uDto)
        {
            using (var context = new ArchivosEntities()) {
                MensajeDto mensajeDto = null;
                var usuarioDb = context.Usuarios
                    .Where(u => u.UsuarioID == uDto.UsuarioID)
                    .FirstOrDefault();
                if (usuarioDb == null) {
                    return new MensajeDto() {
                        Error = true,
                        MensajeDelProceso = "No existe el usuario con id " + uDto.UsuarioID
                    };
                }
                context.Entry(usuarioDb).State = System.Data.Entity.EntityState.Modified;
                mensajeDto = AgregarModificar.Hacer(context, mensajeDto);
                if (mensajeDto != null) { return mensajeDto; }

                return new MensajeDto() {
                    Error = false,
                    MensajeDelProceso = "Se Edito el usuario : " + uDto.UsuarioID,
                    ObjetoDto = uDto
                };
            }
        }
        public List<ArchivosMovimientoDto> ListadoDocumentos(string rutaDestino)
        {
            using (var context = new ArchivosEntities()) {
                var listadoDb = context.ArchivosMovimientos.AsQueryable();

                listadoDb = listadoDb.Take(20).AsQueryable();

                var listado = listadoDb.Select(s => new ArchivosMovimientoDto() {
                    Titulo = s.Titulo,
                    Descripcion = s.Descripcion,
                    NombreArchivo = s.NombreArchivo,
                    Extension = s.Extension
                }).ToList();

                listado.ForEach(delegate(ArchivosMovimientoDto amDto) {
                    this.RecuperarDocumento(amDto.NombreArchivo, rutaDestino);
                });
                return listado;
            }
        }
        public MensajeDto guardarDocumento(string nombre,
            byte[] contenido,
            string titulo,
            string descripcion,
            Guid userID)
        {
            //Se busca el ID del usuario
            int usuarioIDCarga = 0;
            using (var context = new ArchivosEntities()) {
                var usuarioDb = context.Usuarios
                    .Where(u => u.UserID == userID).FirstOrDefault();
                if (usuarioDb == null) {
                    return new MensajeDto() {
                        Error = true,
                        MensajeDelProceso = "Error: Este usuario esta registrado pero no fue aceptado por la administracion aun"
                    };
                }
                usuarioIDCarga = usuarioDb.UsuarioID;
            }

            var mensajeConnString = RecuperarElconnectionStrings("ArchivosDb");
            if (mensajeConnString.Error) {
                return mensajeConnString;
            }
            string CadConexion = mensajeConnString.Valor;

            using (SqlConnection conexionBD = new SqlConnection(CadConexion)) {
                try {
                    conexionBD.Open();
                    if (conexionBD.State == ConnectionState.Open) {
                        using (SqlTransaction transaccion = conexionBD.BeginTransaction()) {
                            //byte[] contenido = File.ReadAllBytes(ubicacion);
                            //Se ve su extencion
                            string[] nombreArchivo = nombre.Split('.');
                            var extension = nombreArchivo[nombreArchivo.Length - 1];

                            string cadSql = @"INSERT INTO [ArchivosMovimientos]
                            (ArchivosMovimientoID,NombreArchivo,
                             DocumentoFile,Titulo,
                             Descripcion, MomentoCarga,
                             UsuarioIDCarga, Extension)
                               VALUES
                            (@ArchivosMovimientoID,@Nombre,
                             @Fichero,@Titulo,
                             @Descripcion, GETDATE(),
                             @UsuarioIDCarga, @Extension)";
                            using (SqlCommand cmd = new SqlCommand(cadSql, conexionBD, transaccion)) {
                                cmd.Parameters.AddWithValue("@ArchivosMovimientoID", Guid.NewGuid().ToString());
                                cmd.Parameters.AddWithValue("@Nombre", nombre);
                                cmd.Parameters.AddWithValue("@Fichero", contenido);
                                cmd.Parameters.AddWithValue("@Titulo", titulo);
                                cmd.Parameters.AddWithValue("@Descripcion", descripcion);
                                cmd.Parameters.AddWithValue("@UsuarioIDCarga", usuarioIDCarga);
                                cmd.Parameters.AddWithValue("@Extension", extension);
                                cmd.ExecuteNonQuery();
                                transaccion.Commit();
                            }
                        }
                    }
                } catch (Exception ex) {
                    return new MensajeDto() {
                        Error = true,
                        MensajeDelProceso = "Error: " + ex.Message
                    };
                } finally {
                    if ((conexionBD != null) && (conexionBD.State == ConnectionState.Open)) {
                        conexionBD.Close();
                    }
                }
            }
            return new MensajeDto() {
                Error = false,
                MensajeDelProceso = "Insercion Exitosa del archivo: " + nombre
            };
        }
        public List<ArchivosMovimientoDto> ListadoDocumentos(string rutaDestino, string titulo, string descripcion)
        {
            using (var context = new ArchivosEntities()) {
                var listadoDb = context.ArchivosMovimientos.AsQueryable();

                if (titulo != null) {
                    var tituloArray = titulo.Split(',');
                    foreach (var palabra in tituloArray) {
                        var palabraTrim = palabra.Trim();
                        listadoDb = listadoDb.Where(l => l.Titulo.Contains(palabraTrim)).AsQueryable();
                    }
                }
                if (descripcion != null) {
                    var descripcionArray = descripcion.Split(',');
                    foreach (var palabra in descripcionArray) {
                        var palabraTrim = palabra.Trim();
                        listadoDb = listadoDb.Where(l => l.Descripcion.Contains(palabraTrim)).AsQueryable();
                    }
                }

                var listado = listadoDb.Select(s => new ArchivosMovimientoDto() {
                    Titulo = s.Titulo,
                    Descripcion = s.Descripcion,
                    NombreArchivo = s.NombreArchivo,
                    Extension = s.Extension
                }).ToList();

                listado.ForEach(delegate(ArchivosMovimientoDto amDto) {
                    this.RecuperarDocumento(amDto.NombreArchivo, rutaDestino);
                });
                return listado;
            }
        }