Example #1
0
        public ROLMENU GetMenuPadre(Guid idMenu, Guid idRol)
        {
            Guid? idPadre = null;
            MENU menu = null;
            ROLMENU result = null;
            try
            {
                using (DQBaseContext context=new DQBaseContext(ConnectionString))
                {
                    idPadre = context.MENU.FirstOrDefault(data => data.IDMENU == idMenu).IDMENUPADRE;
                    menu = context.MENU.FirstOrDefault(data => data.IDMENUPADRE == idPadre);
                }
                result = new ROLMENU
                {
                    IDMENU = menu.IDMENU,
                    IDROL = idRol,
                    IDROLMENU = Guid.NewGuid()
                }.MarkAsAdded();
            }
            catch (Exception)
            {

                throw;
            }
            return result;
        }
Example #2
0
 /// <summary>
 /// Obtiene la lista de menus
 /// </summary>
 /// <returns></returns>
 public List<ListaMenu> GetMenus()
 {
     List<ListaMenu> response = null;
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             response = (from menu1 in context.MENU
                         join menu2 in context.MENU on menu1.IDMENUPADRE equals menu2.IDMENU into leftMenu
                         from menus in leftMenu.DefaultIfEmpty()
                         orderby menu1.NIVELMENU
                         select new
                         {
                             Menu = menu1.DESCRIPCIONMENU,
                             IdMenu = menu1.IDMENU,
                             Padre = menus.DESCRIPCIONMENU,
                             Ruta = menu1.RUTA
                         }).ToList().Select(menu => new ListaMenu
                          {
                              Menu = menu.Menu,
                              Padre = menu.Padre,
                              Ruta = menu.Ruta,
                              IdMenu = menu.IdMenu,
                          }).ToList();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #3
0
 /// <summary>
 /// Obtiene la lista de corporaciones
 /// </summary>
 /// <returns>retorna una lista</returns>
 public List<CORPORACION> ObtenerCorporaciones()
 {
     List<CORPORACION> response = null;
     try
     {
         using (DQBaseContext ctx =new DQBaseContext(ConnectionString))
         {
             response = (from corporacion in ctx.CORPORACION
                         where corporacion.ESBORRADOCORPORACION == false
                         select corporacion).ToList();
             if (response != null)
                 response.Insert(0, new CORPORACION
                 {
                     IDCORPORACION=Guid.Empty,
                     NOMBRECORPORACION=string.Empty,
                     ABREVIATURACORPORACION=string.Empty
                 });
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #4
0
 /// <summary>
 /// Asigna los roles al usuario
 /// </summary>
 /// <param name="rolesAsignados">lista de roles a cargar</param>
 public void AsignaUsuarioRol(List<ROLUSUARIO> rolesAsignados)
 {
     try
     {
         Guid idUsuario = rolesAsignados[0].IDUSUARIO;
         using (DQBaseContext contex=new DQBaseContext(ConnectionString))
         {
             var roles = (from rol in contex.ROLUSUARIO
                          where rol.IDUSUARIO == idUsuario
                          select rol).ToList();
             if (roles != null && roles.Count > 0)
             {
                 roles.ForEach(rol =>
                 {
                     contex.ROLUSUARIO.DeleteObject(rol);
                 });
                 contex.SaveChanges();
             }
             rolesAsignados.ForEach(rol =>
             {
                 contex.ROLUSUARIO.ApplyChanges(rol);
             });
             contex.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #5
0
 /// <summary>
 /// Obtiene los movimientos del producto
 /// </summary>
 /// <returns></returns>
 public List<MovimientoProductos> GetMovimientoProductos()
 {
     List<MovimientoProductos> response = null;
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             response = (from mov in context.MOVIMIENTOSUBPRODUCTO
                         join sub in context.SUBPRODUCTO on mov.IDSUBPRODUCTO equals sub.IDSUBPRODUCTO
                         join lab in context.LABORATORIO on mov.IDLABORATORIO equals lab.IDLABORATORIO
                         join prod in context.PRODUCTO on sub.IDPRODUCTO equals prod.IDPRODUCTO
                         join his in context.HISTORICOPRECIO on mov.CODIGOSUBPRODUCTO equals his.CODIGOSUBPRODUCTO
                         where sub.ESBORRADOSUBPRODUCTO == false &&
                         lab.ESBORRADOLABORATORIO == false &&
                         prod.ESBORRADOPRODUCTO == false
                         orderby lab.NOMBRELABORATORIO
                         select new
                         {
                             lab.NOMBRELABORATORIO,
                             prod.NOMBREPRODUCTO,
                             sub.PRESENTACION,
                             mov.CODIGOPRODUCTOLABORATORIO,
                             his.PRECIO,
                             mov.FECHALANZAMIENTO,
                             mov.CODIGOSUBPRODUCTO,
                             his.IDHISTORICOPRECIO,
                             mov.ESNUEVO,
                             his,
                             mov
                         }).ToList().Select(data => new MovimientoProductos
                         {
                             CodigoProductoLaboratorio = data.CODIGOPRODUCTOLABORATORIO,
                             FechaLanzamiento = string.Format("{0:dd/MM/yyyy}", data.FECHALANZAMIENTO),
                             Laboratorio = data.NOMBRELABORATORIO,
                             NombreProducto = data.NOMBREPRODUCTO,
                             Precio = data.PRECIO,
                             PresentacionProducto = data.PRESENTACION,
                             IdHistorico = data.IDHISTORICOPRECIO,
                             IdMovimiento = data.CODIGOSUBPRODUCTO,
                             EsNuevo = data.ESNUEVO,
                             Movimiento=data.mov,
                             Historico=data.his
                         }).ToList();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #6
0
 /// <summary>
 /// Crea un nuevo catalogo
 /// </summary>
 /// <param name="catalogo">Catalogo a insertar</param>
 public void CrearCatalogo(CATALOGO catalogo)
 {
     try
     {
         using (DQBaseContext ctx = new DQBaseContext(ConnectionString))
         {
             ctx.CATALOGO.ApplyChanges(catalogo);
             ctx.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #7
0
 /// <summary>
 /// Crea o edita una corporacion
 /// </summary>
 /// <param name="corporacion">corporacion</param>
 public void SaveCorporacion(CORPORACION corporacion)
 {
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             context.CORPORACION.ApplyChanges(corporacion);
             context.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #8
0
        public List<ListaLaboratorio> GetLaboratorios()
        {
            List<ListaLaboratorio> response = null;
            try
            {
                using (DQBaseContext context=new DQBaseContext(ConnectionString))
                {
                    response = (from lab in context.LABORATORIO
                                join ubicacion in context.UBICACIONGEOGRAFICA on lab.IDUBICACION equals ubicacion.IDUBICACION
                                join corporacion in context.CORPORACION on lab.IDCORPORACION equals corporacion.IDCORPORACION into leftCorp
                                from corp in leftCorp.Where(x => x.ESBORRADOCORPORACION==false).DefaultIfEmpty()
                                where lab.ESBORRADOLABORATORIO == false && ubicacion.ESBORRADOUBICACION == false
                                select new
                                {
                                    lab.IDLABORATORIO,
                                    ubicacion.NOMBREUBICACION,
                                    NOMBRECORPORACION = string.IsNullOrEmpty(corp.NOMBRECORPORACION) ? string.Empty : corp.NOMBRECORPORACION,
                                    lab.NOMBRELABORATORIO,
                                    lab.ABREVIATURALABORATORIO,
                                    lab.DIRECCION,
                                    lab.DIRECCION2,
                                    lab.TELEFONO,
                                    lab.ORIGEN,
                                    lab.OBSERVACION
                                }).ToList().Select(data => new ListaLaboratorio
                                  {
                                      IdLaboratorio=data.IDLABORATORIO,
                                      Abreviatura=data.ABREVIATURALABORATORIO,
                                      Corporacion=data.NOMBRECORPORACION,
                                      Direccion=data.DIRECCION,
                                      Direccion2=data.DIRECCION2,
                                      Nombre=data.NOMBRELABORATORIO,
                                      Observacion=data.OBSERVACION,
                                      Origen=data.ORIGEN,
                                      Telefono=data.TELEFONO,
                                      Ubicacion=data.NOMBREUBICACION
                                  }).ToList();

                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return response;
        }
Example #9
0
 /// <summary>
 /// Obtiene todos los menus
 /// </summary>
 /// <returns></returns>
 public List<MENU> GetAllMenus()
 {
     List<MENU> response = null;
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             response = (from menu in context.MENU
                         select menu).ToList();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #10
0
        /// <summary>
        /// Metodo para autenticar un usuario en el sistema
        /// </summary>
        /// <param name="usuario">usuario que se va a autenticar</param>
        /// <exception cref="System.ArgumentNullException"/>
        /// <returns></returns>
        public UsuarioAutenticado Autenticar(USUARIO usuario)
        {
            UsuarioAutenticado response = null;
            try
            {
                if (usuario == null)
                    throw new ArgumentNullException("usuario");

                using (DQBaseContext ctx=new DQBaseContext(ConnectionString))
                {
                    var usuarioAutenticado = (from user in ctx.USUARIO
                                                  where user.USUARIO1 == usuario.USUARIO1 && user.CLAVE == usuario.CLAVE
                                                  select new
                                                  {
                                                      user,
                                                      rol=(from rolusuario in ctx.ROLUSUARIO
                                                            where rolusuario.IDUSUARIO==user.IDUSUARIO
                                                            select rolusuario).FirstOrDefault()
                                                  }
                                                  ).FirstOrDefault();

                    if (null == usuarioAutenticado) return null;

                    if (null == usuarioAutenticado.rol) return null;

                    List<MENU> menuUsuario = (from menu in ctx.MENU
                                              join rolmenu in ctx.ROLMENU on menu.IDMENU equals rolmenu.IDMENU
                                              join rol in ctx.ROL on rolmenu.IDROL equals rol.IDROL
                                              where usuarioAutenticado.rol.IDROL == rol.IDROL
                                              select menu).ToList();

                    if (null == menuUsuario) return null;

                    response = new UsuarioAutenticado
                    {
                        Usuario = usuarioAutenticado.user,
                        Menu = menuUsuario
                    };
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            return response;
        }
Example #11
0
 public List<GRUPOTERAPEUTICO> GetGrupos()
 {
     List<GRUPOTERAPEUTICO> response = null;
     try
     {
         using (DQBaseContext contex=new DQBaseContext(ConnectionString))
         {
             response = (from grupo in contex.GRUPOTERAPEUTICO
                         where grupo.ESBORRADOGRUPOTER == false
                         select grupo).ToList();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #12
0
 /// <summary>
 /// Busca un producto por codigo de laboratorio 
 /// </summary>
 /// <param name="codigoLaboratorio">codigo del laboratorio</param>
 /// <returns></returns>
 public MOVIMIENTOSUBPRODUCTO ObtenerSubProductoPorCodigoLab(string codigoLaboratorio)
 {
     MOVIMIENTOSUBPRODUCTO response = null;
     try
     {
         using (DQBaseContext ctx =new DQBaseContext(ConnectionString))
         {
             response = (from movimiento in ctx.MOVIMIENTOSUBPRODUCTO
                        where movimiento.CODIGOPRODUCTOLABORATORIO == codigoLaboratorio
                        select movimiento).FirstOrDefault();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #13
0
 /// <summary>
 /// Existe o no el codigo del laboratorio almacenado en la bdd
 /// </summary>
 /// <param name="codigoLaboratorio">Codigo del laboratorio</param>
 /// <returns></returns>
 public bool ExisteCodigoLab(string codigoLaboratorio)
 {
     bool response = false;
     try
     {
         using (DQBaseContext ctx = new DQBaseContext(ConnectionString))
         {
             response = (from movimiento in ctx.MOVIMIENTOSUBPRODUCTO
                         where movimiento.CODIGOPRODUCTOLABORATORIO == codigoLaboratorio
                         select movimiento).Any();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #14
0
 /// <summary>
 /// Obtiene las regiones
 /// </summary>
 /// <returns></returns>
 public List<UBICACIONGEOGRAFICA> GetRegiones()
 {
     List<UBICACIONGEOGRAFICA> response = null;
     try
     {
         using (DQBaseContext context = new DQBaseContext(ConnectionString))
         {
             response = (from ubicacion in context.UBICACIONGEOGRAFICA
                         where ubicacion.ESBORRADOUBICACION == false && ubicacion.CATEGORIAUBICACION == Constants.TIPO_UBICACION_REGION
                         select ubicacion).ToList();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #15
0
        /// <summary>
        /// Verifica si existen las ventas
        /// </summary>
        /// <param name="fecha">fecha de las ventas</param>
        /// <param name="idLaboratorio">Id del laboratorio</param>
        /// <returns></returns>
        public bool ExistenVentas(DateTime fecha, Guid idLaboratorio)
        {
            bool respuesta = false;
            try
            {
                using (DQBaseContext context = new DQBaseContext(ConnectionString))
                {
                    respuesta = (from venta in context.VENTA
                                 where venta.FECHA == fecha && venta.IDLABORATORIO == idLaboratorio
                                 select venta).Any();
                }
            }
            catch (Exception)
            {

                throw;
            }
            return respuesta;
        }
Example #16
0
 /// <summary>
 /// Obtiene un sun producto por su id
 /// </summary>
 /// <param name="idSubproducto">id del subproducto</param>
 /// <returns></returns>
 public SUBPRODUCTO ObtenerSubProductoById(Guid idSubproducto)
 {
     SUBPRODUCTO response = null;
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             response = (from subp in context.SUBPRODUCTO
                         where subp.IDSUBPRODUCTO == idSubproducto &&
                         subp.ESBORRADOSUBPRODUCTO == false
                         select subp).FirstOrDefault();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #17
0
 // <summary>
 /// Borra un catalogo
 /// </summary>
 /// <param name="catalogo">Catalogo a borrar</param>
 public void BorrarCatalogo(CATALOGO catalogo)
 {
     try
     {
         using (DQBaseContext ctx = new DQBaseContext(ConnectionString))
         {
             var dbquery = (from catalog in ctx.CATALOGO
                            where catalog.IDCATALAGO == catalogo.IDCATALAGO
                            select catalog).FirstOrDefault();
             if (dbquery == null) return;
             dbquery.ESBORRADOCATALOGO = catalogo.ESBORRADOCATALOGO;
             ctx.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #18
0
 /// <summary>
 /// Obtiene el id de la ubicacion de la corporacion
 /// </summary>
 /// <param name="nombreCorporacion">Nombre de la corporacion</param>
 /// <returns></returns>
 public Guid GetIdUbicacionCorporacion(string nombreCorporacion)
 {
     Guid result = Guid.Empty;
     CORPORACION selectedCorp = null;
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             selectedCorp = context.CORPORACION.FirstOrDefault(x => x.NOMBRECORPORACION == nombreCorporacion);
             if (selectedCorp != null)
                 result = selectedCorp.IdUbicacion.GetValueOrDefault();
         }
     }
     catch (Exception)
     {
         throw;
     }
     return result;
 }
Example #19
0
        public List<Ciclo> GetCiclos()
        {
            List<Ciclo> resultado = null;
            try
            {
                using (DQBaseContext context=new DQBaseContext(ConnectionString))
                {
                    resultado = (from ciclo in context.Ciclo
                                 where ciclo.EsBorrado == false
                                 orderby ciclo.FechaCiclo
                                 select ciclo).ToList();
                }
            }
            catch (Exception)
            {

                throw;
            }
            return resultado;
        }
Example #20
0
 /// <summary>
 /// Obtiene la lista de productos
 /// </summary>
 /// <returns></returns>
 public List<PRODUCTO> GetProducts()
 {
     List<PRODUCTO> response = null;
     try
     {
         using (DQBaseContext contex=new DQBaseContext(ConnectionString))
         {
             response = (from product in contex.PRODUCTO
                         where product.ESBORRADOPRODUCTO == false
                         orderby product.NOMBREPRODUCTO
                         select product).ToList();
             response.ForEach(producto => producto= producto.MarkAsUnchanged());
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #21
0
        /// <summary>
        /// Obtiene los laboratorios no asociados a una corporacion
        /// </summary>
        /// <returns></returns>
        public List<LABORATORIO> ObtenerLaboratorio()
        {
            List<LABORATORIO> response = new List<LABORATORIO>();
            try
            {
                response.Add(new LABORATORIO());
                using (DQBaseContext ctx =new DQBaseContext(ConnectionString))
                {
                    var query=(from laboratorio in ctx.LABORATORIO
                                where laboratorio.ESBORRADOLABORATORIO==false
                                orderby laboratorio.NOMBRELABORATORIO
                                select laboratorio).ToList();
                    response.AddRange(query);
                }

            }
            catch (Exception ex)
            {
                throw ex;
            }
            return response;
        }
Example #22
0
        /// <summary>
        /// Actualiza las ventas
        /// </summary>
        /// <param name="idLaboratorio">id del laboratorio</param>
        /// <param name="fechaVenta">fecha de la venta</param>
        public void ActualizarVentas(Guid idLaboratorio,DateTime fechaVenta)
        {
            try
            {
                using (DQBaseContext context=new DQBaseContext(ConnectionString))
                {
                    var ventas = (from venta in context.VENTA
                                  where venta.IDLABORATORIO == idLaboratorio && venta.FECHA==fechaVenta
                                  select venta).ToList();

                    ventas.ForEach(venta =>
                    {
                        venta.ESCORRECTO = true;
                        context.VENTA.ApplyChanges(venta);
                    });
                    context.SaveChanges();
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Example #23
0
 /// <summary>
 /// Obtiene la lista de subProductos mediante el id del producto
 /// </summary>
 /// <param name="productId">id del producto</param>
 /// <returns></returns>
 public List<SubProductos> GetSubProductsByProduct(Guid productId)
 {
     List<SubProductos> response = null;
     int i = 0;
     try
     {
         List<CATALOGO> aplicacion = ObtenerCatalogo(Catalogos.APLICACIONPRODUCTO);
         List<CATALOGO> formaProducto = ObtenerCatalogo(Catalogos.FORMAPRODUCTO);
         List<CATALOGO> tipoMercado = ObtenerCatalogo(Catalogos.TIPOMERCADO);
         List<CATALOGO> tipoProducto = ObtenerCatalogo(Catalogos.TIPOPRODUCTO);
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             response = (from subProducto in context.SUBPRODUCTO
                         join grupo in context.GRUPOTERAPEUTICO on subProducto.IDGRUPO equals grupo.IDGRUPO
                         where subProducto.ESBORRADOSUBPRODUCTO == false && grupo.ESBORRADOGRUPOTER == false &&
                         subProducto.IDPRODUCTO == productId
                         select new
                         {
                             grupo.NOMBREGRUPOTER,
                             subProducto.IDPRODUCTO,
                             subProducto.IDSUBPRODUCTO,
                             subProducto.IDAPLICACION,
                             subProducto.IDFORMAPROD,
                             subProducto.IDTIPOMERCADO,
                             subProducto.IDTIPOPRODUCTO,
                             subProducto.PRESENTACION,
                             subProducto.CONCENTRACION,
                             subProducto.UNIDAD,
                             subProducto.CANTIDAD,
                             subProducto.PRINCIPIOACTIVO,
                             subProducto.INDICACIONESDEUSO,
                             subProducto.ESBORRADOSUBPRODUCTO
                         }).ToList().Select(data => new SubProductos
                         {
                             Aplicacion = aplicacion.FirstOrDefault(x => x.IDCATALAGO == data.IDAPLICACION).DESCRIPCIONCATALOGO,
                             TipoMercado = tipoMercado.FirstOrDefault(x => x.IDCATALAGO == data.IDTIPOMERCADO).DESCRIPCIONCATALOGO,
                             TipoProducto = tipoProducto.FirstOrDefault(x => x.IDCATALAGO  == data.IDTIPOPRODUCTO).DESCRIPCIONCATALOGO,
                             Forma = formaProducto.FirstOrDefault(x => x.IDCATALAGO == data.IDFORMAPROD).DESCRIPCIONCATALOGO,
                             Cantidad = data.CANTIDAD.ToString(),
                             Concentracion = data.CONCENTRACION.ToString(),
                             GrupoTerapeutico =data.NOMBREGRUPOTER,
                             Presentacion = data.PRESENTACION,
                             PrincipioActivo =data.PRINCIPIOACTIVO,
                             Unidad = data.UNIDAD,
                             IdSubProducto=data.IDSUBPRODUCTO,
                             IdProducto=data.IDPRODUCTO,
                             IndicacionesUso=data.INDICACIONESDEUSO,
                             EsBorrado=data.ESBORRADOSUBPRODUCTO,
                             Orden=i++
                         }).ToList();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #24
0
 /// <summary>
 /// Almacena o edita un produto
 /// </summary>
 /// <param name="producto">Producto</param>
 public void SaveProducto(PRODUCTO producto)
 {
     try
     {
         using (DQBaseContext context =new DQBaseContext(ConnectionString))
         {
             context.PRODUCTO.ApplyChanges(producto);
             context.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #25
0
 /// <summary>
 /// Guarda la informacion del movimiento producto
 /// </summary>
 /// <param name="movimiento">movimiento</param>
 public void SaveMovimientoProducto(MOVIMIENTOSUBPRODUCTO movimiento)
 {
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             context.MOVIMIENTOSUBPRODUCTO.ApplyChanges(movimiento);
             context.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #26
0
 /// <summary>
 /// Edita historico precios
 /// </summary>
 /// <param name="historico">historico</param>
 public void SaveHistorico(HISTORICOPRECIO historico)
 {
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             context.HISTORICOPRECIO.ApplyChanges(historico);
             context.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #27
0
 public void SaveLaboratorio(LABORATORIO laboratorio)
 {
     try
     {
         using (DQBaseContext context=new DQBaseContext())
         {
             context.LABORATORIO.ApplyChanges(laboratorio);
             context.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }
Example #28
0
 public List<Ubicacion> GetUbicacionCiudades()
 {
     List<Ubicacion> response = null;
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             response = (from ubicacion in context.UBICACIONGEOGRAFICA
                         join ubicacionregion in context.UBICACIONGEOGRAFICA on ubicacion.IDPADRE equals ubicacionregion.IDUBICACION into left
                         from region in left.Where(x => x.ESBORRADOUBICACION == false)
                         where ubicacion.ESBORRADOUBICACION == false && ubicacion.CATEGORIAUBICACION == Constants.TIPO_UBICACION_CIUDAD
                         && ubicacion.IDPADRE != null
                         orderby ubicacion.NOMBREUBICACION
                         select new
                         {
                             IdRegion = ubicacion.IDUBICACION,
                             NombreRegion = ubicacion.NOMBREUBICACION,
                             Region = region.NOMBREUBICACION
                         }).ToList().Select(data => new Ubicacion
                         {
                             IdUbicacion = data.IdRegion,
                             Nombre = data.NombreRegion,
                             Region = data.Region
                         }).ToList();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #29
0
 /// <summary>
 /// Obtiene los laboratorios asociados a una corporacion
 /// </summary>
 /// <param name="corporacion"></param>
 /// <returns></returns>
 public List<LABORATORIO> ObtenerLaboratorio(string nombreCorporacion)
 {
     List<LABORATORIO> response = null;
     try
     {
         using (DQBaseContext ctx = new DQBaseContext(ConnectionString))
         {
             response = (from laboratorio in ctx.LABORATORIO
                         join corporacion in ctx.CORPORACION on laboratorio.IDCORPORACION equals corporacion.IDCORPORACION
                         where laboratorio.ESBORRADOLABORATORIO == false
                         && corporacion.NOMBRECORPORACION == nombreCorporacion
                         select laboratorio).ToList();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
     return response;
 }
Example #30
0
 /// <summary>
 /// Inserta o edita una ubicacion
 /// </summary>
 /// <param name="ubicacion">Ubicacion geografica</param>
 public void SaveUbicacion(UBICACIONGEOGRAFICA ubicacion)
 {
     try
     {
         using (DQBaseContext context=new DQBaseContext(ConnectionString))
         {
             context.UBICACIONGEOGRAFICA.ApplyChanges(ubicacion);
             context.SaveChanges();
         }
     }
     catch (Exception ex)
     {
         throw ex;
     }
 }