Пример #1
0
        /// <summary>
        /// Método para actualizar
        /// <param name="pBanner">Objeto de tipo E_BANNER con datos a actualizar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE Editar(E_BANNER pBanner)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    ObjectParameter RET_NUMEROERROR   = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                    ObjectParameter RET_MENSAJEERROR  = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                    ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));


                    context.SP_BANNER(pBanner.IdBanner, pBanner.Nombre, pBanner.IdProducto, pBanner.Fotografia,
                                      pBanner.IdPersonaModifica, pBanner.Estatus, "U",
                                      RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);

                    E_MENSAJE vMensaje = new E_MENSAJE {
                        RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString()
                    };
                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #2
0
        /// <summary>
        /// Método para actualizar locales
        /// <param name="pDireccion">Objeto de tipo E_LOCAL con datos a actualizar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE Editar(E_LOCAL pLocal)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    ObjectParameter RET_NUMEROERROR   = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                    ObjectParameter RET_MENSAJEERROR  = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                    ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));


                    context.SP_LOCAL(pLocal.IdLocal, pLocal.Nombre, pLocal.Referencias, pLocal.Latitud, pLocal.Longitud,
                                     pLocal.Fotografia, pLocal.Calle, pLocal.Colonia, pLocal.NoExt, pLocal.NoInt,
                                     pLocal.Costo.IdCosto, pLocal.TipoLocal.IdTipoLocal, pLocal.IdPersonaModifica, pLocal.IdPersonaResponsable, pLocal.Estatus, "U",
                                     RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);

                    E_MENSAJE vMensaje = new E_MENSAJE {
                        RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString()
                    };
                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #3
0
        /// <summary>
        /// Método para eliminar productos favoritos
        /// <param name="pIdPersona">Objeto de tipo E_PRODUCTO con datos a insertar</param>
        /// <param name="pIdProducto">Objeto de tipo E_PRODUCTO con datos a insertar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE EliminarProductoFavorito(int pIdPersona, int pIdProducto)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    /*ObjectParameter RET_NUMEROERROR = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                     * ObjectParameter RET_MENSAJEERROR = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                     * ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));
                     *
                     * var productos = context.SP_PRODUCTO(pIdProducto, null, null, null,
                     *                   null, null, null, pIdPersona, null, "EPF",
                     *                   RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);
                     *
                     * var resultado = context.SaveChanges();
                     *
                     * E_MENSAJE vMensaje = new E_MENSAJE { RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString() };
                     * return vMensaje;*/

                    E_MENSAJE vMensaje       = new E_MENSAJE();
                    var       existeRegistro = (from s in context.R_PERSONA_PRODUCTO_FAVORITO
                                                where
                                                s.id_persona == pIdPersona && s.id_producto == pIdProducto
                                                select s).ToList <R_PERSONA_PRODUCTO_FAVORITO>().FirstOrDefault();

                    if (existeRegistro == null)
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = -200, RET_MENSAJEERROR = "No existe este producto como favorito.", RET_VALORDEVUELTO = "Ya existe este producto como favorito."
                        };
                    }
                    else
                    {
                        context.R_PERSONA_PRODUCTO_FAVORITO.Remove
                            (existeRegistro);
                        var resultado = context.SaveChanges();

                        if (resultado <= 0)
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = -100, RET_MENSAJEERROR = "No se pudo eliminar, intente más tarde", RET_VALORDEVUELTO = "No se pudo eliminar, intente más tarde"
                            }
                        }
                        ;
                        else
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = 0, RET_MENSAJEERROR = "Eliminado", RET_VALORDEVUELTO = "Eliminado"
                            }
                        };
                    }

                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Método para actualizar estatus direcciones
        /// <param name="pDireccion">Objeto de tipo E_DIRECCION con datos a actualizar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE ActualizaEstatusDireccion(E_DIRECCION pDireccion)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    ObjectParameter RET_NUMEROERROR   = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                    ObjectParameter RET_MENSAJEERROR  = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                    ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));


                    context.SP_DIRECCION(pDireccion.IdDireccion, pDireccion.Nombre, pDireccion.Calle,
                                         pDireccion.Colonia, pDireccion.Descripcion, pDireccion.NoExt,
                                         pDireccion.NoInt, pDireccion.Latitud, pDireccion.Longitud,
                                         pDireccion.IdPersona, pDireccion.IdPersonaAlta, pDireccion.Estatus, pDireccion.Predeterminada, "E",
                                         RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);

                    E_MENSAJE vMensaje = new E_MENSAJE {
                        RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString()
                    };
                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #5
0
        /// <summary>
        /// Método para consultar pedido actual
        /// <param name="pIdPersonaPide">Id de la persona que pide</param>
        /// <param name="pIdPersonaEntrega">Id de la persona que entrega</param>
        /// <returns> Objeto tipo List<E_PEDIDO> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_PEDIDO> > ConsultarViajeActual(int?pIdPersonaPide = null, int?pIdPersonaEntrega = null)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    var pedidos = await(from s in context.M_PEDIDO
                                        where
                                        //s.id_persona_pide == pIdPersonaPide
                                        //s.tipo_pedido == 1 &&  //Pedidos normales
                                        (pIdPersonaPide == null || (pIdPersonaPide != null && s.id_persona_pide == pIdPersonaPide)) &&
                                        (pIdPersonaEntrega == null || (pIdPersonaEntrega != null && s.id_persona_entrega == pIdPersonaEntrega)) &&
                                        (s.id_estatus == 1 || s.id_estatus == 2 || s.id_estatus == 3 || s.id_estatus == 4 || s.id_estatus == 8 || s.id_estatus == 9 || s.id_estatus == 10)
                                        //&& (s.id_estatus == 1 || s.id_estatus == 2 || s.id_estatus == 3 || s.id_estatus == 4)
                                        select s).ToListAsync <M_PEDIDO>();


                    return(await ProcesaListaPedidos(pedidos));
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Método para consultar tipos de locales
        /// <param name="pIdTipoLocal">Id del tipo de local a consultar</param>
        /// <returns> Objeto tipo List<E_TIPO_LOCAL> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_TIPO_LOCAL> > ConsultarTipoLocal(byte?pSoloActivos = null, int?pIdTipoLocal = null)
        {
            try
            {
                var listaTipoLocal = new List <E_TIPO_LOCAL>();
                using (context = new ViajesEntities())
                {
                    var tiposLocal = await(from s in context.CTL_TIPO_LOCAL
                                           where
                                           (pIdTipoLocal == null || (pIdTipoLocal != null && s.id_tipo_local == pIdTipoLocal)) &&
                                           (pSoloActivos == null || (pSoloActivos != null && s.estatus == pSoloActivos))
                                           select s).ToListAsync <CTL_TIPO_LOCAL>();

                    foreach (var tipoLocal in tiposLocal)
                    {
                        listaTipoLocal.Add(new E_TIPO_LOCAL
                        {
                            IdTipoLocal = tipoLocal.id_tipo_local,
                            Nombre      = tipoLocal.nombre,
                            Descripcion = tipoLocal.descripcion,
                            Fotografia  = tipoLocal.fotografia
                        });
                    }

                    return(listaTipoLocal);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Método para consultar detalle de pedidos
        /// <param name="pIdLocal">Identificador del local</param>
        /// <returns> Objeto tipo List<E_DETALLE_PEDIDO> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_PEDIDO> > ConsultarPedidosByIdLocal(int pIdLocal)
        {
            try
            {
                //var listaDetallePedidos = new List<E_DETALLE_PEDIDO>();
                using (context = new ViajesEntities())
                {
                    var pedidos = await(from s in context.M_DETALLE_PEDIDO
                                        join p in context.M_PEDIDO on s.id_pedido equals p.id_pedido
                                        where
                                        s.id_local == pIdLocal
                                        group p by p.id_pedido into pe
                                        select new E_PEDIDO
                    {
                        IdPedido = pe.Key
                    }).ToListAsync();

                    return(pedidos);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #8
0
        /// <summary>
        /// Método para realizar crear una persona
        /// <param name="pPersona">Objeto de tipo E_PERSONA con datos de la persona a insertar</param>
        /// /// <param name="pAcceso">Objeto de tipo E_ACCESO_PERSONA con datos para inicio de sesión</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE CreaPersona(E_PERSONA pPersona, E_ACCESO_PERSONA pAcceso)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    ObjectParameter RET_ID_PERSONA    = new ObjectParameter("RET_ID_PERSONA", typeof(string));
                    ObjectParameter RET_NUMEROERROR   = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                    ObjectParameter RET_MENSAJEERROR  = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                    ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));


                    context.SP_PERSONA(pPersona.IdPersona, pPersona.Nombre, pPersona.Telefono, pPersona.Fotografia,
                                       pAcceso.Email, pAcceso.Password, pAcceso.TipoUsuario, pAcceso.TokenFirebase, "U",
                                       null, null, null, null, null, null, null, pAcceso.ClavePassword, "I", pPersona.IdPersonaMod,
                                       RET_ID_PERSONA, RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);

                    E_MENSAJE vMensaje = new E_MENSAJE {
                        RET_ID_PERSONA = int.Parse(RET_ID_PERSONA.Value.ToString()), RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString()
                    };
                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Método para insertar coordenadas de conductores activos
        /// <param name="pDatos">Objeto de tipo E_COORDENADAS_CONDUCTOR con datos a insertar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE AgregarCoordenadas(E_COORDENADAS_CONDUCTOR pDatos)
        {
            try
            {
                E_MENSAJE vMensaje;
                using (context = new ViajesEntities())
                {
                    var coordenadas = context.Set <TBL_COORDENADAS_CONDUCTOR>();
                    coordenadas.Add(new TBL_COORDENADAS_CONDUCTOR {
                        id_coordenada = Guid.NewGuid(), id_pedido = pDatos.IdPedido, id_persona = pDatos.IdPersona, longitud = pDatos.Longitud, latitud = pDatos.Latitud, fecha = DateTime.Now
                    });

                    if (context.SaveChanges() > 0)
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = 0, RET_MENSAJEERROR = "Insertado correctamente", RET_VALORDEVUELTO = "Insertado correctamente"
                        }
                    }
                    ;
                    else
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = -1000, RET_MENSAJEERROR = "No se pudo insertar la coordenada", RET_VALORDEVUELTO = "No se pudo insertar la coordenada"
                        }
                    };

                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #10
0
        /// <summary>
        /// Método para consultar personas
        /// <param name="pIdPersona">Id del producto a consultar</param>
        /// <param name="pSoloActivos">Indica si deben de consultarse solo personas activas</param>
        /// <param name="pIdsTipoUsuario">Identificadores de idtipopersona separados por coma</param>
        /// <param name="pToken">Token de acceso buscado</param>
        /// <returns> Objeto tipo List<E_PERSONA> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_PERSONA> > Consultar(int?pIdPersona = null, byte?pSoloActivos = null, string pIdsTipoUsuario = null, string pToken = null)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    byte[] idsTipoUsuario;

                    if (!string.IsNullOrEmpty(pIdsTipoUsuario))
                    {
                        idsTipoUsuario = Array.ConvertAll(pIdsTipoUsuario.Split(','), byte.Parse);
                    }

                    var personas = await(from p in context.CTL_PERSONA
                                         join acceso in context.CTL_ACCESO_PERSONA on p.id_persona equals acceso.id_persona

                                         where
                                         (pIdPersona == null || (pIdPersona != null && p.id_persona == pIdPersona)) &&
                                         (pSoloActivos == null || (pSoloActivos != null && p.estatus == pSoloActivos)) &&
                                         (pIdsTipoUsuario == null || (pIdsTipoUsuario != null && pIdsTipoUsuario.Contains(acceso.tipo_usuario.ToString()))) &&
                                         (pToken == null || (pToken != null && acceso.clave_password == pToken))
                                         select p).ToListAsync <CTL_PERSONA>();

                    return(await procesaPersonas(personas));
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #11
0
        /// <summary>
        /// Método para insertar personas
        /// <param name="pPersona">Objeto de tipo E_PERSONA con datos a insertar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE Agregar(E_PERSONA pPersona)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    ObjectParameter RET_NUMEROERROR   = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                    ObjectParameter RET_MENSAJEERROR  = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                    ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));


                    /*context.SP_PRODUCTO(pProducto.IdProducto, pProducto.Nombre, pProducto.Descripcion, pProducto.Precio,
                     *                   pProducto.Fotografia, pProducto.IdLocal, pProducto.IdPersonaAlta, pProducto.Estatus, "I",
                     *                   RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);*/

                    E_MENSAJE vMensaje = new E_MENSAJE {
                        RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString()
                    };
                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Método para consultar coordenadas de un conductor
        /// <param name="pIdPersona">Id del conductor</param>
        /// <param name="pIdPedido">Id del pedido en caso de existir</param>
        /// <returns> Objeto tipo List<E_COORDENADAS_CONDUCTOR> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_COORDENADAS_CONDUCTOR> > ConsultarCoordenadas(int?pIdPersona = null, Guid?pIdPedido = null)
        {
            try
            {
                List <E_COORDENADAS_CONDUCTOR> listaCoordenadas = new List <E_COORDENADAS_CONDUCTOR>();
                using (context = new ViajesEntities())
                {
                    var coordenadas = await(from s in context.TBL_COORDENADAS_CONDUCTOR
                                            where
                                            (pIdPersona == null || (pIdPersona != null && s.id_persona == pIdPersona)) &&
                                            (pIdPedido == null || (pIdPedido != null && s.id_pedido == pIdPedido))
                                            select s).OrderByDescending(c => c.fecha).ToListAsync <TBL_COORDENADAS_CONDUCTOR>();


                    foreach (var coordenada in coordenadas)
                    {
                        listaCoordenadas.Add(new E_COORDENADAS_CONDUCTOR
                        {
                            IdCoordenada = coordenada.id_coordenada,
                            IdPedido     = coordenada.id_pedido,
                            IdPersona    = coordenada.id_persona,
                            Fecha        = coordenada.fecha,
                            Latitud      = coordenada.latitud,
                            Longitud     = coordenada.longitud
                        });
                    }

                    return(listaCoordenadas);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #13
0
        /// <summary>
        /// Método para agregar una relación de cliente openpay con cliente interno
        /// <param name="pIdPersona">Id de la persona a existente</param>
        /// /// <param name="pIdCustomerOpenPay">Id generado por OpenPay para el cliente.</param>
        /// <returns> Objeto tipo E_MENSAJE con el resultado de la operación </returns>
        /// </summary>
        public E_MENSAJE AgregarClienteOpenPay(int pIdPersona, string pIdCustomerOpenPay)
        {
            try
            {
                E_MENSAJE vMensaje;
                using (context = new ViajesEntities())
                {
                    var coordenadas = context.Set <R_PERSONA_OPENPAY>();
                    coordenadas.Add(new R_PERSONA_OPENPAY {
                        id_persona = pIdPersona, id_customer = pIdCustomerOpenPay
                    });

                    if (context.SaveChanges() > 0)
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = 0, RET_MENSAJEERROR = "Insertado correctamente", RET_VALORDEVUELTO = "Insertado correctamente"
                        }
                    }
                    ;
                    else
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = -1000, RET_MENSAJEERROR = "No se pudo insertar la coordenada", RET_VALORDEVUELTO = "No se pudo insertar la coordenada"
                        }
                    };

                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Método para consultar detalle de pedidos personalizado
        /// <param name="pIdDetallePedido">Folio del pedido</param>
        /// <param name="pIdPedido">Id del pedido a consultar</param>
        /// <returns> Objeto tipo E_PEDIDO_PERSONALIZADO_DETALLE con los datos solicitados </returns>
        /// </summary>
        public async Task <E_PEDIDO_PERSONALIZADO_DETALLE> Consultar(Guid?pIdDetallePedido = null, Guid?pIdPedido = null)
        {
            try
            {
                //var listaDetallePedidos = new List<E_DETALLE_PEDIDO>();
                using (context = new ViajesEntities())
                {
                    var detalles = await(from s in context.M_DETALLE_PEDIDO_PERSONALIZADO
                                         where
                                         (pIdPedido == null || (pIdPedido != null && s.id_pedido == pIdPedido)) &&
                                         (pIdDetallePedido == null || (pIdDetallePedido != null && s.id_detalle_pedido_personalizado == pIdDetallePedido))
                                         select new E_PEDIDO_PERSONALIZADO_DETALLE
                    {
                        IdPedido = s.id_pedido,
                        IdDetallePedidoPersonalizado = s.id_detalle_pedido_personalizado,
                        Direccion      = s.direccion,
                        Latitud        = s.latitud,
                        LimiteInferion = s.limite_inferior,
                        LimiteSuperior = s.limite_superior,
                        Longitud       = s.longitud,
                        NombreLocal    = s.nombre_local,
                        Pedido         = s.pedido,
                        Referencias    = s.referencias
                    }).ToListAsync();

                    return(detalles.FirstOrDefault());
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #15
0
        /// <summary>
        /// Método para insertar un nuevo escaneo del código qr de descarga de app-
        /// <param name="pDatos">Objeto de tipo E_QR_TIENDA con datos a insertar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public async Task <E_MENSAJE> AgregarVisitaQR(E_QR_TIENDA pDatos)
        {
            try
            {
                E_MENSAJE vMensaje;
                using (context = new ViajesEntities())
                {
                    var coordenadas = context.Set <TBL_QR_TIENDA>();
                    coordenadas.Add(new TBL_QR_TIENDA {
                        id_qr = Guid.NewGuid(), dispositivo = pDatos.Dispositivo, ip = pDatos.Ip, latitud = pDatos.Latitud, longitud = pDatos.Longitud, aplicacion = pDatos.Aplicacion, fecha_alta = DateTime.Now
                    });

                    if (await context.SaveChangesAsync() > 0)
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = 0, RET_MENSAJEERROR = "Insertado correctamente", RET_VALORDEVUELTO = "Insertado correctamente"
                        }
                    }
                    ;
                    else
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = -1000, RET_MENSAJEERROR = "No se pudo insertar la visita QR", RET_VALORDEVUELTO = "No se pudo insertar la visita QR"
                        }
                    };

                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Método para actualizar conductor
        /// <param name="pPersona">Objeto de tipo E_PERSONA con datos a actualizar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE Editar(E_PERSONA pPersona)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    ObjectParameter RET_ID_PERSONA    = new ObjectParameter("RET_ID_PERSONA", typeof(string));
                    ObjectParameter RET_NUMEROERROR   = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                    ObjectParameter RET_MENSAJEERROR  = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                    ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));


                    context.SP_PERSONA(pPersona.IdPersona, pPersona.Nombre, pPersona.Telefono, pPersona.Fotografia,
                                       pPersona.Acceso.Email, pPersona.Acceso.Password, pPersona.Acceso.TipoUsuario, pPersona.Acceso.TokenFirebase, pPersona.Sexo,
                                       pPersona.Conductor.Colonia, pPersona.Conductor.Calle, pPersona.Conductor.NoExt, pPersona.Conductor.NoInt, pPersona.Conductor.NoLicencia, pPersona.Conductor.NoPlacas, pPersona.Conductor.Tipo,
                                       pPersona.Acceso.ClavePassword, "U", pPersona.IdPersonaMod, RET_ID_PERSONA, RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);

                    E_MENSAJE vMensaje = new E_MENSAJE {
                        RET_ID_PERSONA = int.Parse(RET_ID_PERSONA.Value.ToString()), RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString()
                    };
                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #17
0
        /// <summary>
        /// Método para consultar estatus del pedido
        /// <param name="pIdEstatus">Folio del pedido</param>
        /// <returns> Objeto tipo List<E_ESTATUS_PEDIDO> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_ESTATUS_PEDIDO> > Consultar(int?pIdEstatus = null)
        {
            try
            {
                var listaEstatus = new List <E_ESTATUS_PEDIDO>();
                using (context = new ViajesEntities())
                {
                    var estatusQuery = await(from s in context.CTL_ESTATUS_PEDIDO
                                             where
                                             (pIdEstatus == null || (pIdEstatus != null && s.id_estatus == pIdEstatus))
                                             select s).ToListAsync <CTL_ESTATUS_PEDIDO>();

                    foreach (var estatus in estatusQuery)
                    {
                        listaEstatus.Add(new E_ESTATUS_PEDIDO
                        {
                            IdEstatus   = estatus.id_estatus,
                            Nombre      = estatus.nombre,
                            Descripcion = estatus.descripcion
                        });
                    }

                    return(listaEstatus);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Método para consultar locales
        /// <param name="pIdCosto">Id del costo a consultar</param>
        /// <param name="pSoloActivos">Indica consultar solo activos o no</param>
        /// <returns> Objeto tipo List<E_COSTO> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_COSTO> > Consultar(int?pIdCosto = null, byte?pSoloActivos = null)
        {
            try
            {
                var listaCostos = new List <E_COSTO>();
                using (context = new ViajesEntities())
                {
                    var costos = await(from s in context.CTL_COSTO
                                       where
                                       (pIdCosto == null || (pIdCosto != null && s.id_costo == pIdCosto)) &&
                                       (pSoloActivos == null || (pSoloActivos != null && s.estatus == pSoloActivos))

                                       select s).ToListAsync <CTL_COSTO>();

                    foreach (var costo in costos)
                    {
                        listaCostos.Add(new E_COSTO
                        {
                            IdCosto     = costo.id_costo,
                            Nombre      = costo.nombre,
                            Descripcion = costo.descripcion,
                            Estatus     = costo.estatus
                        });
                    }
                    return(listaCostos);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #19
0
        /// <summary>
        /// Método para cancelar pedidos
        /// <param name="pPedido">Objeto de tipo E_PEDIDO con datos a cancelar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE Cancelar(E_PEDIDO pPedido)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    ObjectParameter RET_NUMEROERROR   = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                    ObjectParameter RET_MENSAJEERROR  = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                    ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));


                    context.SP_PEDIDO(pPedido.IdPedido, pPedido.PersonaPide.IdPersona, pPedido.DireccionEntrega.IdDireccion,
                                      pPedido.PersonaEntrega.IdPersona, pPedido.Observaciones, pPedido.Folio,
                                      pPedido.IdMetodoPago, pPedido.Estatus.IdEstatus, null, "C", pPedido.ReferenciaPago,
                                      pPedido.CostoEnvio, pPedido.TipoPedido, pPedido.Propina, pPedido.IdEstatusFactura, pPedido.Iva,
                                      RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);

                    E_MENSAJE vMensaje = new E_MENSAJE {
                        RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString()
                    };
                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #20
0
        /// <summary>
        /// Método para consultar metodos de pago
        /// <param name="pId">Id del pedido a consultar</param>
        /// <param name="SoloActivos">Indica consultar solo activos o no</param>
        /// <returns> Objeto tipo List<E_METODO_PAGO> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_METODO_PAGO> > Consultar(int?pId = null, int?SoloActivos = null)
        {
            try
            {
                var listaMetodosPago = new List <E_METODO_PAGO>();
                using (context = new ViajesEntities())
                {
                    var metodosPago = await(from s in context.CTL_METODO_PAGO
                                            where
                                            (pId == null || (pId != null && s.id_metodo_pago == pId)) &&
                                            (SoloActivos == null || (SoloActivos != null && s.estatus == SoloActivos))
                                            select s).ToListAsync <CTL_METODO_PAGO>();

                    foreach (var metodoPago in metodosPago)
                    {
                        listaMetodosPago.Add(new E_METODO_PAGO
                        {
                            IdMetodoPago  = metodoPago.id_metodo_pago,
                            Nombre        = metodoPago.nombre,
                            Descripcion   = metodoPago.descripcion,
                            Estatus       = metodoPago.estatus,
                            IdPersonaAlta = metodoPago.id_persona_alta,
                        });
                    }

                    return(listaMetodosPago);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #21
0
        /// <summary>
        /// Método para consultar  extras de productos
        /// <param name="pIdProducto">Id del producto</param>
        /// <returns> Objeto tipo List<E_EXTRAS_PRODUCTO> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_EXTRAS_PRODUCTO> > ConsultaExtrasPedidoByIdDetalle(Guid pIdDetalle)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    var extras = await(from s in context.CTL_EXTRAS_PRODUCTO
                                       join l in context.R_DETALLE_PEDIDO_EXTRAS on s.id_extra equals l.id_extra
                                       where
                                       l.id_detalle_pedido == pIdDetalle
                                       select new E_EXTRAS_PRODUCTO
                    {
                        IdExtra    = s.id_extra,
                        Precio     = l.precio,
                        Nombre     = s.nombre,
                        Estatus    = s.estatus,
                        IdProducto = s.id_producto
                    }).ToListAsync();

                    //return procesaExtras(extras);
                    return(extras);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
        /// <summary>
        /// Método para consultar conductores
        /// <param name="SoloActivos">Consultar solo repartidores activos o no</param>
        /// <param name="pIdPersona">Id del conductor  a consultar</param>
        /// <returns> Objeto tipo List<E_PERSONA> con los datos solicitados </returns>
        /// </summary>
        public async Task <List <E_PERSONA> > Consultar(byte?SoloActivos = null, int?pIdPersona = null)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    var conductores = await(from s in context.CTL_PERSONA
                                            join ap in context.CTL_ACCESO_PERSONA on s.id_persona equals ap.id_persona
                                            join c in context.CTL_CONDUCTOR on s.id_persona equals c.id_persona
                                            where
                                            (pIdPersona == null || (pIdPersona != null && s.id_persona == pIdPersona)) &&
                                            (SoloActivos == null || (SoloActivos != null && s.estatus == SoloActivos)) &&
                                            ap.tipo_usuario == 2
                                            select new E_PERSONA
                    {
                        IdPersona  = s.id_persona,
                        Edad       = s.edad,
                        Nombre     = s.nombre,
                        Fotografia = s.fotografia,
                        Sexo       = s.sexo,
                        Telefono   = s.telefono,
                        Estatus    = s.estatus,
                        Acceso     = new E_ACCESO_PERSONA {
                            IdPersona          = ap.id_persona,
                            Email              = ap.email,
                            ClavePassword      = ap.clave_password,
                            FechaClavePassword = ap.fecha_clave_password,
                            Password           = ap.password,
                            TipoUsuario        = ap.tipo_usuario,
                            TokenFirebase      = ap.token_firebase
                        },
                        Conductor = new E_CONDUCTOR {
                            Calle      = c.calle,
                            Colonia    = c.colonia,
                            IdPersona  = c.id_persona,
                            NoExt      = c.no_ext,
                            NoInt      = c.no_int,
                            NoLicencia = c.no_licencia,
                            NoPlacas   = c.no_placas,
                            Tipo       = c.id_tipo ?? 0
                        }
                    }
                                            ).ToListAsync();

                    return(conductores);
                    //return ProcesaListaConductores(conductores);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #23
0
        /// <summary>
        /// Método para insertar pedidos personalizados
        /// <param name="pPedido">Objeto de tipo E_PEDIDO con datos a insertar</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE AgregarPersonalizado(E_PEDIDO_PERSONALIZADO pPedido)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    pPedido.IdPedido = Guid.NewGuid();

                    XElement xmlPedido = new XElement("PEDIDO_PERSONALIZADO");

                    //foreach (var detalle in pPedido.Detalle)
                    //{

                    XElement xDetallePedido = new XElement("DETALLE");
                    xDetallePedido.Add(
                        new XAttribute("ID_DETALLE_PEDIDO_PERSONALIZADO", Guid.NewGuid()),
                        new XAttribute("ID_PEDIDO", pPedido.IdPedido),
                        new XAttribute("NOMBRE_LOCAL", pPedido.Detalle.NombreLocal),
                        new XAttribute("DIRECCION", pPedido.Detalle.Direccion),
                        new XAttribute("REFERENCIAS", pPedido.Detalle.Referencias),
                        new XAttribute("PEDIDO", pPedido.Detalle.Pedido),
                        new XAttribute("LATITUD", pPedido.Detalle.Latitud),
                        new XAttribute("LONGITUD", pPedido.Detalle.Longitud),
                        new XAttribute("LIMITE_INFERIOR", pPedido.Detalle.LimiteInferion),
                        new XAttribute("LIMITE_SUPERIOR", pPedido.Detalle.LimiteSuperior)

                        );
                    xmlPedido.Add(xDetallePedido);
                    //}

                    ObjectParameter RET_NUMEROERROR   = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                    ObjectParameter RET_MENSAJEERROR  = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                    ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));


                    context.SP_PEDIDO(pPedido.IdPedido, pPedido.PersonaPide.IdPersona, pPedido.DireccionEntrega.IdDireccion,
                                      pPedido.PersonaEntrega.IdPersona, pPedido.Observaciones, pPedido.Folio,
                                      pPedido.IdMetodoPago, pPedido.Estatus.IdEstatus, xmlPedido.ToString(), "IP", pPedido.ReferenciaPago,
                                      pPedido.CostoEnvio, pPedido.TipoPedido, pPedido.Propina, pPedido.IdEstatusFactura, pPedido.Iva,
                                      RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);

                    E_MENSAJE vMensaje = new E_MENSAJE {
                        RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString()
                    };
                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #24
0
        /// <summary>
        /// Método para insertar extras a productos.
        /// <param name="pNombre">Nombre del extra</param>
        /// <param name="pIdProducto">Id del producto a relacionar</param>
        /// <param name="pPrecio">Precio del extra</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos del movimiento </returns>
        /// </summary>
        public E_MENSAJE AgregarExtraProducto(string pNombre, int pIdProducto, decimal pPrecio, int pIdPersonaAlta)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    E_MENSAJE vMensaje = new E_MENSAJE();

                    var existeRegistro = (from s in context.CTL_EXTRAS_PRODUCTO
                                          where
                                          s.nombre.ToLower().Trim() == pNombre.ToLower().Trim() && s.id_producto == pIdProducto
                                          select s).ToList <CTL_EXTRAS_PRODUCTO>().FirstOrDefault();

                    if (existeRegistro == null)
                    {
                        context.CTL_EXTRAS_PRODUCTO.Add(new CTL_EXTRAS_PRODUCTO()
                        {
                            id_extra = Guid.NewGuid(), nombre = pNombre.Trim(), id_producto = pIdProducto, precio = pPrecio, id_persona_alta = pIdPersonaAlta, fecha_alta = DateTime.Now
                        });
                        var resultado = context.SaveChanges();

                        if (resultado <= 0)
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = -100, RET_MENSAJEERROR = "No se pudo insertar, intente más tarde", RET_VALORDEVUELTO = "No se pudo insertar, intente más tarde"
                            }
                        }
                        ;
                        else
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = 0, RET_MENSAJEERROR = "Insertado", RET_VALORDEVUELTO = "Insertado"
                            }
                        };
                    }
                    else
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = -200, RET_MENSAJEERROR = "Ya existe un extra con este nombre para el producto.", RET_VALORDEVUELTO = "Ya existe un extra con este nombre para el producto."
                        };
                    }


                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #25
0
        /// <summary>
        /// Método para realizar inicio de sesión
        /// <param name="pAcceso">Objeto de tipo E_ACCESO_PERSONA con datos del inicio de sesión</param>
        /// <returns> Objeto tipo E_LOGIN con los datos del movimiento </returns>
        /// </summary>
        public E_LOGIN Login(E_ACCESO_PERSONA pAcceso)
        {
            try
            {
                var respuesta = new E_LOGIN();
                using (context = new ViajesEntities())
                {
                    ObjectParameter RET_ID_PERSONA    = new ObjectParameter("RET_ID_PERSONA", typeof(string));
                    ObjectParameter RET_NUMEROERROR   = new ObjectParameter("RET_NUMEROERROR", typeof(string));
                    ObjectParameter RET_MENSAJEERROR  = new ObjectParameter("RET_MENSAJEERROR", typeof(string));
                    ObjectParameter RET_VALORDEVUELTO = new ObjectParameter("RET_VALORDEVUELTO", typeof(string));


                    context.SP_LOGIN(pAcceso.Email, pAcceso.Password, pAcceso.TipoUsuario, RET_ID_PERSONA,
                                     RET_NUMEROERROR, RET_MENSAJEERROR, RET_VALORDEVUELTO);

                    E_MENSAJE vMensaje = new E_MENSAJE {
                        RET_NUMEROERROR = int.Parse(RET_NUMEROERROR.Value.ToString()), RET_MENSAJEERROR = RET_MENSAJEERROR.Value.ToString(), RET_VALORDEVUELTO = RET_VALORDEVUELTO.Value.ToString()
                    };
                    var intIdPersona = int.Parse(RET_ID_PERSONA.Value.ToString());

                    if (vMensaje.RET_NUMEROERROR == 0)
                    {
                        //Login correcto, carga datos de la persona
                        respuesta.CORRECTO = true;
                        respuesta.MENSAJE  = vMensaje.RET_MENSAJEERROR;


                        //var persona = context.CTL_PERSONA.SqlQuery(String.Format("SELECT * FROM dbo.CTL_PERSONA where id_persona", intIdPersona)).ToList();
                        var persona = (from s in context.CTL_PERSONA
                                       where s.id_persona == intIdPersona
                                       select s).ToList <CTL_PERSONA>().FirstOrDefault();
                        respuesta.PERSONA = new E_PERSONA()
                        {
                            IdPersona = persona.id_persona, Nombre = persona.nombre, Fotografia = persona.fotografia, Telefono = persona.telefono
                        };
                    }
                    else
                    {
                        respuesta.CORRECTO = false;
                        respuesta.MENSAJE  = vMensaje.RET_VALORDEVUELTO;
                    }
                    return(respuesta);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #26
0
        /// <summary>
        /// Método para actualizar token firebase
        /// <param name="pIdPersona">Persona del token editar</param>
        /// <param name="pToken">Token nuevo</param>
        /// <returns> Objeto tipo E_MENSAJE con el resultado de la operación </returns>
        /// </summary>
        public E_MENSAJE ActualizaToken(int pIdPersona, string pToken)
        {
            try
            {
                E_MENSAJE vMensaje;
                using (context = new ViajesEntities())
                {
                    var accesos = context.CTL_ACCESO_PERSONA.Where(p => p.id_persona == pIdPersona).FirstOrDefault();

                    if (accesos != null)
                    {
                        if (accesos.token_firebase != pToken)
                        {
                            accesos.token_firebase = pToken;
                            if (context.SaveChanges() > 0)
                            {
                                vMensaje = new E_MENSAJE {
                                    RET_NUMEROERROR = 0, RET_MENSAJEERROR = "Token actualizado correctamente", RET_VALORDEVUELTO = "Token actualizado correctamente"
                                }
                            }
                            ;
                            else
                            {
                                vMensaje = new E_MENSAJE {
                                    RET_NUMEROERROR = -1000, RET_MENSAJEERROR = "No se pudo actualizar el token", RET_VALORDEVUELTO = "No se pudo actualizar el token"
                                }
                            };
                        }
                        else
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = 0, RET_MENSAJEERROR = "El token registrado es igual al nuevo, no se actualizará.", RET_VALORDEVUELTO = "Token actualizado correctamente"
                            }
                        };
                    }
                    else
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = -1001, RET_MENSAJEERROR = "No se encontró la persona que indicó, no se actualizará.", RET_VALORDEVUELTO = "Token actualizado correctamente"
                        }
                    };
                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #27
0
        /// <summary>
        /// Actualiza estatus de persona
        /// <param name="pIdPersona">Identidicador de la persona</param>
        /// <param name="pIdEstatus">Estatus a actualizar</param>
        /// <param name="pIdPersonaModifica">Persona que realiza el movimiento</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos de la operación </returns>
        /// </summary>
        public E_MENSAJE ActualizaEstatusRegistro(int pIdPersona, byte pIdEstatus, byte pIdPersonaModifica)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    E_MENSAJE vMensaje = new E_MENSAJE();

                    var entity = context.CTL_PERSONA.FirstOrDefault(item => item.id_persona == pIdPersona);

                    if (entity != null)
                    {
                        entity.estatus        = pIdEstatus;
                        entity.fecha_mod      = DateTime.Now;
                        entity.id_persona_mod = pIdPersonaModifica;
                        var resultado = context.SaveChanges();

                        if (resultado <= 0)
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = -100, RET_MENSAJEERROR = "No se pudo actualizar estatus.", RET_VALORDEVUELTO = "No se pudo actualizar estatus."
                            }
                        }
                        ;
                        else
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = 0, RET_MENSAJEERROR = "Estatus actualizado", RET_VALORDEVUELTO = "Estatus actualizado"
                            }
                        };
                    }
                    else
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = -200, RET_MENSAJEERROR = "No se pudo encontrar la persona proporcionada.", RET_VALORDEVUELTO = "No se pudo encontrar la persona proporcionada."
                        };
                    }



                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #28
0
        /// <summary>
        /// Método para consultar agregar pedido
        /// <param name="pTiempoEspera">Tiempo de espera en minutos del pedido</param>
        /// <param name="pIdPedido">Identificador del pedido</param>
        /// <returns> Objeto tipo E_MENSAJE con el resultado de la operación </returns>
        /// </summary>
        public E_MENSAJE AgregaTiempoEspera(int pTiempoEspera, Guid pIdPedido)
        {
            try
            {
                E_MENSAJE vMensaje = new E_MENSAJE();
                using (context = new ViajesEntities())
                {
                    var pedido = (from s in context.M_PEDIDO
                                  where
                                  s.id_pedido.Equals(pIdPedido)
                                  select s).ToList <M_PEDIDO>().FirstOrDefault();


                    if (pedido != null)
                    {
                        pedido.tiempo_espera = pTiempoEspera;
                        var resultado = context.SaveChanges();

                        if (resultado <= 0)
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = -100, RET_MENSAJEERROR = "No se pudo actualizar, intente más tarde", RET_VALORDEVUELTO = "No se pudo actualizar, intente más tarde"
                            }
                        }
                        ;
                        else
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = 0, RET_MENSAJEERROR = "Actrualizado", RET_VALORDEVUELTO = "Actrualizado"
                            }
                        };
                    }
                    else
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = -200, RET_MENSAJEERROR = "No se pudo encontrar el pedido.", RET_VALORDEVUELTO = "No se pudo encontrar el pedido."
                        };
                    }

                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #29
0
        /// <summary>
        /// Actualiza token para resetear contraseña
        /// <param name="pIdPersona">Identidicador de la persona</param>
        /// <param name="pTokenPassword">Clave  para generar password</param>
        /// <returns> Objeto tipo E_MENSAJE con los datos de la operación </returns>
        /// </summary>
        public E_MENSAJE ActializarTokenPassword(int pIdPersona, Guid pTokenPassword)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    E_MENSAJE vMensaje = new E_MENSAJE();

                    var entity = context.CTL_ACCESO_PERSONA.FirstOrDefault(item => item.id_persona == pIdPersona);

                    if (entity != null)
                    {
                        entity.clave_password       = pTokenPassword.ToString();
                        entity.fecha_clave_password = DateTime.Now;
                        var resultado = context.SaveChanges();

                        if (resultado <= 0)
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = -100, RET_MENSAJEERROR = "No se pudo actualizar token.", RET_VALORDEVUELTO = "No se pudo actualizar token."
                            }
                        }
                        ;
                        else
                        {
                            vMensaje = new E_MENSAJE {
                                RET_NUMEROERROR = 0, RET_MENSAJEERROR = "Token actualizado", RET_VALORDEVUELTO = "Token actualizado"
                            }
                        };
                    }
                    else
                    {
                        vMensaje = new E_MENSAJE {
                            RET_NUMEROERROR = -200, RET_MENSAJEERROR = "No se pudo encontrar la persona proporcionada.", RET_VALORDEVUELTO = "No se pudo encontrar la persona proporcionada."
                        };
                    }



                    return(vMensaje);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }
Пример #30
0
        public async Task <string> ConsultarClienteIdOpenPay(int pIdPersona)
        {
            try
            {
                using (context = new ViajesEntities())
                {
                    var rPersona = await(from p in context.R_PERSONA_OPENPAY
                                         where
                                         p.id_persona == pIdPersona
                                         select p).ToListAsync <R_PERSONA_OPENPAY>();

                    return(rPersona.FirstOrDefault().id_customer);
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }