示例#1
0
文件: Pago.cs 项目: arielarmijos/Api
        /// <summary>
        /// Obtiene la información de un giro dado a partir de su ExternalId (ID Multipay 472)
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="id">ID Multipay 472 del giro</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Un objeto <c>DwhModel.Giro</c> que contiene la información del giro</returns>
        private DwhModel.GiroUltimaTransaccion GetInfoGiroPorExternalId(
            string sessionId,
            long id,
            string pin,
            out ErrorMessagesMnemonics returnCode,
            SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            DwhModel.GiroUltimaTransaccion ret = null;

            try
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                Dictionary <string, object> queryParams = new Dictionary <string, object>()
                {
                    { "@IdGiro", id.ToString() }
                };

                if (connection == null)
                {
                    using (connection = Movilway.API.Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        ret = Movilway.API.Utils.Dwh <DwhModel.GiroUltimaTransaccion> .ExecuteSingle(
                            connection,
                            Queries.Cash.GetInfoGiroPorExternalId,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    ret = Movilway.API.Utils.Dwh <DwhModel.GiroUltimaTransaccion> .ExecuteSingle(
                        connection,
                        Queries.Cash.GetInfoGiroPorExternalId,
                        queryParams,
                        null);
                }

                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Query ejecutado"));
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                ret        = new DwhModel.GiroUltimaTransaccion();
            }

            return(ret);
        }
示例#2
0
 /// <summary>
 /// Establece el error especificado en el objeto de respuesta de una petición
 /// </summary>
 /// <param name="response">Objeto de respuesta de la petición</param>
 /// <param name="code">Error a esteblecer</param>
 private void SetResponseErrorCode(AGenericApiResponse response, ErrorMessagesMnemonics code)
 {
     if (response != null)
     {
         response.ResponseCode    = (int)code;
         response.ResponseMessage = code.ToDescription();
     }
 }
示例#3
0
        /// <summary>
        /// Obtiene la información de un cliente dado
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="tipoIdentificacion">Tipo de identificación del cliente</param>
        /// <param name="numeroIdentificacion">Número de identificación del cliente</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Un objeto <c>DwhModel.Cliente</c> que contiene la información del cliente</returns>
        private List <Cash472.DwhModel.Ciudad> GetListCities(string sessionId, out ErrorMessagesMnemonics returnCode, SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            List <Cash472.DwhModel.Ciudad> listCities = new List <DwhModel.Ciudad>();

            try
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                Dictionary <string, object> queryParams = null;
                if (connection == null)
                {
                    using (connection = Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        listCities = Utils.Dwh <Cash472.DwhModel.Ciudad> .ExecuteReader(
                            connection,
                            Queries.Cash.ListCities,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    listCities = Utils.Dwh <Cash472.DwhModel.Ciudad> .ExecuteReader(
                        connection,
                        Queries.Cash.ListCities,
                        queryParams,
                        null);
                }

                if (listCities == null || listCities.Count == 0)
                {
                    returnCode = ErrorMessagesMnemonics.ErrorGetCities;
                    listCities = null;
                }

                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Query ejecutado"));
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                listCities = null;
            }

            return(listCities);
        }
示例#4
0
        /// <summary>
        /// Mapea los mensajes de error identificados a un código mnemotécnico
        /// </summary>
        /// <param name="message">Mensaje de error</param>
        /// <returns>Código mnemotécnico de error</returns>
        private ErrorMessagesMnemonics MapAuthenticationErrorMessageToErrorMnemonic(string message)
        {
            ErrorMessagesMnemonics ret = ErrorMessagesMnemonics.UnableToAuthenticate;

            if (!string.IsNullOrEmpty(message))
            {
                switch (message)
                {
                case "UserNotFound-Error de Login":
                    ret = ErrorMessagesMnemonics.InvalidUser;
                    break;

                case "WrongPassword-Error de Login":
                    ret = ErrorMessagesMnemonics.InvalidPassword;
                    break;

                default:
                    ret = ErrorMessagesMnemonics.UnableToAuthenticate;
                    break;
                }
            }

            return(ret);
        }
示例#5
0
        /// <summary>
        /// Actualiza en base de datos la información del giro estableciendolo como anulado
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="id">ID del giro a anular</param>
        /// <param name="error">Fuente del error</param>
        /// <param name="descripcion">Descripción del error</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Un <c>int</c> que contiene el número de registros afectados, cero en caso de falla</returns>
        private int AnularGiro(
            string sessionId,
            int id,
            string error,
            string descripcion,
            out ErrorMessagesMnemonics returnCode,
            SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            int ret = 0;

            try
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                Dictionary <string, object> queryParams = new Dictionary <string, object>()
                {
                    { "@IdGiro", id.ToString() },
                    { "@Error", error },
                    { "@IdEstado", Cash472.CashProvider.ObtenerCodigoEstadoGiro(EstadoGiro.ErrorProcesando) },
                    { "@Descripcion", descripcion }
                };

                if (connection == null)
                {
                    using (connection = Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        ret = (int)Utils.Dwh <int> .ExecuteScalar(
                            connection,
                            Queries.Cash.AnularGiro,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    ret = (int)Utils.Dwh <int> .ExecuteScalar(
                        connection,
                        Queries.Cash.AnularGiro,
                        queryParams,
                        null);
                }

                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Query ejecutado"));
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                ret        = 0;
            }

            return(ret);
        }
示例#6
0
        /// <summary>
        /// Inserta en base de datos la información del giro
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="request">Petición original</param>
        /// <param name="emisor">Cliente emisor</param>
        /// <param name="receptor">Cliente receptor</param>
        /// <param name="agencia">Información de la agencia originadora</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Un <c>int</c> que contiene el ID del cliente creado, cero en caso de falla</returns>
        private int InsertGiro(string sessionId, EmitirRequest request, DwhModel.Cliente emisor, DwhModel.Cliente receptor, DwhModel.Agencia agencia, out ErrorMessagesMnemonics returnCode, SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            int ret = 0;

            try
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                Dictionary <string, object> queryParams = new Dictionary <string, object>()
                {
                    { "@EmisorId", emisor.Id },
                    { "@ReceptorId", receptor.Id },
                    { "@EstadoId", Cash472.CashProvider.ObtenerCodigoEstadoGiro(EstadoGiro.EnProceso) },
                    { "@Pdv", request.Pdv },
                    { "@TotalRecibido", request.ValorRecibido },
                    { "@TotalAEntregar", request.ValorAEntregar },
                    { "@Flete", request.ValorFlete },
                    { "@IncluyeFlete", request.IncluyeFlete },
                    { "@CiudadOrigenDANE", request.CiudadPdv },
                    { "@CiudadDestinoDANE", request.CiudadDestino },
                    { "@AgenciaId", agencia.BranchId },
                    { "@AgenciaNombre", agencia.LegalName.Replace("'", "''") },
                    { "@AgenciaDireccion", agencia.Address.Replace("'", "''") },
                    { "@AccesoTipo", request.DeviceType },
                    { "@Acceso", request.AuthenticationData.Username }
                };

                if (connection == null)
                {
                    using (connection = Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        ret = (int)Utils.Dwh <int> .ExecuteScalar(
                            connection,
                            Queries.Cash.InsertGiro,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    ret = (int)Utils.Dwh <int> .ExecuteScalar(
                        connection,
                        Queries.Cash.InsertGiro,
                        queryParams,
                        null);
                }

                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Query ejecutado"));
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                ret        = 0;
            }

            return(ret);
        }
示例#7
0
        /// <summary>
        /// Inserta un nuevo cliente en base de datos
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="idCliente">ID en base de datos del cliente a actualizar</param>
        /// <param name="cliente">Información básica del cliente</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Un <c>int</c> que contiene el ID del cliente creado, cero en caso de falla</returns>
        private bool ActualizarCliente(string sessionId, int idCliente, DataContract.Cash472.Cliente cliente, out ErrorMessagesMnemonics returnCode, SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            bool ret = false;

            try
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                long tipo = Cash472.CashProvider.ObtenerCodigoTipoIdentificacion(cliente.TipoIdentificacion);
                Dictionary <string, object> queryParams = new Dictionary <string, object>()
                {
                    { "@ClienteId", idCliente },
                    { "@FechaExpedicion", (cliente.FechaExpedicion != null && cliente.FechaExpedicion.HasValue) ? (object)cliente.FechaExpedicion.Value.ToString("yyyy-MM-dd") : DBNull.Value },
                    { "@RazonSocial", DBNull.Value },
                    { "@PrimerNombre", cliente.PrimerNombre.Trim() },
                    { "@SegundoNombre", !string.IsNullOrEmpty(cliente.SegundoNombre) ? (object)cliente.SegundoNombre : DBNull.Value },
                    { "@PrimerApellido", cliente.PrimerApellido.Trim() },
                    { "@SegundoApellido", !string.IsNullOrEmpty(cliente.SegundoApellido) ? (object)cliente.SegundoApellido : DBNull.Value },
                    { "@Ciudad", cliente.CiudadDomicilio },
                    { "@Direccion", !string.IsNullOrEmpty(cliente.Direccion) ? (object)cliente.Direccion : DBNull.Value },
                    { "@Telefono", cliente.Telefono },
                    { "@Celular", (cliente.Celular != null && cliente.Celular.HasValue) ? (object)cliente.Celular.Value : DBNull.Value }
                };

                int modicados = 0;
                if (connection == null)
                {
                    using (connection = Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        modicados = Utils.Dwh <int> .ExecuteNonQuery(
                            connection,
                            Queries.Cash.UpdateCliente,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    modicados = Utils.Dwh <int> .ExecuteNonQuery(
                        connection,
                        Queries.Cash.UpdateCliente,
                        queryParams,
                        null);
                }

                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Query ejecutado"));
                ret = modicados == 1;
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                ret        = false;
            }

            return(ret);
        }
示例#8
0
        /// <summary>
        /// Obtiene la información de un cliente dado
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="id">ID interno del giro</param>
        /// <param name="externalId">ID externo del giro</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Un objeto <c>DwhModel.Cliente</c> que contiene la información del cliente</returns>
        private Movilway.API.Service.ExtendedApi.DataContract.Cash472.Factura GetInfoFactura(string sessionId, long id, long externalId, out ErrorMessagesMnemonics returnCode, SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            Movilway.API.Service.ExtendedApi.DataContract.Cash472.Factura ret = null;

            try
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                string query = id != 0 ? Queries.Cash.GetInfoFacturaById : Queries.Cash.GetInfoFacturaByExternalId;
                Dictionary <string, object> queryParams = new Dictionary <string, object>()
                {
                    { "@Id", id != 0 ? id : externalId }
                };

                if (connection == null)
                {
                    using (connection = Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        ret = Utils.Dwh <Movilway.API.Service.ExtendedApi.DataContract.Cash472.Factura> .ExecuteSingle(
                            connection,
                            query,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    ret = Utils.Dwh <Movilway.API.Service.ExtendedApi.DataContract.Cash472.Factura> .ExecuteSingle(
                        connection,
                        query,
                        queryParams,
                        null);
                }

                if (ret == null || ret.Id == 0)
                {
                    returnCode = ErrorMessagesMnemonics.UnableToFindOrderRecordInLocalDatabase;
                    ret        = null;
                }

                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Query ejecutado"));
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                ret        = null;
            }

            return(ret);
        }
示例#9
0
        /// <summary>
        /// Inserta en base de datos la información del giro creado
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="request">Petición original</param>
        /// <param name="emisor">Cliente emisor</param>
        /// <param name="receptor">Cliente receptor</param>
        /// <param name="constitucion">Respuesta WS constitución</param>
        /// <param name="emision">Respuesta WS emisión</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Un <c>int</c> que contiene el ID del cliente creado, cero en caso de falla</returns>
        private int InsertGiroCash472(
            string sessionId,
            EmitirRequest request,
            DwhModel.Cliente emisor,
            DwhModel.Cliente receptor,
            MultiPay472.RespuestaValidacionConstitucionGiro constitucion,
            MultiPay472.RespuestaEmisionGiro emision,
            out ErrorMessagesMnemonics returnCode,
            SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            int ret = 0;

            try
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                Dictionary <string, object> queryParams = new Dictionary <string, object>()
                {
                    { "@EmisorId", emisor.Id },
                    { "@ReceptorId", receptor.Id },
                    { "@Pdv", request.Pdv },
                    { "@TotalRecibido", request.ValorRecibido },
                    { "@TotalAEntregar", Convert.ToInt64(constitucion.Monto) },
                    { "@Flete", Convert.ToInt64(constitucion.ValorFlete) },
                    { "@IncluyeFlete", request.IncluyeFlete },
                    { "@FechaConstitucion", Cash472.CashProvider.ObtenerFechaDesdeString(constitucion.Fecha) },
                    { "@FechaEmision", Cash472.CashProvider.ObtenerFechaDesdeString(emision.Fecha) },
                    { "@CiudadOrigen", request.CiudadPdv },
                    { "@CiudadDestino", request.CiudadDestino },
                    { "@CodigoTransaccionConstitucion", constitucion.CodigoTransaccion },
                    { "@CodigoTransaccionEmision", emision.CodigoTransaccion },
                    { "@Token", constitucion.Token },
                    { "@Pin", emision.PIN },
                    { "@CodigoAutorizacion", emision.CodigoAutorizacion },
                    { "@NumeroFactura", emision.NumeroFactura },
                    { "@NumeroTransaccion", emision.NumeroReferencia },
                    { "@ExternalId", emision.IdGiro }
                };

                if (connection == null)
                {
                    using (connection = Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        ret = (int)Utils.Dwh <int> .ExecuteScalar(
                            connection,
                            Queries.Cash.InsertGiroCash472,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    ret = (int)Utils.Dwh <int> .ExecuteScalar(
                        connection,
                        Queries.Cash.InsertGiroCash472,
                        queryParams,
                        null);
                }

                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Query ejecutado"));
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                ret        = 0;
            }

            return(ret);
        }
示例#10
0
        /// <summary>
        /// Realiza la autenticacion en la plataforma y retorna el SessionId
        /// </summary>
        /// <param name="request">Objeto que contiene las credenciales del usuario</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <returns>Un <c>string</c> que contiene el <c>SessionId</c> del usuario autenticado</returns>
        protected string GetSessionId(ASecuredApiRequest request, out ErrorMessagesMnemonics returnCode)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;

            this.ProviderLogger.InfoLow(() => TagValue.New()
                                        .MethodName(methodName)
                                        .Message("Obteniendo sesion ...")
                                        .Tag("Login").Value((request.AuthenticationData != null && request.AuthenticationData.Username != null) ? request.AuthenticationData.Username : "******")
                                        .Tag("DeviceType").Value(request.DeviceType)
                                        .Tag("RequestPlatformId").Value(string.IsNullOrEmpty(request.Platform) ? string.Empty : request.Platform));

            if (!this.ValidSecureApiRequest(request))
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("Imposible obtener sesion")
                                            .Tag("Login").Value((request.AuthenticationData != null && request.AuthenticationData.Username != null) ? request.AuthenticationData.Username : "******")
                                            .Tag("DeviceType").Value(request.DeviceType)
                                            .Tag("RequestPlatformId").Value(string.IsNullOrEmpty(request.Platform) ? string.Empty : request.Platform));

                returnCode = ErrorMessagesMnemonics.MissingAuthenticationInformation;
                return(string.Empty);
            }

            GetSessionResponseBody sessionResponse = new ServiceExecutionDelegator <GetSessionResponseBody, GetSessionRequestBody>()
                                                     .ResolveRequest(
                new GetSessionRequestBody()
            {
                Username   = request.AuthenticationData.Username,
                Password   = request.AuthenticationData.Password,
                DeviceType = request.DeviceType
            },
                request.Platform ?? string.Empty,
                ApiServiceName.GetSession);

            if (sessionResponse == null ||
                string.IsNullOrEmpty(sessionResponse.SessionID) ||
                sessionResponse.SessionID.Equals("0") ||
                sessionResponse.SessionID.Equals("error"))
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("Imposible obtener sesion")
                                            .Tag("Login").Value((request.AuthenticationData != null && request.AuthenticationData.Username != null) ? request.AuthenticationData.Username : "******")
                                            .Tag("DeviceType").Value(request.DeviceType)
                                            .Tag("RequestPlatformId").Value(string.IsNullOrEmpty(request.Platform) ? string.Empty : request.Platform));

                returnCode = this.MapAuthenticationErrorMessageToErrorMnemonic(sessionResponse != null ? sessionResponse.ResponseMessage : null);
                return(string.Empty);
            }
            else
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionResponse.SessionID + "] " + "Sesion obtenida")
                                            .Tag("SessionId").Value(sessionResponse.SessionID));
            }

            return(sessionResponse.SessionID);
        }
示例#11
0
        /// <summary>
        /// Realiza la autenticacion en la plataforma y retorna el SessionId
        /// </summary>
        /// <param name="request">Objeto que contiene las credenciales del usuario</param>
        /// <param name="response">Objeto base de respuesta</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <returns>Un <c>String</c> que contiene el <c>SessionId</c> del usuario autenticado</returns>
        protected string GetSessionId(ASecuredApiRequest request, AGenericApiResponse response, out ErrorMessagesMnemonics returnCode)
        {
            returnCode = ErrorMessagesMnemonics.None;

            string sessionId = this.GetSessionId(request, out returnCode);

            if (returnCode != ErrorMessagesMnemonics.None)
            {
                response.ResponseCode    = (int)returnCode;
                response.ResponseMessage = returnCode.ToDescription();
            }

            return(sessionId);
        }
示例#12
0
文件: Pago.cs 项目: arielarmijos/Api
        /// <summary>
        /// Inserta en base de datos la información de un pago
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="request">Petición original</param>
        /// <param name="giro">Giro original</param>
        /// <param name="cliente">Información del cliente</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Un <c>int</c> que contiene el ID del pago creado, cero en caso de falla</returns>
        private int InsertPago(
            string sessionId,
            PagoRequest request,
            DwhModel.GiroUltimaTransaccion giro,
            DwhModel.Cliente cliente,
            out ErrorMessagesMnemonics returnCode,
            SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            int ret = 0;

            try
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                bool exists = giro.Id != 0;
                Dictionary <string, object> queryParams = new Dictionary <string, object>()
                {
                    { "@GiroId", giro.Id > 0   ? (object)giro.Id : DBNull.Value },
                    { "@ExternalId", request.Id },
                    { "@EmisorId", giro.EmisorId > 0 ? (object)giro.EmisorId : DBNull.Value },
                    { "@ReceptorId", cliente.Id },
                    { "@Pdv", request.Pdv },
                    { "@CiudadPdv", request.CiudadPdv },
                    { "@TotalRecibido", request.ValorRecibidoTotal },
                    { "@TotalAEntregar", request.Valor },
                    { "@Flete", request.ValorFlete },
                    { "@IncluyeFlete", request.IncluyeFlete },
                    { "@ValorPago", request.Valor }
                };

                if (connection == null)
                {
                    using (connection = Movilway.API.Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        ret = (int)Movilway.API.Utils.Dwh <int> .ExecuteScalar(
                            connection,
                            Queries.Cash.InsertPago,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    ret = (int)Movilway.API.Utils.Dwh <int> .ExecuteScalar(
                        connection,
                        Queries.Cash.InsertPago,
                        queryParams,
                        null);
                }

                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Query ejecutado"));
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                ret        = 0;
            }

            return(ret);
        }
示例#13
0
        /// <summary>
        /// Obtiene la información de un cliente en listas restrictivas
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="tipoIdentificacion">Tipo de identificación del cliente</param>
        /// <param name="numeroIdentificacion">Número de identificación del cliente</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (0 = OK, >0 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Entero que indica las veces en que el cliente esta en listas restrictivas</returns>
        private int GetInfoClienteListasRestrictivas(string sessionId, TipoIdentificacion tipoIdentificacion, string numeroIdentificacion, out ErrorMessagesMnemonics returnCode, SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            int ret = 0;

            try
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                long tipo = Cash472.CashProvider.ObtenerCodigoTipoIdentificacion(tipoIdentificacion);
                Dictionary <string, object> queryParams = new Dictionary <string, object>()
                {
                    { "@TipoIdentificacionId", tipo },
                    { "@NumeroIdentificacion", numeroIdentificacion }
                };

                if (connection == null)
                {
                    using (connection = Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        ret = (int)Utils.Dwh <int> .ExecuteScalar(
                            connection,
                            Queries.Cash.GetOcurrenciasClienteListasRestrictivas,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    ret = (int)Utils.Dwh <int> .ExecuteScalar(
                        connection,
                        Queries.Cash.GetOcurrenciasClienteListasRestrictivas,
                        queryParams,
                        null);
                }

                if (ret > 0)
                {
                    returnCode = ErrorMessagesMnemonics.InvalidUser;
                }

                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Query ejecutado, número ocurrencias: " + ret.ToString()));
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                ret        = -1;
            }

            return(ret);
        }
示例#14
0
        /// <summary>
        /// Consulta de un cliente
        /// </summary>
        /// <param name="request">Objeto que contiene todos los datos de autenticacion del usuario e información de la consulta</param>
        /// <returns>Información del cliente en caso de que exista</returns>
        public ConsultaClienteResponse ConsultaCliente(ConsultaClienteRequest request)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            this.LogRequest(request);

            ConsultaClienteResponse response = new ConsultaClienteResponse();
            string sessionId = this.GetSessionId(request, response, out this.errorMessage);

            if (this.errorMessage != ErrorMessagesMnemonics.None)
            {
                this.LogResponse(response);
                return(response);
            }

            if (!request.IsValidRequest())
            {
                this.SetResponseErrorCode(response, ErrorMessagesMnemonics.InvalidRequiredFields);
                this.LogResponse(response);
                return(response);
            }

            // Validar en listas restrictivas
            ErrorMessagesMnemonics errorMessageRestrictiva = ErrorMessagesMnemonics.None;
            int ocurrenciaListas = this.GetInfoClienteListasRestrictivas(sessionId, request.TipoIdentificacion, request.NumeroIdentificacion, out errorMessageRestrictiva);

            // Obtener informacion del cliente en BD
            ErrorMessagesMnemonics errorMessageCliente = ErrorMessagesMnemonics.None;

            DwhModel.Cliente infoCliente = this.GetInfoCliente(sessionId, request.TipoIdentificacion, request.NumeroIdentificacion, out errorMessageCliente);

            if (errorMessageRestrictiva != ErrorMessagesMnemonics.None && errorMessageCliente == ErrorMessagesMnemonics.None)
            {
                // Cliente en listas restrictivas y enrolado
                if (request.FechaExpedicion != null && request.FechaExpedicion.HasValue)
                {
                    if (infoCliente.FechaExpedicion == null && !infoCliente.FechaExpedicion.HasValue)
                    {
                        // Cliente enrolado sin Fecha de expedicion
                        this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientWithoutDateEspeditionLists);
                        response.Cliente = new DataContract.Cash472.Cliente();
                        this.EstablecerValoresCliente(response.Cliente, infoCliente);
                    }
                    else if (request.FechaExpedicion.Value.ToString("yyyy-MM-dd").Equals(infoCliente.FechaExpedicion.Value.ToString("yyyy-MM-dd")))
                    {
                        // Cliente enrolado con la misma fecha de expedicion
                        this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientInRestrictiveListsAndDatabase);
                        response.Cliente = new DataContract.Cash472.Cliente();
                        this.EstablecerValoresCliente(response.Cliente, infoCliente);
                    }
                    else
                    {
                        // Cliente enrolado con otra fecha de expedicion
                        this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientWithAnotherDateEspeditionLists);
                    }
                }
                else
                {
                    // Cliente enrolado no importa la fecha de expedicion
                    this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientInRestrictiveListsAndDatabase);
                    response.Cliente = new DataContract.Cash472.Cliente();
                    this.EstablecerValoresCliente(response.Cliente, infoCliente);
                }
            }
            else if (errorMessageRestrictiva != ErrorMessagesMnemonics.None && errorMessageCliente != ErrorMessagesMnemonics.None)
            {
                // Cliente en listas restrictivas y no enrolado.
                this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientInRestrictiveListsAndNotInDatabase);
            }
            else if (errorMessageRestrictiva == ErrorMessagesMnemonics.None && errorMessageCliente != ErrorMessagesMnemonics.None)
            {
                // Cliente No esta en listas restrictivas y no esta enrolado.
                this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientNotInRestrictiveListsAndNotInDatabase);
            }
            else if (errorMessageRestrictiva == ErrorMessagesMnemonics.None && errorMessageCliente == ErrorMessagesMnemonics.None)
            {
                // Cliente No esta en listas restrictivas y enrolado.
                if (request.FechaExpedicion != null && request.FechaExpedicion.HasValue)
                {
                    if (infoCliente.FechaExpedicion == null && !infoCliente.FechaExpedicion.HasValue)
                    {
                        // Cliente enrolado con  fecha de expedicion null
                        this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientWithoutDateEspeditionNoLists);
                        response.Cliente = new DataContract.Cash472.Cliente();
                        this.EstablecerValoresCliente(response.Cliente, infoCliente);
                    }
                    else if (request.FechaExpedicion.Value.ToString("yyyy-MM-dd").Equals(infoCliente.FechaExpedicion.Value.ToString("yyyy-MM-dd")))
                    {
                        // Cliente enrolado con la misma fecha de expedicion
                        this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientNotInRestrictiveListsAndInDatabase);
                        response.Cliente = new DataContract.Cash472.Cliente();
                        this.EstablecerValoresCliente(response.Cliente, infoCliente);
                    }
                    else
                    {
                        // Cliente enrolado con otra fecha de expedicion
                        this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientWithAnotherDateEspeditionNoLists);
                    }
                }
                else
                {
                    // Cliente enrolado no importa la fecha de expedicion
                    this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientNotInRestrictiveListsAndInDatabase);
                    response.Cliente = new DataContract.Cash472.Cliente();
                    this.EstablecerValoresCliente(response.Cliente, infoCliente);
                }
            }
            else
            {
                this.SetResponseErrorCode(response, ErrorMessagesMnemonics.ClientNotInRestrictiveListsAndNotInDatabase);
            }

            this.LogResponse(response);
            return(response);
        }
示例#15
0
        /// <summary>
        /// Obtiene la información de un cliente dado
        /// </summary>
        /// <param name="sessionId">Session ID que será escrito en los logs</param>
        /// <param name="tipoIdentificacion">Tipo de identificación del cliente</param>
        /// <param name="numeroIdentificacion">Número de identificación del cliente</param>
        /// <param name="returnCode">Codigo de error en caso de que algo falle (-1 = OK, >-1 = Error)</param>
        /// <param name="connection">Objeto de conexión a base de datos</param>
        /// <returns>Un objeto <c>DwhModel.Cliente</c> que contiene la información del cliente</returns>
        private DwhModel.Cliente GetInfoCliente(string sessionId, TipoIdentificacion tipoIdentificacion, string numeroIdentificacion, out ErrorMessagesMnemonics returnCode, SqlConnection connection = null)
        {
            string methodName = string.Format("{0}", System.Reflection.MethodBase.GetCurrentMethod().Name);

            returnCode = ErrorMessagesMnemonics.None;
            DwhModel.Cliente ret = null;

            try
            {
                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Ejecutando query ..."));

                long tipo = Cash472.CashProvider.ObtenerCodigoTipoIdentificacion(tipoIdentificacion);
                Dictionary <string, object> queryParams = new Dictionary <string, object>()
                {
                    { "@TipoIdentificacionId", tipo },
                    { "@NumeroIdentificacion", numeroIdentificacion }
                };

                if (connection == null)
                {
                    using (connection = Utils.Database.GetCash472DbConnection())
                    {
                        connection.Open();
                        ret = Utils.Dwh <DwhModel.Cliente> .ExecuteSingle(
                            connection,
                            Queries.Cash.GetInfoCliente,
                            queryParams,
                            null);
                    }
                }
                else
                {
                    ret = Utils.Dwh <DwhModel.Cliente> .ExecuteSingle(
                        connection,
                        Queries.Cash.GetInfoCliente,
                        queryParams,
                        null);
                }

                if (ret == null || ret.Id == 0)
                {
                    returnCode = ErrorMessagesMnemonics.UnableToFindUserInLocalDatabase;
                    ret        = null;
                }

                this.ProviderLogger.InfoLow(() => TagValue.New()
                                            .MethodName(methodName)
                                            .Message("[" + sessionId + "] " + "Query ejecutado"));
            }
            catch (Exception ex)
            {
                this.ProviderLogger.ExceptionLow(() => TagValue.New()
                                                 .MethodName(methodName)
                                                 .Message("[" + sessionId + "] " + "Error ejecutando query")
                                                 .Exception(ex));
                returnCode = ErrorMessagesMnemonics.InternalDatabaseError;
                ret        = null;
            }

            return(ret);
        }