Ejemplo n.º 1
0
        /// <summary>
        /// Descarga la foto del colaborador
        /// </summary>
        /// <param name="piIdColaborador"></param>
        /// <returns></returns>
        public IMDResponse <MemoryStream> BDescargarColaboradorFoto(int piIdColaborador)
        {
            IMDResponse <MemoryStream> response = new IMDResponse <MemoryStream>();

            string metodo = nameof(this.BDescargarColaboradorFoto);

            logger.Info(IMDSerialize.Serialize(67823458485769, $"Inicia {metodo}(int piIdColaborador)", piIdColaborador));

            try
            {
                IMDResponse <byte[]> resGetFoto = this.BConvertColaboradorFoto(piIdColaborador);
                if (resGetFoto.Code != 0)
                {
                    return(resGetFoto.GetResponse <MemoryStream>());
                }

                response.Code    = 0;
                response.Message = "OK";
                response.Result  = new MemoryStream(resGetFoto.Result);
            }
            catch (Exception ex)
            {
                response.Code    = 67823458486546;
                response.Message = "Ocurrió un error inesperado al intentar descargar la foto del colaborador.";

                logger.Error(IMDSerialize.Serialize(67823458486546, $"Error en {metodo}: {ex.Message}(int piIdColaborador)", piIdColaborador, ex, response));
            }
            return(response);
        }
Ejemplo n.º 2
0
        public IMDResponse <EntPaciente> BSavePaciente(EntPaciente entPaciente)
        {
            IMDResponse <EntPaciente> response = new IMDResponse <EntPaciente>();

            string metodo = nameof(this.BSavePaciente);

            logger.Info(IMDSerialize.Serialize(67823458420501, $"Inicia {metodo}(EntPaciente entPaciente)", entPaciente));

            try
            {
                IMDResponse <DataTable> imdResponse = datPaciente.DSavePaciente(entPaciente);

                if (imdResponse.Code != 0)
                {
                    return(imdResponse.GetResponse <EntPaciente>());
                }

                entPaciente.iIdPaciente = Convert.ToInt32(imdResponse.Result.Rows[0]["iIdPaciente"].ToString());

                response.Code   = 0;
                response.Result = entPaciente;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458421278;
                response.Message = "Ocurrió un error inesperado al guardar los datos del paciente.";

                logger.Error(IMDSerialize.Serialize(67823458421278, $"Error en {metodo}(EntPaciente entPaciente): {ex.Message}", entPaciente, ex, response));
            }
            return(response);
        }
Ejemplo n.º 3
0
        public IMDResponse <EntProductosNutricionalPsicologia> BGetProductosNutricionalPsicologia()
        {
            IMDResponse <EntProductosNutricionalPsicologia> response = new IMDResponse <EntProductosNutricionalPsicologia>();

            string metodo = nameof(this.BGetProductosNutricionalPsicologia);

            logger.Info(IMDSerialize.Serialize(67823458634953, $"Inicia {metodo}()"));

            try
            {
                IMDResponse <List <EntProducto> > resGetProducts = this.BObtenerProductos(null);
                if (resGetProducts.Code != 0)
                {
                    return(resGetProducts.GetResponse <EntProductosNutricionalPsicologia>());
                }

                EntProductosNutricionalPsicologia entProductos = new EntProductosNutricionalPsicologia
                {
                    lstNutritionalProducts = resGetProducts.Result.Where(x => x.iIdGrupoProducto == (int)EnumGrupoProducto.NutritionalProducts && x.bComercial).OrderBy(x => x.fCosto).ToList(),
                    lstPsychologyProducts  = resGetProducts.Result.Where(x => x.iIdGrupoProducto == (int)EnumGrupoProducto.PsychologyProducts && x.bComercial).OrderBy(x => x.fCosto).ToList()
                };

                response.Code    = 0;
                response.Message = "Lista de productos consultados";
                response.Result  = entProductos;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458635730;
                response.Message = "Ocurrió un error inesperado al consultar los productos disponibles.";

                logger.Error(IMDSerialize.Serialize(67823458635730, $"Error en {metodo}(): {ex.Message}", ex, response));
            }
            return(response);
        }
Ejemplo n.º 4
0
        /// <summary>
        /// Reenviar el correo de una orden de compra
        /// </summary>
        /// <param name="psOrderId"></param>
        /// <returns></returns>
        public IMDResponse <bool> BReenviarCorreo(string psOrderId)
        {
            IMDResponse <bool> response = new IMDResponse <bool>();

            string metodo = nameof(this.BReenviarCorreo);

            logger.Info(IMDSerialize.Serialize(67823458628737, $"Inicia {metodo}(string psOrderId)", psOrderId));

            try
            {
                if (string.IsNullOrWhiteSpace(psOrderId))
                {
                    response.Code    = -345673;
                    response.Message = "No se especificó la orden para guardar el correo.";
                    return(response);
                }

                IMDResponse <DataTable> resGetData = datCorreo.DGetCorreo(psOrderId);
                if (resGetData.Code != 0)
                {
                    return(resGetData.GetResponse <bool>());
                }

                if (resGetData.Result.Rows.Count != 1)
                {
                    response.Code    = -345673;
                    response.Message = "La orden no existe en el registro de correos del sistema.";
                    return(response);
                }

                IMDDataRow dr = new IMDDataRow(resGetData.Result.Rows[0]);

                EntOrderEmail entOrderEmail = new EntOrderEmail
                {
                    sBody    = dr.ConvertTo <string>("sBody"),
                    sOrderId = dr.ConvertTo <string>("sOrderId"),
                    sSubject = dr.ConvertTo <string>("sSubject"),
                    sTo      = dr.ConvertTo <string>("sTo"),
                };

                IMDResponse <bool> resEnviar = this.BEnviarEmail("", "", "", entOrderEmail.sSubject + " (Reenviado)", entOrderEmail.sBody, entOrderEmail.sTo, "", "");
                if (resEnviar.Code != 0)
                {
                    return(resEnviar);
                }

                response.Code    = 0;
                response.Message = $"Se ha reenviado el detalle de la orden a {entOrderEmail.sTo}.";
                response.Result  = true;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458629514;
                response.Message = "Ocurrió un error inesperado al reenviar el correo de la orden al cliente";

                logger.Error(IMDSerialize.Serialize(67823458629514, $"Error en {metodo}(string psOrderId): {ex.Message}", psOrderId, ex, response));
            }
            return(response);
        }
Ejemplo n.º 5
0
        /// <summary>
        /// Función: Obtiene la lista de cupones
        /// Creado: Cristopher Noh 28/07/2020
        /// Modificado:
        /// </summary>
        /// <param name="piIdCupon">Id de cupón</param>
        /// <param name="piIdCuponCategoria">Categoría del cupón</param>
        /// <param name="psDescripcion">Descripción del cupón</param>
        /// <param name="psCodigo">Código de cupón</param>
        /// <param name="pdtFechaVencimientoInicio">Fecha de vencimiento desde...</param>
        /// <param name="pdtFechaVencimientoFin">..a la Fecha de vencimiento</param>
        /// <param name="pdtFechaCreacionInicio">Fecha de creación desde...</param>
        /// <param name="pdtFechaCreacionFin">...a la fecha de creación</param>
        /// <param name="pbActivo">Cupón activo</param>
        /// <param name="pbBaja">Cupón inactivo</param>
        /// <returns></returns>
        public IMDResponse <List <EntCupon> > BObtenerCupones(int?piIdCupon = null, int?piIdCuponCategoria = null, string psDescripcion = null, string psCodigo = null, DateTime?pdtFechaVencimientoInicio = null, DateTime?pdtFechaVencimientoFin = null, DateTime?pdtFechaCreacionInicio = null, DateTime?pdtFechaCreacionFin = null, bool?pbActivo = true, bool?pbBaja = false, bool?pbVigente = null)
        {
            IMDResponse <List <EntCupon> > response = new IMDResponse <List <EntCupon> >();

            string metodo = nameof(this.BObtenerCupones);

            logger.Info(IMDSerialize.Serialize(67823458191286, $"Inicia {metodo}(int? piIdCupon = null, int? piIdCuponCategoria = null, string psDescripcion = null, string psCodigo = null, DateTime? pdtFechaVencimientoInicio = null, DateTime? pdtFechaVencimientoFin = null, DateTime? pdtFechaCreacionInicio = null, DateTime? pdtFechaCreacionFin = null, bool pbActivo = true, bool pbBaja = false)", piIdCupon, piIdCuponCategoria, psDescripcion, psCodigo, pdtFechaVencimientoInicio, pdtFechaVencimientoFin, pdtFechaCreacionInicio, pdtFechaCreacionFin, pbActivo, pbBaja));

            try
            {
                IMDResponse <DataTable> respuestaObtenerCupones = datPromociones.DGetCupones(piIdCupon, piIdCuponCategoria, pbVigente, psDescripcion, psCodigo, pdtFechaVencimientoInicio, pdtFechaVencimientoFin, pdtFechaCreacionInicio, pdtFechaCreacionFin, pbActivo, pbBaja);
                if (respuestaObtenerCupones.Code != 0)
                {
                    return(respuestaObtenerCupones.GetResponse <List <EntCupon> >());
                }

                List <EntCupon> listaCupones = new List <EntCupon>();
                foreach (DataRow filaCupon in respuestaObtenerCupones.Result.Rows)
                {
                    IMDDataRow dr    = new IMDDataRow(filaCupon);
                    EntCupon   cupon = new EntCupon();

                    cupon.fbActivo               = Convert.ToBoolean(dr.ConvertTo <int>("bActivo"));
                    cupon.fbBaja                 = Convert.ToBoolean(dr.ConvertTo <int>("bBaja"));
                    cupon.fbVigente              = Convert.ToBoolean(dr.ConvertTo <int>("bVigente"));
                    cupon.fdtFechaVencimiento    = dr.ConvertTo <DateTime?>("dtFechaVencimiento");
                    cupon.sFechaVencimiento      = cupon.fdtFechaVencimiento == null ? "Hasta agotar" : ((DateTime)cupon.fdtFechaVencimiento).ToString("dd/MM/yy HH:mm");
                    cupon.dtFechaCreacion        = dr.ConvertTo <DateTime?>("dtFechaCreacion");
                    cupon.sFechaCreacion         = cupon.dtFechaCreacion == null ? null : ((DateTime)cupon.dtFechaCreacion).ToString("dd/MM/yy HH:mm");
                    cupon.fiIdCupon              = dr.ConvertTo <int>("iIdCupon");
                    cupon.fiIdCuponCategoria     = dr.ConvertTo <int>("iIdCuponCategoria");
                    cupon.fiMesBono              = dr.ConvertTo <int?>("iMesBono");
                    cupon.fiTotalLanzamiento     = dr.ConvertTo <int>("iTotalLanzamiento");
                    cupon.fiTotalCanjeado        = dr.ConvertTo <int>("iTotalCanjeado");
                    cupon.fnMontoDescuento       = dr.ConvertTo <double?>("nMontoDescuento");
                    cupon.sMontoDescuento        = cupon.fnMontoDescuento == null ? null : ((double)cupon.fnMontoDescuento / 100d).ToString("C");
                    cupon.fnPorcentajeDescuento  = dr.ConvertTo <double?>("nPorcentajeDescuento");
                    cupon.sPorcentajeDescuento   = cupon.fnPorcentajeDescuento == null ? null : ((double)cupon.fnPorcentajeDescuento).ToString("#%");
                    cupon.fsCodigo               = dr.ConvertTo <string>("sCodigo");
                    cupon.fsDescripcion          = dr.ConvertTo <string>("sDescripcion");
                    cupon.fsDescripcionCategoria = dr.ConvertTo <string>("sDescripcionCategoria");

                    listaCupones.Add(cupon);
                }

                response.Code    = 0;
                response.Message = "Lista de cupones obtenida.";
                response.Result  = listaCupones;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458192063;
                response.Message = "Ocurrió un error al intentar consultar los cupones";

                logger.Error(IMDSerialize.Serialize(67823458192063, $"Error en {metodo}(int? piIdCupon = null, int? piIdCuponCategoria = null, string psDescripcion = null, string psCodigo = null, DateTime? pdtFechaVencimientoInicio = null, DateTime? pdtFechaVencimientoFin = null, DateTime? pdtFechaCreacionInicio = null, DateTime? pdtFechaCreacionFin = null, bool pbActivo = true, bool pbBaja = false): {ex.Message}", piIdCupon, piIdCuponCategoria, psDescripcion, psCodigo, pdtFechaVencimientoInicio, pdtFechaVencimientoFin, pdtFechaCreacionInicio, pdtFechaCreacionFin, pbActivo, pbBaja, ex, response));
            }
            return(response);
        }
Ejemplo n.º 6
0
        public IMDResponse <List <EntPaciente> > BGetPacientes(int?piIdPaciente = null, int?piIdFolio = null)
        {
            IMDResponse <List <EntPaciente> > response = new IMDResponse <List <EntPaciente> >();

            string metodo = nameof(this.BGetPacientes);

            logger.Info(IMDSerialize.Serialize(67823458516849, $"Inicia {metodo}(int? piIdPaciente = null, int? piIdFolio = null)", piIdPaciente, piIdFolio));

            try
            {
                IMDResponse <DataTable> resGetPacientes = datPaciente.DGetPacientes(piIdPaciente, piIdFolio);
                if (resGetPacientes.Code != 0)
                {
                    return(resGetPacientes.GetResponse <List <EntPaciente> >());
                }

                List <EntPaciente> lstPacientes = new List <EntPaciente>();

                foreach (DataRow drPaciente in resGetPacientes.Result.Rows)
                {
                    IMDDataRow dr = new IMDDataRow(drPaciente);

                    EntPaciente paciente = new EntPaciente()
                    {
                        iIdFolio           = dr.ConvertTo <int>("iIdFolio"),
                        iIdPaciente        = dr.ConvertTo <int>("iIdPaciente"),
                        iIdSexo            = dr.ConvertTo <int>("iIdSexo"),
                        sApellidoMaterno   = dr.ConvertTo <string>("sApellidoMaterno"),
                        sApellidoPaterno   = dr.ConvertTo <string>("sApellidoPaterno"),
                        sCorreo            = dr.ConvertTo <string>("sCorreo"),
                        dtFechaNacimiento  = dr.ConvertTo <DateTime?>("dtFechaNacimiento"),
                        sdtFechaNacimiento = string.Empty,
                        sFolio             = dr.ConvertTo <string>("sFolio"),
                        sNombre            = dr.ConvertTo <string>("sNombre"),
                        sSexo       = dr.ConvertTo <string>("sSexo"),
                        sTelefono   = dr.ConvertTo <string>("sTelefono"),
                        sTipoSangre = dr.ConvertTo <string>("sTipoSangre"),
                    };

                    paciente.sdtFechaNacimiento = paciente.dtFechaNacimiento?.ToString("dd/MM/yyyy");

                    lstPacientes.Add(paciente);
                }

                response.Code    = 0;
                response.Message = lstPacientes.Count == 0 ? "No se encontraron pacientes en la lista." : "La lista de pacientes ha sido obtenida.";
                response.Result  = lstPacientes;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458517626;
                response.Message = "Ocurrió un error inesperado al obtener la lista de pacientes.";

                logger.Error(IMDSerialize.Serialize(67823458517626, $"Error en {metodo}(int? piIdPaciente = null, int? piIdFolio = null): {ex.Message}", piIdPaciente, piIdFolio, ex, response));
            }
            return(response);
        }
Ejemplo n.º 7
0
        /// <summary>
        /// Guarda los datos de una empresa
        /// </summary>
        /// <param name="entEmpresa"></param>
        /// <returns></returns>
        public IMDResponse <EntEmpresa> BSaveEmpresa(EntEmpresa entEmpresa)
        {
            IMDResponse <bool>       responseValidation = new IMDResponse <bool>();
            IMDResponse <EntEmpresa> response           = new IMDResponse <EntEmpresa>();

            string metodo = nameof(this.BSaveEmpresa);

            logger.Info(IMDSerialize.Serialize(67823458383982, $"Inicia {metodo}(EntEmpresa entEmpresa)", entEmpresa));

            try
            {
                responseValidation = BValidaDatos(entEmpresa);
                if (responseValidation.Code != 0)
                {
                    return(response = responseValidation.GetResponse <EntEmpresa>());
                }

                IMDResponse <DataTable> dtEmpresa = datEmpresa.DSaveEmpresa(entEmpresa);
                if (dtEmpresa.Code != 0)
                {
                    return(dtEmpresa.GetResponse <EntEmpresa>());
                }
                if (dtEmpresa.Result.Rows.Count < 1)
                {
                    response.Code    = -76768273456;
                    response.Message = "No ha sido posible generar la empresa/cliente.";
                    return(response);
                }

                EntEmpresa oEmpresa = new EntEmpresa();
                foreach (DataRow item in dtEmpresa.Result.Rows)
                {
                    IMDDataRow dr = new IMDDataRow(item);

                    oEmpresa.iIdEmpresa     = dr.ConvertTo <int>("iIdEmpresa");
                    oEmpresa.sNombre        = dr.ConvertTo <string>("sNombre");
                    oEmpresa.sFolioEmpresa  = dr.ConvertTo <string>("sFolioEmpresa");
                    oEmpresa.sCorreo        = dr.ConvertTo <string>("sCorreo");
                    oEmpresa.sFechaCreacion = dr.ConvertTo <DateTime>("dtFechaCreacion").ToString("dd/MM/yyyy");
                    oEmpresa.bActivo        = Convert.ToBoolean(dr.ConvertTo <int>("bActivo"));
                    oEmpresa.bBaja          = Convert.ToBoolean(dr.ConvertTo <int>("bBaja"));
                }

                response.Code    = 0;
                response.Message = entEmpresa.iIdEmpresa == 0 ? "La empresa ha sido guardada correctamente." : "La empresa ha sido actualizada correctamente.";
                response.Result  = oEmpresa;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458384759;
                response.Message = "Ocurrió un error inesperado al intentar guardar los datos de la empresa.";

                logger.Error(IMDSerialize.Serialize(67823458384759, $"Error en {metodo}(EntEmpresa entEmpresa): {ex.Message}", entEmpresa, ex, response));
            }
            return(response);
        }
Ejemplo n.º 8
0
        /// <summary>
        /// Función: Consulta los datos de una orden generada en Conekta
        /// Creado: Cristopher Noh 03/07/2020
        /// Modificado:
        /// </summary>
        /// <param name="orderId">Id de ordan Conekta</param>
        /// <returns>Datos de la orden</returns>
        public IMDResponse <EntOrder> BGetOrder(string orderId)
        {
            IMDResponse <EntOrder> response = new IMDResponse <EntOrder>();

            string metodo = nameof(this.BGetOrder);

            logger.Info(IMDSerialize.Serialize(67823458109701, $"Inicia {metodo}(string orderId)", orderId));

            try
            {
                if (string.IsNullOrWhiteSpace(orderId))
                {
                    response.Code    = 67823458120579;
                    response.Message = "No se ingresó el id de la orden.";
                    return(response);
                }

                IMDResponse <EntCreateUserAgent> respuestaObtenerAgenteUsuario = busAgent.BGetUserAgent();
                if (respuestaObtenerAgenteUsuario.Code != 0)
                {
                    return(respuestaObtenerAgenteUsuario.GetResponse <EntOrder>());
                }

                IMDResponse <string> respuestaServicioConsultarOrden = servOrder.SGetOrder(orderId, respuestaObtenerAgenteUsuario.Result);
                if (respuestaServicioConsultarOrden.Code != 0)
                {
                    return(respuestaServicioConsultarOrden.GetResponse <EntOrder>());
                }

                logger.Info(IMDSerialize.Serialize(67823458218481, $"Respuesta del servicio consulta por Conekta", orderId, respuestaObtenerAgenteUsuario.Result, respuestaServicioConsultarOrden));


                EntOrder entOrder = null;
                try
                {
                    entOrder = JsonConvert.DeserializeObject <EntOrder>(respuestaServicioConsultarOrden.Result);
                }
                catch (Exception)
                {
                    entOrder = null;
                }

                response.Code    = 0;
                response.Result  = entOrder;
                response.Message = entOrder == null ? respuestaServicioConsultarOrden.Result : "Orden obtenida.";
            }
            catch (Exception ex)
            {
                response.Code    = 67823458110478;
                response.Message = "Ocurrió un error inesperado al recopilar la información de la orden.";

                logger.Error(IMDSerialize.Serialize(67823458110478, $"Error en {metodo}(string orderId): {ex.Message}", orderId, ex, response));
            }
            return(response);
        }
Ejemplo n.º 9
0
        /// <summary>
        /// Guarda la consulta para un paciente
        /// </summary>
        /// <param name="entConsulta"></param>
        /// <param name="piIdUsuarioMod"></param>
        /// <returns></returns>
        public IMDResponse <EntConsulta> BSaveConsulta(EntConsulta entConsulta, int piIdUsuarioMod = 1)
        {
            IMDResponse <EntConsulta> response = new IMDResponse <EntConsulta>();

            string metodo = nameof(this.BSaveConsulta);

            logger.Info(IMDSerialize.Serialize(67823458519957, $"Inicia {metodo}(EntConsulta entConsulta, int piIdUsuarioMod = 1)", entConsulta, piIdUsuarioMod));

            try
            {
                if (entConsulta == null)
                {
                    response.Code    = -8783458839487;
                    response.Message = "No se ingresó información para guardar la consulta.";
                    return(response);
                }

                //Guardar o actualizar la consulta generada
                IMDResponse <DataTable> resSaveConsulta = datConsulta.DSaveConsulta(
                    entConsulta.iIdConsulta,
                    piIdUsuarioMod,
                    entConsulta.iIdPaciente,
                    entConsulta.iIdColaborador,
                    entConsulta.iIdEstatusConsulta,
                    entConsulta.dtFechaProgramadaInicio,
                    entConsulta.dtFechaProgramadaFin,
                    entConsulta.dtFechaConsultaInicio,
                    entConsulta.dtFechaConsultaFin);
                if (resSaveConsulta.Code != 0)
                {
                    return(resSaveConsulta.GetResponse <EntConsulta>());
                }

                if (resSaveConsulta.Result.Rows.Count != 1)
                {
                    response.Code    = -7623486876234;
                    response.Message = "No se ha sido posible acceder a la consulta en este momento. Intente de nuevo.";
                    return(response);
                }

                entConsulta.iIdConsulta = Convert.ToInt32(resSaveConsulta.Result.Rows[0]["iIdConsulta"].ToString());

                response.Code    = 0;
                response.Message = "La consulta ha sido guardada correctamente.";
                response.Result  = entConsulta;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458520734;
                response.Message = "Ocurrió un error inesperado al guardar la consulta.";

                logger.Error(IMDSerialize.Serialize(67823458520734, $"Error en {metodo}(EntConsulta entConsulta, int piIdUsuarioMod = 1): {ex.Message}", entConsulta, piIdUsuarioMod, ex, response));
            }
            return(response);
        }
Ejemplo n.º 10
0
        /// <summary>
        /// Obtiene los detalles de la consulta del paciente que debe estar programada en el momento de la solicitud
        /// </summary>
        /// <param name="piIdPaciente"></param>
        /// <param name="piIdColaborador"></param>
        /// <returns></returns>
        public IMDResponse <List <EntDetalleConsulta> > BGetConsultaMomento(int piIdPaciente, int piIdColaborador)
        {
            IMDResponse <List <EntDetalleConsulta> > response = new IMDResponse <List <EntDetalleConsulta> >();

            string metodo = nameof(this.BGetConsultaMomento);

            logger.Info(IMDSerialize.Serialize(67823458588333, $"Inicia {metodo}(int piIdPaciente, int piIdColaborador)", piIdPaciente, piIdColaborador));

            try
            {
                int iMinutosToleranciaAntes   = Convert.ToInt32(ConfigurationManager.AppSettings["iMinToleraciaConsultaInicio"]);
                int iMinutosToleranciaDespues = Convert.ToInt32(ConfigurationManager.AppSettings["iMinToleraciaConsultaFin"]);

                IMDResponse <DataTable> resGetConsulta = datConsulta.DGetConsultaProgramada(piIdPaciente, piIdColaborador, iMinutosToleranciaAntes, iMinutosToleranciaDespues);
                if (resGetConsulta.Code != 0)
                {
                    return(resGetConsulta.GetResponse <List <EntDetalleConsulta> >());
                }

                List <EntDetalleConsulta> lstConsultas = new List <EntDetalleConsulta>();

                foreach (DataRow drConsulta in resGetConsulta.Result.Rows)
                {
                    IMDDataRow dr = new IMDDataRow(drConsulta);

                    EntDetalleConsulta consulta = new EntDetalleConsulta
                    {
                        dtFechaConsultaFin      = dr.ConvertTo <DateTime?>("dtFechaConsultaFin"),
                        dtFechaConsultaInicio   = dr.ConvertTo <DateTime?>("dtFechaConsultaInicio"),
                        dtFechaCreacion         = dr.ConvertTo <DateTime?>("dtFechaCreacion"),
                        dtFechaProgramadaFin    = dr.ConvertTo <DateTime?>("dtFechaProgramadaFin"),
                        dtFechaProgramadaInicio = dr.ConvertTo <DateTime?>("dtFechaProgramadaInicio"),
                        iIdColaborador          = dr.ConvertTo <int?>("iIdColaborador"),
                        iIdConsulta             = dr.ConvertTo <int?>("iIdConsulta"),
                        iIdEstatusConsulta      = dr.ConvertTo <int?>("iIdEstatusConsulta"),
                        iIdPaciente             = dr.ConvertTo <int?>("iIdPaciente"),
                    };

                    lstConsultas.Add(consulta);
                }

                response.Code    = 0;
                response.Message = "Se han obtenido las consultas programadas en el horario programado actual.";
                response.Result  = lstConsultas;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458589110;
                response.Message = "Ocurrió un error inesperado al verificar el horario de consulta del paciente.";

                logger.Error(IMDSerialize.Serialize(67823458589110, $"Error en {metodo}(int piIdPaciente, int piIdColaborador): {ex.Message}", piIdPaciente, piIdColaborador, ex, response));
            }
            return(response);
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Obtiene el arreglo de bytes de la foto del colaborador
        /// </summary>
        /// <param name="piIdColaborador"></param>
        /// <returns></returns>
        public IMDResponse <byte[]> BConvertColaboradorFoto(int piIdColaborador)
        {
            IMDResponse <byte[]> response = new IMDResponse <byte[]>();

            string metodo = nameof(this.BConvertColaboradorFoto);

            logger.Info(IMDSerialize.Serialize(67823458487323, $"Inicia {metodo}(int piIdColaborador)", piIdColaborador));

            try
            {
                if (piIdColaborador < 1)
                {
                    response.Code    = -7262876723423;
                    response.Message = "No se ingresó información del colaborador";
                    return(response);
                }

                IMDResponse <DataTable> resGetFoto = datColaborador.DGetColaboradorFoto(piIdColaborador);
                if (resGetFoto.Code != 0)
                {
                    return(resGetFoto.GetResponse <byte[]>());
                }

                if (resGetFoto.Result.Rows.Count != 1)
                {
                    response.Code    = -98672347786234;
                    response.Message = "No se encontró la foto del colaborador.";
                    return(response);
                }

                DataRow dr   = resGetFoto.Result.Rows[0];
                byte[]  foto = dr["sFoto"] is DBNull ? new byte[0] : (byte[])dr["sFoto"];
                if (foto.Length == 0)
                {
                    response.Code    = -1000;
                    response.Message = "El colaborador aún no cuenta con foto de perfil.";
                    return(response);
                }

                response.Code    = 0;
                response.Message = "OK";
                response.Result  = foto;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458488100;
                response.Message = "Ocurrió un error inesperado al leer la foto del colaborador.";

                logger.Error(IMDSerialize.Serialize(67823458488100, $"Error en {metodo}(int piIdColaborador): {ex.Message}", piIdColaborador, ex, response));
            }
            return(response);
        }
Ejemplo n.º 12
0
        //Obtener los perfiles del sistema
        public IMDResponse <List <EntPerfil> > BObtenerPerfil(int?iIdPerfil, bool bActivo, bool bBaja)
        {
            IMDResponse <List <EntPerfil> > response = new IMDResponse <List <EntPerfil> >();

            string metodo = nameof(this.BObtenerPerfil);

            logger.Info(IMDSerialize.Serialize(67823458357564, $"Inicia {metodo}(int? iIdPerfil, bool bActivo, bool bBaja)", iIdPerfil, bActivo, bBaja));

            try
            {
                IMDResponse <DataTable> dtPerfil = datPerfil.DObtenerPerfil(iIdPerfil, bActivo, bBaja);
                if (dtPerfil.Code != 0)
                {
                    return(dtPerfil.GetResponse <List <EntPerfil> >());
                }

                List <EntPerfil> lstPerfiles = new List <EntPerfil>();

                if (dtPerfil.Code != 0)
                {
                    response.Code    = -71470986457102;
                    response.Message = "El sistema no cuenta con perfiles activos.";
                    return(response);
                }


                foreach (DataRow item in dtPerfil.Result.Rows)
                {
                    IMDDataRow dr        = new IMDDataRow(item);
                    EntPerfil  entPerfil = new EntPerfil();

                    entPerfil.iIdPerfil = dr.ConvertTo <int>("iIdPerfil");
                    entPerfil.sNombre   = dr.ConvertTo <string>("sNombre");
                    entPerfil.bActivo   = dr.ConvertTo <bool>("bActivo");
                    entPerfil.bBaja     = dr.ConvertTo <bool>("bBaja");

                    lstPerfiles.Add(entPerfil);
                }

                response.Result  = lstPerfiles;
                response.Message = "Los perfiles del sistema han sido obtenidos.";
            }
            catch (Exception ex)
            {
                response.Code    = 67823458358341;
                response.Message = "Ocurrió un error inesperado al consultar los perfiles del sistema.";

                logger.Error(IMDSerialize.Serialize(67823458358341, $"Error en {metodo}(int? iIdPerfil, bool bActivo, bool bBaja): {ex.Message}", iIdPerfil, bActivo, bBaja, ex, response));
            }
            return(response);
        }
Ejemplo n.º 13
0
        /// <summary>
        /// Obtener el status actual del colaborador
        /// </summary>
        /// <param name="piIdColaborador"></param>
        /// <returns></returns>
        public IMDResponse <EntColaboradorStatus> BGetColaboradorStatus(int piIdColaborador)
        {
            IMDResponse <EntColaboradorStatus> response = new IMDResponse <EntColaboradorStatus>();

            string metodo = nameof(this.BGetColaboradorStatus);

            logger.Info(IMDSerialize.Serialize(67823458648939, $"Inicia {metodo}(int piIdColaborador)", piIdColaborador));

            try
            {
                if (piIdColaborador < 1)
                {
                    response.Code    = -345687324773;
                    response.Message = "No se especificó el colaborador.";
                    return(response);
                }

                IMDResponse <DataTable> resGetStatus = datColaborador.DGetColaboradorStatus(piIdColaborador);
                if (resGetStatus.Code != 0)
                {
                    return(resGetStatus.GetResponse <EntColaboradorStatus>());
                }

                if (resGetStatus.Result.Rows.Count != 1)
                {
                    response.Code    = -345687324773;
                    response.Message = "No se encontró el colaborador especificado.";
                    return(response);
                }

                IMDDataRow dr = new IMDDataRow(resGetStatus.Result.Rows[0]);

                EntColaboradorStatus entColaboradorStatus = new EntColaboradorStatus
                {
                    bOcupado = Convert.ToBoolean(dr.ConvertTo <int>("bOcupado")),
                    bOnline  = Convert.ToBoolean(dr.ConvertTo <int>("bOnline")),
                };

                response.Code    = 0;
                response.Message = "Se ha consultado el estatus del colaborador.";
                response.Result  = entColaboradorStatus;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458649716;
                response.Message = "Ocurrió un error inesperado al consultar el status del colaborador.";

                logger.Error(IMDSerialize.Serialize(67823458649716, $"Error en {metodo}(int piIdColaborador): {ex.Message}", piIdColaborador, ex, response));
            }
            return(response);
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Consulta si existe una sala de colaborador disponible
        /// </summary>
        /// <param name="bAgendada"></param>
        /// <param name="iIdUsuario"></param>
        /// <param name="dtFechaConsulta"></param>
        /// <returns></returns>
        public IMDResponse <EntColaborador> BObtenerSala(bool?bAgendada = null, int?iIdUsuario = null, DateTime?dtFechaConsulta = null)
        {
            IMDResponse <EntColaborador> response = new IMDResponse <EntColaborador>();
            EntColaborador oColaborador           = new EntColaborador();

            string metodo = nameof(this.BObtenerSala);

            logger.Info(IMDSerialize.Serialize(67823458591441, $"Inicia {metodo}(int? iIdTipoProducto = null, int? iIdUsuario = null, DateTime? dtFechaConsulta = null)"));

            try
            {
                IMDResponse <DataTable> dtColaborador = datColaborador.DObtenerSala(bAgendada, iIdUsuario, dtFechaConsulta);
                if (dtColaborador.Code != 0)
                {
                    return(dtColaborador.GetResponse <EntColaborador>());
                }


                foreach (DataRow item in dtColaborador.Result.Rows)
                {
                    IMDDataRow rows = new IMDDataRow(item);

                    oColaborador = new EntColaborador
                    {
                        iIdColaborador = rows.ConvertTo <int>("iIdColaborador"),
                        iNumSala       = rows.ConvertTo <int?>("iNumSala")
                    };
                }

                //Verificar si se ha encontrado una sala disponible
                string medicosOcupados = "Todos los médicos se encuentran ocupados en este momento.";
                if (oColaborador.iNumSala == null)
                {
                    response.Code    = -7262876723423;
                    response.Message = medicosOcupados;
                    return(response);
                }

                response.Code    = 0;
                response.Message = dtColaborador.Result.Rows.Count > 0 ? "Se ha encontrado un sala disponible." : medicosOcupados;
                response.Result  = oColaborador;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458592218;
                response.Message = "Ocurrió un error inesperado al obtener la sala del colaborador.";

                logger.Error(IMDSerialize.Serialize(67823458592218, $"Error en {metodo}(int? iIdTipoProducto = null, int? iIdUsuario = null, DateTime? dtFechaConsulta = null): {ex.Message}", ex, response));
            }
            return(response);
        }
Ejemplo n.º 15
0
        /// <summary>
        /// Obtiene los catálogos del sistema
        /// </summary>
        /// <returns></returns>
        public IMDResponse <EntCatalogos> BGetCatalogos()
        {
            IMDResponse <EntCatalogos> response = new IMDResponse <EntCatalogos>();

            string metodo = nameof(this.BGetCatalogos);

            logger.Info(IMDSerialize.Serialize(67823458644277, $"Inicia {metodo}"));

            try
            {
                IMDResponse <DataSet> resGetCat = datEspecialidad.DGetCatalogos();
                if (resGetCat.Code != 0)
                {
                    return(resGetCat.GetResponse <EntCatalogos>());
                }
                if (resGetCat.Result.Tables.Count < 1)
                {
                    response.Code    = -234768745;
                    response.Message = "El sistema no cuenta con catálogos registrados.";
                }

                //Armar entidad para guardar los catálogos del sistema
                EntCatalogos entCatalogos = new EntCatalogos
                {
                    catCuponCategoria  = this.BReadCat(resGetCat.Result, 0),
                    catEspecialidad    = this.BReadCat(resGetCat.Result, 1),
                    catEstatusConsulta = this.BReadCat(resGetCat.Result, 2),
                    catGrupoProducto   = this.BReadCat(resGetCat.Result, 3),
                    catOrigen          = this.BReadCat(resGetCat.Result, 4),
                    catSexo            = this.BReadCat(resGetCat.Result, 5),
                    catTipoDoctor      = this.BReadCat(resGetCat.Result, 6),
                    catTipoProducto    = this.BReadCat(resGetCat.Result, 7),
                    catUsuarioAccion   = this.BReadCat(resGetCat.Result, 8),
                    catTipoCuenta      = this.BReadCat(resGetCat.Result, 9),
                    catPerfil          = this.BReadCat(resGetCat.Result, 10),
                    catIcon            = this.BReadCat(resGetCat.Result, 11),
                };

                response.Code    = 0;
                response.Message = "Se han consultado los catálogos del sistema.";
                response.Result  = entCatalogos;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458645054;
                response.Message = "Ocurrió un error inesperado al consultar los catalogos del sistema.";

                logger.Error(IMDSerialize.Serialize(67823458645054, $"Error en {metodo}: {ex.Message}", ex, response));
            }
            return(response);
        }
Ejemplo n.º 16
0
        /// <summary>
        /// Obtener la lista de las especialidades
        /// </summary>
        /// <param name="piIdEspecialidad"></param>
        /// <returns></returns>
        public IMDResponse <List <EntEspecialidad> > BGetEspecialidad(int?piIdEspecialidad = null)
        {
            IMDResponse <List <EntEspecialidad> > response = new IMDResponse <List <EntEspecialidad> >();

            string metodo = nameof(this.BGetEspecialidad);

            logger.Info(IMDSerialize.Serialize(67823458451581, $"Inicia {metodo}(int? piIdEspecialidad = null)", piIdEspecialidad));

            try
            {
                //Consultar especialidades
                IMDResponse <DataTable> respuestaGetEspecialidades = datEspecialidad.DGetEspecialidad(piIdEspecialidad);
                if (respuestaGetEspecialidades.Code != 0)
                {
                    return(respuestaGetEspecialidades.GetResponse <List <EntEspecialidad> >());
                }

                List <EntEspecialidad> lstEspecialidades = new List <EntEspecialidad>();
                foreach (DataRow drEspecialidad in respuestaGetEspecialidades.Result.Rows)
                {
                    IMDDataRow dr = new IMDDataRow(drEspecialidad);

                    EntEspecialidad especialidad = new EntEspecialidad
                    {
                        bActivo         = dr.ConvertTo <bool>("bActivo"),
                        bBaja           = dr.ConvertTo <bool>("bBaja"),
                        dtFechaCreacion = dr.ConvertTo <DateTime>("dtFechaCreacion"),
                        iIdEspecialidad = dr.ConvertTo <int>("iIdEspecialidad"),
                        sNombre         = dr.ConvertTo <string>("sNombre")
                    };

                    especialidad.sFechaCreacion = especialidad.dtFechaCreacion.ToString("dd/MM/yyyy HH:mm");

                    lstEspecialidades.Add(especialidad);
                }

                response.Code    = 0;
                response.Message = "Las especialidades han sido obtenidas.";
                response.Result  = lstEspecialidades;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458452358;
                response.Message = "Ocurrió un error inesperado al consultar las especialidades.";

                logger.Error(IMDSerialize.Serialize(67823458452358, $"Error en {metodo}(int? piIdEspecialidad = null): {ex.Message}", piIdEspecialidad, ex, response));
            }
            return(response);
        }
Ejemplo n.º 17
0
        /// <summary>
        /// Obtiene la lista de las empresas solicitadas
        /// </summary>
        /// <param name="iIdEmpresa"></param>
        /// <param name="psCorreo"></param>
        /// <returns></returns>
        public IMDResponse <List <EntEmpresa> > BGetEmpresas(int?iIdEmpresa = null, string psCorreo = null, string psFolioEmpresa = null)
        {
            IMDResponse <List <EntEmpresa> > response = new IMDResponse <List <EntEmpresa> >();

            string metodo = nameof(this.BGetEmpresas);

            logger.Info(IMDSerialize.Serialize(67823458393306, $"Inicia {metodo}(int? iIdEmpresa, string psCorreo = null)", iIdEmpresa, psCorreo));

            try
            {
                IMDResponse <DataTable> dtEmpresa  = datEmpresa.DGetEmpresas(iIdEmpresa, psCorreo, psFolioEmpresa);
                List <EntEmpresa>       lstEmpresa = new List <EntEmpresa>();
                EntEmpresa entEmpresa;

                if (dtEmpresa.Result.Rows.Count < 1)
                {
                    response = dtEmpresa.GetResponse <List <EntEmpresa> >();
                }

                foreach (DataRow item in dtEmpresa.Result.Rows)
                {
                    IMDDataRow dr = new IMDDataRow(item);
                    entEmpresa = new EntEmpresa();

                    entEmpresa.iIdEmpresa     = dr.ConvertTo <int>("iIdEmpresa");
                    entEmpresa.sNombre        = dr.ConvertTo <string>("sNombre");
                    entEmpresa.sFolioEmpresa  = dr.ConvertTo <string>("sFolioEmpresa");
                    entEmpresa.sCorreo        = dr.ConvertTo <string>("sCorreo");
                    entEmpresa.sFechaCreacion = dr.ConvertTo <DateTime>("dtFechaCreacion").ToShortDateString();
                    entEmpresa.bActivo        = Convert.ToBoolean(dr.ConvertTo <int>("bActivo"));
                    entEmpresa.bBaja          = Convert.ToBoolean(dr.ConvertTo <int>("bBaja"));

                    lstEmpresa.Add(entEmpresa);
                }

                response.Code    = 0;
                response.Message = "La lista de empresas ha sido obtenida.";
                response.Result  = lstEmpresa;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458394083;
                response.Message = "Ocurrió un error inesperado al obtener los datos de la empresa.";

                logger.Error(IMDSerialize.Serialize(67823458394083, $"Error en {metodo}(int? iIdEmpresa, string psCorreo = null): {ex.Message}", iIdEmpresa, psCorreo, ex, response));
            }
            return(response);
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Función: Genera un código de cupón aleatorio con la longitud proporcionada
        /// Creado: Cristopher Noh 28/07/2020
        /// Modificado:
        /// </summary>
        /// <param name="piLongitud"></param>
        /// <returns></returns>
        private IMDResponse <string> BGenerarCodigoCupon(int piLongitud)
        {
            IMDResponse <string> response = new IMDResponse <string>();

            string metodo = nameof(this.BGenerarCodigoCupon);

            logger.Info(IMDSerialize.Serialize(67823458194394, $"Inicia {metodo}(int piLongitud)", piLongitud));

            try
            {
                if (piLongitud < 6)
                {
                    response.Code    = 67823458231690;
                    response.Message = "La longitud mínima para un cupón es de 6 caractéres.";
                    return(response);
                }

                IMDResponse <int> respuestaNuevoID = this.BNuevoIdCupon();
                if (respuestaNuevoID.Code != 0)
                {
                    return(respuestaNuevoID.GetResponse <string>());
                }

                IMDEndec iMDEndec = new IMDEndec();

                string sCodigoEncr = iMDEndec.BEncrypt(respuestaNuevoID.Result.ToString(), "abcdefghijklmnop", "abcdefgh")?.Result;

                sCodigoEncr = sCodigoEncr?.Replace("+", "")?.Replace("=", "")?.Replace("/", "");
                sCodigoEncr = sCodigoEncr?.Substring(0, piLongitud > sCodigoEncr.Length ? sCodigoEncr.Length : piLongitud)?.ToUpper();

                if (string.IsNullOrWhiteSpace(sCodigoEncr))
                {
                    response.Code    = 67823458232467;
                    response.Message = "No se pudo generar el código del cupón.";
                    return(response);
                }
                response.Code   = 0;
                response.Result = sCodigoEncr;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458195171;
                response.Message = "Ocurrió un error al generar el cupón.";

                logger.Error(IMDSerialize.Serialize(67823458195171, $"Error en {metodo}(int piLongitud): {ex.Message}", piLongitud, ex, response));
            }
            return(response);
        }
Ejemplo n.º 19
0
        public IMDResponse <EntOrientacionIVA> BGetOrientacionesLocutorios()
        {
            IMDResponse <EntOrientacionIVA> response = new IMDResponse <EntOrientacionIVA>();

            string metodo = nameof(this.BGetOrientacionesLocutorios);

            logger.Info(IMDSerialize.Serialize(67823458658263, $"Inicia {metodo}"));

            try
            {
                IMDResponse <List <EntProducto> > resGetProducts = this.BObtenerProductos(null);
                if (resGetProducts.Code != 0)
                {
                    return(resGetProducts.GetResponse <EntOrientacionIVA>());
                }

                List <EntProducto> productos = resGetProducts.Result.Where(x => x.bActivo && !x.bBaja && x.iIdTipoProducto == (int)EnumTipoProducto.Servicio && x.iIdGrupoProducto == (int)EnumGrupoProducto.ProdutosLocutorios).OrderBy(x => x.iIdGrupoProducto).ThenByDescending(x => x.iIdTipoProducto).ThenBy(x => x.fCosto).ToList();

                if (productos.Count < 1)
                {
                    response.Code    = -24376876873456;
                    response.Message = "No hay productos disponibles para venta.";
                    return(response);
                }

                double taxIVA = Convert.ToDouble(ConfigurationManager.AppSettings["CONEKTA_IMPUESTO"]);

                EntOrientacionIVA entOrientacionIVA = new EntOrientacionIVA
                {
                    dIva         = taxIVA,
                    lstProductos = productos
                };

                response.Code    = 0;
                response.Message = "Se han consultado los productos Meditoc.";
                response.Result  = entOrientacionIVA;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458659040;
                response.Message = "Ocurrió un error inesperado al consultar los productos de Meditoc.";

                logger.Error(IMDSerialize.Serialize(67823458659040, $"Error en {metodo}: {ex.Message}", ex, response));
            }
            return(response);
        }
Ejemplo n.º 20
0
        /// <summary>
        /// Función: Valida si un cupón ya ha sido aplicado por un usuario al momento de realizar la compra
        /// Creado: Cristopher Noh 28/07/2020
        /// Modificado:
        /// </summary>
        /// <param name="piIdCupon">ID del cupón</param>
        /// <param name="psEmail">Correo del cliente que aplica</param>
        /// <returns></returns>
        public IMDResponse <bool> BGetCuponUsed(int piIdCupon, string psEmail)
        {
            IMDResponse <bool> response = new IMDResponse <bool>();

            string metodo = nameof(this.BGetCuponUsed);

            logger.Info(IMDSerialize.Serialize(67823458214596, $"Inicia {metodo}(int piIdCupon, string psEmail)", piIdCupon, psEmail));

            try
            {
                if (piIdCupon <= 0 || string.IsNullOrWhiteSpace(psEmail))
                {
                    response.Code    = 67823458234021;
                    response.Message = "No se ingresaron datos completos";
                    return(response);
                }

                IMDResponse <DataTable> respuestaValidarCuponEmail = datPromociones.DGetCuponUsed(piIdCupon, psEmail);
                if (respuestaValidarCuponEmail.Code != 0)
                {
                    return(respuestaValidarCuponEmail.GetResponse <bool>());
                }

                if (respuestaValidarCuponEmail.Result.Rows.Count > 0)
                {
                    response.Code    = 0;
                    response.Result  = false;
                    response.Message = "El usuario ya ha aplicado este código.";
                }
                else
                {
                    response.Code    = 0;
                    response.Result  = true;
                    response.Message = "Código aplicable al usuario.";
                }
            }
            catch (Exception ex)
            {
                response.Code    = 67823458215373;
                response.Message = "Ocurrió un error inesperado al verificar el código aplicado.";

                logger.Error(IMDSerialize.Serialize(67823458215373, $"Error en {metodo}(int piIdCupon, string psEmail): {ex.Message}", piIdCupon, psEmail, ex, response));
            }
            return(response);
        }
Ejemplo n.º 21
0
        /// <summary>
        /// Iniciar la consulta seteando la fecha de inicio de una consulta proporcionada
        /// </summary>
        /// <param name="iIdConsulta"></param>
        /// <param name="iIdColaborador"></param>
        /// <param name="iIdUsuarioMod"></param>
        /// <returns></returns>
        public IMDResponse <bool> BIniciarConsulta(int iIdConsulta, int iIdColaborador, int iIdUsuarioMod)
        {
            IMDResponse <bool> response = new IMDResponse <bool>();

            string metodo = nameof(this.BIniciarConsulta);

            logger.Info(IMDSerialize.Serialize(67823458526173, $"Inicia {metodo}(int iIdConsulta, int iIdColaborador, int iIdUsuarioMod)", iIdConsulta, iIdColaborador, iIdUsuarioMod));

            try
            {
                if (iIdConsulta == 0)
                {
                    response.Code    = -8793487583457;
                    response.Message = "La información para iniciar la consulta está incompleta.";
                    return(response);
                }

                EntConsulta entConsulta = new EntConsulta
                {
                    iIdConsulta           = iIdConsulta,
                    dtFechaConsultaInicio = DateTime.Now,
                    iIdEstatusConsulta    = (int)EnumEstatusConsulta.EnConsulta
                };

                //Actualizar fecha de inicio de consulta
                IMDResponse <EntConsulta> resSaveConsulta = busConsulta.BSaveConsulta(entConsulta, iIdUsuarioMod);
                if (resSaveConsulta.Code != 0)
                {
                    return(resSaveConsulta.GetResponse <bool>());
                }

                response.Code    = 0;
                response.Message = "La consulta ha iniciado.";
                response.Result  = true;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458526950;
                response.Message = "Ocurrió un error inesperado al iniciar la consulta.";

                logger.Error(IMDSerialize.Serialize(67823458526950, $"Error en {metodo}(int iIdConsulta, int iIdColaborador, int iIdUsuarioMod): {ex.Message}", iIdConsulta, iIdColaborador, iIdUsuarioMod, ex, response));
            }
            return(response);
        }
Ejemplo n.º 22
0
        /// <summary>
        /// Función: Obtiene el GUID de la orden previamente almacenada
        /// Creado: Cristopher Noh 03/07/2020
        /// Modificado:
        /// </summary>
        /// <param name="psOrderId">ID de orden Conekta</param>
        /// <returns></returns>
        public IMDResponse <Guid> BGetOrderGuid(string psOrderId)
        {
            IMDResponse <Guid> response = new IMDResponse <Guid>();

            string metodo = nameof(this.BGetOrderGuid);

            logger.Info(IMDSerialize.Serialize(67823458160206, $"Inicia {metodo}(string psOrderId)", psOrderId));

            try
            {
                if (string.IsNullOrEmpty(psOrderId))
                {
                    response.Code    = 67823458219258;
                    response.Message = "No se ha podido determinar el ID de la orden.";
                    return(response);
                }

                IMDResponse <DataTable> respuestaGetOrderDB = datOrder.DGetOrder(psOrderId);
                if (respuestaGetOrderDB.Code != 0)
                {
                    return(respuestaGetOrderDB.GetResponse <Guid>());
                }
                if (respuestaGetOrderDB.Result.Rows.Count < 1)
                {
                    response.Code    = 67823458220035;
                    response.Message = "No se encontró la orden en la base de datos.";
                    return(response);
                }

                Guid uID = new Guid(respuestaGetOrderDB.Result.Rows[0]["uId"].ToString());

                response.Code    = 0;
                response.Message = "uId obtenido";
                response.Result  = uID;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458160983;
                response.Message = "Ocurrió un error inesperado al consultar el detalle de orden.";

                logger.Error(IMDSerialize.Serialize(67823458160983, $"Error en {metodo}(string psOrderId): {ex.Message}", psOrderId, ex, response));
            }
            return(response);
        }
Ejemplo n.º 23
0
        /// <summary>
        /// Función: Genera un ID de cupón
        /// Creado: Cristopher Noh 28/07/2020
        /// Modificado:
        /// </summary>
        /// <returns></returns>
        public IMDResponse <int> BNuevoIdCupon()
        {
            IMDResponse <int> response = new IMDResponse <int>();

            string metodo = nameof(this.BNuevoIdCupon);

            logger.Info(IMDSerialize.Serialize(67823458211488, $"Inicia {metodo}()"));

            try
            {
                IMDResponse <DataTable> respuestaObtenerId = datPromociones.DGetNewCouponID();
                if (respuestaObtenerId.Code != 0)
                {
                    return(respuestaObtenerId.GetResponse <int>());
                }

                IMDDataRow dr = new IMDDataRow(respuestaObtenerId.Result.Rows[0]);

                int nuevoCuponID = dr.ConvertTo <int>("iIdCupon");

                if (nuevoCuponID == 0)
                {
                    response.Code    = 67823458233244;
                    response.Message = "No se pudo generar el nuevo cupón.";
                    return(response);
                }

                response.Code   = 0;
                response.Result = nuevoCuponID;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458212265;
                response.Message = "Ocurrió un error inesperado al generar el nuevo ID del cupón.";

                logger.Error(IMDSerialize.Serialize(67823458212265, $"Error en {metodo}(): {ex.Message}", ex, response));
            }
            return(response);
        }
Ejemplo n.º 24
0
        /// <summary>
        /// Función: Aplica el cupón guardando en el campo de cupones canjeado
        /// Creado: Cristopher Noh 28/07/2020
        /// Modificado:
        /// </summary>
        /// <param name="piIdCupon">Cupón a aplicar</param>
        /// <param name="piIdUsuario">Usuario que aplica</param>
        /// <returns></returns>
        public IMDResponse <bool> BAplicarCupon(int piIdCupon, int?piIdUsuario = null)
        {
            IMDResponse <bool> response = new IMDResponse <bool>();

            string metodo = nameof(this.BAplicarCupon);

            logger.Info(IMDSerialize.Serialize(67823458195948, $"Inicia {metodo}(int piIdCupon, int? piIdUsuario = null)", piIdCupon, piIdUsuario));

            try
            {
                IMDResponse <EntCupon> respuestaValidarCupon = BValidarCupon(piIdCupon: piIdCupon);
                if (respuestaValidarCupon.Code != 0)
                {
                    return(respuestaValidarCupon.GetResponse <bool>());
                }

                EntCupon entCupon = new EntCupon();
                entCupon.fiIdCupon = piIdCupon;

                IMDResponse <bool> respuestaAplicarCupon = datPromociones.DSaveCupon(entCupon, piIdUsuario);
                if (respuestaAplicarCupon.Code != 0)
                {
                    return(respuestaAplicarCupon);
                }

                response.Code    = 0;
                response.Message = "Código aplicado.";
                response.Result  = true;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458196725;
                response.Message = "Ocurrió un error al intentar aplicar el código.";

                logger.Error(IMDSerialize.Serialize(67823458196725, $"Error en {metodo}(int piIdCupon, int? piIdUsuario = null): {ex.Message}", piIdCupon, piIdUsuario, ex, response));
            }
            return(response);
        }
Ejemplo n.º 25
0
        /// <summary>
        /// Función: Obtiene solo los nombres de cupones para autocompletado
        /// Creado: Cristopher Noh 14/08/2020
        /// Modificado:
        /// </summary>
        /// <returns></returns>
        public IMDResponse <List <string> > BGetCuponAutocomplete()
        {
            IMDResponse <List <string> > response = new IMDResponse <List <string> >();

            string metodo = nameof(this.BGetCuponAutocomplete);

            logger.Info(IMDSerialize.Serialize(67823458236352, $"Inicia {metodo}()"));

            try
            {
                IMDResponse <DataTable> respuestaObtenerCodigos = datPromociones.DGetCuponAutocomplete();
                if (respuestaObtenerCodigos.Code != 0)
                {
                    return(respuestaObtenerCodigos.GetResponse <List <string> >());
                }

                List <string> lstCodigos = new List <string>();
                foreach (DataRow fila in respuestaObtenerCodigos.Result.Rows)
                {
                    string codigo = fila["sCodigo"].ToString();
                    lstCodigos.Add(codigo);
                }

                lstCodigos = lstCodigos.GroupBy(x => x).Select(x => x.Key).OrderBy(x => x).ToList();

                response.Code    = 0;
                response.Message = "Códigos obtenidos.";
                response.Result  = lstCodigos;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458237129;
                response.Message = "Ocurrió un error inesperado al consultar los códigos.";

                logger.Error(IMDSerialize.Serialize(67823458237129, $"Error en {metodo}(): {ex.Message}", ex, response));
            }
            return(response);
        }
Ejemplo n.º 26
0
        public IMDResponse <List <EntProducto> > BGetProductoEmpresaExterna()
        {
            IMDResponse <List <EntProducto> > response = new IMDResponse <List <EntProducto> >();

            string metodo = nameof(this.BGetProductoEmpresaExterna);

            logger.Info(IMDSerialize.Serialize(67823458653601, $"Inicia {metodo}"));

            try
            {
                IMDResponse <List <EntProducto> > resGetProducts = this.BObtenerProductos(null);
                if (resGetProducts.Code != 0)
                {
                    return(resGetProducts.GetResponse <List <EntProducto> >());
                }

                List <EntProducto> productos = resGetProducts.Result.Where(x => x.bActivo && !x.bBaja && x.bComercial).OrderBy(x => x.iIdGrupoProducto).ThenByDescending(x => x.iIdTipoProducto).ThenBy(x => x.fCosto).ToList();

                if (productos.Count < 1)
                {
                    response.Code    = -24376876873456;
                    response.Message = "No se encontraron productos de Meditoc.";
                    return(response);
                }

                response.Code    = 0;
                response.Message = "Se han consultado los productos Meditoc.";
                response.Result  = productos;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458654378;
                response.Message = "Ocurrió un error inesperado al consultar los productos de Meditoc.";

                logger.Error(IMDSerialize.Serialize(67823458654378, $"Error en {metodo}: {ex.Message}", ex, response));
            }
            return(response);
        }
Ejemplo n.º 27
0
        /// <summary>
        /// Obtiene la foto del colaborador
        /// </summary>
        /// <param name="piIdColaborador"></param>
        /// <returns></returns>
        public IMDResponse <string> BGetColaboradorFoto(int piIdColaborador)
        {
            IMDResponse <string> response = new IMDResponse <string>();

            string metodo = nameof(this.BGetColaboradorFoto);

            logger.Info(IMDSerialize.Serialize(67823458484215, $"Inicia {metodo}(int piIdColaborador)", piIdColaborador));

            try
            {
                IMDResponse <byte[]> resGetFoto = this.BConvertColaboradorFoto(piIdColaborador);
                if (resGetFoto.Code != 0)
                {
                    return(resGetFoto.GetResponse <string>());
                }

                string sFoto = Convert.ToBase64String(resGetFoto.Result);
                if (string.IsNullOrWhiteSpace(sFoto))
                {
                    response.Code    = -232876708789;
                    response.Message = "El formato de la imagen del colaborador es incorrecto o el archivo esta dañado.";
                    return(response);
                }

                response.Code    = 0;
                response.Message = "La foto del colaborador ha sido obtenida.";
                response.Result  = sFoto;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458484992;
                response.Message = "Ocurrió un error inesperado al consultar la foto del colaborador.";

                logger.Error(IMDSerialize.Serialize(67823458484992, $"Error en {metodo}(int piIdColaborador): {ex.Message}", piIdColaborador, ex, response));
            }
            return(response);
        }
Ejemplo n.º 28
0
        /// <summary>
        /// Obtener los permisos del sistema o de un perfil proporcionado
        /// </summary>
        /// <param name="iIdPerfil"></param>
        /// <returns></returns>
        //NO SE USA
        public IMDResponse <List <EntPermisoSistema> > BObtenerPermisoxPerfil(int?iIdPerfil)
        {
            IMDResponse <List <EntPermisoSistema> > response = new IMDResponse <List <EntPermisoSistema> >();

            string metodo = nameof(this.BObtenerPermisoxPerfil);

            logger.Info(IMDSerialize.Serialize(67823458354456, $"Inicia {metodo}(int? iIdPermiso)", iIdPerfil));

            try
            {
                IMDResponse <DataSet> dtPermisos = datPermiso.DObtenerPermisosPorPerfil(iIdPerfil);
                if (dtPermisos.Code != 0)
                {
                    return(dtPermisos.GetResponse <List <EntPermisoSistema> >());
                }

                DataRowCollection drBotones    = dtPermisos.Result.Tables[2].Rows;
                DataRowCollection drSubmodulos = dtPermisos.Result.Tables[1].Rows;
                DataRowCollection drModulos    = dtPermisos.Result.Tables[0].Rows;

                List <EntPermisoSistema>   lstPermisoSistema   = new List <EntPermisoSistema>();
                List <EntSubModuloPermiso> lstPermisoSubModulo = new List <EntSubModuloPermiso>();
                List <EntBotonPermiso>     lstPermisoBotones   = new List <EntBotonPermiso>();

                //Leer los módulos, submódulos y botones que se tienen permitidos al perfil
                foreach (DataRow item in drBotones)
                {
                    IMDDataRow      dr       = new IMDDataRow(item);
                    EntBotonPermiso entBoton = new EntBotonPermiso();

                    entBoton.iIdBoton     = dr.ConvertTo <int>("iIdBoton");
                    entBoton.iIdModulo    = dr.ConvertTo <int>("iIdModulo");
                    entBoton.iIdSubModulo = dr.ConvertTo <int>("iIdSubModulo");
                    entBoton.sNombre      = dr.ConvertTo <string>("sNombre");

                    lstPermisoBotones.Add(entBoton);
                }

                foreach (DataRow item in drSubmodulos)
                {
                    IMDDataRow          dr           = new IMDDataRow(item);
                    EntSubModuloPermiso entSubModulo = new EntSubModuloPermiso();

                    entSubModulo.iIdModulo    = dr.ConvertTo <int>("iIdModulo");
                    entSubModulo.iIdSubModulo = dr.ConvertTo <int>("iIdSubModulo");
                    entSubModulo.sNombre      = dr.ConvertTo <string>("sNombre");

                    lstPermisoSubModulo.Add(entSubModulo);
                }

                foreach (DataRow item in drModulos)
                {
                    IMDDataRow        dr      = new IMDDataRow(item);
                    EntPermisoSistema permiso = new EntPermisoSistema();

                    permiso.iIdModulo = dr.ConvertTo <int>("iIdModulo");
                    permiso.sNombre   = dr.ConvertTo <string>("sNombre");

                    lstPermisoSistema.Add(permiso);
                }

                //Armar obtejo lista de los permisos
                lstPermisoBotones = lstPermisoBotones.GroupBy(x => new
                {
                    x.iIdModulo,
                    x.iIdSubModulo,
                    x.iIdBoton
                }).Select(x => new EntBotonPermiso
                {
                    iIdModulo    = x.Key.iIdModulo,
                    iIdSubModulo = x.Key.iIdSubModulo,
                    iIdBoton     = x.Key.iIdBoton,
                    sNombre      = x.Select(y => y.sNombre).First()
                }).ToList();

                lstPermisoSubModulo = lstPermisoSubModulo.GroupBy(x => new
                {
                    x.iIdModulo,
                    x.iIdSubModulo
                }).Select(x => new EntSubModuloPermiso
                {
                    iIdModulo    = x.Key.iIdModulo,
                    iIdSubModulo = x.Key.iIdSubModulo,
                    sNombre      = x.Select(y => y.sNombre).First(),
                    lstBotones   = lstPermisoBotones.Where(y => y.iIdModulo == x.Key.iIdModulo && y.iIdSubModulo == x.Key.iIdSubModulo).ToList()
                }).ToList();

                lstPermisoSistema = lstPermisoSistema.GroupBy(x => x.iIdModulo).Select(x => new EntPermisoSistema
                {
                    iIdModulo    = x.Key,
                    sNombre      = x.Select(y => y.sNombre).First(),
                    lstSubModulo = lstPermisoSubModulo.Where(y => y.iIdModulo == x.Key).ToList()
                }).ToList();

                response.Code    = 0;
                response.Message = "Lista de permisos";
                response.Result  = lstPermisoSistema;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458355233;
                response.Message = "Ocurrió un error inesperado al consultar los permisos.";

                logger.Error(IMDSerialize.Serialize(67823458355233, $"Error en {metodo}(int? iIdPermiso): {ex.Message}", iIdPerfil, ex, response));
            }
            return(response);
        }
Ejemplo n.º 29
0
        /// <summary>
        /// Obtener objeto de los permisos para mostrar/ocultar los elementos del sistema
        /// </summary>
        /// <param name="piIdPerfil"></param>
        /// <returns></returns>
        public IMDResponse <object> BGetUsuarioPermisos(int piIdPerfil)
        {
            IMDResponse <object> response = new IMDResponse <Object>();

            string metodo = nameof(this.BGetUsuarioPermisos);

            logger.Info(IMDSerialize.Serialize(67823458638061, $"Inicia {metodo}"));

            try
            {
                //Consultar los permisos del perfil, el perfil de superadministrador trae todos los elementos
                int?perfil = piIdPerfil == (int)EnumPerfilPrincipal.Superadministrador ? (int?)null : piIdPerfil;
                IMDResponse <List <EntPermisoSistema> > resGetPermisos = this.BObtenerPermisoxPerfil(perfil);
                if (resGetPermisos.Code != 0)
                {
                    return(resGetPermisos.GetResponse <object>());
                }
                if (resGetPermisos.Result.Count == 0)
                {
                    response.Code    = -23476876345;
                    response.Message = "El perfil del usuario aún no cuenta con permisos.";
                }

                JObject objModulos = new JObject();

                //Armar JSON con los permisos consultados
                foreach (EntPermisoSistema modulo in resGetPermisos.Result)
                {
                    JObject objSubmodulos = new JObject();
                    foreach (EntSubModuloPermiso submodulo in modulo.lstSubModulo)
                    {
                        JObject objBotones = new JObject();
                        foreach (EntBotonPermiso boton in submodulo.lstBotones)
                        {
                            JObject objBoton = new JObject();
                            objBoton.Add("Nombre", boton.sNombre);

                            objBotones.Add(boton.iIdBoton.ToString(), objBoton);
                        }

                        JObject objSubmodulo = new JObject();
                        objSubmodulo.Add("Nombre", submodulo.sNombre);
                        objSubmodulo.Add("Botones", objBotones);

                        objSubmodulos.Add(submodulo.iIdSubModulo.ToString(), objSubmodulo);
                    }

                    JObject objModulo = new JObject();
                    objModulo.Add("Nombre", modulo.sNombre);
                    objModulo.Add("Submodulos", objSubmodulos);

                    objModulos.Add(modulo.iIdModulo.ToString(), objModulo);
                }

                object obj = objModulos.ToObject <object>();

                response.Code    = 0;
                response.Message = "Se han obtenido los permisos del usuario.";
                response.Result  = obj;
            }
            catch (Exception ex)
            {
                response.Code    = 67823458638838;
                response.Message = "Ocurrió un error inesperado al consultar los permisos del usuario.";

                logger.Error(IMDSerialize.Serialize(67823458638838, $"Error en {metodo}: {ex.Message}", ex, response));
            }
            return(response);
        }
Ejemplo n.º 30
0
        /// <summary>
        /// Cancela la consulta y el folio de un paciente
        /// </summary>
        /// <param name="consulta"></param>
        /// <returns></returns>
        public IMDResponse <bool> BCancelarConsulta(EntNuevaConsulta consulta)
        {
            IMDResponse <bool> response = new IMDResponse <bool>();

            string metodo = nameof(this.BCancelarConsulta);

            logger.Info(IMDSerialize.Serialize(67823458552591, $"Inicia {metodo}(EntNuevaConsulta consulta)", consulta));

            try
            {
                if (consulta == null)
                {
                    response.Code    = -767234562313709;
                    response.Message = "No se ingresó información de la consulta a cancelar";
                    return(response);
                }

                //Obtene detalle de la consulta
                IMDResponse <List <EntDetalleConsulta> > resGetDetalleConsulta = this.BGetDetalleConsulta(consulta.consulta.iIdConsulta);
                if (resGetDetalleConsulta.Code != 0)
                {
                    return(resGetDetalleConsulta.GetResponse <bool>());
                }

                if (resGetDetalleConsulta.Result.Count != 1)
                {
                    response.Code    = -5723613487698;
                    response.Message = "La consulta proporcionada no se encuentra programada.";
                    return(response);
                }

                EntDetalleConsulta detalleConsulta = resGetDetalleConsulta.Result.First();

                consulta.consulta.iIdEstatusConsulta = (int)EnumEstatusConsulta.Cancelado;

                //Cancelar la consulta del paciente
                IMDResponse <bool> resDelConsulta = datConsulta.DCancelarConsulta(consulta.consulta.iIdConsulta, consulta.iIdUsuarioMod, (int)consulta.consulta.iIdEstatusConsulta);
                if (resDelConsulta.Code != 0)
                {
                    return(resDelConsulta);
                }

                //Cancelar el folio del paciente si éste fue generado con origen Particular
                if (detalleConsulta.iIdOrigen == (int)EnumOrigen.Particular)
                {
                    EntFolioFV entFolio = new EntFolioFV
                    {
                        iIdEmpresa = (int)detalleConsulta.iIdEmpresa,
                        iIdUsuario = consulta.iIdUsuarioMod,
                        lstFolios  = new List <EntFolioFVItem>
                        {
                            new EntFolioFVItem
                            {
                                iIdFolio = (int)detalleConsulta.iIdFolio
                            }
                        }
                    };
                    BusFolio           busFolio            = new BusFolio();
                    IMDResponse <bool> resDesactivarFolios = busFolio.BEliminarFoliosEmpresa(entFolio);
                    if (resDesactivarFolios.Code != 0)
                    {
                        return(resDesactivarFolios);
                    }
                }

                response.Code    = 0;
                response.Result  = true;
                response.Message = "La consulta ha sido cancelada correctamente.";
            }
            catch (Exception ex)
            {
                response.Code    = 67823458553368;
                response.Message = "Ocurrió un error inesperado al cancelar la consulta del paciente.";

                logger.Error(IMDSerialize.Serialize(67823458553368, $"Error en {metodo}(EntNuevaConsulta consulta): {ex.Message}", consulta, ex, response));
            }
            return(response);
        }