Esempio n. 1
0
        public List <Sector> ListarSectoresPorEmpresa(int id)
        {
            List <Sector> sectores = new List <Sector>();

            try{
                Console.WriteLine("[SectoresService] -> buscando sectores en base de datos");
                using (DocumentosDbContext db = new DocumentosDbContext()) {
                    sectores = db.Sectores.Where(s => s.Empresa.EmpresaId == id).ToList();
                }
                string str = "[";
                foreach (Sector o in sectores)
                {
                    str += o.ToString();
                }
                str += "]";
                Console.WriteLine("[SectoresService] -> se encontraron: " + str);
                return(sectores);
            } catch (InvalidOperationException exception) {
                Console.WriteLine("[SectoresService] -> " + exception.GetType().ToString() + ": " + exception.Message);
                return(null);
            } catch (Exception exception) {
                Console.WriteLine("[SectoresService] -> se produjo un error error en acceso a la base de datos");
                Console.WriteLine("[SectoresService] -> " + exception.GetType().ToString() + ": " + exception.Message);
                throw new DocumentosDatabaseException("Se produjo un error error en acceso a la base de datos", exception);
            }
        }
 public DocumentoDTO AddNewDocument(DocumentoDTO documentoDTO, int idEmpresa, int idSector)
 {
     try {
         Console.WriteLine("[DocumentosService] -> insertando nuevo documento");
         Documento documento = ModelMapper.Map(documentoDTO);
         documento.EmpresaId = idEmpresa;
         documento.SectorId  = idSector;
         int idInserted = 0;
         Console.WriteLine("[DocumentosService] -> insertando documento: " + documento.ToString());
         using (DocumentosDbContext db = new DocumentosDbContext()) {
             EntityEntry <Documento> result = db.Documentos.Add(documento);
             db.SaveChanges();
             idInserted = result.Entity.DocumentoId;
         }
         if (idInserted == 0)
         {
             Console.WriteLine("[DocumentosService] -> operacion fallida");
             return(null);
         }
         documentoDTO.DocumentoId = idInserted;
         documentoDTO.Fecha       = documento.Fecha.ToString();
     } catch (Exception exception) {
         Console.WriteLine("[DocumentosService] -> se produjo un error error en acceso a la base de datos");
         throw new DocumentosDatabaseException("Se produjo un error error en acceso a la base de datos", exception);
     }
     // Armado de objeto respuesta no tiene que afectar el flujo, ya que se insertó registro en DB
     try{
         documentoDTO.Empresa = loginService.getNombreEmpresaBy(idEmpresa);
         documentoDTO.Sector  = loginService.getNombreSectorBy(idSector, idEmpresa);
     } catch (Exception exception) {
         Console.WriteLine("[DocumentosService] -> error al obtener nombre para respuesta: " + exception.Message);
     }
     Console.WriteLine("[DocumentosService] -> se registro documento con id" + documentoDTO.DocumentoId);
     return(documentoDTO);
 }
Esempio n. 3
0
        public Sector FindSectorBy(int idEmpresa, int idSector)
        {
            Sector sector = null;

            try {
                Console.WriteLine("[SectoresService] -> buscando sectores en base de datos");
                using (DocumentosDbContext db = new DocumentosDbContext()) {
                    sector = db.Sectores.Where(s => s.Empresa.EmpresaId == idEmpresa && s.SectorId == idSector).First();
                }
                if (sector == null || sector.SectorId == 0)
                {
                    Console.WriteLine("[SectoresService] -> no se encontraron resultado en base de datos");
                    return(null);
                }
                Console.WriteLine("[SectoresService] -> resultado: " + sector.ToString());
                return(sector);
            } catch (InvalidOperationException exception) {
                Console.WriteLine("[SectoresService] -> " + exception.GetType().ToString() + ": " + exception.Message);
                return(null);
            } catch (Exception exception) {
                Console.WriteLine("[SectoresService] -> se produjo un error error en acceso a la base de datos");
                Console.WriteLine("[SectoresService] -> " + exception.GetType().ToString() + ": " + exception.Message);
                throw new DocumentosDatabaseException("Se produjo un error error en acceso a la base de datos", exception);
            }
        }
        public int AddNewSectorInEmpresa(int idEmpresa, Sector sector)
        {
            Console.WriteLine("[EmpresasService] -> buscando empresa");
            Empresa valid = FindEmpresaBy(idEmpresa);

            if (valid == null || valid.Nombre == null)
            {
                Console.WriteLine("[EmpresasService] -> no existe empresa id = " + idEmpresa);
                return(-99);
            }
            int idGenerated = 0;

            try{
                sector.EmpresaId = idEmpresa;
                Console.WriteLine("[EmpresasService] -> insertando nuevo sector");
                using (DocumentosDbContext db = new DocumentosDbContext()) {
                    EntityEntry <Sector> result = db.Sectores.Add(sector);
                    db.SaveChanges();
                    idGenerated = result.Entity.SectorId;
                }
            } catch (Exception exception) {
                Console.WriteLine("[EmpresasService] -> se produjo un error error en el proceso con la base de datos");
                throw new DocumentosDatabaseException("Se produjo un error error en el proceso con la base de datos", exception);
            }
            if (idGenerated == 0)
            {
                Console.WriteLine("[EmpresasService] -> no se completo proceso");
            }
            Console.WriteLine("[EmpresasService] -> se registro nuevo sector con id: " + idGenerated);
            return(idGenerated);
        }
 public UsuarioDTO ValidateUser(string userId, string hashPwd)
 {
     try{
         Usuario result = null;
         using (DocumentosDbContext db = new DocumentosDbContext()) {
             Console.WriteLine("[LoginService] -> Buscando registro de usuario");
             result = db.Usuarios.Where(u => u.UsuarioId == userId).FirstOrDefault();
         }
         if (result == null)
         {
             Console.WriteLine("[LoginService] -> No se encontraron resultados");
             return(null);
         }
         if (result.HashPwd != hashPwd)
         {
             Console.WriteLine("[LoginService] -> Contraseña invalida");
             return(null);
         }
         string empresa = getNombreEmpresaBy(result.EmpresaId);
         return(ModelMapper.Map(result, empresa));
     } catch (Exception exception) {
         Console.WriteLine("[LoginService] -> error en operacion de validacion de usuario");
         throw new DocumentosDatabaseException("Error en operacion de validacion de usuario", exception);
     }
 }
        public Usuario FindUsuarioBy(string userId)
        {
            Usuario usuario = null;

            try{
                Console.WriteLine("[UsuariosService] -> buscando usuario en base de datos");
                using (DocumentosDbContext db = new DocumentosDbContext()) {
                    usuario = db.Usuarios.Where(us => us.UsuarioId == userId).First();
                }
                if (usuario == null || usuario.UsuarioId.Count() == 0)
                {
                    Console.WriteLine("[UsuariosService] -> no se encontraron resultado en base de datos");
                    return(null);
                }
                Console.WriteLine("[UsuariosService] -> resultado: " + usuario.ToString());
                return(usuario);
            } catch (InvalidOperationException exception) {
                Console.WriteLine("[UsuariosService] -> " + exception.GetType().ToString() + ": " + exception.Message);
                return(null);
            } catch (Exception exception) {
                Console.WriteLine("[UsuariosService] -> se produjo un error error en acceso a la base de datos");
                Console.WriteLine("[UsuariosService] -> " + exception.GetType().ToString() + ": " + exception.Message);
                throw new DocumentosDatabaseException("Se produjo un error error en acceso a la base de datos", exception);
            }
        }
        public string getNombreSectorBy(int idSector, int idEmpresa)
        {
            Sector s = null;

            Console.WriteLine("[LoginService] -> buscando nombre de sector " + idSector);
            using (DocumentosDbContext db = new DocumentosDbContext()) {
                s = db.Sectores.Where(s => s.SectorId == idSector & s.EmpresaId == idEmpresa).FirstOrDefault();
            }
            if (s == null)
            {
                Console.WriteLine("[LoginService] -> no se encontro nombre del sector asociado al id " + idEmpresa);
                return("");
            }
            return(s.Nombre);
        }
        public string getNombreEmpresaBy(int idEmpresa)
        {
            Empresa e = null;

            Console.WriteLine("[LoginService] -> buscando nombre de empresa " + idEmpresa);
            using (DocumentosDbContext db = new DocumentosDbContext()) {
                e = db.Empresas.Where(e => e.EmpresaId == idEmpresa).FirstOrDefault();
            }
            if (e == null)
            {
                Console.WriteLine("[LoginService] -> no se encontro nombre de empresa asociado al id " + idEmpresa);
                return("");
            }
            return(e.Nombre);
        }
 public List <DocumentoDTO> FindDocumentoWith(string number)
 {
     try{
         List <Documento> docs = null;
         Console.WriteLine("[DocumentosService] -> buscando documento: " + number);
         using (DocumentosDbContext db = new DocumentosDbContext()){
             docs = db.Documentos.Where(d => d.Numero == number).ToList();
         }
         Console.WriteLine("[DocumentosService] -> se encontraron " + docs.Count() + " resultados");
         return(ProcessResult(docs));
     } catch (InvalidOperationException exception) {
         Console.WriteLine("[DocumentosService] -> " + exception.GetType().ToString() + ": " + exception.Message);
         return(null);
     } catch (Exception exception) {
         Console.WriteLine("[DocumentosService] -> error en proceso de lectura en base de datos");
         throw new DocumentosDatabaseException("Error en proceso de lectura en base de datos", exception);
     }
 }
        public Empresa FindEmpresaBy(int id)
        {
            Empresa empresa = null;

            try{
                Console.WriteLine("[EmpresasService] -> buscando empresa por id en base de datos");
                using (DocumentosDbContext db = new DocumentosDbContext()){
                    empresa = db.Empresas.Find(id);
                }
                if (empresa == null || empresa.EmpresaId == 0)
                {
                    Console.WriteLine("[EmpresasService] -> no se encontraron resultado en base de datos");
                    return(null);
                }
                Console.WriteLine("[EmpresasService] -> resultado: " + empresa.ToString());
                return(empresa);
            } catch (Exception exception) {
                Console.WriteLine("[EmpresasService] -> se produjo un error error en acceso a la base de datos");
                throw new DocumentosDatabaseException("Se produjo un error error en acceso a la base de datos", exception);
            }
        }
        public int AddNewEmpresa(Empresa empresa)
        {
            int idGenerated = 0;

            try{
                Console.WriteLine("[EmpresasService] -> insertando nueva empresa");
                using (DocumentosDbContext db = new DocumentosDbContext()) {
                    EntityEntry <Empresa> result = db.Empresas.Add(empresa);
                    db.SaveChanges();
                    idGenerated = result.Entity.EmpresaId;
                }
            } catch (Exception exception) {
                Console.WriteLine("[EmpresasService] -> se produjo un error error en el proceso con la base de datos");
                throw new DocumentosDatabaseException("Se produjo un error error en el proceso con la base de datos", exception);
            }
            if (idGenerated == 0)
            {
                Console.WriteLine("[EmpresasService] -> no se completo proceso");
            }
            Console.WriteLine("[EmpresasService] -> se registro nueva empresa con id: " + idGenerated);
            return(idGenerated);
        }
        public List <Empresa> ListAllEmpresas()
        {
            List <Empresa> empresas = new List <Empresa>();

            try{
                Console.WriteLine("[EmpresasService] -> listando empresas en base de datos");
                using (DocumentosDbContext db = new DocumentosDbContext()){
                    empresas = db.Empresas.ToList();
                }
                string str = "[";
                foreach (Empresa o in empresas)
                {
                    str += o.ToString();
                }
                str += "]";
                Console.WriteLine("[EmpresasService] -> se encontraron: " + str);
                return(empresas);
            } catch (Exception exception) {
                Console.WriteLine("[EmpresasService] -> se produjo un error error en acceso a la base de datos");
                throw new DocumentosDatabaseException("Se produjo un error error en acceso a la base de datos", exception);
            }
        }
        public EmpresaDTO ModifyEmpresa(int idEmpresa, Empresa empresa)
        {
            Console.WriteLine("[EmpresasService] -> buscando empresa con id: " + idEmpresa);
            Empresa valid = FindEmpresaBy(idEmpresa);

            if (valid == null || valid.Nombre == null)
            {
                Console.WriteLine("[EmpresasService] -> no existe empresa id = " + idEmpresa);
                return(null);
            }
            Console.WriteLine("[EmpresasService] -> actualizando empresa...");
            try{
                if (empresa.Nombre != null)
                {
                    valid.Nombre = empresa.Nombre;
                }
                if (empresa.Direccion != null)
                {
                    valid.Direccion = empresa.Direccion;
                }
                if (empresa.Telefono != null)
                {
                    valid.Telefono = empresa.Telefono;
                }
                if (empresa.Web != null)
                {
                    valid.Web = empresa.Web;
                }
                using (DocumentosDbContext db = new DocumentosDbContext()) {
                    EntityEntry <Empresa> result = db.Empresas.Update(valid);
                    db.SaveChanges();
                    valid = result.Entity;
                }
                return(ModelMapper.Map(valid));
            } catch (Exception exception) {
                Console.WriteLine("[EmpresasService] -> se produjo un error error en el proceso con la base de datos");
                throw new DocumentosDatabaseException("Se produjo un error error en el proceso con la base de datos", exception);
            }
        }
 public int DeleteDocumento(string number)
 {
     try {
         List <Documento> toDelete = null;
         using (DocumentosDbContext db = new DocumentosDbContext()){
             toDelete = db.Documentos.Where(d => d.Numero == number).ToList();
         }
         if (toDelete.Count == 0)
         {
             Console.WriteLine("[DocumentosService] -> no se encontraron registro a eliminar");
             return(0);
         }
         using (DocumentosDbContext db = new DocumentosDbContext()) {
             db.Documentos.RemoveRange(toDelete);
             db.SaveChanges();
         }
         Console.WriteLine("[DocumentosService] -> registros eliminados: " + toDelete.Count);
         return(toDelete.Count);
     } catch (Exception exception) {
         Console.WriteLine("[DocumentosService] -> se produjo un error error en acceso a la base de datos");
         throw new DocumentosDatabaseException("Se produjo un error error en acceso a la base de datos", exception);
     }
 }
        public List <Usuario> ListAllUsuarios()
        {
            List <Usuario> usuarios = null;

            try{
                Console.WriteLine("[UsuariosService] -> listando todos los usuarios en base de datos");
                using (DocumentosDbContext db = new DocumentosDbContext()) {
                    usuarios = db.Usuarios.ToList();
                }
                string str = "[";
                foreach (Usuario o in usuarios)
                {
                    str += o.ToString();
                }
                str += "]";
                Console.WriteLine("[SectoresService] -> se encontraron: " + str);
                return(usuarios);
            } catch (Exception exception) {
                Console.WriteLine("[UsuariosService] -> se produjo un error error en acceso a la base de datos");
                Console.WriteLine("[UsuariosService] -> " + exception.GetType().ToString() + ": " + exception.Message);
                throw new DocumentosDatabaseException("Se produjo un error error en acceso a la base de datos", exception);
            }
        }
        public EmpresaDTO DeleteEmpresa(int idEmpresa)
        {
            Console.WriteLine("[EmpresasService] -> buscando empresa con id: " + idEmpresa);
            Empresa reg = FindEmpresaBy(idEmpresa);

            if (reg == null || reg.Nombre == null)
            {
                Console.WriteLine("[EmpresasService] -> no hay empresas con id: " + idEmpresa);
                return(null);
            }
            Console.WriteLine("[EmpresasService] -> se va a eliminar: " + reg.ToString());
            try{
                EmpresaDTO deleted = new EmpresaDTO();
                using (DocumentosDbContext db = new DocumentosDbContext()){
                    EntityEntry <Empresa> result = db.Empresas.Remove(reg);
                    db.SaveChanges();
                    deleted = ModelMapper.Map(result.Entity);
                }
                return(deleted);
            } catch (Exception exception) {
                Console.WriteLine("[EmpresasService] -> se produjo un error error en el proceso con la base de datos");
                throw new DocumentosDatabaseException("Se produjo un error error en el proceso con la base de datos", exception);
            }
        }