/// <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);
}
/// <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();
}
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}
/// <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);
}