Este paquete debe ser ejecutado en BAPY PRODUCCION
CREATE OR REPLACE PACKAGE BODY PKG_DIMO_CEIBO IS
CREATE OR REPLACE PACKAGE BODY PKG_DIMO_CEIBO IS
-- Private type declarations
--Variable de Historico y tabla para registrar el historico.
VR_HISTORICO HISTORICO_CUENTAS%ROWTYPE;
TYPE T_HISTORICO IS TABLE OF HISTORICO_CUENTAS%ROWTYPE INDEX BY BINARY_INTEGER;
VR_HISTORICOS T_HISTORICO;
VC_HISTORICO HISTORICO_CUENTAS%ROWTYPE;
-- Private constant declarations
CC_DIMO VARCHAR2(4) := 'DIMO';
CC_USUARIO_DIMO VARCHAR2(10) := 'DIMO';
CC_ENT_DIMO_NOV NUMBER := 805;
CC_CAPTADOR_DIMO VARCHAR2(2) := '00';
CC_CORRESPONDENCIA_DIMO VARCHAR2(1) := 'I';
CC_TIPO_DATO_LOG CREDITOPY.CEIBO_LOG.TIPO_DATO%TYPE;
CC_DELAY_SECONDS NUMBER := 2;
-- mantis#2672 Origen bloqueo de Tarjetas 1-Usuario; 2-Entidad
CC_BLOQUEO_USUARIO BINARY_INTEGER := 1;
CC_BLOQUEO_ENTIDAD BINARY_INTEGER := 2;
-- Constantes por tipo de novedad
CC_NOVTIP_IMP_PLASTICO_TP NUMBER(3) := 400;
CC_ORIGEN_IMP_PLASTICO_TP NUMBER(4) := 13;
CC_ESTADO_TP_EN_PROCESO NUMBER(4) := 9;
CC_ESTADO_TP_OPERATIVA NUMBER(4) := 1;
CC_ESTADO_BLOQ_ENTIDAD NUMBER(4) := 4;
CC_ESTADO_BLOQ_USUARIO NUMBER(4) := 5;
FORMATO_FECHA CONSTANT CHAR(21) := 'DD/MM/YYYY HH24:MI:SS';
--FORMATO_FECHA_CORTO CONSTANT CHAR(10) := 'DD/MM/YYYY';
--Constantes para JOBS de Fechas estados Cuentas y Tarjetas.
JOB_ALTAS CONSTANT VARCHAR2(10) := 'ALTAS-OL';
/*
JOB_ALTA_ADICIONAL CONSTANT VARCHAR2(10) := 'ADIC-OL';
JOB_REPOSICION CONSTANT VARCHAR2(10) := 'REPOS-OL';
JOB_REACTIVACION CONSTANT VARCHAR2(10) := 'REACTIV-OL';
JOB_CTAMODIFICACION CONSTANT VARCHAR2(10) := 'CTAMOD-OL';
JOB_DENUNCIAS CONSTANT VARCHAR2(10) := 'DENUN-OL';
*/
-- Private variable declarations
VR_LOG CEIBO_LOG%ROWTYPE;
PV_USUARIO VARCHAR2(16);
PV_JOB_NOMBRE VARCHAR2(10);
PV_BITACORA_ID CEIBO_LOG.BITACORA_ID%TYPE;
PV_LOG_LEN BINARY_INTEGER := 2048;
PV_EMISOR_DIMO TARJETAS.EMISOR%TYPE;
PV_GRUPO_AFINIDAD CREDITOPY.GRUPOS_AFINIDAD.GRUPO_AFINIDAD%TYPE;
PV_PROMOTOR_ID DEBCREDPY.CAPTADORES.CODIGO_CAPTADOR%TYPE;
PV_ESTADO_TJ_ALTA CREDITOPY.TARJETAS.ESTADO%TYPE;
PV_ID_TIPO_PLASTICO CREDITOPY.TARJETAS_PREPAGA.ID_TIPO_TARJETA_PREPAGA%TYPE;
/*
PV_RAISE_MSG VARCHAR2(512);
PV_NOVEDAD HISTORICO_COMERCIOS.NOVEDAD%TYPE;
*/
PV_REGLA_ID NOVEDADES_OL_REGLAS.REGLA_ID%TYPE;
PV_MENSAJE VARCHAR2(4096);
PV_FEC_REG_ALTA DATE;
-- Private variable declarations
-- Variable de Novedades Cuentas y Tarjetas
VR_NOVEDAD_CUENTA NOVEDADES_CUENTAS@OLPY%ROWTYPE;
VR_NOVEDAD_TARJETA NOVEDADES_TARJETAS@OLPY%ROWTYPE;
-- Variables de Tablas Principales
VR_PERSONA DEBCREDPY.PERSONAS%ROWTYPE;
VR_CUENTA CUENTAS%ROWTYPE;
VR_TARJETA TARJETAS%ROWTYPE;
VR_TARJETAS_PREPAGA CREDITOPY.TARJETAS_PREPAGA%ROWTYPE;
VR_DIRECCION DIRECCIONES%ROWTYPE;
VR_CELULAR DIRECCIONES%ROWTYPE;
VR_EMAIL DIRECCIONES%ROWTYPE;
VR_SALDO_CUENTA SALDOS_CUENTAS%ROWTYPE;
VR_LIMITES LIMITES_CUENTAS@OLPY%ROWTYPE;
-- Variables de tablas secundarias.
VR_EMISOR_PRODUCTO DEBCREDPY.EMISORES_PRODUCTOS%ROWTYPE;
VR_CALENDARIO_CIERRE CALENDARIO_CIERRES%ROWTYPE;
VR_CORRESPONDENCIA CODIGOS_CORRESPONDENCIA%ROWTYPE;
VR_AFINIDAD GRUPOS_AFINIDAD%ROWTYPE;
VR_CIUDAD DEBCREDPY.CIUDADES%ROWTYPE;
VR_CARTERA DEBCREDPY.CARTERAS%ROWTYPE;
VR_SUCURSAL DEBCREDPY.SUCURSALES_EMISORES%ROWTYPE;
VR_EMISOR DEBCREDPY.EMISORES%ROWTYPE;
VR_SEXO DEBCREDPY.SEXOS%ROWTYPE;
VR_ESTADO_CIVIL DEBCREDPY.ESTADOS_CIVILES%ROWTYPE;
VR_OCUPACION DEBCREDPY.OCUPACIONES%ROWTYPE;
VR_PROMOTOR DEBCREDPY.CAPTADORES%ROWTYPE;
-- Function and procedure implementations
FUNCTION fn_get_limite(fn_emisor IN creditopy.CUENTAS.emisor%TYPE,
fn_numero_cuenta IN creditopy.CUENTAS.numero_cuenta%TYPE,
fn_plan IN NUMBER) RETURN NUMBER IS
vn_limite NUMBER;
/*****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 24/04/2019
Origen: de la consulta de limites utilizada en el formulario Cuenta.jsp del AccesoCabal
Propósito: Función que retorna el valor del limite correspondiente a una cuenta teniendo como datos de
entrada: el emisor, el numero de cuenta y el plan de venta.
Los planes que definen los límites son:
- Plan: Normal (Unificado) , Codigo: 1. ** Contado (lineas separadas) **
- Plan: Cuotas , Codigo: 3.
- Plan: Adelanto Efectivo , Codigo: 4.
- Plan: Salud , Codigo: 9.
Observación: los limites no se toman de la tabla creditopy.CUENTAS (Batch) porque las
actualizaciones de limites no se impactan hasta el cierre de diaria en el Batch,
y el limite utilizado para el calculo del disponible es el del Online
******************************************************************************************************/
BEGIN
SELECT limite
INTO vn_limite
FROM creditopy.limites_cuentas@olpy olc
WHERE olc.emisor = fn_emisor
AND olc.numero_cuenta = fn_numero_cuenta
AND olc.plan_venta = fn_plan;
RETURN vn_limite;
EXCEPTION
WHEN no_data_found THEN
vn_limite := 0;
RETURN vn_limite;
WHEN OTHERS THEN
RAISE;
END fn_get_limite;
FUNCTION fn_get_pagos_ol(fn_numero_cuenta IN creditopy.CUENTAS.numero_cuenta%TYPE)
RETURN NUMBER IS
vn_pagos_ol NUMBER;
/**********************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 24/04/2019
Origen: regla '100261'
Propósito: Función que retorna el total de los pagos en línea aún no procesados a la cuenta
Se realizara la consulta al OL teniendo como dato de entrada el numero de cuenta.
En la regla original los pagos corresponden a los ingresados en linea sin importar
que esten o no procesados ya por el cierre.
En la version original se toman los no procesados, pero se incluyeron controles adicionales
de forma a tomar los que estan procesados siempre que el proceso de carga de pagos a las
cuentas en el batch no este finalizado.
**********************************************************************************************/
BEGIN
SELECT SUM(DECODE(codigo_operacion,
0,
DECODE(moneda, 830, -importe, -importe * cotizacion),
DECODE(moneda, 830, importe, importe * cotizacion)))
INTO vn_pagos_ol
FROM creditopy.log_transacc_cr@olpy
WHERE nro_cuenta = fn_numero_cuenta
AND plan = 6
AND TIPO_AUTORIZACION = 'A'
AND ( -- no deben estar en proceso de cierre
autextproc IS NULL OR
-- si estan en proceso de cierre
-- solo se suman mientras no termina el proceso de carga de pagos
(autextproc IS NOT NULL AND
0 = nvl((SELECT MAX(1)
FROM creditopy.CONTROL_DATOS cd
WHERE cd.nombre_proceso = 'PAGOS'
AND cd.fecha_proceso >= trunc(autextfch)
AND cd.resultado = 1),
0)));
RETURN NVL(vn_pagos_ol, 0);
EXCEPTION
-- cuando hay sum no sale por no_data_found, solo no suma, se puede omitir
WHEN OTHERS THEN
RAISE;
END fn_get_pagos_ol;
FUNCTION fn_get_ajustes_ol(fn_numero_cuenta IN creditopy.CUENTAS.numero_cuenta%TYPE,
fn_codigo_operacion IN creditopy.movimientos_ajustes.codigo_operacion%TYPE)
RETURN NUMBER IS
vn_ajustes_db_ol NUMBER;
vn_ajustes_cr_ol NUMBER;
vn_codigo_operacion INTEGER;
/*******************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 24/04/2019
Origen: regla '10027'
Propósito: Funcion que retorna los registros de los ajustes en línea de la cuenta
Se realizara la consulta al OL teniendo como dato de entrada el numero de cuenta.
Los ajustes corresponden a movimientos crédito ingresados a la cuenta del tarjetahabiente.
Codigo_Operacion = 1 - creditos
0 - debitos
La funcion original retornaba los ajustes NO PROCESADOS, pero se incluyo el control de forma
a incluir los PROCESADOS de la fecha siempre que el proceso de carga de ajustes en el cierre
del batch aun no finalizo.
Los ajustes crédito se suman a los pagos, para obtener el total de lo abonado por el tarjehabiente.
Los ajustes débito se suman a las compras, para obtener el total de compras del tarjetahabiente.
**********************************************************************************************************/
BEGIN
vn_codigo_operacion := nvl(fn_codigo_operacion, 0);
SELECT NVL(SUM(decode(am.codigo_operacion, 0, am.importe, 0)), 0),
NVL(SUM(decode(am.codigo_operacion, 1, am.importe, 0)), 0)
INTO vn_ajustes_db_ol, vn_ajustes_cr_ol
FROM creditopy.alta_movimientos_ajustes@olpy am
WHERE am.numero_cuenta = fn_numero_cuenta
AND (nvl(am.procesado, 'N') = 'N' OR
(nvl(am.procesado, 'N') = 'S' AND
trunc(am.fecha_proceso) >= trunc(SYSDATE) AND
-- y no haya sido replicada la tabla CUENTAS: este control
-- utiliza una tabla que se registra con un job en el Online
0 = nvl((SELECT COUNT(*)
FROM creditopy.CONTROL_MVIEWS@olpy a
WHERE trunc(a.fecha_registro) >= trunc(SYSDATE)
AND a.mview_name = 'CUENTAS'
AND a.last_refresh_date >= am.fecha_proceso),
0)));
CASE vn_codigo_operacion
WHEN 0 THEN
RETURN NVL(vn_ajustes_db_ol, 0);
ELSE
RETURN NVL(vn_ajustes_cr_ol, 0);
END CASE;
EXCEPTION
WHEN OTHERS THEN
--cuando hay sum no sale por no_data_found, solo no suma, se puede omitir
RAISE;
END fn_get_ajustes_ol;
FUNCTION fn_get_disponible_online(fn_emisor IN creditopy.CUENTAS.emisor%TYPE,
fn_numero_cuenta IN creditopy.CUENTAS.numero_cuenta%TYPE,
fn_plan IN NUMBER,
fn_flg_ul IN NUMBER DEFAULT NULL,
fn_porc_sobregiro IN NUMBER DEFAULT NULL)
RETURN NUMBER IS
vn_disponible NUMBER;
/*************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 24/04/2019
Origen: de la consulta de limites utilizada en el formulario Cuenta.jsp del AccesoCabal
Propósito: Función que retorna el valor del disponible al contado correspondiente a un número de cuenta.
La función llama a el procedimiento creditopy.autorizador_cr.DispPlanesNuevos utilizado en el acceso cabal
para obtener los valores de la sección de disponibles.
***************************************************************************************************/
NP_DISPCONTADO NUMBER;
NP_DISPPLANES NUMBER;
NP_DISPEFECTIVO NUMBER;
NP_DISPAGRO NUMBER;
NP_DISPTANTOS NUMBER;
NP_ESTADO CREDITOPY.LOG_TRANSACC_CR.ESTADOC@OLPY%TYPE;
NP_SALDOCIERREML CREDITOPY.LOG_TRANSACC_CR.SALDO_CIERRE_ML@OLPY%TYPE;
NP_SALDOCIERREMR CREDITOPY.LOG_TRANSACC_CR.SALDO_CIERRE_MR@OLPY%TYPE;
NP_PAGOSML CREDITOPY.LOG_TRANSACC_CR.PAGOS_ML@OLPY%TYPE;
NP_PAGOSMR CREDITOPY.LOG_TRANSACC_CR.PAGOS_MR@OLPY%TYPE;
NP_FECHACIERRE CREDITOPY.LOG_TRANSACC_CR.FECHA_CIERRE@OLPY%TYPE;
NP_FECHAVENCIMIENTO CREDITOPY.LOG_TRANSACC_CR.FECHA_VENCIMIENTO@OLPY%TYPE;
NP_PAGOMINIMO CREDITOPY.LOG_TRANSACC_CR.PAGO_MINIMO_ML@OLPY%TYPE;
NP_RESERVASCONTADO NUMBER;
NP_RESERVASPLANES NUMBER;
NP_RESERVASEFECTIVO NUMBER;
NP_RESERVASAGRO NUMBER;
NP_DISPSALUD NUMBER;
NP_RESERVASALUD NUMBER;
vn_limite_contado NUMBER;
vn_exceso NUMBER;
vn_disp_contado NUMBER;
BEGIN
creditopy.autorizador_cr.DispPlanesNuevos@olpy(fn_numero_cuenta,
NP_DISPCONTADO,
NP_DISPPLANES,
NP_DISPEFECTIVO,
NP_DISPAGRO,
NP_DISPTANTOS,
NP_ESTADO,
NP_SALDOCIERREML,
NP_SALDOCIERREMR,
NP_PAGOSML,
NP_PAGOSMR,
NP_FECHACIERRE,
NP_FECHAVENCIMIENTO,
NP_PAGOMINIMO,
NP_RESERVASCONTADO,
NP_RESERVASPLANES,
NP_RESERVASEFECTIVO,
NP_RESERVASAGRO,
NP_DISPSALUD,
NP_RESERVASALUD);
CASE fn_plan
WHEN 1 THEN
vn_disponible := NP_DISPCONTADO;
WHEN 3 THEN
vn_disponible := NP_DISPPLANES;
WHEN 4 THEN
vn_disponible := NP_DISPEFECTIVO;
WHEN 9 THEN
vn_disponible := NP_DISPSALUD;
ELSE
vn_disponible := 0;
END CASE;
IF vn_disponible < 0 THEN
vn_disponible := 0;
END IF;
-- calculo el exceso
vn_limite_contado := creditopy.pkg_dimo_ceibo.fn_get_limite(fn_emisor,
fn_numero_cuenta,
1);
vn_exceso := NP_DISPCONTADO -
round(vn_limite_contado * fn_porc_sobregiro / 100);
IF vn_exceso < 0 THEN
vn_disp_contado := 0;
ELSE
vn_disp_contado := NP_DISPCONTADO;
END IF;
IF fn_plan = 4 THEN
CASE nvl(fn_flg_ul, -1)
WHEN 0 THEN
-- tiene lineas separadas
IF NP_DISPEFECTIVO > NP_DISPCONTADO + NP_DISPPLANES THEN
vn_disponible := vn_disp_contado + NP_DISPPLANES;
END IF;
WHEN 1 THEN
-- tiene lineas unificadas
IF NP_DISPEFECTIVO > NP_DISPCONTADO THEN
vn_disponible := NP_DISPCONTADO;
END IF;
ELSE
NULL;
END CASE;
END IF;
RETURN vn_disponible;
EXCEPTION
WHEN OTHERS THEN
RETURN 0;
END fn_get_disponible_online;
FUNCTION fn_get_datos_monetarios_ol(fn_emisor IN creditopy.CUENTAS.emisor%TYPE,
fn_sucursal IN creditopy.CUENTAS.sucursal_emisor%TYPE,
fn_numero_cuenta IN creditopy.CUENTAS.numero_cuenta%TYPE,
fn_dato IN INTEGER,
fn_reservas_ml IN creditopy.CUENTAS.reservas_ml%TYPE,
fn_reservas_efectivo_ml IN creditopy.CUENTAS.reservas_efectivo_ml%TYPE,
fn_reservas_planes_ml IN creditopy.CUENTAS.reservas_planes_ml%TYPE)
RETURN NUMBER IS
vn_importe NUMBER;
vn_total_pagos NUMBER;
vd_ultima_fecha_pago DATE;
vn_total_dev_off NUMBER;
vn_total_congelada NUMBER;
vn_ajcrol NUMBER;
vn_ajdbol NUMBER;
vn_aut_pend_totales NUMBER;
vn_total_cuotas_pen NUMBER;
vn_saldo_ultimo_cierre NUMBER;
vn_interes_financiero NUMBER;
vn_interes_moratorio NUMBER;
vn_autorcontado NUMBER;
vn_autoradelanto NUMBER;
vn_autorplan NUMBER;
vn_autorsalud NUMBER;
vn_autorunacuotaplan NUMBER;
vn_autorplanadelanto NUMBER;
vn_autorunacuotaadelanto NUMBER;
vn_autorcanceplanes NUMBER;
vn_autorintcaplanes NUMBER;
vn_autorcancesalud NUMBER;
vn_autorintcasalud NUMBER;
vn_planespe NUMBER;
vn_cargos_decaido NUMBER;
vn_tiene_vinculo NUMBER;
/*******************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 26/06/2019
Origen: complemento de datos de la regla '10020'
Propósito: Funcion que retorna los datos monetarios. Implementada para obtener los datos faltantes para
el saldo a la fecha que debe incluir los pagos en linea, ajustes credito y debito en linea que
aun no fueron procesados.
Retorna los valores de acuerdo al valor de fn_dato:
1 - total de pagos online
2 - ajustes credito online
3 - ajustes debito online
4 - indicador de compras y adelantos pendientes; devuelve 1 si tiene autorizaciones
de compras contado o de adelanto o de compras en planes
*********************************************************************************************************/
BEGIN
creditopy.reportes.PR_GET_DATOS_MONETARIOS@olpy(fn_emisor,
fn_sucursal,
fn_numero_cuenta,
fn_reservas_ml,
fn_reservas_efectivo_ml,
fn_reservas_planes_ml,
vn_total_pagos,
vd_ultima_fecha_pago,
vn_total_dev_off,
vn_total_congelada,
vn_ajcrol,
vn_ajdbol,
vn_aut_pend_totales,
vn_total_cuotas_pen,
vn_saldo_ultimo_cierre,
vn_interes_financiero,
vn_interes_moratorio,
vn_autorcontado,
vn_autoradelanto,
vn_autorplan,
vn_autorsalud,
vn_autorunacuotaplan,
vn_autorplanadelanto,
vn_autorunacuotaadelanto,
vn_autorcanceplanes,
vn_autorintcaplanes,
vn_autorcancesalud,
vn_autorintcasalud,
vn_planespe,
vn_cargos_decaido,
vn_tiene_vinculo);
CASE fn_dato
WHEN 1 THEN
vn_importe := vn_total_pagos;
WHEN 2 THEN
vn_importe := vn_ajcrol;
WHEN 3 THEN
vn_importe := vn_ajdbol;
WHEN 4 THEN
IF nvl(vn_autorcontado, 0) != 0 OR nvl(vn_autoradelanto, 0) != 0 OR
nvl(vn_autorplan, 0) != 0 THEN
vn_importe := 1;
ELSE
vn_importe := 0;
END IF;
ELSE
vn_importe := 0;
END CASE;
RETURN vn_importe;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END fn_get_datos_monetarios_ol;
FUNCTION fn_get_pm_pendiente(fn_numero_cuenta IN creditopy.CUENTAS.numero_cuenta%TYPE,
fn_pm_facturado IN creditopy.SALDOS_CUENTAS.pago_minimo_ml%TYPE,
fn_pagos IN creditopy.CUENTAS.pagos_ml%TYPE)
RETURN NUMBER IS
vn_pago_min_pendiente NUMBER;
BEGIN
-- se calcula sobre el pago minimo facturado menos los pagos procesados a la fecha incluyendo
-- los pagos en linea y los ajustes credito no procesados
-- pago minimo facturado -
-- ( el total de pagos a la ultima diaria
-- + pagos en linea regla 100261
-- + ajustes cr en linea regla 10027)
vn_pago_min_pendiente := fn_pm_facturado -
(fn_pagos +
creditopy.pkg_dimo_ceibo.fn_get_pagos_ol(fn_numero_cuenta) +
creditopy.pkg_dimo_ceibo.fn_get_ajustes_ol(fn_numero_cuenta,
1));
IF vn_pago_min_pendiente < 0 THEN
vn_pago_min_pendiente := 0;
END IF;
RETURN vn_pago_min_pendiente;
EXCEPTION
WHEN OTHERS THEN
--cuando hay sum no sale por no_data_found, solo no suma, se puede omitir
RAISE;
END fn_get_pm_pendiente;
FUNCTION fn_get_ultimo_pago(fn_numero_cuenta IN creditopy.CUENTAS.numero_cuenta%TYPE)
RETURN NUMBER IS
vn_pagos_ol NUMBER;
vn_importe NUMBER;
vd_ult_fecha_pago DATE;
BEGIN
BEGIN
-- primero ver si hay pagos en el Online
SELECT DECODE(moneda, 830, importe, importe * cotizacion)
INTO vn_pagos_ol
FROM creditopy.log_transacc_cr@olpy a
WHERE nro_cuenta = fn_numero_cuenta
AND plan = 6
AND importe != 0 -- por bug del autorizador que se corrije a x hora antes de la captura
AND codigo_operacion = 1
AND tipo_autorizacion = 'A'
AND fecha =
(SELECT MAX(b.fecha)
FROM creditopy.log_transacc_cr@olpy b
WHERE b.nro_cuenta = a.nro_cuenta
AND b.plan = a.plan
AND b.importe != 0 -- por bug del autorizador que se corrije a x hora antes de la captura
AND b.codigo_operacion = a.codigo_operacion
AND b.tipo_autorizacion = a.tipo_autorizacion)
AND movextfch = (SELECT MAX(b.movextfch)
FROM creditopy.log_transacc_cr@olpy b
WHERE b.nro_cuenta = a.nro_cuenta
AND b.plan = a.plan
AND b.importe != 0 -- por bug del autorizador que se corrije a x hora antes de la captura
AND b.codigo_operacion = a.codigo_operacion
AND b.tipo_autorizacion = a.tipo_autorizacion
AND b.fecha = a.fecha)
AND a.idaut = (SELECT MAX(b.idaut)
FROM creditopy.log_transacc_cr@olpy b
WHERE b.nro_cuenta = a.nro_cuenta
AND b.plan = a.plan
AND b.importe != 0 -- por bug del autorizador que se corrije a x hora antes de la captura
AND b.codigo_operacion = a.codigo_operacion
AND b.tipo_autorizacion = a.tipo_autorizacion
AND b.fecha = a.fecha
AND b.movextfch = a.movextfch);
EXCEPTION
WHEN no_data_found THEN
vn_pagos_ol := 0;
WHEN OTHERS THEN
RAISE;
END;
-- si hay pagos en el online ya no necesita ir a buscar en MOVTOS_CUENTAS
IF nvl(vn_pagos_ol, 0) > 0 THEN
vn_importe := vn_pagos_ol;
ELSE
-- busca la maxima fecha de pago registrada
-- no hay un indice por rubro por cuenta, tampoco un indice por cuenta y fecha de movimiento
SELECT MAX(mc.fecha_movimiento)
INTO vd_ult_fecha_pago
FROM creditopy.movtos_cuentas mc
WHERE mc.numero_cuenta = fn_numero_cuenta
AND mc.rubro = 500;
-- para la maxima fecha busca el ultimo pago procesado (el ultimo nro de talon en la fecha)
-- ojo: si realizo varios pagos en una fecha no hay como determinar cual fue el ultimo,
-- se toma el ultimo procesado por numero de talon, que es un secuencial al cargar movtos_cuentas
SELECT mc.importe_ml
INTO vn_importe
FROM creditopy.movtos_cuentas mc
WHERE mc.numero_cuenta = fn_numero_cuenta
AND mc.rubro = 500
AND mc.fecha_movimiento = vd_ult_fecha_pago
AND to_number(TRIM(mc.numero_talon)) =
(SELECT MAX(to_number(TRIM(b.numero_talon)))
FROM creditopy.movtos_cuentas b
WHERE mc.EMISOR = b.EMISOR
AND mc.SUCURSAL_EMISOR = b.sucursal_emisor
AND mc.producto = b.PRODUCTO
AND mc.NUMERO_CUENTA = b.numero_cuenta
-- and mc.PERIODO_CIERRE = b.periodo_cierre -- bug CAD-838. AR. 20200203
AND mc.FECHA_MOVIMIENTO = b.fecha_movimiento
AND mc.RUBRO = b.rubro
AND mc.MONEDA = b.moneda);
END IF;
RETURN nvl(vn_importe, 0);
EXCEPTION
WHEN no_data_found THEN
vn_importe := 0;
RETURN vn_importe;
WHEN OTHERS THEN
RAISE;
END fn_get_ultimo_pago;
FUNCTION fn_get_fecha_ultimo_pago(fn_numero_cuenta IN creditopy.CUENTAS.numero_cuenta%TYPE,
fd_fecha_ult_pago IN creditopy.CUENTAS.fecha_ultimo_pago%TYPE)
RETURN DATE IS
vd_fecha_ult_pago DATE;
BEGIN
SELECT MAX(fecha)
INTO vd_fecha_ult_pago
FROM creditopy.log_transacc_cr@olpy a
WHERE a.nro_cuenta = fn_numero_cuenta
AND a.plan = 6
AND a.codigo_operacion = 1
AND a.TIPO_AUTORIZACION = 'A';
IF vd_fecha_ult_pago IS NULL OR vd_fecha_ult_pago < fd_fecha_ult_pago THEN
vd_fecha_ult_pago := fd_fecha_ult_pago;
END IF;
RETURN vd_fecha_ult_pago;
EXCEPTION
WHEN OTHERS THEN
--cuando hay max no sale por no_data_found
RAISE;
END fn_get_fecha_ultimo_pago;
FUNCTION fn_get_fecha_ult_pago_periodo(fn_emisor IN creditopy.CUENTAS.emisor%TYPE,
fn_sucursal_emisor IN creditopy.CUENTAS.sucursal_emisor%TYPE,
fn_numero_cuenta IN creditopy.CUENTAS.numero_cuenta%TYPE,
fn_periodo_cierre IN creditopy.MOVTOS_CUENTAS.periodo_cierre%TYPE)
RETURN DATE IS
vd_fecha_ult_pago DATE;
BEGIN
SELECT MAX(MC.FECHA_MOVIMIENTO)
INTO vd_fecha_ult_pago
FROM CREDITOPY.MOVTOS_CUENTAS MC
WHERE MC.EMISOR = FN_EMISOR
AND MC.SUCURSAL_EMISOR = FN_SUCURSAL_EMISOR
AND MC.PRODUCTO = 1
AND MC.NUMERO_CUENTA = FN_NUMERO_CUENTA
AND MC.PERIODO_CIERRE = FN_PERIODO_CIERRE
-- Y LOS RUBROS>3000 que no sean ajustes al pm?
AND MC.RUBRO = 500;
RETURN vd_fecha_ult_pago;
EXCEPTION
WHEN OTHERS THEN
--cuando hay max no sale por no_data_found
RAISE;
END fn_get_fecha_ult_pago_periodo;
FUNCTION fn_get_estado_desc(fn_estado IN creditopy.estados_ctas_tarj.estado%TYPE)
RETURN VARCHAR2 IS
vc_desc_estado creditopy.estados_ctas_tarj.descripcion%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 24/04/2019
Propósito: Función que retorna la descripción del estado de una tarjeta o cuenta,
teniendo como dato de entrada el id del estado.
******************************************************************************************************/
BEGIN
SELECT et.descripcion
INTO vc_desc_estado
FROM creditopy.estados_ctas_tarj et
WHERE et.producto = 1
AND et.estado = fn_estado;
RETURN vc_desc_estado;
EXCEPTION
WHEN no_data_found THEN
RETURN ' ';
WHEN OTHERS THEN
RAISE;
END fn_get_estado_desc;
FUNCTION fn_get_emisor_desc(fn_emisor IN debcredpy.emisores.emisor%TYPE)
RETURN VARCHAR2 IS
vc_desc_emisor debcredpy.emisores.descripcion%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 24/04/2019
Propósito: Función que retorna la descripción de un emisor, teniendo como dato de entrada el id del emisor.
******************************************************************************************************/
BEGIN
IF fn_emisor != 0 THEN
SELECT e.descripcion
INTO vc_desc_emisor
FROM debcredpy.emisores e
WHERE e.emisor = fn_emisor;
ELSE
vc_desc_emisor := ' ';
END IF;
RETURN vc_desc_emisor;
EXCEPTION
WHEN no_data_found THEN
vc_desc_emisor := ' ';
RETURN vc_desc_emisor;
WHEN OTHERS THEN
RAISE;
END fn_get_emisor_desc;
FUNCTION fn_get_afinidad_desc(fn_emisor IN creditopy.grupos_afinidad.emisor%TYPE,
fn_grupo_afinidad IN creditopy.grupos_afinidad.grupo_afinidad%TYPE)
RETURN VARCHAR2 IS
vc_desc_afinidad creditopy.grupos_afinidad.descripcion%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 24/04/2019
Propósito: Función que retorna la descripción de una afinidad, teniendo como dato de entrada el id del
grupo afinidad.
******************************************************************************************************/
BEGIN
SELECT ga.descripcion
INTO vc_desc_afinidad
FROM creditopy.grupos_afinidad ga
WHERE ga.emisor = fn_emisor
AND ga.producto = 1
AND ga.grupo_afinidad = fn_grupo_afinidad;
RETURN vc_desc_afinidad;
EXCEPTION
WHEN no_data_found THEN
--PC_SQLERRM := sqlerrm;
--PN_SQLCODE := sqlcode;
vc_desc_afinidad := ' ';
RETURN vc_desc_afinidad;
WHEN OTHERS THEN
RAISE;
END fn_get_afinidad_desc;
FUNCTION fn_get_tarjeta_mask(fc_tarjeta IN creditopy.tarjetas.tarjeta%TYPE)
RETURN VARCHAR2 IS
vc_tarjeta_mask creditopy.tarjetas.tarjeta%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL 0000-XXXX-XXXX-0000
Fecha: 24/04/2019
Propósito: Función que retorna la tarjeta encriptada
******************************************************************************************************/
BEGIN
vc_tarjeta_mask := creditopy.fc_cripto2pan(fc_tarjeta);
vc_tarjeta_mask := substr(vc_tarjeta_mask, 1, 4) || '-XXXX-XXXX-' ||
substr(vc_tarjeta_mask, -4);
RETURN vc_tarjeta_mask;
END fn_get_tarjeta_mask;
FUNCTION fn_get_origen_tarjeta(fc_tarjeta IN creditopy.tarjetas.tarjeta%TYPE)
RETURN NUMBER IS
vn_origen creditopy.imp_tarjetas.cod_origen%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 30/07/2019
Propósito: Función que retorna el codigo del origen de una tarjeta,
teniendo como dato de entrada la tarjeta.
-- origen de las tarjetas: CODIGOS_PY where TIPO_CODIGO = 1
ORIGEN TARJETA/IMP. TIPO
10 Alta de Cuenta ALTA
11 Alta Adicional ALTA
12 Alta Reactivac.Cuenta ALTA
20 Reposicion REPOS
21 Reposicion por Robo REPOS
22 Reposicion por Extravio REPOS
90 Renovacion RENOV
******************************************************************************************************/
BEGIN
SELECT it.cod_origen
INTO vn_origen
FROM creditopy.imp_tarjetas it
WHERE it.tarjeta = fc_tarjeta
AND it.cod_origen != 80
AND it.fecha_alta = (SELECT MAX(b.fecha_alta)
FROM creditopy.imp_tarjetas b
WHERE b.tarjeta = it.tarjeta
AND b.cod_origen != 80);
RETURN vn_origen;
EXCEPTION
WHEN no_data_found THEN
vn_origen := 0;
RETURN vn_origen;
WHEN OTHERS THEN
RAISE;
END fn_get_origen_tarjeta;
FUNCTION fn_is_dimo(fn_emisor IN debcredpy.emisores.emisor%TYPE)
RETURN NUMBER IS
vn_is_dimo NUMBER;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 12/05/2020
Propósito: Función que retorna 1 cuando el emisor es DIMO
******************************************************************************************************/
BEGIN
IF fn_emisor != 0 THEN
SELECT decode(TRIM(tp.marca), CC_DIMO, 1, 0)
INTO vn_is_dimo
FROM creditopy.emisores_prepago tp
WHERE tp.emisor = fn_emisor;
ELSE
vn_is_dimo := 0;
END IF;
RETURN vn_is_dimo;
EXCEPTION
WHEN no_data_found THEN
vn_is_dimo := 0;
RETURN vn_is_dimo;
WHEN OTHERS THEN
RAISE;
END fn_is_dimo;
FUNCTION fn_is_prepaga(fn_emisor IN debcredpy.emisores.emisor%TYPE)
RETURN NUMBER IS
vn_is_prepaga NUMBER;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 12/05/2020
Propósito: Función que retorna 1 cuando el emisor es de tarjeta prepaga
******************************************************************************************************/
BEGIN
IF fn_emisor != 0 THEN
SELECT 1
INTO vn_is_prepaga
FROM creditopy.emisores_prepago tp
WHERE tp.emisor = fn_emisor
--Mantis#2772.
AND tp.genera_tarj_fisica_al_alta = 'N';
ELSE
vn_is_prepaga := 0;
END IF;
RETURN vn_is_prepaga;
EXCEPTION
WHEN no_data_found THEN
vn_is_prepaga := 0;
RETURN vn_is_prepaga;
WHEN OTHERS THEN
RAISE;
END fn_is_prepaga;
FUNCTION fn_is_prepaga_fisica(fi_tarjeta IN creditopy.tarjetas_prepaga.tarjeta%TYPE)
RETURN NUMBER IS
vn_is_fisica NUMBER;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 23/06/2020
Propósito: Función que retorna 1 cuando la tarjeta prepaga tiene plastico operativo
******************************************************************************************************/
BEGIN
IF fi_tarjeta IS NOT NULL THEN
SELECT 1
INTO vn_is_fisica
FROM creditopy.tarjetas_prepaga tp
WHERE tp.tarjeta = fi_tarjeta
AND tp.fecha_vig_plastico >= trunc(SYSDATE)
AND tp.estado_plastico IN (1, 4, 5, 9);
ELSE
vn_is_fisica := 0;
END IF;
RETURN vn_is_fisica;
EXCEPTION
WHEN no_data_found THEN
vn_is_fisica := 0;
RETURN vn_is_fisica;
WHEN OTHERS THEN
RAISE;
END fn_is_prepaga_fisica;
FUNCTION fn_get_vigencia_tp_virtual(fi_emisor IN debcredpy.emisores_productos.emisor%TYPE,
fi_producto IN debcredpy.emisores_productos.producto%TYPE,
fi_grupo_afinidad IN debcredpy.emisores_productos.grupo_afinidad%TYPE,
fi_cartera IN debcredpy.emisores_productos.cartera%TYPE,
fi_fecha_alta IN creditopy.tarjetas.fecha_otorgada%TYPE)
RETURN DATE IS
fecha_vigencia DATE;
BEGIN
/*
Obtiene la fecha de vigencia para las tarjetas prepaga virtuales a partir
del parametro DURACION_TARJETA en la tabla debcredpy.EMISORES_PRODUCTOS.
*/
SELECT LAST_DAY(add_months(fi_fecha_alta, ep.duracion_tarjeta))
INTO fecha_vigencia
FROM debcredpy.emisores_productos ep
WHERE ep.emisor = fi_emisor
AND ep.producto = fi_producto
AND ep.grupo_afinidad = fi_grupo_afinidad
AND ep.cartera = fi_cartera
AND ep.duracion_tarjeta > 0;
RETURN fecha_vigencia;
EXCEPTION
WHEN no_data_found THEN
raise_application_error(-20001,
'USERS_ERROR: duracion de tarjeta virtual no encontrada.');
WHEN OTHERS THEN
raise_application_error(-20001,
'USERS_ERROR: duracion de tarjeta virtual con error.');
END fn_get_vigencia_tp_virtual;
FUNCTION fn_get_vigencia_tp_fisica(fi_emisor IN creditopy.EMISORES_PREPAGO.emisor%TYPE,
fi_tipo_tp IN creditopy.TIPOS_TARJETA_PREPAGA.id_tipo_tarjeta_prepaga%TYPE,
fi_fecha_alta IN DATE) RETURN DATE IS
fecha_vigencia DATE;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 12/06/2020
Propósito: Función que retorna la vigencia de la tarjeta fisica calculada a partir de la fecha
de solicitud del plastico.
Se utiliza el parametro de duracion del tipo de tarjeta, y si es cero
se utiliza el parametro de duracion por emisor.
******************************************************************************************************/
BEGIN
SELECT CASE
WHEN tp.duracion_tipo_tarjeta > 0 THEN
LAST_DAY(add_months(fi_fecha_alta, tp.duracion_tipo_tarjeta))
ELSE
LAST_DAY(add_months(fi_fecha_alta, e.duracion_tarjeta_fisica))
END
INTO fecha_vigencia
FROM creditopy.emisores_prepago e, creditopy.tipos_tarjeta_prepaga tp
WHERE e.emisor = fi_emisor
AND tp.emisor = e.emisor
AND tp.id_tipo_tarjeta_prepaga = fi_tipo_tp;
RETURN fecha_vigencia;
EXCEPTION
WHEN no_data_found THEN
raise_application_error(-20001,
'USERS_ERROR: duracion de tarjeta fisica no encontrada.');
WHEN OTHERS THEN
raise_application_error(-20001,
'USERS_ERROR: duracion de tarjeta fisica con error.');
END fn_get_vigencia_tp_fisica;
FUNCTION fn_datos_plastico_tp(fi_tarjeta IN creditopy.tarjetas_prepaga.tarjeta%TYPE,
fi_dato IN VARCHAR2) RETURN VARCHAR IS
vc_dato VARCHAR2(30);
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 10/06/2020
Propósito: Función que retorna
- para fi_dato
1 : el codigo de tipo de plastico de la tarjeta prepaga fisica
2 : la descripcion abreviada de tipo de plastico de la tarjeta prepaga fisica
3 : el codigo del estado de la tarjeta prepaga fisica
4 : la descripcion del estado de la tarjeta prepaga fisica
******************************************************************************************************/
BEGIN
IF fi_tarjeta IS NOT NULL AND fi_dato IS NOT NULL AND
nvl(fi_dato, 0) IN (1, 2, 3, 4) THEN
CASE
WHEN fi_dato IN (1, 2) THEN
SELECT decode(fi_dato,
1,
rpad(tp.id_tipo_tarjeta_prepaga, 4),
2,
t.tipo_tarjeta,
'0')
INTO vc_dato
FROM creditopy.tarjetas_prepaga tp,
creditopy.tipos_tarjeta_prepaga t
WHERE tp.tarjeta = fi_tarjeta
AND t.id_tipo_tarjeta_prepaga = tp.id_tipo_tarjeta_prepaga;
WHEN fi_dato IN (3, 4) THEN
SELECT decode(fi_dato,
3,
rpad(tp.estado_plastico, 4),
4,
et.descripcion,
'0')
INTO vc_dato
FROM creditopy.tarjetas_prepaga tp,
creditopy.estados_tp_fisica et
WHERE tp.tarjeta = fi_tarjeta
AND et.estado = tp.estado_plastico;
ELSE
vc_dato := '0';
END CASE;
ELSE
vc_dato := '0';
END IF;
RETURN TRIM(vc_dato);
EXCEPTION
WHEN no_data_found THEN
vc_dato := '0';
RETURN vc_dato;
WHEN OTHERS THEN
RAISE;
END fn_datos_plastico_tp;
FUNCTION fn_get_estado_plastico_desc(fn_estado IN creditopy.estados_ctas_tarj.estado%TYPE)
RETURN VARCHAR2 IS
vc_desc_estado creditopy.estados_tp_fisica.descripcion%TYPE;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 11/06/2020
Propósito: Función que retorna la descripción del estado de una tarjeta fisica.
******************************************************************************************************/
BEGIN
SELECT et.descripcion
INTO vc_desc_estado
FROM creditopy.estados_tp_fisica et
WHERE et.estado = fn_estado;
RETURN vc_desc_estado;
EXCEPTION
WHEN no_data_found THEN
RETURN ' ';
WHEN OTHERS THEN
RAISE;
END fn_get_estado_plastico_desc;
FUNCTION fn_tipo_plastico_tp_desc(fi_id_tipo_tp IN creditopy.tarjetas_prepaga.id_tipo_tarjeta_prepaga%TYPE)
RETURN VARCHAR IS
vc_tipo_tarjeta_desc creditopy.tipos_tarjeta_prepaga.tipo_tarjeta%TYPE;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 12/06/2020
Propósito: la descripcion abreviada de tipo de plastico de una tarjeta
******************************************************************************************************/
BEGIN
SELECT t.tipo_tarjeta
INTO vc_tipo_tarjeta_desc
FROM creditopy.tipos_tarjeta_prepaga t
WHERE t.id_tipo_tarjeta_prepaga = fi_id_tipo_tp;
RETURN TRIM(vc_tipo_tarjeta_desc);
EXCEPTION
WHEN no_data_found THEN
RETURN ' ';
WHEN OTHERS THEN
RAISE;
END fn_tipo_plastico_tp_desc;
FUNCTION fn_get_default_tipo_tp_fisica(fi_emisor IN creditopy.EMISORES_PREPAGO.emisor%TYPE)
RETURN NUMBER IS
vn_id_tipo_tarjeta_prepaga creditopy.EMISORES_PREPAGO.default_id_tipo_tarj_prepaga%TYPE;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 15/06/2020
Propósito: obtener el tipo de tarjeta prepaga fisica por default
******************************************************************************************************/
BEGIN
SELECT e.default_id_tipo_tarj_prepaga
INTO vn_id_tipo_tarjeta_prepaga
FROM creditopy.emisores_prepago e
WHERE e.emisor = fi_emisor;
RETURN vn_id_tipo_tarjeta_prepaga;
EXCEPTION
WHEN no_data_found THEN
raise_application_error(-20001,
'USERS_ERROR: tipo default de tarjeta fisica no encontrada.');
WHEN OTHERS THEN
raise_application_error(-20001,
'USERS_ERROR: tipo default de tarjeta fisica con error.');
END fn_get_default_tipo_tp_fisica;
FUNCTION fn_get_estado_gen_tp_fisica(fi_emisor IN creditopy.EMISORES_PREPAGO.emisor%TYPE)
RETURN NUMBER IS
vn_estado_gen_tarjeta_fisica creditopy.EMISORES_PREPAGO.estado_gen_tarjeta_fisica%TYPE;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 15/06/2020
Propósito: obtener el estado al generarse la tarjeta prepaga fisica
******************************************************************************************************/
BEGIN
SELECT e.estado_gen_tarjeta_fisica
INTO vn_estado_gen_tarjeta_fisica
FROM creditopy.emisores_prepago e
WHERE e.emisor = fi_emisor;
RETURN vn_estado_gen_tarjeta_fisica;
EXCEPTION
WHEN no_data_found THEN
raise_application_error(-20001,
'USERS_ERROR: estado al generar tarjeta fisica no encontrado.');
WHEN OTHERS THEN
raise_application_error(-20001,
'USERS_ERROR: estado al generar tarjeta fisica con error.');
END fn_get_estado_gen_tp_fisica;
FUNCTION fn_get_tp_ciudad_desc(fi_pais debcredpy.ciudades.pais%TYPE,
fi_departamento debcredpy.ciudades.departamento%TYPE,
fi_ciudad debcredpy.ciudades.ciudad%TYPE)
RETURN VARCHAR2 IS
vc_ciudad_desc debcredpy.ciudades.descripcion%TYPE;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 11/06/2020
Propósito: Función que retorna la descripción de la ciudad para una cuenta/tarjeta prepaga.
No es valida para TC porque no tiene normalizados los datos de pais/departamento al alta.
******************************************************************************************************/
BEGIN
SELECT ci.descripcion
INTO vc_ciudad_desc
FROM debcredpy.ciudades ci
WHERE ci.pais = fi_pais
AND ci.departamento = fi_departamento
AND ci.ciudad = fi_ciudad;
RETURN vc_ciudad_desc;
EXCEPTION
WHEN no_data_found THEN
RETURN ' ';
WHEN OTHERS THEN
RAISE;
END fn_get_tp_ciudad_desc;
FUNCTION fn_is_adic_enable(fn_adic_tar_prm IN creditopy.TARJETAS.adicional%TYPE,
fn_comp_tar_prm IN creditopy.TARJETAS.componente%TYPE,
fc_flg_adicionales IN VARCHAR2,
fn_adic_tar_mov IN creditopy.TARJETAS.adicional%TYPE,
fn_comp_tar_mov IN creditopy.TARJETAS.componente%TYPE)
RETURN NUMBER IS
vn_enable NUMBER;
BEGIN
/*
1 Identificar el componente de la tarjeta pi_tarjeta
2 Si el componente de pi_tarjeta = 1 y pi_flg_adicionales = 1
mostrar los consumos de todas las tarjetas
3 Si el componente de pi_tarjeta = 1 y pi_flg_adicionales = 0
mostrar los consumos de las titulares
4 Si el componente de pi_tarjeta = 2 -- no importa el pi_flg_adicionales
mostrar los consumos de esa tarjeta
*/
vn_enable := 0;
IF fn_comp_tar_prm = 1 THEN
-- la tarjeta del parametro es una tarjeta titular
CASE fc_flg_adicionales
WHEN '1' THEN
vn_enable := 1;
WHEN '0' THEN
IF fn_comp_tar_mov = 1 THEN
vn_enable := 1;
ELSE
vn_enable := 0;
END IF;
ELSE
vn_enable := 0;
END CASE;
ELSE
-- la tarjeta del parametro es tarjeta adicional
-- habilita si el adicional del parametro es la adicional del movimiento
IF fn_adic_tar_prm = fn_adic_tar_mov THEN
vn_enable := 1;
ELSE
vn_enable := 0;
END IF;
END IF;
RETURN vn_enable;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END fn_is_adic_enable;
FUNCTION fn_get_cantidad_adicionales(fn_numero_cuenta IN creditopy.TARJETAS.numero_cuenta%TYPE)
RETURN NUMBER IS
vn_cant NUMBER;
BEGIN
SELECT COUNT(DISTINCT a.documento)
INTO vn_cant
FROM creditopy.tarjetas a
WHERE a.numero_cuenta = fn_numero_cuenta
AND a.clase_de_estado IN (1, 4, 5, 11)
AND a.componente = 2;
RETURN nvl(vn_cant, 0);
EXCEPTION
WHEN OTHERS THEN
RAISE;
END fn_get_cantidad_adicionales;
FUNCTION fn_get_plan_venta_desc(fn_plan IN creditopy.planes_de_venta.plan_venta%TYPE)
RETURN VARCHAR2 IS
vc_desc_plan creditopy.planes_de_venta.descripcion%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 12/05/2019
Propósito: Función que retorna la descripción del plan de venta,
teniendo como dato de entrada el id del plan.
******************************************************************************************************/
BEGIN
SELECT pv.descripcion
INTO vc_desc_plan
FROM creditopy.planes_de_venta pv
WHERE pv.plan_venta = fn_plan;
RETURN vc_desc_plan;
EXCEPTION
WHEN no_data_found THEN
vc_desc_plan := ' ';
RETURN vc_desc_plan;
WHEN OTHERS THEN
RAISE;
END fn_get_plan_venta_desc;
FUNCTION fn_get_rubro_desc(fn_rubro IN creditopy.rubros.rubro%TYPE,
fn_emisor IN creditopy.cuentas.emisor%TYPE)
RETURN VARCHAR2 IS
vc_desc_rubro creditopy.rubros.descripcion%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 12/05/2019
Propósito: Función que retorna la descripción del rubro del movimiento,
teniendo como dato de entrada el id del rubro.
******************************************************************************************************/
BEGIN
vc_desc_rubro := ' ';
BEGIN
IF creditopy.pkg_dimo_ceibo.fn_is_prepaga(fn_emisor) = 1 THEN
SELECT r.descripcion
INTO vc_desc_rubro
FROM creditopy.rubros_glosa_tp r
WHERE r.rubro = fn_rubro;
END IF;
EXCEPTION
WHEN no_data_found THEN
vc_desc_rubro := ' ';
WHEN OTHERS THEN
RAISE;
END;
IF vc_desc_rubro = ' ' THEN
SELECT r.descripcion
INTO vc_desc_rubro
FROM creditopy.rubros r
WHERE r.rubro = fn_rubro;
/*else
vc_desc_rubro:=' ';*/ -- AR. 03/07/2020 16:00 BUG detectado porque no despliega el concepto de los movimientos facturados.
END IF;
RETURN vc_desc_rubro;
EXCEPTION
WHEN no_data_found THEN
vc_desc_rubro := ' ';
RETURN vc_desc_rubro;
WHEN OTHERS THEN
RAISE;
END fn_get_rubro_desc;
FUNCTION fn_get_ramo_desc(fn_emisor_proc IN creditopy.ramos.emisor_procesador%TYPE,
fn_ramo IN creditopy.ramos.ramo%TYPE)
RETURN VARCHAR2 IS
vc_desc_ramo creditopy.ramos.descripcion%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 12/05/2019
Propósito: Función que retorna la descripción del ramo de comercios,
teniendo como dato de entrada el id del ramo.
******************************************************************************************************/
BEGIN
SELECT ra.descripcion
INTO vc_desc_ramo
FROM creditopy.ramos ra
WHERE ra.emisor_procesador = fn_emisor_proc
AND ra.ramo = fn_ramo;
RETURN vc_desc_ramo;
EXCEPTION
WHEN no_data_found THEN
vc_desc_ramo := ' ';
RETURN vc_desc_ramo;
WHEN OTHERS THEN
RAISE;
END fn_get_ramo_desc;
FUNCTION fn_get_cod_ramo_barra(fn_emisor_proc IN creditopy.ramos.emisor_procesador%TYPE,
fn_ramo IN creditopy.ramos.ramo%TYPE,
fn_comercio IN creditopy.comercios.comercio%TYPE)
RETURN NUMBER IS
-- datos del ramo del comercio para grafico de consumo, si no es ramo 96, 97 o 98
-- ramo 99 es ramo especial en la 805 y tiene comercios especiales
-- 9900030 GUARANICARD
-- 9960410 PLANES DECAIDOS
-- 9999998 COSUMO EN EL EXT. ON LINE
-- se accede a esta funcion solo para los rubros tipo 1 (cupon) y para las autorizaciones
-- si el ramo y el comercio vienen en 0 es un consumo en el exterior
vn_ramo creditopy.ramos.ramo%TYPE;
BEGIN
vn_ramo := 0;
CASE
WHEN fn_emisor_proc = 805 OR fn_emisor_proc = 0 THEN
CASE
-- los cupones procesados del exterior tienen comercio = 0
WHEN fn_comercio = 0 THEN
vn_ramo := 99;
-- se toman como consumos las autorizaciones en GuaraniCard y compras en el exterior
WHEN fn_comercio IN (9900030, 9999998) THEN
vn_ramo := fn_ramo;
ELSE
IF fn_ramo NOT IN (96, 97, 98, 99) THEN
vn_ramo := fn_ramo;
ELSE
vn_ramo := 0;
END IF;
END CASE;
WHEN fn_emisor_proc = 806 THEN
IF fn_ramo NOT IN (96, 97, 98) THEN
vn_ramo := fn_ramo;
ELSE
vn_ramo := 0;
END IF;
ELSE
vn_ramo := 0;
END CASE;
RETURN vn_ramo;
EXCEPTION
WHEN no_data_found THEN
vn_ramo := 0;
RETURN vn_ramo;
WHEN OTHERS THEN
RAISE;
END fn_get_cod_ramo_barra;
FUNCTION fn_get_desc_ramo_barra(fn_emisor_proc IN creditopy.ramos.emisor_procesador%TYPE,
fn_ramo IN creditopy.ramos.ramo%TYPE,
fn_comercio IN creditopy.comercios.comercio%TYPE)
RETURN VARCHAR2 IS
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 24/04/2019
Propósito: Función que retorna la descripción del movimiento.
******************************************************************************************************/
-- datos del ramo del comercio para grafico de consumo, si no es ramo 96, 97 o 98
-- ramo 99 es ramo especial en la 805 y tiene comercios especiales
-- 9900030 GUARANICARD
-- 9960410 PLANES DECAIDOS
-- 9999998 COSUMO EN EL EXT. ON LINE
-- se accede a esta funcion solo para los rubros tipo 1 (cupon) y para las autorizaciones
-- si el ramo y el comercio vienen en 0 es un consumo en el exterior
vc_desc_ramo creditopy.ramos.descripcion%TYPE;
BEGIN
vc_desc_ramo := ' ';
CASE
WHEN fn_emisor_proc = 805 OR fn_emisor_proc = 0 THEN
CASE
-- los cupones procesados del exterior tienen comercio = 0
WHEN fn_comercio = 0 THEN
vc_desc_ramo := 'COMPRAS EN EL EXTERIOR';
-- se toman como consumos las compras en GuaraniCard y compras en el exterior
WHEN fn_comercio = 9900030 THEN
vc_desc_ramo := 'GUARANICARD';
WHEN fn_comercio = 9999998 THEN
vc_desc_ramo := 'COMPRAS EN EL EXTERIOR';
ELSE
IF fn_ramo NOT IN (96, 97, 98, 99) THEN
vc_desc_ramo := creditopy.Pkg_Dimo_Ceibo.fn_get_ramo_desc(fn_emisor_proc,
fn_ramo);
ELSE
vc_desc_ramo := ' ';
END IF;
END CASE;
WHEN fn_emisor_proc = 806 THEN
IF fn_ramo NOT IN (96, 97, 98) THEN
vc_desc_ramo := creditopy.Pkg_Dimo_Ceibo.fn_get_ramo_desc(fn_emisor_proc,
fn_ramo);
ELSE
vc_desc_ramo := ' ';
END IF;
ELSE
vc_desc_ramo := ' ';
END CASE;
RETURN vc_desc_ramo;
EXCEPTION
WHEN no_data_found THEN
vc_desc_ramo := ' ';
RETURN vc_desc_ramo;
WHEN OTHERS THEN
RAISE;
END fn_get_desc_ramo_barra;
FUNCTION fn_get_movto_desc(fn_emisor IN creditopy.movtos_cuentas.emisor%TYPE,
fn_numero_cuenta IN creditopy.movtos_cuentas.numero_cuenta%TYPE,
fn_rubro IN creditopy.movtos_cuentas.rubro%TYPE,
fn_codigo_operacion IN creditopy.movtos_cuentas.codigo_operacion%TYPE,
fn_moneda IN creditopy.movtos_cuentas.moneda%TYPE,
fn_importe IN creditopy.movtos_cuentas.importe_ml%TYPE,
fn_fecha_movimiento IN creditopy.movtos_cuentas.fecha_movimiento%TYPE,
fn_fecha_proceso IN creditopy.movtos_cuentas.fecha_valor%TYPE,
fn_numero_talon IN creditopy.movtos_cuentas.numero_talon%TYPE,
fn_numero_comercio IN creditopy.movtos_cuentas.numero_comercio%TYPE,
fn_leyenda IN VARCHAR2) RETURN VARCHAR2 IS
vc_desc_rubro creditopy.rubros.descripcion%TYPE;
VN_RUBRO_PROMO_DTO NUMBER := 3577;
vn_buscar_concepto NUMBER;
vc_concepto VARCHAR2(35);
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 12/05/2019
Propósito: Función que retorna la descripción del rubro del movimiento,
teniendo como dato de entrada el id del rubro.
Version adaptada de fn_get_comercio_desc:
obtiene los datos del concepto del movimiento de ajuste CR/DB
implementado para Tarjetas Prepagas.
******************************************************************************************************/
BEGIN
vc_desc_rubro := ' ';
IF fn_rubro = VN_RUBRO_PROMO_DTO THEN
vc_desc_rubro := 'DTO. PROMO ';
IF fn_numero_comercio > 0 THEN
vc_desc_rubro := vc_desc_rubro ||
creditopy.Pkg_Dimo_Ceibo.fn_get_comercio_desc(ceibo_utiles.FN_GET_EMISOR_PROCESADOR(fn_emisor),
fn_numero_comercio,
fn_emisor);
END IF;
ELSE
BEGIN
IF creditopy.pkg_dimo_ceibo.fn_is_prepaga(fn_emisor) = 1 THEN
SELECT decode(nvl(TRIM(r.descripcion), ' '),
' ',
ru.descripcion,
r.descripcion),
r.buscar_concepto
INTO vc_desc_rubro, vn_buscar_concepto
FROM creditopy.rubros ru, creditopy.rubros_glosa_tp r
WHERE ru.rubro = fn_rubro
AND r.rubro = ru.rubro;
ELSE
IF TRIM(fn_leyenda) IS NOT NULL THEN
vn_buscar_concepto := 1;
ELSE
vn_buscar_concepto := 0;
END IF;
END IF;
IF vn_buscar_concepto = 1 THEN
IF TRIM(fn_leyenda) IS NOT NULL THEN
vc_concepto := fn_leyenda;
ELSE
BEGIN
SELECT ma.leyenda
INTO vc_concepto
FROM creditopy.movimientos_ajustes ma
WHERE ma.emisor = fn_emisor
AND ma.numero_cuenta = fn_numero_cuenta
AND ma.rubro = fn_rubro
AND ma.codigo_operacion = fn_codigo_operacion
AND ma.tipo_de_moneda =
decode(fn_moneda, 830, 1, 840, 2, 2)
AND ma.importe = fn_importe
AND ma.fecha_movimiento = fn_fecha_movimiento
AND ma.fecha_proceso = fn_fecha_proceso
AND ma.numero_talon = fn_numero_talon;
EXCEPTION
WHEN no_data_found THEN
vc_concepto := NULL;
WHEN OTHERS THEN
RAISE;
END;
END IF;
END IF;
EXCEPTION
WHEN no_data_found THEN
vc_desc_rubro := ' ';
WHEN OTHERS THEN
RAISE;
END;
END IF;
IF vc_desc_rubro = ' ' AND vc_concepto IS NULL THEN
SELECT r.descripcion
INTO vc_desc_rubro
FROM creditopy.rubros r
WHERE r.rubro = fn_rubro;
END IF;
IF vc_concepto IS NULL THEN
RETURN vc_desc_rubro;
ELSE
RETURN vc_concepto;
END IF;
EXCEPTION
WHEN no_data_found THEN
vc_desc_rubro := ' ';
RETURN vc_desc_rubro;
WHEN OTHERS THEN
RAISE;
END fn_get_movto_desc;
FUNCTION fn_get_comercio_desc(fn_emisor_proc IN creditopy.comercios.emisor_procesador%TYPE,
fn_comercio IN creditopy.comercios.comercio%TYPE,
fn_emisor IN creditopy.cuentas.emisor%TYPE,
fn_rubro IN creditopy.rubros.rubro%TYPE DEFAULT NULL,
fn_tipo_rubro IN creditopy.rubros.tipo_de_rubro%TYPE DEFAULT NULL,
fn_compra_ext IN creditopy.movtos_cuentas.compra_exterior%TYPE DEFAULT NULL,
fn_cupon_interno IN creditopy.cupones_internac.cupon%TYPE DEFAULT NULL)
RETURN VARCHAR2 IS
vc_desc_rubro VARCHAR2(30);
vc_desc_comercio VARCHAR2(100);
vc_debaut_mensaje creditopy.mensajes_cupon.mensaje%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 01/07/2019
Propósito: Función que retorna la descripción del comercios,
teniendo como dato de entrada el id del comercio.
Se incluyen casos para mas claridad para la visualizacion
del usuario
Si es consulta de tarjeta prepaga se incluye glosa mapeada
******************************************************************************************************/
BEGIN
vc_desc_rubro := ' ';
vc_desc_comercio := ' ';
vc_debaut_mensaje := NULL;
CASE nvl(fn_rubro, 0)
WHEN 0 THEN
vc_desc_rubro := ' ';
ELSE
CASE nvl(fn_tipo_rubro, 0)
-- si es una compra o adelanto
WHEN 1 THEN
-- 1ro) verificamos si es compra en el exterior
IF nvl(fn_compra_ext, 0) != 0 THEN
BEGIN
SELECT TRIM(ci.nombre_fantasia_comercio) || ' ( ' ||
TRIM(m.simbolo) || ' ' ||
TRIM(to_char(ci.importe_moneda_origen,
'999G999G999D99MI',
'NLS_NUMERIC_CHARACTERS = '',.'' ')) ||
' = ' || 'U$s ' ||
TRIM(to_char(ci.importe_mr,
'999G999G999D99MI',
'NLS_NUMERIC_CHARACTERS = '',.'' ')) || '; ' ||
'Cambio: G ' ||
TRIM(to_char(ci.tipo_de_cambio,
'999G999G999D99MI',
'NLS_NUMERIC_CHARACTERS = '',.'' ')) || ' )'
INTO vc_desc_comercio
FROM creditopy.cupones_internac ci, debcredpy.monedas m
WHERE CI.CUPON = fn_cupon_interno
AND m.producto = ci.producto
AND m.codigo_de_moneda = ci.moneda;
EXCEPTION
WHEN no_data_found THEN
vc_desc_comercio := 'COMPRAS EN EL EXTERIOR';
WHEN OTHERS THEN
RAISE;
END;
ELSE
-- 2do) si es debito automatico: al nombre del comercio se le agrega el mensaje
-- para el usuario, si tiene
IF fn_rubro = 1900 THEN
vc_desc_rubro := creditopy.Pkg_Dimo_Ceibo.fn_get_rubro_desc(fn_rubro,
fn_emisor);
vc_desc_comercio := ' ';
vc_debaut_mensaje := NULL;
BEGIN
SELECT md.mensaje
INTO vc_debaut_mensaje
FROM creditopy.mensajes_cupon md
WHERE md.cupon = fn_cupon_interno;
EXCEPTION
WHEN no_data_found THEN
vc_debaut_mensaje := NULL;
WHEN OTHERS THEN
RAISE;
END;
END IF;
END IF;
-- sino es un movimiento de pago o ajuste o cargo
ELSE
vc_desc_rubro := creditopy.Pkg_Dimo_Ceibo.fn_get_rubro_desc(fn_rubro,
fn_emisor);
END CASE;
END CASE;
IF vc_desc_comercio = ' ' AND nvl(fn_comercio, 0) != 0 THEN
CASE
WHEN fn_emisor_proc = 805 AND nvl(fn_comercio, 0) = 9999998 THEN
vc_desc_comercio := 'COMPRAS EN EL EXTERIOR';
ELSE
SELECT co.descripcion
INTO vc_desc_comercio
FROM creditopy.comercios co
WHERE co.emisor_procesador = fn_emisor_proc
AND co.comercio = fn_comercio;
END CASE;
END IF;
IF vc_desc_rubro != ' ' THEN
IF vc_desc_comercio = ' ' THEN
vc_desc_comercio := TRIM(vc_desc_rubro);
ELSE
IF vc_debaut_mensaje IS NULL THEN
vc_desc_comercio := TRIM(vc_desc_rubro) || '-' ||
TRIM(vc_desc_comercio);
ELSE
vc_desc_comercio := TRIM(vc_desc_comercio) || '-' ||
TRIM(vc_debaut_mensaje);
END IF;
END IF;
END IF;
RETURN vc_desc_comercio;
EXCEPTION
WHEN no_data_found THEN
vc_desc_comercio := ' ';
RETURN vc_desc_comercio;
WHEN OTHERS THEN
RAISE;
END fn_get_comercio_desc;
FUNCTION fn_get_leyenda_movimiento(fn_emisor IN creditopy.movtos_cuentas.emisor%TYPE,
fn_numero_cuenta IN creditopy.movtos_cuentas.numero_cuenta%TYPE,
fn_rubro IN creditopy.movtos_cuentas.rubro%TYPE,
fn_codigo_operacion IN creditopy.movtos_cuentas.codigo_operacion%TYPE,
fn_moneda IN creditopy.movtos_cuentas.moneda%TYPE,
fn_importe IN creditopy.movtos_cuentas.importe_ml%TYPE,
fn_fecha_movimiento IN creditopy.movtos_cuentas.fecha_movimiento%TYPE,
fn_fecha_proceso IN creditopy.movtos_cuentas.fecha_valor%TYPE,
fn_numero_talon IN creditopy.movtos_cuentas.numero_talon%TYPE,
fn_numero_comercio IN creditopy.movtos_cuentas.numero_comercio%TYPE,
fn_leyenda IN VARCHAR2)
RETURN VARCHAR2 IS
vc_desc_rubro VARCHAR2(300);
vn_rubro_especial NUMBER := 0;
VN_RUBRO_PROMO_DTO NUMBER := 3577;
vn_codigos_py_cuo NUMBER := 14;
vn_buscar_leyenda NUMBER := 0;
vc_leyenda_ajuste VARCHAR2(300);
vc_leyenda VARCHAR2(300);
vc_glosa VARCHAR2(300);
vr_sicoop_uuid creditopy.sicoop_uuid@olpy%ROWTYPE;
v_num_cuenta_origen NUMBER;
v_num_cuenta_destino NUMBER;
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 06/08/2020
Propósito: Función que retorna la leyenda de un movimiento de ajuste ingresado por la entidad
teniendo como dato de entrada el id del rubro.
Obtiene los datos del concepto del movimiento de ajuste CR/DB.
OBS: Los ajustes corresponden a los rubros de tipo_de_rubro = 3 - Ajuste, y deben
ingresar al proceso a traves de la tabla MOVIMIENTOS_AJUSTES.
Tambien pueden quedar registrados en la misma tabla los cargos con tipo_de_rubro = 3
y tipo_de_rubro = 4 - Producto
******************************************************************************************************/
BEGIN
vc_desc_rubro := NULL;
vc_leyenda := NULL;
vn_buscar_leyenda := 0;
vn_rubro_especial := 0;
vc_glosa := ' ';
-- Ver rubros con leyenda especial (valores para procesos):
-- no debe utilizarse la leyenda sino la descripcion del rubro
BEGIN
IF fn_rubro = VN_RUBRO_PROMO_DTO THEN
vn_rubro_especial := 1;
-- busco el nombre del comercio de la promo
IF fn_numero_comercio > 0 THEN
BEGIN
SELECT co.descripcion
INTO vc_desc_rubro
FROM creditopy.comercios co
WHERE co.comercio = fn_numero_comercio;
vc_desc_rubro := 'DTO. PROMO ' || vc_desc_rubro;
EXCEPTION
WHEN no_data_found THEN
vc_desc_rubro := 'DTO. PROMO';
WHEN OTHERS THEN
RAISE;
END;
END IF;
ELSE
CASE
WHEN (upper(substr(fn_leyenda, 4, 5)) = 'CUOTA') THEN
vn_rubro_especial := 1;
ELSE
SELECT 1
INTO vn_rubro_especial
FROM creditopy.codigos_py cp
WHERE cp.tipo_codigo = vn_codigos_py_cuo
AND TRIM(cp.valor) = fn_rubro;
END CASE;
-- si vn_rubro_especial = 1 armar la glosa de la cuota
END IF;
EXCEPTION
WHEN no_data_found THEN
vn_rubro_especial := 0;
WHEN OTHERS THEN
RAISE;
END;
IF fn_leyenda IS NULL THEN
BEGIN
SELECT ma.leyenda
INTO vc_leyenda_ajuste
FROM creditopy.movimientos_ajustes ma
WHERE ma.emisor = fn_emisor
AND ma.numero_cuenta = fn_numero_cuenta
AND ma.rubro = fn_rubro
AND ma.codigo_operacion = fn_codigo_operacion
AND ma.tipo_de_moneda = decode(fn_moneda, 830, 1, 840, 2, 2)
AND ma.importe = fn_importe
AND ma.fecha_movimiento = fn_fecha_movimiento
AND ma.fecha_proceso = fn_fecha_proceso
AND ma.numero_talon = fn_numero_talon;
EXCEPTION
WHEN no_data_found THEN
vc_leyenda_ajuste := NULL;
WHEN OTHERS THEN
RAISE;
END;
ELSE
vc_leyenda_ajuste := fn_leyenda;
END IF;
-- se incluye la busqueda de la glosa en claro para los ajustes ingresados por trxs sicoop
IF nvl(vn_rubro_especial, 0) != 1 AND
substr(nvl(vc_leyenda_ajuste, ' '), 1, 8) = 'RefDimo.' THEN
-- busco los datos de sicoop_uuid
vr_sicoop_uuid.numero_auditoria := substr(fn_leyenda, 9, 6);
vr_sicoop_uuid.fecha := fn_fecha_movimiento;
BEGIN
SELECT uuid.rubro,
uuid.num_cuenta_origen,
uuid.glosa_para_origen,
uuid.num_cuenta_destino,
uuid.glosa_para_destino
INTO vr_sicoop_uuid.rubro,
vr_sicoop_uuid.num_cuenta_origen,
vr_sicoop_uuid.glosa_para_origen,
vr_sicoop_uuid.num_cuenta_destino,
vr_sicoop_uuid.glosa_para_destino
FROM creditopy.sicoop_uuid@OLPY uuid
WHERE uuid.numero_auditoria = vr_sicoop_uuid.numero_auditoria
AND uuid.fecha = vr_sicoop_uuid.fecha;
EXCEPTION
WHEN no_data_found THEN
NULL;
WHEN OTHERS THEN
RAISE;
END;
-- si es el rubro cargo se deja que la glosa se resuelva como cargo
-- sino se despliega la leyenda
IF vr_sicoop_uuid.rubro != fn_rubro THEN
v_num_cuenta_origen := 0;
v_num_cuenta_destino := 0;
-- controlar si el movimiento es para la centa origen
BEGIN
SELECT n.numero_cuenta
INTO v_num_cuenta_origen
FROM creditopy.tarjetas n
WHERE n.tarjeta =
fc_pan2cripto(vr_sicoop_uuid.num_cuenta_origen);
IF v_num_cuenta_origen = fn_numero_cuenta THEN
vc_leyenda := vr_sicoop_uuid.glosa_para_origen;
vn_rubro_especial := 1;
vn_buscar_leyenda := 0;
END IF;
EXCEPTION
WHEN no_data_found THEN
v_num_cuenta_origen := 0;
WHEN OTHERS THEN
RAISE;
END;
IF v_num_cuenta_origen = 0 THEN
-- controlar si el movimiento es para la centa origen
BEGIN
SELECT n.numero_cuenta
INTO v_num_cuenta_destino
FROM creditopy.tarjetas n
WHERE n.tarjeta =
fc_pan2cripto(vr_sicoop_uuid.num_cuenta_destino);
IF v_num_cuenta_destino = fn_numero_cuenta THEN
vc_leyenda := vr_sicoop_uuid.glosa_para_destino;
vn_rubro_especial := 1;
vn_buscar_leyenda := 0;
END IF;
EXCEPTION
WHEN no_data_found THEN
v_num_cuenta_destino := 0;
WHEN OTHERS THEN
RAISE;
END;
END IF;
END IF;
END IF;
-- si no se obtuvo la leyenda entonces se busca por el rubro y sus condiciones
IF nvl(vn_rubro_especial, 0) != 1 THEN
-- se revisa si es un emisor prepago y debe buscar la glosa equivalente
-- o es emisor TC y tiene parametrizado utilizar la leyenda como descripcion del movimiento
BEGIN
IF creditopy.pkg_dimo_ceibo.fn_is_prepaga(fn_emisor) = 1 THEN
SELECT decode(nvl(TRIM(rg.descripcion), ' '),
' ',
ru.descripcion,
rg.descripcion),
nvl(rg.buscar_concepto, 0)
INTO vc_desc_rubro, vn_buscar_leyenda
FROM creditopy.rubros ru, creditopy.rubros_glosa_tp rg
WHERE ru.rubro = fn_rubro
AND rg.rubro = ru.rubro;
ELSE
SELECT nvl(rg.buscar_concepto, 0)
INTO vn_buscar_leyenda
FROM creditopy.rubros_glosa_tc rg
WHERE rg.emisor = fn_emisor
AND (rg.rubro = fn_rubro OR rg.rubro = 0);
END IF;
EXCEPTION
WHEN no_data_found THEN
vc_desc_rubro := NULL;
vn_buscar_leyenda := 0;
WHEN OTHERS THEN
RAISE;
END;
-- si permite usar la leyenda se puede tomar el dato recibido, si no es leyenda especial
-- o se busca la leyenda
IF vn_buscar_leyenda = 1 THEN
IF TRIM(fn_leyenda) IS NOT NULL THEN
vc_leyenda := fn_leyenda;
ELSE
vc_leyenda := nvl(vc_leyenda_ajuste, ' ');
END IF;
ELSE
vc_leyenda_ajuste := NULL; -- fix Release 2.7.9.1 PROD JZ/AR
END IF;
END IF;
-- si hay leyenda se despliega la glosa del rubro + la leyenda
-- si no hay leyenda del movimiento ni descripcion equivalente de rubro entonces
-- desplegar la descripcion del rubro origen
IF nvl(TRIM(vc_desc_rubro), ' ') = ' ' THEN
SELECT r.descripcion
INTO vc_desc_rubro
FROM creditopy.rubros r
WHERE r.rubro = fn_rubro;
END IF;
--if vc_leyenda is null then
IF nvl(vc_leyenda_ajuste, ' ') = ' ' THEN
vc_glosa := vc_desc_rubro;
ELSE
--vc_glosa := trim(vc_desc_rubro)||'-'||trim(vc_leyenda);
vc_glosa := TRIM(vc_leyenda);
END IF;
RETURN vc_glosa;
EXCEPTION
WHEN no_data_found THEN
vc_desc_rubro := ' ';
RETURN vc_desc_rubro;
WHEN OTHERS THEN
RAISE;
END fn_get_leyenda_movimiento;
FUNCTION fn_get_glosa_aut_trxs(fi_tarjeta VARCHAR2,
fi_tipo_trxs VARCHAR2,
fi_fecha DATE,
fi_hora DATE,
fi_numero_auditoria NUMBER,
fi_nro_ticket NUMBER,
fi_emisor_proc NUMBER,
fi_comercio NUMBER,
fi_emisor NUMBER,
fi_acquirer VARCHAR2)
RETURN VARCHAR2 IS
v_tarjeta VARCHAR2(16);
vr_sicoop_uuid creditopy.sicoop_uuid@olpy%ROWTYPE;
vc_glosa_transaccion VARCHAR2(1024);
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 18/06/2019
Propósito: Función que retorna la descripción modificada de la red de una transaccion
******************************************************************************************************/
BEGIN
-- primero busca la glosa en la transaccion
BEGIN
v_tarjeta := fc_cripto2pan(fi_tarjeta);
SELECT su.glosa_para_origen, su.glosa_para_destino
INTO vr_sicoop_uuid.glosa_para_origen,
vr_sicoop_uuid.glosa_para_destino
FROM creditopy.sicoop_uuid@olpy su
WHERE su.numero_auditoria = fi_numero_auditoria
AND su.fecha = fi_fecha
--and su.nro_ticket_rrn = fi_nro_ticket
AND ((nvl(fi_tipo_trxs, ' ') = 'C' AND
su.num_cuenta_origen = v_tarjeta) OR
(nvl(fi_tipo_trxs, ' ') = 'P' AND
su.num_cuenta_destino = v_tarjeta));
CASE nvl(fi_tipo_trxs, ' ')
WHEN 'C' THEN
-- consumo: la transaccion viene de una autorizacion de compra
vc_glosa_transaccion := TRIM(vr_sicoop_uuid.glosa_para_origen);
WHEN 'P' THEN
-- pago o deposito
vc_glosa_transaccion := TRIM(vr_sicoop_uuid.glosa_para_destino);
ELSE
vc_glosa_transaccion := ' ';
END CASE;
EXCEPTION
WHEN no_data_found THEN
vc_glosa_transaccion := ' ';
WHEN OTHERS THEN
RAISE;
END;
IF TRIM(vc_glosa_transaccion) IS NULL THEN
IF nvl(fi_tipo_trxs, ' ') = 'C' THEN
-- busco la descripcion del comercio
vc_glosa_transaccion := creditopy.Pkg_Dimo_Ceibo.fn_get_comercio_desc(fi_emisor_proc,
fi_comercio,
fi_emisor);
ELSE
/*if nvl(fi_tipo_trxs,' ') = 'C' then
vc_glosa_transaccion := 'DEPOSITO '||creditopy.Pkg_Dimo_Ceibo.FN_GET_RED(fi_acquirer);
end if;*/
IF nvl(fi_tipo_trxs, ' ') = 'P' THEN
IF pkg_dimo_ceibo.fn_is_prepaga(fi_emisor) = 1 THEN
vc_glosa_transaccion := 'DEPOSITO ' ||
creditopy.Pkg_Dimo_Ceibo.FN_GET_RED(nvl(fi_acquirer,
0));
ELSE
vc_glosa_transaccion := 'PAGO ' ||
creditopy.Pkg_Dimo_Ceibo.FN_GET_RED(nvl(fi_acquirer,
0));
END IF;
END IF;
END IF;
END IF;
RETURN vc_glosa_transaccion;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END fn_get_glosa_aut_trxs;
FUNCTION fn_get_red(fn_acquirer IN creditopy.acquirers.acquirer@olpy%TYPE)
RETURN VARCHAR2 IS
vc_desc_red creditopy.acquirers.descripcion@olpy%TYPE;
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 18/06/2019
Propósito: Función que retorna la descripción modificada de la red de una transaccion
******************************************************************************************************/
BEGIN
SELECT decode(h.acquirer,
10000000005,
'EN LINEA',
10000000013,
'EN BOCA DE COBRANZA',
10000000008,
'EN CAJA',
REPLACE(h.descripcion, 'PAGOS '))
INTO vc_desc_red
FROM creditopy.acquirers@olpy h
WHERE h.acquirer = fn_acquirer;
RETURN vc_desc_red;
EXCEPTION
WHEN no_data_found THEN
vc_desc_red := ' ';
RETURN vc_desc_red;
WHEN OTHERS THEN
RAISE;
END fn_get_red;
FUNCTION fn_get_motivo_bloqueo(fn_motivo IN motivos_devolucion.devcod%TYPE)
RETURN VARCHAR2 AS
vc_resultado VARCHAR2(128);
BEGIN
SELECT devdesc
INTO vc_resultado
FROM creditopy.motivos_devolucion md
WHERE md.devcod = fn_motivo;
RETURN vc_resultado;
EXCEPTION
WHEN no_data_found THEN
RETURN 'NO DEFINIDO';
END;
FUNCTION fn_get_ult_rechazo_solicitud(fn_id_solicitud IN solicitudes_recibidas.id_solicitud_recibida%TYPE,
fn_codigo_respuesta IN solicitudes_recibidas.codigo_respuesta%TYPE)
RETURN VARCHAR2 AS
vc_motivo creditopy.solicitudes_motivos_rechazos.motivo_rechazo%TYPE;
BEGIN
SELECT x.motivo_rechazo resultado
INTO vc_motivo
FROM creditopy.solicitudes_recibidas sr,
creditopy.solicitudes_motivos_rechazos x
WHERE sr.id_solicitud_recibida = fn_id_solicitud
AND sr.codigo_respuesta != 0
AND x.id_solicitud_recibida = sr.id_solicitud_recibida
AND x.regla_id = fn_codigo_respuesta;
RETURN vc_motivo;
EXCEPTION
WHEN no_data_found THEN
RETURN 'NO DEFINIDO';
WHEN OTHERS THEN
RAISE;
END;
FUNCTION fn_random RETURN BINARY_INTEGER IS
vn_inicio NUMBER;
vn_random BINARY_INTEGER;
BEGIN
vn_inicio := to_char(systimestamp, 'FF');
dbms_random.initialize(vn_inicio);
vn_random := dbms_random.random;
dbms_random.terminate;
RETURN(vn_random);
END fn_random;
FUNCTION fn_gen_pin(fn_pin IN tarjetas.pin%TYPE DEFAULT NULL)
RETURN VARCHAR2 AS
vc_pin tarjetas.pin%TYPE;
BEGIN
IF fn_pin IS NULL THEN
vc_pin := rpad(substr(fn_random, -4), 16, 0);
ELSE
vc_pin := fn_pin;
END IF;
vc_pin := pcutiles.desf('E', 'ADCF8073FAD1CF55', vc_pin);
RETURN vc_pin;
EXCEPTION
WHEN OTHERS THEN
raise_application_error(-20001,
'Error al calcular el pin para la tarjeta.');
END fn_gen_pin;
FUNCTION fn_getComercioGestionDIMO RETURN NUMBER AS
v_cod_comercio_dimo NUMBER;
BEGIN
SELECT ec.comercio_puente
INTO v_cod_comercio_dimo
FROM creditopy.emisor_comercios_tarj_puente ec
WHERE ec.participante = 115;
RETURN v_cod_comercio_dimo;
EXCEPTION
WHEN no_data_found THEN
RETURN - 1;
WHEN OTHERS THEN
raise_application_error(-20001,
'Error al obtener comercio de gestion DIMO.');
END;
FUNCTION fc_getTarjetaPuenteDIMO RETURN VARCHAR2 AS
v_tarjeta_puente_DIMO VARCHAR2(16);
BEGIN
SELECT ec.tarjeta_puente
INTO v_tarjeta_puente_DIMO
FROM creditopy.emisor_comercios_tarj_puente ec
WHERE ec.participante = 115;
RETURN v_tarjeta_puente_DIMO;
EXCEPTION
WHEN no_data_found THEN
RETURN - 1;
WHEN OTHERS THEN
raise_application_error(-20001,
'Error al obtener tarjeta para transferencia DIMO.');
END;
FUNCTION fn_emisor_proc_habilitado(fn_emisor IN NUMBER) RETURN NUMBER AS
v_emisor_proc NUMBER;
v_habil_generico NUMBER;
v_habilitado NUMBER;
BEGIN
v_emisor_proc := CEIBO_UTILES.FN_GET_EMISOR_PROCESADOR(fn_emisor);
BEGIN
SELECT ep.habilitado_dimo
INTO v_habil_generico
FROM creditopy.emisor_procesador_dimo ep
WHERE ep.emisor_procesador = v_emisor_proc
AND ep.emisor = 0;
EXCEPTION
WHEN no_data_found THEN
v_habil_generico := 0;
WHEN OTHERS THEN
RAISE;
END;
BEGIN
SELECT ep.habilitado_dimo
INTO v_habilitado
FROM creditopy.emisor_procesador_dimo ep
WHERE ep.emisor_procesador = v_emisor_proc
AND ep.emisor = fn_emisor;
v_habil_generico := 0; -- se desactiva porque prima el flag obtenido
EXCEPTION
WHEN no_data_found THEN
v_habilitado := 0;
WHEN OTHERS THEN
RAISE;
END;
IF v_habilitado = 0 THEN
v_habilitado := v_habil_generico;
END IF;
RETURN v_habilitado;
EXCEPTION
WHEN no_data_found THEN
RETURN 0;
WHEN OTHERS THEN
raise_application_error(-20001,
'Error al obtener procesador habilitado DIMO.');
END;
FUNCTION FC_GET_FECHA_LARGA(DP_FECHA IN DATE) RETURN VARCHAR2 AS
BEGIN
RETURN TO_CHAR(DP_FECHA, FORMATO_FECHA);
END FC_GET_FECHA_LARGA;
FUNCTION FC_GET_ID_NOVEDAD RETURN VARCHAR2 AS
BEGIN
RETURN 'Tipo Novedad>' || VR_HISTORICO.NOVTIP || '< Novedad>' || VR_HISTORICO.NOVNRO || '< Fecha Ingreso>' || NVL(TO_CHAR(VR_HISTORICO.NOVFCHING,
FORMATO_FECHA),
'NONE') || '< NovGen>' || VR_HISTORICO.NOVGEN || '< Usuario>' || VR_HISTORICO.USUARIO || '<';
END;
FUNCTION FC_GET_TIPO_PLASTICO RETURN VARCHAR2 AS
VC_TIPO_PLASTICO VARCHAR2(2);
PROCEDURE PL_TOO_MANY AS
BEGIN
SELECT A.TIPO_PLASTICO
INTO VC_TIPO_PLASTICO
FROM CREDITOPY.TIPO_PLASTICO A, CREDITOPY.GRUPOS_AFINIDAD B
WHERE B.EMISOR = A.EMISOR
AND B.PRODUCTO = A.PRODUCTO
AND B.GRUPO_AFINIDAD = A.GRUPO_AFINIDAD
AND SUBSTR(B.DESCRIPCION, 1, 2) = A.TIPO_PLASTICO
AND A.EMISOR = VR_AFINIDAD.EMISOR
AND A.PRODUCTO = VR_AFINIDAD.PRODUCTO
AND A.GRUPO_AFINIDAD = VR_AFINIDAD.GRUPO_AFINIDAD;
EXCEPTION
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.FC_GET_TIPO_PLASTICO.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.PRODUCTO:' || VR_AFINIDAD.PRODUCTO ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' ||
VR_AFINIDAD.GRUPO_AFINIDAD || FC_GET_ID_NOVEDAD ||
SQLERRM);
END PL_TOO_MANY;
BEGIN
SELECT A.TIPO_PLASTICO
INTO VC_TIPO_PLASTICO
FROM CREDITOPY.TIPO_PLASTICO A
WHERE A.EMISOR = VR_AFINIDAD.EMISOR
AND A.PRODUCTO = VR_AFINIDAD.PRODUCTO
AND A.GRUPO_AFINIDAD = VR_AFINIDAD.GRUPO_AFINIDAD;
RETURN VC_TIPO_PLASTICO;
EXCEPTION
WHEN TOO_MANY_ROWS THEN
PL_TOO_MANY;
RETURN VC_TIPO_PLASTICO;
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.FC_GET_TIPO_PLASTICO.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.PRODUCTO:' || VR_AFINIDAD.PRODUCTO ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' ||
VR_AFINIDAD.GRUPO_AFINIDAD || FC_GET_ID_NOVEDAD || SQLERRM);
END FC_GET_TIPO_PLASTICO;
FUNCTION FN_GET_NRO_NOVEDAD RETURN NUMBER AS
VN_RESULTADO NUMBER(6);
VL_INTENTOS NUMBER := 0;
BEGIN
VL_INTENTOS := VL_INTENTOS + 1;
SELECT CONTADOR_NOVEDADES.NEXTVAL@OLPY INTO VN_RESULTADO FROM DUAL;
RETURN VN_RESULTADO;
EXCEPTION
WHEN OTHERS THEN
IF VL_INTENTOS <= 3 THEN
VL_INTENTOS := VL_INTENTOS + 1;
SELECT CONTADOR_NOVEDADES.NEXTVAL@OLPY INTO VN_RESULTADO FROM DUAL;
RETURN VN_RESULTADO;
ELSE
RAISE_APPLICATION_ERROR(-20100,
'No se pudo recuperar el valor de la secuencia. Error: ' ||
SQLERRM);
END IF;
END FN_GET_NRO_NOVEDAD;
FUNCTION FC_PARSE_CADENA(CP_CADENA IN CLOB,
NP_PARSE IN INTEGER,
NP_LEN_DATA IN BINARY_INTEGER) RETURN VARCHAR2 AS
VI_INDEX BINARY_INTEGER;
BEGIN
VI_INDEX := 1 + (NP_LEN_DATA * NP_PARSE - NP_LEN_DATA);
RETURN SUBSTR(DBMS_LOB.substr(CP_CADENA,
DBMS_LOB.getlength(CP_CADENA),
1),
VI_INDEX,
NP_LEN_DATA);
END FC_PARSE_CADENA;
FUNCTION F_FILTRAR_CARACTERES_INVALIDOS(CP_PALABRA_A_FILTRAR IN VARCHAR2)
RETURN VARCHAR2 IS
VC_RESULTADO VARCHAR2(2049);
VC_LISTA_NEGRA VARCHAR2(2049);
VC_CARACTER CHAR(1);
VC_CAMBIO CHAR(1);
VN_POSICION BINARY_INTEGER;
-- ¿ÁÉÍÓÚáéíóúÁÉÍÓÚ'?&#-_abcdefghijklmnñopqrstuvwxyzÄËÏÖÜäëïöüÂÊÎÔÛâêîôû
VC_CAMBIOS VARCHAR2(512) := '#AEIOUAEIOUAEIOU######ABCEDFGHIJKLMNNOPQRSTUVWXYZAEIOUAEIOUAEIOUAEIOU';
BEGIN
VC_RESULTADO := CP_PALABRA_A_FILTRAR;
--Filtramos el Nombre Plastico
VC_LISTA_NEGRA := FC_GET_BLACKLIST_EMBOZADO(805);
FOR VN_INDEX IN 1 .. LENGTH(VC_RESULTADO) LOOP
VC_CARACTER := SUBSTR(VC_RESULTADO, VN_INDEX, 1);
VN_POSICION := INSTR(VC_LISTA_NEGRA, VC_CARACTER);
IF VN_POSICION > 0 THEN
VC_CAMBIO := SUBSTR(VC_CAMBIOS, VN_POSICION, 1);
VC_RESULTADO := REPLACE(VC_RESULTADO, VC_CARACTER, VC_CAMBIO);
END IF;
END LOOP;
RETURN(vc_resultado);
END F_FILTRAR_CARACTERES_INVALIDOS;
FUNCTION FC_GET_NOMBRE_PLASTICO(CP_NOMBRES IN DEBCREDPY.PERSONAS.NOMBRES%TYPE,
CP_APELLIDOS IN DEBCREDPY.PERSONAS.APELLIDOS%TYPE)
RETURN TARJETAS.NOMBRE_PARA_PLASTICO%TYPE AS
VC_NOMBRE DEBCREDPY.PERSONAS.NOMBRES%TYPE;
VC_APELLIDO DEBCREDPY.PERSONAS.NOMBRES%TYPE;
VC_COMODIN DEBCREDPY.PERSONAS.NOMBRES%TYPE;
VC_NOMRE_PLASTICO TARJETAS.NOMBRE_PARA_PLASTICO%TYPE;
--VC_LISTA_NEGRA VARCHAR2(2048);
--VC_CARACTER CHAR(1);
BEGIN
----Obtener Nombre para Plastico
CEIBO_COMERCIOS.PR_GET_NOMBRES_APELLIDOS(CP_NOMBRES,
VC_NOMBRE,
VC_COMODIN);
CEIBO_COMERCIOS.PR_GET_NOMBRES_APELLIDOS(CP_APELLIDOS,
VC_APELLIDO,
VC_COMODIN);
VC_NOMRE_PLASTICO := UPPER(TRIM(SUBSTR(VC_NOMBRE || ' ' || VC_APELLIDO,
1,
26)));
--VC_NOMRE_PLASTICO := fc_filtrar_nompla(VC_NOMRE_PLASTICO);
VC_NOMRE_PLASTICO := F_FILTRAR_CARACTERES_INVALIDOS(VC_NOMRE_PLASTICO);
--Filtramos el Nombre Plastico
/*
VC_LISTA_NEGRA := FC_GET_BLACKLIST_EMBOZADO(805);
FOR VN_INDEX IN 1 .. LENGTH(VC_NOMRE_PLASTICO) LOOP
VC_CARACTER := SUBSTR(VC_NOMRE_PLASTICO,VN_INDEX,1);
IF INSTR(VC_LISTA_NEGRA,VC_CARACTER) > 0 THEN
--Excepto numeral.
IF VC_CARACTER !='#' THEN
VC_NOMRE_PLASTICO := REPLACE(VC_NOMRE_PLASTICO,VC_CARACTER,'#');
END IF;
END IF;
END LOOP;
*/
RETURN VC_NOMRE_PLASTICO;
END;
--FUNCTION FD_FECHA_PROCESO(CP_PROCESO IN VARCHAR2 DEFAULT 'NONE')
FUNCTION FD_FECHA_PROCESO RETURN DEBCREDPY.FECHAS.FECHA_HOY%TYPE AS
VD_FECHA_PROCESO DATE;
BEGIN
/*Solo existe Fecha Proceso para la 805. AR,ER 201508112302*/
VD_FECHA_PROCESO := CEIBO_SOCIOS.GET_FECHA_PROCESO_MOV(805,
VR_HISTORICO.NOVTIP);
/*
Si la fecha proceso es en el dia, entonces aplicar SYSDATE.
Caso contrario mantener la fecha sin hora.
De lo contrario, si tomamos la hora y le agregamos a la fecha proceso
puede que la posterior activacion figure como anterior a la fecha y hora del proceso.
*/
IF TRUNC(SYSDATE) = TRUNC(VD_FECHA_PROCESO) THEN
VD_FECHA_PROCESO := SYSDATE;
END IF;
PR_LOGGING('WS',
'01',
' FECHA_PROCESO>' || FC_GET_FECHA_LARGA(VD_FECHA_PROCESO));
RETURN VD_FECHA_PROCESO;
EXCEPTION
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.FD_FECHA_PROCESO.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' ||
VR_AFINIDAD.GRUPO_AFINIDAD);
PR_LOGGING('WS', '01', FC_GET_ID_NOVEDAD || 'Error:' || SQLERRM);
RAISE;
END FD_FECHA_PROCESO;
FUNCTION FN_GET_NEXT_ADICIONAL(NP_NUMERO_CUENTA IN TARJETAS.NUMERO_CUENTA%TYPE)
RETURN TARJETAS.ADICIONAL%TYPE AS
VN_ADICIONAL TARJETAS.ADICIONAL%TYPE;
BEGIN
SELECT NVL(MAX(A.ADICIONAL), 0) + 1
INTO VN_ADICIONAL
FROM CREDITOPY.TARJETAS A
WHERE A.NUMERO_CUENTA = NP_NUMERO_CUENTA;
RETURN VN_ADICIONAL;
EXCEPTION
WHEN OTHERS THEN
RAISE_APPLICATION_ERROR(-20001,
'PKG_DIMO_CEIBO.FD_FECHA_PROCESO.FN_GET_NEXT_ADICIONAL' ||
' NP_NUMERO_CUENTA:' || NP_NUMERO_CUENTA || ' ' ||
FC_GET_ID_NOVEDAD || ' Error:' || SQLERRM);
END;
FUNCTION FD_GET_NEW_VIGENCIA RETURN DATE AS
VD_VIGENCIA DATE;
FUNCTION FL_GET_PARAMETROS RETURN VARCHAR2 AS
BEGIN
RETURN 'Parametros: EMISOR>' || VR_AFINIDAD.EMISOR || '<' || 'PRODUCTO>' || VR_AFINIDAD.PRODUCTO || '<' || 'GRUPO_AFINIDAD>' || VR_AFINIDAD.GRUPO_AFINIDAD || '<' || 'CARTERA>' || VR_CARTERA.CARTERA || '<' || 'FECHA_PROCESO>' || VR_CUENTA.FECHA_ESTADO || '<';
END FL_GET_PARAMETROS;
BEGIN
VD_VIGENCIA := CEIBO_SOCIOS.GET_VIGENCIA_NUEVA(VR_TARJETA.EMISOR,
VR_TARJETA.PRODUCTO,
VR_TARJETA.GRUPO_AFINIDAD,
VR_CUENTA.CARTERA,
VR_CUENTA.FECHA_ESTADO,
NULL,
NULL);
RETURN VD_VIGENCIA;
EXCEPTION
WHEN OTHERS THEN
RAISE_APPLICATION_ERROR(-20001,
'No se logro obtener una vigencia valida.' ||
FC_GET_ID_NOVEDAD ||
'<No se logro obtener una vigencia valida.' ||
FL_GET_PARAMETROS || ' Error>' || SQLERRM);
END;
FUNCTION FN_GET_COBOL_CUENTA_DV(CP_CUENTA IN VARCHAR2) RETURN NUMBER AS
VC_CUENTA VARCHAR2(12);
VC_BASE VARCHAR2(12) := '971397139713';
VN_TOTAL NUMBER(4);
VN_FACTOR NUMBER(2);
FUNCTION FI_DIGITO_ONE(NP_DIGITO IN NUMBER, NP_INDEX IN NUMBER)
RETURN NUMBER AS
BEGIN
RETURN TO_NUMBER(SUBSTR(LPAD(NP_DIGITO, 2, 0), NP_INDEX, 1));
END FI_DIGITO_ONE;
BEGIN
VC_CUENTA := LPAD(CP_CUENTA, 12, 0);
VN_TOTAL := 0;
FOR VI_INDEX IN 1 .. 12 LOOP
VN_FACTOR := TO_NUMBER(SUBSTR(VC_CUENTA, VI_INDEX, 1)) *
TO_NUMBER(SUBSTR(VC_BASE, VI_INDEX, 1));
VN_TOTAL := VN_TOTAL + FI_DIGITO_ONE(VN_FACTOR, -1);
END LOOP;
IF VN_TOTAL > 9 THEN
VN_TOTAL := FI_DIGITO_ONE(VN_TOTAL, 1) + 1 || 0 - VN_TOTAL;
ELSE
VN_TOTAL := 10 - VN_TOTAL;
END IF;
RETURN SUBSTR(LPAD(VN_TOTAL, 2, 0), -1);
END FN_GET_COBOL_CUENTA_DV;
FUNCTION FR_ULT_PERIODO_CERRADO(NP_EMISOR IN CALENDARIO_CIERRES.EMISOR%TYPE DEFAULT NULL,
NP_PRODUCTO IN CALENDARIO_CIERRES.PRODUCTO%TYPE DEFAULT NULL,
NP_CIERRE IN CALENDARIO_CIERRES.CIERRE%TYPE DEFAULT NULL,
NP_GRUPO_AFINIDAD IN CALENDARIO_CIERRES.GRUPO_AFINIDAD%TYPE DEFAULT NULL)
RETURN CREDITOPY.CALENDARIO_CIERRES%ROWTYPE AS
VR_ULTIMO_CIERRE CREDITOPY.CALENDARIO_CIERRES%ROWTYPE;
BEGIN
VR_ULTIMO_CIERRE.EMISOR := NVL(NP_EMISOR, VR_CUENTA.EMISOR);
VR_ULTIMO_CIERRE.PRODUCTO := NVL(NP_PRODUCTO, VR_CUENTA.PRODUCTO);
VR_ULTIMO_CIERRE.CIERRE := NVL(NP_CIERRE, VR_CUENTA.CIERRE);
VR_ULTIMO_CIERRE.PERIODO := CREDITOPY.CEIBO_UTILES.GetUltPeriodoCerrado(VR_ULTIMO_CIERRE.EMISOR,
VR_ULTIMO_CIERRE.PRODUCTO,
VR_ULTIMO_CIERRE.CIERRE);
VR_ULTIMO_CIERRE.GRUPO_AFINIDAD := NVL(NP_GRUPO_AFINIDAD,
VR_CUENTA.GRUPO_AFINIDAD);
SELECT *
INTO VR_ULTIMO_CIERRE
FROM CREDITOPY.CALENDARIO_CIERRES@BAPY A
WHERE A.EMISOR = VR_ULTIMO_CIERRE.EMISOR
AND A.PRODUCTO = VR_ULTIMO_CIERRE.PRODUCTO
AND A.CIERRE = VR_ULTIMO_CIERRE.CIERRE
AND A.PERIODO = VR_ULTIMO_CIERRE.PERIODO
AND A.GRUPO_AFINIDAD = VR_ULTIMO_CIERRE.GRUPO_AFINIDAD;
RETURN VR_ULTIMO_CIERRE;
EXCEPTION
WHEN OTHERS THEN
RAISE_APPLICATION_ERROR(-20001,
FC_GET_ID_NOVEDAD ||
' VR_ULTIMO_CIERRE.EMISOR:' ||
VR_ULTIMO_CIERRE.EMISOR ||
' VR_ULTIMO_CIERRE.PRODUCTO:' ||
VR_ULTIMO_CIERRE.PRODUCTO ||
' VR_ULTIMO_CIERRE.CIERRE:' ||
VR_ULTIMO_CIERRE.CIERRE ||
' VR_ULTIMO_CIERRE.PERIODO:' ||
VR_ULTIMO_CIERRE.PERIODO ||
' VR_ULTIMO_CIERRE.GRUPO_AFINIDAD:' ||
VR_ULTIMO_CIERRE.GRUPO_AFINIDAD || ' Error:' ||
SQLERRM);
END FR_ULT_PERIODO_CERRADO;
FUNCTION FC_FILTRAR_NOMPLA(CP_NOMBRE_PLASTICO IN VARCHAR2) RETURN VARCHAR2 IS
VC_RESULTADO VARCHAR2(26);
--VC_LISTA_NEGRA VARCHAR2(2049);
--VC_CARACTER CHAR(1);
--VC_CAMBIO CHAR(1);
--VN_POSICION BINARY_INTEGER;
-- ¿ÁÉÍÓÚáéíóúÁÉÍÓÚ'?&#-_abcdefghijklmnñopqrstuvwxyzÄËÏÖÜäëïöüÂÊÎÔÛâêîôû
--VC_CAMBIOS VARCHAR2(512) := '#AEIOUAEIOUAEIOU######ABCEDFGHIJKLMNNOPQRSTUVWXYZAEIOUAEIOUAEIOUAEIOU';
BEGIN
IF LENGTH(CP_NOMBRE_PLASTICO) > 26 THEN
RAISE_APPLICATION_ERROR(-20001,
'El nombre para plastico no debe exceder de 26 caracteres!');
END IF;
VC_RESULTADO := UPPER(CP_NOMBRE_PLASTICO);
VC_RESULTADO := F_FILTRAR_CARACTERES_INVALIDOS(VC_RESULTADO);
/*
--Filtramos el Nombre Plastico
VC_LISTA_NEGRA := FC_GET_BLACKLIST_EMBOZADO(805);
FOR VN_INDEX IN 1 .. LENGTH(VC_RESULTADO) LOOP
VC_CARACTER := SUBSTR(VC_RESULTADO,VN_INDEX,1);
VN_POSICION := INSTR(VC_LISTA_NEGRA,VC_CARACTER);
IF VN_POSICION > 0 THEN
VC_CAMBIO := SUBSTR(VC_CAMBIOS,VN_POSICION,1);
VC_RESULTADO := REPLACE(VC_RESULTADO,VC_CARACTER,VC_CAMBIO);
END IF;
END LOOP;
*/
RETURN(VC_RESULTADO);
END FC_FILTRAR_NOMPLA;
FUNCTION get_usuario RETURN VARCHAR2 AS
BEGIN
PV_USUARIO := NVL(PV_USUARIO, CC_USUARIO_DIMO);
RETURN PV_USUARIO;
END get_usuario;
-- ====================================================================== --
-- Autor: Lic. Orlando Ojeda
-- Fecha: 30/04/2021
-- Proposito: Obtener el CVV de una tarjeta...
-- ====================================================================== --
FUNCTION f_get_cvc_tarjeta(pi_tarjeta IN VARCHAR2) RETURN VARCHAR2 IS
v_cvv VARCHAR2(100);
BEGIN
BEGIN
PCUTILES.GET_PAN_CRIPTOKEY;
END;
SELECT CS.GET_CVC(CEIBO_UTILES.FN_GET_EMISOR_PROCESADOR(T.EMISOR),
T.TARJETA,
T.FECHA_VIGENCIA,
2) cvv
INTO v_cvv
FROM tarjetas t
WHERE 1 = 1
AND t.tarjeta = pi_tarjeta;
RETURN v_cvv;
EXCEPTION
WHEN OTHERS THEN
RETURN NULL;
END;
-- ====================================================================== --
-- Autor: Lic. Orlando Ojeda
-- Fecha: 29/04/2021
-- Proposito: Retornar el valor de la respuesta configurada
-- para la pregunta de seguridad y la tarjeta
-- ====================================================================== --
FUNCTION f_get_resp_pregunta_vinc_tc(pi_id_pregunta IN NUMBER,
pi_tarjeta IN VARCHAR2)
RETURN VARCHAR2 AS
v_retorno VARCHAR2(3000) := NULL;
v_sql_valid VARCHAR2(1000);
BEGIN
BEGIN
SELECT ps.sql_respuesta
INTO v_sql_valid
FROM creditopy.dimo_tc_preguntas_seguridad ps
WHERE ps.id_pregunta = pi_id_pregunta
AND ps.estado = 1 -- 1 Activo
AND PS.DESTINO_CONSULTA = 'VTC' --DESTINO
;
EXECUTE IMMEDIATE v_sql_valid
INTO v_retorno
USING pi_tarjeta;
EXCEPTION
WHEN OTHERS THEN
NULL;
END;
RETURN TRIM(v_retorno);
EXCEPTION
WHEN OTHERS THEN
RETURN NULL;
END;
-- ====================================================================== --
-- Autor: FELICIANO AMARILLA
-- Fecha: 29/04/2021
-- Proposito: Retornar el valor de la respuesta configurada
-- para la pregunta de seguridad de tu eres tu
-- ====================================================================== --
FUNCTION f_get_resp_pregunta_tutu(pi_id_pregunta IN NUMBER,
pi_documento IN VARCHAR2)
RETURN VARCHAR2 AS
v_retorno VARCHAR2(3000) := NULL;
v_sql_valid VARCHAR2(4000);
BEGIN
BEGIN
SELECT ps.sql_respuesta
INTO v_sql_valid
FROM creditopy.dimo_tc_preguntas_seguridad ps
WHERE ps.id_pregunta = pi_id_pregunta
AND ps.estado = 1 -- 1 Activo
AND PS.DESTINO_CONSULTA = 'TUTU' --DESTINO
;
EXECUTE IMMEDIATE v_sql_valid
INTO v_retorno
USING pi_documento;
EXCEPTION
WHEN OTHERS THEN
NULL;
-- raise_application_error(-20001,sqlerrm||' '|| v_sql_valid );
END;
RETURN TRIM(v_retorno);
EXCEPTION
WHEN OTHERS THEN
RETURN NULL;
-- v_retorno:=sqlerrm||' '|| v_sql_valid;
--return v_retorno;
-- creditopy.pkg_dimo_ceibo.pr_ceibo_log('DIMO', 'PREGUN_TUTU', TO_CHAR(sqlerrm), sysdate, 'DIMO');
-- raise_application_error(-20001,sqlerrm||' '|| v_sql_valid );
END f_get_resp_pregunta_tutu;
-- ===================================================================================== --
-- Autor: Lic. Orlando Ojeda
-- Fecha: 30/04/2021
-- Proposito: Retornar un valor random relacionado a la pregunta de seguridad de la TC
-- ===================================================================================== --
FUNCTION f_valor_random_pregun_vinc_tc(pi_id_pregunta IN NUMBER)
RETURN VARCHAR2 AS
v_retorno VARCHAR2(3000) := NULL;
v_sql VARCHAR2(1000);
BEGIN
BEGIN
SELECT ps.sql_valor_random
INTO v_sql
FROM creditopy.dimo_tc_preguntas_seguridad ps
WHERE ps.id_pregunta = pi_id_pregunta
AND ps.estado = 1 -- 1 Activo
AND PS.DESTINO_CONSULTA = 'VTC' --DESTINO
;
EXECUTE IMMEDIATE v_sql
INTO v_retorno;
EXCEPTION
WHEN OTHERS THEN
NULL;
END;
RETURN TRIM(v_retorno);
EXCEPTION
WHEN OTHERS THEN
RETURN NULL;
END;
-- ===================================================================================== --
-- Autor: Feliciano Amarilla
-- Fecha: 07/08/2023
-- Proposito: Retornar un valor random relacionado a la pregunta de seguridad de tu eres tu
-- del catastro de Dimo
-- ===================================================================================== --
FUNCTION f_valor_random_pregun_tutu(pi_id_pregunta IN NUMBER,
pi_dcumento IN VARCHAR2)
RETURN VARCHAR2 AS
v_retorno VARCHAR2(3000) := NULL;
v_sql VARCHAR2(4000);
BEGIN
BEGIN
SELECT ps.sql_valor_random
INTO v_sql
FROM creditopy.dimo_tc_preguntas_seguridad ps
WHERE ps.id_pregunta = pi_id_pregunta
AND ps.estado = 1 -- 1 Activo
AND PS.DESTINO_CONSULTA = 'TUTU' --DESTINO
;
EXECUTE IMMEDIATE v_sql
INTO v_retorno
USING pi_dcumento;
EXCEPTION
WHEN OTHERS THEN
NULL;
-- v_retorno:=sqlerrm||' '||v_sql;
END;
RETURN TRIM(v_retorno);
EXCEPTION
WHEN OTHERS THEN
RETURN NULL;
END f_valor_random_pregun_tutu;
-------
------
PROCEDURE set_usuario(PI_USUARIO IN VARCHAR2 DEFAULT NULL) AS
BEGIN
PV_USUARIO := SUBSTR(NVL(PI_USUARIO, CC_USUARIO_DIMO), 1, 16);
END set_usuario;
PROCEDURE sp_setearValoresSession IS
BEGIN
dbms_session.set_nls('NLS_LANGUAGE', chr(39) || 'SPANISH' || chr(39));
dbms_session.set_nls('NLS_TERRITORY', chr(39) || 'SPAIN' || chr(39));
dbms_session.set_nls('NLS_CURRENCY', chr(39) || '?' || chr(39));
dbms_session.set_nls('NLS_ISO_CURRENCY', chr(39) || 'SPAIN' || chr(39));
dbms_session.set_nls('NLS_NUMERIC_CHARACTERS',
chr(39) || ',.' || chr(39));
dbms_session.set_nls('NLS_DATE_FORMAT',
chr(39) || 'DD/MM/RR' || chr(39));
dbms_session.set_nls('NLS_DATE_LANGUAGE',
chr(39) || 'SPANISH' || chr(39));
dbms_session.set_nls('NLS_SORT', chr(39) || 'SPANISH' || chr(39));
END sp_setearValoresSession;
PROCEDURE sp_delay(fn_segundos IN NUMBER) AS
v_ini DATE;
v_fin DATE;
BEGIN
v_ini := SYSDATE;
DBMS_LOCK.SLEEP(nvl(fn_segundos, 1)); -- segundo de delay
v_fin := SYSDATE;
END sp_delay;
PROCEDURE sp_setEmisorDimo AS
BEGIN
SELECT ep.Emisor
INTO PV_EMISOR_DIMO
FROM creditopy.emisores_prepago ep
WHERE TRIM(ep.marca) = CC_DIMO;
EXCEPTION
WHEN NO_DATA_FOUND THEN
raise_application_error(-20001, 'Emisor DIMO no configurado.');
END sp_setEmisorDimo;
/*PROCEDURE PR_SET_USUARIO(CP_USUARIO IN VARCHAR2)
AS
BEGIN
PV_USUARIO := CP_USUARIO;
END;*/
PROCEDURE PR_LIMPIAR_HISTORICO AS
BEGIN
--Limpiamos la tabla VR_HISTORICOS.
VR_HISTORICOS.DELETE;
--Inicializamos Datos constantes en el historico de Cuentas. Se asume que la tarjeta es titular.
VR_HISTORICO.USUARIO := CC_USUARIO_DIMO;
VR_HISTORICO.DESPLEGAR := 0;
VR_HISTORICO.NOVGEN := 0;
VR_HISTORICO.NOVTIP := 1;
VR_HISTORICO.OPCION := 'NovAltaCuentaTarjetaHandler';
VR_HISTORICO.TITULAR := 1;
VR_HISTORICO.NOVFCHING := SYSDATE;
VR_HISTORICO.FECHA_REGISTRO := VR_HISTORICO.NOVFCHING;
VR_HISTORICO.EMISOR := VR_EMISOR.EMISOR;
END PR_LIMPIAR_HISTORICO;
PROCEDURE PR_REGISTRAR_HISTORICO AS
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
FOR IDX IN 1 .. VR_HISTORICOS.COUNT LOOP
INSERT INTO HISTORICO_CUENTAS@OLPY VALUES VR_HISTORICOS (IDX);
END LOOP;
COMMIT;
--Limpiamos la tabla VR_HISTORICOS.
PR_LIMPIAR_HISTORICO;
END PR_REGISTRAR_HISTORICO;
PROCEDURE PR_RECHAZAR_NOVEDAD AS
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
PV_REGLA_ID := SOCIOS_MANTENIMIENTOS.FC_GET_REGLA_ID;
PV_MENSAJE := SOCIOS_MANTENIMIENTOS.FC_GET_MENSAJE;
--Motivo de Rechazo
VR_HISTORICO.TABLA := 'NOVEDADES_CUENTAS';
VR_HISTORICO.CAMPO := 'REGLA_VALIDACION';
IF SQLERRM IS NULL THEN
VR_HISTORICO.DATO_ANTERIOR := ' ';
ELSE
VR_HISTORICO.DATO_ANTERIOR := SUBSTR(SQLERRM, 1, 150);
END IF;
VR_HISTORICO.DATO_POSTERIOR := 'reglaId:' || PV_REGLA_ID || ' ' ||
PV_MENSAJE;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
PR_REGISTRAR_HISTORICO;
UPDATE HISTORICO_CUENTAS@OLPY HC
SET HC.NOVGEN = '3'
WHERE HC.NOVTIP = VR_HISTORICO.NOVTIP
AND HC.NOVNRO = VR_HISTORICO.NOVNRO
AND HC.NOVFCHING = VR_HISTORICO.NOVFCHING;
COMMIT;
END PR_RECHAZAR_NOVEDAD;
PROCEDURE PR_SET_FECHA_COSTO_ALTA AS
BEGIN
/*
FECHA_COSTO. Encuentro que se unifico la rutina en el cobol para altas y reposiciones.
El calculo es siempre FECHA_COSTO = last_day(add_months(fecha_otorgada de la nueva tarjeta,12)).
Tambien reactivaciones.
VR_TARJETA.FECHA_OTORGADA = FECHA PROCESO. Es para previnir la fecha otorgada aun no fue asignada.
*/
--En las altas, la tarjeta del registro de novedades siempre es nula.
VR_TARJETA.FECHA_COSTO := LAST_DAY(ADD_MONTHS(TRUNC(VR_CUENTA.FECHA_ESTADO),
12));
PR_LOGGING('WS',
'01',
' FECHA_COSTO>' ||
FC_GET_FECHA_LARGA(VR_TARJETA.FECHA_COSTO));
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_SET_FECHA_COSTO_ALTA. FECHA_COSTO:' ||
FC_GET_FECHA_LARGA(VR_TARJETA.FECHA_COSTO));
EXCEPTION
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_SET_FECHA_COSTO_ALTA. Error:' ||
SQLERRM);
END;
PROCEDURE PR_GET_AFINIDAD AS
BEGIN
SELECT *
INTO VR_AFINIDAD
FROM CREDITOPY.GRUPOS_AFINIDAD A
WHERE A.EMISOR = VR_AFINIDAD.EMISOR
AND A.PRODUCTO = 1
AND A.GRUPO_AFINIDAD = VR_AFINIDAD.GRUPO_AFINIDAD;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_AFINIDAD. Afinidad no encontrada.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' ||
VR_AFINIDAD.GRUPO_AFINIDAD);
RAISE_APPLICATION_ERROR(-20001,
'La Afinidad no fue encontrada. Emisor:' ||
VR_AFINIDAD.EMISOR || ' Afinidad:' ||
VR_AFINIDAD.GRUPO_AFINIDAD);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_AFINIDAD. Error al buscar la Afinidad.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' ||
VR_AFINIDAD.GRUPO_AFINIDAD);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar la Afinidad. Emisor:' ||
VR_AFINIDAD.EMISOR || ' Afinidad:' ||
VR_AFINIDAD.GRUPO_AFINIDAD);
END PR_GET_AFINIDAD;
PROCEDURE PR_GET_CIUDAD AS
BEGIN
SELECT *
INTO VR_CIUDAD
FROM DEBCREDPY.CIUDADES C
WHERE C.CIUDAD = VR_CIUDAD.CIUDAD
AND C.CODIGO_POSTAL = 2; -- Nueva Clasificacion de Ciudades. ER 202003200651.
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CIUDAD. Ciudad no encontrada.' ||
' VR_CIUDAD.CIUDAD:' || VR_CIUDAD.CIUDAD);
RAISE_APPLICATION_ERROR(-20001,
'La Ciudad no fue encontrada. Ciudad:' ||
VR_CIUDAD.CIUDAD);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CIUDAD. Error al buscar la Ciudad.' ||
' VR_CIUDAD.CIUDAD:' || VR_CIUDAD.CIUDAD);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar la Ciudad. Ciudad:' ||
VR_CIUDAD.CIUDAD);
END PR_GET_CIUDAD;
PROCEDURE PR_GET_CARTERA AS
BEGIN
SELECT *
INTO VR_CARTERA
FROM DEBCREDPY.CARTERAS A
WHERE A.EMISOR = VR_CARTERA.EMISOR
AND A.CARTERA = VR_CARTERA.CARTERA;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CARTERA.CARTERA NO ENCONTRADA.' ||
' VR_CARTERA.EMISOR:' || VR_CARTERA.EMISOR ||
' VR_CARTERA.CARTERA:' || VR_CARTERA.CARTERA);
RAISE_APPLICATION_ERROR(-20001,
'La cartera no fue encontrada. Emisor:' ||
VR_CARTERA.EMISOR || ' Cartera:' ||
VR_CARTERA.CARTERA);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CARTERA.CARTERA ERROR AL BUSCAR.' ||
' VR_NOVEDAD_CUENTA.EMISOR_CUENTA:' || VR_CARTERA.EMISOR ||
' VR_CARTERA:' || VR_CARTERA.CARTERA);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar la cartera ' ||
VR_CARTERA.CARTERA);
END PR_GET_CARTERA;
PROCEDURE PR_GET_CORRESPONDENCIA AS
BEGIN
SELECT *
INTO VR_CORRESPONDENCIA
FROM CREDITOPY.CODIGOS_CORRESPONDENCIA A
WHERE A.EMISOR = VR_CORRESPONDENCIA.EMISOR
AND A.CODIGO = VR_CORRESPONDENCIA.CODIGO;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CORRESPONDENCIA. Codigo de Correspondencia no encontrado.' ||
' VR_CORRESPONDENCIA.EMISOR:' || VR_CORRESPONDENCIA.EMISOR ||
' VR_CORRESPONDENCIA.CODIGO:' || VR_CORRESPONDENCIA.CODIGO);
RAISE_APPLICATION_ERROR(-20001,
'El codigo de correspondencia no fue encontrado. Emisor:' ||
VR_CORRESPONDENCIA.EMISOR || ' Codigo:' ||
VR_CORRESPONDENCIA.CODIGO);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CORRESPONDENCIA. Error al buscar el Codigo de Correspondencia.' ||
' VR_CORRESPONDENCIA.EMISOR:' || VR_CORRESPONDENCIA.EMISOR ||
' VR_CORRESPONDENCIA.CODIGO:' || VR_CORRESPONDENCIA.CODIGO);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar el Codigo de Correspondencia. Emisor:' ||
VR_CORRESPONDENCIA.EMISOR || ' Afinidad:' ||
VR_CORRESPONDENCIA.CODIGO);
END PR_GET_CORRESPONDENCIA;
PROCEDURE PR_GET_SEXO AS
BEGIN
SELECT *
INTO VR_SEXO
FROM DEBCREDPY.SEXOS A
WHERE A.SEXO = VR_SEXO.SEXO;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_SEXO. Sexo no encontrado.' ||
' VR_SEXO.SEXO:' || VR_SEXO.SEXO);
RAISE_APPLICATION_ERROR(-20001,
'El Sexo no fue encontrado. Sexo:' ||
VR_SEXO.SEXO);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_SEXO. Error al buscar el Sexo.' ||
' VR_SEXO.SEXO:' || VR_SEXO.SEXO);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar el Sexo. Sexo:' ||
VR_SEXO.SEXO);
END PR_GET_SEXO;
PROCEDURE PR_GET_ESTADO_CIVIL AS
BEGIN
SELECT *
INTO VR_ESTADO_CIVIL
FROM DEBCREDPY.ESTADOS_CIVILES A
WHERE A.ESTADO_CIVIL = VR_ESTADO_CIVIL.ESTADO_CIVIL;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_ESTADO_CIVIL. Estado Civil no encontrado.' ||
' VR_ESTADO_CIVIL.ESTADO_CIVIL:' ||
VR_ESTADO_CIVIL.ESTADO_CIVIL);
RAISE_APPLICATION_ERROR(-20001,
'El Estado Civil no fue encontrado. Sexo:' ||
VR_ESTADO_CIVIL.ESTADO_CIVIL);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_ESTADO_CIVIL. Error al buscar el Estado Civil.' ||
' VR_NOVEDAD_TARJETA.ESTADO_CIVIL:' ||
VR_ESTADO_CIVIL.ESTADO_CIVIL);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar el Estado Civil. Estado Civil:' ||
VR_ESTADO_CIVIL.ESTADO_CIVIL);
END PR_GET_ESTADO_CIVIL;
PROCEDURE PR_GET_OCUPACION AS
BEGIN
SELECT *
INTO VR_OCUPACION
FROM DEBCREDPY.OCUPACIONES A
WHERE A.CODIGO_OCUPACION = VR_OCUPACION.CODIGO_OCUPACION;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_OCUPACION. Ocupacion no encontrada.' ||
' VR_OCUPACION.CODIGO_OCUPACION:' ||
VR_OCUPACION.CODIGO_OCUPACION);
RAISE_APPLICATION_ERROR(-20001,
'La Ocupacion no fue encontrada. Ocupacion:' ||
VR_OCUPACION.CODIGO_OCUPACION);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_OCUPACION. Error al buscar la Ocupacion.' ||
' VR_OCUPACION.CODIGO_OCUPACION:' ||
VR_OCUPACION.CODIGO_OCUPACION);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar la Ocupacion. Ocupacion:' ||
VR_OCUPACION.CODIGO_OCUPACION);
END PR_GET_OCUPACION;
PROCEDURE PR_GET_PROMOTOR AS
BEGIN
SELECT *
INTO VR_PROMOTOR
FROM DEBCREDPY.CAPTADORES A
WHERE A.EMISOR = VR_PROMOTOR.EMISOR
AND A.CODIGO_CAPTADOR = VR_PROMOTOR.CODIGO_CAPTADOR;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_PROMOTOR. Promotor no encontrado.' ||
' VR_PROMOTOR.EMISOR:' || VR_PROMOTOR.EMISOR ||
' VR_PROMOTOR.CODIGO_CAPTADOR:' ||
VR_PROMOTOR.CODIGO_CAPTADOR);
RAISE_APPLICATION_ERROR(-20001,
'El Promotor no fue encontrado.. Emisor:' ||
VR_PROMOTOR.EMISOR || ' Promotor:' ||
VR_PROMOTOR.CODIGO_CAPTADOR);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_PROMOTOR. Error al buscar el Promotor.' ||
' VR_PROMOTOR.EMISOR:' || VR_PROMOTOR.EMISOR ||
' VR_PROMOTOR.CODIGO_CAPTADOR:' ||
VR_PROMOTOR.CODIGO_CAPTADOR);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar el Promotor. Emisor:' ||
VR_PROMOTOR.EMISOR || ' Promotor:' ||
VR_PROMOTOR.CODIGO_CAPTADOR);
END PR_GET_PROMOTOR;
PROCEDURE PR_GET_SUCURSAL AS
BEGIN
SELECT *
INTO VR_SUCURSAL
FROM DEBCREDPY.SUCURSALES_EMISORES A
WHERE A.EMISOR = VR_SUCURSAL.EMISOR
AND A.SUCURSAL_EMISOR = VR_SUCURSAL.SUCURSAL_EMISOR;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_SUCURSAL. Sucursal del Emisor no encontrado.' ||
' VR_SUCURSAL.EMISOR:' || VR_SUCURSAL.EMISOR ||
' VR_SUCURSAL.SUCURSAL_CUENTA:' ||
VR_SUCURSAL.SUCURSAL_EMISOR);
RAISE_APPLICATION_ERROR(-20001,
'La Sucursal del Emisor no fue encontrado.. Emisor:' ||
VR_SUCURSAL.EMISOR || ' Sucursal:' ||
VR_SUCURSAL.SUCURSAL_EMISOR);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_SUCURSAL. Error al buscar la Sucursal del Emisor.' ||
' VR_NOVEDAD_CUENTA.EMISOR_CUENTA:' || VR_SUCURSAL.EMISOR ||
' VR_NOVEDAD_CUENTA.SUCURSAL_CUENTA:' ||
VR_SUCURSAL.SUCURSAL_EMISOR);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar la Sucursal del Emisor. Emisor:' ||
VR_SUCURSAL.EMISOR || ' Sucursal:' ||
VR_SUCURSAL.SUCURSAL_EMISOR);
END PR_GET_SUCURSAL;
PROCEDURE PR_GET_EMISOR AS
BEGIN
SELECT *
INTO VR_EMISOR
FROM DEBCREDPY.EMISORES A
WHERE A.EMISOR = VR_EMISOR.EMISOR;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_EMISOR. Emisor de la Cuenta no encontrado.' ||
' VR_EMISOR.EMISOR:' || VR_EMISOR.EMISOR);
RAISE_APPLICATION_ERROR(-20001,
'El Emisor de la Cuenta no fue encontrado. Emisor:' ||
VR_EMISOR.EMISOR);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_EMISOR. Error al buscar el Emisor de la Cuenta.' ||
' VR_EMISOR.EMISOR:' || VR_EMISOR.EMISOR);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar el Emisor de la Cuenta. Emisor:' ||
VR_EMISOR.EMISOR);
END PR_GET_EMISOR;
PROCEDURE PR_GET_CIERRE_DIMO AS
BEGIN
SELECT CC.CIERRE
INTO VR_CUENTA.CIERRE
FROM CREDITOPY.CIERRES_HABILITADOS CC
WHERE CC.EMISOR = VR_AFINIDAD.EMISOR
AND CC.PRODUCTO = VR_AFINIDAD.PRODUCTO
AND CC.CLASE_TARJETA = 1
AND CC.GRUPO_AFINIDAD = VR_AFINIDAD.GRUPO_AFINIDAD;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CIERRE_DIMO. Cierre del Emisor de la Cuenta no encontrado.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' ||
VR_AFINIDAD.GRUPO_AFINIDAD);
RAISE_APPLICATION_ERROR(-20001,
'El Cierre del Emisor de la Cuenta no fue encontrado. Emisor:' ||
VR_AFINIDAD.EMISOR);
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CIERRE_DIMO. Error al buscar el Cierre del Emisor de la Cuenta.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' ||
VR_AFINIDAD.GRUPO_AFINIDAD);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar el Cierre del Emisor de la Cuenta. Emisor:' ||
VR_AFINIDAD.EMISOR);
END PR_GET_CIERRE_DIMO;
PROCEDURE PR_GET_EMISOR_PRODUCTO AS
BEGIN
SELECT *
INTO VR_EMISOR_PRODUCTO
FROM DEBCREDPY.EMISORES_PRODUCTOS A
WHERE A.EMISOR = VR_AFINIDAD.EMISOR
AND A.PRODUCTO = VR_AFINIDAD.PRODUCTO
AND A.GRUPO_AFINIDAD = VR_AFINIDAD.GRUPO_AFINIDAD
AND A.CARTERA = VR_CARTERA.CARTERA;
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_EMISOR_PRODUCTO.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.PRODUCTO:' || VR_AFINIDAD.PRODUCTO ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' || VR_AFINIDAD.GRUPO_AFINIDAD ||
' VR_CARTERA.CARTERA:' || VR_CARTERA.CARTERA);
EXCEPTION
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_EMISOR_PRODUCTO. Error al buscar el Emisor Producto de la Cuenta.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.PRODUCTO:' || VR_AFINIDAD.PRODUCTO ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' ||
VR_AFINIDAD.GRUPO_AFINIDAD || ' VR_CARTERA.CARTERA:' ||
VR_CARTERA.CARTERA);
END;
PROCEDURE PR_DATOS_CIERRES AS
BEGIN
VR_CALENDARIO_CIERRE.PERIODO := CREDITOPY.CEIBO_SOCIOS.GET_PERIODO_ACTUAL(VR_AFINIDAD.EMISOR,
VR_AFINIDAD.PRODUCTO,
VR_CUENTA.CIERRE);
SELECT *
INTO VR_CALENDARIO_CIERRE
FROM CREDITOPY.CALENDARIO_CIERRES A
WHERE A.EMISOR = VR_AFINIDAD.EMISOR
AND A.PRODUCTO = VR_AFINIDAD.PRODUCTO
AND A.CIERRE = VR_CUENTA.CIERRE
AND A.PERIODO = VR_CALENDARIO_CIERRE.PERIODO
AND A.GRUPO_AFINIDAD = VR_AFINIDAD.GRUPO_AFINIDAD;
EXCEPTION
WHEN OTHERS THEN
RAISE_APPLICATION_ERROR(-20001,
'PKG_DIMO_CEIBO.PR_DATOS_CIERRES. Error al buscar el Emisor Producto de la Cuenta.' ||
' VR_AFINIDAD.EMISOR:' || VR_AFINIDAD.EMISOR ||
' VR_AFINIDAD.PRODUCTO:' ||
VR_AFINIDAD.PRODUCTO ||
' VR_AFINIDAD.GRUPO_AFINIDAD:' ||
VR_AFINIDAD.GRUPO_AFINIDAD ||
' VR_CARTERA.CARTERA:' || VR_CARTERA.CARTERA);
END PR_DATOS_CIERRES;
PROCEDURE PR_SET_EMISOR_DIMO AS
BEGIN
BEGIN
SELECT EMISOR
INTO VR_EMISOR.EMISOR
FROM CREDITOPY.EMISORES_PREPAGO EP
WHERE TRIM(EP.MARCA) = CC_DIMO;
EXCEPTION
WHEN NO_DATA_FOUND THEN
VR_EMISOR.EMISOR := 999;
END;
VR_SUCURSAL.EMISOR := VR_EMISOR.EMISOR;
VR_SUCURSAL.SUCURSAL_EMISOR := 1;
VR_AFINIDAD.EMISOR := VR_EMISOR.EMISOR;
--VR_AFINIDAD.GRUPO_AFINIDAD := VR_EMISOR.EMISOR||'001';
VR_AFINIDAD.GRUPO_AFINIDAD := CASE
WHEN PV_GRUPO_AFINIDAD IS NULL THEN
VR_EMISOR.EMISOR || '001'
ELSE
PV_GRUPO_AFINIDAD
END;
VR_CARTERA.EMISOR := VR_EMISOR.EMISOR;
VR_CARTERA.CARTERA := 1;
VR_CORRESPONDENCIA.EMISOR := VR_EMISOR.EMISOR;
VR_CORRESPONDENCIA.CODIGO := CC_CORRESPONDENCIA_DIMO; --'D';
VR_PROMOTOR.EMISOR := VR_EMISOR.EMISOR;
--VR_PROMOTOR.CODIGO_CAPTADOR := CC_CAPTADOR_DIMO; --'91';
VR_PROMOTOR.CODIGO_CAPTADOR := PV_PROMOTOR_ID; -- ticket 0002049-Afinidad DIMO. AR. 27/05/2022 16:32:00 p.m.
--Limites en Cero para la Cuenta en Dimo.
VR_CUENTA.LIMITE_CREDITO := 0;
VR_CUENTA.LIMITE_FINANCIACION := 0;
END PR_SET_EMISOR_DIMO;
PROCEDURE PR_SET_PERSONA_DIMO AS
BEGIN
--Datos faltantes.
VR_PERSONA.ESTADO_CIVIL := VR_ESTADO_CIVIL.ESTADO_CIVIL;
VR_PERSONA.CODIGO_OCUPACION := VR_OCUPACION.CODIGO_OCUPACION;
VR_PERSONA.IPIN := 'ABCDEF0912345678';
VR_PERSONA.CODIGO_NACIONALIDAD := 0;
--Indicado
VR_PERSONA.ULT_ACTUALIZACION := SYSDATE;
VR_PERSONA.OPERADOR := CC_USUARIO_DIMO;
VR_PERSONA.TIPO_NOV := 'A';
END PR_SET_PERSONA_DIMO;
PROCEDURE PR_SET_DIRECCION_DIMO(RP_DIRECCION OUT DIRECCIONES%ROWTYPE) AS
BEGIN
RP_DIRECCION.EMISOR := VR_EMISOR.EMISOR;
RP_DIRECCION.SUCURSAL_EMISOR := VR_SUCURSAL.SUCURSAL_EMISOR;
RP_DIRECCION.PRODUCTO := 1;
RP_DIRECCION.NUMERO_CUENTA := 0;
RP_DIRECCION.TIPO_DE_DOCUMENTO := VR_PERSONA.TIPO_DE_DOCUMENTO;
RP_DIRECCION.DOCUMENTO := VR_PERSONA.DOCUMENTO;
--RP_DIRECCION.TIPO_DE_DIRECCION 1
RP_DIRECCION.PAIS := 1;
RP_DIRECCION.DEPARTAMENTO := 0;
RP_DIRECCION.CIUDAD := 1;
--RP_DIRECCION.CALLE CNEL PANCHITO LOPEZ C/ RUTA 1
RP_DIRECCION.TIENE_EXTENSION := 0;
RP_DIRECCION.NUMERO_PUERTA := 0;
RP_DIRECCION.APARTAMENTO := 0;
RP_DIRECCION.CODIGO_POSTAL := 0;
--RP_DIRECCION.TELEFONO NO DEFINIDO
--RP_DIRECCION.BARRIO
--RP_DIRECCION.ULT_ACTUALIZACION
RP_DIRECCION.OPERADOR := CC_USUARIO_DIMO;
RP_DIRECCION.TIPO_NOV := 'A';
END PR_SET_DIRECCION_DIMO;
PROCEDURE PR_HISTORICO_ALTA_DIMO AS
BEGIN
--Historico a nivel de Cuentas.
VR_HISTORICO.EMISOR := VR_EMISOR.EMISOR;
VR_HISTORICO.NOVNRO := FN_GET_NRO_NOVEDAD;
VR_HISTORICO.NUMERO_CUENTA := VR_HISTORICO.NOVNRO;
VR_CUENTA.FORMULARIO := VR_HISTORICO.NOVNRO;
VR_TARJETA.FORMULARIO := VR_HISTORICO.NOVNRO;
--Cada parrafo corresponde a un dato a auditar.
VR_HISTORICO.TABLA := 'NOVEDADES_CUENTAS';
--Agregamos el GRUPO de AFINIDAD.
VR_HISTORICO.CAMPO := 'GRUPO_AFINIDAD';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_AFINIDAD.GRUPO_AFINIDAD || CHR(32) ||
VR_AFINIDAD.DESCRIPCION;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la Calle.
VR_HISTORICO.CAMPO := 'CALLE';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_DIRECCION.CALLE;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la Ciudad.
VR_HISTORICO.CAMPO := 'CIUDAD';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_CIUDAD.DESCRIPCION;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la TELEFONO.
VR_HISTORICO.CAMPO := 'TELEFONO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_CELULAR.CALLE;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la PAGO_AUTOMATICO.
VR_HISTORICO.CAMPO := 'PAGO_AUTOMATICO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := 'Ventanilla';
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la CICLO_NUEVO.
VR_HISTORICO.CAMPO := 'CICLO_NUEVO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_CUENTA.CIERRE;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la LIMITE_CREDITO.
VR_HISTORICO.CAMPO := 'LIMITE_CREDITO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
--2DO--Manejar importes ...
VR_HISTORICO.DATO_POSTERIOR := TO_CHAR(VR_CUENTA.LIMITE_CREDITO,
'99G999G999');
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la LIMITE_FINANCIACION.
VR_HISTORICO.CAMPO := 'LIMITE_FINANCIACION';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := TO_CHAR(VR_CUENTA.LIMITE_FINANCIACION,
'99G999G999');
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la LIMITE_ADELANTO.
VR_HISTORICO.CAMPO := 'LIMITE_ADELANTO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := TO_CHAR(VR_CUENTA.LIMITE_CREDITO,
'99G999G999');
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la CANTIDAD_TARJETAS.
VR_HISTORICO.CAMPO := 'CANTIDAD_TARJETAS';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := 1;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la NOVCARTERA.
VR_HISTORICO.CAMPO := 'NOVCARTERA';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_CARTERA.DESCRIPCION;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos la CODIGO_CORRESPONDENCIA.
VR_HISTORICO.CAMPO := 'CODIGO_CORRESPONDENCIA';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_CORRESPONDENCIA.DESCRIPCION;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Agregamos EMISOR_CUENTA.
VR_HISTORICO.CAMPO := 'EMISOR_CUENTA';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_EMISOR.EMISOR || ' ' ||
VR_EMISOR.DESCRIPCION;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos SUCURSAL_CUENTA.
VR_HISTORICO.CAMPO := 'SUCURSAL_CUENTA';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_SUCURSAL.SUCURSAL_EMISOR || ' ' ||
VR_SUCURSAL.DESCRIPCION;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
-- VR_HISTORICO.TARJETA := VR_NOVEDAD_TARJETA.Novnro;
--Agregamos APELLIDOS.
VR_HISTORICO.TABLA := 'NOVEDADES_TARJETAS';
VR_HISTORICO.CAMPO := 'CALLE';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_DIRECCION.CALLE;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos NOMBRES.
VR_HISTORICO.CAMPO := 'NOMBRES';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_PERSONA.NOMBRES;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos FECHA_NACIMIENTO.
VR_HISTORICO.CAMPO := 'FECHA_NACIMIENTO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := TO_CHAR(VR_PERSONA.FECHA_NACIMIENTO,
'DD/MM/YYYY');
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos SEXO.
VR_HISTORICO.CAMPO := 'SEXO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_SEXO.DESCRIPCION;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos ESTADO_CIVIL.
VR_HISTORICO.CAMPO := 'ESTADO_CIVIL';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_ESTADO_CIVIL.DESCRIPCION;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos CODIGO_OCUPACION.
VR_HISTORICO.CAMPO := 'CODIGO_OCUPACION';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_OCUPACION.DESCRIPCION;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos TIPO_DE_DOCUMENTO.
VR_HISTORICO.CAMPO := 'TIPO_DE_DOCUMENTO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := 'Cedula de identidad';
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos DOCUMENTO.
VR_HISTORICO.CAMPO := 'DOCUMENTO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 3-1-1-1.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
/*VR_HISTORICO.DATO_POSTERIOR := TO_NUMBER(SUBSTR(VR_PERSONA.DOCUMENTO,
4,
12));*/
VR_HISTORICO.DATO_POSTERIOR := SUBSTR(VR_PERSONA.DOCUMENTO,
4,
12);
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 3-1-1-2.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos NOMBRE_PLASTICO.
VR_HISTORICO.CAMPO := 'NOMBRE_PLASTICO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_TARJETA.NOMBRE_PARA_PLASTICO;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
--Agregamos NOVPROM.
--VR_HISTORICO.CAMPO := 'NOVPROM';
--VR_HISTORICO.DATO_ANTERIOR := ' ';
--VR_HISTORICO.DATO_POSTERIOR := VR_PROMOTOR.DESCRIPCION||'('||VN_VENDEDOR||')';
--Agregamos a la tabla de historicos.
--VR_HISTORICOS((VR_HISTORICOS.COUNT+1)) := VR_HISTORICO;
PR_REGISTRAR_HISTORICO;
END PR_HISTORICO_ALTA_DIMO;
PROCEDURE PR_SET_CUENTA_DIMO AS
BEGIN
--Seteamos los campos de cuentas.
VR_CUENTA.EMISOR := VR_EMISOR.EMISOR;
VR_CUENTA.SUCURSAL_EMISOR := VR_SUCURSAL.SUCURSAL_EMISOR;
VR_CUENTA.PRODUCTO := VR_AFINIDAD.PRODUCTO;
VR_CUENTA.NUMERO_CUENTA := 0;
VR_CUENTA.TIPO_DE_DOCUMENTO := VR_PERSONA.TIPO_DE_DOCUMENTO;
VR_CUENTA.DOCUMENTO := VR_PERSONA.DOCUMENTO;
VR_CUENTA.GRUPO_AFINIDAD := VR_AFINIDAD.GRUPO_AFINIDAD;
VR_CUENTA.CARTERA := VR_CARTERA.CARTERA;
--Siempre sin Descuenta cuota y no tiene UL. Parametros 54 y 55
VR_CUENTA.NUMERO_EMPRESA := 0;
VR_CUENTA.ESTADO := 1;
VR_CUENTA.CLASE_DE_ESTADO := 1;
--Se asigna la fecha de Proceso
VR_CUENTA.FECHA_ESTADO := PV_FEC_REG_ALTA;
--VR_CUENTA.FECHA_ESTADO := TO_DATE(TO_CHAR(VR_CUENTA.FECHA_ESTADO,'DDMMYYYY')||TO_CHAR(VR_NOV_CUENTA.NOVFCHING,'HH24MISS'),'DDMMYYYYHH24MISS');
/*SE FIJA EL VALOR 3 EN EL CAMPO ENVIAR_RESUMEN PARA IDENTIFICAR
LA CUENTA EN GESTION DE REFINANCIACION DE SALDO.-
Se comenta a Sol. de Arya Baher ( 07/11/05 )
En base al comentario del cobol y lo conversado con Amalia, se asume que siempre es 1.
*/
VR_CUENTA.ENVIAR_RESUMEN := 1;
VR_CUENTA.TIPO_MONEDA_CREDITO := 1;
/*Si es 1, Se paga automaticamente el PM.
Si es 2, el total del resumen.
Ver PAGOS_AUTOMATICOS.
*/
VR_CUENTA.PAGO_AUTOMATICO := 2;
VR_CUENTA.PORC_DEBITO := 0;
VR_CUENTA.PORC_LIMITE_EFECTIVO := 0;
VR_CUENTA.PORC_GASTOS_ADM := 0;
VR_CUENTA.BONIFICACION_TASAS := 0;
--DURACION_TARJETA de debcredpy.EMISORES_PRODUCTOS
VR_CUENTA.CODIGO_DE_VINCULO := VR_EMISOR_PRODUCTO.DURACION_TARJETA;
--Pendiente. Se ve por defecto
VR_CUENTA.CODIGO_DE_ESTADO_FIN := 1;
VR_CUENTA.CODIGO_DE_GARANTIA := 0;
VR_CUENTA.FECHA_NO_RENOVACION := NULL;
VR_CUENTA.PUBLICA_NO_RENOVACION := 0;
VR_CUENTA.AUTOMATICO_A_BOLETIN := 0;
VR_CUENTA.NUMERO_SOCIO_LEGAJO := 0;
VR_CUENTA.PERIODO_CIERRE_DEBE := VR_CALENDARIO_CIERRE.PERIODO;
VR_CUENTA.PERIODO_CIERRE_PM := VR_CALENDARIO_CIERRE.PERIODO;
VR_CUENTA.RESERVAS_ML := 0;
VR_CUENTA.RESERVAS_MR := 0;
VR_CUENTA.RESERVAS_EFECTIVO_ML := 0;
VR_CUENTA.RESERVAS_EFECTIVO_MR := 0;
VR_CUENTA.RESERVAS_PLANES_ML := 0;
VR_CUENTA.RESERVAS_PLANES_MR := 0;
VR_CUENTA.SALDO_CIERRE_ML := 0;
VR_CUENTA.SALDO_CIERRE_MR := 0;
VR_CUENTA.EFECTIVO_ML := 0;
VR_CUENTA.EFECTIVO_MR := 0;
VR_CUENTA.COMPRAS_ML := 0;
VR_CUENTA.COMPRAS_MR := 0;
VR_CUENTA.PAGOS_ML := 0;
VR_CUENTA.PAGOS_MR := 0;
VR_CUENTA.RESERVAS_AGROCABAL_ML := 0;
VR_CUENTA.RESERVAS_AGROCABAL_MR := 0;
VR_CUENTA.COMPRAS_AGROCABAL_ML := 0;
VR_CUENTA.COMPRAS_AGROCABAL_MR := 0;
VR_CUENTA.FECHA_FORMULARIO := VR_HISTORICO.NOVFCHING;
VR_CUENTA.NRO_CONTRI_IMPOSITIVA := 0; --CASE NVL(VR_NOV_CUENTA.RUC,' ') WHEN ' ' THEN 0 ELSE VR_NOV_CUENTA.RUC END;
VR_CUENTA.CODIGO_COSTO := 0;
VR_CUENTA.UNA_CUOTA := 0;
VR_CUENTA.TOTAL_CUOTAS := 0;
--Siempre 0 en el alta.
VR_CUENTA.ORIGEN_ANULACION := 0;
VR_CUENTA.AJUSTES_DB_ML := 0;
VR_CUENTA.AJUSTES_DB_MR := 0;
VR_CUENTA.AJUSTES_CR_ML := 0;
VR_CUENTA.AJUSTES_CR_MR := 0;
VR_CUENTA.FECHA_ULTIMO_PAGO := NULL;
/*TIPO_DE_CUENTA_EMISOR Solo es 1 o 2.
1 Cta Cte
2 Caja de Ahorro
*/
VR_CUENTA.TIPO_DE_CUENTA_EMISOR := 0; --NVL(VR_NOV_CUENTA.TIPO_CUENTA,0);
/* 1 si TIPO_DE_CUENTA_EMISOR 1 o 2, sino 2 */
VR_CUENTA.TIPO_MONEDA_CTA_EMISOR := CASE VR_CUENTA.TIPO_DE_CUENTA_EMISOR
WHEN 1 THEN
1
WHEN 2 THEN
1
ELSE
2
END;
VR_CUENTA.NUMERO_CUENTA_EMISOR := 0; --NVL(VR_NOV_CUENTA.NUMERO_CUENTA_DEB,0);
-- Se asigna la fecha de Proceso.
VR_CUENTA.FECHA_DE_ALTA := TRUNC(PV_FEC_REG_ALTA);
VR_CUENTA.TIENE_VINCULO := 0;
VR_CUENTA.CTADISCNJ := 0;
VR_CUENTA.NUMERO_USUARIO_PY := 0;
--no vigente, usado de creditopy.TIPO_PLASTICO */
VR_CUENTA.CLASE_TARJETA_PY := FC_GET_TIPO_PLASTICO;
VR_CUENTA.ENCARGADO_DE_CUENTA := 0;
--VR_CUENTA.CODIGO_CAPTADOR := CC_CAPTADOR_DIMO; --'91';
VR_CUENTA.CODIGO_CAPTADOR := PV_PROMOTOR_ID; -- ticket 0002049-Afinidad DIMO. AR. 02/03/2022 10:32:00 a.m.
VR_CUENTA.INCREMENTO_LIMITE_CREDITO := 0;
VR_CUENTA.CODIGO_DE_CORRESPONDENCIA := VR_CORRESPONDENCIA.CODIGO;
VR_CUENTA.FACTOR_DE_INCREMENTO := 0;
VR_CUENTA.SOBRECUPO := 0;
VR_CUENTA.SALDO_A_FACTURAR := 0;
VR_CUENTA.SALDO_FACTURADO_NO_VENCIDO := 0;
VR_CUENTA.SALDO_FINANCIADO := 0;
VR_CUENTA.SALDO_EN_MORA := 0;
VR_CUENTA.DIAS_EN_MORA := 0;
VR_CUENTA.FECHA_VTO_INC_LIMITE := NULL;
VR_CUENTA.DISPONIBLE_SOBRECUPO := 0;
VR_CUENTA.PORCENTAJE_SOBRECUPO := 0;
VR_CUENTA.ULT_ACTUALIZACION := SYSDATE;
VR_CUENTA.OPERADOR := CC_USUARIO_DIMO;
VR_CUENTA.TIPO_NOV := 'A';
END;
PROCEDURE PR_SET_TARJETA_DIMO AS
BEGIN
--FECHA-COSTO. Caso 1) para altas de cuenta/tarjeta(tarjetas nuevas en el sistema).
VR_TARJETA.FECHA_ESTADO := PV_FEC_REG_ALTA;
VR_TARJETA.FECHA_OTORGADA := TRUNC(PV_FEC_REG_ALTA);
PR_SET_FECHA_COSTO_ALTA;
VR_TARJETA.ORIGEN_ANULACION := 0;
VR_TARJETA.EMISOR := VR_CUENTA.EMISOR;
VR_TARJETA.SUCURSAL_EMISOR := VR_CUENTA.SUCURSAL_EMISOR;
VR_TARJETA.PRODUCTO := VR_CUENTA.PRODUCTO;
VR_TARJETA.GRUPO_AFINIDAD := VR_CUENTA.GRUPO_AFINIDAD;
VR_TARJETA.NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
VR_TARJETA.TIPO_DE_DOCUMENTO := VR_PERSONA.TIPO_DE_DOCUMENTO;
VR_TARJETA.DOCUMENTO := VR_PERSONA.DOCUMENTO;
VR_TARJETA.ADICIONAL := FN_GET_NEXT_ADICIONAL(VR_TARJETA.NUMERO_CUENTA);
--VR_TARJETA.ESTADO := 1;
VR_TARJETA.ESTADO := PV_ESTADO_TJ_ALTA; --ticket 0002049-Afinidad DIMO. AR. 01/06/2022 18:38:00 p.m.
VR_TARJETA.CLASE_DE_ESTADO := 1;
-- Se adiciona la DURACION_TARJETA al mes de FECHA_HOY, y se lleva al lastday del mes/a?o obtenido
--VR_TARJETA.FECHA_VIGENCIA := TRUNC(FD_GET_NEW_VIGENCIA);
VR_TARJETA.FECHA_VIGENCIA := fn_get_vigencia_tp_virtual(VR_TARJETA.EMISOR,
VR_TARJETA.PRODUCTO,
VR_TARJETA.GRUPO_AFINIDAD,
VR_CUENTA.CARTERA,
VR_TARJETA.FECHA_OTORGADA);
VR_TARJETA.CODIGO_COSTO := 0;
VR_TARJETA.TIPO_MONEDA_COSTO := 1;
/* Se comenta. El campo Tarjetas.costo solo tiene 5 enteros y dos decimales
mientras que el costo ya alcanza los 6 digitos.
Este dato tampoco se utiliza mas. ER,AR 201511182322*/
VR_TARJETA.COSTO := 0;
--COD-PARA-COBRAR(=1)
VR_TARJETA.ESTADO_DE_COSTO := 1;
VR_TARJETA.PIN := 'ABCDEF0987654321';
VR_TARJETA.OFFSET := 0;
VR_TARJETA.FECHA_FORMULARIO := VR_HISTORICO.NOVFCHING;
VR_TARJETA.COMPONENTE := 1;
VR_TARJETA.CODIGO_CAPTADOR := VR_CUENTA.CODIGO_CAPTADOR;
--Pendiente.
VR_TARJETA.PROCESO_URGENTE := ' ';
VR_TARJETA.NO_RENOVACION := ' ';
VR_TARJETA.ULT_ACTUALIZACION := VR_HISTORICO.NOVFCHING;
VR_TARJETA.OPERADOR := VR_HISTORICO.USUARIO;
VR_TARJETA.TIPO_NOV := 'A';
END;
PROCEDURE PR_UPD_JOB_NOMBRE(NI_JOBTYPE IN INTEGER DEFAULT NULL,
CP_JOB_NAME IN VARCHAR2 DEFAULT NULL)
/*Por defecto es de tarjetas.*/
AS
VC_JOB_NAME VARCHAR2(10);
BEGIN
IF CP_JOB_NAME IS NOT NULL THEN
VC_JOB_NAME := CP_JOB_NAME;
ELSE
VC_JOB_NAME := PV_JOB_NOMBRE;
END IF;
IF NI_JOBTYPE IS NOT NULL AND NI_JOBTYPE = 1 THEN
UPDATE CREDITOPY.FECHAS_ESTADO_CTAS A
SET A.JOB_NOMBRE = VC_JOB_NAME,
A.JOB_USUARIO = VR_HISTORICO.USUARIO
WHERE A.EMISOR = VR_TARJETA.EMISOR
AND A.SUCURSAL_EMISOR = VR_TARJETA.SUCURSAL_EMISOR
AND A.PRODUCTO = VR_TARJETA.PRODUCTO
AND A.NUMERO_CUENTA = VR_TARJETA.NUMERO_CUENTA;
ELSE
UPDATE CREDITOPY.FECHAS_ESTADO_TARJ A
SET A.JOB_NOMBRE = VC_JOB_NAME,
A.JOB_USUARIO = VR_HISTORICO.USUARIO
WHERE A.EMISOR = VR_TARJETA.EMISOR
AND A.SUCURSAL_EMISOR = VR_TARJETA.SUCURSAL_EMISOR
AND A.PRODUCTO = VR_TARJETA.PRODUCTO
AND A.NUMERO_CUENTA = VR_TARJETA.NUMERO_CUENTA
AND A.ADICIONAL = VR_TARJETA.ADICIONAL;
END IF;
PR_LOGGING('WS',
'01',
'JOB_NOMBRE ' || VC_JOB_NAME || '< JOB_USUARIO>' ||
VR_HISTORICO.USUARIO);
EXCEPTION
WHEN OTHERS THEN
PR_LOGGING('WS',
'01',
'PR_UPD_JOB_NOMBRE.JOB_NOMBRE ' || VC_JOB_NAME ||
'< JOB_USUARIO>' || VR_HISTORICO.USUARIO ||
FC_GET_ID_NOVEDAD || SQLERRM);
--No se realiza el raise por que ya esta registrado, solo no se aplico el nombre del proceso.
END PR_UPD_JOB_NOMBRE;
PROCEDURE PR_SET_NUMERO_CUENTA AS
PRAGMA AUTONOMOUS_TRANSACTION;
VN_NUMERO_CUENTA CUENTAS.NUMERO_CUENTA%TYPE;
VI_EXISTE BINARY_INTEGER;
BEGIN
LOOP
--Actualizamos el secuencial del emisor.
UPDATE CREDITOPY.EMISOR_NROCTA_TARJ A
SET A.NUMERO_CUENTA = A.NUMERO_CUENTA + 1
WHERE A.EMISOR = VR_EMISOR.EMISOR;
--Recuperamos el secuencial del emisor.
SELECT A.NUMERO_CUENTA
INTO VN_NUMERO_CUENTA
FROM CREDITOPY.EMISOR_NROCTA_TARJ A
WHERE A.EMISOR = VR_EMISOR.EMISOR;
/*#Ojo. AR pide que se tomen los 9 digitos para Probar.
VN_NUMERO_CUENTA := SUBSTR(VN_NUMERO_CUENTA,-6);
VN_NUMERO_CUENTA := VR_EMISOR.EMISOR||'000'||LPAD(VN_NUMERO_CUENTA,6,0);
*/
VN_NUMERO_CUENTA := SUBSTR(VN_NUMERO_CUENTA, -9);
VN_NUMERO_CUENTA := VR_EMISOR.EMISOR || LPAD(VN_NUMERO_CUENTA, 9, 0);
VN_NUMERO_CUENTA := VN_NUMERO_CUENTA ||
FN_GET_COBOL_CUENTA_DV(VN_NUMERO_CUENTA);
SELECT NVL(MAX(1), 0)
INTO VI_EXISTE
FROM CREDITOPY.CUENTAS A
WHERE A.NUMERO_CUENTA = VN_NUMERO_CUENTA;
EXIT WHEN VI_EXISTE = 0;
END LOOP;
VR_CUENTA.NUMERO_CUENTA := VN_NUMERO_CUENTA;
PR_LOGGING('WS',
'01',
'PKG_DIMO_CEIBO.PR_SET_NUMERO_CUENTA VR_CUENTA.NUMERO_CUENTA:' ||
VR_CUENTA.NUMERO_CUENTA);
COMMIT;
EXCEPTION
WHEN NO_DATA_FOUND THEN
ROLLBACK;
RAISE_APPLICATION_ERROR(-20001,
FC_GET_ID_NOVEDAD ||
'PKG_DIMO_CEIBO.PR_SET_NUMERO_CUENTA Error: El Emisor ' ||
VR_EMISOR.EMISOR ||
'< no tiene un secuencial registrado.');
WHEN OTHERS THEN
ROLLBACK;
RAISE_APPLICATION_ERROR(-20001,
FC_GET_ID_NOVEDAD ||
'PKG_DIMO_CEIBO.PR_SET_NUMERO_CUENTA Emisor ' ||
VR_EMISOR.EMISOR || ' Error:' || SQLERRM);
END;
PROCEDURE PR_LIMITES_DIMO AS
BEGIN
VR_LIMITES.EMISOR := VR_CUENTA.EMISOR;
VR_LIMITES.NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
VR_LIMITES.LIMITE := 0;
VR_LIMITES.PLAN_VENTA := 1;
INSERT INTO LIMITES_CUENTAS@OLPY VALUES VR_LIMITES;
VR_LIMITES.PLAN_VENTA := 3;
INSERT INTO LIMITES_CUENTAS@OLPY VALUES VR_LIMITES;
VR_LIMITES.PLAN_VENTA := 4;
INSERT INTO LIMITES_CUENTAS@OLPY VALUES VR_LIMITES;
END;
PROCEDURE PR_SALDO_CUENTA AS
VR_ULTIMO_CIERRE CALENDARIO_CIERRES%ROWTYPE;
BEGIN
VR_ULTIMO_CIERRE := FR_ULT_PERIODO_CERRADO;
VR_SALDO_CUENTA.EMISOR := VR_CUENTA.EMISOR;
VR_SALDO_CUENTA.SUCURSAL_EMISOR := VR_CUENTA.SUCURSAL_EMISOR;
VR_SALDO_CUENTA.PRODUCTO := VR_CUENTA.PRODUCTO;
VR_SALDO_CUENTA.NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
VR_SALDO_CUENTA.PERIODO_CIERRE := VR_ULTIMO_CIERRE.PERIODO;
VR_SALDO_CUENTA.FECHA_CIERRE := VR_ULTIMO_CIERRE.FECHA_CIERRE;
VR_SALDO_CUENTA.FECHA_VENCIMIENTO := VR_ULTIMO_CIERRE.FECHA_VENCIMIENTO;
VR_SALDO_CUENTA.PAGO_MINIMO_ML := 0;
VR_SALDO_CUENTA.PAGO_MINIMO_MR := 0;
VR_SALDO_CUENTA.PAGO_CONTADO_ML := 0;
VR_SALDO_CUENTA.PAGO_CONTADO_MR := 0;
VR_SALDO_CUENTA.SALDO_CAPITAL_ML := 0;
VR_SALDO_CUENTA.SALDO_CAPITAL_MR := 0;
VR_SALDO_CUENTA.TOTAL_PAGOS_ML := 0;
VR_SALDO_CUENTA.TOTAL_PAGOS_MR := 0;
VR_SALDO_CUENTA.TOTAL_COMPRAS_ML := 0;
VR_SALDO_CUENTA.TOTAL_COMPRAS_MR := 0;
VR_SALDO_CUENTA.FECHA_COMPRA_ML := NULL;
VR_SALDO_CUENTA.FECHA_COMPRA_MR := NULL;
VR_SALDO_CUENTA.ULT_ACTUALIZACION := VR_HISTORICO.NOVFCHING;
VR_SALDO_CUENTA.OPERADOR := VR_HISTORICO.USUARIO;
VR_SALDO_CUENTA.TIPO_NOV := 'A';
INSERT INTO CREDITOPY.SALDOS_CUENTAS@BAPY VALUES VR_SALDO_CUENTA;
EXCEPTION
WHEN OTHERS THEN
RAISE_APPLICATION_ERROR(-20001,
FC_GET_ID_NOVEDAD || ' Error:' || SQLERRM);
END PR_SALDO_CUENTA;
PROCEDURE PR_CARGOS_EMISION AS
VN_RETORNO NUMBER;
VC_GLOSA VARCHAR2(512);
BEGIN
CEIBO_SOCIOS.PR_GENERAR_CARGO@BAPY(805,
VR_TARJETA.NUMERO_CUENTA,
VR_TARJETA.TARJETA,
VR_HISTORICO.NOVTIP,
63, --COD_PRM,
VR_CUENTA.FECHA_ESTADO,
VR_HISTORICO.USUARIO,
VN_RETORNO, -- out
VC_GLOSA);
PR_LOGGING('DIMO',
'CARGO',
'PROCESADOR>805< NUMERO_CUENTA>' || VR_TARJETA.NUMERO_CUENTA ||
'< TARJETA>' || VR_TARJETA.TARJETA || '< NOVTIP>' ||
VR_HISTORICO.NOVTIP || '< COD_PRM>63< FECHA_PROCESO>' ||
FC_GET_FECHA_LARGA(VR_CUENTA.FECHA_ESTADO) || '< USUARIO>' ||
VR_HISTORICO.USUARIO || '< RETORNO>' || VN_RETORNO ||
'< GLOSA>' || VC_GLOSA || '<');
-- SIEMPRE RETORNA UN VALOR. LAS EXCEPCIONES NO SON ARROJADAS AL SELECT QUE LO INVOCA. Comentario del sp de Amalia.
IF VN_RETORNO != 0 THEN
PR_LOGGING('DIMO',
'CARGO',
FC_GET_ID_NOVEDAD || '< VN_RETORNO>' || VN_RETORNO ||
'<< VC_GLOSA>' || VC_GLOSA || '<<');
END IF;
EXCEPTION
WHEN OTHERS THEN
PR_LOGGING('DIMO', 'CARGO', FC_GET_ID_NOVEDAD || SQLERRM);
--No se realiza el raise por que se definio que el fallo de parametros no debe interrumpir el altaOL. RA,ER
END PR_CARGOS_EMISION;
PROCEDURE PR_ALTA_PERSONA AS
vb_existe_persona NUMBER;
BEGIN
BEGIN
SELECT 1
INTO vb_existe_persona
FROM DEBCREDPY.PERSONAS p
WHERE P.TIPO_DE_DOCUMENTO = VR_PERSONA.TIPO_DE_DOCUMENTO
AND P.DOCUMENTO = VR_PERSONA.DOCUMENTO;
EXCEPTION
WHEN no_data_found THEN
INSERT INTO DEBCREDPY.PERSONAS VALUES VR_PERSONA;
WHEN OTHERS THEN
RAISE;
END;
EXCEPTION
WHEN OTHERS THEN
PR_LOGGING('DIMO',
'CARGO',
'ALTA_PERSONA DOCUMENTO:' || VR_PERSONA.DOCUMENTO ||
' Error:' || SQLERRM);
END PR_ALTA_PERSONA;
PROCEDURE PR_SOLICITUDES(RT_SOLICITUD IN OUT SOLICITUDES_RECIBIDAS%ROWTYPE,
RT_SOLICITUD_DATOS IN OUT SOLICITUDES_DATOS%ROWTYPE)
/*A.Rodriguez. Version llevada al PKG_DIMO_CEIBO al 15/06/2020. */
/*
Autor: Edgar Rojas.
Fecha: 10/06/2020
Proposito: Registrar y validar todas las solicitudes de acuerdo al tipo de cada una.
Las solicitudes rechazadas igual deben ser registradas. Para ello en ciertos
casos, si se deben a motivos de integridad referencial, se asignaran datos
para poder registrarse.
Los diferentes motivos de rechazos tambien deben ser registrados.
Solicitudes manejadas estan registradas en la tabla SOLICITUDES:
--------------------------------------------------------------------------------------
ID_SOLICITUD CODIGO_SOLICITUD SOLICITUD
--------------------------------------------------------------------------------------
1 9,10 Pedido Plastico DIMO
2 21,10 Aviso de Viaje DIMO
3 22,00 Reposición de Tarjeta DIMO
4 25,00 Aviso de Viaje Tarjeta de Crédito
5 26,00 Reimpresion de Tarjeta de Crédito
6 29,00 Pedido de Adicional para Tarjeta de Crédito.
7 31,00 Aumento de Línea para Tarjeta de Crédito.
8 33,00 Pedido de Cambio de Ciclo para Tarjeta de Crédito.
*/
AS
PRAGMA AUTONOMOUS_TRANSACTION;
VR_TIPO SOLICITUDES%ROWTYPE;
VR_SOLICITUD SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS SOLICITUDES_DATOS%ROWTYPE;
VR_MOTIVO SM.T_REGLA;
VR_MOTIVOS SM.T_MOTIVOS;
VR_RECHAZO SOLICITUDES_MOTIVOS_RECHAZOS%ROWTYPE;
VR_TARJETA TARJETAS%ROWTYPE;
BEGIN
DELETE SOLICITUD_RECIBIDA_TMP;
DELETE SOLICITUD_DATO_TMP;
DELETE SOLICITUD_MOTIVO_RECHAZO_TMP;
VR_SOLICITUD := RT_SOLICITUD;
VR_DATOS := RT_SOLICITUD_DATOS;
VR_SOLICITUD.FECHA_ESTADO := SYSDATE;
VR_SOLICITUD.FECHA_REGISTRO := SYSDATE;
--Encriptamos la tarjeta para registrar.
VR_SOLICITUD.TARJETA := fc_pan2cripto(VR_SOLICITUD.TARJETA);
--Obtenemos el dato del emisor.
BEGIN
SELECT *
INTO VR_TARJETA
FROM CREDITOPY.TARJETAS T
WHERE T.TARJETA = VR_SOLICITUD.TARJETA;
VR_SOLICITUD.EMISOR := VR_TARJETA.EMISOR;
EXCEPTION
WHEN OTHERS THEN
VR_SOLICITUD.EMISOR := 0;
END;
--Obtenemos el Id para las Solicitudes.
SELECT SEQ_SOLICITUDES.NEXTVAL
INTO VR_SOLICITUD.ID_SOLICITUD_RECIBIDA
FROM DUAL;
SELECT SEQ_SS_DATOS.NEXTVAL INTO VR_DATOS.ID_SOLICITUD_DATO FROM DUAL;
VR_DATOS.ID_SOLICITUD_RECIBIDA := VR_SOLICITUD.ID_SOLICITUD_RECIBIDA;
--Obtenemos el Tipo de Solicitud a evaluar.
BEGIN
SELECT *
INTO VR_TIPO
FROM CREDITOPY.SOLICITUDES S
WHERE S.ID_SOLICITUD = VR_SOLICITUD.ID_SOLICITUD;
EXCEPTION
WHEN OTHERS THEN
SELECT *
INTO VR_TIPO
FROM CREDITOPY.SOLICITUDES S
WHERE S.ID_SOLICITUD = 0;
END;
--Registramos en las tablas temporales.
INSERT INTO TARJETA_TMP VALUES VR_TARJETA;
INSERT INTO SOLICITUD_RECIBIDA_TMP VALUES VR_SOLICITUD;
INSERT INTO SOLICITUD_DATO_TMP VALUES VR_DATOS;
--Aplicamos las reglas de evaluacion.
SM.PR_SET_EVALUACION_COMPLETA;
--Validar la Novedad
SM.PR_VALIDAR_NOVEDAD(VR_TIPO.TIPO_NOVEDAD,
VR_NOVEDAD_CUENTA.NOVNRO,
VR_NOVEDAD_CUENTA.NOVFCHING,
VR_SOLICITUD.USUARIO,
VR_SOLICITUD.EMISOR);
VR_MOTIVOS := SM.FT_GET_MOTIVOS;
--Si tenemos rechazos, aplicamos las adaptaciones.
IF VR_MOTIVOS.COUNT > 0 THEN
--Registramos los motivos de rechazos.
FOR X IN 1 .. VR_MOTIVOS.COUNT LOOP
SELECT SEQ_SS_MM_RECHAZOS.NEXTVAL
INTO VR_RECHAZO.ID_MOTIVO_RECHAZO
FROM DUAL;
VR_RECHAZO.ID_SOLICITUD_RECIBIDA := VR_SOLICITUD.ID_SOLICITUD_RECIBIDA;
VR_RECHAZO.REGLA_ID := VR_MOTIVOS(X).REGLA_ID;
VR_RECHAZO.MOTIVO_RECHAZO := VR_MOTIVOS(X).MENSAJE;
INSERT INTO SOLICITUD_MOTIVO_RECHAZO_TMP VALUES VR_RECHAZO;
--Registramos en la Tabla Temporal de rechazos
END LOOP;
--Aplicar las correcciones.
FOR R IN (SELECT A.REGLA_ID, A.CORRECCION
FROM CREDITOPY.SOLICITUDES_CORRECCIONES A,
CREDITOPY.SOLICITUD_MOTIVO_RECHAZO_TMP B,
CREDITOPY.SOLICITUD_RECIBIDA_TMP C
WHERE C.ID_SOLICITUD_RECIBIDA = B.ID_SOLICITUD_RECIBIDA
AND A.ID_SOLICITUD = C.ID_SOLICITUD
AND A.REGLA_ID = B.REGLA_ID) LOOP
EXECUTE IMMEDIATE R.CORRECCION;
END LOOP;
--Tomamos los datos corregidos.
SELECT * INTO VR_SOLICITUD FROM CREDITOPY.SOLICITUD_RECIBIDA_TMP;
SELECT * INTO VR_DATOS FROM CREDITOPY.SOLICITUD_DATO_TMP;
ELSE
VR_RECHAZO.REGLA_ID := 0;
END IF;
VR_SOLICITUD.CODIGO_RESPUESTA := VR_RECHAZO.REGLA_ID;
--Registramos la Solicitud.
INSERT INTO SOLICITUDES_RECIBIDAS VALUES VR_SOLICITUD;
INSERT INTO SOLICITUDES_DATOS VALUES VR_DATOS;
--Registramos los motivos de rechazos
INSERT INTO SOLICITUDES_MOTIVOS_RECHAZOS
SELECT * FROM CREDITOPY.SOLICITUD_MOTIVO_RECHAZO_TMP;
RT_SOLICITUD := VR_SOLICITUD;
RT_SOLICITUD_DATOS := VR_DATOS;
COMMIT;
END;
PROCEDURE PR_ADM_ERROR_SOLICITUD(NP_ID_SOLICITUD_RECIBIDA IN SOLICITUDES_MOTIVOS_RECHAZOS.ID_SOLICITUD_RECIBIDA%TYPE,
NP_ID_ESTADO IN SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE,
NP_REGLA_ID IN SOLICITUDES_MOTIVOS_RECHAZOS.REGLA_ID%TYPE,
CP_MOTIVO_RECHAZO IN SOLICITUDES_MOTIVOS_RECHAZOS.MOTIVO_RECHAZO%TYPE) AS
PRAGMA AUTONOMOUS_TRANSACTION;
VR_RECHAZO SOLICITUDES_MOTIVOS_RECHAZOS%ROWTYPE;
BEGIN
--Marcamos la Solicitud Recibida con su respectivo Estado de Rechazo.
UPDATE SOLICITUDES_RECIBIDAS SR
SET SR.ID_ESTADO = NP_ID_ESTADO, SR.CODIGO_RESPUESTA = NP_REGLA_ID
WHERE SR.ID_SOLICITUD_RECIBIDA = NP_ID_SOLICITUD_RECIBIDA;
SELECT SEQ_SS_MM_RECHAZOS.NEXTVAL
INTO VR_RECHAZO.ID_MOTIVO_RECHAZO
FROM DUAL;
VR_RECHAZO.ID_SOLICITUD_RECIBIDA := NP_ID_SOLICITUD_RECIBIDA;
VR_RECHAZO.REGLA_ID := NP_REGLA_ID;
VR_RECHAZO.MOTIVO_RECHAZO := CP_MOTIVO_RECHAZO;
INSERT INTO SOLICITUDES_MOTIVOS_RECHAZOS VALUES VR_RECHAZO;
COMMIT;
END PR_ADM_ERROR_SOLICITUD;
PROCEDURE PR_CEIBO_LOG(CP_TIPO_DATO IN VARCHAR2,
CP_TD_REGISTRO IN VARCHAR2,
CP_DESCRIPCION IN CLOB,
DP_FECHA_REGISTRO IN DATE,
CP_USUARIO IN VARCHAR2) AS
PRAGMA AUTONOMOUS_TRANSACTION;
/*
Procedimiento para registrar logs de ejecucion en creditopy.CEIBO_LOG
24/10/2007 17:42:08 - Amalia R.
Procedimiento adaptado por ER para registro de novedades en linea.
Necesario para el reporte de novedades. 081120111152.
*/
VI_PARSE BINARY_INTEGER;
PROCEDURE PL_SET_SECUENCIA AS
BEGIN
SELECT SEQ_CEIBO_LOG.NEXTVAL INTO VR_LOG.TD_SECUENCIA FROM DUAL;
EXCEPTION
WHEN OTHERS THEN
VR_LOG.TD_SECUENCIA := 0;
END PL_SET_SECUENCIA;
PROCEDURE PL_EXCEPCION AS
BEGIN
INSERT INTO CREDITOPY.CEIBO_LOG
(TIPO_DATO,
TD_REGISTRO,
TD_SECUENCIA,
DESCRIPCION,
FECHA,
USUARIO,
BITACORA_ID)
VALUES
('999',
'999',
VR_LOG.TD_SECUENCIA,
VR_LOG.DESCRIPCION,
VR_LOG.FECHA,
VR_LOG.USUARIO,
PV_BITACORA_ID);
EXCEPTION
WHEN OTHERS THEN
IF NVL(VR_LOG.TD_SECUENCIA, 0) = 0 THEN
PL_SET_SECUENCIA;
END IF;
IF VR_LOG.DESCRIPCION IS NULL THEN
VR_LOG.DESCRIPCION := SQLERRM;
END IF;
IF VR_LOG.FECHA IS NULL THEN
VR_LOG.FECHA := SYSDATE;
END IF;
IF VR_LOG.USUARIO IS NULL THEN
VR_LOG.USUARIO := 'NONE';
END IF;
INSERT INTO CREDITOPY.CEIBO_LOG
(TIPO_DATO,
TD_REGISTRO,
TD_SECUENCIA,
DESCRIPCION,
FECHA,
USUARIO,
BITACORA_ID)
VALUES
('999',
'999',
VR_LOG.TD_SECUENCIA,
VR_LOG.DESCRIPCION,
VR_LOG.FECHA,
VR_LOG.USUARIO,
PV_BITACORA_ID);
END PL_EXCEPCION;
FUNCTION FL_GET_DESCRIPCION RETURN VARCHAR2 AS
BEGIN
RETURN SUBSTR(NVL(CP_DESCRIPCION, 'MENSAJE NULO'), 1, PV_LOG_LEN);
EXCEPTION
WHEN OTHERS THEN
RETURN 'ERROR AL OBTENER MENSAJE.';
END FL_GET_DESCRIPCION;
BEGIN
VR_LOG.FECHA := NVL(DP_FECHA_REGISTRO, SYSDATE);
VR_LOG.USUARIO := substr(CP_USUARIO, 1, 15);
VR_LOG.TIPO_DATO := substr(CP_TIPO_DATO, 1, 50);
VR_LOG.TD_REGISTRO := substr(CP_TD_REGISTRO, 1, 15);
VR_LOG.BITACORA_ID := PV_BITACORA_ID;
VI_PARSE := 1;
LOOP
VR_LOG.DESCRIPCION := FC_PARSE_CADENA(CP_DESCRIPCION,
VI_PARSE,
PV_LOG_LEN);
EXIT WHEN VR_LOG.DESCRIPCION IS NULL;
--Obtenemos la secuencia.
PL_SET_SECUENCIA;
INSERT INTO CREDITOPY.CEIBO_LOG VALUES VR_LOG;
VI_PARSE := VI_PARSE + 1;
END LOOP;
COMMIT;
EXCEPTION
WHEN OTHERS THEN
ROLLBACK;
IF VR_LOG.USUARIO IS NULL THEN
VR_LOG.USUARIO := 'NONE';
END IF;
VR_LOG.DESCRIPCION := SQLERRM;
PL_EXCEPCION;
VR_LOG.DESCRIPCION := FL_GET_DESCRIPCION;
PL_EXCEPCION;
COMMIT;
END PR_CEIBO_LOG;
PROCEDURE PR_LOGGING(CP_TIPO IN CEIBO_LOG.TIPO_DATO%TYPE,
CP_REGISTRO IN CEIBO_LOG.TD_REGISTRO%TYPE,
CP_DESCRIPCION IN CLOB DEFAULT NULL) AS
BEGIN
PV_USUARIO := get_usuario;
PR_CEIBO_LOG(CP_TIPO,
CP_REGISTRO,
--Comentamos, pues ya tenemos bitacora_id
--FC_GET_ID_NOVEDAD||CP_DESCRIPCION,
NVL(CP_DESCRIPCION, ' '),
SYSDATE,
PV_USUARIO);
END PR_LOGGING;
PROCEDURE spAcreditarTransfPendientes(PI_NUMERO_CUENTA IN NUMBER,
PI_TARJETA IN VARCHAR2,
PI_DOCUMENTO IN VARCHAR2, -- Documento de Identidad
PI_CELULAR IN VARCHAR2, -- Numero de Celular Formato 0NNNNNNNNN
PI_NOVEDAD IN NUMBER, -- Numero de novedad de alta
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
PO_CNT_TXS OUT NUMBER,
PO_LISTA_TXS OUT VARCHAR2) AS
PRAGMA AUTONOMOUS_TRANSACTION;
VR_CUENTAS creditopy.CUENTAS%ROWTYPE;
VR_CUENTA_PUENTE creditopy.CUENTAS%ROWTYPE;
VR_ALTA_MOV_AJUSTES creditopy.ALTA_MOVIMIENTOS_AJUSTES@OLPY%ROWTYPE;
VD_FECHA_PROCESO DATE;
CC_RUBRO_CR NUMBER(4) := 5703;
VD_FECHA_SYS DATE;
V_COD_COMERCIO_DIMO NUMBER;
V_COD_COMERCIO_AUX NUMBER := 9960410;
--V_TARJETA VARCHAR2(16);
VC_REQ VARCHAR2(512);
VC_RES VARCHAR2(512);
PROCEDURE inicializar_alta_ajuste AS
BEGIN
VR_ALTA_MOV_AJUSTES.FECHA_PROCESO := VD_FECHA_PROCESO;
VR_ALTA_MOV_AJUSTES.PERIODO_CIERRE := VR_CUENTAS.PERIODO_CIERRE_DEBE;
VR_ALTA_MOV_AJUSTES.RUBRO := CC_RUBRO_CR;
VR_ALTA_MOV_AJUSTES.TIPO_DE_MONEDA := 1;
VR_ALTA_MOV_AJUSTES.OPERADOR := 805;
VR_ALTA_MOV_AJUSTES.PROCESADO := 'N';
VR_ALTA_MOV_AJUSTES.SECUENCIA := 1;
VR_ALTA_MOV_AJUSTES.EMISOR_RECEPTOR := 0;
VR_ALTA_MOV_AJUSTES.NUMERO_TALON := 1;
VR_ALTA_MOV_AJUSTES.USUARIO := CC_USUARIO_DIMO;
VR_ALTA_MOV_AJUSTES.FECHA_REGISTRO := SYSDATE;
VR_ALTA_MOV_AJUSTES.NOVEDAD := PI_NOVEDAD;
VR_ALTA_MOV_AJUSTES.USUARIO_ORIGINAL := CC_USUARIO_DIMO;
END inicializar_alta_ajuste;
BEGIN
vd_fecha_proceso := SYSDATE;
vd_fecha_sys := SYSDATE;
PO_CNT_TXS := 0;
PO_LISTA_TXS := CHR(037);
BEGIN
-- obtener datos de la cuenta de tarjeta puente DIMO
SELECT C.*
INTO VR_CUENTA_PUENTE
FROM creditopy.TARJETAS TP, creditopy.CUENTAS C
WHERE tp.tarjeta = fc_getTarjetaPuenteDIMO
AND c.numero_cuenta = tp.numero_cuenta;
-- obtener datos de la cuenta destino
SELECT C.*
INTO VR_CUENTAS
FROM creditopy.CUENTAS C
WHERE c.numero_cuenta = PI_NUMERO_CUENTA;
END;
inicializar_alta_ajuste;
BEGIN
V_COD_COMERCIO_DIMO := fn_getComercioGestionDIMO;
IF V_COD_COMERCIO_DIMO = -1 THEN
V_COD_COMERCIO_DIMO := V_COD_COMERCIO_AUX;
END IF;
END;
--V_TARJETA := fc_pan2cripto(PI_TARJETA);
-- seleccionamos las transferencias que corresponden al usuario de DOCUMENTO recibido
-- y todavia no se le acreditaron
FOR B IN (SELECT t.*
FROM creditopy.SICOOP_TRANSFER@OLPY t
WHERE lpad(t.documento_destino, 12, 0) =
lpad(PI_DOCUMENTO, 12, 0)
AND t.telefono_destino = PI_CELULAR
AND t.aplicado_destino = 0
ORDER BY t.fecha_transf) LOOP
-- datos de la cuenta destino
VR_ALTA_MOV_AJUSTES.EMISOR := VR_CUENTAS.Emisor;
VR_ALTA_MOV_AJUSTES.SUCURSAL_EMISOR := VR_CUENTAS.Sucursal_Emisor;
VR_ALTA_MOV_AJUSTES.PRODUCTO := VR_CUENTAS.Producto;
VR_ALTA_MOV_AJUSTES.NUMERO_CUENTA := VR_CUENTAS.Numero_Cuenta;
VR_ALTA_MOV_AJUSTES.CODIGO_OPERACION := 1;
VR_ALTA_MOV_AJUSTES.FECHA_MOVIMIENTO := trunc(b.fecha_transf);
VR_ALTA_MOV_AJUSTES.IMPORTE := b.monto_transferido;
VR_ALTA_MOV_AJUSTES.LEYENDA := 'Transf.recibida el ' ||
to_char(b.fecha_transf,
'dd/mm/yyyy');
-- registrar el movimiento de credito
INSERT INTO CREDITOPY.ALTA_MOVIMIENTOS_AJUSTES@OLPY
VALUES VR_ALTA_MOV_AJUSTES;
-- la transferencia como acreditada
UPDATE creditopy.SICOOP_TRANSFER@OLPY BD
SET BD.APLICADO_DESTINO = 1,
BD.FECHA_APLICADO = SYSDATE,
BD.TARJETA_APLICADO = PI_TARJETA
WHERE BD.DOCUMENTO_DESTINO = b.documento_destino
AND BD.TELEFONO_DESTINO = b.telefono_destino
AND BD.APLICADO_DESTINO = 0
AND BD.IDSESION_UUID = b.idsesion_uuid;
-- datos de la cuenta de tarjeta puente
VR_ALTA_MOV_AJUSTES.EMISOR := VR_CUENTA_PUENTE.Emisor;
VR_ALTA_MOV_AJUSTES.SUCURSAL_EMISOR := VR_CUENTA_PUENTE.Sucursal_Emisor;
VR_ALTA_MOV_AJUSTES.PRODUCTO := VR_CUENTA_PUENTE.Producto;
VR_ALTA_MOV_AJUSTES.NUMERO_CUENTA := VR_CUENTA_PUENTE.Numero_Cuenta;
VR_ALTA_MOV_AJUSTES.CODIGO_OPERACION := 0;
VR_ALTA_MOV_AJUSTES.LEYENDA := 'Transf.de ' ||
TRIM(leading '0' FROM
substr(b.documento_origen,
4,
12));
-- registrar el movimiento de credito
INSERT INTO CREDITOPY.ALTA_MOVIMIENTOS_AJUSTES@OLPY
VALUES VR_ALTA_MOV_AJUSTES;
COMMIT;
-- insertar la txs off-line para otorgar el disponible
BEGIN
/* original
SELECT '02207238058100C1801416'||
FC_CRIPTO2PAN(PI_TARJETA)||'203000'||
LPAD(VR_ALTA_MOV_AJUSTES.IMPORTE,10,0)||'00'
||TO_CHAR(SYSDATE,'MMDDhh24mmss')||LPAD(SEQ_STAN.NEXTVAL@OLPY,6,0)||TO_CHAR(SYSDATE,'hh24mmss')
||TO_CHAR(SYSDATE,'MMDD')||'0100000000011'||'10000000004'||
'TRANDIMO'||LPAD(V_COD_COMERCIO_DIMO,15,' ')||'010R'||LPAD(1,2,0)||V_COD_COMERCIO_DIMO
||'83021'||'TRAN.PEN.DIMO 1.0 '||'009001007838'
as DEVOFFLINE
INTO VC_REQ
FROM DUAL;*/
-- version del PR_EJEMPLO_DEVOFF 04/10/2020
SELECT '02207238058100C1801416' || FC_CRIPTO2PAN(PI_TARJETA) ||
'203000' || LPAD(VR_ALTA_MOV_AJUSTES.IMPORTE, 10, 0) || '00' ||
TO_CHAR(SYSDATE, 'MMDDhh24mmss') ||
LPAD(SEQ_STAN.NEXTVAL@OLPY, 6, 0) ||
TO_CHAR(SYSDATE, 'hh24mmss') || TO_CHAR(SYSDATE, 'MMDD') ||
'0100000000011' || '10000000004' || 'TRANDIMO' ||
LPAD(V_COD_COMERCIO_DIMO, 15, ' ') || '011R' ||
LPAD(1, 2, 0) || LPAD(V_COD_COMERCIO_DIMO, 8, 0) || '83021' ||
'TRAN.PEN.DIMO 1.0 ' || '009001007838' AS DEVOFFLINE
INTO VC_REQ
FROM DUAL;
--Procesamos la autorizacion
VC_RES := AUTORIZADOR_CR.FUNCIONAUTORIZADORCREDITO@OLPY(VC_REQ);
END;
sp_delay(2);
PO_CNT_TXS := PO_CNT_TXS + 1;
PO_LISTA_TXS := PO_LISTA_TXS || TRIM(b.idsesion_uuid) || CHR(037);
END LOOP;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
IF PO_CNT_TXS = 0 THEN
PO_LISTA_TXS := ' ';
PO_SQLCODE := 1;
PO_SQLERRM := 'No hay transferencia pendiente para el documento.';
END IF;
IF PO_SQLCODE = 1 THEN
ROLLBACK;
ELSE
COMMIT;
END IF;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
PO_CNT_TXS := 0;
PO_LISTA_TXS := ' ';
ROLLBACK;
END spAcreditarTransfPendientes;
PROCEDURE sp_setearGrupoAfinidad(PI_NUMERO_TARJETA IN VARCHAR2, -- Numero de tarjeta
PI_GRUPO_AFINIDAD IN NUMBER, -- Grupo de afinidad al que va a pertenecer
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
vc_afinidad_m NUMBER := 115002;
vc_captador_m VARCHAR2(2) := 'DM';
vc_id_plastico_m NUMBER := 5;
vc_id_plastico_std NUMBER := 1;
vc_tarjeta VARCHAR2(19);
v_doc_tarjeta creditopy.tarjetas.documento%TYPE;
v_afinidad_original creditopy.tarjetas.grupo_afinidad%TYPE;
v_cant_tarjetas NUMBER;
v_mensaje VARCHAR2(30);
BEGIN
sp_setEmisorDimo;
-- se determina si para el documento de este usuario ya existe una tarjeta con la afinidad solicitada
-- y que este operativa
vc_tarjeta := creditopy.FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
vc_id_plastico_std := fn_get_default_tipo_tp_fisica(PV_EMISOR_DIMO);
BEGIN
SELECT t.documento, t.grupo_afinidad
INTO v_doc_tarjeta, v_afinidad_original
FROM creditopy.tarjetas t
WHERE t.tarjeta = vc_tarjeta;
SELECT COUNT(*)
INTO v_cant_tarjetas
FROM creditopy.tarjetas t
WHERE t.emisor = PV_EMISOR_DIMO
AND t.tarjeta != vc_tarjeta
AND t.documento = v_doc_tarjeta
AND t.grupo_afinidad = PI_GRUPO_AFINIDAD
AND creditopy.estado_ct(t.tarjeta, 'T') IN (0, 1);
EXCEPTION
WHEN no_data_found THEN
v_cant_tarjetas := 0;
WHEN OTHERS THEN
RAISE;
END;
-- si no tiene otra tarjeta operativa en la nueva afinidad: se cambia esta tarjeta a la afinidad destino
IF v_cant_tarjetas = 0 THEN
BEGIN
-- obs: por indicacion de Juan Almada las tarjetas de la afinidad 115002 nacen no operativas
-- y con el tipo de plastico exclusivo
-- si la nueva afinidad es 115002 entonces al confirmar
-- debe quedar operativa
-- indicar el captador(promotor) exclusivo = 'CM'
-- cambiar al tipo de plalstico exclusivo = 5
IF PI_GRUPO_AFINIDAD = vc_afinidad_m THEN
UPDATE creditopy.tarjetas u
SET u.grupo_afinidad = PI_GRUPO_AFINIDAD,
u.codigo_captador = VC_CAPTADOR_M,
u.estado = CC_ESTADO_TP_OPERATIVA,
u.clase_de_estado = 1,
u.fecha_estado = SYSDATE
WHERE u.tarjeta = vc_tarjeta;
UPDATE creditopy.tarjetas_prepaga u
SET u.id_tipo_tarjeta_prepaga = VC_ID_PLASTICO_M
WHERE u.tarjeta = vc_tarjeta;
v_mensaje := 'Tarjeta confirmada.';
ELSE
-- si la afinidad original es 115002 entonces
-- se cambia a la nueva afinidad
-- se debe dejar operativa la tarjeta
-- se debe configurar el tipo de plastico a standard
IF v_afinidad_original = vc_afinidad_m THEN
UPDATE creditopy.tarjetas u
SET u.grupo_afinidad = PI_GRUPO_AFINIDAD,
u.codigo_captador = CC_CAPTADOR_DIMO,
u.estado = CC_ESTADO_TP_OPERATIVA,
u.clase_de_estado = 1,
u.fecha_estado = SYSDATE
WHERE u.tarjeta = vc_tarjeta;
UPDATE creditopy.tarjetas_prepaga u
SET u.id_tipo_tarjeta_prepaga = vc_id_plastico_std
WHERE u.tarjeta = vc_tarjeta;
ELSE
-- si no es ninguno de los casos anteriores
-- solo cambia a la nueva afinidad
UPDATE creditopy.tarjetas u
SET u.grupo_afinidad = PI_GRUPO_AFINIDAD
WHERE u.tarjeta = vc_tarjeta;
END IF;
v_mensaje := 'Afinidad cambiada.';
END IF;
UPDATE creditopy.cuentas u
SET u.grupo_afinidad = PI_GRUPO_AFINIDAD,
u.codigo_captador = CASE
WHEN PI_GRUPO_AFINIDAD = 115002 THEN
vc_captador_m
ELSE
CC_CAPTADOR_DIMO
END
WHERE u.numero_cuenta =
(SELECT t.numero_cuenta
FROM creditopy.tarjetas t
WHERE t.tarjeta = vc_tarjeta);
END;
ELSE
-- si ya tiene una tarjeta en la afinidad destino
-- anular esta cuenta/tarjeta
-- pasar el saldo actual a la tarjeta operativa standard: pendiente, descontinuado para 115002
BEGIN
UPDATE creditopy.tarjetas u
SET u.estado = 17,
u.clase_de_estado = 16,
u.fecha_estado = SYSDATE
WHERE u.tarjeta = vc_tarjeta;
UPDATE creditopy.cuentas u
SET u.estado = 70,
u.clase_de_estado = 16,
u.fecha_estado = SYSDATE
WHERE u.numero_cuenta =
(SELECT t.numero_cuenta
FROM creditopy.tarjetas t
WHERE t.tarjeta = vc_tarjeta);
END;
v_mensaje := 'Tarjeta anulada.';
END IF;
-- se actualiza el cambio de estado en el Online. 06/06/2022. AR.
INSERT INTO cambios_de_estado@olpy ct
SELECT t.tarjeta, t.estado, t.fecha_estado, 0
FROM creditopy.tarjetas t
WHERE t.tarjeta = vc_tarjeta;
INSERT INTO cambios_de_estado@olpy ct
SELECT t.numero_cuenta, t.estado, t.fecha_estado, 0
FROM creditopy.tarjetas t
WHERE t.tarjeta = vc_tarjeta;
COMMIT;
OPEN po_cursor FOR
SELECT substr(t.documento, 4, 12) AS documento,
-- PAN de la tarjeta
creditopy.fc_cripto2pan(t.tarjeta) AS numero_tarjeta,
t.grupo_afinidad AS afinidad,
t.codigo_captador AS id_promotor,
t.estado AS estado,
tp.id_tipo_tarjeta_prepaga AS id_tipo_tarjeta,
v_mensaje AS accion
FROM creditopy.tarjetas t, creditopy.tarjetas_prepaga tp
WHERE t.tarjeta = vc_tarjeta
AND tp.tarjeta = t.tarjeta;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_setearGrupoAfinidad;
PROCEDURE spConfigurarAfinidadDimo(PI_NUMERO_TARJETA IN VARCHAR2, -- Numero de tarjeta
PI_GRUPO_AFINIDAD IN NUMBER, -- Grupo de afinidad al que va a pertenecer
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/****************************************************************************************************
Autor: Amalia Rodriguez.
Procedimiento para dar de alta una tarjeta indicando su grupo de afinidad especifico.
ticket 0002049-Afinidad DIMO. AR. 27/05/2022 16:32:00 p.m.
Fecha: 27/05/2022 16:32:00 p.m.
Propósito: Procedimiento que devuelve un cursor con los datos de las tarjetas prepagas
DIMOs por grupo de afinidad si no tienen plastico solicitado.
Se tiene como dato de entrada el grupo de afinidad a revisar
PARAMETROS DE ENTRADA:
pi_afinidad_dimo: codigo de grupo afinidad de Dimo
******************************************************************************************************/
vc_tarjeta VARCHAR2(19);
v_grupo_afinidad creditopy.tarjetas.grupo_afinidad%TYPE;
v_id_tipo_plastico creditopy.tipos_tarjeta_prepaga.id_tipo_tarjeta_prepaga%TYPE;
vc_afinidad_m NUMBER := 115002;
vc_captador_m VARCHAR2(2) := 'DM';
vc_tipo_plastico_m NUMBER := 5;
vc_tipo_plastico_std NUMBER := 1;
vn_tipo_direccion_email direcciones.tipo_de_direccion%TYPE := 6;
vn_tipo_direccion_cel direcciones.tipo_de_direccion%TYPE := 7;
BEGIN
-- inicializaciones
sp_setEmisorDimo;
vc_tarjeta := creditopy.fc_pan2cripto(PI_NUMERO_TARJETA);
vc_tipo_plastico_std := fn_get_default_tipo_tp_fisica(PV_EMISOR_DIMO);
-- control de consistencia
BEGIN
SELECT t.grupo_afinidad
INTO v_grupo_afinidad
FROM creditopy.tarjetas t
WHERE t.tarjeta = vc_tarjeta;
EXCEPTION
WHEN no_data_found THEN
raise_application_error(-20001,
'USERS_ERROR: No se puede encontrar la tarjeta indicada.');
WHEN OTHERS THEN
RAISE;
END;
IF PI_GRUPO_AFINIDAD = vc_afinidad_m AND
PI_GRUPO_AFINIDAD = v_grupo_afinidad THEN
-- si se confirma el grupo de afinidad 115002 entonces se activa la tarjeta
--
BEGIN
UPDATE creditopy.tarjetas u
SET u.estado = CC_ESTADO_TP_OPERATIVA,
u.clase_de_estado = 1,
u.fecha_estado = SYSDATE,
u.codigo_captador = vc_captador_m
WHERE u.tarjeta = vc_tarjeta;
-- se actualiza el cambio de estado en el Online. 06/06/2022. AR.
INSERT INTO cambios_de_estado@olpy ct
SELECT t.tarjeta, t.estado, t.fecha_estado, 0
FROM creditopy.tarjetas t
WHERE t.tarjeta = vc_tarjeta;
COMMIT;
END;
ELSE
sp_setearGrupoAfinidad(PI_NUMERO_TARJETA,
PI_GRUPO_AFINIDAD,
PO_SQLCODE,
PO_SQLERRM,
po_cursor);
END IF;
OPEN po_cursor FOR
SELECT
-- Numero del documento de identidad
substr(t.documento, 4, 12) AS documento,
-- PAN de la tarjeta
creditopy.fc_cripto2pan(t.tarjeta) AS numero_tarjeta,
-- tipo medio: VIRTUAL / FISICA
decode(creditopy.pkg_dimo_ceibo.fn_is_prepaga_fisica(t.tarjeta),
1,
'FISICA',
'VIRTUAL') AS tipo_medio,
-- nombre que aparece en el plastico de la tarjeta
t.nombre_para_plastico AS nombre_usuario,
-- id del estado de la tarjeta
creditopy.estado_ct(t.tarjeta, 'T') AS estado,
-- descripcion del estado de la tarjeta
creditopy.pkg_dimo_ceibo.fn_get_estado_desc(creditopy.estado_ct(t.tarjeta,
'T')) AS desc_estado,
tp.id_tipo_tarjeta_prepaga AS id_tipo_tarjeta_prepaga,
creditopy.pkg_dimo_ceibo.fn_datos_plastico_tp(t.tarjeta, 2) AS tipo_tarjeta_prepaga,
tp.estado_plastico AS estado_tarjeta_fisica,
creditopy.pkg_dimo_ceibo.fn_datos_plastico_tp(t.tarjeta, 4) AS desc_estado_tarjeta_fisica,
t.grupo_afinidad AS id_grupo_afinidad,
ga.descripcion AS desc_afinidad,
dc.calle AS celular,
de.calle AS email,
t.tarjeta AS tarjeta
FROM creditopy.tarjetas t,
creditopy.grupos_afinidad ga,
creditopy.tarjetas_prepaga tp,
creditopy.direcciones dc,
creditopy.direcciones de
WHERE t.tarjeta = vc_tarjeta -- Encriptada. 06/06/2022. AR.
--AND t.estado IN (0,1) -- Sin considerar el estado. 06/06/2022. AR.
AND t.fecha_vigencia > trunc(SYSDATE)
AND ga.emisor = t.emisor
AND ga.grupo_afinidad = t.grupo_afinidad
AND tp.tarjeta = t.tarjeta
AND dc.emisor = t.emisor
AND dc.sucursal_emisor = t.sucursal_emisor
AND dc.producto = t.producto
AND dc.numero_cuenta = t.numero_cuenta
AND dc.tipo_de_documento = t.tipo_de_documento
AND dc.documento = t.documento
AND dc.tipo_de_direccion = vn_tipo_direccion_cel
AND de.emisor = t.emisor
AND de.sucursal_emisor = t.sucursal_emisor
AND de.producto = t.producto
AND de.numero_cuenta = t.numero_cuenta
AND de.tipo_de_documento = t.tipo_de_documento
AND de.documento = t.documento
AND de.tipo_de_direccion = vn_tipo_direccion_email
ORDER BY documento;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END spConfigurarAfinidadDimo;
PROCEDURE sp_RegistroDimoPorAfinidad(PI_DOCUMENTO IN VARCHAR2, -- Documento de Identidad
PI_EMAIL IN VARCHAR2, -- Correo Electronico. SICOOP debe aplicar control de formato
PI_CELULAR IN VARCHAR2, -- Numero de Celular Formato 0NNNNNNNNN
PI_NOMBRES IN VARCHAR2, -- Nombres de la Persona
PI_APELLIDOS IN VARCHAR2, -- Apellidos de la Persona
PI_FECHA_NACIMIENTO IN DATE, -- Fecha de Nacimiento de la Persona.
PI_CODIGO_SEXO IN NUMBER, -- 1 Femenino, 2 Masculino,0 Nulo
PI_GRUPO_AFINIDAD IN NUMBER,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/****************************************************************************************************
Autor: Amalia Rodriguez.
Procedimiento para dar de alta una tarjeta indicando su grupo de afinidad especifico.
ticket 0002049-Afinidad DIMO. AR. 27/05/2022 16:32:00 p.m.
Fecha: 27/05/2022 16:32:00 p.m.
Propósito: Reutilizar el sp_registroDimo seteando previamente valores para el grupo de afinidad
al alta de acuerdo a las indicaciones de Juan Almada:
-- las tarjetas de la afinidad 115002 no nacen operativas
-- el tipo de plastico no se permite seleccionar, se relaciona al tipo de plastico 5
PARAMETROS DE ENTRADA:
* todos los parametros originales del sp_registroDImo +
pi_afinidad_dimo: codigo de grupo afinidad de Dimo
******************************************************************************************************/
BEGIN
PR_LOGGING('DIMO',
'ALTAS-DIMO',
'LLEGO PKG_DIMO_CEIBO.sp_RegistroDimoPorAfinidad. INICIO.' ||
' DOCUMENTO:' || PI_DOCUMENTO || ' AFINIDAD: ' ||
PI_GRUPO_AFINIDAD);
PR_LOGGING('DIMO',
'ALTAS-DIMO',
'PKG_DIMO_CEIBO.sp_RegistroDimoPorAfinidad. INICIO.' ||
' DOCUMENTO:' || PI_DOCUMENTO || ' AFINIDAD: ' ||
PI_GRUPO_AFINIDAD);
sp_setEmisorDimo;
PV_GRUPO_AFINIDAD := PI_GRUPO_AFINIDAD;
CASE PV_GRUPO_AFINIDAD
WHEN 115002 THEN
PV_PROMOTOR_ID := 'DM';
PV_ESTADO_TJ_ALTA := 0; -- no activada
PV_ID_TIPO_PLASTICO := 5; -- plastico predefinido
ELSE
PV_PROMOTOR_ID := CC_CAPTADOR_DIMO;
PV_ESTADO_TJ_ALTA := CC_ESTADO_TP_OPERATIVA;
PV_ID_TIPO_PLASTICO := fn_get_default_tipo_tp_fisica(PV_EMISOR_DIMO);
END CASE;
creditopy.PKG_DIMO_CEIBO.sp_RegistroDimo(PI_DOCUMENTO,
PI_EMAIL,
PI_CELULAR,
PI_NOMBRES,
PI_APELLIDOS,
PI_FECHA_NACIMIENTO,
PI_CODIGO_SEXO,
PO_SQLCODE,
PO_SQLERRM,
PO_CURSOR);
EXCEPTION
WHEN OTHERS THEN
RAISE;
END sp_RegistroDimoPorAfinidad;
PROCEDURE sp_registrodimo(PI_DOCUMENTO IN VARCHAR2, -- Documento de Identidad
PI_EMAIL IN VARCHAR2, -- Correo Electronico. SICOOP debe aplicar control de formato
PI_CELULAR IN VARCHAR2, -- Numero de Celular Formato 0NNNNNNNNN
PI_NOMBRES IN VARCHAR2, -- Nombres de la Persona
PI_APELLIDOS IN VARCHAR2, -- Apellidos de la Persona
PI_FECHA_NACIMIENTO IN DATE, -- Fecha de Nacimiento de la Persona.
PI_CODIGO_SEXO IN NUMBER, -- 1 Femenino, 2 Masculino,0 Nulo
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
8.1- Registro cliente nuevo Dimo y nueva cuenta para una tarjeta prepaga
Adaptado del PKG_SICOOP_DIMO.
Ajustes a invocacion para el backend DIMO: A.Rodriguez. 12/05/2020.
*/
/*
Autor: Edgar Rojas.
Fecha: 23/04/2020 11:02
Proposito: Registro cliente nuevo Dimo y nueva cuenta para una tarjeta prepaga
Al registrarse a la app DIMO, se crea una cuenta nueva correspondiente a la tarjeta prepaga, y queda
disponible para utilizar con saldo 0.
NO GENERA PLASTICO NI PIN, aunque la documentacion indique que es opciona.
No tiene parametros que definan si se genera plastico ni pin por tanto, solo es Virtual.
Cumple con el 3.2 Sobre la tarjeta prepaga:generacion y renovacion
a)Pueden emitirse tarjetas: solo relacionadas a un documento, con nombre del usuario.
b)El alta de una tarjeta prepaga relacionada al documento del usuario GENERA UNA CUENTA, Y LA PRIMERA TARJETA
PARA EL USUARIO.
--------------------------------------------------------------------------------------------
NRA: no impide que pueda realizar otras altas.
Genera la cuenta tarjeta sin importar si ya tiene otra cuenta.
--------------------------------------------------------------------------------------------
f) Se puede indicar una cantidad máxima de tarjetas por cuenta. Esto es parametrizable.
g) No se habilita la generacion de tarjetas adicionales para otro documento, la relacion es que todas las tarjetas de una cuenta son de un mismo documento.
h) Los saldos siempre son administrados por cuenta y se debe poder definir un limite de uso por tarjeta.
i) El plazo de vigencia es diferencial (5 anios). Esto es parametrizable.
j) Se debe poder aplicar cargos en la emision. Esto es parametrizable.
k) El cargo de emision se aplican por tarjeta/cuenta. Esto es parametrizable.
l) El cargo por la emision debe poder aplicarse en los distintos pasos de la emision y con montos parametrizables. Los pasos donde pueden aplicarse son actualmente:
¿ Al momento de generar la cuenta/tarjeta por un alta, o
¿ Al renovar la tarjeta, o
¿ Al activar la tarjeta
Si no hay parametrizacion de monto entonces no se aplica el cargo.
Sobre la aplicacion del cargo en la emision referenciar el item 3.5. Sobre la aplicacion de los cargos y la facturacion de los mismos.
---------------------------------------------------------------------
NRA: No hay parametros al momento del desarrollo. ER 202004231311.
---------------------------------------------------------------------
m) La tarjeta que nace con la cuenta es una tarjeta virtual. Esta tarjeta virtual puede ser activada por el usuario o puede quedar Operativa, se manejará por un parámetro.
Debe poder transaccionar en forma inmediata.
o) El embozado es opcional en la generación. Debe quedar un indicador que la tarjeta no tiene plástico.
Referencia: API_TARJETAHABIENTE_15abril2020.xlsx Hoja 8.1- Crear tar-cuenta DIMO
Las prepagas deben poder darse de alta y utilizarse EN TODO MOMENTO:
Utilizar en todo momento tambien incluye poder operar por lo tanto DEBE SER VIRTUAL para este procedimiento.
Prevenir para cuando las Novedades On Line es solo Otorgar o Denegar.
Esta prestacion se analizara posterior al lunes 27.
Falta el tema de Cargos Pendientes
Temas Pendientes para el Alta
2. Parámetros nuevos exclusivos para tarjeta pre-paga
Indicador de emisor de tarjetas prepagas.
Indicador de cantidad máxima de tarjetas por cuenta.
Indicador de estado de una tarjeta virtual a su generación. Si nace operativa o se deja para que el usuario la active o no.
Indicador de operaciones que puede realizar la tarjeta virtual y cuales solo si cuenta con el plástico.
Indicador de cantidad de reintentos para aplicar cargos programados no cubiertos.
Cargos a aplicar por transacción, como originatario de la transacción o destinatario
*/
-- variables de input y output originales
CP_MESSAGE_CODE VARCHAR2(20); --Codigo especifico de mensaje.
CP_MESSAGE VARCHAR2(2064); --Mensaje asociado a messageCode
NP_NOVEDAD NUMBER(16); --Codigo de resultado de la Novedad.
NP_NUMERO_CUENTA NUMBER(13); --Numero de Cuenta de la tarjeta.
NP_NUMERO_TARJETA_NUEVA VARCHAR2(16); --Numero de la Tarjeta
--2472: Revision de los errores de Registro (OTP)
--Se amplio de 25 a 26. ER 202208170932
CP_NOMBRE_PLASTICO VARCHAR2(26);
-- variables para aplicacion de trasnferencias pendientes
v_sqlcode NUMBER;
v_sqlerrm VARCHAR2(2064);
vn_cnt_txs NUMBER;
vc_lista_txs VARCHAR2(2064);
v_flg_con_tranf VARCHAR2(1);
BEGIN
PR_LOGGING('DIMO', --'WS',
'ALTAS-DIMO', --'01',
'PKG_DIMO_CEIBO.sp_registrodimo. INICIO.' || ' DOCUMENTO:' ||
PI_DOCUMENTO);
--||' NP_ID_REQUEST:' || NP_ID_REQUEST||
--' CP_CODIGO_PARTICIPANTE:' || CP_CODIGO_PARTICIPANTE||
--' CP_CANAL:' || CP_CANAL);
--Los datos del Header Request son registrados en el Ceibo Log y en el Historico de Cuentas.
--Se da de alta la Cuenta Tarjeta Prepaga con Limites Cuentas en cero para todos los planes.
--Se modifico que el Calculo de Disponibles
CP_MESSAGE_CODE := '0';
CP_MESSAGE := 'Ok.';
/*
NP_NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
NP_NUMERO_TARJETA_NUEVA := FC_CRIPTO2PAN(VR_TARJETA.TARJETA);
CP_NOMBRE_PLASTICO := VR_TARJETA.NOMBRE_PARA_PLASTICO;
*/
--Primer punto, todos los procedimientos de NOVEDADES_ONLINE_PCI se deben traer aqui:Es mejor separar todo del CEIBO Tarjetas.
--Esto fue lo acordadro.
--Consideraciones y Ventajas:
--1. De acuerdo al Nivel del Proceso: Sino es Full: es solo Otorgar o Denegar.
-- 1.1 Debemos proceder normalmente en el Batch.
-- 1.2 Registrar la nueva cuenta y tarjeta en la tabla auxiliar del OL.
-- 1.3 La replicacion quedara a cargo de la Diaria.
--2. Para aplicar nuevas reglas, se usaran las tablas de novedades en el Batch.
--3. Es mejor el manejo de errores en este paquete.
--4. No es necesario completar NovedadesCuentas ni NovedadesTarjetas del OL.
/**************************************************************************************************/
--Proceso Normal.
--Limpiar el Historico (matriz donde se registraran todos los datos a registrar en el Historico@olpy)
--Asignar los datos por defecto en las tablas Principales y Secundarias
--Realizar los Geteres: Obtener todos los datos de tablas secundarias.
--Tomar los parametros de entrada en las tablas Principales.
--Setear los Tipos de Direcciones: Direccion (por defecto datos de Cabal), Correo Electronico y Numero de Celular.
--Contiuamos tomando los datos personales.
--Fin de toma de los Parametros.
--Obtener los datos para el Historico.
--Se registra en el Historico@olpy
--Se cargan en las tablas de Temporales de Cuentas, Tarjetas, Personas, ... del Batch.
--Se ejecutan las reglas de validacion.
--Se registra el resultado en el Historico@olpy
--Si se Aprueba, se hace el commit en el WebService.
--Si se rechaza, se hace el rollback en el WebService.
--De acuerdo al Nivel del Proceso, el WebService replica o no los cambios.
/**************************************************************************************************/
--LIMPIAR EL HISTORICO
PR_LIMPIAR_HISTORICO;
--Incializamos ciertas Variables.
PV_JOB_NOMBRE := JOB_ALTAS;
VR_PERSONA := NULL;
VR_CUENTA := NULL;
VR_TARJETA := NULL;
VR_DIRECCION := NULL;
VR_EMAIL := NULL;
VR_CELULAR := NULL;
VR_TARJETAS_PREPAGA := NULL;
PV_FEC_REG_ALTA := SYSDATE;
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 1.' || ' DOCUMENTO:' || PI_DOCUMENTO);
--Asignar los datos por defecto en las tablas Principales y Secundarias
VR_CIUDAD.CIUDAD := 1;
VR_OCUPACION.CODIGO_OCUPACION := 9999;
VR_ESTADO_CIVIL.ESTADO_CIVIL := 9;
PR_SET_EMISOR_DIMO;
VR_PERSONA.TIPO_DE_DOCUMENTO := 1;
VR_PERSONA.DOCUMENTO := LPAD(VR_EMISOR.EMISOR, 3, 0) ||
LPAD(PI_DOCUMENTO, 12, 0);
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 2.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
--Nombres y Apellidos
VR_PERSONA.NOMBRES := SUBSTR(PI_NOMBRES, 1, 25);
VR_PERSONA.APELLIDOS := SUBSTR(PI_APELLIDOS, 1, 25);
VR_PERSONA.FECHA_NACIMIENTO := PI_FECHA_NACIMIENTO;
VR_PERSONA.SEXO := PI_CODIGO_SEXO;
--#1 Set Persona.
PR_SET_PERSONA_DIMO;
VR_SEXO.SEXO := PI_CODIGO_SEXO;
--Realizar los Geteres...
PR_GET_AFINIDAD;
PR_GET_CIUDAD;
PR_GET_CARTERA;
PR_GET_CORRESPONDENCIA;
PR_GET_SEXO;
PR_GET_ESTADO_CIVIL;
PR_GET_OCUPACION;
PR_GET_PROMOTOR;
PR_GET_EMISOR;
PR_GET_SUCURSAL;
PR_GET_EMISOR_PRODUCTO;
PR_GET_CIERRE_DIMO;
PR_DATOS_CIERRES;
--Tomar los parametros de entrada en las tablas Principales.
--#2 Set Cuenta
PR_SET_CUENTA_DIMO;
--# Set Tarjeta
--Nombre Para Plastico
VR_TARJETA.NOMBRE_PARA_PLASTICO := FC_GET_NOMBRE_PLASTICO(VR_PERSONA.NOMBRES,
VR_PERSONA.APELLIDOS);
PR_SET_TARJETA_DIMO;
--Setear los Tipos de Direcciones
--El tipo 1 es por defecto.
--Direccion
PR_SET_DIRECCION_DIMO(VR_DIRECCION);
VR_DIRECCION.TIPO_DE_DIRECCION := 1;
VR_DIRECCION.BARRIO := 'Catedral';
VR_DIRECCION.CALLE := 'CABALLERO 728';
VR_DIRECCION.TELEFONO := '(59521) 4147000';
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 3.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
--Email
PR_SET_DIRECCION_DIMO(VR_EMAIL);
VR_EMAIL.TIPO_DE_DIRECCION := 6;
VR_EMAIL.BARRIO := 'Catedral';
VR_EMAIL.CALLE := PI_EMAIL;
VR_EMAIL.TELEFONO := PI_CELULAR;
--Celular
PR_SET_DIRECCION_DIMO(VR_CELULAR);
VR_CELULAR.TIPO_DE_DIRECCION := 7;
VR_CELULAR.BARRIO := 'Catedral';
VR_CELULAR.CALLE := PI_CELULAR;
VR_CELULAR.TELEFONO := PI_CELULAR;
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 3-1.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
--Registramos el Historico.
PR_HISTORICO_ALTA_DIMO;
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 3-1-1.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
NP_NOVEDAD := VR_HISTORICO.NOVNRO;
--Evaluar las reglas del Alta Dimo.
--Para eso debemos Registrar en las tablas temporales.
INSERT INTO PERSONA_TMP VALUES VR_PERSONA;
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 3-1-2.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
INSERT INTO CUENTA_TMP VALUES VR_CUENTA;
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 3-2.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
INSERT INTO TARJETA_TMP VALUES VR_TARJETA;
INSERT INTO DIRECCION_TMP VALUES VR_DIRECCION;
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 3-3.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
INSERT INTO DIRECCION_TMP VALUES VR_EMAIL;
INSERT INTO DIRECCION_TMP VALUES VR_CELULAR;
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 4.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
--Validar la Novedad
SOCIOS_MANTENIMIENTOS.PR_VALIDAR_NOVEDAD(100,
VR_HISTORICO.NOVNRO,
VR_HISTORICO.NOVFCHING,
VR_HISTORICO.USUARIO,
805);
--Obtenemos el Numero de Cuenta y Tarjeta
PR_SET_NUMERO_CUENTA;
--TARJETA
PCUTILES.GET_PAN_CRIPTOKEY;
PCUTILES.PR_INIT_BIN_EMISORES;
--En pinNew se guarda la tarjeta en claro por si es posible el alta.
CEIBO_EMISORES.PR_GEN_NEW_TARJETA(805,
VR_TARJETA.EMISOR,
VR_TARJETA.PRODUCTO,
VR_HISTORICO.USUARIO,
VR_TARJETA.PIN,
VR_TARJETA.TARJETA);
--Asingamos el Numero de Cuenta a las demas tablas.
VR_TARJETA.NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
VR_DIRECCION.NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
VR_EMAIL.NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
VR_CELULAR.NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
VR_LIMITES.NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
VR_SALDO_CUENTA.NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
--Registramos
PR_ALTA_PERSONA;
--Datos TARJETAS
VR_TARJETA.PIN := fn_gen_pin('');
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 5.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
-- insertamos datos de tarjetas prepagas
VR_TARJETAS_PREPAGA.TARJETA := VR_TARJETA.TARJETA;
--VR_TARJETAS_PREPAGA.ID_TIPO_TARJETA_PREPAGA := fn_get_default_tipo_tp_fisica(VR_TARJETA.EMISOR);--CC_TIPO_TARJETA_PREPAGA;
VR_TARJETAS_PREPAGA.ID_TIPO_TARJETA_PREPAGA := PV_ID_TIPO_PLASTICO; -- ticket 0002049-Afinidad DIMO. AR. 02/03/2022 10:32:00 a.m.
VR_TARJETAS_PREPAGA.ESTADO_PLASTICO := fn_get_estado_gen_tp_fisica(VR_TARJETA.EMISOR); --CC_ESTADO_PLASTICO;
VR_TARJETAS_PREPAGA.FECHA_ESTADO := VR_TARJETA.FECHA_ESTADO;
VR_TARJETAS_PREPAGA.FECHA_VIG_PLASTICO := VR_TARJETA.FECHA_OTORGADA - 1;
VR_TARJETAS_PREPAGA.FECHA_ULT_ACTUALIZACION := VR_TARJETA.ULT_ACTUALIZACION;
VR_TARJETAS_PREPAGA.CONTADOR_DE_IMPRESION := 0;
VR_TARJETAS_PREPAGA.FECHA_VIG_PIN := VR_TARJETA.FECHA_OTORGADA - 1;
INSERT INTO CREDITOPY.CUENTAS VALUES VR_CUENTA;
INSERT INTO CREDITOPY.TARJETAS VALUES VR_TARJETA;
INSERT INTO DIRECCIONES VALUES VR_DIRECCION;
INSERT INTO DIRECCIONES VALUES VR_EMAIL;
INSERT INTO DIRECCIONES VALUES VR_CELULAR;
INSERT INTO CREDITOPY.TARJETAS_PREPAGA VALUES VR_TARJETAS_PREPAGA;
PR_LOGGING('DIMO', 'ALTAS-DIMO', 'PKG_DIMO_CEIBO.sp_registrodimo. LOG 6.' || ' VR_PERSONA.DOCUMENTO:' || VR_PERSONA.DOCUMENTO);
NP_NUMERO_CUENTA := VR_CUENTA.NUMERO_CUENTA;
NP_NUMERO_TARJETA_NUEVA := FC_CRIPTO2PAN(VR_TARJETA.TARJETA);
CP_NOMBRE_PLASTICO := VR_TARJETA.NOMBRE_PARA_PLASTICO;
--Actualizamos el nombre del job en estados de cuentas.
PR_UPD_JOB_NOMBRE(1);
--Actualizamos el nombre del job en estados de tarjetas.
PR_UPD_JOB_NOMBRE;
--4974
PR_CARGOS_EMISION;
PR_LIMITES_DIMO;
PR_SALDO_CUENTA;
COMMIT;
/*begin
CREDITOPY.NOVEDADES_ONLINE_PCI.PR_REFRESCAR_VISTAS @OLPY('ALTAS-OL');
end;*/
BEGIN
spacreditartransfpendientes(VR_TARJETA.NUMERO_CUENTA,
VR_TARJETA.TARJETA,
PI_DOCUMENTO,
PI_CELULAR,
NP_NOVEDAD,
v_sqlcode,
v_sqlerrm,
vn_cnt_txs,
vc_lista_txs);
IF v_sqlcode != 0 AND v_sqlcode != 1 THEN
PR_LOGGING('DIMO',
'TRANS_PEND',
'TRANSFER PENDIENTES:' || PI_DOCUMENTO || ' Error:' ||
v_sqlerrm);
END IF;
IF nvl(vn_cnt_txs, 0) > 0 THEN
v_flg_con_tranf := '1';
ELSE
v_flg_con_tranf := '0';
END IF;
EXCEPTION
WHEN OTHERS THEN
v_flg_con_tranf := '0';
vc_lista_txs := ' ';
v_sqlcode := SQLCODE;
v_sqlerrm := SQLERRM;
END;
PR_LOGGING('DIMO',
'ALTAS-DIMO',
'Alta OK:' || PI_DOCUMENTO || ';Numero_Cuenta:' ||
NP_NUMERO_CUENTA);
PR_LOGGING('DIMO',
'ALTAS-DIMO',
'Nivel Bloqueo:' || CEIBO_SOCIOS.GET_NIVEL_BLOQUEO(805, 1) ||
';Numero_Cuenta:' || NP_NUMERO_CUENTA);
OPEN po_cursor FOR
SELECT NP_NOVEDAD AS codigo_novedad, --Codigo de resultado de la Novedad.
NP_NUMERO_CUENTA AS numero_cuenta, --Numero de Cuenta de la tarjeta.
NP_NUMERO_TARJETA_NUEVA AS numero_tarjeta, --Numero de la Tarjeta
CP_NOMBRE_PLASTICO AS nombre_plastico_normalizado, --El nombre que se utiliza para imprimir el plastico, luego de la limpieza de caracteres.
v_flg_con_tranf AS transf_acreditadas,
vc_lista_txs AS lista_uuid_transf
FROM dual;
PO_SQLCODE := CP_MESSAGE_CODE; --Codigo especifico de mensaje.
PO_SQLERRM := CP_MESSAGE; --Mensaje asociado a messageCode
EXCEPTION
WHEN OTHERS THEN
PR_RECHAZAR_NOVEDAD;
CP_MESSAGE_CODE := SQLCODE;
CP_MESSAGE := SQLERRM;
PO_SQLCODE := CP_MESSAGE_CODE; --Codigo especifico de mensaje.
PO_SQLERRM := CP_MESSAGE; --Mensaje asociado a messageCode
ROLLBACK;
END sp_registrodimo;
PROCEDURE sp_InitNovedades(PI_NOVEDAD_CUENTA IN OUT NOVEDADES_CUENTAS@OLPY%ROWTYPE,
PI_NOVEDAD_TARJETA IN OUT NOVEDADES_TARJETAS@OLPY%ROWTYPE) AS
BEGIN
PI_NOVEDAD_CUENTA.NOVTIP := NULL;
PI_NOVEDAD_CUENTA.NOVNRO := NULL;
PI_NOVEDAD_CUENTA.NOVFCHING := NULL;
PI_NOVEDAD_CUENTA.NUMERO_CUENTA := NULL;
PI_NOVEDAD_CUENTA.NUMERO_EMPRESA := NULL;
PI_NOVEDAD_CUENTA.GRUPO_AFINIDAD := NULL;
PI_NOVEDAD_CUENTA.NOVPROM := NULL;
PI_NOVEDAD_CUENTA.TIPO_DE_DIRECCION := NULL;
PI_NOVEDAD_CUENTA.CALLE := NULL;
PI_NOVEDAD_CUENTA.NUMERO_PUERTA := NULL;
PI_NOVEDAD_CUENTA.APARTAMENTO := NULL;
PI_NOVEDAD_CUENTA.CIUDAD := NULL;
PI_NOVEDAD_CUENTA.CODIGO_POSTAL := NULL;
PI_NOVEDAD_CUENTA.TELEFONO := NULL;
PI_NOVEDAD_CUENTA.CODIGO_DE_VINCULO := NULL;
PI_NOVEDAD_CUENTA.CODIGO_DE_ESTADO_FIN := NULL;
PI_NOVEDAD_CUENTA.CODIGO_DE_GARANTIA := NULL;
PI_NOVEDAD_CUENTA.TIPO_CUENTA := NULL;
PI_NOVEDAD_CUENTA.EMISOR := NULL;
PI_NOVEDAD_CUENTA.SUCURSAL_EMISOR := NULL;
PI_NOVEDAD_CUENTA.NUMERO_CUENTA_DEB := NULL;
PI_NOVEDAD_CUENTA.PAGO_AUTOMATICO := NULL;
PI_NOVEDAD_CUENTA.NUMERO_SOCIO_LEGAJO := NULL;
PI_NOVEDAD_CUENTA.BONIFICACION_TASAS := NULL;
PI_NOVEDAD_CUENTA.RUC := NULL;
PI_NOVEDAD_CUENTA.CICLO_ANTERIOR := NULL;
PI_NOVEDAD_CUENTA.CICLO_NUEVO := NULL;
PI_NOVEDAD_CUENTA.CODIGO_COSTO := NULL;
PI_NOVEDAD_CUENTA.LIMITE_CREDITO := NULL;
PI_NOVEDAD_CUENTA.LIMITE_FINANCIACION := NULL;
PI_NOVEDAD_CUENTA.NOVRENOV := NULL;
PI_NOVEDAD_CUENTA.NOVANUORG := NULL;
PI_NOVEDAD_CUENTA.NOVANUBOL := NULL;
PI_NOVEDAD_CUENTA.NOVANUDEB := NULL;
PI_NOVEDAD_CUENTA.NUMERO_TICKET := NULL;
PI_NOVEDAD_CUENTA.NOVGEN := NULL;
PI_NOVEDAD_CUENTA.FECHA_PROCESO := NULL;
PI_NOVEDAD_CUENTA.USUARIO := NULL;
PI_NOVEDAD_CUENTA.NOVNROSEC := NULL;
PI_NOVEDAD_CUENTA.NOVMOTDEV := NULL;
PI_NOVEDAD_CUENTA.CANTIDAD_TARJETAS := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_A := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_B := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_C := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_E := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_F := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_G := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_H := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_K := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_L := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_M := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_N := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_O := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_P := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_Q := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_R := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_S := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_T := NULL;
PI_NOVEDAD_CUENTA.NOVPARAM_U := NULL;
PI_NOVEDAD_CUENTA.NOVCARTERA := NULL;
PI_NOVEDAD_CUENTA.EMISOR_CUENTA := NULL;
PI_NOVEDAD_CUENTA.SUCURSAL_CUENTA := NULL;
PI_NOVEDAD_CUENTA.LIMITE_ADELANTO := NULL;
PI_NOVEDAD_CUENTA.CODIGO_CORRESPONDENCIA := NULL;
PI_NOVEDAD_CUENTA.CUOTAS_REFINAN := NULL;
PI_NOVEDAD_CUENTA.TASA_REFINAN := NULL;
PI_NOVEDAD_CUENTA.BLOQUEA_REFINAN := NULL;
PI_NOVEDAD_CUENTA.CARGO_REFINAN := NULL;
PI_NOVEDAD_CUENTA.IMPORTE_REFINAN := NULL;
PI_NOVEDAD_CUENTA.CUPONGEN := NULL;
PI_NOVEDAD_CUENTA.AUTGEN := NULL;
PI_NOVEDAD_CUENTA.BIN := NULL;
PI_NOVEDAD_CUENTA.PRODUCTO := NULL;
PI_NOVEDAD_CUENTA.BARRIO := NULL;
PI_NOVEDAD_CUENTA.LIMITE_PLAN_SALUD := NULL;
PI_NOVEDAD_CUENTA.ESTADO_OL := NULL;
PI_NOVEDAD_CUENTA.FECHA_ESTADO_OL := NULL;
PI_NOVEDAD_CUENTA.FILE_ID := NULL;
PI_NOVEDAD_CUENTA.REGLA_VALIDACION := NULL;
PI_NOVEDAD_CUENTA.BITACORA_ID := NULL;
PI_NOVEDAD_CUENTA.NUEVO_ESTADO_OL := NULL;
PI_NOVEDAD_CUENTA.NUEVA_FECHA_ESTADO_OL := NULL;
PI_NOVEDAD_CUENTA.FECHA_PROCESO_OL := NULL;
PI_NOVEDAD_CUENTA.EMAIL := NULL;
PI_NOVEDAD_CUENTA.ENVIO_EMAIL := NULL;
PI_NOVEDAD_CUENTA.CELULAR := NULL;
PI_NOVEDAD_CUENTA.ENVIO_SMS := NULL;
PI_NOVEDAD_TARJETA.NOVTIP := NULL;
PI_NOVEDAD_TARJETA.NOVNRO := NULL;
PI_NOVEDAD_TARJETA.NOVFCHING := NULL;
PI_NOVEDAD_TARJETA.NUMERO_CUENTA := NULL;
PI_NOVEDAD_TARJETA.TARJETA := NULL;
PI_NOVEDAD_TARJETA.APELLIDOS := NULL;
PI_NOVEDAD_TARJETA.NOMBRES := NULL;
PI_NOVEDAD_TARJETA.FECHA_NACIMIENTO := NULL;
PI_NOVEDAD_TARJETA.SEXO := NULL;
PI_NOVEDAD_TARJETA.ESTADO_CIVIL := NULL;
PI_NOVEDAD_TARJETA.CODIGO_OCUPACION := NULL;
PI_NOVEDAD_TARJETA.TIPO_DE_DOCUMENTO := NULL;
PI_NOVEDAD_TARJETA.DOCUMENTO := NULL;
PI_NOVEDAD_TARJETA.NOVRENOV := NULL;
PI_NOVEDAD_TARJETA.NOVANUORG := NULL;
PI_NOVEDAD_TARJETA.NOVANUBOL := NULL;
PI_NOVEDAD_TARJETA.NOVANUDEB := NULL;
PI_NOVEDAD_TARJETA.NOVSEC := NULL;
PI_NOVEDAD_TARJETA.NOVNROSEC := NULL;
PI_NOVEDAD_TARJETA.NOVGEN := NULL;
PI_NOVEDAD_TARJETA.FECHA_PROCESO := NULL;
PI_NOVEDAD_TARJETA.PIN_NEW := NULL;
PI_NOVEDAD_TARJETA.NOMBRE_PLASTICO := NULL;
PI_NOVEDAD_TARJETA.NOVPARAM_I := NULL;
PI_NOVEDAD_TARJETA.NOVPARAM_J := NULL;
PI_NOVEDAD_TARJETA.NOVPROM := NULL;
PI_NOVEDAD_TARJETA.NOVMOTDEV := NULL;
PI_NOVEDAD_TARJETA.EMISOR_CUENTA := NULL;
PI_NOVEDAD_TARJETA.SUCURSAL_CUENTA := NULL;
PI_NOVEDAD_TARJETA.NUEVO_ESTADO := NULL;
PI_NOVEDAD_TARJETA.NRO_DENUNCIA := NULL;
PI_NOVEDAD_TARJETA.ADICIONAL := NULL;
PI_NOVEDAD_TARJETA.ESTADO_OL := NULL;
PI_NOVEDAD_TARJETA.FECHA_ESTADO_OL := NULL;
PI_NOVEDAD_TARJETA.TARJETA_NUEVA := NULL;
PI_NOVEDAD_TARJETA.CODIGO_ORIGEN := NULL;
PI_NOVEDAD_TARJETA.REGLA_VALIDACION := NULL;
PI_NOVEDAD_TARJETA.FECHA_PROCESO_OL := NULL;
PI_NOVEDAD_TARJETA.FECHA_VIGENCIA := NULL;
PI_NOVEDAD_TARJETA.FECHA_VIGENCIA_NUEVA := NULL;
PI_NOVEDAD_TARJETA.NUEVO_ESTADO_OL := NULL;
PI_NOVEDAD_TARJETA.NUEVA_FECHA_ESTADO_OL := NULL;
END sp_InitNovedades;
PROCEDURE sp_get_tarjeta(PI_TARJETA IN CREDITOPY.TARJETAS.TARJETA%TYPE,
PR_TARJETAS OUT CREDITOPY.TARJETAS%ROWTYPE) AS
BEGIN
SELECT *
INTO PR_TARJETAS
FROM CREDITOPY.TARJETAS A
WHERE A.TARJETA = PI_TARJETA;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_REFLOG_PLSQL('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_TARJETA. La tarjeta no fue encontrada.' ||
' PI_TARJETA:' || PI_TARJETA,
SYSDATE);
RAISE_APPLICATION_ERROR(-20001,
'La tarjeta no fue encontrada. Tarjeta:' ||
CREDITOPY.FC_CRIPTO2PAN(PI_TARJETA));
WHEN OTHERS THEN
PR_REFLOG_PLSQL('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_TARJETA. Error al buscar la Tarjeta.' ||
' PI_TARJETA:' || PI_TARJETA,
SYSDATE);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar la Tarjeta. Tarjeta:' ||
CREDITOPY.FC_CRIPTO2PAN(PI_TARJETA));
END sp_get_tarjeta;
PROCEDURE sp_get_tarjeta_prepaga(PI_TARJETA IN CREDITOPY.TARJETAS.TARJETA%TYPE,
PR_TARJETAS_PREPAGA OUT CREDITOPY.TARJETAS_PREPAGA%ROWTYPE) AS
BEGIN
SELECT *
INTO PR_TARJETAS_PREPAGA
FROM CREDITOPY.TARJETAS_PREPAGA A
WHERE A.TARJETA = PI_TARJETA;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_CEIBO_LOG(CC_TIPO_DATO_LOG,
'GET_TARJ_PRE',
'PKG_DIMO_CEIBO.PR_GET_TARJETA_PREPAGA. La tarjeta no fue encontrada.' ||
' PI_TARJETA:' || PI_TARJETA,
SYSDATE,
CC_USUARIO_DIMO);
RAISE_APPLICATION_ERROR(-20001,
'La tarjeta PREPAGA no fue encontrada. Tarjeta:' ||
CREDITOPY.FC_CRIPTO2PAN(PI_TARJETA));
WHEN OTHERS THEN
PR_CEIBO_LOG(CC_TIPO_DATO_LOG,
'GET_TARJ_PRE',
'PKG_DIMO_CEIBO.PR_GET_TARJETA_PREPAGA. Error al buscar la Tarjeta.' ||
' PI_TARJETA:' || PI_TARJETA,
SYSDATE,
CC_USUARIO_DIMO);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar la Tarjeta Prepaga. Tarjeta:' ||
CREDITOPY.FC_CRIPTO2PAN(PI_TARJETA));
END sp_get_tarjeta_prepaga;
PROCEDURE sp_get_cuenta(PI_NUMERO_CUENTA IN CREDITOPY.CUENTAS.NUMERO_CUENTA%TYPE,
PR_CUENTAS OUT CREDITOPY.CUENTAS%ROWTYPE) AS
BEGIN
SELECT *
INTO PR_CUENTAS
FROM CREDITOPY.CUENTAS A
WHERE A.NUMERO_CUENTA = PI_NUMERO_CUENTA;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_REFLOG_PLSQL('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CUENTA. La cuenta no fue encontrada.' ||
' PI_NUMERO_CUENTA:' || PI_NUMERO_CUENTA,
SYSDATE);
RAISE_APPLICATION_ERROR(-20001,
'La cuenta no fue encontrada. Cuenta:' ||
PI_NUMERO_CUENTA);
WHEN OTHERS THEN
PR_REFLOG_PLSQL('WS',
'01',
'PKG_DIMO_CEIBO.PR_GET_CUENTA. Error al buscar la Cuenta.' ||
' PI_NUMERO_CUENTA:' || PI_NUMERO_CUENTA,
SYSDATE);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar la Cuenta. Cuenta:' ||
PI_NUMERO_CUENTA);
END sp_get_cuenta;
PROCEDURE sp_gen_cargos_de_novedad(PI_TARJETA IN CREDITOPY.TARJETAS.TARJETA%TYPE,
PI_TIPO_NOVEDAD IN CREDITOPY.NOVEDADES_CARGOS_TP.TIPO_NOVEDAD%TYPE,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
VN_CARGO_ID CREDITOPY.CODIGOS_CARGOS_GESTION_TP.CARGO_ID%TYPE;
VC_DESC_CORTA CREDITOPY.CODIGOS_CARGOS_GESTION_TP.DESC_CORTA%TYPE;
VN_RUBRO CREDITOPY.CARGOS_GESTION_PREPAGA.RUBRO%TYPE;
VN_IMPORTE NUMBER;
VN_CANT_CUOTAS NUMBER;
BEGIN
-- identificar cuantos cargos se tienen definidos para la novedad
FOR nov_cargos IN (SELECT *
FROM CREDITOPY.NOVEDADES_CARGOS_TP N
WHERE N.TIPO_NOVEDAD = PI_TIPO_NOVEDAD) LOOP
FOR cargos IN (SELECT CG.CARGO_ID,
CC.DESC_CORTA,
CG.IMPORTE,
CG.CANTIDAD_CUOTAS,
CG.RUBRO,
CG.APLICA_DESDE,
CC.MODO_APLICACION,
-- impresion tarjeta fisica
TP.CONTADOR_DE_IMPRESION --- ojo en que momento estoy tratando de registrar el cargo
FROM CREDITOPY.TARJETAS T,
CREDITOPY.TARJETAS_PREPAGA TP,
CREDITOPY.CODIGOS_CARGOS_GESTION_TP CC,
CREDITOPY.CARGOS_GESTION_PREPAGA CG
WHERE T.TARJETA = PI_TARJETA
AND TP.TARJETA = T.TARJETA
AND CC.CARGO_ID = nov_cargos.CARGO_ID
AND CG.CARGO_ID = CC.CARGO_ID
AND CG.GRUPO_AFINIDAD = T.GRUPO_AFINIDAD
AND CG.ID_TIPO_TARJETA_PREPAGA =
TP.ID_TIPO_TARJETA_PREPAGA
AND CG.CANTIDAD_CUOTAS > 0
AND CG.IMPORTE > 0) LOOP
VN_CARGO_ID := cargos.cargo_id;
VC_DESC_CORTA := cargos.desc_corta;
VN_RUBRO := cargos.rubro;
-- se analiza la aplicación de acuerdo al proceso
--Impresion de tarjeta fisica
CASE PI_TIPO_NOVEDAD
WHEN CC_NOVTIP_IMP_PLASTICO_TP THEN
IF cargos.contador_de_impresion + 1 > cargos.aplica_desde THEN
VN_IMPORTE := cargos.importe;
VN_CANT_CUOTAS := cargos.cantidad_cuotas;
ELSE
VN_IMPORTE := 0;
VN_CANT_CUOTAS := 0;
END IF;
ELSE
VN_IMPORTE := cargos.importe;
VN_CANT_CUOTAS := cargos.cantidad_cuotas;
END CASE;
-- AQUI INVOCAR AL PROCEDIMIENTO QUE REGISTRA EL CARGO
END LOOP;
END LOOP;
EXCEPTION
WHEN NO_DATA_FOUND THEN
PR_CEIBO_LOG(CC_TIPO_DATO_LOG,
'GET_CARGO',
'PKG_DIMO_CEIBO.PR_GET_DETALLE_CARGO. No hay parametro del cargo. Tipo Novedad:' ||
PI_TIPO_NOVEDAD,
SYSDATE,
CC_USUARIO_DIMO);
RAISE_APPLICATION_ERROR(-20001,
'No hay parametro del cargo. Tipo Novedad:' ||
PI_TIPO_NOVEDAD);
WHEN OTHERS THEN
PR_CEIBO_LOG(CC_TIPO_DATO_LOG,
'GET_CARGO',
'PKG_DIMO_CEIBO.PR_GET_DETALLE_CARGO. Error al buscar parametro del cargo. Tipo Novedad:' ||
PI_TIPO_NOVEDAD,
SYSDATE,
CC_USUARIO_DIMO);
RAISE_APPLICATION_ERROR(-20001,
'Error al buscar parametro del cargo. Tipo Novedad:' ||
PI_TIPO_NOVEDAD);
END sp_gen_cargos_de_novedad;
PROCEDURE sp_resguarda_datos_historico AS
BEGIN
-- resguardo los datos de la novedad antes de registrar y limpiar
VC_HISTORICO.NOVNRO := VR_HISTORICO.NOVNRO;
VC_HISTORICO.NOVTIP := VR_HISTORICO.NOVTIP;
VC_HISTORICO.NOVFCHING := VR_HISTORICO.NOVFCHING;
VC_HISTORICO.FECHA_REGISTRO := VR_HISTORICO.FECHA_REGISTRO;
VC_HISTORICO.NUMERO_CUENTA := VR_HISTORICO.NUMERO_CUENTA;
VC_HISTORICO.TARJETA := VR_HISTORICO.TARJETA;
VC_HISTORICO.TITULAR := VR_HISTORICO.TITULAR;
VC_HISTORICO.OPCION := VR_HISTORICO.OPCION;
VC_HISTORICO.TABLA := VR_HISTORICO.TABLA;
VC_HISTORICO.USUARIO := VR_HISTORICO.USUARIO;
VC_HISTORICO.DESPLEGAR := VR_HISTORICO.DESPLEGAR;
VC_HISTORICO.EMISOR := VR_HISTORICO.EMISOR;
VC_HISTORICO.NOVSEC := VR_HISTORICO.NOVSEC;
VC_HISTORICO.NOVGEN := VR_HISTORICO.NOVGEN;
END sp_resguarda_datos_historico;
PROCEDURE sp_registrar_hist_novedad AS
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
FOR IDX IN 1 .. VR_HISTORICOS.COUNT LOOP
INSERT INTO HISTORICO_CUENTAS@OLPY VALUES VR_HISTORICOS (IDX);
END LOOP;
COMMIT;
VR_HISTORICOS.DELETE;
END sp_registrar_hist_novedad;
PROCEDURE sp_rechazar_novedad AS
PRAGMA AUTONOMOUS_TRANSACTION;
BEGIN
PV_REGLA_ID := SOCIOS_MANTENIMIENTOS.FC_GET_REGLA_ID;
PV_MENSAJE := SOCIOS_MANTENIMIENTOS.FC_GET_MENSAJE;
--Motivo de Rechazo
VR_HISTORICO.TABLA := 'NOVEDADES_CUENTAS';
VR_HISTORICO.CAMPO := 'REGLA_VALIDACION';
IF SQLERRM IS NULL THEN
VR_HISTORICO.DATO_ANTERIOR := ' ';
ELSE
VR_HISTORICO.DATO_ANTERIOR := SUBSTR(SQLERRM, 1, 150);
END IF;
VR_HISTORICO.DATO_POSTERIOR := 'reglaId:' || PV_REGLA_ID || ' ' ||
PV_MENSAJE;
--Agregamos a la tabla de historicos.
VR_HISTORICOS((VR_HISTORICOS.COUNT + 1)) := VR_HISTORICO;
sp_registrar_hist_novedad;
UPDATE HISTORICO_CUENTAS@OLPY HC
SET HC.NOVGEN = '3'
WHERE HC.NOVTIP = VR_HISTORICO.NOVTIP
AND HC.NOVNRO = VR_HISTORICO.NOVNRO
AND HC.NOVFCHING = VR_HISTORICO.NOVFCHING;
COMMIT;
END sp_rechazar_novedad;
PROCEDURE sp_rechazar_solicitud(PI_ID_SOLICITUD IN SOLICITUDES_RECIBIDAS.ID_SOLICITUD_RECIBIDA%TYPE,
PI_REGLA_ID IN SOLICITUDES_MOTIVOS_RECHAZOS.REGLA_ID%TYPE,
PI_MOTIVO_RECHAZO IN SOLICITUDES_MOTIVOS_RECHAZOS.MOTIVO_RECHAZO%TYPE) AS
PRAGMA AUTONOMOUS_TRANSACTION;
VR_MOTIVOS_RECHAZOS CREDITOPY.SOLICITUDES_MOTIVOS_RECHAZOS%ROWTYPE;
BEGIN
SELECT SEQ_SS_MM_RECHAZOS.NEXTVAL
INTO VR_MOTIVOS_RECHAZOS.ID_MOTIVO_RECHAZO
FROM DUAL;
VR_MOTIVOS_RECHAZOS.ID_SOLICITUD_RECIBIDA := PI_ID_SOLICITUD;
VR_MOTIVOS_RECHAZOS.REGLA_ID := PI_REGLA_ID;
VR_MOTIVOS_RECHAZOS.MOTIVO_RECHAZO := PI_MOTIVO_RECHAZO;
INSERT INTO CREDITOPY.SOLICITUDES_MOTIVOS_RECHAZOS
VALUES VR_MOTIVOS_RECHAZOS;
UPDATE CREDITOPY.SOLICITUDES_RECIBIDAS u
SET U.CODIGO_RESPUESTA = -1
WHERE u.ID_SOLICITUD_RECIBIDA = PI_ID_SOLICITUD;
COMMIT;
END sp_rechazar_solicitud;
PROCEDURE sp_solicitudesUsuario(PI_DOCUMENTO IN VARCHAR2, -- Documento de Identidad
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
Autor: Edgar Rojas.
Fecha: 11/06/2020 16:50
Proposito: Consulta el estado de las solicitudes remitidas por los socios/clientes de DIMO.
Adaptado del sp_SeguimientosSolicitud por: Amalia Rodriguez
Fecha: 29/09/2020
Mejora: Se accede a todas las solicitudes de un usuario por su documento
*/
VR_SOLICITUD_RECIBIDA CREDITOPY.SOLICITUDES_RECIBIDAS%ROWTYPE;
BEGIN
VR_SOLICITUD_RECIBIDA.Documento := lpad(PI_DOCUMENTO, 12, '0');
/*SELECT *
INTO VR_SOLICITUD_RECIBIDA
FROM SOLICITUDES_RECIBIDAS SR
WHERE LPAD(SR.DOCUMENTO,12,'0') = VR_SOLICITUD_RECIBIDA.DOCUMENTO;*/
OPEN po_cursor FOR
-- solicitudes aprobadas
SELECT sr.id_solicitud_recibida AS id_solicitud_recibida,
c.solicitud AS solicitud,
--c.descripcion as descripcion_solicitud,
'Aprobada' AS resultado,
to_char(sr.fecha_registro, 'DD/MM/YYYY HH24:MI:SS') AS fecha_solicitud,
b.descripcion AS descripcion_estado_solicitud,
to_char(sr.fecha_estado, 'DD/MM/YYYY HH24:MI:SS') AS fecha_estado_solicitud,
sr.novedad AS codigo_novedad,
creditopy.fc_cripto2pan(sr.tarjeta) AS numero_tarjeta
FROM creditopy.solicitudes_recibidas sr,
creditopy.solicitudes c,
creditopy.solicitudes_estados b
WHERE lpad(sr.documento, 12, '0') = vr_solicitud_recibida.documento
AND sr.codigo_respuesta = 0
AND sr.id_solicitud = c.id_solicitud
AND sr.id_solicitud = b.id_solicitud
AND sr.id_estado = b.id_estado
UNION ALL
-- solicitudes rechazadas
SELECT sr.id_solicitud_recibida AS id_solicitud_recibida,
c.solicitud AS solicitud,
--c.descripcion as descripcion_solicitud,
'(' || x.regla_id || ') ' || x.motivo_rechazo AS resultado,
to_char(sr.fecha_registro, 'DD/MM/YYYY HH24:MI:SS') AS fecha_solicitud,
b.descripcion AS descripcion_estado_solicitud,
to_char(sr.fecha_estado, 'DD/MM/YYYY HH24:MI:SS') AS fecha_estado_solicitud,
sr.novedad AS codigo_novedad,
creditopy.fc_cripto2pan(sr.tarjeta) AS numero_tarjeta
FROM creditopy.solicitudes_recibidas sr,
creditopy.solicitudes c,
creditopy.solicitudes_estados b,
creditopy.solicitudes_motivos_rechazos x
WHERE lpad(sr.documento, 12, '0') = vr_solicitud_recibida.documento
AND sr.codigo_respuesta > 0
AND sr.id_solicitud = c.id_solicitud
AND sr.id_solicitud = b.id_solicitud
AND sr.id_estado = b.id_estado
AND sr.id_solicitud_recibida = x.id_solicitud_recibida
ORDER BY id_solicitud_recibida DESC, resultado;
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END sp_solicitudesUsuario;
PROCEDURE sp_pedidoImpresionTarjetaDimo(PI_NUMERO_TARJETA IN VARCHAR2, -- Numero de la Tarjeta que debe ser Impresa
PI_PAIS IN NUMBER, -- Codigo de pais. Se obtuvo de la lista de ciudades.
PI_DEPARTAMENTO IN NUMBER, -- Codigo de departamento. Se obtuvo de la lista de ciudades.
PI_CIUDAD IN NUMBER, -- Codigo de la ciudad de entrega. Se obtuvo de la lista de ciudades.
PI_DIRECCION IN VARCHAR2, -- Direccion de envio de la tarjeta
PI_NOMBRE_APELLIDO_CONTACTO IN VARCHAR2, -- Nombre del contacto
PI_TELEFONO_CONTACTO IN VARCHAR2, -- Telefono del contacto
PI_MAIL_CONTACTO IN VARCHAR2, -- Direccion de correo del contacto
PI_ID_TIPO_TARJETA IN NUMBER, -- Numero de Id del tipo de tarjeta
PI_NOMBRE_PLASTICO IN VARCHAR2, -- El nombre que se utiliza para imprimir el plastico
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
9.1- Pedido de plastico tarjeta DIMO (El usuario quiere el plastico) y
especifica lugar entrega
Adaptado del PKG_SICOOP_DIMO.
Ajustes a invocacion para el backend DIMO: A.Rodriguez. 10/06/2020.
*/
/*
Autor: Edgar Rojas.
Fecha:18/03/2020
Proposito: El usuario no imprimió su tarjeta y requiere la tarjeta física.
Pedido de plastico (El usuario quiere el plastico) y especifica lugar entrega.
Referencia: API_SICOOP-CEIBO(postrevision).xlsx. Hoja 9-Pedido de plastico
*/
VN_IS_PREPAGA NUMBER := 0;
VC_TARJETA VARCHAR2(19);
VC_NOMBRE_PARA_PLASTICO creditopy.TARJETAS.nombre_para_plastico%TYPE;
VN_ORI_ESTADO_PLASTICO creditopy.TARJETAS_PREPAGA.estado_plastico%TYPE;
VN_ESTADO_PLASTICO creditopy.TARJETAS_PREPAGA.estado_plastico%TYPE;
VD_FECHA_VIG_PLASTICO DATE;
VN_ID_TIPO_TARJETA creditopy.TARJETAS_PREPAGA.id_tipo_tarjeta_prepaga%TYPE;
VR_IMP_TARJETA creditopy.IMP_TARJETAS%ROWTYPE;
VD_FECHA_ULT_ACTUALIZACION DATE := SYSDATE;
/*-- variables para el cargo
VN_CARGO_ID CREDITOPY.CARGOS_GESTION_PREPAGA.CARGO_ID%TYPE;
VC_CARGO_DESC_CORTA CREDITOPY.CODIGOS_CARGOS_GESTION_TP.DESC_CORTA%TYPE;
VN_CARGO_IMPORTE CREDITOPY.CARGOS_GESTION_PREPAGA.IMPORTE%TYPE:=0;
VN_CARGO_CANTIDAD_CUOTAS CREDITOPY.CARGOS_GESTION_PREPAGA.CANTIDAD_CUOTAS%TYPE;
VN_CARGO_RUBRO CREDITOPY.CARGOS_GESTION_PREPAGA.RUBRO%TYPE;
*/
-- variables para la solicitud
VR_SOLICITUD SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS SOLICITUDES_DATOS%ROWTYPE;
VN_IMPRIME_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 2;
VN_IMPRIME_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 3;
BEGIN
--#1ro Registrar los datos del historico
--#2do Registrar la solicitud de seguimiento correspondiente
-- si ok:
-- #3ro Registrar la impresion de tarjeta y el historico
-- #4to Registrar el costo de impresion del plastico
-- sino
-- marcar en el historico la novedad como rechazada
-- registrar el rechazo en la solicitud de seguimiento
-- se valida que sea una tarjeta prepaga antes de continuar
BEGIN
SELECT creditopy.pkg_dimo_ceibo.fn_is_prepaga(t.emisor)
INTO vn_is_prepaga
FROM creditopy.tarjetas t
WHERE t.tarjeta = creditopy.fc_pan2cripto(PI_NUMERO_TARJETA);
EXCEPTION
-- no puede darse por valido si es no_data_found porque debio pasar por
-- las validaciones previas
WHEN no_data_found THEN
raise_application_error(-20001, 'Tarjeta invalida.');
WHEN OTHERS THEN
RAISE;
END;
-- FALTA VALIDAR LOS DATOS DE ENTRADA!!!
--Datos de la tarjeta
-- obtener tarjeta encriptada
VC_TARJETA := FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
-- obtener datos de la tarjeta
VR_TARJETA := NULL;
VR_TARJETAS_PREPAGA := NULL;
sp_get_tarjeta(VC_TARJETA, VR_TARJETA);
sp_get_tarjeta_prepaga(VC_TARJETA, VR_TARJETAS_PREPAGA);
-- obtener datos de la cuenta
sp_get_cuenta(VR_TARJETA.NUMERO_CUENTA, VR_CUENTA);
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
--Obtener la numero de novedad.
VR_NOVEDAD_CUENTA.NOVNRO := FN_GET_NRO_NOVEDAD;
VR_NOVEDAD_CUENTA.NOVFCHING := VD_FECHA_ULT_ACTUALIZACION;
-- datos de IMP_TARJETAS
VR_IMP_TARJETA.FECHA_ALTA := TRUNC(VD_FECHA_ULT_ACTUALIZACION);
VR_IMP_TARJETA.TARJETA := VC_TARJETA;
VR_IMP_TARJETA.TIPO_CODIGO := 1;
VR_IMP_TARJETA.COD_ORIGEN := CC_ORIGEN_IMP_PLASTICO_TP;
VR_IMP_TARJETA.TIPO_NOVEDAD := CC_NOVTIP_IMP_PLASTICO_TP;
VR_IMP_TARJETA.FORMULARIO := VR_NOVEDAD_CUENTA.NOVNRO;
VR_IMP_TARJETA.FECHA_FORMULARIO := VD_FECHA_ULT_ACTUALIZACION;
VR_IMP_TARJETA.USUARIO_ALTA := CC_USUARIO_DIMO;
-- Datos nuevos del plastico
--VC_NOMBRE_PARA_PLASTICO := PI_NOMBRE_PLASTICO;
--VC_NOMBRE_PARA_PLASTICO := VR_TARJETA.NOMBRE_PARA_PLASTICO;-- SE FUERZA TOMAR EL DATO NORMALIZADO DE TARJETAS HG/AR 01/07/2020 10:20
--Filtro de Nombre Plastio ingresado por el Usuario.
--ER 202006301425.
VC_NOMBRE_PARA_PLASTICO := FC_FILTRAR_NOMPLA(PI_NOMBRE_PLASTICO);
--VC_NOMBRE_PARA_PLASTICO := FC_FILTRAR_NOMPLA(VC_NOMBRE_PARA_PLASTICO);
VN_ID_TIPO_TARJETA := PI_ID_TIPO_TARJETA;
VD_FECHA_VIG_PLASTICO := creditopy.PKG_DIMO_CEIBO.fn_get_vigencia_tp_fisica(VR_TARJETA.EMISOR,
VN_ID_TIPO_TARJETA,
VR_IMP_TARJETA.FECHA_ALTA);
VN_ORI_ESTADO_PLASTICO := VR_TARJETAS_PREPAGA.ESTADO_PLASTICO;
VN_ESTADO_PLASTICO := CC_ESTADO_TP_EN_PROCESO;
-- datos de TARJETAS_PREPAGA
VR_TARJETAS_PREPAGA.FECHA_SOLIC_PLASTICO := VR_IMP_TARJETA.FECHA_ALTA;
VR_TARJETAS_PREPAGA.FORMULARIO_SOLIC_PLASTICO := VR_IMP_TARJETA.FORMULARIO;
VR_TARJETAS_PREPAGA.FECHA_ESTADO := VR_TARJETAS_PREPAGA.FECHA_SOLIC_PLASTICO;
VR_TARJETAS_PREPAGA.FECHA_ULT_ACTUALIZACION := VD_FECHA_ULT_ACTUALIZACION;
VR_TARJETAS_PREPAGA.ID_TIPO_TARJETA_PREPAGA := VN_ID_TIPO_TARJETA;
VR_TARJETAS_PREPAGA.FECHA_VIG_PLASTICO := VD_FECHA_VIG_PLASTICO;
VR_TARJETAS_PREPAGA.ESTADO_PLASTICO := VN_ESTADO_PLASTICO;
VR_TARJETAS_PREPAGA.CONTADOR_DE_IMPRESION := VR_TARJETAS_PREPAGA.CONTADOR_DE_IMPRESION + 1;
-- datos de TARJETAS
VR_TARJETA.NOMBRE_PARA_PLASTICO := VC_NOMBRE_PARA_PLASTICO;
-- 08/07/2020. AR. Se debe ajustar la vigencia de la tarjeta virtual
IF VR_TARJETAS_PREPAGA.FECHA_VIG_PLASTICO > VR_TARJETA.FECHA_VIGENCIA THEN
VR_TARJETA.FECHA_VIGENCIA := VR_TARJETAS_PREPAGA.FECHA_VIG_PLASTICO;
END IF;
--Registramos los datos para la solicitud de impresion del plastico
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_PLASTICO_DIMO;
VR_SOLICITUD.ID_ESTADO := VN_IMPRIME_OK;
VR_SOLICITUD.NOVEDAD := VR_IMP_TARJETA.FORMULARIO;
VR_SOLICITUD.TARJETA := PI_NUMERO_TARJETA;
VR_SOLICITUD.USUARIO := CC_USUARIO_DIMO;
VR_SOLICITUD.DOCUMENTO := TRIM(LEADING '0' FROM
SUBSTR(VR_TARJETA.DOCUMENTO, 4, 12));
VR_DATOS.PAIS := PI_PAIS;
VR_DATOS.DEPARTAMENTO := PI_DEPARTAMENTO;
VR_DATOS.CIUDAD := PI_CIUDAD;
VR_DATOS.DIRECCION := PI_DIRECCION;
VR_DATOS.NOMBRE_APELLIDO_CONTACTO := PI_NOMBRE_APELLIDO_CONTACTO;
VR_DATOS.TELEFONO_CONTACTO := PI_TELEFONO_CONTACTO;
VR_DATOS.EMAIL_CONTACTO := PI_MAIL_CONTACTO;
VR_DATOS.ID_TIPO_TARJETA_PREPAGA := PI_ID_TIPO_TARJETA;
--VR_DATOS.NOMBRE_PARA_PLASTICO := PI_NOMBRE_PLASTICO;
VR_DATOS.NOMBRE_PARA_PLASTICO := VC_NOMBRE_PARA_PLASTICO;
-- Utilizo este dato para validar vigencia y el estado de la tarjeta fisica
VR_DATOS.CICLO_ACTUAL := VN_ORI_ESTADO_PLASTICO;
VR_DATOS.FECHA_FINAL := VD_FECHA_VIG_PLASTICO;
PR_SOLICITUDES(VR_SOLICITUD, VR_DATOS);
IF VR_SOLICITUD.ID_ESTADO = VN_IMPRIME_OK AND
VR_SOLICITUD.CODIGO_RESPUESTA = 0 THEN
--Actualizamos los datos en TARJETAS y TARJETAS_PREPAGA
UPDATE TARJETAS T
SET T.NOMBRE_PARA_PLASTICO = VR_TARJETA.NOMBRE_PARA_PLASTICO,
T.FECHA_VIGENCIA = VR_TARJETA.FECHA_VIGENCIA, -- 08/07/2020. AR. Se debe ajustar la vigencia de la tarjeta virtual
T.ULT_ACTUALIZACION = VD_FECHA_ULT_ACTUALIZACION,
T.OPERADOR = VR_IMP_TARJETA.USUARIO_ALTA
WHERE T.TARJETA = VR_TARJETA.TARJETA;
UPDATE TARJETAS_PREPAGA TP
SET TP.ID_TIPO_TARJETA_PREPAGA = VR_TARJETAS_PREPAGA.ID_TIPO_TARJETA_PREPAGA,
TP.FECHA_SOLIC_PLASTICO = VR_TARJETAS_PREPAGA.FECHA_SOLIC_PLASTICO,
TP.FORMULARIO_SOLIC_PLASTICO = VR_TARJETAS_PREPAGA.FORMULARIO_SOLIC_PLASTICO,
TP.ESTADO_PLASTICO = VR_TARJETAS_PREPAGA.ESTADO_PLASTICO,
TP.FECHA_ESTADO = VR_TARJETAS_PREPAGA.FECHA_ESTADO,
TP.FECHA_VIG_PLASTICO = VR_TARJETAS_PREPAGA.FECHA_VIG_PLASTICO,
TP.CONTADOR_DE_IMPRESION = VR_TARJETAS_PREPAGA.CONTADOR_DE_IMPRESION,
TP.FECHA_ULT_ACTUALIZACION = VD_FECHA_ULT_ACTUALIZACION
WHERE TP.TARJETA = VR_TARJETAS_PREPAGA.TARJETA;
--Registrar en ImpTarjetas para su impresion.
INSERT INTO IMP_TARJETAS VALUES VR_IMP_TARJETA;
--Actualizamos los datos de direccion de envio TIPO_DE_DIRECCION = 1
UPDATE CREDITOPY.DIRECCIONES D
SET D.CALLE = VR_DATOS.DIRECCION,
D.PAIS = VR_DATOS.PAIS,
D.DEPARTAMENTO = VR_DATOS.DEPARTAMENTO,
D.CIUDAD = VR_DATOS.CIUDAD,
D.BARRIO = ' ',
D.TELEFONO = VR_DATOS.TELEFONO_CONTACTO
WHERE D.NUMERO_CUENTA = VR_TARJETA.NUMERO_CUENTA
AND D.TIPO_DE_DIRECCION = 1;
--Registramos el cargo por la impresion
-- Si el usuario tiene el disponible se registra para la actualizacion del saldo
-- y el correspondiente movimiento de ajuste
-- sino se deja en un modulo de cargos pendientes de aplicar por falta de disponible
END IF;
COMMIT;
IF VR_SOLICITUD.CODIGO_RESPUESTA != 0 THEN
po_sqlcode := VR_SOLICITUD.CODIGO_RESPUESTA;
po_sqlerrm := fn_get_ult_rechazo_solicitud(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.CODIGO_RESPUESTA);
ELSE
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END IF;
OPEN po_cursor FOR
SELECT decode(VR_SOLICITUD.CODIGO_RESPUESTA,
0,
0,
nvl(VR_SOLICITUD.NOVEDAD, 0)) AS CODIGO_NOVEDAD,
VR_SOLICITUD.ID_SOLICITUD_RECIBIDA AS ID_SOLICITUD,
VR_SOLICITUD.CODIGO_RESPUESTA AS CODIGO_RESPUESTA,
decode(VR_SOLICITUD.CODIGO_RESPUESTA, 0, ' ', PO_SQLERRM) AS GLOSA_RESPUESTA
FROM dual;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
IF VR_SOLICITUD.ID_SOLICITUD_RECIBIDA IS NOT NULL THEN
VR_SOLICITUD.ID_ESTADO := VN_IMPRIME_RECHA;
PR_ADM_ERROR_SOLICITUD(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.ID_ESTADO,
SQLCODE,
SQLERRM);
END IF;
ROLLBACK;
OPEN po_cursor FOR
SELECT nvl(VR_NOVEDAD_CUENTA.NOVNRO, 0) AS CODIGO_NOVEDAD,
nvl(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA, 0) AS ID_SOLICITUD,
po_sqlcode AS CODIGO_RESPUESTA,
po_sqlerrm AS GLOSA_RESPUESTA
FROM dual;
END sp_pedidoImpresionTarjetaDimo;
PROCEDURE sp_tiposTarjetaPrepaga(PI_EMISOR IN NUMBER,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
9.1a-Obtener tipos de tarjeta fisica
*/
/****************************************************************************************************
Autor: Hugo Gonzalez.
Fecha: 10/06/2019
Propósito: Procedimiento que devuelve un cursor con los datos de los tipod de plastico de
las tarjetas prepagas.
******************************************************************************************************/
BEGIN
OPEN po_cursor FOR
SELECT emisor, tipo_tarjeta, id_tipo_tarjeta_prepaga id_tipo_tarjeta
FROM creditopy.TIPOS_TARJETA_PREPAGA
WHERE emisor = pi_emisor
AND desplegar = 1;
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END sp_tiposTarjetaPrepaga;
PROCEDURE sp_ciudades(PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cur_departamentos OUT SYS_REFCURSOR,
po_cur_ciudades OUT SYS_REFCURSOR) AS
/*
9.3 - Obtener ciudades
*/
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 25/05/2020
Propósito: Función que retorna la lista de ciudades requerimientos de cuenta/tarjeta prepaga.
No es valida para TC porque no tiene normalizados los datos de pais/departamento al alta.
******************************************************************************************************/
BEGIN
OPEN po_cur_departamentos FOR
SELECT d.departamento AS id, d.descripcion AS descripcion
FROM debcredpy.departamentos d
WHERE d.pais = 1
ORDER BY d.pais, d.departamento;
OPEN po_cur_ciudades FOR
SELECT c.ciudad AS id,
c.descripcion AS descripcion,
c.departamento AS id_Departamento
FROM debcredpy.ciudades c
WHERE c.pais = 1
AND c.codigo_postal = 2 -- 2 = Igual a Nuevo set de Ciudades actualizadas
ORDER BY c.pais, c.departamento, c.ciudad;
/*
Open po_cursor for
select ci.pais AS pais,
ci.departamento AS departamento,
ci.ciudad AS ciudad,
ci.descripcion AS ciudad_descripcion,
d.descripcion AS departamento_descripcion
from debcredpy.ciudades ci
left join debcredpy.departamentos d on d.pais = ci.pais and
d.departamento = ci.departamento
where ci.codigo_postal = 2
order by ci.descripcion, d.descripcion;
*/
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_Ciudades;
PROCEDURE sp_paises(
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
21.2 - Obtener países
*/
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 24/08/2020
Propósito: Función que retorna la lista de paises parametrizados.
******************************************************************************************************/
BEGIN
OPEN po_cursor FOR
SELECT p.pais AS pais, p.descripcion AS pais_descripcion
FROM debcredpy.paises p
ORDER BY p.descripcion;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END;
PROCEDURE sp_activarPlasticoDimo(PI_NUMERO_TARJETA IN VARCHAR2, -- Numero de la Tarjeta fisica que se desea activar
PI_CVV IN VARCHAR2, -- CVV de la tarjeta para verificacion
PI_PIN_TARJETA IN VARCHAR2, -- PIN indicado por el usuario para la tarjeta, encriptado
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
9.4 - Activar tarjeta fisica DIMO
Adaptado del PKG_SICOOP_CEIBO.
Ajustes a invocacion para el backend DIMO: A.Rodriguez. 22/06/2020
*/
/*
Autor : Edgar Rojas.
Fecha : 19/06/2020 12:50
Proposito : Activar el plastico DIMO impreso recibido por el Usuario.
Referencia: No existe aun
*/
VR_SOLICITUD SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS SOLICITUDES_DATOS%ROWTYPE;
VC_TARJETA VARCHAR2(19);
VN_ACTIVAR_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 56;
VN_ACTIVAR_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 57;
BEGIN
--Datos DIMO
PV_USUARIO := get_usuario;
--Datos de la Tarjeta
-- obtener tarjeta encriptada
VC_TARJETA := FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
-- obtener datos de la tarjeta
VR_TARJETA := NULL;
VR_TARJETAS_PREPAGA := NULL;
sp_get_tarjeta(VC_TARJETA, VR_TARJETA);
sp_get_tarjeta_prepaga(VC_TARJETA, VR_TARJETAS_PREPAGA);
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
--Registramos los datos para la activacion del plastico
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_ACTIVAR_P_DIMO;
VR_SOLICITUD.ID_ESTADO := VN_ACTIVAR_OK;
VR_SOLICITUD.NOVEDAD := 0;
VR_SOLICITUD.TARJETA := PI_NUMERO_TARJETA;
VR_SOLICITUD.USUARIO := PV_USUARIO; --CC_USUARIO_DIMO;
VR_SOLICITUD.DOCUMENTO := TRIM(LEADING '0' FROM
SUBSTR(VR_TARJETA.DOCUMENTO, 4, 12));
--Utilizamos estos campos para controlar el CVV mediante las reglas de la Novedad.
CREDITOPY.PCUTILES.GET_PAN_CRIPTOKEY;
CREDITOPY.PCUTILES.PR_INIT_BIN_EMISORES;
VR_DATOS.PAIS := PI_CVV;
VR_DATOS.DEPARTAMENTO := CS.GET_CVC(CEIBO_UTILES.FN_GET_EMISOR_PROCESADOR(VR_TARJETA.EMISOR),
VR_TARJETAS_PREPAGA.TARJETA,
VR_TARJETAS_PREPAGA.FECHA_VIG_PLASTICO,
2);
PR_SOLICITUDES(VR_SOLICITUD, VR_DATOS);
--Calcular el CVV y registrarlo en los datos para su control.
IF VR_SOLICITUD.ID_ESTADO = VN_ACTIVAR_OK AND
VR_SOLICITUD.CODIGO_RESPUESTA = 0 THEN
VR_TARJETA.PIN := RPAD(PI_PIN_TARJETA, 16, 0);
VR_TARJETA.PIN := PCUTILES.DESF('E',
'ADCF8073FAD1CF55',
VR_TARJETA.PIN);
UPDATE TARJETAS T
SET T.PIN = VR_TARJETA.PIN,
T.OPERADOR = substr(PV_USUARIO, 8),
T.ULT_ACTUALIZACION = SYSDATE
WHERE T.TARJETA = VR_TARJETA.TARJETA;
UPDATE TARJETAS_PREPAGA TP
SET TP.ESTADO_PLASTICO = CC_ESTADO_TP_OPERATIVA,
TP.FECHA_VIG_PIN = VR_TARJETAS_PREPAGA.FECHA_VIG_PLASTICO,
TP.FECHA_ULT_ACTUALIZACION = SYSDATE
WHERE TP.TARJETA = VR_TARJETA.TARJETA;
END IF;
COMMIT;
IF VR_SOLICITUD.CODIGO_RESPUESTA != 0 THEN
po_sqlcode := VR_SOLICITUD.CODIGO_RESPUESTA;
po_sqlerrm := fn_get_ult_rechazo_solicitud(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.CODIGO_RESPUESTA);
ELSE
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END IF;
OPEN po_cursor FOR
SELECT decode(VR_SOLICITUD.CODIGO_RESPUESTA,
0,
0,
nvl(VR_SOLICITUD.NOVEDAD, 0)) AS CODIGO_NOVEDAD,
VR_SOLICITUD.ID_SOLICITUD_RECIBIDA AS ID_SOLICITUD,
VR_SOLICITUD.CODIGO_RESPUESTA AS CODIGO_RESPUESTA,
decode(VR_SOLICITUD.CODIGO_RESPUESTA, 0, ' ', PO_SQLERRM) AS GLOSA_RESPUESTA
FROM dual;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
IF VR_SOLICITUD.ID_SOLICITUD_RECIBIDA IS NOT NULL THEN
VR_SOLICITUD.ID_ESTADO := VN_ACTIVAR_RECHA;
PR_ADM_ERROR_SOLICITUD(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.ID_ESTADO,
SQLCODE,
SQLERRM);
END IF;
ROLLBACK;
OPEN po_cursor FOR
SELECT nvl(VR_NOVEDAD_CUENTA.NOVNRO, 0) AS CODIGO_NOVEDAD,
nvl(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA, 0) AS ID_SOLICITUD,
po_sqlcode AS CODIGO_RESPUESTA,
po_sqlerrm AS GLOSA_RESPUESTA
FROM dual;
END sp_activarPlasticoDimo;
PROCEDURE sp_modificarPinDimo(PI_NUMERO_TARJETA IN VARCHAR2, -- Numero de la Tarjeta
PI_PIN_TARJETA IN VARCHAR2, -- PIN indicado por el usuario para la tarjeta, encriptado
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
10.2 - Modificación del PIN de tarjeta física DIMO
Adaptado del PKG_SICOOP_CEIBO.
Ajustes a invocacion para el backend DIMO: A.Rodriguez. 22/06/2020
*/
/*
Autor : Edgar Rojas.
Fecha : 18/06/2020 09:50
Proposito : Operaciones TP - Actualización de PIN personalizado.
Referencia: API_TARJETAHABIENTE. google Drive Hoja 10.2 - Modificación del PIN de tarjeta física DIMO
*/
VR_SOLICITUD SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS SOLICITUDES_DATOS%ROWTYPE;
VR_TARJETA TARJETAS%ROWTYPE;
VC_TARJETA VARCHAR2(19);
VN_MOD_PIN_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 54;
VN_MOD_PIN_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 55;
BEGIN
--Datos DIMO
PV_USUARIO := get_usuario;
--Datos de la Tarjeta
-- obtener tarjeta encriptada
VC_TARJETA := FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
-- obtener datos de la tarjeta
VR_TARJETA := NULL;
VR_TARJETAS_PREPAGA := NULL;
sp_get_tarjeta(VC_TARJETA, VR_TARJETA);
sp_get_tarjeta_prepaga(VC_TARJETA, VR_TARJETAS_PREPAGA);
--Registramos los datos para la activacion del plastico
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_ACTUALIZAR_PIN;
VR_SOLICITUD.ID_ESTADO := VN_MOD_PIN_OK;
VR_SOLICITUD.NOVEDAD := 0;
VR_SOLICITUD.TARJETA := PI_NUMERO_TARJETA;
VR_SOLICITUD.USUARIO := PV_USUARIO; --CC_USUARIO_DIMO;
VR_SOLICITUD.DOCUMENTO := TRIM(LEADING '0' FROM
SUBSTR(VR_TARJETA.DOCUMENTO, 4, 12));
IF PI_PIN_TARJETA IS NULL THEN
RAISE_APPLICATION_ERROR(-20001, 'El Pin no ha sido ingresado.');
END IF;
PR_SOLICITUDES(VR_SOLICITUD, VR_DATOS);
IF VR_SOLICITUD.ID_ESTADO = VN_MOD_PIN_OK AND
VR_SOLICITUD.CODIGO_RESPUESTA = 0 THEN
VR_TARJETA.PIN := RPAD(PI_PIN_TARJETA, 16, 0);
VR_TARJETA.PIN := PCUTILES.DESF('E',
'ADCF8073FAD1CF55',
VR_TARJETA.PIN);
UPDATE TARJETAS T
SET T.PIN = VR_TARJETA.PIN,
T.OPERADOR = SUBSTR(PV_USUARIO, 1, 8),
T.ULT_ACTUALIZACION = SYSDATE
WHERE T.TARJETA = VR_TARJETA.TARJETA;
UPDATE TARJETAS_PREPAGA TP
SET TP.FECHA_VIG_PIN = VR_TARJETAS_PREPAGA.FECHA_VIG_PLASTICO,
TP.FECHA_ULT_ACTUALIZACION = SYSDATE
WHERE TP.TARJETA = VR_TARJETAS_PREPAGA.TARJETA;
END IF;
COMMIT;
IF VR_SOLICITUD.CODIGO_RESPUESTA != 0 THEN
po_sqlcode := VR_SOLICITUD.CODIGO_RESPUESTA;
po_sqlerrm := fn_get_ult_rechazo_solicitud(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.CODIGO_RESPUESTA);
ELSE
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END IF;
OPEN po_cursor FOR
SELECT decode(VR_SOLICITUD.CODIGO_RESPUESTA,
0,
0,
nvl(VR_SOLICITUD.NOVEDAD, 0)) AS CODIGO_NOVEDAD,
VR_SOLICITUD.ID_SOLICITUD_RECIBIDA AS ID_SOLICITUD,
VR_SOLICITUD.CODIGO_RESPUESTA AS CODIGO_RESPUESTA,
decode(VR_SOLICITUD.CODIGO_RESPUESTA, 0, ' ', PO_SQLERRM) AS GLOSA_RESPUESTA
FROM dual;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
IF VR_SOLICITUD.ID_SOLICITUD_RECIBIDA IS NOT NULL THEN
VR_SOLICITUD.ID_ESTADO := VN_MOD_PIN_RECHA;
PR_ADM_ERROR_SOLICITUD(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.ID_ESTADO,
SQLCODE,
SQLERRM);
END IF;
ROLLBACK;
OPEN po_cursor FOR
SELECT nvl(VR_NOVEDAD_CUENTA.NOVNRO, 0) AS CODIGO_NOVEDAD,
nvl(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA, 0) AS ID_SOLICITUD,
po_sqlcode AS CODIGO_RESPUESTA,
po_sqlerrm AS GLOSA_RESPUESTA
FROM dual;
END sp_modificarPinDimo;
PROCEDURE sp_modificarPinTC(PI_NUMERO_TARJETA IN VARCHAR2, -- Numero de la Tarjeta
PI_PIN_TARJETA IN VARCHAR2, -- PIN indicado por el usuario para la tarjeta, encriptado
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
10.2 - Modificación del PIN de tarjeta de credito
Adaptado del sp_modificacionPinDIMO. A.Rodriguez. 16/11/2020
*/
VR_SOLICITUD SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS SOLICITUDES_DATOS%ROWTYPE;
VR_TARJETA TARJETAS%ROWTYPE;
VC_TARJETA VARCHAR2(19);
VN_MOD_PIN_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 73;
VN_MOD_PIN_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 74;
BEGIN
--Datos DIMO
PV_USUARIO := get_usuario;
--Datos de la Tarjeta
-- obtener tarjeta encriptada
VC_TARJETA := FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
-- obtener datos de la tarjeta
VR_TARJETA := NULL;
sp_get_tarjeta(VC_TARJETA, VR_TARJETA);
--Registramos los datos para la activacion del plastico
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_ACTUALIZAR_PIN_TC;
VR_SOLICITUD.ID_ESTADO := VN_MOD_PIN_OK;
VR_SOLICITUD.NOVEDAD := 0;
VR_SOLICITUD.TARJETA := PI_NUMERO_TARJETA;
VR_SOLICITUD.USUARIO := PV_USUARIO; --CC_USUARIO_DIMO;
VR_SOLICITUD.DOCUMENTO := TRIM(LEADING '0' FROM
SUBSTR(VR_TARJETA.DOCUMENTO, 4, 12));
IF PI_PIN_TARJETA IS NULL THEN
RAISE_APPLICATION_ERROR(-20001, 'El Pin no ha sido ingresado.');
END IF;
PR_SOLICITUDES(VR_SOLICITUD, VR_DATOS);
IF VR_SOLICITUD.ID_ESTADO = VN_MOD_PIN_OK AND
VR_SOLICITUD.CODIGO_RESPUESTA = 0 THEN
VR_TARJETA.PIN := RPAD(PI_PIN_TARJETA, 16, 0);
VR_TARJETA.PIN := PCUTILES.DESF('E',
'ADCF8073FAD1CF55',
VR_TARJETA.PIN);
UPDATE TARJETAS T
SET T.PIN = VR_TARJETA.PIN,
T.OPERADOR = SUBSTR(PV_USUARIO, 1, 8),
T.ULT_ACTUALIZACION = SYSDATE
WHERE T.TARJETA = VR_TARJETA.TARJETA;
END IF;
COMMIT;
IF VR_SOLICITUD.CODIGO_RESPUESTA != 0 THEN
po_sqlcode := VR_SOLICITUD.CODIGO_RESPUESTA;
po_sqlerrm := fn_get_ult_rechazo_solicitud(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.CODIGO_RESPUESTA);
ELSE
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END IF;
OPEN po_cursor FOR
SELECT decode(VR_SOLICITUD.CODIGO_RESPUESTA,
0,
0,
nvl(VR_SOLICITUD.NOVEDAD, 0)) AS CODIGO_NOVEDAD,
VR_SOLICITUD.ID_SOLICITUD_RECIBIDA AS ID_SOLICITUD,
VR_SOLICITUD.CODIGO_RESPUESTA AS CODIGO_RESPUESTA,
decode(VR_SOLICITUD.CODIGO_RESPUESTA, 0, ' ', PO_SQLERRM) AS GLOSA_RESPUESTA
FROM dual;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
IF VR_SOLICITUD.ID_SOLICITUD_RECIBIDA IS NOT NULL THEN
VR_SOLICITUD.ID_ESTADO := VN_MOD_PIN_RECHA;
PR_ADM_ERROR_SOLICITUD(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.ID_ESTADO,
SQLCODE,
SQLERRM);
END IF;
ROLLBACK;
OPEN po_cursor FOR
SELECT nvl(VR_NOVEDAD_CUENTA.NOVNRO, 0) AS CODIGO_NOVEDAD,
nvl(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA, 0) AS ID_SOLICITUD,
po_sqlcode AS CODIGO_RESPUESTA,
po_sqlerrm AS GLOSA_RESPUESTA
FROM dual;
END sp_modificarPinTC;
PROCEDURE sp_modificacionPinDimo(PI_NUMERO_TARJETA IN VARCHAR2, -- Numero de la Tarjeta
PI_PIN_TARJETA IN VARCHAR2, -- PIN indicado por el usuario para la tarjeta, encriptado
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
10.2 - Modificación del PIN de tarjeta
Se adapta de forma que se utilice el mismo end-point y se deriva al
procedimiento correspondiente a DIMO o a TC.
Ajustes a invocacion para el backend DIMO: A.Rodriguez. 16/11/2020
*/
VC_TARJETA VARCHAR2(19);
VN_EMISOR NUMBER;
BEGIN
-- obtener datos DIMO
PV_USUARIO := get_usuario;
-- validar parametros de entrada no nulos
IF PI_NUMERO_TARJETA IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: tarjeta is null.');
ELSE
IF PI_PIN_TARJETA IS NULL THEN
RAISE_APPLICATION_ERROR(-20001, 'El Pin no ha sido ingresado.');
END IF;
END IF;
VC_TARJETA := creditopy.FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
-- verificar si el emisor de la tarjeta es un emisor PREPAGO o no
BEGIN
SELECT t.emisor
INTO VN_EMISOR
FROM creditopy.tarjetas t
WHERE t.tarjeta = VC_TARJETA;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END;
-- cambio de PIN DIMO / TC
CASE
WHEN creditopy.pkg_dimo_ceibo.fn_is_prepaga(VN_EMISOR) = 1 THEN
sp_modificarPinDIMO(PI_NUMERO_TARJETA, -- Numero de la Tarjeta
PI_PIN_TARJETA, -- PIN indicado por el usuario para la tarjeta, encriptado
PO_SQLCODE,
PO_SQLERRM,
po_cursor);
WHEN creditopy.pkg_dimo_ceibo.fn_is_prepaga(VN_EMISOR) = 0 THEN
sp_modificarPinTC(PI_NUMERO_TARJETA, -- Numero de la Tarjeta
PI_PIN_TARJETA, -- PIN indicado por el usuario para la tarjeta, encriptado
PO_SQLCODE,
PO_SQLERRM,
po_cursor);
ELSE
RAISE_APPLICATION_ERROR(-20001,
'USERS_ERROR: operacion not valid.');
END CASE;
IF PO_SQLCODE != 0 THEN
PO_SQLCODE := -1;
END IF;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END sp_modificacionPinDimo;
PROCEDURE sp_tarjetasdimo(PI_DOCUMENTO IN VARCHAR2, -- Documento de Identidad
PI_SOLO_DIMO IN NUMBER, -- Bandera que indica si se deberia devolve: 1-solo las dimo y 2-otras prepagas
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
11.1 - Consulta lista TPs DIMOs por usuario
*/
/****************************************************************************************************
Autor: Amalia Rodriguez.
Adaptacion del original de obtención de lista TC de PKG_MICABAL.
Fecha: 13/05/2019
Propósito: Procedimiento que devuelve un cursor con los datos de las tarjetas prepagas
en base una serie de condiciones.
Se tiene como dato de entrada el numero de documento del tarjetahabiente.
PARAMETROS DE ENTRADA:
pi_documento: un numero de documento rellenado con 0 a la izquierda con 12 de longitud total
******************************************************************************************************/
BEGIN
IF pi_documento IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: document is null.');
END IF;
IF pi_solo_dimo IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: flag dimo is null.');
END IF;
OPEN po_cursor FOR
SELECT
-- Numero del documento de identidad
substr(t.documento, 4, 12) AS documento,
-- esta funcion dice cual es el procesador (cabal o panal) del emisor: retorna el id del procesador
creditopy.ceibo_utiles.fn_get_emisor_procesador(t.emisor) AS procesador,
-- descripcion del procesador
creditopy.pkg_dimo_ceibo.fn_get_emisor_desc(creditopy.ceibo_utiles.fn_get_emisor_procesador(t.emisor)) AS desc_procesador,
-- id del emisor
t.emisor AS emisor,
-- descripcion del emisor
creditopy.pkg_dimo_ceibo.fn_get_emisor_desc(t.emisor) AS desc_emisor,
-- número de cuenta
t.numero_cuenta AS numero_cuenta,
creditopy.fc_cripto2pan(t.tarjeta) AS numero_tarjeta,
-- mascara del número de la tarjeta desencriptada
creditopy.pkg_dimo_ceibo.fn_get_tarjeta_mask(t.tarjeta) AS tar_mask,
-- tipo medio: VIRTUAL / FISICA
decode(creditopy.pkg_dimo_ceibo.fn_is_prepaga_fisica(t.tarjeta),
1,
'FISICA',
'VIRTUAL') AS tipo_medio,
-- nombre que aparece en el plastico de la tarjeta
t.nombre_para_plastico AS nombre_usuario,
-- descripcion si la tarjeta es del titular o es una adicional
t.componente AS componente,
-- siempre devuelve solo titulares
'TITULAR' AS tipo_tarjeta,
-- fc_tjtp identifica cual es la ultima emitida para la cuenta correspondiendo esa tarjeta a la PRINCIPAL
CASE
WHEN t.tarjeta = creditopy.fc_tjtp(t.numero_cuenta) THEN
'PRINCIPAL'
ELSE
'NO PRINCIPAL'
END AS tj_principal,
-- la fecha de entrega de la tarjeta << de emision, generacion
to_char(t.fecha_otorgada, 'DD/MM/YYYY') AS fecha_otorgada,
-- adicional (para identificar la tarjeta en consulta se usa numero_cuenta + adicional)
t.adicional AS adicional,
-- la fecha de vencimiento de la tarjeta virtual
to_char(t.fecha_vigencia, 'DD/MM/YYYY') AS fecha_vigencia,
-- vencimiento de la tarjeta formato MMYY
to_char(t.fecha_vigencia, 'MMYY') AS vencimiento_tar,
-- id del estado de la tarjeta
creditopy.estado_ct(t.tarjeta, 'T') AS estado,
-- descripcion del estado de la tarjeta
creditopy.pkg_dimo_ceibo.fn_get_estado_desc(creditopy.estado_ct(t.tarjeta,
'T')) AS desc_estado,
-- ultimo periodo cerrado
sc.periodo_cierre AS ultimo_periodo_cerrado,
-- monto del disponible normal (o contado), el unico que utiliza la prepaga
-- este disponible se muestra a nivel de cuentas,
creditopy.pkg_dimo_ceibo.fn_get_disponible_online(ct.emisor,
ct.numero_cuenta,
1) AS disponible_normal,
--periodo actual
to_char(add_months(to_date(ve.periodo_cierre, 'yyyymm'), 1),
'yyyymm') AS periodo_actual_tarjeta,
-- indicador de que la tarjeta es una renovacion
decode(creditopy.pkg_dimo_ceibo.fn_get_origen_tarjeta(t.tarjeta),
90,
1,
0) AS flg_renovacion,
-- indicador de tarjeta DIMO
creditopy.pkg_dimo_ceibo.fn_is_dimo(t.emisor) AS es_dimo,
ct.cierre AS cierre,
t.tarjeta AS tarjeta,
creditopy.pkg_dimo_ceibo.fn_datos_plastico_tp(t.tarjeta, 1) AS id_tipo_tarjeta_prepaga,
creditopy.pkg_dimo_ceibo.fn_datos_plastico_tp(t.tarjeta, 2) AS tipo_tarjeta_prepaga,
creditopy.pkg_dimo_ceibo.fn_datos_plastico_tp(t.tarjeta, 3) AS estado_tarjeta_fisica,
creditopy.pkg_dimo_ceibo.fn_datos_plastico_tp(t.tarjeta, 4) AS desc_estado_tarjeta_fisica
-- ticket 0002049-Afinidad DIMO. AR. 27/05/2022 12:15:57 p.m.
,
t.grupo_afinidad AS id_grupo_afinidad,
creditopy.pkg_dimo_ceibo.fn_get_afinidad_desc(t.emisor,
t.grupo_afinidad) AS desc_afinidad
FROM creditopy.tarjetas t,
creditopy.cuentas ct,
creditopy.variables_entorno ve,
creditopy.saldos_cuentas sc,
debcredpy.emisores e,
creditopy.calendario_cierres cc,
debcredpy.emisores_productos ep
WHERE substr(t.documento, 4, 12) = lpad(PI_DOCUMENTO, 12, '0')
-- se muestran solo los emisores prepago
AND ((PI_SOLO_DIMO = 1 AND
creditopy.pkg_dimo_ceibo.fn_is_dimo(t.emisor) = 1) OR
(PI_SOLO_DIMO = 0 AND
creditopy.pkg_dimo_ceibo.fn_is_prepaga(t.emisor) = 1))
-- muestra las operativas, bloqueadas -- las DIMO no entran en atraso
AND ((creditopy.estado_ct(t.tarjeta, 'T') IN (0, 1, 4, 5)
--t.clase_de_estado IN (1,4,5) --,11) -- AR. 15/10/2020
AND t.fecha_vigencia > trunc(SYSDATE)) OR
-- se incluyen las no operativas pero con saldo al ultimo cierre porque tienen saldo
-- solo se toma la ultima
(t.clase_de_estado != 1 --NOT IN (1,11) -- AR. 15/10/2020
AND ct.saldo_cierre_ml != 0 AND
t.tarjeta = creditopy.fc_tjtp(t.numero_cuenta)) OR
-- se incluyen las no operativas incluso sin saldo porque puede solicitar desbloquear y reponer
-- solo se toma la ultima
(creditopy.estado_ct(t.tarjeta, 'T') IN (4, 5) AND
ct.saldo_cierre_ml = 0 AND
t.tarjeta = creditopy.fc_tjtp(t.numero_cuenta)))
-- solo desplegar las tarjetas donde el usuario es el titular
AND t.componente = 1
AND ct.numero_cuenta = t.numero_cuenta
-- la cuenta de las tarjetas tiene que estar operativa, no anulada
AND creditopy.estado_ct(ct.numero_cuenta, 'C') = 1 -- AR. 15/10/2020
AND ve.emisor = ct.emisor
AND ve.producto = ct.producto
AND ve.cierre = ct.cierre
AND ve.grupo_afinidad = ct.grupo_afinidad
AND sc.emisor = ct.emisor
AND sc.sucursal_emisor = ct.sucursal_emisor
AND sc.producto = ct.producto
AND sc.numero_cuenta = ct.numero_cuenta
AND sc.periodo_cierre = ve.periodo_cierre
-- no incluir las tarjetas de emisores CABAL
AND t.emisor NOT IN (99, 108, 120)
-- solo los emisores que estamos procesando a la fecha
AND e.emisor = t.emisor
AND e.base_pago_minimo = 'A'
AND cc.emisor = ct.emisor
AND cc.producto = ct.producto
AND cc.cierre = ct.cierre
AND cc.periodo =
to_char(add_months(to_date(sc.periodo_cierre, 'yyyymm'), 1),
'YYYYMM')
AND cc.grupo_afinidad(+) = ct.grupo_afinidad
AND ep.emisor = ct.emisor
AND ep.producto = ct.producto
AND ep.grupo_afinidad = ct.grupo_afinidad
AND ep.cartera = ct.cartera
ORDER BY procesador,
to_date(fecha_vigencia, 'DD/MM/YYYY') DESC,
numero_cuenta;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_tarjetasdimo;
PROCEDURE sp_tarjetasDimoPorAfinidad(PI_AFINIDAD_DIMO IN NUMBER, -- grupo de afinidad que se desea listar
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/****************************************************************************************************
Autor: Amalia Rodriguez.
Adaptacion del original de obtención de lista de tarjetas Dimo por documento.
ticket 0002049-Afinidad DIMO. AR. 27/05/2022 16:32:00 p.m.
Fecha: 27/05/2022 16:32:00 p.m.
Propósito: Procedimiento que devuelve un cursor con los datos de las tarjetas prepagas
DIMOs por grupo de afinidad si no tienen plastico solicitado.
Se tiene como dato de entrada el grupo de afinidad a revisar
PARAMETROS DE ENTRADA:
pi_afinidad_dimo: codigo de grupo afinidad de Dimo
******************************************************************************************************/
v_afinidad_ok NUMBER;
vb_todos NUMBER;
vn_tipo_direccion_email direcciones.tipo_de_direccion%TYPE := 6;
vn_tipo_direccion_cel direcciones.tipo_de_direccion%TYPE := 7;
BEGIN
sp_setEmisorDimo;
v_afinidad_ok := 0;
IF pi_afinidad_dimo IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: Afinidad is null.');
ELSE
BEGIN
SELECT 1
INTO v_afinidad_ok
FROM creditopy.grupos_afinidad ga
WHERE ga.emisor = PV_EMISOR_DIMO
AND ga.grupo_afinidad = PI_AFINIDAD_DIMO;
EXCEPTION
WHEN no_data_found THEN
raise_application_error(-20001,
'USERS_ERROR: Afinidad no es de DIMO.');
WHEN OTHERS THEN
RAISE;
END;
END IF;
-- por si sea un parametro a futuro
CASE PI_AFINIDAD_DIMO
WHEN 115002 THEN
vb_todos := 0;
ELSE
vb_todos := 1;
END CASE;
OPEN po_cursor FOR
SELECT
-- Numero del documento de identidad
substr(t.documento, 4, 12) AS documento,
-- PAN de la tarjeta
creditopy.fc_cripto2pan(t.tarjeta) AS numero_tarjeta,
-- mascara del número de la tarjeta desencriptada
creditopy.pkg_dimo_ceibo.fn_get_tarjeta_mask(t.tarjeta) AS tar_mask,
-- tipo medio: VIRTUAL / FISICA
decode(creditopy.pkg_dimo_ceibo.fn_is_prepaga_fisica(t.tarjeta),
1,
'FISICA',
'VIRTUAL') AS tipo_medio,
-- nombre que aparece en el plastico de la tarjeta
t.nombre_para_plastico AS nombre_usuario,
-- la fecha de entrega de la tarjeta << de emision, generacion
to_char(t.fecha_otorgada, 'DD/MM/YYYY') AS fecha_otorgada,
-- la fecha de vencimiento de la tarjeta virtual
to_char(t.fecha_vigencia, 'DD/MM/YYYY') AS fecha_vigencia,
-- id del estado de la tarjeta
creditopy.estado_ct(t.tarjeta, 'T') AS estado,
-- descripcion del estado de la tarjeta
creditopy.pkg_dimo_ceibo.fn_get_estado_desc(creditopy.estado_ct(t.tarjeta,
'T')) AS desc_estado,
t.tarjeta AS tarjeta,
tp.id_tipo_tarjeta_prepaga AS id_tipo_tarjeta_prepaga,
creditopy.pkg_dimo_ceibo.fn_datos_plastico_tp(t.tarjeta, 2) AS tipo_tarjeta_prepaga,
tp.estado_plastico AS estado_tarjeta_fisica,
creditopy.pkg_dimo_ceibo.fn_datos_plastico_tp(t.tarjeta, 4) AS desc_estado_tarjeta_fisica,
t.grupo_afinidad AS id_grupo_afinidad,
ga.descripcion AS desc_afinidad,
dc.calle AS celular,
de.calle AS email
FROM creditopy.tarjetas t,
creditopy.grupos_afinidad ga,
creditopy.tarjetas_prepaga tp,
creditopy.direcciones dc,
creditopy.direcciones de
WHERE
-- se muestran solo las dimo
t.emisor = PV_EMISOR_DIMO
-- muestra las operativas, bloqueadas -- las DIMO no entran en atraso
AND t.grupo_afinidad = PI_AFINIDAD_DIMO
AND creditopy.estado_ct(t.tarjeta, 'T') IN (0, 1)
AND t.fecha_vigencia > trunc(SYSDATE)
AND ga.emisor = t.emisor
AND ga.grupo_afinidad = t.grupo_afinidad
AND tp.tarjeta = t.tarjeta
AND ((vb_todos = 0 AND tp.estado_plastico = 0) -- aun no se imprime, para la afinidad 115002
OR vb_todos = 1)
AND dc.emisor = t.emisor
AND dc.sucursal_emisor = t.sucursal_emisor
AND dc.producto = t.producto
AND dc.numero_cuenta = t.numero_cuenta
AND dc.tipo_de_documento = t.tipo_de_documento
AND dc.documento = t.documento
AND dc.tipo_de_direccion = vn_tipo_direccion_cel
AND de.emisor = t.emisor
AND de.sucursal_emisor = t.sucursal_emisor
AND de.producto = t.producto
AND de.numero_cuenta = t.numero_cuenta
AND de.tipo_de_documento = t.tipo_de_documento
AND de.documento = t.documento
AND de.tipo_de_direccion = vn_tipo_direccion_email
ORDER BY numero_tarjeta;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_tarjetasDimoPorAfinidad;
PROCEDURE sp_modificacionEmailDIMO(PI_DOCUMENTO IN VARCHAR2, -- Documento de Identidad
PI_EMAIL IN VARCHAR2, -- Correo Electronico, en la app se debe aplicar control de formato
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
VR_SOLICITUD SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS SOLICITUDES_DATOS%ROWTYPE;
VC_TARJETA VARCHAR2(19);
VN_UPD_EMAIL_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 69;
VN_UPD_EMAIL_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 70;
VN_TIPO_DIRECCION_EMAIL DIRECCIONES.TIPO_DE_DIRECCION%TYPE := 6;
BEGIN
-- obtener emisor DIMO
sp_setEmisorDimo;
PV_USUARIO := get_usuario;
--Datos de la Tarjeta/Cuenta operativa
FOR R IN (
SELECT t.tarjeta
FROM creditopy.TARJETAS t, creditopy.CUENTAS c
WHERE substr(t.documento, 4, 12) = lpad(PI_DOCUMENTO, 12, '0')
AND t.emisor = PV_EMISOR_DIMO
AND c.numero_cuenta = t.numero_cuenta
AND creditopy.estado_ct(c.numero_cuenta, 'C') = 1)LOOP
-- obtener datos de la tarjeta
VC_TARJETA := R.TARJETA;
sp_get_tarjeta(VC_TARJETA, VR_TARJETA);
VR_CUENTA := NULL;
sp_get_cuenta(VR_TARJETA.NUMERO_CUENTA, VR_CUENTA);
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
--Datos de la Solicitud
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_UPD_EMAIL_DIMO;
VR_SOLICITUD.ID_ESTADO := VN_UPD_EMAIL_OK;
VR_SOLICITUD.TARJETA := fc_cripto2pan(VC_TARJETA);
VR_SOLICITUD.USUARIO := PV_USUARIO; --CC_USUARIO_DIMO;
VR_SOLICITUD.DOCUMENTO := PI_DOCUMENTO;
VR_DATOS.EMAIL := PI_EMAIL;
--Datos de la Novedad
VR_NOVEDAD_TARJETA.TARJETA := VR_TARJETA.TARJETA;
VR_NOVEDAD_TARJETA.NOVFCHING := SYSDATE;
PR_SOLICITUDES(VR_SOLICITUD, VR_DATOS);
IF VR_SOLICITUD.ID_ESTADO = VN_UPD_EMAIL_OK AND
VR_SOLICITUD.CODIGO_RESPUESTA = 0 THEN
-- actualizar el EMAIL del usuario
UPDATE DIRECCIONES D
SET D.CALLE = PI_EMAIL,
D.OPERADOR = SUBSTR(PV_USUARIO, 1, 8),
D.TIPO_NOV = 'M'
WHERE D.EMISOR = VR_CUENTA.EMISOR
AND D.SUCURSAL_EMISOR = VR_CUENTA.SUCURSAL_EMISOR
AND D.PRODUCTO = VR_CUENTA.PRODUCTO
AND D.NUMERO_CUENTA = VR_CUENTA.NUMERO_CUENTA
AND D.TIPO_DE_DOCUMENTO = VR_CUENTA.TIPO_DE_DOCUMENTO
AND D.DOCUMENTO = VR_CUENTA.DOCUMENTO
AND D.TIPO_DE_DIRECCION = VN_TIPO_DIRECCION_EMAIL;
END IF;
COMMIT;
IF VR_SOLICITUD.CODIGO_RESPUESTA != 0 THEN
po_sqlcode := VR_SOLICITUD.CODIGO_RESPUESTA;
po_sqlerrm := fn_get_ult_rechazo_solicitud(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.CODIGO_RESPUESTA);
ELSE
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END IF;
OPEN po_cursor FOR
SELECT decode(VR_SOLICITUD.CODIGO_RESPUESTA,
0,
0,
nvl(VR_SOLICITUD.NOVEDAD, 0)) AS CODIGO_NOVEDAD,
VR_SOLICITUD.ID_SOLICITUD_RECIBIDA AS ID_SOLICITUD,
VR_SOLICITUD.CODIGO_RESPUESTA AS CODIGO_RESPUESTA,
decode(VR_SOLICITUD.CODIGO_RESPUESTA, 0, ' ', PO_SQLERRM) AS GLOSA_RESPUESTA
FROM dual;
END LOOP;
IF VC_TARJETA IS NULL THEN
raise_application_error(-20001,
'El documento no tiene tarjeta con cuenta operativa.');
END IF;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
IF VR_SOLICITUD.ID_SOLICITUD_RECIBIDA IS NOT NULL THEN
VR_SOLICITUD.ID_ESTADO := VN_UPD_EMAIL_RECHA;
PR_ADM_ERROR_SOLICITUD(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.ID_ESTADO,
SQLCODE,
SQLERRM);
END IF;
ROLLBACK;
OPEN po_cursor FOR
SELECT nvl(VR_NOVEDAD_CUENTA.NOVNRO, 0) AS CODIGO_NOVEDAD,
nvl(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA, 0) AS ID_SOLICITUD,
po_sqlcode AS CODIGO_RESPUESTA,
po_sqlerrm AS GLOSA_RESPUESTA
FROM dual;
END sp_modificacionEmailDIMO;
PROCEDURE sp_modificacionCelularDIMO(PI_DOCUMENTO IN VARCHAR2, -- Documento de Identidad
PI_CELULAR IN VARCHAR2, -- Numero de Celular Formato 0NNNNNNNNN
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
VR_SOLICITUD SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS SOLICITUDES_DATOS%ROWTYPE;
VR_DIRECCION DIRECCIONES%ROWTYPE;
VC_TARJETA VARCHAR2(19);
VN_UPD_CELULAR_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 71;
VN_UPD_CELULAR_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 72;
VN_TIPO_DIRECCION_CEL DIRECCIONES.TIPO_DE_DIRECCION%TYPE := 7;
BEGIN
-- obtener emisor DIMO
sp_setEmisorDimo;
PV_USUARIO := get_usuario;
--Datos de la Tarjeta/Cuenta operativa
FOR R IN (
SELECT t.tarjeta
FROM creditopy.TARJETAS t, creditopy.CUENTAS c
WHERE substr(t.documento, 4, 12) = lpad(PI_DOCUMENTO, 12, '0')
AND t.emisor = PV_EMISOR_DIMO
AND c.numero_cuenta = t.numero_cuenta
AND creditopy.estado_ct(c.numero_cuenta, 'C') = 1)LOOP
VC_TARJETA := R.TARJETA;
sp_get_tarjeta(VC_TARJETA, VR_TARJETA);
VR_CUENTA := NULL;
sp_get_cuenta(VR_TARJETA.NUMERO_CUENTA, VR_CUENTA);
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
--Datos de la Solicitud
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_UPD_CELULAR_DIMO;
VR_SOLICITUD.ID_ESTADO := VN_UPD_CELULAR_OK;
VR_SOLICITUD.TARJETA := fc_cripto2pan(VC_TARJETA);
VR_SOLICITUD.USUARIO := PV_USUARIO; --CC_USUARIO_DIMO;
VR_SOLICITUD.DOCUMENTO := PI_DOCUMENTO;
VR_DATOS.TELEFONO := PI_CELULAR;
--Datos de la Novedad
VR_NOVEDAD_TARJETA.TARJETA := VR_TARJETA.TARJETA;
VR_NOVEDAD_TARJETA.NOVFCHING := SYSDATE;
PR_SOLICITUDES(VR_SOLICITUD, VR_DATOS);
IF VR_SOLICITUD.ID_ESTADO = VN_UPD_CELULAR_OK AND
VR_SOLICITUD.CODIGO_RESPUESTA = 0 THEN
-- actualizar el celular del usuario
UPDATE DIRECCIONES D
SET D.CALLE = PI_CELULAR,
D.TELEFONO = PI_CELULAR,
D.OPERADOR = SUBSTR(PV_USUARIO, 1, 8),
D.TIPO_NOV = 'M'
WHERE D.EMISOR = VR_CUENTA.EMISOR
AND D.SUCURSAL_EMISOR = VR_CUENTA.SUCURSAL_EMISOR
AND D.PRODUCTO = VR_CUENTA.PRODUCTO
AND D.NUMERO_CUENTA = VR_CUENTA.NUMERO_CUENTA
AND D.TIPO_DE_DOCUMENTO = VR_CUENTA.TIPO_DE_DOCUMENTO
AND D.DOCUMENTO = VR_CUENTA.DOCUMENTO
AND D.TIPO_DE_DIRECCION = VN_TIPO_DIRECCION_CEL;
END IF;
COMMIT;
IF VR_SOLICITUD.CODIGO_RESPUESTA != 0 THEN
po_sqlcode := VR_SOLICITUD.CODIGO_RESPUESTA;
po_sqlerrm := fn_get_ult_rechazo_solicitud(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.CODIGO_RESPUESTA);
ELSE
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END IF;
OPEN po_cursor FOR
SELECT decode(VR_SOLICITUD.CODIGO_RESPUESTA,
0,
0,
nvl(VR_SOLICITUD.NOVEDAD, 0)) AS CODIGO_NOVEDAD,
VR_SOLICITUD.ID_SOLICITUD_RECIBIDA AS ID_SOLICITUD,
VR_SOLICITUD.CODIGO_RESPUESTA AS CODIGO_RESPUESTA,
decode(VR_SOLICITUD.CODIGO_RESPUESTA, 0, ' ', PO_SQLERRM) AS GLOSA_RESPUESTA
FROM dual;
END LOOP;
-- obtener datos de la tarjeta
IF VC_TARJETA IS NULL THEN
raise_application_error(-20001,
'El documento no tiene tarjeta con cuenta operativa.');
END IF;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
IF VR_SOLICITUD.ID_SOLICITUD_RECIBIDA IS NOT NULL THEN
VR_SOLICITUD.ID_ESTADO := VN_UPD_CELULAR_RECHA;
PR_ADM_ERROR_SOLICITUD(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.ID_ESTADO,
SQLCODE,
SQLERRM);
END IF;
ROLLBACK;
OPEN po_cursor FOR
SELECT nvl(VR_NOVEDAD_CUENTA.NOVNRO, 0) AS CODIGO_NOVEDAD,
nvl(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA, 0) AS ID_SOLICITUD,
po_sqlcode AS CODIGO_RESPUESTA,
po_sqlerrm AS GLOSA_RESPUESTA
FROM dual;
END sp_modificacionCelularDIMO;
PROCEDURE sp_datosTarjetaDimo_v1(PI_EMISOR IN NUMBER, -- Codigo de la entidad emisora de la tarjeta en consulta
PI_SUFIJO_TARJETA IN VARCHAR2, -- Ultimos 10 digitos de la tarjeta
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
12 - Consulta Datos TP DIMO
-- 2021/02/19 Descontinuado por tiempos de respuesta excedidos. La busqueda desencriptando
-- la tarjeta no es recomendada.
*/
/****************************************************************************************************
Autor: Amalia Rodriguez.
Fecha: 10/09/2019
Propósito: Dados el codigo de la entidad y los 10 ultimos numeros de una tarjeta, debe
obtener los datos de la tarjeta: el numero de TC, numero de CI, y nombre del usuario
Se obtienen los datos de tarjeta DIMO, vigente y operativa.
PARAMETROS DE ENTRADA:
pi_emisor : codigo del emisor
pi_sufijo_tarjeta : ultimos 10 digitos de la tarjeta en consulta
******************************************************************************************************/
vc_tarjeta VARCHAR2(16);
vn_is_prepaga NUMBER;
vc_documento VARCHAR2(12);
vc_nombre VARCHAR2(25);
vc_estado VARCHAR2(15);
BEGIN
IF pi_emisor IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: entidad is null.');
ELSE
IF pkg_dimo_ceibo.fn_is_prepaga(pi_emisor) != 1 THEN
raise_application_error(-20001,
'USERS_ERROR: entidad no es prepaga.');
END IF;
IF pkg_dimo_ceibo.fn_is_dimo(PI_EMISOR) != 1 THEN
raise_application_error(-20001, 'USERS_ERROR: entidad no es DIMO.');
END IF;
END IF;
IF pi_sufijo_tarjeta IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: tarjeta is null.');
END IF;
-- obtener una tarjeta vigente, operativa para el emisor indicado
SELECT creditopy.fc_cripto2pan(t.tarjeta),
creditopy.pkg_dimo_ceibo.fn_is_prepaga(t.emisor),
substr(t.documento, 4, 12),
t.nombre_para_plastico,
CASE
WHEN creditopy.estado_ct(t.tarjeta, 'T') = 1 THEN
'OPERATIVA'
ELSE
'NO HABILITADA'
END
INTO vc_tarjeta, vn_is_prepaga, vc_documento, vc_nombre, vc_estado
FROM creditopy.tarjetas t, debcredpy.emisores e
WHERE e.emisor = PI_EMISOR
-- no incluir las tarjetas de emisores CABAL
AND e.emisor NOT IN (99, 108, 120)
-- solo los emisores que estamos procesando a la fecha
AND e.base_pago_minimo = 'A'
AND t.emisor = e.emisor
-- es prepaga DIMO
AND creditopy.pkg_dimo_ceibo.fn_is_dimo(t.emisor) = 1
-- vigente
AND t.fecha_vigencia >= trunc(SYSDATE)
-- operativa
AND creditopy.estado_ct(t.tarjeta, 'T') = 1
AND substr(creditopy.fc_cripto2pan(t.tarjeta), 7, 10) =
PI_SUFIJO_TARJETA;
OPEN po_cursor FOR
SELECT vc_tarjeta AS TARJETA,
vc_documento AS DOCUMENTO,
vc_nombre AS NOMBRE_USUARIO
--,vn_is_prepaga as ES_PREPAGA
--,vc_estado as ESTADO
FROM dual;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN NO_DATA_FOUND THEN
OPEN po_cursor FOR
SELECT ' ' AS TARJETA,
0 AS ES_PREPAGA,
' ' AS DOCUMENTO,
' ' AS NOMBRE_USUARIO,
' ' AS ESTADO
FROM dual;
PO_SQLCODE := -1;
PO_SQLERRM := 'No existe tarjeta operativa para el dato.';
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_datosTarjetaDimo_v1;
PROCEDURE sp_datosTarjetaDimo(PI_EMISOR IN NUMBER, -- Codigo de la entidad emisora de la tarjeta en consulta
PI_SUFIJO_TARJETA IN VARCHAR2, -- Ultimos 10 digitos de la tarjeta
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
12 - Consulta Datos TP DIMO
*/
/****************************************************************************************************
Autor: Amalia Rodriguez.
Fecha: 10/09/2019
Propósito: Dados el codigo de la entidad y los 10 ultimos numeros de una tarjeta, debe
obtener los datos de la tarjeta: el numero de TC, numero de CI, y nombre del usuario
Se obtienen los datos de tarjeta DIMO, vigente y operativa.
Se llega a la tarjeta tomando los bines del emisor y armando el string
bin + pi_sufijo_tarjeta
PARAMETROS DE ENTRADA:
pi_emisor : codigo del emisor
pi_sufijo_tarjeta : ultimos 10 digitos de la tarjeta en consulta
******************************************************************************************************/
vc_tarjeta VARCHAR2(16);
vn_is_prepaga NUMBER;
vc_documento VARCHAR2(12);
vc_nombre VARCHAR2(25);
vc_estado VARCHAR2(15);
is_found NUMBER;
BEGIN
IF pi_emisor IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: entidad is null.');
ELSE
IF pkg_dimo_ceibo.fn_is_prepaga(pi_emisor) != 1 THEN
raise_application_error(-20001,
'USERS_ERROR: entidad no es prepaga.');
END IF;
IF pkg_dimo_ceibo.fn_is_dimo(PI_EMISOR) != 1 THEN
raise_application_error(-20001, 'USERS_ERROR: entidad no es DIMO.');
END IF;
END IF;
IF pi_sufijo_tarjeta IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: tarjeta is null.');
END IF;
-- obtener una tarjeta vigente, operativa para el emisor indicado
is_found := 0;
FOR b IN (SELECT p.emisor, --p.bin_id,
substr(fc_cripto2pan(bi.bin), 1, bi.longitud) d_bin,
bi.longitud
FROM debcredpy.emisores e,
debcredpy.procesadores_prods p,
creditopy.bin_emisores bi
WHERE e.emisor = PI_EMISOR
-- no incluir las tarjetas de emisores CABAL
AND e.emisor NOT IN (99, 108, 120)
-- solo los emisores que estamos procesando a la fecha
AND e.base_pago_minimo = 'A'
-- es prepaga DIMO
AND creditopy.pkg_dimo_ceibo.fn_is_dimo(e.emisor) = 1
AND p.emisor = e.emisor
AND bi.bin_id = p.bin_id) LOOP
vc_tarjeta := b.d_bin || PI_SUFIJO_TARJETA;
BEGIN
SELECT creditopy.fc_cripto2pan(t.tarjeta),
substr(t.documento, 4, 12),
t.nombre_para_plastico,
1
/*, creditopy.pkg_dimo_ceibo.fn_is_prepaga(t.emisor),
, case when creditopy.estado_ct(t.tarjeta,'T') = 1 then 'OPERATIVA'
else 'NO HABILITADA'
end*/
INTO vc_tarjeta, vc_documento, vc_nombre, is_found
FROM creditopy.tarjetas t
WHERE t.emisor = b.emisor
AND t.tarjeta = fc_pan2cripto(vc_tarjeta)
-- operativa
AND creditopy.estado_ct(t.tarjeta, 'T') = 1
-- vigente
AND t.fecha_vigencia >= trunc(SYSDATE);
EXIT WHEN nvl(is_found, 0) = 1;
EXCEPTION
WHEN no_data_found THEN
is_found := 0;
WHEN OTHERS THEN
RAISE;
END;
END LOOP;
--
IF nvl(is_found, 0) = 1 THEN
OPEN po_cursor FOR
SELECT vc_tarjeta AS TARJETA,
vc_documento AS DOCUMENTO,
vc_nombre AS NOMBRE_USUARIO
--,vn_is_prepaga as ES_PREPAGA
--,vc_estado as ESTADO
FROM dual;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
ELSE
OPEN po_cursor FOR
SELECT ' ' AS TARJETA, ' ' AS DOCUMENTO, ' ' AS NOMBRE_USUARIO
--,0 as ES_PREPAGA
--,' ' as ESTADO
FROM dual;
PO_SQLCODE := -1;
PO_SQLERRM := 'No existe tarjeta operativa para el dato.';
END IF;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_datosTarjetaDimo;
PROCEDURE sp_consultaemisortarjeta(PI_NUMERO_TARJETA IN VARCHAR2, -- PAN de la tarjeta
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
vn_existe_emisor NUMBER(4);
/*
14- Consulta emisor tarjeta
*/
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 27/05/2020
Propósito: Procedimiento que devuelve un cursor con los datos del emisor si es una tarjeta de Cabal.
Se tiene como dato de entrada el numero de tarjeta.
Si no existe debe retonar el not found, no un cursor vacío.
PARAMETROS DE ENTRADA:
pi_numero_tarjeta: tarjeta a consultar
******************************************************************************************************/
BEGIN
IF PI_NUMERO_TARJETA IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: tarjeta is null.');
END IF;
-- si no esta parametrizado el emisor debe informar fin anormal
BEGIN
SELECT 1
INTO vn_existe_emisor
FROM creditopy.tarjetas t
WHERE t.tarjeta = creditopy.fc_pan2cripto(PI_NUMERO_TARJETA);
EXCEPTION
WHEN no_data_found THEN
raise_application_error(-20001,
'Tarjeta no corresponde a un emisor procesado.');
WHEN OTHERS THEN
RAISE;
END;
-- obtener los datos del emisor
OPEN po_cursor FOR
SELECT t.emisor AS emisor,
decode(nvl(ep.marca, 'TC'), CC_DIMO, 1, 'TC', 2, 3) AS es_dimo
FROM creditopy.tarjetas t
LEFT OUTER JOIN creditopy.emisores_prepago ep
ON t.emisor = ep.emisor
WHERE t.tarjeta = creditopy.fc_pan2cripto(PI_NUMERO_TARJETA);
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_consultaemisortarjeta;
PROCEDURE sp_ConsultaDatosTxsEmisor(PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
vn_existe_emisor NUMBER(4);
/*
14.1-Consulta datos para txs de un emisor
*/
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 27/05/2020
Propósito: Procedimiento que devuelve un cursor con los datos para el registro del comercio o
tarjeta puente cuando el originante o el destinatario no es una tarjeta de Cabal.
Se tiene como dato de entrada el numero del emisor.
Si el emisor no está parametrizado debe retonar el not found.
PARAMETROS DE ENTRADA:
pi_emisor: código del emisor a consultar
******************************************************************************************************/
BEGIN
-- si no esta parametrizado el emisor debe informar fin anormal
BEGIN
SELECT COUNT(*)
INTO vn_existe_emisor
FROM creditopy.emisor_comercios_tarj_puente ect;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END;
-- obtener los datos del emisor para transaccionar
OPEN po_cursor FOR
SELECT ect.participante AS emisor,
decode(nvl(ep.marca, 'TC'), CC_DIMO, 1, 'TC', 2, 3) AS es_dimo,
ect.comercio_puente AS cod_comercio_puente,
CASE
WHEN ect.tarjeta_puente IS NULL THEN
NULL
ELSE
creditopy.fc_cripto2pan(ect.tarjeta_puente)
END AS tarjeta_puente,
ect.comercio_adel_vent AS cod_comercio_adelanto,
lpad(ect.emisor_receptor_pago, 3, 0) ||
lpad(ect.sucursal_receptor_pago, 3, 0) AS receptor_pago,
t.nombre_para_plastico AS nombre_tarjeta_puente,
o.descripcion AS desc_comercio_puente
FROM creditopy.emisor_comercios_tarj_puente ect
LEFT OUTER JOIN creditopy.emisores_prepago ep
ON ect.participante = ep.emisor
LEFT JOIN creditopy.tarjetas t
ON ect.tarjeta_puente = t.tarjeta
LEFT JOIN creditopy.comercios o
ON ect.comercio_puente = o.comercio;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_ConsultaDatosTxsEmisor;
PROCEDURE sp_tarjetascredito(PI_DOCUMENTO IN VARCHAR2, -- Documento de Identidad
PI_EMISOR IN NUMBER DEFAULT NULL,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
15.1 - Consulta lista tarjetas TC
*/
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 24/04/2019
Propósito: Procedimiento que devuelve un cursor con los datos de las tarjetas de creditos cumpliendo
una serie de condiciones.
Se tiene como dato de entrada el numero de documento del tarjetahabiente.
OBS: Se toma la consulta utilizada en Micabal.
PARAMETROS DE ENTRADA:
pi_documento: un numero de documento rellenado con 0 a la izquierda con 12 de longitud total
******************************************************************************************************/
BEGIN
IF pi_documento IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: document is null.');
END IF;
OPEN po_cursor FOR
SELECT
-- Numero del documento de identidad
substr(t.documento, 4, 12) AS documento,
-- esta funcion dice cual es el procesador (cabal o panal) del emisor: retorna el id del procesador
creditopy.ceibo_utiles.FN_GET_EMISOR_PROCESADOR(t.emisor) AS procesador,
-- descripcion del procesador
creditopy.pkg_dimo_ceibo.fn_get_emisor_desc(creditopy.ceibo_utiles.FN_GET_EMISOR_PROCESADOR(t.emisor)) AS desc_procesador,
-- id del emisor
t.emisor AS emisor,
-- descripcion del emisor
creditopy.pkg_dimo_ceibo.fn_get_emisor_desc(t.emisor) AS desc_emisor,
-- id de la afinidad
ct.grupo_afinidad AS grupo_afinidad,
-- descripcion de la afinidad
creditopy.pkg_dimo_ceibo.fn_get_afinidad_desc(ct.emisor,
ct.grupo_afinidad) AS desc_grupo_af,
-- número de cuenta
t.numero_cuenta AS numero_cuenta,
-- tarjeta desencriptada
creditopy.fc_cripto2pan(t.tarjeta) AS numero_tarjeta,
-- tarjeta enmascarada
creditopy.pkg_dimo_ceibo.fn_get_tarjeta_mask(t.tarjeta) AS tar_mask,
-- tarjeta encriptada
t.tarjeta AS tar_cripto,
-- nombre que aparece en el plastico de la tarjeta
t.nombre_para_plastico AS nombre_usuario,
-- descripcion si la tarjeta es del titular o es una adicional
t.componente AS componente,
-- siempre devuelve solo titulares
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- fc_tjtp identifica cual es la ultima emitida para la cuenta correspondiendo esa tarjeta a la PRINCIPAL
CASE
WHEN t.tarjeta = creditopy.fc_tjtp(t.numero_cuenta) THEN
'PRINCIPAL'
ELSE
'NO PRINCIPAL'
END AS tj_principal,
-- la fecha de entrega de la tarjeta << de emision, generacion
to_char(t.fecha_otorgada, 'DD/MM/YYYY') AS fecha_otorgada,
-- adicional (para identificar la tarjeta en consulta se usa numero_cuenta + adicional)
t.adicional AS adicional,
-- la fecha de vencimiento del plastico
to_char(t.fecha_vigencia, 'DD/MM/YYYY') AS fecha_vigencia,
-- vencimiento de la tarjeta formato MMYY
TO_CHAR(t.fecha_vigencia, 'MMYY') AS vencimiento_tar,
-- id del estado de la tarjeta
creditopy.ESTADO_CT(t.tarjeta, 'T') AS estado,
-- descripcion del estado de la tarjeta
creditopy.pkg_dimo_ceibo.fn_get_estado_desc(creditopy.ESTADO_CT(t.tarjeta,
'T')) AS desc_estado,
-- si la cuenta esta congelada, devuelve "Cta.Congelada"
CASE
WHEN ct.tiene_vinculo = 1 THEN
'Cta.CONGELADA'
ELSE
'Cta.ACTIVA'
END AS congelada,
-- A deuda al cierre
ol.saldo_cierre_ml AS deuda_al_cierre,
-- ultimo periodo cerrado
sc.periodo_cierre AS ultimo_periodo_cerrado,
-- fecha vencimiento pago minimo
TO_CHAR(sc.fecha_vencimiento, 'DD/MM/YYYY') AS fecha_vencimiento_pago_minimo,
-- importe pago minimo,
sc.pago_minimo_ml AS importe_pm_facturado,
-- Saldo a la fecha es la deuda a la fecha emulada del AccesoCabal:
-- es el saldo actual calculado sobre el saldo al ultimo cierre de facturación
-- menos los pagos y ajustes crédito, incluyendo los pagos y ajustes del online,
-- mas los consumos (compras+ajustes db + adelantos) del periodo actual y los ajustes debito
-- del online, sin incluir las reservas
round(ol.saldo_cierre_ml
-- menos todos los creditos (pagos procesados, pagos en linea y ajustes credito en linea)
- (ol.pagos_ml +
creditopy.pkg_dimo_ceibo.fn_get_pagos_ol(t.numero_cuenta) +
creditopy.pkg_dimo_ceibo.fn_get_ajustes_ol(ct.numero_cuenta,
1))
-- mas los consumos del mes y los ajustes debito en linea
+ (ol.compras_ml + ol.efectivo_ml +
creditopy.pkg_dimo_ceibo.fn_get_ajustes_ol(ct.numero_cuenta,
0))) AS deuda_a_la_fecha,
--
-- pagos del periodo a la fecha: el total de pagos realizado por el tarjetahabiente
-- se calcula realizando la sumatoria de:
-- los pagos que se encuentran en el BACTH
-- + los pagos del dia registrados en el ONLINE
-- + los ajuste crédito registrados en el ONLINE.
(ct.pagos_ml +
creditopy.pkg_dimo_ceibo.fn_get_pagos_ol(t.numero_cuenta) +
creditopy.pkg_dimo_ceibo.fn_get_ajustes_ol(t.numero_cuenta, 1)) AS pagos,
-- importe del ultimo pago
creditopy.pkg_dimo_ceibo.fn_get_ultimo_pago(t.numero_cuenta) AS importe_ultimo_pago,
-- fecha de ultimo pago
to_char(creditopy.pkg_dimo_ceibo.fn_get_fecha_ultimo_pago(t.numero_cuenta,
ct.fecha_ultimo_pago),
'DD/MM/YYYY') AS fecha_ultimo_pago,
-- el monto del limite credito normal (plan_venta = 1) (o limite contado para los que tienen linea separada) (total)
creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor, t.numero_cuenta, 1) AS limite_credito_total_olpy,
-- el monto del limite planes (compras en cuotas) (plan_venta = 3)
creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor, t.numero_cuenta, 3) AS limite_planes_olpy,
-- el monto del limite de adelanto (efectivo) (plan_venta = 4)
creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor, t.numero_cuenta, 4) AS limite_adelanto_olpy,
-- el monto del limite del plan salud (plan_venta = 9)
creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor, t.numero_cuenta, 9) AS limite_salud_olpy,
-- monto del disponible normal (o contado para los que tienen linea separada) (total)
-- este disponible se muestra a nivel de cuentas,
-- no se estan mostrando los disponibles individuales para tarjetas adicionales
creditopy.pkg_dimo_ceibo.fn_get_disponible_online(ct.emisor,
ct.numero_cuenta,
1) AS disponible_normal,
-- obtiene la cantidad de adicionales que tiene para esta tarjeta
creditopy.pkg_dimo_ceibo.fn_get_cantidad_adicionales(t.numero_cuenta) AS cant_adicionales,
-- importe pago minimo pendiente
creditopy.pkg_dimo_ceibo.fn_get_pm_pendiente(t.numero_cuenta,
sc.pago_minimo_ml,
ol.pagos_ml) AS importe_pago_minimo,
-- dias en mora a la ultima diaria
CASE
WHEN creditopy.pkg_dimo_ceibo.fn_get_pm_pendiente(t.numero_cuenta,
sc.pago_minimo_ml,
ol.pagos_ml) > 0 THEN
ct.dias_en_mora
ELSE
0
END AS dias_en_mora,
TO_CHAR(sc.fecha_cierre, 'DD/MM/YYYY') AS fecha_emision_pago_minimo,
TO_CHAR(cc.fecha_cierre, 'DD/MM/YYYY') AS fecha_emision_pago_min_sig,
TO_CHAR(cc.fecha_vencimiento, 'DD/MM/YYYY') AS fecha_vencimiento_pago_min_sig,
-- indicadores para mensajes
CASE
WHEN creditopy.pkg_dimo_ceibo.fn_get_datos_monetarios_ol(ct.emisor,
ct.sucursal_emisor,
ct.numero_cuenta,
4,
ol.reservas_ml,
ol.reservas_efectivo_ml,
ol.reservas_planes_ml) != 0 THEN
1
ELSE
0
END AS con_autorizaciones_pendientes,
CASE
WHEN nvl(ep.porc_sobregiro_cont, 0) != 0 THEN
1
ELSE
0
END AS con_sobregiro,
-- indicador de que la tarjeta es una renovacion
decode(creditopy.pkg_dimo_ceibo.fn_get_origen_tarjeta(t.tarjeta),
90,
1,
0) AS flg_renovacion,
-- separacion de limites y disponibles por lineas:
-- si tiene linea unificada no se despliegan limite planes (compras en cuotas)
-- ni su linea disponible planes
decode(ct.numero_empresa, 1, 1, 0) AS is_linea_unificada,
-- monto del disponible planes (o compras en cuotas, para los que tienen linea separada)
creditopy.pkg_dimo_ceibo.fn_get_disponible_online(ct.emisor,
ct.numero_cuenta,
3) AS disponible_plan,
-- monto del disponible de adelantos
creditopy.pkg_dimo_ceibo.fn_get_disponible_online(ct.emisor,
ct.numero_cuenta,
4,
decode(ct.numero_empresa,
1,
1,
0),
nvl(ep.porc_sobregiro_cont,
0)) AS disponible_adelanto,
-- Plan Salud: si no tiene parametrizado no se despliegan el limite del plan salud
-- ni su linea disponible
nvl((SELECT 1
FROM creditopy.emisores_planes_am
WHERE emisor = ct.emisor
AND plan_amortizable = 9),
0) AS tiene_plan_salud,
creditopy.pkg_dimo_ceibo.fn_get_disponible_online(ct.emisor,
ct.numero_cuenta,
9) AS disponible_plan_salud,
round(creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor,
t.numero_cuenta,
1) *
nvl(ep.porc_sobregiro_cont, 0) / 100) AS importe_sobregiro
--periodo actual
,
to_char(add_months(to_date(ve.periodo_cierre, 'yyyymm'), 1),
'yyyymm') AS periodo_actual_tarjeta,
ct.cierre AS cierre,
(SELECT CASE
WHEN MAX(1) IS NULL THEN
'N'
ELSE
'S'
END
FROM creditopy.dimo_tc_vinculadas dtc
WHERE dtc.tarjeta = t.tarjeta
AND dtc.estado = 1 -- Vinculado...
) vinculada_dimo
FROM creditopy.tarjetas t,
creditopy.cuentas ct,
-- se utiliza la visa del Online para minimizar los tiempos de inconsistencia en el cierre diario
creditopy.cuentas@olpy ol,
creditopy.variables_entorno ve,
creditopy.saldos_cuentas sc,
debcredpy.emisores e,
creditopy.calendario_cierres cc,
debcredpy.emisores_productos ep
WHERE substr(t.documento, 4, 12) = lpad(pi_documento, 12, '0')
/* DIMO: se ajusta a desplegar solo las tarjetas titulares vigentes y
con estados operativos o bloqueado por el usuario
o que tengan saldo facturado al ultimo cierre
-- muestra las operativas, bloqueadas o atrasadas vigentes
and ((t.clase_de_estado in (1,4,5,11) and t.fecha_vigencia > trunc(sysdate)) or
-- se incluyen las no operativas pero con saldo al ultimo cierre porque facturan aun
-- solo se toma la ultima
(t.clase_de_estado not in (1,11) and ct.saldo_cierre_ml != 0 and
t.tarjeta = creditopy.fc_tjtp(t.numero_cuenta)) or
-- se incluyen las no operativas incluso sin saldo porque puede solicitar desbloquear y reponer
-- solo se toma la ultima
(t.clase_de_estado in (4,5) and ct.saldo_cierre_ml = 0 and
t.tarjeta = creditopy.fc_tjtp(t.numero_cuenta))
)
-- solo desplegar las tarjetas donde el usuario es el titular
and t.componente = 1
*/
AND t.emisor = decode(nvl(PI_EMISOR, 0), 0, t.emisor, PI_EMISOR)
--and CEIBO_UTILES.FN_GET_EMISOR_PROCESADOR(t.emisor) = 805
-- no incluir las tarjetas de emisores CABAL
--and t.emisor not in (99, 108, 120)
AND 1 = fn_emisor_proc_habilitado(t.emisor)
-- siempre que tenga vigencia valida
AND t.fecha_vigencia >= trunc(SYSDATE)
AND ct.numero_cuenta = t.numero_cuenta
-- se lista si es la tarjeta principal
AND (t.tarjeta = creditopy.fc_tjtp(t.numero_cuenta)
-- Ticket 0000467. OOJEDA --
-- o es la anterior emitida para el Titular de la Cta.
OR
(t.documento = ct.documento AND
t.adicional =
(SELECT MAX(TA.ADICIONAL) ADICIONAL_ANTERIOR
FROM TARJETAS TA
WHERE TA.NUMERO_CUENTA = T.NUMERO_CUENTA
AND TA.TIPO_DE_DOCUMENTO = T.TIPO_DE_DOCUMENTO
AND TA.DOCUMENTO = T.DOCUMENTO
AND TA.TARJETA != creditopy.fc_tjtp(t.numero_cuenta))))
-- y si la cuenta esta activa (estados operativa o con atraso)
-- o tenga saldo facturado al ultimo cierre
AND (ct.clase_de_estado IN (1, 11) OR
(ct.clase_de_estado NOT IN (1, 11) AND
ct.saldo_cierre_ml != 0))
-- y que este operativa, bloqueada a pedido del usuario o con atraso
-- o tenga saldo facturado al ultimo cierre
AND (t.clase_de_estado IN (1, 5, 11) OR
(t.clase_de_estado NOT IN (1, 11) AND ct.saldo_cierre_ml != 0))
AND ol.numero_cuenta = ct.numero_cuenta
AND ve.emisor = ct.emisor
AND ve.producto = ct.producto
AND ve.cierre = ct.cierre
AND ve.grupo_afinidad = ct.grupo_afinidad
AND sc.EMISOR = ct.emisor
AND sc.SUCURSAL_EMISOR = ct.sucursal_emisor
AND sc.PRODUCTO = ct.Producto
AND sc.NUMERO_CUENTA = ct.numero_cuenta
AND sc.periodo_cierre = ve.periodo_cierre
-- no incluir las tarjetas prepago
AND creditopy.pkg_dimo_ceibo.fn_is_prepaga(t.emisor) = 0
-- solo los emisores que estamos procesando a la fecha
AND e.emisor = t.emisor
AND e.base_pago_minimo = 'A'
AND cc.emisor = ct.emisor
AND cc.producto = ct.producto
AND cc.cierre = ct.cierre
AND cc.periodo =
to_char(add_months(to_date(sc.periodo_cierre, 'yyyymm'), 1),
'YYYYMM')
AND cc.grupo_afinidad(+) = ct.grupo_afinidad
AND ep.emisor = ct.emisor
AND ep.producto = ct.producto
AND ep.grupo_afinidad = ct.grupo_afinidad
AND ep.cartera = ct.cartera
ORDER BY procesador,
t.adicional, -- Ticket 0000467. OOJEDA --
to_date(fecha_vigencia, 'DD/MM/YYYY') DESC,
numero_cuenta;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_tarjetasCredito;
PROCEDURE sp_ConsultaExtracto(PI_NUMERO_CUENTA IN NUMBER, -- Documento de Identidad
PI_PERIODO IN NUMBER, -- Periodo inicial
PI_PERIODO_ACTUAL IN NUMBER, -- Periodo actual
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
15.3 - Consulta datos de extractos
*/
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 24/04/2019
Propósito: Procedimiento que devuelve un cursor con los datos de los extractos de facturacion del
rango de periodo indicado hasta el actual.
OBS: Se toma la consulta utilizada en Micabal.
PARAMETROS DE ENTRADA:
pi_numero_cuenta: un numero de cuenta para obtener los extractos
pi_periodo: periodo yyyymm de 12 meses atras del emisor de la cuenta
pi_periodo_actual: periodo yyyymm vigente del emisor de la cuenta
******************************************************************************************************/
BEGIN
IF PI_NUMERO_CUENTA IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: cuenta is null.');
END IF;
IF PI_PERIODO IS NULL OR PI_PERIODO_ACTUAL IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: periodo is null.');
END IF;
OPEN po_cursor FOR
SELECT substr(RI.PERIODO, 1, 4) AS anio,
substr(RI.PERIODO, 5, 2) AS mes,
to_char(RI.FECHA_CIERRE, 'DD/MM/YYYY') AS FECHA_EMISION,
SC.PAGO_MINIMO_ML AS PAGO_MINIMO,
to_char(SC.FECHA_VENCIMIENTO, 'DD/MM/YYYY') AS FECHA_VTO_PAGO_MINIMO,
CASE
-- si el periodo es el ultimo facturado (anterior al actual) se debe tomar de pagos a la fecha
WHEN SC.PERIODO_CIERRE =
to_char(add_months(to_date(pi_periodo_actual, 'YYYYMM'),
-1),
'YYYYMM') THEN
(ct.pagos_ml +
creditopy.pkg_dimo_ceibo.fn_get_pagos_ol(ct.numero_cuenta) +
creditopy.pkg_dimo_ceibo.fn_get_ajustes_ol(ct.numero_cuenta,
1))
ELSE
SC.TOTAL_PAGOS_ML
END AS MONTO_PAGO,
CASE
-- siempre buscar los pagos del periodo del row
-- si el periodo es el ultimo facturado (anterior al actual)
-- se debe tomar la ultima fecha de los pagos del periodo actual
WHEN SC.PERIODO_CIERRE =
to_char(add_months(to_date(pi_periodo_actual, 'YYYYMM'),
-1),
'YYYYMM') THEN
NVL(to_char(creditopy.pkg_dimo_ceibo.fn_get_fecha_ultimo_pago(CT.NUMERO_CUENTA,
creditopy.pkg_dimo_ceibo.fn_get_fecha_ult_pago_periodo(ct.emisor,
ct.sucursal_emisor,
ct.numero_cuenta,
pi_periodo_actual)),
'DD/MM/YYYY'),
' ')
ELSE
NVL(to_char(creditopy.pkg_dimo_ceibo.fn_get_fecha_ult_pago_periodo(ct.emisor,
ct.sucursal_emisor,
ct.numero_cuenta,
to_number(to_char(add_months(to_date(SC.PERIODO_CIERRE,
'YYYYMM'),
1),
'YYYYMM'))),
'DD/MM/YYYY'),
' ')
END AS FECHA_PAGO,
decode(NVL(RI.NRO_ORDEN_IMP, 0), 0, 0, 1) AS FLAG_EXTRACTO,
RI.EMISOR AS EMISOR,
creditopy.ceibo_utiles.FN_GET_EMISOR_PROCESADOR(RI.EMISOR) AS PROCESADOR
FROM CREDITOPY.RESUMENES_IMP RI,
CREDITOPY.CUENTAS CT,
CREDITOPY.SALDOS_CUENTAS SC -- periodo en consulta
WHERE RI.NUMERO_CUENTA = pi_numero_cuenta
AND RI.PERIODO >= pi_periodo --- formato YYYYMM y calcular los 12 ultimos
AND CT.NUMERO_CUENTA = RI.NUMERO_CUENTA
-- no incluir las cuentas prepago
AND creditopy.pkg_dimo_ceibo.fn_is_prepaga(ct.emisor) = 0
AND SC.EMISOR = RI.EMISOR
AND SC.SUCURSAL_EMISOR = RI.SUCURSAL_EMISOR
AND SC.PRODUCTO = 1
AND SC.NUMERO_CUENTA = RI.NUMERO_CUENTA
AND SC.PERIODO_CIERRE = RI.PERIODO
ORDER BY RI.PERIODO DESC;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_ConsultaExtracto;
PROCEDURE sp_adicionalTC(PI_NUMERO_CUENTA IN VARCHAR2, -- Numero de cuenta de las adicionales a consultar
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
16.1 Consulta lista de adicionales por numero de cuenta de TC
*/
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez
Fecha: 24/04/2019
Propósito: Procedimiento que devuelve un cursor con los datos de las tarjetas de creditos adicionales
cumpliendo una serie de condiciones.
Se tiene como dato de entrada el numero de documento del tarjetahabiente.
OBS: Se toma la consulta utilizada en Micabal.
PARAMETROS DE ENTRADA:
pi_numero_cuenta: un numero de cuenta para obetener las adicionales
******************************************************************************************************/
BEGIN
IF PI_NUMERO_CUENTA IS NULL THEN
raise_application_error(-20001,
'USERS_ERROR: numero cuenta is null.');
END IF;
OPEN po_cursor FOR
SELECT
-- Numero del documento de identidad
substr(t.documento, 4, 12) AS documento,
-- esta funcion dice cual es el procesador (cabal o panal) del emisor: retorna el id del procesador
creditopy.ceibo_utiles.FN_GET_EMISOR_PROCESADOR(t.emisor) AS procesador,
-- descripcion del procesador
creditopy.pkg_dimo_ceibo.fn_get_emisor_desc(creditopy.ceibo_utiles.FN_GET_EMISOR_PROCESADOR(t.emisor)) AS desc_procesador,
-- id del emisor
t.emisor AS emisor,
-- descripcion del emisor
creditopy.pkg_dimo_ceibo.fn_get_emisor_desc(t.emisor) AS desc_emisor,
-- id de la afinidad
ct.grupo_afinidad AS grupo_afinidad,
-- descripcion de la afinidad
creditopy.pkg_dimo_ceibo.fn_get_afinidad_desc(ct.emisor,
ct.grupo_afinidad) AS desc_grupo_af,
-- número de cuenta
t.numero_cuenta AS numero_cuenta,
-- numero de tarjeta
creditopy.fc_cripto2pan(t.tarjeta) AS numero_tarjeta,
-- numero de tarjeta con mascara en el siguiente formato 0000-XXXX-XXXX-0000
creditopy.pkg_dimo_ceibo.fn_get_tarjeta_mask(t.tarjeta) AS tar_mask,
-- número de la tarjeta encriptada
t.tarjeta AS tar_cripto,
-- nombre que aparece en el plastico de la tarjeta
t.nombre_para_plastico AS nombre_usuario,
-- la fecha de entrega de la tarjeta << de emision, generacion
t.fecha_otorgada AS fecha_otorgada,
-- adicional (para identificar la tarjeta en consulta se usa numero_cuenta + adicional)
t.adicional AS adicional,
-- la fecha de vencimiento del plastico
to_char(t.fecha_vigencia, 'DD/MM/YYYY') AS fecha_vigencia,
-- vencimiento de la tarjeta formato MMYY
TO_CHAR(t.fecha_vigencia, 'MMYY') AS vencimiento_tar,
-- id del estado de la tarjeta
creditopy.ESTADO_CT(t.tarjeta, 'T') AS estado,
-- descripcion del estado de la tarjeta
creditopy.pkg_dimo_ceibo.fn_get_estado_desc(creditopy.ESTADO_CT(t.tarjeta,
'T')) AS desc_estado,
-- si la cuenta esta congelada, devuelve "Cta.Congelada"
CASE
WHEN ct.tiene_vinculo = 1 THEN
'Cta.CONGELADA'
ELSE
'Cta.ACTIVA'
END AS congelada,
-- el monto del limite credito normal (plan_venta = 1) (o limite contado para los que tienen linea separada) (total)
creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor, t.numero_cuenta, 1) AS limite_credito_total_olpy,
-- el monto del limite planes (compras en cuotas) (plan_venta = 3)
creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor, t.numero_cuenta, 3) AS limite_planes_olpy,
-- el monto del limite de adelanto (efectivo) (plan_venta = 4)
creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor, t.numero_cuenta, 4) AS limite_adelanto_olpy,
-- el monto del limite del plan salud (plan_venta = 9)
creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor, t.numero_cuenta, 9) AS limite_salud_olpy,
-- monto del disponible normal (o contado para los que tienen linea separada) (total)
-- este disponible se muestra a nivel de cuentas, no se estan mostrando los disponibles individuales para tarjetas adicionales
creditopy.pkg_dimo_ceibo.fn_get_disponible_online(ct.emisor,
ct.numero_cuenta,
1) AS disponible_normal,
-- indicador de que la tarjeta es una renovacion
decode(creditopy.pkg_dimo_ceibo.fn_get_origen_tarjeta(t.tarjeta),
90,
1,
0) AS flg_renovacion,
-- separacion de limites y disponibles por lineas:
-- si tiene linea unificada no se despliegan limite planes (compras en cuotas)
-- ni su linea disponible planes
decode(ct.numero_empresa, 1, 1, 0) AS is_linea_unificada,
-- monto del disponible planes (o compras en cuotas, para los que tienen linea separada)
creditopy.pkg_dimo_ceibo.fn_get_disponible_online(ct.emisor,
ct.numero_cuenta,
3) AS disponible_plan,
-- monto del disponible de adelantos
creditopy.pkg_dimo_ceibo.fn_get_disponible_online(ct.emisor,
ct.numero_cuenta,
4,
decode(ct.numero_empresa,
1,
1,
0),
nvl(ep.porc_sobregiro_cont,
0)) AS disponible_adelanto,
-- Plan Salud: si no tiene parametrizado no se despliegan el limite del plan salud
-- ni su linea disponible
nvl((SELECT 1
FROM creditopy.emisores_planes_am
WHERE emisor = ct.emisor
AND plan_amortizable = 9),
0) AS tiene_plan_salud,
creditopy.pkg_dimo_ceibo.fn_get_disponible_online(ct.emisor,
ct.numero_cuenta,
9) AS disponible_plan_salud,
-- se incluye el indicador de sobregiro y el importe para las adicionales
CASE
WHEN nvl(ep.porc_sobregiro_cont, 0) != 0 THEN
1
ELSE
0
END AS con_sobregiro,
round(creditopy.pkg_dimo_ceibo.fn_get_limite(t.emisor,
t.numero_cuenta,
1) *
nvl(ep.porc_sobregiro_cont, 0) / 100) AS importe_sobregiro
FROM creditopy.tarjetas t,
creditopy.cuentas ct,
creditopy.variables_entorno ve,
creditopy.saldos_cuentas sc,
debcredpy.emisores_productos ep
WHERE t.numero_cuenta = pi_numero_cuenta
AND t.clase_de_estado IN (1, 4, 5, 11)
AND t.componente = 2 -- solo se desplegan las tarjetas adicionales
AND ct.numero_cuenta = t.numero_cuenta
-- no incluir las tarjetas prepago
AND creditopy.pkg_dimo_ceibo.fn_is_prepaga(t.emisor) = 0
AND ve.emisor = ct.emisor
AND ve.producto = ct.producto
AND ve.cierre = ct.cierre
AND ve.grupo_afinidad = ct.grupo_afinidad
AND sc.EMISOR = ct.emisor
AND sc.SUCURSAL_EMISOR = ct.sucursal_emisor
AND sc.PRODUCTO = ct.Producto
AND sc.NUMERO_CUENTA = ct.numero_cuenta
AND sc.periodo_cierre = ve.periodo_cierre
-- no incluir las tarjetas de emisores CABAL
AND t.emisor NOT IN (99, 108, 120)
-- no incluir las tarjetas prepago
AND creditopy.pkg_dimo_ceibo.fn_is_prepaga(t.emisor) = 0
AND ep.emisor = ct.emisor
AND ep.producto = ct.producto
AND ep.grupo_afinidad = ct.grupo_afinidad
AND ep.cartera = ct.cartera
ORDER BY t.numero_cuenta,
substr(t.documento, 4, 12),
t.fecha_otorgada,
t.fecha_vigencia;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_adicionalTC;
PROCEDURE sp_movimientosdimo(PI_EMISOR IN VARCHAR2, -- Identificador del emisor
PI_PERIODO_ACTUAL_TARJETA IN VARCHAR2, -- Periodo actual de la tarjeta
PI_CIERRE IN VARCHAR2, -- Ultimo Periodo de cierre
PI_NUMERO_TARJETA IN VARCHAR2, -- PAN tarjeta
PI_NUMERO_CUENTA IN VARCHAR2, -- Numero de cuenta de la tarjeta
PI_ADICIONAL IN VARCHAR2, -- Adicional
PI_FLG_ADICIONAL IN VARCHAR2, -- Boolean que indica si se obtienen movimientos de tarjetas adicionales
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
17.1 - Consulta movimientos TPs DIMO
*/
-- FALTA INCORPORAR RUBROS_GLOSA_TP
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 29/04/2019
Propósito: Procedimiento que devuelve...
pi_flg_adicionales valores
0 - no icluye los movimientos de las adicionales
1 - incluye los movimientos de las adicionales
Cursor:
- idramo, descramo: no se informan los ramos:
96 ADQUISICION CARTERA
97 REFINANCIACIONES
98 CUOTIZACION
- cred: valores posibles de codigo_operacion
codigo_operacion = 0 - compras (debito al usuario) ó
1 - devoluciones (credito al usuario)
****************************************************************************************************/
vn_componente_tar_param NUMBER;
vr_tarjeta creditopy.tarjetas%ROWTYPE;
vc_tarjeta creditopy.tarjetas.tarjeta%TYPE;
vb_is_periodo_actual NUMBER;
v_fecha_saldo DATE;
v_periodo_anterior NUMBER;
v_saldo_inicio_periodo NUMBER;
BEGIN
vc_tarjeta := creditopy.fc_pan2cripto(pi_numero_tarjeta);
IF cs.GET_PERIODO_ACTUAL(PI_EMISOR, 1, PI_CIERRE) =
PI_PERIODO_ACTUAL_TARJETA THEN
vb_is_periodo_actual := 1;
ELSE
vb_is_periodo_actual := 0;
END IF;
-- se valida existencia de la tarjeta antes de consultar
BEGIN
SELECT t.*
INTO vr_tarjeta
FROM creditopy.tarjetas t
WHERE t.tarjeta = vc_tarjeta
AND t.emisor = pi_emisor
AND t.numero_cuenta = pi_numero_cuenta
AND t.adicional = pi_adicional;
EXCEPTION
-- no puede darse por valido si es no_data_found porque debio pasar por
-- las validaciones previas
WHEN no_data_found THEN
raise_application_error(-20001, 'Tarjeta invalida.');
WHEN OTHERS THEN
RAISE;
END;
vn_componente_tar_param := vr_tarjeta.componente;
-- obtener el saldo anterior de la cuenta
v_periodo_anterior := to_char(add_months(to_date(PI_PERIODO_ACTUAL_TARJETA,
'YYYYMM'),
-1),
'YYYYMM');
BEGIN
SELECT sc.fecha_cierre, sc.pago_contado_ml * -1
INTO v_fecha_saldo, v_saldo_inicio_periodo
FROM creditopy.SALDOS_CUENTAS sc
WHERE sc.emisor = vr_tarjeta.emisor
AND sc.sucursal_emisor = vr_tarjeta.sucursal_emisor
AND sc.producto = vr_tarjeta.producto
AND sc.numero_cuenta = vr_tarjeta.numero_cuenta
AND sc.periodo_cierre = v_periodo_anterior;
EXCEPTION
WHEN no_data_found THEN
v_fecha_saldo := to_date(PI_PERIODO_ACTUAL_TARJETA || '01',
'YYYYMMDD');
v_saldo_inicio_periodo := 0;
WHEN OTHERS THEN
RAISE;
END;
OPEN po_cursor FOR
SELECT cuenta,
tarjeta,
fecha_movimiento_date,
fecha_movimiento,
nombre_comercio,
cupon,
autorizacion,
importe,
moneda,
fecha_proceso,
adicional,
tipo_tarjeta,
estado_mov,
idRamo,
descRamo,
cred,
talon,
orden,
SUM(simporte) over(PARTITION BY cuenta ORDER BY orden) - simporte saldo_ant,
SUM(simporte) over(PARTITION BY cuenta ORDER BY orden) saldo_act
FROM (SELECT vr_tarjeta.numero_cuenta AS cuenta,
vr_tarjeta.tarjeta AS tarjeta,
v_fecha_saldo AS fecha_movimiento_date,
to_char(v_fecha_saldo, 'DD/MM/YYYY') AS fecha_movimiento,
'Saldo inicial' AS nombre_comercio,
0 AS cupon,
0 AS autorizacion,
0 AS importe,
' ' AS moneda,
' ' AS fecha_proceso,
1 AS adicional,
'TITULAR' AS tipo_tarjeta,
' ' AS estado_mov,
0 AS idRamo,
' ' AS descRamo,
1 AS cred,
0 AS talon,
v_saldo_inicio_periodo AS simporte,
0 orden
FROM dual
UNION ALL
SELECT fila.*,
decode(cred, 1, -importe, importe) simporte,
rownum orden
FROM (
/*
1. consulta de AUTORIZACIONES PROCESADAS DEL BATCH no cuponadas, tomada de la regla 10014
*/
SELECT a.numero_cuenta AS cuenta,
a.tarjeta AS tarjeta,
/*a.fecha as fecha_movimiento_date,
to_char(a.fecha,'DD/MM/YYYY')
as fecha_movimiento,*/
to_date(to_char(a.fecha, 'DD/MM/YYYY') || ' ' ||
to_char(a.hora, 'HH24:MI:SS'),
'DD/MM/YYYY HH24:MI:SS') AS fecha_movimiento_date,
to_char(a.fecha, 'DD/MM/YYYY') || ' ' ||
to_char(a.hora, 'HH24:MI:SS') AS fecha_movimiento,
/*-- descripcion del comercio
creditopy.Pkg_Dimo_Ceibo.fn_get_comercio_desc(o.emisor_procesador,o.comercio,a.emisor)
as nombre_comercio,*/
-- glosa de la transaccion
creditopy.Pkg_Dimo_Ceibo.fn_get_glosa_aut_trxs(a.tarjeta,
'C', -- consumo
a.fecha,
a.hora,
substr(lpad(a.numero_ticket,
15,
0),
-6),
a.numero_ticket,
o.emisor_procesador,
o.comercio,
a.emisor,
a.autorizante) AS nombre_comercio,
nvl(a.numero_ticket, 0) AS cupon,
a.numero_autorizacion AS autorizacion,
a.monto_compra AS importe,
e.descripcion AS moneda,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Reserva' AS estado_mov,
-- datos del ramo del comercio para grafico de consumo
creditopy.Pkg_Dimo_Ceibo.fn_get_cod_ramo_barra(o.emisor_procesador,
o.ramo,
o.comercio) AS idramo,
creditopy.Pkg_Dimo_Ceibo.fn_get_desc_ramo_barra(o.emisor_procesador,
o.ramo,
o.comercio) AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
0 AS talon
FROM creditopy.autorizaciones a,
creditopy.comercios o,
creditopy.planes_de_venta d,
debcredpy.monedas e,
creditopy.acquirers h,
creditopy.tarjetas t
WHERE a.numero_cuenta = pi_numero_cuenta
-- las autorizaciones no procesadas solo se muestran en el periodo actual
AND vb_is_periodo_actual = 1
AND CASE autorizante
WHEN 'Incoming' THEN
9999998
ELSE
a.numero_comercio
END = o.comercio
AND a.producto >= -1
AND e.producto = a.producto
AND e.codigo_de_moneda = a.moneda_compra
AND d.plan_venta = a.plan_venta
AND h.acquirer = CASE autorizante
WHEN 'Incoming' THEN
'490000'
ELSE
autorizante
END
AND a.baja IN (' ', '0')
AND t.tarjeta = a.tarjeta
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente) -- de la tarjeta del movimiento
UNION ALL
/*
2. consulta de MOVIMIENTOS DEL PERIODO ACTUAL
Se obtiene de la regla 10973 para consulta al bapy, que esta compuesta de 4 consultas pero
se utilizan solo la 1 y la 2, porque el interes y el IVA se suman en la cuota correspondiente.
La consulta del IVA es solo para los cargos que hayan aplicado en la diaria y ya se visualizan.
Se consulta por numero_cuenta, la principal ve todo lo que se le va a facturar,
incluidas las transacciones de sus adicionales porque hacen a su deuda
*/
SELECT
-- 2.1 Movimientos facturados:
-- Los movimientos se facturan con un rubro que se despliega en el nombre del comercio
-- Los consumos ingresan con un rubro y para ese caso se debe incluir el nombre
-- del comercio (compra o debito automático)
-- Los consumos en el extranjero se despliegan XXXXXXX <<< definir igual que en los extractos
-- Para cuotas decaidas anticipadamente, se suman al importe el interes y el IVA
b.numero_cuenta AS cuenta,
t.tarjeta AS tarjeta,
a.fecha_movimiento AS fecha_movimiento_date,
to_char(a.fecha_movimiento, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del comercio (consumos) o
-- descripcion del rubro con el que se factura (pagos, cargos)
-- y el concepto para los ajustes (tipo_de_rubro = 3) que tengan leyenda (concepto)
/*case
when ru.tipo_de_rubro = 1 then
creditopy.Pkg_Dimo_Ceibo.fn_get_comercio_desc(
nvl(o.emisor_procesador,0),
a.numero_comercio,
a.emisor,
a.rubro,
ru.tipo_de_rubro,
a.compra_exterior,
a.numero_cupon_interno)
else
creditopy.pkg_dimo_ceibo.fn_get_leyenda_movimiento(
a.emisor,
a.numero_cuenta,
a.rubro,
a.codigo_operacion,
a.moneda,
a.importe_ml,
a.fecha_movimiento,
a.fecha_valor,
a.numero_talon,
a.numero_comercio,
'')
end as nombre_comercio,*/
CASE
WHEN ru.tipo_de_rubro = 1 THEN
creditopy.Pkg_Dimo_Ceibo.fn_get_glosa_aut_trxs(cu.tarjeta_externa,
'C', -- consumo
cu.fecha_cupon,
NULL,
substr(lpad(cu.numero_cupon,
15,
0),
-6),
cu.numero_cupon,
o.emisor_procesador,
o.comercio,
t.emisor,
' ')
ELSE
creditopy.pkg_dimo_ceibo.fn_get_leyenda_movimiento(a.emisor,
a.numero_cuenta,
a.rubro,
a.codigo_operacion,
a.moneda,
a.importe_ml,
a.fecha_movimiento,
a.fecha_valor,
a.numero_talon,
a.numero_comercio,
' ')
END AS nombre_comercio,
-- numero de cupon y autorizacion solo importan cuando es un consumo
CASE
WHEN a.numero_comercio > 0 THEN
a.numero_cupon
ELSE
0
END AS cupon,
CASE
WHEN a.numero_comercio > 0 THEN
cu.numero_autorizacion
ELSE
0
END AS autorizacion,
CASE
WHEN ru.tipo_de_rubro = 1 AND a.son > 1 THEN
a.importe_ml + nvl(c.importe_producto, 0) +
nvl(c.importe_impuesto, 0)
ELSE
a.importe_ml
END AS importe,
e.descripcion AS moneda,
to_char(a.fecha_valor, 'DD/MM/YYYY') AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Procesado' AS estado_mov,
-- datos del ramo del comercio para grafico de consumo
-- si es un consumo solo se despliega el ramo cuando es la cuota 1, por ser la compra inicial
CASE
WHEN ru.tipo_de_rubro = 1 AND a.van = 1 THEN
creditopy.Pkg_Dimo_Ceibo.fn_get_cod_ramo_barra(nvl(o.emisor_procesador,
0),
nvl(o.ramo,
0),
nvl(o.comercio,
0))
ELSE
0
END AS idramo,
CASE
WHEN ru.tipo_de_rubro = 1 AND a.van = 1 THEN
creditopy.Pkg_Dimo_Ceibo.fn_get_desc_ramo_barra(nvl(o.emisor_procesador,
0),
nvl(o.ramo,
0),
nvl(o.comercio,
0))
ELSE
' '
END AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
to_number(TRIM(a.numero_talon)) AS talon
FROM creditopy.movtos_cuentas a,
creditopy.cuentas b,
creditopy.rubros ru,
debcredpy.monedas e,
creditopy.cupones cu,
creditopy.comercios o,
creditopy.movs_prods_imps c,
creditopy.tarjetas t
WHERE a.emisor = pi_emisor
AND a.periodo_cierre = pi_periodo_actual_tarjeta
AND a.cierre = pi_cierre
AND a.numero_cuenta = pi_numero_cuenta
AND b.emisor = a.emisor
AND b.sucursal_emisor = a.sucursal_emisor
AND b.producto = a.producto
AND b.numero_cuenta = a.numero_cuenta
AND ru.rubro = a.rubro
AND e.producto = a.producto
AND e.codigo_de_moneda = a.moneda
AND cu.cupon(+) = CASE
WHEN a.numero_comercio > 0 THEN
a.numero_cupon_interno
ELSE
-1
END
AND o.comercio(+) = CASE
WHEN a.numero_comercio > 0 THEN
a.numero_comercio
ELSE
-1
END
AND a.prods_imps = c.prods_imps(+)
AND t.numero_cuenta = a.numero_cuenta
-- los cargos de la cuenta se registran con adicional = 1 pero
-- deben desplegarse referenciando a la tarjeta principal
AND t.adicional = CASE
WHEN a.adicional = 1 THEN
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta =
creditopy.fc_tjtp(a.numero_cuenta))
ELSE
a.adicional
END
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
UNION ALL
SELECT
-- 2.2. IVA de los movimientos facturados. Se ajusta para que no incluya las compras en planes
-- que hayan decaido antes de la facturacion, ya que los movimientos de cuotas totalizan
-- el importe de la amortizacion (cuota) más intereses e iva sobre el interes
b.numero_cuenta AS cuenta,
t.tarjeta AS tarjeta,
a.fecha_movimiento AS fecha_movimiento_date,
to_char(a.fecha_movimiento, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del rubro con el que se factura
'I.V.A.' AS nombre_comercio,
-- numero de cupon y autorizacion solo importan cuando es un consumo
0 AS cupon,
0 AS autorizacion,
a.importe_ml AS importe,
e.descripcion AS moneda,
to_char(a.fecha_valor, 'DD/MM/YYYY') AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Procesado IVA' AS estado_mov,
-- no se debe incluir datos del ramo del comercio para los intereses
0 AS idramo,
' ' AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
to_number(TRIM(a.numero_talon)) AS talon
FROM creditopy.movtos_cuentas a,
creditopy.cuentas b,
creditopy.rubros ru,
debcredpy.monedas e,
creditopy.movs_prods_imps c,
creditopy.tarjetas t
WHERE a.emisor = pi_emisor
AND a.periodo_cierre = pi_periodo_actual_tarjeta
AND a.cierre = pi_cierre
AND a.numero_cuenta = pi_numero_cuenta
AND b.emisor = a.emisor
AND b.sucursal_emisor = a.sucursal_emisor
AND b.producto = a.producto
AND b.numero_cuenta = a.numero_cuenta
AND ru.rubro = a.rubro
AND ru.tipo_de_rubro != 1 -- no se toman los IVA de rubros de compras en planes (cupones en cuotas)
AND e.producto = a.producto
AND e.codigo_de_moneda = a.moneda
-- solo si tienen IVA calculado
AND a.prods_imps = c.prods_imps
AND nvl(c.importe_impuesto, 0) != 0 -- en esta columna estan los interese calculados de cuotas de planes
AND t.numero_cuenta = a.numero_cuenta
-- los cargos de la cuenta se registran con adicional = 1 pero
-- deben desplegarse referenciando a la tarjeta principal
AND t.adicional = CASE
WHEN a.adicional = 1 THEN
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta =
creditopy.fc_tjtp(a.numero_cuenta))
ELSE
a.adicional
END
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
UNION ALL
SELECT
-- 2.3 Movimientos en proceso de cierre diario aun no facturados: corresponden a
-- ajustes credito o debito y que ingresan con un rubro.
-- Incluye los descuentos por promocion en cuyo caso se relaciona a un consumo
-- y debe indicar el comercio y cupon al que se aplica
-- Algunos ajustes corresponden a cargos que se en cuotas e ingresan como ajustes
-- en cuyo caso se debe indicar las cuotas
b.numero_cuenta AS cuenta,
t.tarjeta AS tarjeta,
a.fecha_movimiento AS fecha_movimiento_date,
to_char(a.fecha_movimiento, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del rubro con el que se factura y el nombre del comercio para los consumos
creditopy.pkg_dimo_ceibo.fn_get_leyenda_movimiento(a.emisor,
a.numero_cuenta,
a.rubro,
a.codigo_operacion,
decode(a.tipo_de_moneda,
1,
830,
840),
a.importe,
a.fecha_movimiento,
a.fecha_proceso,
a.numero_talon,
nvl(cu.comercio_cabal,
0),
a.leyenda) AS nombre_comercio,
CASE
WHEN cu.comercio_cabal > 0 THEN
cu.numero_cupon
ELSE
to_number(TRIM(a.numero_talon))
END AS cupon,
CASE
WHEN cu.comercio_cabal > 0 THEN
cu.numero_autorizacion
ELSE
0
END AS autorizacion,
a.importe AS importe,
e.descripcion AS moneda,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'En Proceso' AS estado_mov,
-- los ajustes no son consumos, no incluir datos del ramo del comercio
0 AS idramo,
' ' AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
to_number(TRIM(a.numero_talon)) AS talon
FROM creditopy.movimientos_ajustes a,
creditopy.cuentas b,
creditopy.rubros ru,
debcredpy.monedas e,
creditopy.cupones cu,
creditopy.tarjetas t
WHERE b.emisor = pi_emisor
AND b.cierre = pi_cierre
AND b.numero_cuenta = pi_numero_cuenta
AND a.emisor = b.emisor
AND a.sucursal_emisor = b.sucursal_emisor
AND a.producto = b.producto
AND a.periodo_cierre = pi_periodo_actual_tarjeta
AND nvl(a.procesado, 'N') != 'S'
AND a.numero_cuenta = b.numero_cuenta
AND a.rubro = ru.rubro
AND e.producto = a.producto
AND e.codigo_de_moneda =
decode(a.tipo_de_moneda, 1, 830, 840)
-- obtener los datos del cupon cuando es descuento por promo (rubro3577)
AND cu.cupon(+) = CASE
WHEN a.rubro = 3577 THEN
to_number(substr(a.leyenda, 2, 13))
ELSE
-1
END
-- obtener la tarjeta (cuenta+adicional) a la que se aplica el ajuste
AND t.numero_cuenta = a.numero_cuenta
AND t.adicional = CASE
WHEN 1 = (SELECT 1
FROM creditopy.codigos_py cp
WHERE cp.tipo_codigo = 14
AND TRIM(cp.valor) = a.rubro) OR
substr(a.leyenda, 4, 5) = 'Cuota' THEN
to_number(substr(a.leyenda, 1, 2))
WHEN a.rubro = 3577 THEN
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta =
nvl(cu.tarjeta_externa,
creditopy.fc_tjtp(a.numero_cuenta)))
ELSE
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta =
creditopy.fc_tjtp(a.numero_cuenta))
END
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
UNION ALL
/* -- no corresponde PLANES para PREPAGAS
3. consulta de PLANES pendientes de facturar (cuota e interes)
union all
-- 3.2 planes pagos (planes sin interes) pendientes de facturacion
union all*/
/*
4. Consultas ONLINE: autorizaciones, pagos y ajustes
*/
SELECT
-- 4.1 consulta de AUTORIZACIONES de COMPRA pendientes del Online tomada de la regla 10014
a.nro_cuenta AS cuenta,
a.nro_tarjeta AS tarjeta,
/*a.fecha as fecha_movimiento_date,
to_char(a.fecha,'DD/MM/YYYY') as fecha_movimiento,*/
to_date(to_char(a.fecha, 'DD/MM/YYYY') || ' ' ||
to_char(a.hora, 'HH24:MI:SS'),
'DD/MM/YYYY HH24:MI:SS') AS fecha_movimiento_date,
to_char(a.fecha, 'DD/MM/YYYY') || ' ' ||
to_char(a.hora, 'HH24:MI:SS') AS fecha_movimiento, /*-- descripcion del comercio
creditopy.Pkg_Dimo_Ceibo.fn_get_comercio_desc(c.emisor_procesador,c.comercio,a.emisor)
as nombre_comercio,*/
-- glosa de la transaccion
creditopy.Pkg_Dimo_Ceibo.fn_get_glosa_aut_trxs(a.nro_tarjeta,
'C', -- consumo
a.fecha,
a.hora,
a.numero_auditoria,
a.nro_ticket,
c.emisor_procesador,
c.comercio,
a.emisor,
a.acquiring_institution) AS nombre_comercio,
nvl(to_number(a.nro_ticket), 0) AS cupon,
a.nro_autorizacion AS autorizacion,
a.importe AS importe,
e.descripcion AS moneda,
--to_char(a.autextfch,'DD/MM/YYYY') as fecha_proceso,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Tx OnLine' AS estado_mov,
-- datos del ramo del comercio para grafico de consumo
creditopy.Pkg_Dimo_Ceibo.fn_get_cod_ramo_barra(c.emisor_procesador,
c.ramo,
c.comercio) AS idramo,
creditopy.Pkg_Dimo_Ceibo.fn_get_desc_ramo_barra(c.emisor_procesador,
c.ramo,
c.comercio) AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
0 AS talon
FROM creditopy.log_transacc_cr@olpy a,
creditopy.comercios c,
creditopy.planes_de_venta d,
debcredpy.monedas e,
creditopy.ramos r,
creditopy.tarjetas t
WHERE a.emisor = pi_emisor
-- las autorizaciones en linea solo se muestran en el periodo actual
AND vb_is_periodo_actual = 1
AND a.nro_cuenta = pi_numero_cuenta
AND a.nro_comercio = c.comercio
AND a.TX_INTERNA NOT IN ('OFF COMP', 'OFF DEV') -- no incluir off-line
AND a.producto >= -1
AND d.plan_venta >= -1
AND d.plan_venta = a.plan
AND nvl(a.tipo_autorizacion, 'R') = 'A'
AND a.autextproc IS NULL
AND r.emisor_procesador = c.emisor_procesador
AND r.ramo = c.ramo
AND t.tarjeta = a.nro_tarjeta
AND e.producto = t.producto
AND e.codigo_de_moneda = a.moneda
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente) -- de la tarjeta del movimiento
UNION ALL
SELECT
-- 4.2 PAGOS de la fecha: los pagos entran a la cuenta, aunque se registren con una tarjeta
-- se obtiene de la CONSULTA1 de la regla 10974
a.nro_cuenta AS cuenta,
a.nro_tarjeta AS tarjeta,
/*a.fecha as fecha_movimiento_date,
to_char(a.fecha,'DD/MM/YYYY') as fecha_movimiento,*/
to_date(to_char(a.fecha, 'DD/MM/YYYY') || ' ' ||
to_char(a.hora, 'HH24:MI:SS'),
'DD/MM/YYYY HH24:MI:SS') AS fecha_movimiento_date,
to_char(a.fecha, 'DD/MM/YYYY') || ' ' ||
to_char(a.hora, 'HH24:MI:SS') AS fecha_movimiento, /*-- descripcion de la red de pago adquiriente
'DEPOSITO '||creditopy.Pkg_Dimo_Ceibo.FN_GET_RED(a.acquiring_institution)
as nombre_comercio,*/
-- glosa de la transaccion
creditopy.Pkg_Dimo_Ceibo.fn_get_glosa_aut_trxs(a.nro_tarjeta,
'P', -- pago/deposito
a.fecha,
a.hora,
a.numero_auditoria,
a.nro_ticket,
0,
a.nro_comercio,
a.emisor,
a.acquiring_institution) AS nombre_comercio,
0 AS cupon,
a.nro_autorizacion AS autorizacion,
a.importe AS importe,
e.descripcion AS moneda,
--to_char(a.autextfch,'DD/MM/YYYY') as fecha_proceso,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Deposito OnLine' AS estado_mov,
-- los pagos no son consumos, no incluir datos del ramo del comercio
0 AS idramo,
' ' AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
0 AS talon
FROM creditopy.log_transacc_cr@olpy a,
debcredpy.monedas e,
creditopy.tarjetas t
WHERE a.emisor = pi_emisor
-- los pagos en linea solo se muestran en el periodo actual
AND vb_is_periodo_actual = 1
AND a.nro_cuenta = pi_numero_cuenta
AND a.producto = 1
AND a.plan = 6
AND tx_interna IN ('PAGO', 'REVERSO')
AND importe > 0
AND a.tipo_autorizacion = 'A'
AND -- consideraciones para pagos
-- no deben estar en proceso de cierre
(autextproc IS NULL OR
-- si estan en proceso de cierre
-- solo se incluyen mientras no termina el proceso de carga de pagos
(autextproc IS NOT NULL AND
1 =
nvl((SELECT MAX(1)
FROM creditopy.CONTROL_DATOS cd
WHERE cd.nombre_proceso = 'PAGOS'
AND cd.fecha_proceso >= trunc(autextfch)
AND cd.resultado = 0),
0)))
AND t.tarjeta = a.nro_tarjeta
AND e.producto = t.producto
AND e.codigo_de_moneda = a.moneda
-- si es la titular muestra los pagos de todas las tarjetas, sino solo los de la tarjeta
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
'1', -- pi_flg_adicional: debe desplegar los pagos aunque entraron con otra tarjeta
t.adicional, -- de la tarjeta del movimiento
t.componente) -- de la tarjeta del movimiento
UNION ALL
SELECT
-- 4.3 los MOVIMIENTOS DE AJUSTES que se cargaron a la cuenta
-- se obtiene de la CONSULTA2 de la regla 10974
b.numero_cuenta AS cuenta,
t.tarjeta AS tarjeta,
a.fecha_movimiento AS fecha_movimiento_date,
to_char(a.fecha_movimiento, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del rubro con el que se factura y el nombre del comercio para los consumos
creditopy.pkg_dimo_ceibo.fn_get_leyenda_movimiento(a.emisor,
a.numero_cuenta,
a.rubro,
a.codigo_operacion,
decode(a.tipo_de_moneda,
1,
830,
840),
a.importe,
a.fecha_movimiento,
a.fecha_proceso,
a.numero_talon,
nvl(cu.comercio_cabal,
0),
a.leyenda) AS nombre_comercio,
CASE
WHEN cu.comercio_cabal > 0 THEN
cu.numero_cupon
ELSE
to_number(nvl(a.numero_talon, '0'))
END AS cupon,
CASE
WHEN cu.comercio_cabal > 0 THEN
cu.numero_autorizacion
ELSE
0
END AS autorizacion,
a.importe AS importe,
e.descripcion AS moneda,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Ajuste OnLine' AS estado_mov,
-- los ajustes no son consumos, no incluir datos del ramo del comercio
0 AS idramo,
' ' AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
to_number(to_char(a.fecha_proceso, 'yyyymmddhh24miss')) AS talon
FROM creditopy.alta_movimientos_ajustes@olpy a,
creditopy.cuentas b,
creditopy.rubros ru,
debcredpy.monedas e,
creditopy.cupones cu,
creditopy.tarjetas t
WHERE b.emisor = pi_emisor
-- los ajustes en linea solo se muestran en el periodo actual
AND vb_is_periodo_actual = 1
AND b.cierre = pi_cierre
AND b.numero_cuenta = pi_numero_cuenta
AND a.emisor = b.emisor
AND a.sucursal_emisor = b.sucursal_emisor
AND a.producto = b.producto
AND a.periodo_cierre <= pi_periodo_actual_tarjeta
AND -- consideraciones para ajustes del online
-- no deben estar en proceso de cierre
(nvl(a.procesado, 'N') != 'S' OR
-- si estan en proceso de cierre
-- solo se incluyen mientras no termina el proceso de carga de ajustes
(nvl(a.procesado, 'N') = 'S' AND
1 = nvl((SELECT MAX(1)
FROM creditopy.CONTROL_DATOS cd
WHERE cd.nombre_proceso = 'AJUSTES'
AND cd.fecha_proceso >=
trunc(a.fecha_proceso)
AND cd.resultado = 0),
0)))
AND a.numero_cuenta = b.numero_cuenta
AND a.rubro = ru.rubro
AND e.producto = a.producto
AND e.codigo_de_moneda =
decode(a.tipo_de_moneda, 1, 830, 840)
AND cu.cupon(+) = CASE
WHEN a.rubro = 3577 THEN
to_number(substr(a.leyenda, 2, 13))
ELSE
-1
END
-- obtener la tarjeta (cuenta+adicional) a la que se aplica el ajuste
AND t.numero_cuenta = a.numero_cuenta
AND t.adicional = CASE
WHEN 1 = (SELECT 1
FROM creditopy.codigos_py cp
WHERE cp.tipo_codigo = 14
AND TRIM(cp.valor) = a.rubro) OR
upper(substr(a.leyenda, 4, 5)) = 'CUOTA' THEN
to_number(substr(a.leyenda, 1, 2))
WHEN a.rubro = 3577 THEN
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta =
nvl(cu.tarjeta_externa,
creditopy.fc_tjtp(a.numero_cuenta)))
ELSE
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta =
creditopy.fc_tjtp(a.numero_cuenta))
END
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
ORDER BY fecha_movimiento_date,
cupon,
autorizacion,
talon) fila
ORDER BY orden);
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_movimientosdimo;
PROCEDURE sp_movimientosTC(PI_EMISOR IN VARCHAR2, -- Identificador del emisor
PI_PERIODO_ACTUAL_TARJETA IN VARCHAR2, -- Periodo actual de la tarjeta
PI_CIERRE IN VARCHAR2, -- Ultimo Periodo de cierre
PI_NUMERO_TARJETA IN VARCHAR2, -- PAN tarjeta
PI_NUMERO_CUENTA IN VARCHAR2, -- Numero de cuenta de la tarjeta
PI_ADICIONAL IN VARCHAR2, -- Adicional
PI_FLG_ADICIONAL IN VARCHAR2, -- Boolean que indica si se obtienen movimientos de tarjetas adicionales
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
17.2 - Consulta movimientos TC
*/
/****************************************************************************************************
Autor: Juan Carlos Soto / Amalia Rodriguez - PKG_MICABAL
Fecha: 29/04/2019
Propósito: Procedimiento que devuelve..
pi_flg_adicionales valores
0 - no icluye los movimientos de las adicionales
1 - incluye los movimientos de las adicionales
Cursor:
- idramo, descramo: no se informan los ramos:
96 ADQUISICION CARTERA
97 REFINANCIACIONES
98 CUOTIZACION
- cred: valores posibles de codigo_operacion
codigo_operacion = 0 - compras (debito al usuario) ó
1 - devoluciones (credito al usuario)
****************************************************************************************************/
vn_componente_tar_param NUMBER;
vc_tarjeta creditopy.tarjetas.tarjeta%TYPE;
BEGIN
vc_tarjeta := creditopy.fc_pan2cripto(pi_numero_tarjeta);
-- se valida existencia de la tarjeta antes de consultar
-- solo emisor de tarjeta de credito
BEGIN
SELECT t.componente
INTO vn_componente_tar_param
FROM creditopy.tarjetas t
WHERE t.tarjeta = vc_tarjeta
AND t.emisor = pi_emisor
-- solo habilita emisor de tarjeta de credito
AND creditopy.pkg_dimo_ceibo.fn_is_prepaga(t.emisor) = 0
AND t.numero_cuenta = pi_numero_cuenta
AND t.adicional = pi_adicional;
EXCEPTION
-- no puede darse por valido si es no_data_found porque debio pasar por
-- las validaciones previas
WHEN no_data_found THEN
raise_application_error(-20001, 'Tarjeta invalida.');
WHEN OTHERS THEN
RAISE;
END;
OPEN po_cursor FOR
SELECT fila.*, rownum orden
FROM (
/*
1. consulta de AUTORIZACIONES PROCESADAS DEL BATCH no cuponadas, tomada de la regla 10014
*/
SELECT a.numero_cuenta AS cuenta,
a.tarjeta AS tarjeta,
a.fecha AS fecha_movimiento_date,
to_char(a.fecha, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del comercio
creditopy.Pkg_Dimo_Ceibo.fn_get_comercio_desc(o.emisor_procesador,
o.comercio,
a.emisor) AS nombre_comercio,
nvl(a.numero_ticket, 0) AS cupon,
a.numero_autorizacion AS autorizacion,
a.monto_compra AS importe,
e.descripcion AS moneda,
d.descripcion AS plan_venta,
CASE
WHEN a.cantidad_cuotas > 1 THEN
' (' || a.cantidad_cuotas || ' Cuotas)'
ELSE
' '
END AS cuotas,
--to_char(a.fecha_negocio,'DD/MM/YYYY') as fecha_proceso,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Reserva' AS estado_mov,
-- datos del ramo del comercio para grafico de consumo
creditopy.Pkg_Dimo_Ceibo.fn_get_cod_ramo_barra(o.emisor_procesador,
o.ramo,
o.comercio) AS idramo,
creditopy.Pkg_Dimo_Ceibo.fn_get_desc_ramo_barra(o.emisor_procesador,
o.ramo,
o.comercio) AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
-- flag indicador de consulta adicional de cuotas con interes e IVA
0 AS flg_detalle_cuota,
0 AS cuota_amortizacion,
0 AS cuota_interes,
0 AS cuota_IVA,
0 AS flg_interes_plan,
0 AS talon
FROM creditopy.autorizaciones a,
creditopy.comercios o,
creditopy.planes_de_venta d,
debcredpy.monedas e,
creditopy.acquirers h,
creditopy.tarjetas t
WHERE a.numero_cuenta = pi_numero_cuenta
AND CASE autorizante
WHEN 'Incoming' THEN
9999998
ELSE
a.numero_comercio
END = o.comercio
AND a.producto >= -1
AND e.producto = a.producto
AND e.codigo_de_moneda = a.moneda_compra
AND d.plan_venta = a.plan_venta
AND h.acquirer = CASE autorizante
WHEN 'Incoming' THEN
'490000'
ELSE
autorizante
END
AND a.baja IN (' ', '0')
AND t.tarjeta = a.tarjeta
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente) -- de la tarjeta del movimiento
UNION ALL
/*
2. consulta de MOVIMIENTOS DEL PERIODO ACTUAL
Se obtiene de la regla 10973 para consulta al bapy, que esta compuesta de 4 consultas pero
se utilizan solo la 1 y la 2, porque el interes y el IVA se suman en la cuota correspondiente.
La consulta del IVA es solo para los cargos que hayan aplicado en la diaria y ya se visualizan.
Se consulta por numero_cuenta, la principal ve todo lo que se le va a facturar,
incluidas las transacciones de sus adicionales porque hacen a su deuda
*/
SELECT
-- 2.1 Movimientos facturados:
-- Los movimientos se facturan con un rubro que se despliega en el nombre del comercio
-- Los consumos ingresan con un rubro y para ese caso se debe incluir el nombre
-- del comercio (compra o debito automático)
-- Los consumos en el extranjero se despliegan XXXXXXX <<< definir igual que en los extractos
-- Para cuotas decaidas anticipadamente, se suman al importe el interes y el IVA
b.numero_cuenta AS cuenta,
t.tarjeta AS tarjeta,
a.fecha_movimiento AS fecha_movimiento_date,
to_char(a.fecha_movimiento, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del comercio (consumos) o
-- descripcion del rubro con el que se factura (pagos, cargos)
-- y el concepto para los ajustes (tipo_de_rubro = 3) que tengan leyenda (concepto)
CASE
WHEN ru.tipo_de_rubro = 1 THEN
creditopy.Pkg_Dimo_Ceibo.fn_get_comercio_desc(nvl(o.emisor_procesador,
0),
a.numero_comercio,
a.emisor,
a.rubro,
ru.tipo_de_rubro,
a.compra_exterior,
a.numero_cupon_interno)
ELSE
creditopy.pkg_dimo_ceibo.fn_get_leyenda_movimiento(a.emisor,
a.numero_cuenta,
a.rubro,
a.codigo_operacion,
a.moneda,
a.importe_ml,
a.fecha_movimiento,
a.fecha_valor,
a.numero_talon,
a.numero_comercio,
NULL)
END AS nombre_comercio,
-- numero de cupon y autorizacion solo importan cuando es un consumo
CASE
WHEN a.numero_comercio > 0 THEN
a.numero_cupon
ELSE
0
END AS cupon,
CASE
WHEN a.numero_comercio > 0 THEN
cu.numero_autorizacion
ELSE
0
END AS autorizacion,
CASE
WHEN ru.tipo_de_rubro = 1 AND a.son > 1 THEN
a.importe_ml + nvl(c.importe_producto, 0) +
nvl(c.importe_impuesto, 0)
ELSE
a.importe_ml
END AS importe,
e.descripcion AS moneda,
-- plan solo importa cuando es un consumo (el tipo_de_rubro debe ser 1)
CASE
WHEN a.son > 1 OR ru.tipo_de_rubro = 1 THEN -- << por que pregunte por son > 1???
creditopy.Pkg_Dimo_Ceibo.fn_get_plan_venta_desc(cu.plan_venta)
ELSE
' '
END AS plan_venta,
CASE
WHEN a.son > 1 --or ru.tipo_de_rubro = 1
THEN
' (Cuota ' || a.van || '/' || a.son || ')'
ELSE
' '
END AS cuotas,
to_char(a.fecha_valor, 'DD/MM/YYYY') AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Procesado' AS estado_mov,
-- datos del ramo del comercio para grafico de consumo
-- si es un consumo solo se despliega el ramo cuando es la cuota 1, por ser la compra inicial
CASE
WHEN ru.tipo_de_rubro = 1 AND a.van = 1 THEN
creditopy.Pkg_Dimo_Ceibo.fn_get_cod_ramo_barra(nvl(o.emisor_procesador,
0),
nvl(o.ramo, 0),
nvl(o.comercio,
0))
ELSE
0
END AS idramo,
CASE
WHEN ru.tipo_de_rubro = 1 AND a.van = 1 THEN
creditopy.Pkg_Dimo_Ceibo.fn_get_desc_ramo_barra(nvl(o.emisor_procesador,
0),
nvl(o.ramo, 0),
nvl(o.comercio,
0))
ELSE
' '
END AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
-- flag indicador de consulta adicional de cuotas con interes e IVA
-- en esta consulta se condiciona cuando es una cuota de una compra,
-- (no se aplica para cargos en cuotas) y se informa el capital amortizado,
-- el interes y el IVA
CASE
WHEN ru.tipo_de_rubro = 1 AND a.son > 1 THEN
1
ELSE
0
END AS flg_detalle_cuota,
a.importe_ml AS cuota_amortizacion,
nvl(c.importe_producto, 0) AS cuota_interes,
nvl(c.importe_impuesto, 0) AS cuota_IVA,
CASE
WHEN ru.tipo_de_rubro = 1 AND a.son > 1 THEN
CASE
WHEN a.rubro = 1100 THEN
0
ELSE
1
END
ELSE
0
END AS flg_interes_plan,
to_number(TRIM(a.numero_talon)) AS talon
FROM creditopy.movtos_cuentas a,
creditopy.cuentas b,
creditopy.rubros ru,
debcredpy.monedas e,
creditopy.cupones cu,
creditopy.comercios o,
creditopy.movs_prods_imps c,
creditopy.tarjetas t
WHERE a.emisor = pi_emisor
AND a.periodo_cierre = pi_periodo_actual_tarjeta
AND a.cierre = pi_cierre
AND a.numero_cuenta = pi_numero_cuenta
AND b.emisor = a.emisor
AND b.sucursal_emisor = a.sucursal_emisor
AND b.producto = a.producto
AND b.numero_cuenta = a.numero_cuenta
AND ru.rubro = a.rubro
AND e.producto = a.producto
AND e.codigo_de_moneda = a.moneda
AND cu.cupon(+) = CASE
WHEN a.numero_comercio > 0 THEN
a.numero_cupon_interno
ELSE
-1
END
AND o.comercio(+) = CASE
WHEN a.numero_comercio > 0 THEN
a.numero_comercio
ELSE
-1
END
AND a.prods_imps = c.prods_imps(+)
AND t.numero_cuenta = a.numero_cuenta
-- los cargos de la cuenta se registran con adicional = 1 pero
-- deben desplegarse referenciando a la tarjeta principal
AND t.adicional = CASE
WHEN a.adicional = 1 THEN
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta = creditopy.fc_tjtp(a.numero_cuenta))
ELSE
a.adicional
END
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
UNION ALL
SELECT
-- 2.2. IVA de los movimientos facturados. Se ajusta para que no incluya las compras en planes
-- que hayan decaido antes de la facturacion, ya que los movimientos de cuotas totalizan
-- el importe de la amortizacion (cuota) más intereses e iva sobre el interes
b.numero_cuenta AS cuenta,
t.tarjeta AS tarjeta,
a.fecha_movimiento AS fecha_movimiento_date,
to_char(a.fecha_movimiento, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del rubro con el que se factura
'I.V.A.' AS nombre_comercio,
-- numero de cupon y autorizacion solo importan cuando es un consumo
0 AS cupon,
0 AS autorizacion,
a.importe_ml AS importe,
e.descripcion AS moneda,
-- plan solo importa cuando es un consumo (el tipo_de_rubro debe ser 1)
' ' AS plan_venta,
CASE
WHEN a.son > 1 THEN
' (Cuota ' || a.van || '/' || a.son || ')'
ELSE
' '
END AS cuotas,
to_char(a.fecha_valor, 'DD/MM/YYYY') AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Procesado IVA' AS estado_mov,
-- no se debe incluir datos del ramo del comercio para los intereses
0 AS idramo,
' ' AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
-- flag indicador de consulta adicional de cuotas con interes e IVA
0 AS flg_detalle_cuota,
0 AS cuota_amortizacion,
0 AS cuota_interes,
0 AS cuota_IVA,
0 AS flg_interes_plan,
to_number(TRIM(a.numero_talon)) AS talon
FROM creditopy.movtos_cuentas a,
creditopy.cuentas b,
creditopy.rubros ru,
debcredpy.monedas e,
creditopy.movs_prods_imps c,
creditopy.tarjetas t
WHERE a.emisor = pi_emisor
AND a.periodo_cierre = pi_periodo_actual_tarjeta
AND a.cierre = pi_cierre
AND a.numero_cuenta = pi_numero_cuenta
AND b.emisor = a.emisor
AND b.sucursal_emisor = a.sucursal_emisor
AND b.producto = a.producto
AND b.numero_cuenta = a.numero_cuenta
AND ru.rubro = a.rubro
AND ru.tipo_de_rubro != 1 -- no se toman los IVA de rubros de compras en planes (cupones en cuotas)
AND e.producto = a.producto
AND e.codigo_de_moneda = a.moneda
-- solo si tienen IVA calculado
AND a.prods_imps = c.prods_imps
AND nvl(c.importe_impuesto, 0) != 0 -- en esta columna estan los interese calculados de cuotas de planes
AND t.numero_cuenta = a.numero_cuenta
-- los cargos de la cuenta se registran con adicional = 1 pero
-- deben desplegarse referenciando a la tarjeta principal
AND t.adicional = CASE
WHEN a.adicional = 1 THEN
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta = creditopy.fc_tjtp(a.numero_cuenta))
ELSE
a.adicional
END
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
UNION ALL
SELECT
-- 2.3 Movimientos en proceso de cierre diario aun no facturados: corresponden a
-- ajustes credito o debito y que ingresan con un rubro.
-- Incluye los descuentos por promocion en cuyo caso se relaciona a un consumo
-- y debe indicar el comercio y cupon al que se aplica
-- Algunos ajustes corresponden a cargos que se en cuotas e ingresan como ajustes
-- en cuyo caso se debe indicar las cuotas
b.numero_cuenta AS cuenta,
t.tarjeta AS tarjeta,
a.fecha_movimiento AS fecha_movimiento_date,
to_char(a.fecha_movimiento, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del rubro con el que se factura y el nombre del comercio para los consumos
creditopy.pkg_dimo_ceibo.fn_get_leyenda_movimiento(a.emisor,
a.numero_cuenta,
a.rubro,
a.codigo_operacion,
decode(a.tipo_de_moneda,
1,
830,
840),
a.importe,
a.fecha_movimiento,
a.fecha_proceso,
a.numero_talon,
nvl(cu.comercio_cabal,
0),
a.leyenda) AS nombre_comercio,
CASE
WHEN cu.comercio_cabal > 0 THEN
cu.numero_cupon
ELSE
to_number(TRIM(a.numero_talon))
END AS cupon,
CASE
WHEN cu.comercio_cabal > 0 THEN
cu.numero_autorizacion
ELSE
0
END AS autorizacion,
a.importe AS importe,
e.descripcion AS moneda,
' ' AS plan_venta,
CASE
WHEN 1 = (SELECT 1
FROM creditopy.codigos_py cp
WHERE cp.tipo_codigo = 14
AND TRIM(cp.valor) = a.rubro) OR
upper(substr(a.leyenda, 4, 5)) = 'CUOTA' THEN
CASE
WHEN substr(a.leyenda, 16, 2) > 1 THEN
' (Cuota ' || substr(a.leyenda, 10, 2) || '/' ||
substr(a.leyenda, 16, 2) || ')'
ELSE
' '
END
ELSE
' '
END AS cuotas,
--to_char(a.fecha_proceso,'DD/MM/YYYY') as fecha_proceso,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'En Proceso' AS estado_mov,
-- los ajustes no son consumos, no incluir datos del ramo del comercio
0 AS idramo,
' ' AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
-- flag indicador de consulta adicional de cuotas con interes e IVA
0 AS flg_detalle_cuota,
0 AS cuota_amortizacion,
0 AS cuota_interes,
0 AS cuota_IVA,
0 AS flg_interes_plan,
to_number(TRIM(a.numero_talon)) AS talon
FROM creditopy.movimientos_ajustes a,
creditopy.cuentas b,
creditopy.rubros ru,
debcredpy.monedas e,
creditopy.cupones cu,
creditopy.tarjetas t
WHERE b.emisor = pi_emisor
AND b.cierre = pi_cierre
AND b.numero_cuenta = pi_numero_cuenta
AND a.emisor = b.emisor
AND a.sucursal_emisor = b.sucursal_emisor
AND a.producto = b.producto
AND a.periodo_cierre = pi_periodo_actual_tarjeta
AND nvl(a.procesado, 'N') != 'S'
AND a.numero_cuenta = b.numero_cuenta
AND a.rubro = ru.rubro
AND e.producto = a.producto
AND e.codigo_de_moneda =
decode(a.tipo_de_moneda, 1, 830, 840)
AND cu.cupon(+) = CASE
WHEN a.rubro = 3577 THEN
to_number(substr(a.leyenda, 2, 13))
ELSE
-1
END
-- obtener la tarjeta (cuenta+adicional) a la que se aplica el ajuste
AND t.numero_cuenta = a.numero_cuenta
AND t.adicional = CASE
WHEN 1 = (SELECT 1
FROM creditopy.codigos_py cp
WHERE cp.tipo_codigo = 14
AND TRIM(cp.valor) = a.rubro) OR
substr(a.leyenda, 4, 5) = 'Cuota' THEN
to_number(substr(a.leyenda, 1, 2))
WHEN a.rubro = 3577 THEN
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta =
nvl(cu.tarjeta_externa,
creditopy.fc_tjtp(a.numero_cuenta)))
ELSE
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta = creditopy.fc_tjtp(a.numero_cuenta))
END
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
UNION ALL
/*
3. consulta de PLANES pendientes de facturar (cuota e interes)
*/
SELECT
-- 3.1 planes amortizables amortizables (con intereses) pendientes de facturacion
-- al importe de la cuota se le suman los intereses y el IVA
pa.numero_cuenta AS cuenta,
pa.tarjeta_ext AS tarjeta,
pa.fecha_cupon AS fecha_movimiento_date,
to_char(pa.fecha_cupon, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del comercio
TRIM(c.descripcion) AS nombre_comercio,
nvl(pa.numero_de_cupon, 0) AS cupon,
cu.numero_autorizacion AS autorizacion,
--pa.cuota_am as importe,
pa.cuota_am + pa.interes_am AS importe,
e.descripcion AS moneda,
d.descripcion AS plan_venta,
CASE
WHEN pa.cuotas_son > 1 THEN
' (Cuota ' || pa.cuotas_van || '/' || pa.cuotas_son || ')'
ELSE
' '
END AS cuotas,
-- las cuotas a facturar no tienen fecha de proceso
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Plan a facturar' AS estado_mov,
-- datos del ramo del comercio para grafico de consumo, si no es ramo 96, 97 o 98
-- solo despliega el ramo para la primera cuota, por ser consumo del mes
CASE
WHEN c.ramo NOT IN (96, 97, 98) --and pa.cuotas_van = 1
THEN
c.ramo
ELSE
0
END AS idramo,
CASE
WHEN c.ramo NOT IN (96, 97, 98) --and pa.cuotas_van = 1
THEN
r.descripcion
ELSE
' '
END AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
1,
0) AS cred,
-- flag indicador de consulta adicional de cuotas con interes e IVA
-- en esta consulta se informa el capital amortizado y el interes,
-- en este estadio, antes de facturar, no hay IVA aplicado, ya que
-- eso se calcula en base a los parametros al facturar
1 AS flg_detalle_cuota,
pa.cuota_am AS cuota_amortizacion,
pa.interes_am AS cuota_interes,
0 AS cuota_IVA,
1 AS flg_interes_plan,
0 AS talon
FROM creditopy.planes_amortizables pa,
creditopy.comercios c,
creditopy.planes_de_venta d,
debcredpy.monedas e,
creditopy.ramos r,
creditopy.cupones cu,
creditopy.tarjetas t
WHERE pa.numero_cuenta = pi_numero_cuenta
AND pa.marca_vigente = 1
AND pa.numero_comercio = c.comercio
AND d.plan_venta = pa.plan_amortizable
AND e.producto = pa.producto
AND e.codigo_de_moneda =
decode(pa.tipo_de_moneda, 1, 830, 40)
AND r.emisor_procesador = c.emisor_procesador
AND r.ramo = c.ramo
AND cu.cupon = pa.numero_cupon_interno
AND t.tarjeta = pa.tarjeta_ext
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
UNION ALL
SELECT
-- 3.2 planes pagos (planes sin interes) pendientes de facturacion
pp.numero_cuenta AS cuenta,
pp.tarjeta_ext AS tarjeta,
pp.fecha_cupon AS fecha_movimiento_date,
to_char(pp.fecha_cupon, 'DD/MM/YYYY') AS fecha_movimiento,
TRIM(c.descripcion) AS nombre_comercio, -- descripcion del comercio
nvl(pp.numero_de_cupon, 0) AS cupon,
cu.numero_autorizacion AS autorizacion,
pp.importe_cuota AS importe,
e.descripcion AS moneda,
d.descripcion AS plan_venta,
CASE
WHEN pp.cuotas_son > 1 THEN
' (Cuota ' || pp.cuotas_van || '/' || pp.cuotas_son || ')'
ELSE
' '
END AS cuotas,
-- las cuotas a facturar no tienen fecha de proceso
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Plan a facturar' AS estado_mov,
-- datos del ramo del comercio para grafico de consumo, si no es ramo 96, 97 o 98
-- solo despliega el ramo para la primera cuota, por ser consumo del mes
CASE
WHEN c.ramo NOT IN (96, 97, 98) --and pp.cuotas_van = 1
THEN
c.ramo
ELSE
0
END AS idramo,
CASE
WHEN c.ramo NOT IN (96, 97, 98) --and pp.cuotas_van = 1
THEN
r.descripcion
ELSE
' '
END AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
1,
0) AS cred,
-- flag indicador de consulta adicional de cuotas con interes e IVA
0 AS flg_detalle_cuota,
0 AS cuota_amortizacion,
0 AS cuota_interes,
0 AS cuota_IVA,
0 AS flg_interes_plan,
0 AS talon
FROM creditopy.planes_pagos pp,
creditopy.comercios c,
creditopy.planes_de_venta d,
debcredpy.monedas e,
creditopy.ramos r,
creditopy.cupones cu,
creditopy.tarjetas t
WHERE pp.numero_cuenta = pi_numero_cuenta
AND pp.marca_vigente = 1
AND pp.numero_comercio = c.comercio
AND d.plan_venta = pp.plan_pago
AND e.producto = pp.producto
AND e.codigo_de_moneda =
decode(pp.tipo_de_moneda, 1, 830, 40)
AND r.emisor_procesador = c.emisor_procesador
AND r.ramo = c.ramo
AND cu.cupon = pp.numero_cupon_interno
AND t.tarjeta = pp.tarjeta_ext
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
UNION ALL
/*
4. Consultas ONLINE: autorizaciones, pagos y ajustes
*/
SELECT
-- 4.1 consulta de AUTORIZACIONES de COMPRA pendientes del Online tomada de la regla 10014
a.nro_cuenta AS cuenta,
a.nro_tarjeta AS tarjeta,
a.fecha AS fecha_movimiento_date,
to_char(a.fecha, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del comercio
creditopy.Pkg_Dimo_Ceibo.fn_get_comercio_desc(c.emisor_procesador,
c.comercio,
a.emisor) AS nombre_comercio,
nvl(to_number(a.nro_ticket), 0) AS cupon,
a.nro_autorizacion AS autorizacion,
a.importe AS importe,
e.descripcion AS moneda,
d.descripcion AS plan_venta,
CASE
WHEN a.cuotas > 1 THEN
' (' || a.cuotas || ' Cuotas)'
ELSE
' '
END AS cuotas,
--to_char(a.autextfch,'DD/MM/YYYY') as fecha_proceso,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Tx OnLine' AS estado_mov,
-- datos del ramo del comercio para grafico de consumo
creditopy.Pkg_Dimo_Ceibo.fn_get_cod_ramo_barra(c.emisor_procesador,
c.ramo,
c.comercio) AS idramo,
creditopy.Pkg_Dimo_Ceibo.fn_get_desc_ramo_barra(c.emisor_procesador,
c.ramo,
c.comercio) AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
-- flag indicador de consulta adicional de cuotas con interes e IVA
0 AS flg_detalle_cuota,
0 AS cuota_amortizacion,
0 AS cuota_interes,
0 AS cuota_IVA,
0 AS flg_interes_plan,
0 AS talon
FROM creditopy.log_transacc_cr@olpy a,
creditopy.comercios c,
creditopy.planes_de_venta d,
debcredpy.monedas e,
creditopy.ramos r,
creditopy.tarjetas t
WHERE a.emisor = pi_emisor
AND a.nro_cuenta = pi_numero_cuenta
AND a.nro_comercio = c.comercio
AND a.TX_INTERNA NOT IN ('OFF COMP', 'OFF DEV') -- no incluir off-line
AND a.producto >= -1
AND d.plan_venta >= -1
AND d.plan_venta = a.plan
AND nvl(a.tipo_autorizacion, 'R') = 'A'
AND a.autextproc IS NULL
AND r.emisor_procesador = c.emisor_procesador
AND r.ramo = c.ramo
AND t.tarjeta = a.nro_tarjeta
AND e.producto = t.producto
AND e.codigo_de_moneda = a.moneda
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente) -- de la tarjeta del movimiento
UNION ALL
SELECT
-- 4.2 PAGOS de la fecha: los pagos entran a la cuenta, aunque se registren con una tarjeta
-- se obtiene de la CONSULTA1 de la regla 10974
a.nro_cuenta AS cuenta,
a.nro_tarjeta AS tarjeta,
a.fecha AS fecha_movimiento_date,
to_char(a.fecha, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion de la red de pago adquiriente
decode(a.TX_INTERNA,
'PAGO',
'SU PAGO ',
'REVERSO',
'Rev PAGO ',
a.TX_INTERNA) ||
creditopy.Pkg_Dimo_Ceibo.FN_GET_RED(a.acquiring_institution) AS nombre_comercio,
0 AS cupon,
a.nro_autorizacion AS autorizacion,
a.importe AS importe,
e.descripcion AS moneda,
' ' AS plan_venta,
' ' AS cuotas,
--to_char(a.autextfch,'DD/MM/YYYY') as fecha_proceso,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Pagos OnLine' AS estado_mov,
-- los pagos no son consumos, no incluir datos del ramo del comercio
0 AS idramo,
' ' AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
-- flag indicador de consulta adicional de cuotas con interes e IVA
0 AS flg_detalle_cuota,
0 AS cuota_amortizacion,
0 AS cuota_interes,
0 AS cuota_IVA,
0 AS flg_interes_plan,
0 AS talon
FROM creditopy.log_transacc_cr@olpy a,
debcredpy.monedas e,
creditopy.tarjetas t
WHERE a.emisor = pi_emisor
AND a.nro_cuenta = pi_numero_cuenta
--and a.TX_INTERNA IN ('OFF COMP', 'OFF DEV') -- no se requiere controlar porque se filtran solo 'PAGO'
AND a.producto = 1
AND a.plan = 6
AND tx_interna IN ('PAGO', 'REVERSO')
AND importe > 0
AND a.tipo_autorizacion = 'A'
AND -- consideraciones para pagos
-- no deben estar en proceso de cierre
(autextproc IS NULL OR
-- si estan en proceso de cierre
-- solo se incluyen mientras no termina el proceso de carga de pagos
(autextproc IS NOT NULL AND
1 = nvl((SELECT MAX(1)
FROM creditopy.CONTROL_DATOS cd
WHERE cd.nombre_proceso = 'PAGOS'
AND cd.fecha_proceso >= trunc(autextfch)
AND cd.resultado = 0),
0)))
AND t.tarjeta = a.nro_tarjeta
AND e.producto = t.producto
AND e.codigo_de_moneda = a.moneda
-- si es la titular muestra los pagos de todas las tarjetas, sino solo los de la tarjeta
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
'1', -- pi_flg_adicional: debe desplegar los pagos aunque entraron con otra tarjeta
t.adicional, -- de la tarjeta del movimiento
t.componente) -- de la tarjeta del movimiento
UNION ALL
SELECT
-- 4.3 los MOVIMIENTOS DE AJUSTES que se cargaron a la cuenta
-- se obtiene de la CONSULTA2 de la regla 10974
b.numero_cuenta AS cuenta,
t.tarjeta AS tarjeta,
a.fecha_movimiento AS fecha_movimiento_date,
to_char(a.fecha_movimiento, 'DD/MM/YYYY') AS fecha_movimiento,
-- descripcion del rubro con el que se factura y el nombre del comercio para los consumos
creditopy.pkg_dimo_ceibo.fn_get_leyenda_movimiento(a.emisor,
a.numero_cuenta,
a.rubro,
a.codigo_operacion,
decode(a.tipo_de_moneda,
1,
830,
840),
a.importe,
a.fecha_movimiento,
a.fecha_proceso,
a.numero_talon,
nvl(cu.comercio_cabal,
0),
a.leyenda) AS nombre_comercio,
CASE
WHEN cu.comercio_cabal > 0 THEN
cu.numero_cupon
ELSE
to_number(nvl(a.numero_talon, '0'))
END AS cupon,
CASE
WHEN cu.comercio_cabal > 0 THEN
cu.numero_autorizacion
ELSE
0
END AS autorizacion,
a.importe AS importe,
e.descripcion AS moneda,
' ' AS plan_venta,
CASE
WHEN 1 = (SELECT 1
FROM creditopy.codigos_py cp
WHERE cp.tipo_codigo = 14
AND TRIM(cp.valor) = a.rubro) OR
upper(substr(a.leyenda, 4, 5)) = 'CUOTA' THEN
CASE
WHEN substr(a.leyenda, 16, 2) > 1 THEN
' (Cuota ' || substr(a.leyenda, 10, 2) || '/' ||
substr(a.leyenda, 16, 2) || ')'
ELSE
' '
END
ELSE
' '
END AS cuotas,
' ' AS fecha_proceso,
-- datos de la tarjeta del movimiento
t.adicional AS adicional,
decode(t.componente, 1, 'TITULAR', 'ADICIONAL') AS tipo_tarjeta,
-- tipo de movimiento desplegado
'Ajuste OnLine' AS estado_mov,
-- los ajustes no son consumos, no incluir datos del ramo del comercio
0 AS idramo,
' ' AS descramo,
-- operaciones credito
decode(creditopy.Pkg_Dimo_Ceibo.fn_is_prepaga(t.emisor),
1,
decode(a.codigo_operacion, 1, 0, 1),
a.codigo_operacion) AS cred,
-- flag indicador de consulta adicional
0 AS flg_detalle_cuota,
0 AS cuota_amortizacion,
0 AS cuota_interes,
0 AS cuota_IVA,
0 AS flg_interes_plan,
to_number(to_char(a.fecha_proceso, 'yyyymmddhh24miss')) AS talon
FROM creditopy.alta_movimientos_ajustes@olpy a,
creditopy.cuentas b,
creditopy.rubros ru,
debcredpy.monedas e,
creditopy.cupones cu,
creditopy.tarjetas t
WHERE b.emisor = pi_emisor
AND b.cierre = pi_cierre
AND b.numero_cuenta = pi_numero_cuenta
AND a.emisor = b.emisor
AND a.sucursal_emisor = b.sucursal_emisor
AND a.producto = b.producto
AND a.periodo_cierre = pi_periodo_actual_tarjeta
AND -- consideraciones para ajustes del online
-- no deben estar en proceso de cierre
(nvl(a.procesado, 'N') != 'S' OR
-- si estan en proceso de cierre
-- solo se incluyen mientras no termina el proceso de carga de ajustes
(nvl(a.procesado, 'N') = 'S' AND
1 =
nvl((SELECT MAX(1)
FROM creditopy.CONTROL_DATOS cd
WHERE cd.nombre_proceso = 'AJUSTES'
AND cd.fecha_proceso >= trunc(a.fecha_proceso)
AND cd.resultado = 0),
0)))
AND a.numero_cuenta = b.numero_cuenta
AND a.rubro = ru.rubro
AND e.producto = a.producto
AND e.codigo_de_moneda =
decode(a.tipo_de_moneda, 1, 830, 840)
AND cu.cupon(+) = CASE
WHEN a.rubro = 3577 THEN
to_number(substr(a.leyenda, 2, 13))
ELSE
-1
END
-- obtener la tarjeta (cuenta+adicional) a la que se aplica el ajuste
AND t.numero_cuenta = a.numero_cuenta
AND t.adicional = CASE
WHEN 1 = (SELECT 1
FROM creditopy.codigos_py cp
WHERE cp.tipo_codigo = 14
AND TRIM(cp.valor) = a.rubro) OR
upper(substr(a.leyenda, 4, 5)) = 'CUOTA' THEN
to_number(substr(a.leyenda, 1, 2))
WHEN a.rubro = 3577 THEN
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta =
nvl(cu.tarjeta_externa,
creditopy.fc_tjtp(a.numero_cuenta)))
ELSE
(SELECT tj.adicional
FROM creditopy.tarjetas tj
WHERE tj.tarjeta = creditopy.fc_tjtp(a.numero_cuenta))
END
-- muestra solo txs de la tarjeta o incluye las adicionales: esta
-- condicion se evalua con el pi_flg_adicional y el pi_adicional
AND 1 =
creditopy.Pkg_Dimo_Ceibo.fn_is_adic_enable(pi_adicional,
vn_componente_tar_param,
pi_flg_adicional,
t.adicional, -- de la tarjeta del movimiento
t.componente)
ORDER BY fecha_movimiento_date, cupon, autorizacion, talon) fila;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_movimientosTC;
PROCEDURE sp_costosOperacionalesDimo(PI_CODIGO_EF IN NUMBER,
PI_TIPO_CUENTA_ORIGEN IN VARCHAR2,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
19.1- Info. COSTOS OPERACIONALES de TXS DIMO
*/
/****************************************************************************************************
Autor: Amalia Rodriguez.
Fecha: 07/09/2020
Propósito: Procedimiento que devuelve un cursor con los datos de los costos a aplicar de
acuerdo al tipo de cuenta de origen.
Permite informar a un usuario los costos vigentes de las transacciones.
Se consulta por el codigo del participante y el tipo de cuenta seleccionados
para consultar.
PARAMETROS DE ENTRADA:
PI_CODIGO_EF Corresponde al codigo del participante de la cuenta seleccionada.
PI_TIPO_CUENTA_ORIGEN Corresponde al tipo de cuenta que se quiere consultar, y los valores
son los de tipoCuentaOrigen del SICOOP.
ALL para consultar todas las parametrizadas.
*****************************************************************************************************/
vn_tipo_ok NUMBER;
BEGIN
-- se valida codigo ef originante
IF PI_CODIGO_EF IS NULL THEN
raise_application_error(-20001,
'Codigo de participante origen invalido.');
END IF;
-- se valida tipo de cuenta origen
IF upper(nvl(PI_TIPO_CUENTA_ORIGEN, 'all')) != 'ALL' THEN
BEGIN
SELECT 1
INTO vn_tipo_ok
FROM creditopy.SICOOP_TIPO_CUENTA t
WHERE t.tipo_cuenta = PI_TIPO_CUENTA_ORIGEN
AND t.tipo_ori_des = 'O';
EXCEPTION
-- no puede darse por valido si es no_data_found porque debio pasar por
-- las validaciones previas
WHEN no_data_found THEN
raise_application_error(-20001,
'Tipo de cuenta origen invalida.');
WHEN OTHERS THEN
RAISE;
END;
END IF;
OPEN po_cursor FOR
SELECT ct.id_cargo_tran AS COSTO_ID,
ct.descripcion_cargo AS COSTO_DESCRIPCION,
cr.rango_monto_desde AS MONTO_DESDE,
cr.rango_monto_hasta AS MONTO_HASTA,
cr.tipo_cargo_originante AS TIPO_CARGO_ORIGINANTE,
CASE
WHEN cr.tipo_cargo_originante = 'FEE' THEN
cr.cargo_originante
ELSE
0
END AS IMPORTE_CARGO_ORIGINANTE,
CASE
WHEN cr.tipo_cargo_originante = '%' THEN
cr.porcentaje_originante
ELSE
0
END AS TASA_CARGO_ORIGINANTE,
cr.tipo_cargo_destinatario AS TIPO_CARGO_DESTINATARIO,
CASE
WHEN cr.tipo_cargo_destinatario = 'FEE' THEN
cr.cargo_destinatario
ELSE
0
END AS IMPORTE_CARGO_DESTINATARIO,
CASE
WHEN cr.tipo_cargo_originante = '%' THEN
cr.Porcentaje_destinatario
ELSE
0
END AS TASA_CARGO_DESTINATARIO,
i.valor_impuesto AS APLICAR_IVA,
ct.canal AS CANAL,
ct.pagador AS PAGADOR,
m.tipo_transaccion AS TIPO_TRANSACCION,
m.cod_servicio AS COD_SERVICIO,
cs.descripcion AS DESCRIPCION_SERVICIO,
ct.codigo_ef_originante AS EF_ORIGINANTE,
nvl(ct.emisor_cabal_originante, 0) AS EMISOR_CABAL_ORIGINANTE,
CASE
WHEN ct.emisor_cabal_originante IS NOT NULL THEN
creditopy.pkg_dimo_ceibo.fn_get_emisor_desc(ct.emisor_cabal_originante)
ELSE
' '
END AS DESC_EMI_CABAL_ORIGINANTE,
m.tipo_cuenta_origen AS TIPO_CUENTA_ORIGEN,
tco.descripcion AS DESC_TIPO_CUENTA_ORIGEN,
ct.codigo_ef_destinatario AS EF_DESTINATARIO,
nvl(ct.emisor_cabal_destinatario, 0) AS EMISOR_CABAL_DESTINATARIO,
CASE
WHEN ct.emisor_cabal_destinatario IS NOT NULL THEN
creditopy.pkg_dimo_ceibo.fn_get_emisor_desc(ct.emisor_cabal_destinatario)
ELSE
' '
END AS DESC_EMI_CABAL_DESTINATARIO,
m.tipo_cuenta_destino AS TIPO_CUENTA_DESTINO,
tcd.descripcion AS DESC_TIPO_CUENTA_DESTINO,
ct.fecha_vigencia_desde AS FECHA_VIGENCIA_DESDE,
ct.fecha_vigencia_hasta AS FECHA_VIGENCIA_HASTA,
ct.pagador AS PAGADOR
FROM creditopy.CARGOS_POR_TRANSAC_DIMO ct,
creditopy.CARGOS_POR_TRANSAC_DIMO_RANGO cr,
creditopy.SICOOP_LISTA_TRANSAC_MENSAJE m,
creditopy.SICOOP_CODIGOS_DE_SERVICIO cs,
creditopy.SICOOP_TIPO_CUENTA tco,
creditopy.SICOOP_TIPO_CUENTA tcd,
creditopy.IMPUESTOS i
WHERE ct.codigo_ef_originante =
decode(nvl(PI_CODIGO_EF, 0),
0,
ct.codigo_ef_originante,
PI_CODIGO_EF)
AND (ct.codigo_ef_originante != 0 OR
(nvl(PI_CODIGO_EF, 0) = 0 AND ct.codigo_ef_originante = 0 AND
NOT EXISTS (SELECT 1
FROM creditopy.CARGOS_POR_TRANSAC_DIMO e
WHERE e.codigo_ef_originante != 0
AND e.id_tran_mensaje = ct.id_tran_mensaje
AND e.cargo_activo = 'S')))
AND m.id_tran_mensaje = ct.id_tran_mensaje
AND m.tipo_cuenta_origen =
decode(upper(nvl(PI_TIPO_CUENTA_ORIGEN, 'ALL')),
'ALL',
m.tipo_cuenta_origen,
PI_TIPO_CUENTA_ORIGEN)
AND cr.id_cargo_tran = ct.id_cargo_tran
-- solo se despliegan los cargos vigentes
AND trunc(SYSDATE) BETWEEN ct.fecha_vigencia_desde AND
ct.fecha_vigencia_hasta
-- en la version 1 se liberan los cargos del originante
-- se despliegan los cargos que sean cubiertos por el orginante o esten subsidiados
AND ct.pagador IN ('ORIGINANTE', 'SUBSIDIADO')
-- y tengan importe o porcentaje > 0
-- 11/05/2021 OOJEDA. Se comenta condicion para que los datos puedan ser retornados
--and (cr.cargo_originante != 0 or cr.porcentaje_originante != 0)
AND ct.cargo_activo = 'S' -- 11/05/2021 OOJEDA. Se agrega condicion de cargo activo
AND cs.cod_servicio = m.cod_servicio
AND tco.tipo_cuenta = m.tipo_cuenta_origen
AND tcd.tipo_cuenta = m.tipo_cuenta_destino
AND i.codigo_impuesto = ct.codigo_impuesto
ORDER BY ct.descripcion_cargo,
ct.id_cargo_tran,
cr.id_cargo_tran_rango;
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END sp_CostosOperacionalesDimo;
/*
19.2- Info. CARGO INDIVIDUAL APLICADOS A TXS DE DIMO
*/
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 27/05/2020
Propósito: Procedimiento que devuelve un cursor con los datos del cargo que se aplica a la
transacción.
Si hay mas de una fila debe retornar error por duplicacion.
Si hay no cargo parametrizado debe retonar el not found.
******************************************************************************************************/
/*
PROCEDURE sp_CargoTxsDimo(PI_CANAL IN VARCHAR2,
PI_TIPO_TRANSACCION IN VARCHAR2,
PI_COD_SERVICIO IN VARCHAR2,
PI_EF_ORIGINANTE IN NUMBER,
PI_CUENTA_ORIGINANTE IN VARCHAR2,
PI_TIPO_CUENTA_ORIGEN IN VARCHAR2,
PI_EF_DESTINATARIO IN NUMBER,
PI_CUENTA_DESTINATARIO IN VARCHAR2,
PI_TIPO_CUENTA_DESTINO IN VARCHAR2,
PI_MONTO_TRANSACCION IN NUMBER,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
v_fecha_tran DATE;
VR_CARGO_X_TR creditopy.Cargos_Por_Transac_Dimo%ROWTYPE;
v_min_loop NUMBER := 3;
v_max_loop NUMBER := 6;
v_loop NUMBER;
V_CANT_TRANSAC NUMBER := 0;
CURSOR c_cargo(c_id_tran_men creditopy.Cargos_Por_Transac_Dimo.id_tran_mensaje%TYPE,
c_canal creditopy.Cargos_Por_Transac_Dimo.canal%TYPE,
c_ef_ori creditopy.Cargos_Por_Transac_Dimo.codigo_ef_originante%TYPE,
c_emi_ori creditopy.Cargos_Por_Transac_Dimo.emisor_cabal_originante%TYPE,
c_ef_dest creditopy.Cargos_Por_Transac_Dimo.codigo_ef_destinatario%TYPE,
c_emi_dest creditopy.Cargos_Por_Transac_Dimo.emisor_cabal_destinatario%TYPE,
c_fec_tran creditopy.Cargos_Por_Transac_Dimo.fecha_vigencia_desde%TYPE) IS
SELECT id_cargo_tran
FROM creditopy.Cargos_Por_Transac_Dimo a
WHERE a.id_tran_mensaje = c_id_tran_men
AND a.canal = c_canal
AND a.codigo_ef_originante = c_ef_ori
AND a.emisor_cabal_originante = c_emi_ori
AND a.codigo_ef_destinatario = c_ef_dest
AND a.emisor_cabal_destinatario = c_emi_dest
AND a.cargo_activo = 'S'
AND c_fec_tran BETWEEN a.fecha_vigencia_desde AND
a.fecha_vigencia_hasta;
v_costo_id NUMBER;
V_COSTO_DESCRIPCION creditopy.Cargos_Por_Transac_Dimo.descripcion_cargo%TYPE := ' ';
V_MONTO_CARGO_ORIGINANTE NUMBER := 0;
V_MONTO_CARGO_DESTINATARIO NUMBER := 0;
V_IVA NUMBER := 0;
V_RUBRO NUMBER := 0;
--Buscamos la cantidad de transacciones para el id_cargo en un periodo
FUNCTION FN_GET_CANTIDAD_TRX(pi_id_cargo IN NUMBER) RETURN NUMBER IS
V_CANT NUMBER := 0;
BEGIN
SELECT (CANTIDAD) CANT
INTO V_CANT
FROM ACUM_TRANSAC_CUENTA a
WHERE A.PERIODO = to_char(V_FECHA_TRAN, 'yyyymm')
AND A.CUENTA = PI_CUENTA_ORIGINANTE
AND a.id_cargo_tran = pi_id_cargo;
-- and a.tipo_operacion=PI_TIPO_TRANSACCION;
RETURN V_CANT;
EXCEPTION
WHEN NO_DATA_FOUND THEN
V_CANT := 0;
RETURN V_CANT;
WHEN OTHERS THEN
--RAISE;
V_CANT := 0;
RETURN V_CANT;
END FN_GET_CANTIDAD_TRX;
FUNCTION fn_get_emisor_cabal(VN_TARJETA IN VARCHAR2) RETURN NUMBER IS
vn_emisor NUMBER;
BEGIN
SELECT t.emisor
INTO vn_emisor
FROM creditopy.tarjetas t
WHERE t.tarjeta = creditopy.fc_pan2cripto(PI_CUENTA_ORIGINANTE);
RETURN vn_emisor;
EXCEPTION
WHEN NO_DATA_FOUND THEN
vn_emisor := 0;
RETURN vn_emisor;
WHEN OTHERS THEN
RAISE;
END fn_get_emisor_cabal;
PROCEDURE buscar_un_id_cargo AS
BEGIN
OPEN c_cargo(VR_CARGO_X_TR.Id_Tran_Mensaje,
VR_CARGO_X_TR.Canal,
VR_CARGO_X_TR.Codigo_Ef_Originante,
VR_CARGO_X_TR.Emisor_Cabal_Originante,
VR_CARGO_X_TR.Codigo_Ef_Destinatario,
VR_CARGO_X_TR.Emisor_Cabal_Destinatario,
v_fecha_tran);
LOOP
FETCH c_cargo
INTO v_costo_id;
EXIT WHEN c_cargo%NOTFOUND;
--dbms_output.put_line (v_costo_id);
IF c_cargo%ROWCOUNT > 1 THEN
raise_application_error(-20001, 'Cargo duplicado.');
END IF;
END LOOP;
CLOSE c_cargo;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END buscar_un_id_cargo;
BEGIN
-- obtener el id_tran_mensaje de la transaccion
BEGIN
SELECT m.id_tran_mensaje
INTO VR_CARGO_X_TR.Id_Tran_Mensaje
FROM creditopy.Sicoop_Lista_Transac_Mensaje m
WHERE m.tipo_transaccion = nvl(PI_TIPO_TRANSACCION, '-1')
AND m.cod_servicio = nvl(PI_COD_SERVICIO, '-1')
AND m.tipo_cuenta_origen = nvl(PI_TIPO_CUENTA_ORIGEN, '-1')
AND m.tipo_cuenta_destino = nvl(PI_TIPO_CUENTA_DESTINO, '-1')
AND m.disponible_para_cargo_tran = 1;
EXCEPTION
WHEN OTHERS THEN
raise_application_error(-20001, 'Servicio no existe.');
END;
--buscar el cargo para los datos especificos de participante/emisor
v_fecha_tran := SYSDATE;
VR_CARGO_X_TR.Canal := PI_CANAL;
VR_CARGO_X_TR.Codigo_Ef_Originante := PI_EF_ORIGINANTE;
VR_CARGO_X_TR.Codigo_Ef_Destinatario := PI_EF_DESTINATARIO;
-- obtener el emisor_cabal de la cuenta originante y cuenta destinatario
VR_CARGO_X_TR.Emisor_Cabal_Originante := fn_get_emisor_cabal(PI_CUENTA_ORIGINANTE);
VR_CARGO_X_TR.Emisor_Cabal_Destinatario := fn_get_emisor_cabal(PI_CUENTA_DESTINATARIO);
v_costo_id := 0;
buscar_un_id_cargo;
-- si no hay cargo para participante/emisor origen y destino espeficos se
-- debe buscar el comodin que responda a los datos
IF v_costo_id = 0 THEN
v_loop := v_max_loop;
WHILE v_costo_id = 0 LOOP
CASE v_loop
WHEN 6 THEN
VR_CARGO_X_TR.Emisor_Cabal_Destinatario := 0;
WHEN 5 THEN
VR_CARGO_X_TR.Codigo_Ef_Destinatario := 0;
WHEN 4 THEN
VR_CARGO_X_TR.Emisor_Cabal_Originante := 0;
WHEN 3 THEN
VR_CARGO_X_TR.Codigo_Ef_Originante := 0;
ELSE
NULL;
END CASE;
buscar_un_id_cargo;
v_loop := v_loop - 1;
IF v_costo_id != 0 OR v_loop < v_min_loop THEN
EXIT;
END IF;
END LOOP;
END IF;
IF v_costo_id != 0 THEN
VR_CARGO_X_TR.Id_Cargo_Tran := v_costo_id;
V_CANT_TRANSAC := FN_GET_CANTIDAD_TRX(V_COSTO_ID);
SELECT
-- ct.id_cargo_tran as COSTO_ID,
m.desc_tran_mensaje AS COSTO_DESCRIPCION,
CASE
WHEN cr.tipo_cargo_originante = 'FEE' THEN
cr.cargo_originante +
decode(i.valor_impuesto,
0,
0,
round((cr.cargo_originante * i.valor_impuesto / 100)))
ELSE
round(PI_MONTO_TRANSACCION * cr.porcentaje_originante / 100) +
decode(i.valor_impuesto,
0,
0,
round(round(PI_MONTO_TRANSACCION * cr.porcentaje_originante / 100) *
i.valor_impuesto / 100))
END AS MONTO_CARGO_ORIGINANTE,
0 AS MONTO_CARGO_DESTINATARIO,
i.valor_impuesto AS IVA,
ct.rubro_cargo AS RUBRO
INTO -- V_COSTO_ID,
V_COSTO_DESCRIPCION,
V_MONTO_CARGO_ORIGINANTE,
V_MONTO_CARGO_DESTINATARIO,
V_IVA,
V_RUBRO
FROM creditopy.CARGOS_POR_TRANSAC_DIMO ct,
creditopy.CARGOS_POR_TRANSAC_DIMO_RANGO cr,
creditopy.SICOOP_LISTA_TRANSAC_MENSAJE m,
creditopy.IMPUESTOS i
WHERE ct.id_cargo_tran = VR_CARGO_X_TR.Id_Cargo_Tran
AND m.id_tran_mensaje = ct.id_tran_mensaje
AND ct.pagador != 'SUBSIDIADO'
AND cr.id_cargo_tran = ct.id_cargo_tran
AND nvl(CT.CANTIDAD_EXONERADA, 0) <= V_CANT_TRANSAC
AND PI_MONTO_TRANSACCION BETWEEN cr.rango_monto_desde AND
cr.rango_monto_hasta
AND i.codigo_impuesto = ct.codigo_impuesto;
END IF;
OPEN po_cursor FOR
SELECT V_COSTO_ID AS COSTO_ID,
V_COSTO_DESCRIPCION AS COSTO_DESCRIPCION,
V_MONTO_CARGO_ORIGINANTE AS MONTO_CARGO_ORIGINANTE,
V_MONTO_CARGO_DESTINATARIO AS MONTO_CARGO_DESTINATARIO,
V_IVA AS IVA,
V_RUBRO AS RUBRO
FROM dual;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := CASE
WHEN v_costo_id = 0 THEN
'Sin cargo.'
ELSE
SQLERRM
END;
EXCEPTION
WHEN NO_DATA_FOUND THEN
OPEN po_cursor FOR
SELECT V_COSTO_ID AS COSTO_ID,
' ' AS COSTO_DESCRIPCION,
0 AS MONTO_CARGO_ORIGINANTE,
0 AS MONTO_CARGO_DESTINATARIO,
0 AS IVA,
0 AS RUBRO
FROM dual;
PO_SQLCODE := 0;
PO_SQLERRM := 'Sin cargo.';
WHEN OTHERS THEN
OPEN po_cursor FOR
SELECT 0 AS COSTO_ID,
' ' AS COSTO_DESCRIPCION,
0 AS MONTO_CARGO_ORIGINANTE,
0 AS MONTO_CARGO_DESTINATARIO,
0 AS IVA,
0 AS RUBRO
FROM dual;
PO_SQLCODE := 0;
PO_SQLERRM := SQLERRM;
END sp_CargoTxsDimo;
*/
PROCEDURE spBloqueoTarjetaPrepaga(PI_NUMERO_TARJETA IN VARCHAR2,
PI_ORIGEN_PEDIDO IN NUMBER, -- 1-Usuario; 2-Entidad
PI_MOTIVO_BLOQUEO IN NUMBER, --REGLA_WEB 13647
PI_OTROS_MOTIVO_DESC IN VARCHAR2,
PI_USUARIO_NOVEDAD IN VARCHAR2, -- usuario que procesa la novedad
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
VR_SOLICITUD SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS SOLICITUDES_DATOS%ROWTYPE;
VC_TARJETA VARCHAR2(19);
VN_NEW_ESTADO NUMBER(4);
VN_NEW_CLASE_DE_ESTADO NUMBER(4);
VN_IS_BLOQ_USUARIO NUMBER(1);
VN_BLOQ_USU_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 46;
VN_BLOQ_USU_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 47;
VN_BLOQ_ENT_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 50;
VN_BLOQ_ENT_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 51;
BEGIN
--Datos DIMO
PV_USUARIO := get_usuario;
PV_USUARIO := NVL(PI_USUARIO_NOVEDAD, PV_USUARIO);
--Datos de la Tarjeta
VC_TARJETA := FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
-- obtener datos de la tarjeta
VR_TARJETA := NULL;
sp_get_tarjeta(VC_TARJETA, VR_TARJETA);
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
--Datos de la Solicitud
CASE PI_ORIGEN_PEDIDO
WHEN 1 THEN
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_BLOQUEO_USU_DIMO;
VR_SOLICITUD.ID_ESTADO := VN_BLOQ_USU_OK;
VN_IS_BLOQ_USUARIO := 1;
WHEN 2 THEN
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_BLOQUEO_ENT_DIMO;
VR_SOLICITUD.ID_ESTADO := VN_BLOQ_ENT_OK;
VN_IS_BLOQ_USUARIO := 0;
ELSE
raise_application_error(-20001,
'USERS_ERROR: origen bloqueo is null.');
END CASE;
VR_SOLICITUD.TARJETA := PI_NUMERO_TARJETA;
VR_SOLICITUD.USUARIO := PV_USUARIO; --PI_USUARIO_NOVEDAD;
VR_SOLICITUD.DOCUMENTO := TRIM(LEADING '0' FROM SUBSTR(VR_TARJETA.DOCUMENTO,
4,
12));
VR_DATOS.CODIGO_MOTIVO_BLOQUEO := PI_MOTIVO_BLOQUEO;
VR_DATOS.OTROS_MOTIVOS_BLOQUEO := PI_OTROS_MOTIVO_DESC;
--Datos del nuevo estado
SELECT e.estado, e.clase_de_estado
INTO VN_NEW_ESTADO, VN_NEW_CLASE_DE_ESTADO
FROM creditopy.estados_ctas_tarj e
WHERE e.estado = decode(VN_IS_BLOQ_USUARIO,
1,
CC_ESTADO_BLOQ_USUARIO,
CC_ESTADO_BLOQ_ENTIDAD);
--Datos de la Novedad
VR_NOVEDAD_TARJETA.TARJETA := VR_TARJETA.TARJETA;
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := VN_NEW_ESTADO;
VR_NOVEDAD_TARJETA.NOVFCHING := SYSDATE;
--Utilizamos estos campos para controlar el nuevo estado
VR_DATOS.PAIS := VN_NEW_ESTADO;
VR_DATOS.CIUDAD := PI_ORIGEN_PEDIDO;
PR_SOLICITUDES(VR_SOLICITUD, VR_DATOS);
IF VR_SOLICITUD.ID_ESTADO IN (VN_BLOQ_USU_OK, VN_BLOQ_ENT_OK) AND
VR_SOLICITUD.CODIGO_RESPUESTA = 0 THEN
--Registramos en Cambios de Estado.
INSERT INTO CREDITOPY.CAMBIOS_DE_ESTADO@OLPY
VALUES
(VR_NOVEDAD_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_NOVEDAD_TARJETA.NOVFCHING,
creditopy.seq_estados.nextval@OLPY);
-- se resguarda el estado
IF VR_TARJETA.CLASE_DE_ESTADO != 11 AND
VR_TARJETA.CLASE_DE_ESTADO != 5 THEN
UPDATE TARJETAS T
SET T.ORIGEN_ANULACION = T.ESTADO
WHERE T.TARJETA = VR_TARJETA.TARJETA;
END IF;
-- actualizar el estado de TARJETAS
UPDATE TARJETAS T
SET T.ESTADO = VN_NEW_ESTADO,
T.CLASE_DE_ESTADO = VN_NEW_CLASE_DE_ESTADO,
T.FECHA_ESTADO = VR_NOVEDAD_TARJETA.NOVFCHING,
T.ULT_ACTUALIZACION = VR_NOVEDAD_TARJETA.NOVFCHING,
T.OPERADOR = SUBSTR(PV_USUARIO, 1, 8) --rpad(PI_USUARIO_NOVEDAD,8)
WHERE T.TARJETA = VR_TARJETA.TARJETA;
-- actualizar TARJETAS_PREPAGA solo si esta operativa o
-- si es bloqueo de la entidad y esta bloqueada a pedido del usuario
UPDATE TARJETAS_PREPAGA TP
SET TP.ESTADO_PLASTICO = VN_NEW_ESTADO,
TP.FECHA_ULT_ACTUALIZACION = VR_NOVEDAD_TARJETA.NOVFCHING
WHERE TP.TARJETA = VR_TARJETA.TARJETA
AND TP.FECHA_VIG_PLASTICO >= TRUNC(SYSDATE)
AND (TP.ESTADO_PLASTICO = 1 OR
(VN_NEW_ESTADO = 4 AND TP.ESTADO_PLASTICO = 5));
END IF;
COMMIT;
IF VR_SOLICITUD.CODIGO_RESPUESTA != 0 THEN
po_sqlcode := VR_SOLICITUD.CODIGO_RESPUESTA;
po_sqlerrm := fn_get_ult_rechazo_solicitud(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.CODIGO_RESPUESTA);
ELSE
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END IF;
OPEN po_cursor FOR
SELECT decode(VR_SOLICITUD.CODIGO_RESPUESTA,
0,
0,
nvl(VR_SOLICITUD.NOVEDAD, 0)) AS CODIGO_NOVEDAD,
VR_SOLICITUD.ID_SOLICITUD_RECIBIDA AS ID_SOLICITUD,
VR_SOLICITUD.CODIGO_RESPUESTA AS CODIGO_RESPUESTA,
decode(VR_SOLICITUD.CODIGO_RESPUESTA, 0, ' ', PO_SQLERRM) AS GLOSA_RESPUESTA
FROM dual;
-- Se incluye un dummy para evitar bloque/desbloqueo en la misma hora
sp_delay(CC_DELAY_SECONDS);
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
IF VR_SOLICITUD.ID_SOLICITUD_RECIBIDA IS NOT NULL THEN
VR_SOLICITUD.ID_ESTADO := CASE
WHEN VN_IS_BLOQ_USUARIO = 1 THEN
VN_BLOQ_USU_RECHA
ELSE
VN_BLOQ_ENT_RECHA
END;
PR_ADM_ERROR_SOLICITUD(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.ID_ESTADO,
SQLCODE,
SQLERRM);
END IF;
ROLLBACK;
OPEN po_cursor FOR
SELECT nvl(VR_NOVEDAD_CUENTA.NOVNRO, 0) AS CODIGO_NOVEDAD,
nvl(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA, 0) AS ID_SOLICITUD,
po_sqlcode AS CODIGO_RESPUESTA,
po_sqlerrm AS GLOSA_RESPUESTA
FROM dual;
END spBloqueoTarjetaPrepaga;
PROCEDURE spDesbTarUsuarioDIMO(PI_NUMERO_TARJETA IN VARCHAR2,
PI_ENTIDAD_NOVEDAD IN NUMBER, -- entidad del usuario que procesa la novedad
PI_USUARIO_NOVEDAD IN VARCHAR2, -- usuario que procesa la novedad
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
24- Bloqueo y desbloqueo de tarjeta TC
Adaptado del PKG_SICOOP_DIMO.
Ajustes a invocacion para el backend DIMO: A.Rodriguez. 03/06/2020
*/
/*
Autor: Edgar Rojas.
Fecha: 19/03/2020
Proposito: Operaciones DIMO - Desbloqueo.
Bloqueo y desbloqueo de una tarjeta a solicitud del usuario.
La novedad se ejecuta con el emisor y usuario recibido, por tanto
se puede disponibilizar desde un endpoint especifico.
Referencia: API_SICOOP-CEIBO(postrevision).xlsx. Hoja 20-Bloqueo-Desbloqueo
*/
BEGIN
-- FALTA VALIDAR LOS DATOS DE ENTRADA
-- Limpiamos la tabla VR_HISTORICOS.
VR_HISTORICOS.DELETE;
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
-- obtener datos de la tarjeta
sp_get_tarjeta(FC_PAN2CRIPTO(PI_NUMERO_TARJETA), VR_TARJETA);
-- obtener datos de la cuenta
sp_get_cuenta(VR_TARJETA.NUMERO_CUENTA, VR_CUENTA);
--Obtener la numero de novedad.
VR_NOVEDAD_CUENTA.NOVNRO := FN_GET_NRO_NOVEDAD; -- NP_NOVEDAD;
VR_NOVEDAD_CUENTA.NOVTIP := 15;
VR_NOVEDAD_CUENTA.NOVFCHING := SYSDATE;
VR_NOVEDAD_CUENTA.NUMERO_CUENTA := NULL;
VR_NOVEDAD_TARJETA.NOVTIP := 15;
VR_NOVEDAD_TARJETA.TARJETA := VR_TARJETA.TARJETA; --FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
--Datos constantes en el historico de Cuentas. Se asume que la tarjeta es titular.
VR_HISTORICO.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_HISTORICO.USUARIO := PI_USUARIO_NOVEDAD; --CP_USUARIO_ENTIDAD;
VR_HISTORICO.DESPLEGAR := 0;
VR_HISTORICO.EMISOR := PI_ENTIDAD_NOVEDAD; --NP_ENTIDAD_ID;
VR_HISTORICO.NOVSEC := 1;
VR_HISTORICO.NOVGEN := 2;
VR_HISTORICO.NOVNRO := VR_NOVEDAD_CUENTA.NOVNRO; --NP_RESPUESTA;
VR_HISTORICO.NOVTIP := VR_NOVEDAD_CUENTA.NOVTIP;
VR_HISTORICO.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_HISTORICO.FECHA_REGISTRO := VR_HISTORICO.NOVFCHING;
VR_HISTORICO.OPCION := 'NovDesbloqueoAdmTarjetaHandler';
VR_HISTORICO.NUMERO_CUENTA := VR_TARJETA.NUMERO_CUENTA;
VR_HISTORICO.TARJETA := VR_TARJETA.TARJETA;
VR_HISTORICO.EMISOR := VR_TARJETA.EMISOR;
VR_HISTORICO.TITULAR := CASE
WHEN VR_TARJETA.COMPONENTE = 1 THEN
1
ELSE
2
END;
VR_CUENTA.ESTADO := ESTADO_CT(VR_CUENTA.NUMERO_CUENTA, 'C');
--mantis#2672
VR_TARJETA.ESTADO := ESTADO_CT(VR_TARJETA.TARJETA, 'T');
VR_TARJETA.CLASE_DE_ESTADO := CC_BLOQUEO_USUARIO;
VR_NOVEDAD_CUENTA.NOVNROSEC := 1; --NP_FORMULARIO;
VR_NOVEDAD_CUENTA.USUARIO := PI_USUARIO_NOVEDAD; --CP_USUARIO_ENTIDAD;
VR_NOVEDAD_CUENTA.BIN := SUBSTR(PI_NUMERO_TARJETA, 1, 6); -- asumio long de bin = 6
VR_NOVEDAD_CUENTA.PRODUCTO := 1;
VR_NOVEDAD_CUENTA.EMISOR_CUENTA := VR_TARJETA.EMISOR;
VR_NOVEDAD_CUENTA.SUCURSAL_CUENTA := VR_TARJETA.SUCURSAL_EMISOR;
VR_NOVEDAD_TARJETA.NOVNRO := VR_NOVEDAD_CUENTA.NOVNRO;
VR_NOVEDAD_TARJETA.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_NOVEDAD_TARJETA.NOVANUORG := NULL;
VR_NOVEDAD_TARJETA.NOVMOTDEV := NULL;
VR_NOVEDAD_TARJETA.NOVSEC := 1;
VR_NOVEDAD_TARJETA.NOVNROSEC := VR_NOVEDAD_CUENTA.NOVNROSEC;
VR_NOVEDAD_TARJETA.NUMERO_CUENTA := VR_TARJETA.NUMERO_CUENTA;
VR_NOVEDAD_TARJETA.EMISOR_CUENTA := VR_NOVEDAD_CUENTA.EMISOR_CUENTA;
VR_NOVEDAD_TARJETA.SUCURSAL_CUENTA := VR_NOVEDAD_CUENTA.SUCURSAL_CUENTA;
--Historico a nivel de Cuentas.
VR_HISTORICO.TABLA := 'NOVEDADES_CUENTAS';
--#Estado de la Cuenta antes del Desbloqueo
VR_HISTORICO.CAMPO := 'ESTADO_CUENTA';
VR_CUENTA.ESTADO := ESTADO_CT(VR_TARJETA.NUMERO_CUENTA, 'C');
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := '(' || VR_CUENTA.ESTADO || ') ' ||
FC_GET_ESTADO(VR_CUENTA.ESTADO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Estado de la Tarjeta antes del Desbloqueo
VR_HISTORICO.CAMPO := 'ESTADO_TARJETA';
VR_TARJETA.ESTADO := ESTADO_CT(VR_TARJETA.TARJETA, 'T');
VR_HISTORICO.DATO_ANTERIOR := '(' || VR_TARJETA.ESTADO || ') ' ||
FC_GET_ESTADO(VR_TARJETA.ESTADO);
VR_HISTORICO.DATO_POSTERIOR := '(' || VR_NOVEDAD_TARJETA.NUEVO_ESTADO || ') ' ||
FC_GET_ESTADO(VR_NOVEDAD_TARJETA.NUEVO_ESTADO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
VR_HISTORICO.TABLA := 'NOVEDADES_TARJETAS';
--#Origen del bloqueo Entidad o Usuario
VR_HISTORICO.CAMPO := 'NOVANUORG';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := 'Usuario';
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Formulario
VR_HISTORICO.CAMPO := 'NOVNROSEC';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_NOVEDAD_CUENTA.NOVNROSEC; --NP_FORMULARIO;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
sp_resguarda_datos_historico;
sp_registrar_hist_novedad;
VR_HISTORICO := VC_HISTORICO;
--Para poder evaluar la novedad.
VR_CUENTA.EMISOR := PI_ENTIDAD_NOVEDAD; --NP_ENTIDAD_ID;
VR_CUENTA.OPERADOR := TRIM(SUBSTR(UPPER(PI_USUARIO_NOVEDAD), 1, 8)); --TRIM(SUBSTR(UPPER(CP_USUARIO_ENTIDAD),1,8));
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := 1;
INSERT INTO TARJETA_TMP
(EMISOR,
SUCURSAL_EMISOR,
PRODUCTO,
NUMERO_CUENTA,
DOCUMENTO,
TARJETA,
ESTADO,
FECHA_VIGENCIA
--mantis#2672
,
ESTADO_DE_COSTO,
CLASE_DE_ESTADO)
VALUES
(VR_TARJETA.EMISOR,
VR_TARJETA.SUCURSAL_EMISOR,
VR_TARJETA.PRODUCTO,
VR_TARJETA.NUMERO_CUENTA,
VR_TARJETA.DOCUMENTO,
VR_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_TARJETA.FECHA_VIGENCIA,
--mantis#2672
VR_TARJETA.ESTADO,
VR_TARJETA.CLASE_DE_ESTADO);
INSERT INTO CUENTA_TMP
(EMISOR, OPERADOR)
VALUES
(VR_CUENTA.EMISOR, VR_CUENTA.OPERADOR);
--Validar la Novedad
SM.PR_VALIDAR_NOVEDAD(304,
VR_NOVEDAD_CUENTA.NOVNRO,
VR_NOVEDAD_CUENTA.NOVFCHING,
VR_CUENTA.OPERADOR, --CP_USUARIO_ENTIDAD,
VR_CUENTA.EMISOR); --NP_ENTIDAD_ID);
--Registramos en Cambios de Estado.
INSERT INTO CREDITOPY.CAMBIOS_DE_ESTADO@OLPY
VALUES
(VR_NOVEDAD_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_NOVEDAD_CUENTA.NOVFCHING,
creditopy.seq_estados.nextval@OLPY);
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := NULL;
INSERT INTO NOVEDADES_CUENTAS@OLPY VALUES VR_NOVEDAD_CUENTA;
INSERT INTO NOVEDADES_TARJETAS@OLPY VALUES VR_NOVEDAD_TARJETA;
COMMIT;
/*
open po_cursor for
select VR_NOVEDAD_CUENTA.NOVNRO AS CODIGO_NOVEDAD
from dual;
*/
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
OPEN po_cursor FOR
SELECT VR_NOVEDAD_CUENTA.NOVNRO AS CODIGO_NOVEDAD,
0 AS ID_SOLICITUD,
0 AS CODIGO_RESPUESTA,
' ' AS GLOSA_RESPUESTA
FROM dual;
-- Se incluye un dummy para evitar bloque/desbloqueo en la misma hora
sp_delay(CC_DELAY_SECONDS);
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
sp_rechazar_novedad;
ROLLBACK;
END;
PROCEDURE spBloqTarUsuarioDimo(PI_NUMERO_TARJETA IN VARCHAR2,
PI_MOTIVO_BLOQUEO IN NUMBER, --REGLA_WEB 13647
PI_OTROS_MOTIVO_DESC IN VARCHAR2,
PI_ENTIDAD_NOVEDAD IN NUMBER, -- entidad del usuario que procesa la novedad
PI_USUARIO_NOVEDAD IN VARCHAR2, -- usuario que procesa la novedad
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
24- SOLO Bloqueo de tarjeta TC por parte de Usuarios (hoy usan la aplicacion DIMO o HomeBanking de las entidades).
Adaptado del PKG_SICOOP_DIMO.
*/
/*
Autor: Edgar Rojas.
Fecha: 06/01/2023
Proposito: Operaciones DIMO - Bloqueo.
Bloqueo de una tarjeta a solicitud del usuario.
La novedad se ejecuta con el emisor y usuario recibido, por tanto
se puede disponibilizar desde un endpoint especifico.
Referencia: API_SICOOP-CEIBO(postrevision).xlsx. Hoja 20-Bloqueo-Desbloqueo
*/
BEGIN
-- FALTA VALIDAR LOS DATOS DE ENTRADA
-- Limpiamos la tabla VR_HISTORICOS.
VR_HISTORICOS.DELETE;
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
-- obtener datos de la tarjeta
sp_get_tarjeta(FC_PAN2CRIPTO(PI_NUMERO_TARJETA), VR_TARJETA);
-- obtener datos de la cuenta
sp_get_cuenta(VR_TARJETA.NUMERO_CUENTA, VR_CUENTA);
--Obtener la numero de novedad.
VR_NOVEDAD_CUENTA.NOVNRO := FN_GET_NRO_NOVEDAD;
VR_NOVEDAD_CUENTA.NOVTIP := 14;
VR_NOVEDAD_CUENTA.NOVFCHING := SYSDATE;
VR_NOVEDAD_CUENTA.NUMERO_CUENTA := NULL;
VR_NOVEDAD_TARJETA.NOVTIP := 14;
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := 5;
VR_NOVEDAD_TARJETA.TARJETA := VR_TARJETA.TARJETA; --FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
--Datos constantes en el historico de Cuentas.
-- Se asume que la tarjeta es titular.
VR_HISTORICO.USUARIO := PI_USUARIO_NOVEDAD; --CP_USUARIO_ENTIDAD;
VR_HISTORICO.DESPLEGAR := 0;
VR_HISTORICO.EMISOR := PI_ENTIDAD_NOVEDAD; --VR_TARJETA.EMISOR;
VR_HISTORICO.NOVSEC := 1;
VR_HISTORICO.NOVGEN := 2;
VR_HISTORICO.NOVNRO := VR_NOVEDAD_CUENTA.NOVNRO; --NP_RESPUESTA;
VR_HISTORICO.NOVTIP := VR_NOVEDAD_CUENTA.NOVTIP;
VR_HISTORICO.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_HISTORICO.FECHA_REGISTRO := VR_HISTORICO.NOVFCHING;
VR_HISTORICO.OPCION := 'NovBloqueoAdmTarjetaHandler';
VR_HISTORICO.NUMERO_CUENTA := VR_TARJETA.NUMERO_CUENTA;
VR_HISTORICO.TARJETA := VR_TARJETA.TARJETA;
VR_HISTORICO.TITULAR := CASE
WHEN VR_TARJETA.COMPONENTE = 1 THEN
1
ELSE
2
END;
VR_NOVEDAD_CUENTA.NOVNROSEC := 1; --NP_FORMULARIO;
VR_NOVEDAD_CUENTA.USUARIO := PI_USUARIO_NOVEDAD; --CP_USUARIO_ENTIDAD;
VR_NOVEDAD_CUENTA.BIN := SUBSTR(PI_NUMERO_TARJETA, 1, 6); -- asumio long de bin = 6
VR_NOVEDAD_CUENTA.PRODUCTO := 1;
VR_NOVEDAD_CUENTA.EMISOR_CUENTA := VR_TARJETA.EMISOR;
VR_NOVEDAD_CUENTA.SUCURSAL_CUENTA := VR_TARJETA.SUCURSAL_EMISOR;
VR_NOVEDAD_TARJETA.NOVNRO := VR_NOVEDAD_CUENTA.NOVNRO;
VR_NOVEDAD_TARJETA.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_NOVEDAD_TARJETA.NOVANUORG := CC_BLOQUEO_USUARIO;
VR_NOVEDAD_TARJETA.NOVMOTDEV := PI_MOTIVO_BLOQUEO;
VR_NOVEDAD_TARJETA.NOVSEC := 1;
VR_NOVEDAD_TARJETA.NOVNROSEC := VR_NOVEDAD_CUENTA.NOVNROSEC;
VR_NOVEDAD_TARJETA.NUMERO_CUENTA := VR_TARJETA.NUMERO_CUENTA;
VR_NOVEDAD_TARJETA.EMISOR_CUENTA := VR_NOVEDAD_CUENTA.EMISOR_CUENTA;
VR_NOVEDAD_TARJETA.SUCURSAL_CUENTA := VR_NOVEDAD_CUENTA.SUCURSAL_CUENTA;
--Historico a nivel de Cuentas.
VR_HISTORICO.TABLA := 'NOVEDADES_CUENTAS';
--#Formulario
VR_HISTORICO.CAMPO := 'NOVNROSEC';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_NOVEDAD_CUENTA.NOVNROSEC; --NP_FORMULARIO;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Estado de la Cuenta antes del Bloqueo
VR_HISTORICO.CAMPO := 'ESTADO_CUENTA';
VR_CUENTA.ESTADO := ESTADO_CT(VR_TARJETA.NUMERO_CUENTA, 'C');
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := '(' || VR_CUENTA.ESTADO || ') ' ||
fn_get_estado_desc(VR_CUENTA.ESTADO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Estado de la Tarjeta antes del bloqueo
VR_HISTORICO.CAMPO := 'ESTADO_TARJETA';
VR_TARJETA.ESTADO := ESTADO_CT(VR_TARJETA.TARJETA, 'T');
VR_HISTORICO.DATO_ANTERIOR := '(' || VR_TARJETA.ESTADO || ') ' ||
fn_get_estado_desc(VR_TARJETA.ESTADO);
VR_HISTORICO.DATO_POSTERIOR := '(' || VR_NOVEDAD_TARJETA.NUEVO_ESTADO || ') ' ||
fn_get_estado_desc(VR_NOVEDAD_TARJETA.NUEVO_ESTADO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Historico a nivel de Tarjetas.
VR_HISTORICO.TABLA := 'NOVEDADES_TARJETAS';
--#Origen del bloqueo Entidad o Usuario
VR_HISTORICO.CAMPO := 'NOVANUORG';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := 'Usuario';
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Motivo del bloqueo.
VR_HISTORICO.CAMPO := 'NOVMOTDEV';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := fn_get_motivo_bloqueo(PI_MOTIVO_BLOQUEO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
IF PI_OTROS_MOTIVO_DESC IS NOT NULL THEN
--#Motivo del bloqueo.
VR_HISTORICO.CAMPO := 'OTROMOTIVO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := PI_OTROS_MOTIVO_DESC;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
END IF;
sp_resguarda_datos_historico;
sp_registrar_hist_novedad;
VR_HISTORICO := VC_HISTORICO;
--Cuando el usuario bloquea, solo bloquea su tarjeta
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := 5;
--Para poder evaluar la novedad.
VR_CUENTA.EMISOR := PI_ENTIDAD_NOVEDAD; --NP_ENTIDAD_ID;
VR_CUENTA.OPERADOR := TRIM(SUBSTR(UPPER(PI_USUARIO_NOVEDAD), 1, 8)); --TRIM(SUBSTR(UPPER(CP_USUARIO_ENTIDAD),1,8));
INSERT INTO TARJETA_TMP
(EMISOR, NUMERO_CUENTA, TARJETA, ESTADO, FECHA_VIGENCIA)
VALUES
(VR_TARJETA.EMISOR,
VR_TARJETA.NUMERO_CUENTA,
VR_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_TARJETA.FECHA_VIGENCIA);
INSERT INTO CUENTA_TMP
(EMISOR, OPERADOR)
VALUES
(VR_CUENTA.EMISOR, VR_CUENTA.OPERADOR);
--Validar la Novedad
SM.PR_VALIDAR_NOVEDAD(305,
VR_NOVEDAD_CUENTA.NOVNRO,
VR_NOVEDAD_CUENTA.NOVFCHING,
VR_CUENTA.OPERADOR, --CP_USUARIO_ENTIDAD,
VR_CUENTA.EMISOR); -- NP_ENTIDAD_ID);
--Registramos en Cambios de Estado.
INSERT INTO CREDITOPY.CAMBIOS_DE_ESTADO@OLPY
VALUES
(VR_NOVEDAD_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_NOVEDAD_CUENTA.NOVFCHING,
creditopy.seq_estados.nextval@OLPY);
--Registramos la novedad para procesarse en el Batch.
INSERT INTO NOVEDADES_CUENTAS@OLPY VALUES VR_NOVEDAD_CUENTA;
INSERT INTO NOVEDADES_TARJETAS@OLPY VALUES VR_NOVEDAD_TARJETA;
sp_resguarda_datos_historico;
sp_registrar_hist_novedad;
VR_HISTORICO := VC_HISTORICO;
COMMIT;
/*
open po_cursor for
select VR_NOVEDAD_CUENTA.NOVNRO AS CODIGO_NOVEDAD
from dual;
PO_SQLCODE := sqlcode;
PO_SQLERRM := sqlerrm;
*/
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
OPEN po_cursor FOR
SELECT VR_NOVEDAD_CUENTA.NOVNRO AS CODIGO_NOVEDAD,
0 AS ID_SOLICITUD,
0 AS CODIGO_RESPUESTA,
' ' AS GLOSA_RESPUESTA
FROM dual;
-- Se incluye un dummy para evitar bloque/desbloqueo en la misma hora
sp_delay(CC_DELAY_SECONDS);
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
sp_rechazar_novedad;
ROLLBACK;
END;
PROCEDURE spDesbloqueoTarjetaPrepaga(PI_NUMERO_TARJETA IN VARCHAR2,
PI_ORIGEN_PEDIDO IN NUMBER, -- 1-Usuario; 2-Entidad
PI_USUARIO_NOVEDAD IN VARCHAR2, -- usuario que procesa la novedad
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
VR_SOLICITUD SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS SOLICITUDES_DATOS%ROWTYPE;
VC_TARJETA VARCHAR2(19);
VN_NEW_ESTADO NUMBER(4);
VN_NEW_CLASE_DE_ESTADO NUMBER(4);
VN_NEW_ESTADO_FISICA NUMBER(4);
VN_IS_DBLOQ_USUARIO NUMBER(1);
VN_DBLOQ_USU_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 48;
VN_DBLOQ_USU_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 49;
VN_DBLOQ_ENT_OK SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 52;
VN_DBLOQ_ENT_RECHA SOLICITUDES_RECIBIDAS.ID_ESTADO%TYPE := 53;
BEGIN
--Datos DIMO
PV_USUARIO := get_usuario;
PV_USUARIO := NVL(PI_USUARIO_NOVEDAD, PV_USUARIO);
--Datos de la Tarjeta
VC_TARJETA := FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
-- obtener datos de la tarjeta
VR_TARJETA := NULL;
VR_TARJETAS_PREPAGA := NULL;
sp_get_tarjeta(VC_TARJETA, VR_TARJETA);
sp_get_tarjeta_prepaga(VC_TARJETA, VR_TARJETAS_PREPAGA);
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
--Datos de la Solicitud
CASE PI_ORIGEN_PEDIDO
WHEN 1 THEN
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_DESBLOQ_USU_DIMO;
VR_SOLICITUD.ID_ESTADO := VN_DBLOQ_USU_OK;
VN_IS_DBLOQ_USUARIO := 1;
WHEN 2 THEN
VR_SOLICITUD.ID_SOLICITUD := SOLICITUD_DESBLOQ_ENT_DIMO;
VR_SOLICITUD.ID_ESTADO := VN_DBLOQ_ENT_OK;
VN_IS_DBLOQ_USUARIO := 0;
ELSE
raise_application_error(-20001,
'USERS_ERROR: origen desbloqueo is null.');
END CASE;
VR_SOLICITUD.TARJETA := PI_NUMERO_TARJETA;
VR_SOLICITUD.USUARIO := PV_USUARIO; --PI_USUARIO_NOVEDAD;
VR_SOLICITUD.DOCUMENTO := TRIM(LEADING '0' FROM
SUBSTR(VR_TARJETA.DOCUMENTO, 4, 12));
--Datos del nuevo estado
IF VR_TARJETA.FECHA_VIGENCIA < TRUNC(SYSDATE) THEN
-- vencio la tarjeta virtual
VN_NEW_ESTADO := 8;
ELSE
VN_NEW_ESTADO := VR_TARJETA.ORIGEN_ANULACION;
VR_TARJETA.ORIGEN_ANULACION := 0;
END IF;
SELECT e.clase_de_estado
INTO VN_NEW_CLASE_DE_ESTADO
FROM creditopy.estados_ctas_tarj e
WHERE e.estado = VN_NEW_ESTADO;
IF VR_TARJETAS_PREPAGA.FECHA_VIG_PLASTICO >= TRUNC(SYSDATE) THEN
IF VR_TARJETAS_PREPAGA.ESTADO_PLASTICO = 5 THEN
VN_NEW_ESTADO_FISICA := VN_NEW_ESTADO;
ELSE
IF VN_IS_DBLOQ_USUARIO = 1 THEN
VN_NEW_ESTADO_FISICA := VR_TARJETAS_PREPAGA.ESTADO_PLASTICO;
ELSE
VN_NEW_ESTADO_FISICA := VN_NEW_ESTADO;
END IF;
END IF;
ELSE
IF VR_TARJETAS_PREPAGA.ESTADO_PLASTICO = 5 THEN
VN_NEW_ESTADO_FISICA := 8;
ELSE
VN_NEW_ESTADO_FISICA := VR_TARJETAS_PREPAGA.ESTADO_PLASTICO;
END IF;
END IF;
--Datos de la Novedad
VR_NOVEDAD_TARJETA.TARJETA := VR_TARJETA.TARJETA;
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := VN_NEW_ESTADO;
VR_NOVEDAD_TARJETA.NOVFCHING := SYSDATE;
--Utilizamos estos campos para controlar el nuevo estado
--VR_DATOS.PAIS := PI_ORIGEN_PEDIDO;
VR_DATOS.PAIS := VN_NEW_ESTADO;
VR_DATOS.CIUDAD := PI_ORIGEN_PEDIDO;
PR_SOLICITUDES(VR_SOLICITUD, VR_DATOS);
IF VR_SOLICITUD.ID_ESTADO IN (VN_DBLOQ_USU_OK, VN_DBLOQ_ENT_OK) AND
VR_SOLICITUD.CODIGO_RESPUESTA = 0 THEN
--Registramos en Cambios de Estado.
INSERT INTO CREDITOPY.CAMBIOS_DE_ESTADO@OLPY
VALUES
(VR_NOVEDAD_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_NOVEDAD_TARJETA.NOVFCHING,
creditopy.seq_estados.nextval@OLPY);
-- actualizar el estado de TARJETAS
UPDATE TARJETAS T
SET T.ESTADO = VN_NEW_ESTADO,
T.CLASE_DE_ESTADO = VN_NEW_CLASE_DE_ESTADO,
T.FECHA_ESTADO = VR_NOVEDAD_TARJETA.NOVFCHING,
T.ORIGEN_ANULACION = VR_TARJETA.ORIGEN_ANULACION,
T.ULT_ACTUALIZACION = VR_NOVEDAD_TARJETA.NOVFCHING,
T.OPERADOR = SUBSTR(PV_USUARIO, 1, 8) --rpad(PI_USUARIO_NOVEDAD,8)
WHERE T.TARJETA = VR_TARJETA.TARJETA;
-- actualizar TARJETAS_PREPAGA vigente, solo si fue impresa y activada
UPDATE TARJETAS_PREPAGA TP
SET TP.ESTADO_PLASTICO = VN_NEW_ESTADO_FISICA,
TP.FECHA_ULT_ACTUALIZACION = VR_NOVEDAD_TARJETA.NOVFCHING
WHERE TP.TARJETA = VR_TARJETA.TARJETA
AND TP.FECHA_VIG_PLASTICO >= TRUNC(SYSDATE)
AND TP.ESTADO_PLASTICO NOT IN (0, 9);
END IF;
COMMIT;
IF VR_SOLICITUD.CODIGO_RESPUESTA != 0 THEN
po_sqlcode := VR_SOLICITUD.CODIGO_RESPUESTA;
po_sqlerrm := fn_get_ult_rechazo_solicitud(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.CODIGO_RESPUESTA);
ELSE
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END IF;
OPEN po_cursor FOR
SELECT decode(VR_SOLICITUD.CODIGO_RESPUESTA,
0,
0,
nvl(VR_SOLICITUD.NOVEDAD, 0)) AS CODIGO_NOVEDAD,
VR_SOLICITUD.ID_SOLICITUD_RECIBIDA AS ID_SOLICITUD,
VR_SOLICITUD.CODIGO_RESPUESTA AS CODIGO_RESPUESTA,
decode(VR_SOLICITUD.CODIGO_RESPUESTA, 0, ' ', PO_SQLERRM) AS GLOSA_RESPUESTA
FROM dual;
-- Se incluye un dummy para evitar bloque/desbloqueo en la misma hora
sp_delay(CC_DELAY_SECONDS);
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
IF VR_SOLICITUD.ID_SOLICITUD_RECIBIDA IS NOT NULL THEN
VR_SOLICITUD.ID_ESTADO := CASE
WHEN VN_IS_DBLOQ_USUARIO = 1 THEN
VN_DBLOQ_USU_RECHA
ELSE
VN_DBLOQ_ENT_RECHA
END;
PR_ADM_ERROR_SOLICITUD(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA,
VR_SOLICITUD.ID_ESTADO,
SQLCODE,
SQLERRM);
END IF;
ROLLBACK;
OPEN po_cursor FOR
SELECT nvl(VR_NOVEDAD_CUENTA.NOVNRO, 0) AS CODIGO_NOVEDAD,
nvl(VR_SOLICITUD.ID_SOLICITUD_RECIBIDA, 0) AS ID_SOLICITUD,
po_sqlcode AS CODIGO_RESPUESTA,
po_sqlerrm AS GLOSA_RESPUESTA
FROM dual;
END spDesbloqueoTarjetaPrepaga;
PROCEDURE sp_bloqueoDesbloqueoDIMO(PI_TIPO_OPERACION IN NUMBER, -- Bandera para saber si la operacion es 1-bloquear, 2-desbloquear.
PI_NUMERO_TARJETA IN VARCHAR2, -- Numero de tarjeta
PI_ORIGEN_PEDIDO IN NUMBER, -- 1- Decisión del usuario 2- Decisión de la Entidad
PI_MOTIVO_PEDIDO IN NUMBER, -- Codigo del motivo del pedido - REGLA_WEB 13647
PI_OTROS_MOTIVO_DESC IN VARCHAR2, -- Descripcion de motivo otros
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
vn_emisor creditopy.tarjetas.emisor%TYPE;
/*
20- Bloqueo y desbloqueo de tarjeta DIMO
*/
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 23/06/2020
Propósito: Procedimiento que permite bloquear/desbloquear una tarjeta DIMO a pedido del usuario.
El procedimiento puede ser invocado para el bloqueo a solicitud de la entidad.
****************************************************************************************************/
BEGIN
-- obtener datos DIMO
PV_USUARIO := get_usuario;
-- validar parametros de entrada no nulos
IF PI_NUMERO_TARJETA IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: tarjeta is null.');
ELSE
-- validar que el emisor de la tarjeta sea un emisor PREPAGO
BEGIN
SELECT t.emisor
INTO vn_emisor
FROM creditopy.tarjetas t
WHERE t.tarjeta = fc_pan2cripto(PI_NUMERO_TARJETA);
IF creditopy.pkg_dimo_ceibo.fn_is_prepaga(vn_emisor) = 0 THEN
raise_application_error(-20001,
'USERS_ERROR: la tarjeta no es prepaga.');
END IF;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END;
END IF;
IF NVL(PI_ORIGEN_PEDIDO, 0) != 1 AND NVL(PI_ORIGEN_PEDIDO, 0) != 2 THEN
raise_application_error(-20001,
'USERS_ERROR: origen pedido invalid.');
END IF;
IF NVL(PI_MOTIVO_PEDIDO, 0) = 0 THEN
IF nvl(PI_TIPO_OPERACION, 0) = 1 THEN
raise_application_error(-20001,
'USERS_ERROR: motivo pedido invalid.');
END IF;
END IF;
-- bloqueo/desbloqueo
CASE nvl(PI_TIPO_OPERACION, 0)
WHEN 1 THEN
spBloqueoTarjetaPrepaga(PI_NUMERO_TARJETA,
PI_ORIGEN_PEDIDO, -- 1-Usuario; 2-Entidad
PI_MOTIVO_PEDIDO, --REGLA_WEB 13647
PI_OTROS_MOTIVO_DESC,
PV_USUARIO, --CC_USUARIO_DIMO,
PO_SQLCODE,
PO_SQLERRM,
po_cursor);
WHEN 2 THEN
spDesbloqueoTarjetaPrepaga(PI_NUMERO_TARJETA,
PI_ORIGEN_PEDIDO, -- 1-Usuario; 2-Entidad
PV_USUARIO, --CC_USUARIO_DIMO,
PO_SQLCODE,
PO_SQLERRM,
po_cursor);
ELSE
RAISE_APPLICATION_ERROR(-20001,
'USERS_ERROR: operacion not valid.');
END CASE;
IF PO_SQLCODE != 0 THEN
PO_SQLCODE := -1;
END IF;
EXCEPTION
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
END sp_bloqueoDesbloqueoDIMO;
PROCEDURE sp_motivosBloqueoDevoluc(PI_ORIGEN_PEDIDO IN NUMBER, -- 1- Decisión del usuario 2- Decisión de la Entidad
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
20.1- Motivos de Bloqueo y devolucion
*/
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 23/06/2020
Propósito: Procedimiento lista los motivos de bloqueo y devolucion de tarjetas.
Permite compatibilizar la carga de motivos respetando la tabla utilizada por
las tarjetas de credito.
****************************************************************************************************/
BEGIN
IF PI_ORIGEN_PEDIDO IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: origen is null.');
ELSE
IF PI_ORIGEN_PEDIDO NOT IN (1, 2) THEN
raise_application_error(-20001,
'USERS_ERROR: valor de origen incorrecto.');
END IF;
END IF;
OPEN po_cursor FOR
SELECT m.id_motivo AS id_motivo,
m.devcod AS motivo_pedido,
m.descripcion AS desc_motivo,
m.origen_pedido AS origen_pedido,
m.cargar_glosa AS flg_cargar_glosa
FROM creditopy.Motivos_Bloqueo_Devoluc m
WHERE m.origen_pedido =
decode(PI_ORIGEN_PEDIDO, 1, 1, m.origen_pedido)
ORDER BY m.id_motivo;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_motivosBloqueoDevoluc;
PROCEDURE spBloqueoTarjeta(PI_NUMERO_TARJETA IN VARCHAR2,
PI_ORIGEN_PEDIDO IN NUMBER, -- 1-Usuario; 2-Entidad
PI_MOTIVO_BLOQUEO IN NUMBER, --REGLA_WEB 13647
PI_OTROS_MOTIVO_DESC IN VARCHAR2,
PI_ENTIDAD_NOVEDAD IN NUMBER, -- entidad del usuario que procesa la novedad
PI_USUARIO_NOVEDAD IN VARCHAR2, -- usuario que procesa la novedad
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
24- Bloqueo y desbloqueo de tarjeta TC
Adaptado del PKG_SICOOP_DIMO.
Ajustes a invocacion para el backend DIMO: A.Rodriguez. 29/05/2020
*/
/*
Autor: Edgar Rojas.
Fecha: 19/03/2020
Proposito: Operaciones DIMO - Bloqueo.
Bloqueo y desbloqueo de una tarjeta a solicitud del usuario.
La novedad se ejecuta con el emisor y usuario recibido, por tanto
se puede disponibilizar desde un endpoint especifico.
Referencia: API_SICOOP-CEIBO(postrevision).xlsx. Hoja 20-Bloqueo-Desbloqueo
*/
BEGIN
-- FALTA VALIDAR LOS DATOS DE ENTRADA
-- Limpiamos la tabla VR_HISTORICOS.
VR_HISTORICOS.DELETE;
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
-- obtener datos de la tarjeta
sp_get_tarjeta(FC_PAN2CRIPTO(PI_NUMERO_TARJETA), VR_TARJETA);
-- obtener datos de la cuenta
sp_get_cuenta(VR_TARJETA.NUMERO_CUENTA, VR_CUENTA);
--Obtener la numero de novedad.
VR_NOVEDAD_CUENTA.NOVNRO := FN_GET_NRO_NOVEDAD;
VR_NOVEDAD_CUENTA.NOVTIP := 14;
VR_NOVEDAD_CUENTA.NOVFCHING := SYSDATE;
VR_NOVEDAD_CUENTA.NUMERO_CUENTA := NULL;
VR_NOVEDAD_TARJETA.NOVTIP := 14;
IF PI_ORIGEN_PEDIDO = 1 THEN
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := 5;
ELSE
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := 4;
END IF;
VR_NOVEDAD_TARJETA.TARJETA := VR_TARJETA.TARJETA; --FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
--Datos constantes en el historico de Cuentas.
-- Se asume que la tarjeta es titular.
VR_HISTORICO.USUARIO := PI_USUARIO_NOVEDAD; --CP_USUARIO_ENTIDAD;
VR_HISTORICO.DESPLEGAR := 0;
VR_HISTORICO.EMISOR := PI_ENTIDAD_NOVEDAD; --VR_TARJETA.EMISOR;
VR_HISTORICO.NOVSEC := 1;
VR_HISTORICO.NOVGEN := 2;
VR_HISTORICO.NOVNRO := VR_NOVEDAD_CUENTA.NOVNRO; --NP_RESPUESTA;
VR_HISTORICO.NOVTIP := VR_NOVEDAD_CUENTA.NOVTIP;
VR_HISTORICO.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_HISTORICO.FECHA_REGISTRO := VR_HISTORICO.NOVFCHING;
VR_HISTORICO.OPCION := 'NovBloqueoAdmTarjetaHandler';
VR_HISTORICO.NUMERO_CUENTA := VR_TARJETA.NUMERO_CUENTA;
VR_HISTORICO.TARJETA := VR_TARJETA.TARJETA;
VR_HISTORICO.TITULAR := CASE
WHEN VR_TARJETA.COMPONENTE = 1 THEN
1
ELSE
2
END;
VR_NOVEDAD_CUENTA.NOVNROSEC := 1; --NP_FORMULARIO;
VR_NOVEDAD_CUENTA.USUARIO := PI_USUARIO_NOVEDAD; --CP_USUARIO_ENTIDAD;
VR_NOVEDAD_CUENTA.BIN := SUBSTR(PI_NUMERO_TARJETA, 1, 6); -- asumio long de bin = 6
VR_NOVEDAD_CUENTA.PRODUCTO := 1;
VR_NOVEDAD_CUENTA.EMISOR_CUENTA := VR_TARJETA.EMISOR;
VR_NOVEDAD_CUENTA.SUCURSAL_CUENTA := VR_TARJETA.SUCURSAL_EMISOR;
VR_NOVEDAD_TARJETA.NOVNRO := VR_NOVEDAD_CUENTA.NOVNRO;
VR_NOVEDAD_TARJETA.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_NOVEDAD_TARJETA.NOVANUORG := PI_ORIGEN_PEDIDO;
VR_NOVEDAD_TARJETA.NOVMOTDEV := PI_MOTIVO_BLOQUEO;
VR_NOVEDAD_TARJETA.NOVSEC := 1;
VR_NOVEDAD_TARJETA.NOVNROSEC := VR_NOVEDAD_CUENTA.NOVNROSEC;
VR_NOVEDAD_TARJETA.NUMERO_CUENTA := VR_TARJETA.NUMERO_CUENTA;
VR_NOVEDAD_TARJETA.EMISOR_CUENTA := VR_NOVEDAD_CUENTA.EMISOR_CUENTA;
VR_NOVEDAD_TARJETA.SUCURSAL_CUENTA := VR_NOVEDAD_CUENTA.SUCURSAL_CUENTA;
--Historico a nivel de Cuentas.
VR_HISTORICO.TABLA := 'NOVEDADES_CUENTAS';
--#Formulario
VR_HISTORICO.CAMPO := 'NOVNROSEC';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_NOVEDAD_CUENTA.NOVNROSEC; --NP_FORMULARIO;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Estado de la Cuenta antes del Bloqueo
VR_HISTORICO.CAMPO := 'ESTADO_CUENTA';
VR_CUENTA.ESTADO := ESTADO_CT(VR_TARJETA.NUMERO_CUENTA, 'C');
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := '(' || VR_CUENTA.ESTADO || ') ' ||
fn_get_estado_desc(VR_CUENTA.ESTADO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Estado de la Tarjeta antes del bloqueo
VR_HISTORICO.CAMPO := 'ESTADO_TARJETA';
VR_TARJETA.ESTADO := ESTADO_CT(VR_TARJETA.TARJETA, 'T');
VR_HISTORICO.DATO_ANTERIOR := '(' || VR_TARJETA.ESTADO || ') ' ||
fn_get_estado_desc(VR_TARJETA.ESTADO);
VR_HISTORICO.DATO_POSTERIOR := '(' || VR_NOVEDAD_TARJETA.NUEVO_ESTADO || ') ' ||
fn_get_estado_desc(VR_NOVEDAD_TARJETA.NUEVO_ESTADO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--Historico a nivel de Tarjetas.
VR_HISTORICO.TABLA := 'NOVEDADES_TARJETAS';
--#Origen del bloqueo Entidad o Usuario
VR_HISTORICO.CAMPO := 'NOVANUORG';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := CASE PI_ORIGEN_PEDIDO
WHEN 1 THEN
'Usuario'
WHEN 2 THEN
'Emisor'
ELSE
'No determinado'
END;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Motivo del bloqueo.
VR_HISTORICO.CAMPO := 'NOVMOTDEV';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := fn_get_motivo_bloqueo(PI_MOTIVO_BLOQUEO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
IF PI_OTROS_MOTIVO_DESC IS NOT NULL THEN
--#Motivo del bloqueo.
VR_HISTORICO.CAMPO := 'OTROMOTIVO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := PI_OTROS_MOTIVO_DESC;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
END IF;
sp_resguarda_datos_historico;
sp_registrar_hist_novedad;
VR_HISTORICO := VC_HISTORICO;
--Para poder evaluar la novedad.
VR_CUENTA.EMISOR := PI_ENTIDAD_NOVEDAD; --NP_ENTIDAD_ID;
VR_CUENTA.OPERADOR := TRIM(SUBSTR(UPPER(PI_USUARIO_NOVEDAD), 1, 8)); --TRIM(SUBSTR(UPPER(CP_USUARIO_ENTIDAD),1,8));
INSERT INTO TARJETA_TMP
(EMISOR, NUMERO_CUENTA, TARJETA, ESTADO, FECHA_VIGENCIA)
VALUES
(VR_TARJETA.EMISOR,
VR_TARJETA.NUMERO_CUENTA,
VR_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_TARJETA.FECHA_VIGENCIA);
INSERT INTO CUENTA_TMP
(EMISOR, OPERADOR)
VALUES
(VR_CUENTA.EMISOR, VR_CUENTA.OPERADOR);
--Validar la Novedad
SM.PR_VALIDAR_NOVEDAD(301,
VR_NOVEDAD_CUENTA.NOVNRO,
VR_NOVEDAD_CUENTA.NOVFCHING,
VR_CUENTA.OPERADOR, --CP_USUARIO_ENTIDAD,
VR_CUENTA.EMISOR); -- NP_ENTIDAD_ID);
--Registramos en Cambios de Estado.
INSERT INTO CREDITOPY.CAMBIOS_DE_ESTADO@OLPY
VALUES
(VR_NOVEDAD_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_NOVEDAD_CUENTA.NOVFCHING,
creditopy.seq_estados.nextval@OLPY);
--Registramos la novedad para procesarse en el Batch.
INSERT INTO NOVEDADES_CUENTAS@OLPY VALUES VR_NOVEDAD_CUENTA;
INSERT INTO NOVEDADES_TARJETAS@OLPY VALUES VR_NOVEDAD_TARJETA;
--Procedemos a Bloquear las demas Tarjetas
-- Solo si es la Principal, se bloquean todas las demas tarjetas Operativas de la Cuenta.
IF FC_TJTP(VR_TARJETA.NUMERO_CUENTA) = VR_TARJETA.TARJETA AND
VR_NOVEDAD_TARJETA.NUEVO_ESTADO = 4 THEN
FOR TARJETAS_OPERATIVAS IN (SELECT FC_CRIPTO2PAN(T.TARJETA) TARJETA,
T.NOMBRE_PARA_PLASTICO NOMBRE_PLASTICO,
ESTADO_CT(T.TARJETA, 'T') ESTADO_OL,
T.TARJETA CRIPTO
FROM TARJETAS T
WHERE T.NUMERO_CUENTA =
VR_TARJETA.NUMERO_CUENTA
AND T.FECHA_VIGENCIA > SYSDATE
AND 1 = CASE
WHEN T.TARJETA =
VR_TARJETA.TARJETA THEN
0
ELSE
1
END
) LOOP
IF TARJETAS_OPERATIVAS.ESTADO_OL IN (0,
1,
5,
50,
51,
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69) THEN
--Registramos en Cambios de Estado.
INSERT INTO CREDITOPY.CAMBIOS_DE_ESTADO@OLPY
VALUES
(TARJETAS_OPERATIVAS.CRIPTO,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_NOVEDAD_CUENTA.NOVFCHING,
CREDITOPY.SEQ_ESTADOS.NEXTVAL@OLPY);
--#Tarjetas Operativas de la Cuenta Bloqueadas por Bloqueo de la Principal.
VR_HISTORICO.CAMPO := 'ADIC_BLOQUEADAS';
VR_TARJETA.ESTADO := ESTADO_CT(VR_TARJETA.TARJETA, 'T');
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := TARJETAS_OPERATIVAS.TARJETA || ' (' ||
VR_TARJETA.ESTADO || ') ' ||
FC_GET_ESTADO(VR_TARJETA.ESTADO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Nombres de Plastico de Tarjetas Operativas de la Cuenta Bloqueadas por Bloqueo de la Principal.
VR_HISTORICO.CAMPO := 'NOMBRE_PLASTICO';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := TARJETAS_OPERATIVAS.NOMBRE_PLASTICO;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
END IF;
END LOOP;
sp_resguarda_datos_historico;
sp_registrar_hist_novedad;
VR_HISTORICO := VC_HISTORICO;
END IF;
COMMIT;
/*
open po_cursor for
select VR_NOVEDAD_CUENTA.NOVNRO AS CODIGO_NOVEDAD
from dual;
PO_SQLCODE := sqlcode;
PO_SQLERRM := sqlerrm;
*/
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
OPEN po_cursor FOR
SELECT VR_NOVEDAD_CUENTA.NOVNRO AS CODIGO_NOVEDAD,
0 AS ID_SOLICITUD,
0 AS CODIGO_RESPUESTA,
' ' AS GLOSA_RESPUESTA
FROM dual;
-- Se incluye un dummy para evitar bloque/desbloqueo en la misma hora
sp_delay(CC_DELAY_SECONDS);
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
sp_rechazar_novedad;
ROLLBACK;
END spBloqueoTarjeta;
PROCEDURE spDesbloqueoTarjeta(PI_NUMERO_TARJETA IN VARCHAR2,
PI_ORIGEN_PEDIDO IN NUMBER, -- 1-Usuario; 2-Entidad
PI_ENTIDAD_NOVEDAD IN NUMBER, -- entidad del usuario que procesa la novedad
PI_USUARIO_NOVEDAD IN VARCHAR2, -- usuario que procesa la novedad
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
24- Bloqueo y desbloqueo de tarjeta TC
Adaptado del PKG_SICOOP_DIMO.
Ajustes a invocacion para el backend DIMO: A.Rodriguez. 03/06/2020
*/
/*
Autor: Edgar Rojas.
Fecha: 19/03/2020
Proposito: Operaciones DIMO - Desbloqueo.
Bloqueo y desbloqueo de una tarjeta a solicitud del usuario.
La novedad se ejecuta con el emisor y usuario recibido, por tanto
se puede disponibilizar desde un endpoint especifico.
Referencia: API_SICOOP-CEIBO(postrevision).xlsx. Hoja 20-Bloqueo-Desbloqueo
*/
BEGIN
-- FALTA VALIDAR LOS DATOS DE ENTRADA
-- Limpiamos la tabla VR_HISTORICOS.
VR_HISTORICOS.DELETE;
-- Inicializar registros de novedades.
sp_InitNovedades(VR_NOVEDAD_CUENTA, VR_NOVEDAD_TARJETA);
-- obtener datos de la tarjeta
sp_get_tarjeta(FC_PAN2CRIPTO(PI_NUMERO_TARJETA), VR_TARJETA);
-- obtener datos de la cuenta
sp_get_cuenta(VR_TARJETA.NUMERO_CUENTA, VR_CUENTA);
--Obtener la numero de novedad.
VR_NOVEDAD_CUENTA.NOVNRO := FN_GET_NRO_NOVEDAD; -- NP_NOVEDAD;
VR_NOVEDAD_CUENTA.NOVTIP := 15;
VR_NOVEDAD_CUENTA.NOVFCHING := SYSDATE;
VR_NOVEDAD_CUENTA.NUMERO_CUENTA := NULL;
VR_NOVEDAD_TARJETA.NOVTIP := 15;
VR_NOVEDAD_TARJETA.TARJETA := VR_TARJETA.TARJETA; --FC_PAN2CRIPTO(PI_NUMERO_TARJETA);
--Datos constantes en el historico de Cuentas. Se asume que la tarjeta es titular.
VR_HISTORICO.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_HISTORICO.USUARIO := PI_USUARIO_NOVEDAD; --CP_USUARIO_ENTIDAD;
VR_HISTORICO.DESPLEGAR := 0;
VR_HISTORICO.EMISOR := PI_ENTIDAD_NOVEDAD; --NP_ENTIDAD_ID;
VR_HISTORICO.NOVSEC := 1;
VR_HISTORICO.NOVGEN := 2;
VR_HISTORICO.NOVNRO := VR_NOVEDAD_CUENTA.NOVNRO; --NP_RESPUESTA;
VR_HISTORICO.NOVTIP := VR_NOVEDAD_CUENTA.NOVTIP;
VR_HISTORICO.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_HISTORICO.FECHA_REGISTRO := VR_HISTORICO.NOVFCHING;
VR_HISTORICO.OPCION := 'NovDesbloqueoAdmTarjetaHandler';
VR_HISTORICO.NUMERO_CUENTA := VR_TARJETA.NUMERO_CUENTA;
VR_HISTORICO.TARJETA := VR_TARJETA.TARJETA;
VR_HISTORICO.EMISOR := VR_TARJETA.EMISOR;
VR_HISTORICO.TITULAR := CASE
WHEN VR_TARJETA.COMPONENTE = 1 THEN
1
ELSE
2
END;
VR_CUENTA.ESTADO := ESTADO_CT(VR_CUENTA.NUMERO_CUENTA, 'C');
--mantis#2672
VR_TARJETA.ESTADO := ESTADO_CT(VR_TARJETA.TARJETA, 'T');
VR_TARJETA.CLASE_DE_ESTADO := PI_ORIGEN_PEDIDO;
--Evaluar el nuevo estado de la Tarjeta si se Desbloquea
----Debemos registrar en el Historico.
IF VR_CUENTA.ESTADO = 1 THEN
IF VR_TARJETA.FECHA_VIGENCIA > SYSDATE THEN
IF ESTADO_CT(VR_TARJETA.TARJETA, 'T') = VR_TARJETA.ESTADO THEN
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := CASE
WHEN VR_TARJETA.ORIGEN_ANULACION = 0 THEN
0
ELSE
VR_CUENTA.ESTADO
END;
ELSE
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := VR_TARJETA.ESTADO;
END IF;
ELSE
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := 8;
END IF;
ELSE
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := VR_CUENTA.ESTADO;
END IF;
VR_NOVEDAD_CUENTA.NOVNROSEC := 1; --NP_FORMULARIO;
VR_NOVEDAD_CUENTA.USUARIO := PI_USUARIO_NOVEDAD; --CP_USUARIO_ENTIDAD;
VR_NOVEDAD_CUENTA.BIN := SUBSTR(PI_NUMERO_TARJETA, 1, 6); -- asumio long de bin = 6
VR_NOVEDAD_CUENTA.PRODUCTO := 1;
VR_NOVEDAD_CUENTA.EMISOR_CUENTA := VR_TARJETA.EMISOR;
VR_NOVEDAD_CUENTA.SUCURSAL_CUENTA := VR_TARJETA.SUCURSAL_EMISOR;
VR_NOVEDAD_TARJETA.NOVNRO := VR_NOVEDAD_CUENTA.NOVNRO;
VR_NOVEDAD_TARJETA.NOVFCHING := VR_NOVEDAD_CUENTA.NOVFCHING;
VR_NOVEDAD_TARJETA.NOVANUORG := NULL;
VR_NOVEDAD_TARJETA.NOVMOTDEV := NULL;
VR_NOVEDAD_TARJETA.NOVSEC := 1;
VR_NOVEDAD_TARJETA.NOVNROSEC := VR_NOVEDAD_CUENTA.NOVNROSEC;
VR_NOVEDAD_TARJETA.NUMERO_CUENTA := VR_TARJETA.NUMERO_CUENTA;
VR_NOVEDAD_TARJETA.EMISOR_CUENTA := VR_NOVEDAD_CUENTA.EMISOR_CUENTA;
VR_NOVEDAD_TARJETA.SUCURSAL_CUENTA := VR_NOVEDAD_CUENTA.SUCURSAL_CUENTA;
--Historico a nivel de Cuentas.
VR_HISTORICO.TABLA := 'NOVEDADES_CUENTAS';
--#Estado de la Cuenta antes del Desbloqueo
VR_HISTORICO.CAMPO := 'ESTADO_CUENTA';
VR_CUENTA.ESTADO := ESTADO_CT(VR_TARJETA.NUMERO_CUENTA, 'C');
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := '(' || VR_CUENTA.ESTADO || ') ' ||
FC_GET_ESTADO(VR_CUENTA.ESTADO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Estado de la Tarjeta antes del Desbloqueo
VR_HISTORICO.CAMPO := 'ESTADO_TARJETA';
VR_TARJETA.ESTADO := ESTADO_CT(VR_TARJETA.TARJETA, 'T');
VR_HISTORICO.DATO_ANTERIOR := '(' || VR_TARJETA.ESTADO || ') ' ||
FC_GET_ESTADO(VR_TARJETA.ESTADO);
VR_HISTORICO.DATO_POSTERIOR := '(' || VR_NOVEDAD_TARJETA.NUEVO_ESTADO || ') ' ||
FC_GET_ESTADO(VR_NOVEDAD_TARJETA.NUEVO_ESTADO);
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
VR_HISTORICO.TABLA := 'NOVEDADES_TARJETAS';
--#Origen del bloqueo Entidad o Usuario
VR_HISTORICO.CAMPO := 'NOVANUORG';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := CASE PI_ORIGEN_PEDIDO
WHEN 1 THEN
'Usuario'
WHEN 2 THEN
'Emisor'
ELSE
'No determinado'
END;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
--#Formulario
VR_HISTORICO.CAMPO := 'NOVNROSEC';
VR_HISTORICO.DATO_ANTERIOR := ' ';
VR_HISTORICO.DATO_POSTERIOR := VR_NOVEDAD_CUENTA.NOVNROSEC; --NP_FORMULARIO;
--Agregamos a la tabla de historicos.
VR_HISTORICOS(VR_HISTORICOS.COUNT + 1) := VR_HISTORICO;
sp_resguarda_datos_historico;
sp_registrar_hist_novedad;
VR_HISTORICO := VC_HISTORICO;
--Para poder evaluar la novedad.
VR_CUENTA.EMISOR := PI_ENTIDAD_NOVEDAD; --NP_ENTIDAD_ID;
VR_CUENTA.OPERADOR := TRIM(SUBSTR(UPPER(PI_USUARIO_NOVEDAD), 1, 8)); --TRIM(SUBSTR(UPPER(CP_USUARIO_ENTIDAD),1,8));
INSERT INTO TARJETA_TMP
(EMISOR,
SUCURSAL_EMISOR,
PRODUCTO,
NUMERO_CUENTA,
DOCUMENTO,
TARJETA,
ESTADO,
FECHA_VIGENCIA
--mantis#2672
,
ESTADO_DE_COSTO,
CLASE_DE_ESTADO)
VALUES
(VR_TARJETA.EMISOR,
VR_TARJETA.SUCURSAL_EMISOR,
VR_TARJETA.PRODUCTO,
VR_TARJETA.NUMERO_CUENTA,
VR_TARJETA.DOCUMENTO,
VR_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_TARJETA.FECHA_VIGENCIA,
--mantis#2672
VR_TARJETA.ESTADO,
VR_TARJETA.CLASE_DE_ESTADO);
INSERT INTO CUENTA_TMP
(EMISOR, OPERADOR)
VALUES
(VR_CUENTA.EMISOR, VR_CUENTA.OPERADOR);
--Validar la Novedad
SM.PR_VALIDAR_NOVEDAD(302,
VR_NOVEDAD_CUENTA.NOVNRO,
VR_NOVEDAD_CUENTA.NOVFCHING,
VR_CUENTA.OPERADOR, --CP_USUARIO_ENTIDAD,
VR_CUENTA.EMISOR); --NP_ENTIDAD_ID);
--Registramos en Cambios de Estado.
INSERT INTO CREDITOPY.CAMBIOS_DE_ESTADO@OLPY
VALUES
(VR_NOVEDAD_TARJETA.TARJETA,
VR_NOVEDAD_TARJETA.NUEVO_ESTADO,
VR_NOVEDAD_CUENTA.NOVFCHING,
creditopy.seq_estados.nextval@OLPY);
VR_NOVEDAD_TARJETA.NUEVO_ESTADO := NULL;
INSERT INTO NOVEDADES_CUENTAS@OLPY VALUES VR_NOVEDAD_CUENTA;
INSERT INTO NOVEDADES_TARJETAS@OLPY VALUES VR_NOVEDAD_TARJETA;
COMMIT;
/*
open po_cursor for
select VR_NOVEDAD_CUENTA.NOVNRO AS CODIGO_NOVEDAD
from dual;
*/
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
OPEN po_cursor FOR
SELECT VR_NOVEDAD_CUENTA.NOVNRO AS CODIGO_NOVEDAD,
0 AS ID_SOLICITUD,
0 AS CODIGO_RESPUESTA,
' ' AS GLOSA_RESPUESTA
FROM dual;
-- Se incluye un dummy para evitar bloque/desbloqueo en la misma hora
sp_delay(CC_DELAY_SECONDS);
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
sp_rechazar_novedad;
ROLLBACK;
END spDesbloqueoTarjeta;
PROCEDURE sp_bloqueoDesbloqueoTC(PI_TIPO_OPERACION IN NUMBER, -- Bandera para saber si la operacion es 1-bloquear, 2-desbloquear.
PI_NUMERO_TARJETA IN VARCHAR2, -- Numero de tarjeta
PI_ORIGEN_PEDIDO IN NUMBER, -- 1- Decisión del usuario 2- Decisión de la Entidad
PI_MOTIVO_PEDIDO IN NUMBER, -- Codigo del motivo del pedido - REGLA_WEB 13647
PI_OTROS_MOTIVO_DESC IN VARCHAR2, -- Descripcion de motivo otros
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
vn_emisor creditopy.tarjetas.emisor%TYPE;
/*
24- Bloqueo y desbloqueo de tarjeta TC
Adaptado del PKG_SICOOP_CEIBO.
Ajustes a invocacion para el backend DIMO: A.Rodriguez. 29/05/2020
*/
/*
Autor: Edgar Rojas.
Fecha: 19/03/2020
Proposito: Operaciones DIMO - Bloqueo, desbloqueo.
Bloqueo y desbloqueo de una tarjeta a solicitud del usuario.
La novedad se ejecuta con el emisor 805 (variable CC_ENT_DIMO_NOV)
y el usuario 'DIMO' (variable CC_USUARIO_DIMO)
Referencia: API_SICOOP-CEIBO(postrevision).xlsx. Hoja 20-Bloqueo-Desbloqueo
*/
BEGIN
-- validar parametros de entrada no nulos
IF PI_NUMERO_TARJETA IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: tarjeta is null.');
ELSE
-- validar que el emisor de la tarjeta no sea un emisor PREPAGO
BEGIN
SELECT t.emisor
INTO vn_emisor
FROM creditopy.tarjetas t
WHERE t.tarjeta = fc_pan2cripto(PI_NUMERO_TARJETA);
IF creditopy.pkg_dimo_ceibo.fn_is_prepaga(vn_emisor) = 1 THEN
raise_application_error(-20001,
'USERS_ERROR: la tarjeta no es de credito.');
END IF;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END;
END IF;
IF NVL(PI_ORIGEN_PEDIDO, 0) != 1 AND NVL(PI_ORIGEN_PEDIDO, 0) != 2 THEN
raise_application_error(-20001,
'USERS_ERROR: origen pedido invalid.');
END IF;
IF NVL(PI_MOTIVO_PEDIDO, 0) = 0 THEN
IF nvl(PI_TIPO_OPERACION, 0) = 1 THEN
raise_application_error(-20001,
'USERS_ERROR: motivo pedido invalid.');
END IF;
END IF;
--Validacion de Entidad Procesadora
IF vn_emisor = 40 THEN
--Panal: 806
CC_USUARIO_DIMO := 'DIMO_P';
CC_ENT_DIMO_NOV := 806;
END IF;
-- bloqueo/desbloqueo
CASE nvl(PI_TIPO_OPERACION, 0)
WHEN 1 THEN
IF PI_ORIGEN_PEDIDO = 2 THEN
spBloqueoTarjeta(PI_NUMERO_TARJETA,
PI_ORIGEN_PEDIDO, -- 1-Usuario; 2-Entidad
PI_MOTIVO_PEDIDO, --REGLA_WEB 13647
PI_OTROS_MOTIVO_DESC,
CC_ENT_DIMO_NOV,
CC_USUARIO_DIMO,
PO_SQLCODE,
PO_SQLERRM,
po_cursor);
ELSE
spBloqTarUsuarioDimo(PI_NUMERO_TARJETA,
PI_MOTIVO_PEDIDO, --REGLA_WEB 13647
PI_OTROS_MOTIVO_DESC,
CC_ENT_DIMO_NOV, -- entidad del usuario que procesa la novedad
CC_USUARIO_DIMO, -- usuario que procesa la novedad
PO_SQLCODE,
PO_SQLERRM,
po_cursor);
END IF;
WHEN 2 THEN
IF PI_ORIGEN_PEDIDO = 2 THEN
spDesbloqueoTarjeta(PI_NUMERO_TARJETA,
PI_ORIGEN_PEDIDO, -- 1-Usuario; 2-Entidad
CC_ENT_DIMO_NOV,
CC_USUARIO_DIMO,
PO_SQLCODE,
PO_SQLERRM,
po_cursor);
ELSE
spDesbTarUsuarioDIMO(PI_NUMERO_TARJETA,
CC_ENT_DIMO_NOV,
CC_USUARIO_DIMO,
PO_SQLCODE,
PO_SQLERRM,
po_cursor);
END IF;
ELSE
RAISE_APPLICATION_ERROR(-20001,
'USERS_ERROR: operacion not valid.');
END CASE;
IF PO_SQLCODE != 0 THEN
PO_SQLCODE := -1;
END IF;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_bloqueoDesbloqueoTC;
PROCEDURE sp_ObtenerCierreEmisor(PI_EMISOR IN NUMBER,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
33.2 - Obtener cierres-emisor
*/
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 24/08/2020
Propósito: Función que retorna datos de los cierres habilitados para un emisor.
******************************************************************************************************/
vb_existe NUMBER;
BEGIN
IF PI_EMISOR IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: Emisor is null.');
ELSE
BEGIN
SELECT 1
INTO vb_existe
FROM debcredpy.emisores e
WHERE e.emisor = PI_EMISOR
AND e.base_pago_minimo = 'A';
EXCEPTION
WHEN no_data_found THEN
raise_application_error(-20001, 'Emisor invalido.');
WHEN OTHERS THEN
RAISE;
END;
END IF;
OPEN po_cursor FOR
SELECT C.CIERRE,
CC.PERIODO PERIODO_ACTUAL, -- YYYYMM
TO_CHAR(MAX(CC.FECHA_VENCIMIENTO), 'DD/MM/YYYY') FECHA_VENCIMIENTO
FROM creditopy.CIERRES C,
creditopy.CIERRES_HABILITADOS B,
creditopy.CALENDARIO_CIERRES CC
WHERE c.EMISOR = PI_EMISOR
AND c.PRODUCTO = 1
AND B.EMISOR = C.EMISOR
AND B.PRODUCTO = C.PRODUCTO
AND B.CIERRE = C.CIERRE
AND CC.EMISOR = C.EMISOR
AND CC.PRODUCTO = C.PRODUCTO
AND CC.CIERRE = C.CIERRE
AND CC.PERIODO =
CS.GET_PERIODO_ACTUAL(C.EMISOR, C.PRODUCTO, C.CIERRE)
GROUP BY C.CIERRE, CC.PERIODO
ORDER BY C.CIERRE;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_ObtenerCierreEmisor;
PROCEDURE sp_comercioPrepago(PI_CODIGO_COMERCIO IN NUMBER,
PI_VALIDA_CREDITO_TP IN NUMBER,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/*
35 - Datos de comercio
*/
/****************************************************************************************************
Autor: Amalia Rodriguez
Fecha: 24/08/2020
Propósito: Función que retorna datos del comercio. Uso: APP DIMO Comercios.
******************************************************************************************************/
v_emisor_pago_prepaga NUMBER := 114;
vb_existe NUMBER;
v_estado NUMBER;
BEGIN
IF PI_CODIGO_COMERCIO IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: comercio is null.');
ELSE
BEGIN
SELECT 1, c.codigo_baja
INTO vb_existe, v_estado
FROM creditopy.comercios c
WHERE c.comercio = PI_CODIGO_COMERCIO
AND c.codigo_baja = 1;
IF v_estado != 1 THEN
raise_application_error(-20001, 'Comercio no habilitado.');
END IF;
EXCEPTION
WHEN no_data_found THEN
raise_application_error(-20001, 'No existe el comercio.');
WHEN OTHERS THEN
RAISE;
END;
END IF;
OPEN po_cursor FOR
SELECT c.comercio AS codigo_comercio,
c.descripcion AS nombre_comercio,
c.codigo_baja AS codigo_estado,
cp.descripcion AS estado,
c.ruc AS ruc,
c.razon_social AS razon_social,
c.pagador AS codigo_pagador,
p.descripcion AS desc_pagador,
-- número de cuenta
c.cuenta AS numero_de_cuenta,
-- tarjeta si tiene credito con prepaga comercio
CASE
WHEN c.pagador = v_emisor_pago_prepaga THEN
creditopy.fc_tjtp(c.cuenta)
ELSE
' '
END AS TARJETA,
-- mascara del número de la tarjeta desencriptada
CASE
WHEN c.pagador = v_emisor_pago_prepaga THEN
creditopy.pkg_dimo_ceibo.fn_get_tarjeta_mask(fc_tjtp(c.cuenta))
ELSE
' '
END AS tar_mask,
decode(c.pagador, v_emisor_pago_prepaga, 1, 0) AS tiene_cr_con_prepaga
FROM creditopy.comercios c,
creditopy.codigos_py cp,
creditopy.pagadores p
WHERE c.comercio = PI_CODIGO_COMERCIO
AND cp.tipo_codigo = c.cod_codigo_baja
AND cp.codigo = c.codigo_baja
AND p.emisor_procesador = c.emisor_procesador
AND p.pagador = c.pagador
AND ((nvl(PI_VALIDA_CREDITO_TP, 0) = 1 AND
c.pagador = v_emisor_pago_prepaga) OR
(nvl(PI_VALIDA_CREDITO_TP, 0) = 0));
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_comercioPrepago;
PROCEDURE sp_alta_gestion_reversos(pi_id_session_uuid VARCHAR2,
pi_motivo_inicial VARCHAR2 DEFAULT NULL,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
-- variables para la solicitud
VR_SOLICITUD CREDITOPY.SOLICITUDES_RECIBIDAS%ROWTYPE;
VR_DATOS CREDITOPY.SOLICITUDES_DATOS%ROWTYPE;
--v_uuid varchar2(100) := '61fcc7309f680aa6d0466bde4212c7c97532c7e3';
vuuid creditopy.sicoop_uuid.idsesion_uuid@olpy%TYPE;
vnumero_auditoria creditopy.sicoop_uuid.numero_auditoria@olpy%TYPE;
vfecha creditopy.sicoop_uuid.fecha@olpy%TYPE;
vr_log_transacc_cr log_transacc_cr@olpy%ROWTYPE;
vid_solicitud creditopy.solicitudes.id_solicitud%TYPE := 19;
vid_estado creditopy.solicitudes_estados.id_estado%TYPE := 64;
vdatos_hist VARCHAR2(1) := 'N';
vexception EXCEPTION;
vexception_mensaje VARCHAR2(500);
BEGIN
BEGIN
SELECT uuid.idsesion_uuid, uuid.numero_auditoria, uuid.fecha
INTO vuuid, vnumero_auditoria, vfecha
FROM creditopy.sicoop_uuid@olpy uuid
WHERE uuid.idsesion_uuid = pi_id_session_uuid;
EXCEPTION
WHEN no_data_found THEN
vuuid := NULL;
vnumero_auditoria := 0;
vexception_mensaje := 'UUID no existe';
RAISE vexception;
--raise_application_error(-20000,'UUID no existe');
WHEN OTHERS THEN
raise_application_error(-20000, 'Error al buscar UUID:' || SQLERRM);
END;
vr_log_transacc_cr := NULL;
BEGIN
SELECT *
INTO vr_log_transacc_cr
FROM creditopy.log_transacc_cr@olpy l
WHERE l.numero_auditoria = vnumero_auditoria
AND l.nro_autorizacion =
nvl((SELECT MIN(ll.nro_autorizacion)
FROM creditopy.log_transacc_cr@olpy ll
WHERE ll.numero_auditoria = l.numero_auditoria),
0);
vdatos_hist := 'N';
EXCEPTION
WHEN no_data_found THEN
vr_log_transacc_cr := NULL;
WHEN OTHERS THEN
raise_application_error(-20000,
'Error al buscar transaccion en log_transacc_cr' ||
SQLERRM);
END;
IF vr_log_transacc_cr.nro_tarjeta IS NULL THEN
BEGIN
SELECT *
INTO vr_log_transacc_cr
FROM creditopy.log_transacc_cr_hist@olpy l
WHERE l.numero_auditoria = vnumero_auditoria
AND l.nro_autorizacion =
nvl((SELECT MIN(ll.nro_autorizacion)
FROM creditopy.log_transacc_cr_hist@olpy ll
WHERE ll.numero_auditoria = l.numero_auditoria
AND ll.fecha BETWEEN (l.fecha - 2) AND l.fecha),
0);
vdatos_hist := 'S';
EXCEPTION
WHEN no_data_found THEN
vr_log_transacc_cr := NULL;
WHEN OTHERS THEN
raise_application_error(-20000,
'Error al buscar transaccion en log_transacc_cr_hist' ||
SQLERRM);
END;
END IF;
IF vr_log_transacc_cr.nro_tarjeta IS NULL THEN
vexception_mensaje := 'No se encuentra datos en log_transacc_cr';
RAISE vexception;
--raise_application_error(-20000,'No se encuentra datos en log_transacc_cr'||sqlerrm);
END IF;
--Registramos los datos para la solicitud de impresion del plastico
VR_SOLICITUD.ID_SOLICITUD := vid_solicitud;
VR_SOLICITUD.ID_ESTADO := vid_estado;
--VR_SOLICITUD.NOVEDAD := VR_IMP_TARJETA.FORMULARIO;
VR_SOLICITUD.TARJETA := vr_log_transacc_cr.nro_tarjeta;
VR_SOLICITUD.USUARIO := 'CABAL';
VR_SOLICITUD.DOCUMENTO := TRIM(LEADING '0' FROM SUBSTR(vr_log_transacc_cr.nro_documento,
4,
12));
VR_DATOS.nro_tarjeta := vr_log_transacc_cr.nro_tarjeta;
VR_DATOS.nro_autorizacion := vr_log_transacc_cr.nro_autorizacion;
VR_DATOS.fecha := vr_log_transacc_cr.fecha;
VR_DATOS.hora := vr_log_transacc_cr.hora;
VR_DATOS.importe := vr_log_transacc_cr.importe;
VR_DATOS.plan := vr_log_transacc_cr.plan;
VR_DATOS.cuotas := vr_log_transacc_cr.cuotas;
VR_DATOS.codigo_operacion := vr_log_transacc_cr.codigo_operacion;
VR_DATOS.Documento := vr_log_transacc_cr.nro_documento;
VR_DATOS.nro_cuenta := vr_log_transacc_cr.nro_cuenta;
VR_DATOS.tipo_autorizacion := vr_log_transacc_cr.tipo_autorizacion;
VR_DATOS.baja := vr_log_transacc_cr.baja;
VR_DATOS.marca_transf := vr_log_transacc_cr.marca_transf;
VR_DATOS.nro_res := vr_log_transacc_cr.nro_res;
VR_DATOS.nro_res_interno := vr_log_transacc_cr.nro_res_interno;
VR_DATOS.res_interno := vr_log_transacc_cr.res_interno;
VR_DATOS.autextfch := vr_log_transacc_cr.autextfch;
VR_DATOS.autextproc := vr_log_transacc_cr.autextproc;
VR_DATOS.movextproc := vr_log_transacc_cr.movextproc;
VR_DATOS.tx_interna := vr_log_transacc_cr.tx_interna;
VR_DATOS.numero_auditoria := vr_log_transacc_cr.numero_auditoria;
VR_DATOS.is_log_transacc_cr_hist := vdatos_hist;
VR_DATOS.idsesion_uuid := vuuid;
VR_DATOS.motivo_inicial := pi_motivo_inicial;
PR_SOLICITUDES(VR_SOLICITUD, VR_DATOS);
COMMIT;
IF VR_SOLICITUD.CODIGO_RESPUESTA = 0 THEN
po_sqlcode := VR_SOLICITUD.CODIGO_RESPUESTA;
po_sqlerrm := SQLERRM;
ELSE
po_sqlcode := -1;
po_sqlerrm := SQLERRM;
END IF;
OPEN po_cursor FOR
SELECT po_sqlcode, po_sqlerrm FROM dual;
EXCEPTION
WHEN vexception THEN
po_sqlcode := -1;
po_sqlerrm := vexception_mensaje;
OPEN po_cursor FOR
SELECT po_sqlcode, po_sqlerrm FROM dual;
WHEN OTHERS THEN
po_sqlcode := SQLCODE;
po_sqlerrm := SQLERRM;
OPEN po_cursor FOR
SELECT po_sqlcode, po_sqlerrm FROM dual;
END;
/*
*Author : HGONZALEZ
*Created : 20/11/2020 22:50:00 p.m.
*Purpose : Consulta de factura para su correspondiente descarga.
*/
PROCEDURE sp_ConsultaFacturaDimo(PI_NUMERO_CUENTA IN NUMBER, -- Numero de cuenta
PI_PERIODO IN NUMBER, -- Periodo inicial
PI_PERIODO_ACTUAL IN NUMBER, -- Periodo actual
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) AS
/****************************************************************************************************
PARAMETROS DE ENTRADA:
pi_numero_cuenta: un numero de cuenta para obtener los extractos
pi_periodo: periodo yyyymm de 12 meses atras del emisor de la cuenta
pi_periodo_actual: periodo yyyymm vigente del emisor de la cuenta
******************************************************************************************************/
BEGIN
IF PI_NUMERO_CUENTA IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: cuenta is null.');
END IF;
IF PI_PERIODO IS NULL OR PI_PERIODO_ACTUAL IS NULL THEN
raise_application_error(-20001, 'USERS_ERROR: periodo is null.');
END IF;
OPEN po_cursor FOR
SELECT SUBSTR(A.PERIODO, 1, 4) ANIO,
A.EMISOR,
A.FECHA_REGISTRO FECHA_EMISION,
1 FLAG_FACTURA,
SUBSTR(A.PERIODO, -2) MES,
805 PROCESADOR,
A.TOTAL_CARGOS MONTO_FACTURA,
A.TOTAL_IVA_10 + A.TOTAL_IVA_5 IVA
--mantis#3668 Mejoras en el Frontend de DIMO para Facturacion Electronica
--,A.FACTURA
,
A.FACTURA_LEYENDA FACTURA,
A.DOCUMENTO,
A.NOMBRE_RAZON_SOCIAL
FROM camello.FACTURAS_USUARIOS A
WHERE A.NUMERO_CUENTA = PI_NUMERO_CUENTA
AND A.PERIODO BETWEEN PI_PERIODO AND PI_PERIODO_ACTUAL;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
PR_LOGGING('DIMO',
'facturasDIMO',
'PKG_DIMO_CEIBO.sp_ConsultaFacturaDimo. Parametros.' ||
' PI_NUMERO_CUENTA:' || PI_NUMERO_CUENTA ||
' PI_PERIODO: ' || PI_PERIODO || ' PI_PERIODO_ACTUAL: ' ||
PI_PERIODO_ACTUAL || SQLERRM);
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
END sp_ConsultaFacturaDimo;
-- ====================================================================== --
-- Autor: Lic. Orlando Ojeda
-- Fecha: 29/04/2021
-- Proposito: Obtener las preguntas de Seguridad para el
-- proceso de vinculacion de las tarjetas de Credito
-- ====================================================================== --
PROCEDURE sp_obtener_pregutas_vinc_tc(pi_documento IN VARCHAR2,
pi_tarjeta_cripto IN VARCHAR2,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_id_vinc_proceso OUT NUMBER,
po_cur_preguntas OUT SYS_REFCURSOR,
po_cur_respuestas OUT SYS_REFCURSOR) IS
v_aux NUMBER := 0;
v_id_proceso NUMBER := 0;
v_cont_preg_opciones NUMBER := 0;
v_resp_correcta VARCHAR2(3000);
v_resp_random VARCHAR2(3000);
FUNCTION fi_get_id_respuesta_random(pi_id_vinc_proceso IN NUMBER,
pi_id_pregunta IN NUMBER)
RETURN NUMBER AS
v_id_resp_retorno NUMBER := 0;
v_cont NUMBER := 0;
BEGIN
LOOP
v_id_resp_retorno := round(dbms_random.value * 100);
SELECT COUNT(1)
INTO v_cont
FROM creditopy.dimo_tc_vinc_proceso_preguntas dvp
WHERE dvp.id_vinc_proceso = pi_id_vinc_proceso
AND dvp.id_pregunta = pi_id_pregunta
AND dvp.id_respuesta = v_id_resp_retorno;
EXIT WHEN V_CONT = 0;
END LOOP;
RETURN v_id_resp_retorno;
END;
BEGIN
-- ================================================ --
-- Preproceso. Validaciones
-- ================================================ --
-- * Buscamos si la tarjeta existe
SELECT COUNT(1)
INTO v_aux
FROM creditopy.tarjetas t
WHERE t.tarjeta = pi_tarjeta_cripto
AND substr(t.documento, 4, 12) = lpad(pi_documento, 12, '0');
IF v_aux = 0 THEN
raise_application_error(-20001, 'La tarjeta seleccionada no existe');
END IF;
-- * Buscamos si la tarjeta ya no se encuentra vinculada a DIMO
SELECT COUNT(1)
INTO v_aux
FROM creditopy.dimo_tc_vinculadas dtc
WHERE dtc.tarjeta = pi_tarjeta_cripto
AND dtc.estado = 1 -- Vinculado...
;
IF v_aux > 0 THEN
raise_application_error(-20001,
'La tarjeta seleccionada ya se encuentra vinculada a DIMO');
END IF;
-- * Buscamos si no existe un proceso de vinculacion previo
SELECT COUNT(1)
INTO v_id_proceso
FROM creditopy.DIMO_TC_VINC_PROCESO vp
WHERE vp.documento = pi_documento
AND vp.tarjeta = pi_tarjeta_cripto
AND vp.estado = 0;
-- Si no hay ningun proceso previo de vinculacion...
IF v_id_proceso = 0 THEN
BEGIN
-- Dar de alta Nuevo Proceso de Vinculacion
-- ================================================= --
-- Registramos el inicio del proceso de vinculacion
-- ================================================= --
SELECT creditopy.seq_dimo_tc_vinc_proc.nextval
INTO v_id_proceso
FROM dual;
INSERT INTO creditopy.DIMO_TC_VINC_PROCESO
(id_vinc_proceso, documento, tarjeta, estado, fecha_hora_ins)
VALUES
(v_id_proceso,
pi_documento,
pi_tarjeta_cripto,
0, -- 0 Estado Inicial
SYSDATE);
-- ======================================================== --
-- Generamos el detalle de opciones de respuestas posibles...
-- ======================================================== --
FOR pp IN (SELECT ps.id_pregunta,
ps.opciones_s_n,
nvl(ps.opciones_cant, 0) opciones_cant
FROM creditopy.dimo_tc_preguntas_seguridad ps
WHERE ps.estado = 1
AND PS.DESTINO_CONSULTA = 'VTC' --DESTINO
ORDER BY ps.orden, ps.id_pregunta) LOOP
v_resp_correcta := f_get_resp_pregunta_vinc_tc(pp.id_pregunta,
pi_tarjeta_cripto);
IF (v_resp_correcta IS NULL) THEN
raise_application_error(-20001,
'No se pudo obtener la respuesta verdadera de una de las preguntas. IdPregunta: ' ||
pp.id_pregunta);
END IF;
v_aux := fi_get_id_respuesta_random(v_id_proceso, pp.id_pregunta);
-- Insertamos la respuesta verdadera
INSERT INTO creditopy.dimo_tc_vinc_proceso_preguntas
(id_vinc_proceso, id_pregunta, id_respuesta, valor_respuesta)
VALUES
(v_id_proceso,
pp.id_pregunta,
v_aux,
CASE WHEN pp.opciones_s_n = 'S' THEN v_resp_correcta ELSE NULL END);
-- Si se deben tener multiples opciones de respuesta...
IF pp.opciones_s_n = 'S' THEN
-- Insertamos las respuestas random
FOR idx_pregunta IN 1 .. pp.opciones_cant -- Desde 1 hasta la cantidad configurada por cada pregunta...
LOOP
v_cont_preg_opciones := 0;
v_aux := 0;
-- Obtenemos las respuestas posibles siempre que sean diferentes a la respuesta original
LOOP
v_cont_preg_opciones := nvl(v_cont_preg_opciones, 0) + 1;
v_resp_random := f_valor_random_pregun_vinc_tc(pp.id_pregunta);
-- Verificamos si ya no existe una opcion con el mismo valor
SELECT COUNT(1)
INTO v_aux
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtp
WHERE dtp.id_vinc_proceso = v_id_proceso
AND dtp.id_pregunta = pp.id_pregunta
AND dtp.valor_respuesta = v_resp_random;
-- Control para evitar loop infinito...
IF v_cont_preg_opciones > 100 THEN
v_resp_random := NULL;
END IF;
EXIT WHEN v_aux = 0 OR v_resp_random IS NULL;
END LOOP;
-- Solo insertamos si se pudo obtener un valor random valido
IF (v_resp_random IS NULL) THEN
raise_application_error(-20001,
'No se pudieron obtener las opciones de resp. de una de las preguntas. IdPregunta: ' ||
pp.id_pregunta ||
' . ContadorIntentos: ' ||
v_cont_preg_opciones);
END IF;
v_aux := fi_get_id_respuesta_random(v_id_proceso,
pp.id_pregunta);
--
INSERT INTO creditopy.dimo_tc_vinc_proceso_preguntas
(id_vinc_proceso,
id_pregunta,
id_respuesta,
valor_respuesta)
VALUES
(v_id_proceso, pp.id_pregunta, v_aux, v_resp_random);
END LOOP;
END IF;
END LOOP;
END; -- Fin dar de alta nuevo Proceso de Vinculacion
ELSE
-- * Obtenemos el Id Proceso vigente
SELECT MAX(vp.id_vinc_proceso)
INTO v_id_proceso
FROM creditopy.DIMO_TC_VINC_PROCESO vp
WHERE vp.documento = pi_documento
AND vp.tarjeta = pi_tarjeta_cripto
AND vp.estado = 0;
-- * Actualizamos la cantidad de intentos del proceso de vinculacion...
UPDATE creditopy.DIMO_TC_VINC_PROCESO vp
SET vp.cant_solicitudes = nvl(vp.cant_solicitudes, 0) + 1
WHERE vp.id_vinc_proceso = v_id_proceso;
-- * Damos de baja los otros pendientes (si es que existen)
UPDATE creditopy.DIMO_TC_VINC_PROCESO vp
SET vp.estado = 3 -- Baja
WHERE vp.documento = pi_documento
AND vp.tarjeta = pi_tarjeta_cripto
AND vp.estado = 0
AND vp.id_vinc_proceso != v_id_proceso;
END IF;
po_id_vinc_proceso := v_id_proceso;
-- Retornamos las preguntas y las opciones
OPEN po_cur_preguntas FOR
SELECT ps.id_pregunta, ps.label, ps.hint, ps.opciones_s_n
FROM creditopy.dimo_tc_preguntas_seguridad ps
JOIN (SELECT dtcp.id_pregunta, COUNT(1) cantidad
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtcp
WHERE dtcp.id_vinc_proceso = v_id_proceso
GROUP BY dtcp.id_pregunta) resp
ON resp.id_pregunta = ps.id_pregunta
WHERE ps.estado = 1
AND PS.DESTINO_CONSULTA = 'VTC' --DESTINO
ORDER BY ps.orden, ps.id_pregunta;
OPEN po_cur_respuestas FOR
SELECT dtcp.id_pregunta, dtcp.id_respuesta, dtcp.valor_respuesta
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtcp
JOIN creditopy.dimo_tc_preguntas_seguridad ps
ON ps.id_pregunta = dtcp.id_pregunta
AND ps.opciones_s_n = 'S'
AND PS.DESTINO_CONSULTA = 'VTC' --DESTINO
WHERE dtcp.id_vinc_proceso = v_id_proceso
ORDER BY dtcp.id_pregunta, dbms_random.value;
COMMIT;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
po_id_vinc_proceso := -1;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
BEGIN
creditopy.pkg_dimo_ceibo.pr_ceibo_log('DIMO',
'PREGUN_VINC_TC',
TO_CHAR(SQLERRM),
SYSDATE,
'DIMO');
EXCEPTION
WHEN OTHERS THEN
NULL;
END;
END;
---
---
-- ====================================================================== --
-- Autor: Feliciano Amarilla
-- Fecha: 02/08/2023
-- Proposito: Obtener las preguntas de Seguridad para el
-- catastro de Dimo de tu eres tu
-- ====================================================================== --
-- ====================================================================== --
-- Autor: Feliciano Amarilla
-- Fecha: 02/08/2023
-- Proposito: Obtener las preguntas de Seguridad para el
-- catastro de Dimo de tu eres tu
-- ====================================================================== --
PROCEDURE sp_obtener_pregutas_tu_tu(pi_documento IN VARCHAR2,
-- pi_tarjeta_cripto in varchar2,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_id_vinc_proceso OUT NUMBER,
po_cur_preguntas OUT SYS_REFCURSOR,
po_cur_respuestas OUT SYS_REFCURSOR) IS
v_aux NUMBER := 0;
v_id_proceso NUMBER := 0;
v_cont_preg_opciones NUMBER := 0;
v_resp_correcta VARCHAR2(3000);
v_resp_random VARCHAR2(3000);
FUNCTION fi_get_id_respuesta_random(pi_id_vinc_proceso IN NUMBER,
pi_id_pregunta IN NUMBER)
RETURN NUMBER AS
v_id_resp_retorno NUMBER := 0;
v_cont NUMBER := 0;
BEGIN
LOOP
v_id_resp_retorno := round(dbms_random.value * 100);
SELECT COUNT(1)
INTO v_cont
FROM creditopy.dimo_tc_vinc_proceso_preguntas dvp
WHERE dvp.id_vinc_proceso = pi_id_vinc_proceso
AND dvp.id_pregunta = pi_id_pregunta
AND dvp.id_respuesta = v_id_resp_retorno;
EXIT WHEN V_CONT = 0;
END LOOP;
RETURN v_id_resp_retorno;
END;
BEGIN
-- ================================================ --
-- Preproceso. Validaciones
-- ================================================ --
-- Verificamos la cantidad de intentos que hizo la persona para responder las preguntas
SELECT COUNT(1)
INTO v_aux
FROM creditopy.DIMO_TC_VINC_PROCESO vp
WHERE vp.documento = pi_documento
AND tarjeta IS NULL
and vp.origen='TUTU'; -- Proceso tu eres tu
IF nvl(v_aux, 0) > 2 THEN
raise_application_error(-20001,
'Ya no quedan intentos para responder las preguntas');
END IF;
v_aux:=0;
-- * Buscamos si la persona posee alguna tc activa operativa
SELECT count(*) cant_tc
into v_aux
FROM CREDITOPY.CUENTAS CUENTAS,
DEBCREDPY.PERSONAS PERSONAS2,
DEBCREDPY.Emisores e,
CREDITOPY.TARJETAS t,
CREDITOPY.clases_estados cl,
CREDITOPY.Estados_Ctas_Tarj et
WHERE PERSONAS2.DOCUMENTO = CUENTAS.DOCUMENTO
AND PERSONAS2.TIPO_DE_DOCUMENTO IN (1, 2, 3, 4, 5, 6, 7, 8, 9)
AND CUENTAS.SUCURSAL_EMISOR < 9999
AND CUENTAS.PRODUCTO = 1
AND CUENTAS.EMISOR <> 115
AND TRIM(SUBSTR(PERSONAS2.documento, 4)) =
TRIM(to_char(pi_documento , '000000000000'))
AND e.emisor = cuentas.emisor
AND t.numero_cuenta = cuentas.numero_cuenta
and et.estado=t.estado
and et.clase_de_estado=cl.clase_de_estado
and t.estado=1
and t.clase_de_estado=1;
IF nvl(v_aux,0) = 0 THEN
raise_application_error(-20020, 'No existe ninguna TC asociada al nro de documento');
END IF;
-- * Buscamos si la tarjeta ya no se encuentra vinculada a DIMO
/* select count(1) into v_aux
from creditopy.dimo_tc_vinculadas dtc
where dtc.tarjeta = pi_tarjeta_cripto
and dtc.estado = 1 -- Vinculado...
;*/
v_aux := 0;
/*if v_aux > 0 then
raise_application_error(-20001,'La tarjeta seleccionada ya se encuentra vinculada a DIMO');
end if;*/
-- * Buscamos si no existe un proceso de vinculacion previo
SELECT COUNT(1)
INTO v_id_proceso
FROM creditopy.DIMO_TC_VINC_PROCESO vp
WHERE vp.documento = pi_documento
-- and vp.tarjeta = pi_tarjeta_cripto
AND vp.estado = 0
and vp.origen='TUTU'; -- Proceso tu eres tu
-- v_id_proceso:=0;
-- Si no hay ningun proceso previo de vinculacion...
IF v_id_proceso = 0 THEN
BEGIN
-- Dar de alta Nuevo Proceso de Vinculacion
-- ================================================= --
-- Registramos el inicio del proceso de vinculacion
-- ================================================= --
SELECT creditopy.seq_dimo_tc_vinc_proc.nextval
INTO v_id_proceso
FROM dual;
INSERT INTO creditopy.DIMO_TC_VINC_PROCESO
(id_vinc_proceso,
documento,
-- tarjeta,
estado,
fecha_hora_ins,
ORIGEN)
VALUES
(v_id_proceso,
pi_documento,
--pi_tarjeta_cripto,
0, -- 0 Estado Inicial
SYSDATE,
'TUTU');
-- ======================================================== --
-- Generamos el detalle de opciones de respuestas posibles...
-- ======================================================== --
FOR pp IN (SELECT ps.id_pregunta,
ps.opciones_s_n,
nvl(ps.opciones_cant, 0) opciones_cant
FROM creditopy.dimo_tc_preguntas_seguridad ps
WHERE ps.estado = 1
AND PS.DESTINO_CONSULTA = 'TUTU' --DESTINO
ORDER BY ps.orden, ps.id_pregunta) LOOP
v_resp_correcta := f_get_resp_pregunta_tutu(pp.id_pregunta,
pi_documento);
IF (v_resp_correcta IS NULL) THEN
raise_application_error(-20001,
'No se pudo obtener la respuesta verdadera de una de las preguntas. IdPregunta: ' ||
pp.id_pregunta);
END IF;
v_aux := fi_get_id_respuesta_random(v_id_proceso, pp.id_pregunta);
-- Insertamos la respuesta verdadera
INSERT INTO creditopy.dimo_tc_vinc_proceso_preguntas
(id_vinc_proceso, id_pregunta, id_respuesta, valor_respuesta)
VALUES
(v_id_proceso,
pp.id_pregunta,
v_aux,
CASE WHEN pp.opciones_s_n = 'S' THEN v_resp_correcta ELSE NULL END);
-- Si se deben tener multiples opciones de respuesta...
IF pp.opciones_s_n = 'S' THEN
-- Insertamos las respuestas random
FOR idx_pregunta IN 1 .. pp.opciones_cant -- Desde 1 hasta la cantidad configurada por cada pregunta...
LOOP
v_cont_preg_opciones := 0;
v_aux := 0;
-- Obtenemos las respuestas posibles siempre que sean diferentes a la respuesta original
LOOP
v_cont_preg_opciones := nvl(v_cont_preg_opciones, 0) + 1;
v_resp_random := f_valor_random_pregun_tutu(pp.id_pregunta,
pi_documento);
-- Verificamos si ya no existe una opcion con el mismo valor
SELECT COUNT(1)
INTO v_aux
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtp
WHERE dtp.id_vinc_proceso = v_id_proceso
AND dtp.id_pregunta = pp.id_pregunta
AND dtp.valor_respuesta = v_resp_random;
-- Control para evitar loop infinito...
IF v_cont_preg_opciones > 100 THEN
v_resp_random := NULL;
END IF;
EXIT WHEN v_aux = 0 OR v_resp_random IS NULL;
END LOOP;
-- Solo insertamos si se pudo obtener un valor random valido
IF (v_resp_random IS NULL) THEN
raise_application_error(-20001,
'No se pudieron obtener las opciones de resp. de una de las preguntas. IdPregunta: ' ||
pp.id_pregunta ||
' . ContadorIntentos: ' ||
v_cont_preg_opciones);
END IF;
v_aux := fi_get_id_respuesta_random(v_id_proceso,
pp.id_pregunta);
--
INSERT INTO creditopy.dimo_tc_vinc_proceso_preguntas
(id_vinc_proceso,
id_pregunta,
id_respuesta,
valor_respuesta)
VALUES
(v_id_proceso, pp.id_pregunta, v_aux, v_resp_random);
END LOOP;
END IF;
END LOOP;
END; -- Fin dar de alta nuevo Proceso de Vinculacion
ELSE
-- * Obtenemos el Id Proceso vigente
SELECT MAX(vp.id_vinc_proceso)
INTO v_id_proceso
FROM creditopy.DIMO_TC_VINC_PROCESO vp
WHERE vp.documento = pi_documento
--and vp.tarjeta = pi_tarjeta_cripto
AND vp.estado = 0
AND VP.ORIGEN='TUTU';
-- v_id_proceso:=1;
-- * Actualizamos la cantidad de intentos del proceso de vinculacion...
UPDATE creditopy.DIMO_TC_VINC_PROCESO vp
SET vp.cant_solicitudes = nvl(vp.cant_solicitudes, 0) + 1
WHERE vp.id_vinc_proceso = v_id_proceso
AND VP.ORIGEN='TUTU';
-- * Damos de baja los otros pendientes (si es que existen)
UPDATE creditopy.DIMO_TC_VINC_PROCESO vp
SET vp.estado = 3 -- Baja
WHERE vp.documento = pi_documento
-- and vp.tarjeta = pi_tarjeta_cripto
AND vp.estado = 0
AND vp.id_vinc_proceso != v_id_proceso
AND VP.ORIGEN='TUTU';
END IF;
po_id_vinc_proceso := v_id_proceso;
-- Retornamos las preguntas y las opciones
OPEN po_cur_preguntas FOR
SELECT ps.id_pregunta, ps.label, ps.hint, ps.opciones_s_n
FROM creditopy.dimo_tc_preguntas_seguridad ps
JOIN (SELECT dtcp.id_pregunta, COUNT(1) cantidad
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtcp
WHERE dtcp.id_vinc_proceso = v_id_proceso
GROUP BY dtcp.id_pregunta) resp
ON resp.id_pregunta = ps.id_pregunta
WHERE ps.estado = 1
AND PS.DESTINO_CONSULTA = 'TUTU' --DESTINO
ORDER BY ps.orden, ps.id_pregunta;
OPEN po_cur_respuestas FOR
SELECT dtcp.id_pregunta, dtcp.id_respuesta, dtcp.valor_respuesta
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtcp
JOIN creditopy.dimo_tc_preguntas_seguridad ps
ON ps.id_pregunta = dtcp.id_pregunta
AND ps.opciones_s_n = 'S'
AND PS.DESTINO_CONSULTA = 'TUTU' --DESTINO
WHERE dtcp.id_vinc_proceso = v_id_proceso
ORDER BY dtcp.id_pregunta, dbms_random.value;
COMMIT;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
if SQLCODE =(-20020) then
po_id_vinc_proceso := -99;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
BEGIN
--'PREGUN_VINC_TC'
creditopy.pkg_dimo_ceibo.pr_ceibo_log('DIMO',
'PREGUN_TUTU',
TO_CHAR(SQLERRM),
SYSDATE,
'DIMO');
EXCEPTION
WHEN OTHERS THEN
NULL;
END;
else
po_id_vinc_proceso := -1;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
BEGIN
--'PREGUN_VINC_TC'
creditopy.pkg_dimo_ceibo.pr_ceibo_log('DIMO',
'PREGUN_TUTU',
TO_CHAR(SQLERRM),
SYSDATE,
'DIMO');
EXCEPTION
WHEN OTHERS THEN
NULL;
END;
end if;
END sp_obtener_pregutas_tu_tu;
---
--
-- ============================================================================== --
-- Autor: Lic. Orlando Ojeda
-- Fecha: 29/04/2021
-- Proposito: Registrar las respuestas a las preguntas de Seguridad y
-- vincular la tarjeta a DIMO en caso exitoso.
--
-- Observaciones:
-- Las respuestas enviadas en el prm "pi_clob_respuetas" deben venir con en el sgte. formato
-- [ID_PREGUNTA1]:[ID_RESPUESTA1/VALOR_RESPUESTA1][;][ID_PREGUNTA2]:[ID_RESPUESTA2/VALOR_RESPUESTA2][;] [... n]
-- Donde: [;] Es el separador entre cada pregunta/respuesta
-- Ejemplo: [1]:[123123123][;][2]:[12123123][;][3]:[312312312]
-- ============================================================================== --
PROCEDURE sp_procesar_respuestas_vinc_tc(pi_id_vinc_proceso IN NUMBER,
pi_clob_respuestas IN CLOB, -- String concatenado con todas las respuestas
po_retorno OUT NUMBER, -- 0 = OK / != 0 NO OK
po_retorno_msg OUT VARCHAR2,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2) AS
v_contador_resp_total NUMBER := 0;
v_contador_resp_ok NUMBER := 0;
v_clob_resultado CLOB := '';
v_dimo_vinc_proces_row creditopy.dimo_tc_vinc_proceso%ROWTYPE;
v_dimo_pregunta_segu_row creditopy.dimo_tc_preguntas_seguridad%ROWTYPE;
v_id_seq_vinc NUMBER := 0;
v_resp_correcta VARCHAR2(3000);
v_resp_enviada VARCHAR2(3000);
VR_EVENTO fide_eventos_ceibo%ROWTYPE;
FUNCTION GET_ID_EVENTO RETURN VARCHAR2 AS
BEGIN
RETURN 'FECHA_PROCESO:' || TO_CHAR(VR_EVENTO.FECHA_PROCESO,
'DD/MM/YYYY') || ' ' || 'CODIGO_EVENTO:' || VR_EVENTO.CODIGO_EVENTO || ' ' || 'ID_VINC_PROCESO:' || V_DIMO_VINC_PROCES_ROW.ID_VINC_PROCESO || ' ' || 'TARJETA:' || V_DIMO_VINC_PROCES_ROW.TARJETA || ' ' || 'DOCUMENTO:' || VR_EVENTO.DOCUMENTO || ' ' || 'CODIGO_RETORNO:' || VR_EVENTO.CODIGO_RETORNO || ' ' || 'TEXT_RETORNO:' || VR_EVENTO.TEXT_RETORNO || ' ' || 'PEDIDO_INICIO_TS:' || TO_CHAR(VR_EVENTO.PEDIDO_INICIO_TS) || ' ' || 'PEDIDO_FIN_TS:' || TO_CHAR(VR_EVENTO.TEXT_RETORNO);
END;
PROCEDURE PL_SERVICIO_GUARDAR(CP_TABLA_ORIGEN IN VARCHAR2,
NP_ID_ORIGEN IN NUMBER,
CP_UUID IN VARCHAR2 DEFAULT NULL) AS
BEGIN
VR_EVENTO.PEDIDO_INICIO_TS := SYSTIMESTAMP;
VR_EVENTO.Documento := v_dimo_vinc_proces_row.documento;
vr_evento.importe := 0;
vr_evento.codigo_evento := 'VINCULAR_TC';
OPERAC_SICOOP.PKG_OD.PR_GUARDAR_EVENTOS_CEIBO@SICOOP(DP_FECHA_PROCESO => VR_EVENTO.FECHA_PROCESO,
CP_DOCUMENTO => VR_EVENTO.DOCUMENTO,
CP_TABLA_ORIGEN => CP_TABLA_ORIGEN,
NP_MONTO_OPERACION => VR_EVENTO.IMPORTE,
NP_ID_ORIGEN => NP_ID_ORIGEN,
CP_UUID => CP_UUID,
CP_CODIGO_EVENTO => VR_EVENTO.CODIGO_EVENTO,
CP_CODIGO_RETORNO => VR_EVENTO.CODIGO_RETORNO,
CP_TEXT_RETORNO => VR_EVENTO.TEXT_RETORNO);
VR_EVENTO.PEDIDO_FIN_TS := SYSTIMESTAMP;
PR_CEIBO_LOG('PKG_DIMO_CEIBO',
'PL_SERVICIO_GUARDAR',
'Evento informado. EventoId:' || GET_ID_EVENTO,
SYSDATE,
'DIMO');
EXCEPTION
WHEN OTHERS THEN
PR_CEIBO_LOG('PKG_DIMO_CEIBO',
'PL_SERVICIO_GUARDAR',
'Error al Informar el evento. EventoId:' ||
GET_ID_EVENTO || ' ' || SQLERRM,
SYSDATE,
'DIMO');
END;
BEGIN
-- ============================================== --
-- Obtenemos los datos del Proceso de Vinculacion
-- ============================================== --
BEGIN
SELECT dvp.*
INTO v_dimo_vinc_proces_row
FROM creditopy.dimo_tc_vinc_proceso dvp
WHERE dvp.id_vinc_proceso = pi_id_vinc_proceso;
-- * Validamos el estado de la vinculacion, debe estar en 0 = Iniciado
IF v_dimo_vinc_proces_row.estado != 0 THEN
raise_application_error(-20001,
'El estado del proceso de vinculacion de TC ha sido ' || CASE WHEN
v_dimo_vinc_proces_row.estado = 1 THEN
'Finalizado previamente' WHEN
v_dimo_vinc_proces_row.estado = 2 THEN
'Rechazado previamente' WHEN
v_dimo_vinc_proces_row.estado = 3 THEN
'Dado de Baja' ELSE 'no reconocido' END);
END IF;
-- * Validamos si la tarjeta ya no este vinculada
SELECT COUNT(1)
INTO v_id_seq_vinc
FROM creditopy.dimo_tc_vinculadas dtc
WHERE dtc.tarjeta = v_dimo_vinc_proces_row.tarjeta
AND dtc.estado = 1 -- Vinculado...
;
IF v_id_seq_vinc > 0 THEN
raise_application_error(-20001,
'La tarjeta ya se encuentra vinculada a DIMO');
END IF;
-- Obtenemos la cantidad de respuestas que deben ser respondidas...
SELECT COUNT(1)
INTO v_contador_resp_total
FROM (SELECT dtcp.id_pregunta
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtcp
WHERE dtcp.id_vinc_proceso = pi_id_vinc_proceso
GROUP BY dtcp.id_vinc_proceso, dtcp.id_pregunta);
EXCEPTION
WHEN NO_DATA_FOUND THEN
raise_application_error(-20001,
' No existe el Id ProcesoVinculacion ' ||
pi_id_vinc_proceso);
WHEN OTHERS THEN
RAISE;
END;
-- ==================================== --
-- Procesamos las respuestas envidas
-- ==================================== --
v_contador_resp_ok := 0;
-- Obtenemos en un select la Lista de Preguntas/Respuestas
FOR respuestas IN (SELECT TRIM(substr(resp.pregunta,
2,
length(resp.pregunta) - 2)) id_pregunta,
TRIM(substr(resp.respuesta,
2,
length(resp.respuesta) - 2)) respuesta
FROM (SELECT creditopy.f_split_valor(TRIM(registro),
':',
1) pregunta,
creditopy.f_split_valor(TRIM(registro),
':',
2) respuesta
FROM (SELECT column_value AS registro
FROM TABLE(creditopy.f_split_clob(pi_clob_respuestas,
'[;]')))
WHERE registro IS NOT NULL) resp) LOOP
v_resp_correcta := '';
v_resp_enviada := '';
-- * Obtenemos la config de la pregunta y su valor valido para la comparacion..
BEGIN
SELECT ps.*
INTO v_dimo_pregunta_segu_row
FROM creditopy.dimo_tc_preguntas_seguridad ps
WHERE to_char(ps.id_pregunta) = respuestas.id_pregunta
AND PS.DESTINO_CONSULTA = 'VTC' --DESTINO
;
EXCEPTION
WHEN OTHERS THEN
raise_application_error(-20001,
' No existe el Id Pregunta ' ||
respuestas.id_pregunta);
END;
-- * Obtenemos el VALOR VALIDO de la Respuesta
v_resp_correcta := f_get_resp_pregunta_vinc_tc(respuestas.id_pregunta,
v_dimo_vinc_proces_row.tarjeta);
-- * Obtenemos el VALOR ENVIADO para Responder pregunta de seguridad
-- Si el Pregunta esta configurada como CON opciones multiples
IF v_dimo_pregunta_segu_row.opciones_s_n = 'S' THEN
-- Se envia el ID de Respuesta..
SELECT MAX(dtcp.valor_respuesta)
INTO v_resp_enviada
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtcp
WHERE dtcp.id_vinc_proceso = pi_id_vinc_proceso
AND dtcp.id_pregunta = respuestas.id_pregunta
AND TO_CHAR(dtcp.id_respuesta) = TO_CHAR(respuestas.respuesta);
ELSE
-- Se envia el VALOR en si
v_resp_enviada := respuestas.respuesta;
END IF;
/* -- Se comenta condicion por que se encontro que el PL no toma bien los RAISE dentro de un Loop --
if v_resp_correcta is null then
po_retorno_msg := 'No se pudo obtener la respuesta correcta p/ comparacion, de una de las preguntas. IdPregunta: '|| respuestas.id_pregunta;
raise_application_error(-20001,
'No se pudo obtener la respuesta correcta p/ comparacion, de una de las preguntas. IdPregunta: '|| respuestas.id_pregunta
);
end if;
*/
-- * Si llegamos hasta aqui, comparamos las respuestas...
IF v_resp_correcta = v_resp_enviada THEN
v_contador_resp_ok := v_contador_resp_ok + 1;
END IF;
v_clob_resultado := v_clob_resultado || 'IdPregunta: ' ||
v_dimo_pregunta_segu_row.id_pregunta || ';' || CHR(9) ||
'Label: ' || v_dimo_pregunta_segu_row.label || ';' ||
CHR(9) || 'Respuesta: ' || v_resp_enviada || ';' ||
CHR(9) || 'Resultado: ' || CASE
WHEN v_resp_correcta = v_resp_enviada THEN
'Correcto'
ELSE
'Incorrecto'
END || CHR(13);
END LOOP; -- fin loop respuestas enviadas
UPDATE creditopy.dimo_tc_vinc_proceso dvp
SET dvp.estado = CASE
WHEN v_contador_resp_total = v_contador_resp_ok THEN
1
ELSE
2
END,
dvp.fecha_hora_resp = SYSDATE,
dvp.respuestas_enviadas = v_clob_resultado
WHERE dvp.id_vinc_proceso = pi_id_vinc_proceso;
IF v_contador_resp_ok = v_contador_resp_total THEN
-- ================================================= --
-- Insertamos la tarjeta como vinculada
-- ================================================= --
SELECT creditopy.seq_dimo_tc_vinc.nextval
INTO v_id_seq_vinc
FROM dual;
INSERT INTO creditopy.DIMO_TC_VINCULADAS
(id_registro,
tarjeta,
fecha_hora_vinculacion,
id_vinc_proceso,
estado,
detalle_preguntas)
VALUES
(v_id_seq_vinc,
v_dimo_vinc_proces_row.tarjeta,
SYSDATE,
v_dimo_vinc_proces_row.id_vinc_proceso,
1,
v_clob_resultado);
-- ================================================================= --
-- PROCEDIMIENTO PARA INSERTAR LA TCO EN D_CUENTA@SICOOP... Arturo Sosa
-- ================================================================= --
BEGIN
PR_INSERT_TCO_CUENTAS_V1(P_DOCUMENTO => v_dimo_vinc_proces_row.documento,
P_TARJETA_ENCR => v_dimo_vinc_proces_row.tarjeta);
END;
po_retorno := 0;
po_retorno_msg := 'OK';
pl_servicio_guardar('DIMO_TC_VINC_PROCESO',
v_dimo_vinc_proces_row.id_vinc_proceso,
NULL);
ELSE
po_retorno := 1;
po_retorno_msg := 'No se han respondido correctamente las preguntas de seguridad';
END IF;
COMMIT;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
po_retorno := -1;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
BEGIN
creditopy.pkg_dimo_ceibo.pr_ceibo_log('DIMO',
'RESP_VINC_TC',
TO_CHAR(SQLERRM),
SYSDATE,
'DIMO');
EXCEPTION
WHEN OTHERS THEN
NULL;
END;
END;
/* PROCEDURE PR_INSERT_TCO_CUENTAS_V1(P_DOCUMENTO IN VARCHAR2,
P_TARJETA_ENCR IN VARCHAR2) IS
BEGIN
DECLARE
PO_DOCUMENTO VARCHAR2(40);
PO_TARJETA_DESEN VARCHAR2(40);
BEGIN
PO_DOCUMENTO := P_DOCUMENTO;
PO_TARJETA_DESEN:= CREDITOPY.FC_CRIPTO2PAN(P_TARJETA_ENCR);
--RECUPERAR EL CLIENTE_ID
SELECT dc.CLIENTE_ID INTO PO_DOCUMENTO
FROM DIMO_SICOOP.D_CLIENTE@SICOOP dc
WHERE dc.CI = P_DOCUMENTO;
--HACER EL INSERT
INSERT INTO DIMO_SICOOP.D_CUENTA@SICOOP
(CUENTA_ID, CLIENTE_ID, PARTICIPANTE_ID, NRO_CUENTA, TIPO_CUENTA, NRO_CONTRATO, MONEDA, ENABLED, LAST_USER, LAST_TIME, CUENTA_MADRE_FLAG, CODIGO_NOVEDAD, FAVORITO)
VALUES(DIMO_SICOOP.S_D_CUENTA.nextval@SICOOP, PO_DOCUMENTO, 1, PO_TARJETA_DESEN, 'TCO', '0', 'GUA', 1, 'administrador', SYSDATE(), 0, NULL, 0);
COMMIT;
EXCEPTION
WHEN OTHERS THEN
PO_DOCUMENTO := 'ALGO REVIENTA';
PO_TARJETA_DESEN := SQLCODE;
END;
END PR_INSERT_TCO_CUENTAS_V1;*/
-----
---
-- ============================================================================== --
-- Autor: Feliciano Amarilla
-- Fecha: 03/08/2023
-- Proposito: Registrar las respuestas a las preguntas de Seguridad del
-- catastro de Dimo, tu eres tu.
--
-- Observaciones:
-- Las respuestas enviadas en el prm "pi_clob_respuetas" deben venir con en el sgte. formato
-- [ID_PREGUNTA1]:[ID_RESPUESTA1/VALOR_RESPUESTA1][;][ID_PREGUNTA2]:[ID_RESPUESTA2/VALOR_RESPUESTA2][;] [... n]
-- Donde: [;] Es el separador entre cada pregunta/respuesta
-- Ejemplo: [1]:[123123123][;][2]:[12123123][;][3]:[312312312]
-- ============================================================================== --
PROCEDURE sp_procesar_respuestas_tu_tu(pi_id_vinc_proceso IN NUMBER,
pi_clob_respuestas IN CLOB, -- String concatenado con todas las respuestas
po_retorno OUT NUMBER, -- 0 = OK / != 0 NO OK
po_retorno_msg OUT VARCHAR2,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2) AS
v_contador_resp_total NUMBER := 0;
v_contador_resp_ok NUMBER := 0;
v_clob_resultado CLOB := '';
v_dimo_vinc_proces_row creditopy.dimo_tc_vinc_proceso%ROWTYPE;
v_dimo_pregunta_segu_row creditopy.dimo_tc_preguntas_seguridad%ROWTYPE;
v_id_seq_vinc NUMBER := 0;
v_resp_correcta VARCHAR2(3000);
v_resp_enviada VARCHAR2(3000);
VR_EVENTO fide_eventos_ceibo%ROWTYPE;
FUNCTION GET_ID_EVENTO RETURN VARCHAR2 AS
BEGIN
RETURN 'FECHA_PROCESO:' || TO_CHAR(VR_EVENTO.FECHA_PROCESO,
'DD/MM/YYYY') || ' ' || 'CODIGO_EVENTO:' || VR_EVENTO.CODIGO_EVENTO || ' ' || 'ID_VINC_PROCESO:' || V_DIMO_VINC_PROCES_ROW.ID_VINC_PROCESO || ' ' || 'TARJETA:' || V_DIMO_VINC_PROCES_ROW.TARJETA || ' ' || 'DOCUMENTO:' || VR_EVENTO.DOCUMENTO || ' ' || 'CODIGO_RETORNO:' || VR_EVENTO.CODIGO_RETORNO || ' ' || 'TEXT_RETORNO:' || VR_EVENTO.TEXT_RETORNO || ' ' || 'PEDIDO_INICIO_TS:' || TO_CHAR(VR_EVENTO.PEDIDO_INICIO_TS) || ' ' || 'PEDIDO_FIN_TS:' || TO_CHAR(VR_EVENTO.TEXT_RETORNO);
END;
PROCEDURE PL_SERVICIO_GUARDAR(CP_TABLA_ORIGEN IN VARCHAR2,
NP_ID_ORIGEN IN NUMBER,
CP_UUID IN VARCHAR2 DEFAULT NULL) AS
BEGIN
VR_EVENTO.PEDIDO_INICIO_TS := SYSTIMESTAMP;
VR_EVENTO.Documento := v_dimo_vinc_proces_row.documento;
vr_evento.importe := 0;
vr_evento.codigo_evento := 'PREGUNTAS_TUTU';
OPERAC_SICOOP.PKG_OD.PR_GUARDAR_EVENTOS_CEIBO@SICOOP(DP_FECHA_PROCESO => VR_EVENTO.FECHA_PROCESO,
CP_DOCUMENTO => VR_EVENTO.DOCUMENTO,
CP_TABLA_ORIGEN => CP_TABLA_ORIGEN,
NP_MONTO_OPERACION => VR_EVENTO.IMPORTE,
NP_ID_ORIGEN => NP_ID_ORIGEN,
CP_UUID => CP_UUID,
CP_CODIGO_EVENTO => VR_EVENTO.CODIGO_EVENTO,
CP_CODIGO_RETORNO => VR_EVENTO.CODIGO_RETORNO,
CP_TEXT_RETORNO => VR_EVENTO.TEXT_RETORNO);
VR_EVENTO.PEDIDO_FIN_TS := SYSTIMESTAMP;
PR_CEIBO_LOG('PKG_DIMO_CEIBO',
'PL_SERVICIO_GUARDAR',
'Evento informado. EventoId:' || GET_ID_EVENTO,
SYSDATE,
'DIMO');
EXCEPTION
WHEN OTHERS THEN
PR_CEIBO_LOG('PKG_DIMO_CEIBO',
'PL_SERVICIO_GUARDAR',
'Error al Informar el evento. EventoId:' ||
GET_ID_EVENTO || ' ' || SQLERRM,
SYSDATE,
'DIMO');
END;
BEGIN
-- ============================================== --
-- Obtenemos los datos del Proceso de Vinculacion
-- ============================================== --
BEGIN
SELECT dvp.*
INTO v_dimo_vinc_proces_row
FROM creditopy.dimo_tc_vinc_proceso dvp
WHERE dvp.id_vinc_proceso = pi_id_vinc_proceso;
-- * Validamos el estado de la vinculacion, debe estar en 0 = Iniciado
IF v_dimo_vinc_proces_row.estado != 0 THEN
raise_application_error(-20001,
'El estado del proceso de vinculacion de TC ha sido ' || CASE WHEN
v_dimo_vinc_proces_row.estado = 1 THEN
'Finalizado previamente' WHEN
v_dimo_vinc_proces_row.estado = 2 THEN
'Rechazado previamente' WHEN
v_dimo_vinc_proces_row.estado = 3 THEN
'Dado de Baja' ELSE 'no reconocido' END);
END IF;
-- * Validamos si la tarjeta ya no este vinculada
SELECT COUNT(1)
INTO v_id_seq_vinc
FROM creditopy.dimo_tc_vinculadas dtc
WHERE dtc.tarjeta = v_dimo_vinc_proces_row.tarjeta
AND dtc.estado = 1 -- Vinculado...
;
IF v_id_seq_vinc > 0 THEN
raise_application_error(-20001,
'La tarjeta ya se encuentra vinculada a DIMO');
END IF;
-- Obtenemos la cantidad de respuestas que deben ser respondidas...
SELECT COUNT(1)
INTO v_contador_resp_total
FROM (SELECT dtcp.id_pregunta
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtcp
WHERE dtcp.id_vinc_proceso = pi_id_vinc_proceso
GROUP BY dtcp.id_vinc_proceso, dtcp.id_pregunta);
EXCEPTION
WHEN NO_DATA_FOUND THEN
raise_application_error(-20001,
' No existe el Id ProcesoVinculacion ' ||
pi_id_vinc_proceso);
WHEN OTHERS THEN
RAISE;
END;
-- ==================================== --
-- Procesamos las respuestas envidas
-- ==================================== --
v_contador_resp_ok := 0;
-- Obtenemos en un select la Lista de Preguntas/Respuestas
FOR respuestas IN (SELECT TRIM(substr(resp.pregunta,
2,
length(resp.pregunta) - 2)) id_pregunta,
TRIM(substr(resp.respuesta,
2,
length(resp.respuesta) - 2)) respuesta
FROM (SELECT creditopy.f_split_valor(TRIM(registro),
':',
1) pregunta,
creditopy.f_split_valor(TRIM(registro),
':',
2) respuesta
FROM (SELECT column_value AS registro
FROM TABLE(creditopy.f_split_clob(pi_clob_respuestas,
'[;]')))
WHERE registro IS NOT NULL) resp) LOOP
v_resp_correcta := '';
v_resp_enviada := '';
-- * Obtenemos la config de la pregunta y su valor valido para la comparacion..
BEGIN
SELECT ps.*
INTO v_dimo_pregunta_segu_row
FROM creditopy.dimo_tc_preguntas_seguridad ps
WHERE to_char(ps.id_pregunta) = respuestas.id_pregunta
AND PS.DESTINO_CONSULTA = 'TUTU' --DESTINO
;
EXCEPTION
WHEN OTHERS THEN
raise_application_error(-20001,
' No existe el Id Pregunta ' ||
respuestas.id_pregunta);
END;
-- * Obtenemos el VALOR VALIDO de la Respuesta
v_resp_correcta := f_get_resp_pregunta_tutu(respuestas.id_pregunta,
v_dimo_vinc_proces_row.documento);
-- * Obtenemos el VALOR ENVIADO para Responder pregunta de seguridad
-- Si el Pregunta esta configurada como CON opciones multiples
IF v_dimo_pregunta_segu_row.opciones_s_n = 'S' THEN
-- Se envia el ID de Respuesta..
SELECT MAX(dtcp.valor_respuesta)
INTO v_resp_enviada
FROM creditopy.dimo_tc_vinc_proceso_preguntas dtcp
WHERE dtcp.id_vinc_proceso = pi_id_vinc_proceso
AND dtcp.id_pregunta = respuestas.id_pregunta
AND TO_CHAR(dtcp.id_respuesta) = TO_CHAR(respuestas.respuesta);
ELSE
-- Se envia el VALOR en si
v_resp_enviada := respuestas.respuesta;
END IF;
/* -- Se comenta condicion por que se encontro que el PL no toma bien los RAISE dentro de un Loop --
if v_resp_correcta is null then
po_retorno_msg := 'No se pudo obtener la respuesta correcta p/ comparacion, de una de las preguntas. IdPregunta: '|| respuestas.id_pregunta;
raise_application_error(-20001,
'No se pudo obtener la respuesta correcta p/ comparacion, de una de las preguntas. IdPregunta: '|| respuestas.id_pregunta
);
end if;
*/
-- * Si llegamos hasta aqui, comparamos las respuestas...
IF v_resp_correcta = v_resp_enviada THEN
v_contador_resp_ok := v_contador_resp_ok + 1;
END IF;
v_clob_resultado := v_clob_resultado || 'IdPregunta: ' ||
v_dimo_pregunta_segu_row.id_pregunta || ';' || CHR(9) ||
'Label: ' || v_dimo_pregunta_segu_row.label || ';' ||
CHR(9) || 'Respuesta: ' || v_resp_enviada || ';' ||
CHR(9) || 'Resultado: ' || CASE
WHEN v_resp_correcta = v_resp_enviada THEN
'Correcto'
ELSE
'Incorrecto'
END || CHR(13);
END LOOP; -- fin loop respuestas enviadas
UPDATE creditopy.dimo_tc_vinc_proceso dvp
SET dvp.estado = CASE
WHEN v_contador_resp_total = v_contador_resp_ok THEN
1
ELSE
2
END,
dvp.fecha_hora_resp = SYSDATE,
dvp.respuestas_enviadas = v_clob_resultado
WHERE dvp.id_vinc_proceso = pi_id_vinc_proceso;
IF v_contador_resp_ok = v_contador_resp_total THEN
-- ================================================= --
-- Insertamos la tarjeta como vinculada
-- ================================================= --
SELECT creditopy.seq_dimo_tc_vinc.nextval
INTO v_id_seq_vinc
FROM dual;
--insertar en tabla de dimo_catastros_completados
/*insert into creditopy.DIMO_TC_VINCULADAS
(
id_registro,
tarjeta,
fecha_hora_vinculacion,
id_vinc_proceso,
estado,
detalle_preguntas
)
values
(
v_id_seq_vinc,
v_dimo_vinc_proces_row.tarjeta,
sysdate,
v_dimo_vinc_proces_row.id_vinc_proceso,
1,
v_clob_resultado
);*/
po_retorno := 0;
po_retorno_msg := 'OK';
pl_servicio_guardar('DIMO_TC_VINC_PROCESO',
v_dimo_vinc_proces_row.id_vinc_proceso,
NULL);
ELSE
po_retorno := 1;
po_retorno_msg := 'No se han respondido correctamente las preguntas de seguridad';
END IF;
COMMIT;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
po_retorno := -1;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
BEGIN
creditopy.pkg_dimo_ceibo.pr_ceibo_log('DIMO',
'RESP_VINC_TC',
TO_CHAR(SQLERRM),
SYSDATE,
'DIMO');
EXCEPTION
WHEN OTHERS THEN
NULL;
END;
END sp_procesar_respuestas_tu_tu;
-----
------
-- ====================================================================== --
-- Autor: Edgar Rojas
-- Fecha: 19/05/2021
-- Proposito: Obtener datos de la tarjeta
-- ====================================================================== --
PROCEDURE PR_DATOS_TARJETA(CP_TARJETA IN VARCHAR2,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
PO_DATOS_TARJETAS OUT SYS_REFCURSOR) AS
VC_CRIPTO TARJETAS.TARJETA%TYPE;
BEGIN
VC_CRIPTO := FC_PAN2CRIPTO(CP_TARJETA);
OPEN PO_DATOS_TARJETAS FOR
SELECT T.EMISOR,
T.SUCURSAL_EMISOR,
T.NUMERO_CUENTA,
T.ADICIONAL,
T.DOCUMENTO,
T.FECHA_OTORGADA,
T.FECHA_VIGENCIA,
T.NOMBRE_PARA_PLASTICO
FROM TARJETAS T
WHERE T.TARJETA = VC_CRIPTO;
PO_SQLCODE := 0;
PO_SQLERRM := 'La consulta fue realizada.';
EXCEPTION
WHEN OTHERS THEN
PO_SQLCODE := SQLCODE;
PO_SQLERRM := SQLERRM;
BEGIN
PR_CEIBO_LOG('PKG_DIMO_CEIBO',
'PR_DATOS_TARJETA',
TO_CHAR(SQLERRM),
SYSDATE,
'DIMO');
EXCEPTION
WHEN OTHERS THEN
NULL;
END;
END;
-- ====================================================================== --
-- Autor: Feliciano Amarilla
-- Fecha: 17/08/2023
-- Proposito: Retornar la fecha de la ultima compra con TC
-- ====================================================================== --
FUNCTION FN_RETORNA_ULTIMA_COMPRA(P_DOCUMENTO IN NUMBER) RETURN DATE IS
V_FECHA DATE;
is_found NUMBER;
BEGIN
is_found := 0;
BEGIN
SELECT MAX(to_date((to_char(tc.FECHA, 'dd/mm/yyyy') ||
to_char(tc.hora, ' hh24:mi')),
'dd/mm/yyyy hh24:mi')) fecha
INTO V_FECHA
FROM creditopy.log_transacc_cr@olpy tc
WHERE TRIM(SUBSTR(tc.nro_documento, 4)) =
TRIM(to_char(P_DOCUMENTO, '000000000000'))
AND tc.codigo_operacion = 0
AND tc.emisor <> 115
AND tc.tipo_autorizacion = 'A'
ORDER BY 1 DESC;
IF V_FECHA IS NULL THEN
RAISE no_data_found;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
-- SI NO SE ENCUENTRA SE BUSCA EN EL HISTORICO
BEGIN
SELECT MAX(to_date((to_char(th.FECHA, 'dd/mm/yyyy') ||
to_char(th.hora, ' hh24:mi')),
'dd/mm/yyyy hh24:mi')) fecha
INTO V_FECHA
FROM creditopy.log_transacc_cr_hist@olpy th
WHERE TRIM(SUBSTR(th.nro_documento, 4)) =
TRIM(to_char(P_DOCUMENTO /*'4040440'*/, '000000000000'))
AND th.codigo_operacion = 0
AND th.tipo_autorizacion = 'A'
AND th.emisor <> 115
--and th.fecha>sysdate-30
AND th.MOVEXTFCH > SYSDATE - 30
ORDER BY 1 DESC;
EXCEPTION
WHEN NO_DATA_FOUND THEN
V_FECHA := NULL;
END;
-- WHEN OTHERS THEN
-- V_FECHA := SYSDATE + 2;
END;
/* for b in (SELECT MAX(to_date((tc.FECHA||to_char(tc.hora,' hh24:mi')),'dd/mm/yyyy hh24:mi')) fecha
FROM creditopy.log_transacc_cr@olpy tc
WHERE
TRIM(SUBSTR(tc.nro_documento, 4)) =
TRIM(to_char(P_DOCUMENTO , '000000000000'))
and tc.codigo_operacion=0
and tc.emisor<>115
and tc.tipo_autorizacion='A'
ORDER BY 1 DESC
)
loop
--vc_tarjeta := b.d_bin||PI_SUFIJO_TARJETA;
begin
exit when nvl(is_found,0) = 1;
exception
when no_data_found then
is_found := 0;
when others then
raise;
end;
end loop;*/
RETURN V_FECHA;
END FN_RETORNA_ULTIMA_COMPRA;
-- ====================================================================== --
-- Autor: Feliciano Amarilla
-- Fecha: 22/08/2023
-- Proposito: Retornar el importe de la ultima compra con TC
-- ====================================================================== --
FUNCTION FN_RETORNA_IMPORTE_UC(P_DOCUMENTO IN NUMBER) RETURN NUMBER IS
V_IMPORTE NUMBER := 0;
is_found NUMBER;
-- V_MAX_FEC DATE:=CREDITOPY.PKG_DIMO_CEIBO.FN_RETORNA_ULTIMA_COMPRA(P_DOCUMENTO);
v_fec VARCHAR2(10);
v_hora VARCHAR2(5);
BEGIN
BEGIN
SELECT to_char(x.FEC_ULT, 'DD/MM/YYYY') fecha,
to_char(x.FEC_ULT, 'hh24:mi') HORA
INTO v_fec, v_hora
FROM (SELECT CREDITOPY.PKG_DIMO_CEIBO.FN_RETORNA_ULTIMA_COMPRA(P_DOCUMENTO) FEC_ULT
FROM DUAL) x;
EXCEPTION
WHEN OTHERS THEN
v_fec := NULL;
v_hora := NULL;
END;
is_found := 0;
IF v_fec IS NULL THEN
V_IMPORTE := NULL;
ELSE
BEGIN
SELECT tc.importe
INTO V_IMPORTE
FROM creditopy.log_transacc_cr@olpy tc
WHERE TRIM(SUBSTR(tc.nro_documento, 4)) =
TRIM(to_char(P_DOCUMENTO, '000000000000'))
AND tc.codigo_operacion = 0
AND tc.emisor <> 115
AND tc.tipo_autorizacion = 'A'
AND TRIM(TO_CHAR(tc.FECHA, 'DD/MM/YYYY')) = TRIM(v_fec)
AND TRIM(to_char(tc.hora, 'hh24:mi')) = TRIM(v_hora)
ORDER BY 1 DESC;
EXCEPTION
WHEN NO_DATA_FOUND THEN
-- SI NO SE ENCUENTRA SE BUSCA EN EL HISTORICO
BEGIN
SELECT th.importe
-- MAX(to_date((th.FECHA || to_char(th.hora, ' hh24:mi')),
-- 'dd/mm/yyyy hh24:mi')) fecha
INTO V_IMPORTE
FROM creditopy.log_transacc_cr_hist@olpy th
WHERE TRIM(SUBSTR(th.nro_documento, 4)) =
TRIM(to_char(P_DOCUMENTO /*'4040440'*/, '000000000000'))
AND th.codigo_operacion = 0
AND th.tipo_autorizacion = 'A'
AND th.emisor <> 115
--and th.fecha>sysdate-30
AND th.MOVEXTFCH > SYSDATE - 30
AND TRIM(TO_CHAR(th.FECHA, 'DD/MM/YYYY')) = TRIM(v_fec)
AND TRIM(to_char(th.hora, 'hh24:mi')) = TRIM(v_hora)
ORDER BY 1 DESC;
EXCEPTION
WHEN NO_DATA_FOUND THEN
V_IMPORTE := NULL;
END;
-- WHEN OTHERS THEN
-- V_FECHA := SYSDATE + 2;
END;
END IF;
RETURN V_IMPORTE;
END FN_RETORNA_IMPORTE_UC;
-- ====================================================================== --
-- Autor: Feliciano Amarilla
-- Fecha: 23/08/2023
-- Proposito: Retornar el COMERCIO de la ultima compra con TC
-- ====================================================================== --
FUNCTION FN_RETORNA_COMERCIO_UC(P_DOCUMENTO IN NUMBER) RETURN VARCHAR2 IS
V_COMERCIO creditopy.comercios.descripcion%TYPE;
is_found NUMBER;
-- V_MAX_FEC DATE:=CREDITOPY.PKG_DIMO_CEIBO.FN_RETORNA_ULTIMA_COMPRA(P_DOCUMENTO);
v_fec VARCHAR2(10);
v_hora VARCHAR2(5);
BEGIN
BEGIN
SELECT to_char(x.FEC_ULT, 'DD/MM/YYYY') fecha,
to_char(x.FEC_ULT, 'hh24:mi') HORA
INTO v_fec, v_hora
FROM (SELECT CREDITOPY.PKG_DIMO_CEIBO.FN_RETORNA_ULTIMA_COMPRA(P_DOCUMENTO) FEC_ULT
FROM DUAL) x;
EXCEPTION
WHEN OTHERS THEN
v_fec := NULL;
v_hora := NULL;
END;
is_found := 0;
IF v_fec IS NULL THEN
V_COMERCIO := NULL;
ELSE
BEGIN
SELECT C.DESCRIPCION
INTO V_COMERCIO
FROM creditopy.log_transacc_cr@olpy tc, creditopy.comercios c
WHERE TRIM(SUBSTR(tc.nro_documento, 4)) =
TRIM(to_char(P_DOCUMENTO, '000000000000'))
AND tc.codigo_operacion = 0
AND tc.emisor <> 115
AND tc.tipo_autorizacion = 'A'
AND TRIM(TO_CHAR(tc.FECHA, 'DD/MM/YYYY')) = TRIM(v_fec)
AND TRIM(to_char(tc.hora, 'hh24:mi')) = TRIM(v_hora)
AND tc.nro_comercio = C.COMERCIO
ORDER BY 1 DESC;
EXCEPTION
WHEN NO_DATA_FOUND THEN
-- SI NO SE ENCUENTRA SE BUSCA EN EL HISTORICO
BEGIN
SELECT C.DESCRIPCION
-- MAX(to_date((th.FECHA || to_char(th.hora, ' hh24:mi')),
-- 'dd/mm/yyyy hh24:mi')) fecha
INTO V_COMERCIO
FROM creditopy.log_transacc_cr_hist@olpy th,
creditopy.comercios c
WHERE TRIM(SUBSTR(th.nro_documento, 4)) =
TRIM(to_char(P_DOCUMENTO /*'4040440'*/, '000000000000'))
AND th.codigo_operacion = 0
AND th.tipo_autorizacion = 'A'
AND th.emisor <> 115
--and th.fecha>sysdate-30
AND th.MOVEXTFCH > SYSDATE - 30
AND TRIM(TO_CHAR(th.FECHA, 'DD/MM/YYYY')) = TRIM(v_fec)
AND TRIM(to_char(th.hora, 'hh24:mi')) = TRIM(v_hora)
AND tH.nro_comercio = C.COMERCIO
ORDER BY 1 DESC;
EXCEPTION
WHEN NO_DATA_FOUND THEN
V_COMERCIO := NULL;
END;
-- WHEN OTHERS THEN
-- V_FECHA := SYSDATE + 2;
END;
END IF;
RETURN V_COMERCIO;
END FN_RETORNA_COMERCIO_UC;
------------------------
-----------------------
/*
Info. CARGO INDIVIDUAL APLICADOS A TXS DE DEBITOS
*/
/****************************************************************************************************
Autor: Feliciano Amarilla
Fecha: 25/09/2023
Propósito: Procedimiento que devuelve los datos del cargo que se aplica a la
transacción
******************************************************************************************************/
PROCEDURE PR_RETORNA_CARGO_DEBITO(PI_FECHA_OPERACION IN DATE,
PI_CANAL IN VARCHAR2, --CEIBO (POS, ATM,)/ SICOOP
PI_CUENTA_ORIGINANTE IN VARCHAR2, --CEIBO / SICOOP
PI_EF_ORIGINANTE IN NUMBER, --CEIBO / SICOOP
PI_MONTO_TRANSACCION IN NUMBER, --CEIBO / SICOOP
PI_TIPO_TRANSACCION IN VARCHAR2 DEFAULT NULL, -- SICOOP
PI_COD_SERVICIO IN VARCHAR2 DEFAULT NULL, -- SICOOP
PI_TIPO_CUENTA_ORIGEN IN VARCHAR2 DEFAULT NULL, -- SICOOP
PI_EF_DESTINATARIO IN NUMBER DEFAULT NULL, -- SICOOP
PI_CUENTA_DESTINATARIO IN VARCHAR2 DEFAULT NULL, -- SICOOP
PI_TIPO_CUENTA_DESTINO IN VARCHAR2 DEFAULT NULL, -- SICOOP
PI_EMISOR IN NUMBER, --CEIBO / SICOOP
PI_AFINIDAD IN NUMBER, --CEIBO / SICOOP
PI_CARTERA IN NUMBER, --CEIBO / SICOOP
PI_RAMO_COMERCIO IN NUMBER DEFAULT NULL, --CEIBO
PI_COD_COMERCIO IN NUMBER DEFAULT NULL, --CEIBO
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
P_PAGADOR OUT VARCHAR2,
--P_APLICACION_DEL_CARGO OUT VARCHAR2,
P_MONTO_CARGO OUT NUMBER,
P_RUBRO_CARGO OUT NUMBER,
-- P_CODIGO_IMPUESTO OUT NUMBER,
P_ID_CARGO OUT NUMBER,
P_ID_RANGO OUT NUMBER,
P_GLOSA_PARA_USUARIO OUT VARCHAR2,
PO_CURSOR OUT SYS_REFCURSOR) AS
V_FECHA_TRAN DATE;
VR_CARGO_X_TR CREDITOPY.CARGOS_POR_TRANSAC_DIMO%ROWTYPE;
V_TAB_AUX CREDITOPY.CARGOS_POR_TRANSAC_DIMO%ROWTYPE;
V_MIN_LOOP NUMBER := 3;
V_MAX_LOOP NUMBER := 8;
V_MIN_LOOP_CEIBO NUMBER := 3;
V_MAX_LOOP_CEIBO NUMBER := 8;
V_LOOP NUMBER;
V_CANT_TRANSAC NUMBER := 0;
CURSOR cur_cargos is
SELECT *
FROM creditopy.Cargos_Por_Transac_Dimo a
WHERE canal = PI_CANAL
AND a.cargo_activo = 'S'
AND nvl(PI_FECHA_OPERACION,sysdate) BETWEEN a.fecha_vigencia_desde AND
a.fecha_vigencia_hasta
ORDER BY prioridad, id_cargo_tran;
V_COSTO_ID NUMBER;
V_id_rango NUMBER;
V_COSTO_DESCRIPCION CREDITOPY.CARGOS_POR_TRANSAC_DIMO.DESCRIPCION_CARGO%TYPE := ' ';
V_PAGADOR VARCHAR2(1000);
V_MONTO_CARGO_ORIGINANTE NUMBER := 0;
V_MONTO_CARGO_DESTINATARIO NUMBER := 0;
V_IVA NUMBER := 0;
V_RUBRO NUMBER := 0;
FUNCTION FN_GET_CUENTA (P_TARJETA IN VARCHAR2) RETURN NUMBER AS
v_CUENTA_IN NUMBER;
BEGIN
SELECT MAX (T.numero_cuenta) CUENTA
INTO v_CUENTA_IN
FROM creditopy.tarjetas t
WHERE t.tarjeta = creditopy.fc_pan2cripto(P_TARJETA);
-- and c.numero_cuenta= t.numero_cuenta;
RETURN v_CUENTA_IN;
END;
FUNCTION FN_GET_EMISOR_CABAL(VN_TARJETA IN VARCHAR2) RETURN NUMBER IS
VN_EMISOR NUMBER;
BEGIN
SELECT T.EMISOR
INTO VN_EMISOR
FROM CREDITOPY.TARJETAS T
WHERE T.TARJETA = CREDITOPY.FC_PAN2CRIPTO(PI_CUENTA_ORIGINANTE);
RETURN VN_EMISOR;
EXCEPTION
WHEN NO_DATA_FOUND THEN
VN_EMISOR := 0;
RETURN VN_EMISOR;
WHEN OTHERS THEN
RAISE;
END FN_GET_EMISOR_CABAL;
--Buscamos la cantidad de transacciones para el id_cargo en un periodo
FUNCTION FN_GET_CANTIDAD_TRX(pi_id_cargo IN NUMBER) RETURN NUMBER IS
V_CANT NUMBER := 0;
V_CUENTA NUMBER;
BEGIN
IF LENGTH(PI_CUENTA_ORIGINANTE)=16 THEN
V_CUENTA:=FN_GET_CUENTA(PI_CUENTA_ORIGINANTE);
ELSE
V_CUENTA:=PI_CUENTA_ORIGINANTE;
END IF;
SELECT (CANTIDAD) CANT
INTO V_CANT
FROM ACUM_TRANSAC_CUENTA a
WHERE A.PERIODO = to_char(V_FECHA_TRAN, 'yyyymm')
AND A.CUENTA = V_CUENTA--enviar cuenta
AND a.id_cargo_tran = pi_id_cargo;
-- and a.tipo_operacion=PI_TIPO_TRANSACCION;
RETURN V_CANT;
EXCEPTION
WHEN NO_DATA_FOUND THEN
V_CANT := 0;
RETURN V_CANT;
WHEN OTHERS THEN
--RAISE;
V_CANT := 0;
RETURN V_CANT;
END FN_GET_CANTIDAD_TRX;
FUNCTION fn_get_afinidad RETURN NUMBER IS
v_afinidad NUMBER;
BEGIN
SELECT c.grupo_afinidad
INTO v_afinidad
FROM creditopy.tarjetas t, creditopy.cuentas c
WHERE t.tarjeta = creditopy.fc_pan2cripto(PI_CUENTA_ORIGINANTE)
and c.numero_cuenta= t.numero_cuenta;
RETURN v_afinidad;
EXCEPTION
WHEN NO_DATA_FOUND THEN
v_afinidad := 0;
RETURN v_afinidad;
WHEN OTHERS THEN
RAISE;
END fn_get_afinidad;
FUNCTION fn_get_cartera RETURN NUMBER IS
v_cartera NUMBER;
BEGIN
SELECT c.cartera
INTO v_cartera
FROM creditopy.tarjetas t, creditopy.cuentas c
WHERE t.tarjeta = creditopy.fc_pan2cripto(PI_CUENTA_ORIGINANTE)
and c.numero_cuenta= t.numero_cuenta;
RETURN v_cartera;
EXCEPTION
WHEN NO_DATA_FOUND THEN
v_cartera := 0;
RETURN v_cartera;
WHEN OTHERS THEN
RAISE;
END fn_get_cartera;
PROCEDURE buscar_un_id_cargo AS
BEGIN
V_COSTO_ID := 0;
for c in cur_cargos loop
for t in (SELECT 1 FROM dual l
WHERE 1=1
and ( V_TAB_AUX.EMISOR_CABAL_DESTINATARIO=c.EMISOR_CABAL_DESTINATARIO or nvl(c.EMISOR_CABAL_DESTINATARIO,0) =0)
and ( V_TAB_AUX.CODIGO_EF_DESTINATARIO=c.CODIGO_EF_DESTINATARIO or nvl(c.CODIGO_EF_DESTINATARIO,0) =0)
and ( V_TAB_AUX.CARTERA_CABAL_ORIGINANTE=c.CARTERA_CABAL_ORIGINANTE or nvl(c.CARTERA_CABAL_ORIGINANTE,0) =0)
and ( V_TAB_AUX.AFINIDAD_CABAL_ORIGINANTE=c.AFINIDAD_CABAL_ORIGINANTE or nvl(c.AFINIDAD_CABAL_ORIGINANTE,0) =0)
and ( V_TAB_AUX.EMISOR_CABAL_ORIGINANTE=c.EMISOR_CABAL_ORIGINANTE or nvl(c.EMISOR_CABAL_ORIGINANTE,0) =0)
and ( V_TAB_AUX.CODIGO_EF_ORIGINANTE=c.CODIGO_EF_ORIGINANTE or nvl(c.CODIGO_EF_ORIGINANTE,0) =0)
and ( V_TAB_AUX.ID_TRAN_MENSAJE=c.ID_TRAN_MENSAJE or nvl(c.ID_TRAN_MENSAJE,0) =0)) loop
if nvl(V_COSTO_ID,0)=0 then
V_COSTO_ID:=c.id_cargo_tran;
PR_LOGGING('CARGO_DIMO',
'01',
'encontro un cargo PARAMETROS RECIBIDOS.' ||
' V_COSTO_ID:' ||V_COSTO_ID ||
' PI_TIPO_TRANSACCION:' ||PI_TIPO_TRANSACCION ||
' PI_COD_SERVICIO:' ||PI_COD_SERVICIO ||
' PI_EF_ORIGINANTE:' ||PI_EF_ORIGINANTE ||
' PI_CUENTA_ORIGINANTE:' ||PI_CUENTA_ORIGINANTE ||
' PI_TIPO_CUENTA_ORIGEN:' ||PI_TIPO_CUENTA_ORIGEN ||
' PI_EF_DESTINATARIO:' ||PI_EF_DESTINATARIO ||
' PI_CUENTA_DESTINATARIO:' ||PI_CUENTA_DESTINATARIO ||
' PI_TIPO_CUENTA_DESTINO:' ||PI_TIPO_CUENTA_DESTINO ||
' PI_MONTO_TRANSACCION:' ||PI_MONTO_TRANSACCION ||
'FIN');
end if;
end loop;
end loop;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END buscar_un_id_cargo;
PROCEDURE buscar_un_id_cargo_ceibo AS
BEGIN
V_COSTO_ID := 0;
for c in cur_cargos loop
for t in (SELECT 1 FROM dual l
WHERE 1=1
and ( V_TAB_AUX.COD_COMERCIO=c.COD_COMERCIO or nvl(c.COD_COMERCIO,0) =0)
and ( V_TAB_AUX.RAMO_COMERCIO=c.RAMO_COMERCIO or nvl(c.RAMO_COMERCIO,0) =0)
and ( V_TAB_AUX.CARTERA_CABAL_ORIGINANTE=c.CARTERA_CABAL_ORIGINANTE or nvl(c.CARTERA_CABAL_ORIGINANTE,0) =0)
and ( V_TAB_AUX.AFINIDAD_CABAL_ORIGINANTE=c.AFINIDAD_CABAL_ORIGINANTE or nvl(c.AFINIDAD_CABAL_ORIGINANTE,0) =0)
and ( V_TAB_AUX.EMISOR_CABAL_ORIGINANTE=c.EMISOR_CABAL_ORIGINANTE or nvl(c.EMISOR_CABAL_ORIGINANTE,0) =0)
and ( V_TAB_AUX.CODIGO_EF_ORIGINANTE=c.CODIGO_EF_ORIGINANTE or nvl(c.CODIGO_EF_ORIGINANTE,0) =0))
-- and ( V_TAB_AUX.ID_TRAN_MENSAJE=c.ID_TRAN_MENSAJE or nvl(c.ID_TRAN_MENSAJE,0) =0))
loop
if nvl(V_COSTO_ID,0)=0 then
V_COSTO_ID:=c.id_cargo_tran;
PR_LOGGING('CARGO_DIMO',
'02',-- puede ser atm ceibo o atm qr sicoop
'encontro un cargo PARAMETROS RECIBIDOS.' ||
' V_COSTO_ID:' ||V_COSTO_ID ||
' PI_TIPO_TRANSACCION:' ||PI_TIPO_TRANSACCION ||
' PI_COD_SERVICIO:' ||PI_COD_SERVICIO ||
' PI_EF_ORIGINANTE:' ||PI_EF_ORIGINANTE ||
' PI_CUENTA_ORIGINANTE:' ||PI_CUENTA_ORIGINANTE ||
' PI_TIPO_CUENTA_ORIGEN:' ||PI_TIPO_CUENTA_ORIGEN ||
' PI_EF_DESTINATARIO:' ||PI_EF_DESTINATARIO ||
' PI_CUENTA_DESTINATARIO:' ||PI_CUENTA_DESTINATARIO ||
' PI_TIPO_CUENTA_DESTINO:' ||PI_TIPO_CUENTA_DESTINO ||
' PI_MONTO_TRANSACCION:' ||PI_MONTO_TRANSACCION ||
'FIN');
end if;
end loop;
end loop;
EXCEPTION
WHEN OTHERS THEN
RAISE;
END buscar_un_id_cargo_ceibo;
BEGIN
---CUANDO LA PETICION VIENE DE CEIBO
IF UPPER(PI_CANAL) IN ('POS', 'ATM') THEN
PR_LOGGING('CARGO_DIMO',
'02',
'llego al principal PARAMETROS RECIBIDOS.' ||
' PI_CANAL:' ||PI_CANAL ||
' PI_TIPO_TRANSACCION:' ||PI_TIPO_TRANSACCION ||
' PI_COD_SERVICIO:' ||PI_COD_SERVICIO ||
' PI_EF_ORIGINANTE:' ||PI_EF_ORIGINANTE ||
' PI_CUENTA_ORIGINANTE:' ||PI_CUENTA_ORIGINANTE ||
' PI_TIPO_CUENTA_ORIGEN:' ||PI_TIPO_CUENTA_ORIGEN ||
' PI_EF_DESTINATARIO:' ||PI_EF_DESTINATARIO ||
' PI_CUENTA_DESTINATARIO:' ||PI_CUENTA_DESTINATARIO ||
' PI_TIPO_CUENTA_DESTINO:' ||PI_TIPO_CUENTA_DESTINO ||
' PI_MONTO_TRANSACCION:' ||PI_MONTO_TRANSACCION ||
'FIN');
-- NULL;
--BUSCAR EL CARGO PARA LOS DATOS ESPECIFICOS DE PARTICIPANTE/EMISOR
V_FECHA_TRAN := NVL(PI_FECHA_OPERACION, SYSDATE);
VR_CARGO_X_TR.CANAL := PI_CANAL;
VR_CARGO_X_TR.CODIGO_EF_ORIGINANTE := PI_EF_ORIGINANTE;
VR_CARGO_X_TR.EMISOR_CABAL_ORIGINANTE := PI_EMISOR;
VR_CARGO_X_TR.AFINIDAD_CABAL_ORIGINANTE := PI_AFINIDAD;
VR_CARGO_X_TR.CARTERA_CABAL_ORIGINANTE := PI_CARTERA;
VR_CARGO_X_TR.RAMO_COMERCIO := PI_RAMO_COMERCIO;
VR_CARGO_X_TR.COD_COMERCIO := PI_COD_COMERCIO;
V_TAB_AUX.CANAL:=PI_CANAL;
V_TAB_AUX.COD_COMERCIO:= VR_CARGO_X_TR.COD_COMERCIO;
V_TAB_AUX.RAMO_COMERCIO := VR_CARGO_X_TR.RAMO_COMERCIO;
V_TAB_AUX.CARTERA_CABAL_ORIGINANTE := VR_CARGO_X_TR.CARTERA_CABAL_ORIGINANTE;
V_TAB_AUX.AFINIDAD_CABAL_ORIGINANTE := VR_CARGO_X_TR.AFINIDAD_CABAL_ORIGINANTE;
V_TAB_AUX.EMISOR_CABAL_ORIGINANTE := VR_CARGO_X_TR.EMISOR_CABAL_ORIGINANTE;
V_TAB_AUX.CODIGO_EF_ORIGINANTE := VR_CARGO_X_TR.CODIGO_EF_ORIGINANTE ;
-- V_TAB_AUX.CANAL :=VR_CARGO_X_TR.CANAL;
V_COSTO_ID := 0;
BUSCAR_UN_ID_CARGO_CEIBO;
IF V_COSTO_ID != 0 THEN
VR_CARGO_X_TR.ID_CARGO_TRAN := V_COSTO_ID;
V_CANT_TRANSAC := FN_GET_CANTIDAD_TRX(V_COSTO_ID);
SELECT --CT.ID_CARGO_TRAN AS COSTO_ID,
-- M.DESC_TRAN_MENSAJE AS COSTO_DESCRIPCION,
CT.DESCRIPCION_CARGO AS COSTO_DESCRIPCION,
CASE
WHEN CR.TIPO_CARGO_ORIGINANTE = 'FEE' THEN
CR.CARGO_ORIGINANTE +
DECODE(I.VALOR_IMPUESTO,
0,
0,
ROUND((CR.CARGO_ORIGINANTE * I.VALOR_IMPUESTO / 100)))
ELSE
ROUND(PI_MONTO_TRANSACCION * CR.PORCENTAJE_ORIGINANTE / 100) +
DECODE(I.VALOR_IMPUESTO,
0,
0,
ROUND(ROUND(PI_MONTO_TRANSACCION *
CR.PORCENTAJE_ORIGINANTE / 100) *
I.VALOR_IMPUESTO / 100))
END AS MONTO_CARGO_ORIGINANTE,
0 AS MONTO_CARGO_DESTINATARIO,
I.VALOR_IMPUESTO AS IVA,
CT.RUBRO_CARGO AS RUBRO,
CT.PAGADOR,
cr.id_cargo_tran_rango
INTO --V_COSTO_ID,
V_COSTO_DESCRIPCION,
V_MONTO_CARGO_ORIGINANTE,
V_MONTO_CARGO_DESTINATARIO,
V_IVA,
V_RUBRO,
V_PAGADOR,
V_id_rango
FROM CREDITOPY.CARGOS_POR_TRANSAC_DIMO CT,
CREDITOPY.CARGOS_POR_TRANSAC_DIMO_RANGO CR,
--CREDITOPY.SICOOP_LISTA_TRANSAC_MENSAJE M,
CREDITOPY.IMPUESTOS I
WHERE CT.ID_CARGO_TRAN = VR_CARGO_X_TR.ID_CARGO_TRAN
-- AND M.ID_TRAN_MENSAJE = CT.ID_TRAN_MENSAJE
AND CT.PAGADOR != 'SUBSIDIADO'
AND CR.ID_CARGO_TRAN = CT.ID_CARGO_TRAN
AND CT.CANTIDAD_EXONERADA <= V_CANT_TRANSAC
AND PI_MONTO_TRANSACCION BETWEEN CR.RANGO_MONTO_DESDE AND
CR.RANGO_MONTO_HASTA
AND I.CODIGO_IMPUESTO = CT.CODIGO_IMPUESTO;
END IF;
ELSE
--CUANDO PROVIENE DE SICOOP
-- OBTENER EL ID_TRAN_MENSAJE DE LA TRANSACCION
PR_LOGGING('CARGO_DIMO',
'01',
'llego al principal PARAMETROS RECIBIDOS.' ||
' PI_CANAL:' ||PI_CANAL ||
' PI_TIPO_TRANSACCION:' ||PI_TIPO_TRANSACCION ||
' PI_COD_SERVICIO:' ||PI_COD_SERVICIO ||
' PI_EF_ORIGINANTE:' ||PI_EF_ORIGINANTE ||
' PI_CUENTA_ORIGINANTE:' ||PI_CUENTA_ORIGINANTE ||
' PI_TIPO_CUENTA_ORIGEN:' ||PI_TIPO_CUENTA_ORIGEN ||
' PI_EF_DESTINATARIO:' ||PI_EF_DESTINATARIO ||
' PI_CUENTA_DESTINATARIO:' ||PI_CUENTA_DESTINATARIO ||
' PI_TIPO_CUENTA_DESTINO:' ||PI_TIPO_CUENTA_DESTINO ||
' PI_MONTO_TRANSACCION:' ||PI_MONTO_TRANSACCION ||
'FIN');
BEGIN
SELECT M.ID_TRAN_MENSAJE
INTO VR_CARGO_X_TR.ID_TRAN_MENSAJE
FROM CREDITOPY.SICOOP_LISTA_TRANSAC_MENSAJE M
WHERE M.TIPO_TRANSACCION = NVL(PI_TIPO_TRANSACCION, '-1')
AND M.COD_SERVICIO = NVL(PI_COD_SERVICIO, '-1')
AND M.TIPO_CUENTA_ORIGEN = NVL(PI_TIPO_CUENTA_ORIGEN, '-1')
AND M.TIPO_CUENTA_DESTINO = NVL(PI_TIPO_CUENTA_DESTINO, '-1')
AND M.DISPONIBLE_PARA_CARGO_TRAN = 1;
EXCEPTION
WHEN OTHERS THEN
RAISE_APPLICATION_ERROR(-20001, 'Servicio no existe.');
END;
--BUSCAR EL CARGO PARA LOS DATOS ESPECIFICOS DE PARTICIPANTE/EMISOR
V_FECHA_TRAN := NVL(PI_FECHA_OPERACION,
SYSDATE);
VR_CARGO_X_TR.CANAL := PI_CANAL;
VR_CARGO_X_TR.CODIGO_EF_ORIGINANTE := PI_EF_ORIGINANTE;
VR_CARGO_X_TR.CODIGO_EF_DESTINATARIO := PI_EF_DESTINATARIO;
-- OBTENER EL EMISOR_CABAL DE LA CUENTA ORIGINANTE Y CUENTA DESTINATARIO
VR_CARGO_X_TR.EMISOR_CABAL_ORIGINANTE := FN_GET_EMISOR_CABAL(PI_CUENTA_ORIGINANTE);
VR_CARGO_X_TR.EMISOR_CABAL_DESTINATARIO := FN_GET_EMISOR_CABAL(PI_CUENTA_DESTINATARIO);
VR_CARGO_X_TR.AFINIDAD_CABAL_ORIGINANTE := fn_get_afinidad;
VR_CARGO_X_TR.CARTERA_CABAL_ORIGINANTE := fn_get_cartera;
V_COSTO_ID := 0;
V_TAB_AUX.CANAL:=PI_CANAL;
V_TAB_AUX.EMISOR_CABAL_DESTINATARIO:=VR_CARGO_X_TR.EMISOR_CABAL_DESTINATARIO ;
V_TAB_AUX.CODIGO_EF_DESTINATARIO:=VR_CARGO_X_TR.CODIGO_EF_DESTINATARIO ;
V_TAB_AUX.CARTERA_CABAL_ORIGINANTE:=VR_CARGO_X_TR.CARTERA_CABAL_ORIGINANTE ;
V_TAB_AUX.AFINIDAD_CABAL_ORIGINANTE:= VR_CARGO_X_TR.AFINIDAD_CABAL_ORIGINANTE ;
V_TAB_AUX.EMISOR_CABAL_ORIGINANTE:=VR_CARGO_X_TR.EMISOR_CABAL_ORIGINANTE ;
V_TAB_AUX.CODIGO_EF_ORIGINANTE:= VR_CARGO_X_TR.CODIGO_EF_ORIGINANTE;
V_TAB_AUX.ID_TRAN_MENSAJE:=VR_CARGO_X_TR.ID_TRAN_MENSAJE;
BUSCAR_UN_ID_CARGO;
IF v_costo_id != 0 THEN
VR_CARGO_X_TR.Id_Cargo_Tran := v_costo_id;
V_CANT_TRANSAC := FN_GET_CANTIDAD_TRX(V_COSTO_ID);
SELECT
-- ct.id_cargo_tran as COSTO_ID,
m.desc_tran_mensaje AS COSTO_DESCRIPCION,
CASE
WHEN cr.tipo_cargo_originante = 'FEE' THEN
cr.cargo_originante +
decode(i.valor_impuesto,
0,
0,
round((cr.cargo_originante * i.valor_impuesto / 100)))
ELSE
round(PI_MONTO_TRANSACCION * cr.porcentaje_originante / 100) +
decode(i.valor_impuesto,
0,
0,
round(round(PI_MONTO_TRANSACCION * cr.porcentaje_originante / 100) *
i.valor_impuesto / 100))
END AS MONTO_CARGO_ORIGINANTE,
0 AS MONTO_CARGO_DESTINATARIO,
i.valor_impuesto AS IVA,
ct.rubro_cargo AS RUBRO
INTO -- V_COSTO_ID,
V_COSTO_DESCRIPCION,
V_MONTO_CARGO_ORIGINANTE,
V_MONTO_CARGO_DESTINATARIO,
V_IVA,
V_RUBRO
FROM creditopy.CARGOS_POR_TRANSAC_DIMO ct,
creditopy.CARGOS_POR_TRANSAC_DIMO_RANGO cr,
creditopy.SICOOP_LISTA_TRANSAC_MENSAJE m,
creditopy.IMPUESTOS i
WHERE ct.id_cargo_tran = VR_CARGO_X_TR.Id_Cargo_Tran
AND m.id_tran_mensaje = ct.id_tran_mensaje
AND ct.pagador != 'SUBSIDIADO'
AND cr.id_cargo_tran = ct.id_cargo_tran
AND nvl(CT.CANTIDAD_EXONERADA, 0) <= V_CANT_TRANSAC
AND PI_MONTO_TRANSACCION BETWEEN cr.rango_monto_desde AND
cr.rango_monto_hasta
AND i.codigo_impuesto = ct.codigo_impuesto;
END IF;
END IF;
OPEN PO_CURSOR FOR
SELECT V_COSTO_ID AS COSTO_ID,
V_COSTO_DESCRIPCION AS COSTO_DESCRIPCION,
V_MONTO_CARGO_ORIGINANTE AS MONTO_CARGO_ORIGINANTE,
V_MONTO_CARGO_DESTINATARIO AS MONTO_CARGO_DESTINATARIO,
V_IVA AS IVA,
V_RUBRO AS RUBRO
FROM DUAL;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := CASE
WHEN V_COSTO_ID = 0 THEN
'Sin cargo.'
ELSE
SQLERRM
END;
P_PAGADOR := V_PAGADOR;
--P_APLICACION_DEL_CARGO:=V_COSTO_DESCRIPCION;
P_GLOSA_PARA_USUARIO := V_COSTO_DESCRIPCION;
P_MONTO_CARGO := V_MONTO_CARGO_ORIGINANTE;
P_RUBRO_CARGO := V_RUBRO;
--P_CODIGO_IMPUESTO:=V_IVA;
P_ID_CARGO := V_COSTO_ID;
P_ID_RANGO := V_id_rango;
PO_SQLCODE := SQLCODE;
PO_SQLERRM := CASE
WHEN V_COSTO_ID = 0 THEN
'Sin cargo.'
ELSE
SQLERRM
END;
EXCEPTION
WHEN NO_DATA_FOUND THEN
-- IF pi_canal IN ('ATM', 'POS') THEN
P_PAGADOR := 0;
--P_APLICACION_DEL_CARGO:=V_COSTO_DESCRIPCION;
P_GLOSA_PARA_USUARIO := 0;
P_MONTO_CARGO := 0;
P_RUBRO_CARGO := 0;
P_ID_RANGO := 0;
P_ID_CARGO := V_COSTO_ID; --se pide que se retorne igual el id_cargo
--ELSE
OPEN PO_CURSOR FOR
SELECT nvl(v_costo_id,0) AS COSTO_ID,
' ' AS COSTO_DESCRIPCION,
0 AS MONTO_CARGO_ORIGINANTE,
0 AS MONTO_CARGO_DESTINATARIO,
0 AS IVA,
0 AS RUBRO
FROM DUAL;
PO_SQLCODE := 0;
PO_SQLERRM := 'Sin cargo.';
--END IF;
WHEN OTHERS THEN
--IF pi_canal IN ('ATM', 'POS') THEN
P_PAGADOR := 0;
--P_APLICACION_DEL_CARGO:=V_COSTO_DESCRIPCION;
P_GLOSA_PARA_USUARIO := -1;
P_MONTO_CARGO := -1;
P_RUBRO_CARGO := -1;
P_ID_CARGO := -1;
--ELSE
OPEN PO_CURSOR FOR
SELECT 0 AS COSTO_ID,
' ' AS COSTO_DESCRIPCION,
0 AS MONTO_CARGO_ORIGINANTE,
0 AS MONTO_CARGO_DESTINATARIO,
0 AS IVA,
0 AS RUBRO
FROM DUAL;
--END IF;
PO_SQLCODE := 0;
PO_SQLERRM := SQLERRM;
END PR_RETORNA_CARGO_DEBITO;
-----------------------
------------------------
-----------------------
------------------------
/*
INFO. PROCEDIMIENTO PARA ENCAPSULAR PETICION DE CARGOS DE DEBITOS DE CEIBO
*/
/****************************************************************************************************
AUTOR: FELICIANO AMARILLA
FECHA: 02/10/2023
PROPÓSITO: PROCEDIMIENTO QUE DEVUELVE LOS DATOS DEL CARGO PARA CEIBO
******************************************************************************************************/
PROCEDURE PR_RETORNA_CARGO_DEB_CEIBO(PI_FECHA_OPERACION IN DATE,
PI_CANAL IN VARCHAR2, --CEIBO (POS, ATM,)/ SICOOP
PI_EMISOR IN NUMBER,
PI_AFINIDAD IN NUMBER,
PI_CARTERA IN NUMBER,
PI_CUENTA_ORIGINANTE IN VARCHAR2, --CEIBO / SICOOP
PI_EF_ORIGINANTE IN NUMBER, --CEIBO / SICOOP
PI_MONTO_TRANSACCION IN NUMBER, --CEIBO / SICOOP
PI_RAMO_COMERCIO IN NUMBER, --CEIBO
PI_COD_COMERCIO IN NUMBER, --CEIBO
P_MONTO_CARGO OUT NUMBER,
P_RUBRO_CARGO OUT NUMBER,
P_ID_CARGO OUT NUMBER,
P_ID_RANGO OUT NUMBER) IS
V_SQLCODE NUMBER;
V_SQLERRM VARCHAR2(4000);
V_PAGADOR VARCHAR2(4000);
V_MONTO_CARGO NUMBER;
V_RUBRO_CARGO NUMBER;
V_GLOSA_PARA_USUARIO VARCHAR2(4000);
V_ID_CARGO NUMBER;
V_ID_RANGO NUMBER;
V_CURSOR SYS_REFCURSOR;
BEGIN
PR_LOGGING('CARGO_DIMO',
'02',
'PKG_DIMO_CEIBO.PR_RETORNA_CARGO_DEB_CEIBO. PARAMETROS RECIBIDOS.' ||
' PI_CANAL: ' ||PI_CANAL ||
' PI_EMISOR: ' ||PI_EMISOR ||
' PI_AFINIDAD: ' ||PI_AFINIDAD ||
' PI_CARTERA: ' ||PI_CARTERA ||
' PI_CUENTA_ORIGINANTE: ' ||PI_CUENTA_ORIGINANTE ||
' PI_EF_ORIGINANTE: ' ||PI_EF_ORIGINANTE ||
' PI_MONTO_TRANSACCION: ' ||PI_MONTO_TRANSACCION ||
' PI_RAMO_COMERCIO: ' ||PI_RAMO_COMERCIO ||
' PI_COD_COMERCIO: ' ||PI_COD_COMERCIO ||
' FIN');
PKG_DIMO_CEIBO.PR_RETORNA_CARGO_DEBITO(PI_FECHA_OPERACION => PI_FECHA_OPERACION,
PI_CANAL => PI_CANAL, --CEIBO (POS, ATM,)/ SICOOP
PI_CUENTA_ORIGINANTE => PI_CUENTA_ORIGINANTE, --CEIBO / SICOOP
PI_EF_ORIGINANTE => PI_EF_ORIGINANTE, --CEIBO / SICOOP
PI_MONTO_TRANSACCION => PI_MONTO_TRANSACCION, --CEIBO / SICOOP
PI_TIPO_TRANSACCION => NULL, -- SICOOP
PI_COD_SERVICIO => NULL, -- SICOOP
PI_TIPO_CUENTA_ORIGEN => NULL, -- SICOOP
PI_EF_DESTINATARIO => NULL, -- SICOOP
PI_CUENTA_DESTINATARIO => NULL, -- SICOOP
PI_TIPO_CUENTA_DESTINO => NULL, -- SICOOP
PI_EMISOR => PI_EMISOR, --CEIBO / SICOOP
PI_AFINIDAD => PI_AFINIDAD, --CEIBO / SICOOP
PI_CARTERA => PI_CARTERA, --CEIBO / SICOOP
PI_RAMO_COMERCIO => PI_RAMO_COMERCIO, --CEIBO
PI_COD_COMERCIO => PI_COD_COMERCIO, --CEIBO
PO_SQLCODE => V_SQLCODE,
PO_SQLERRM => V_SQLERRM,
P_PAGADOR => V_PAGADOR,
--P_APLICACION_DEL_CARGO OUT VARCHAR2,
P_MONTO_CARGO => V_MONTO_CARGO,
P_RUBRO_CARGO => V_RUBRO_CARGO,
-- P_CODIGO_IMPUESTO OUT NUMBER,
P_ID_CARGO => V_ID_CARGO,
P_ID_RANGO => V_ID_RANGO,
P_GLOSA_PARA_USUARIO => V_GLOSA_PARA_USUARIO,
PO_CURSOR => V_CURSOR);
--P_PAGADOR :=V_PAGADOR ;
P_MONTO_CARGO := V_MONTO_CARGO;
P_RUBRO_CARGO := V_RUBRO_CARGO;
P_ID_CARGO := V_ID_CARGO;
P_ID_RANGO := V_ID_RANGO;
--P_GLOSA_PARA_USUARIO := V_GLOSA_PARA_USUARIO;
END PR_RETORNA_CARGO_DEB_CEIBO;
-----------------
-----------------------
------------------------
/*
INFO. PROCEDIMIENTO PARA ACUMULAR TRANSACCIONES DE DEBITOS
*/
/****************************************************************************************************
AUTOR: FELICIANO AMARILLA
FECHA: 10/10/2023
PROPÓSITO: PROCEDIMIENTO PARA ACUMULAR TRANSACCIONES DE DEBITOS
******************************************************************************************************/
PROCEDURE PR_ACUMULAR_TRX_DEBITO(PI_ID_CARGO IN NUMBER,
PI_CUENTA IN VARCHAR2, --CEIBO / SICOOP
pi_fecha_operacion IN DATE, -- Se respeta la fecha de operacion para establecer el periodo
pi_signo_operacion IN VARCHAR2 --- Si es negativo - corresponde a un reverso
) IS
PRAGMA AUTONOMOUS_TRANSACTION;
V_SQLCODE NUMBER;
V_SQLERRM VARCHAR2(4000);
V_ID_ACUM NUMBER;
V_TIPO_OPERACION VARCHAR2(100);
V_TOTAL NUMBER;
V_CANT_REVERSO NUMBER;
V_TOTAL_REVERSO NUMBER;
vr_Regitro ACUM_TRANSAC_CUENTA%ROWTYPE;
V_CANAL VARCHAR2(20);
V_PERIODO NUMBER;
V_CODIGO_EF NUMBER;
V_EMISOR NUMBER;
V_CUENTA NUMBER;
V_CANTIDAD NUMBER;
PROCEDURE PL_ACTUALIZAR AS
BEGIN
vr_Regitro.CANTIDAD := vr_Regitro.CANTIDAD + v_cantidad;
vr_Regitro.FECHA_ACTUALIZACION := SYSTIMESTAMP;
-- vr_Regitro.Total:=vr_Regitro.Total+v_total;
-- vr_Regitro.Cant_Reverso:=vr_Regitro.Cant_Reverso+v_cant_reverso;
-- vr_Regitro.Total_Reverso:=vr_Regitro.Total_Reverso+v_total_reverso;
UPDATE ACUM_TRANSAC_CUENTA a
SET A.CANTIDAD = vr_Regitro.CANTIDAD,
A.FECHA_ACTUALIZACION = vr_Regitro.FECHA_ACTUALIZACION
--a.total=vr_Regitro.Total,
-- a.cant_reverso=vr_Regitro.Cant_Reverso,
-- a.total_reverso=vr_Regitro.Total_Reverso
WHERE A.PERIODO = V_PERIODO
AND A.CUENTA = V_CUENTA
AND a.id_cargo_tran = pi_id_cargo;
COMMIT;
EXCEPTION
WHEN OTHERS THEN
ROLLBACK;
END;
FUNCTION FN_GET_CUENTA (P_TARJETA IN VARCHAR2) RETURN NUMBER AS
v_CUENTA_IN NUMBER;
BEGIN
SELECT MAX (T.numero_cuenta) CUENTA
INTO v_CUENTA_IN
FROM creditopy.tarjetas t
WHERE t.tarjeta = creditopy.fc_pan2cripto(P_TARJETA);
-- and c.numero_cuenta= t.numero_cuenta;
RETURN v_CUENTA_IN;
END;
PROCEDURE pl_insert AS
BEGIN
SELECT ACUM_TRANSAC_CUENTA_SEQ.NEXTVAL seq INTO V_ID_ACUM FROM dual;
vr_Regitro.ID_ACUM := V_ID_ACUM;
-- vr_Regitro.CANAL := V_CANAL;
vr_Regitro.PERIODO := V_PERIODO;
-- vr_Regitro.CODIGO_EF := V_CODIGO_EF;
-- vr_Regitro.EMISOR := V_EMISOR;
vr_Regitro.CUENTA := V_CUENTA;
vr_Regitro.CANTIDAD := v_cantidad;
vr_Regitro.FECHA_ACTUALIZACION := SYSTIMESTAMP;
vr_Regitro.Id_Cargo_Tran := pi_id_cargo;
--vr_Regitro.Tipo_Operacion:=pi_tipo_operacion;
--vr_Regitro.Total:=v_total;
-- vr_Regitro.Cant_Reverso:=v_cant_reverso;
--vr_Regitro.Total_Reverso:=v_total_reverso;
INSERT INTO ACUM_TRANSAC_CUENTA VALUES vr_Regitro;
COMMIT;
EXCEPTION
WHEN OTHERS THEN
PL_ACTUALIZAR;
END;
BEGIN
IF LENGTH(PI_CUENTA)=16 THEN
V_CUENTA := FN_GET_CUENTA(PI_CUENTA);
ELSE
V_CUENTA := PI_CUENTA;
END IF;
IF pi_signo_operacion = '-' THEN
-- V_CANAL := pi_canal;
V_PERIODO := to_char(pi_fecha_operacion, 'yyyymm'); --periodo actual
-- V_CODIGO_EF :=PI_EF_ORIGINANTE;
-- V_EMISOR := PI_EMISOR;
--V_CUENTA := PI_CUENTA;
V_CANTIDAD := -1;
-- V_TIPO_OPERACION := pi_tipo_operacion;
-- V_TOTAL := pi_monto*-1;
-- V_CANT_REVERSO := 1;
-- V_TOTAL_REVERSO := pi_monto;
ELSE
-- V_CANAL := pi_canal;
V_PERIODO := to_char(pi_fecha_operacion, 'yyyymm'); --periodo actual
-- V_CODIGO_EF :=PI_EF_ORIGINANTE;
-- V_EMISOR := PI_EMISOR;
--V_CUENTA := PI_CUENTA;
V_CANTIDAD := 1; --pi_cantidad;
--V_TIPO_OPERACION := pi_tipo_operacion;
--V_TOTAL := pi_monto;
--V_CANT_REVERSO := 0;
-- V_TOTAL_REVERSO := 0;
END IF;
-- begin
SELECT *
INTO vr_Regitro
FROM ACUM_TRANSAC_CUENTA a
WHERE A.PERIODO = V_PERIODO
AND A.CUENTA = V_CUENTA
AND A.ID_CARGO_TRAN = PI_ID_CARGO
FOR UPDATE;
PL_ACTUALIZAR;
COMMIT;
EXCEPTION
WHEN NO_DATA_FOUND THEN
pl_insert;
WHEN OTHERS THEN
ROLLBACK;
END PR_ACUMULAR_TRX_DEBITO;
-----------------
-----------------
-----------------------
------------------------
/*
INFO. PROCEDIMIENTO PARA SETEAR ACEPTACION DE CONDICIONES DE COMERCIOS
*/
/****************************************************************************************************
AUTOR: FELICIANO AMARILLA
FECHA: 30/10/2023
PROPÓSITO: PROCEDIMIENTO PARA SETEAR ACEPTACION DE CONDICIONES DE COMERCIOSOS
******************************************************************************************************/
PROCEDURE PR_SET_CONDICIONES_COMERCIOS(P_COD_COMERCIO IN NUMBER,
P_USUARIO IN VARCHAR2,
P_CODRETORNO OUT NUMBER,
P_MSGRETORNO OUT VARCHAR2,
P_SQLCODE OUT NUMBER,
P_SQLERRN OUT VARCHAR2) IS
V_ID_REG NUMBER;
BEGIN
BEGIN
SELECT ID_COND_COMERCIO
INTO V_ID_REG
FROM CREDITOPY.DOCUMENTOS_COMERCIOS
WHERE COD_COMERCIO = P_COD_COMERCIO;
IF V_ID_REG IS NOT NULL THEN
UPDATE CREDITOPY.DOCUMENTOS_COMERCIOS
SET FECHA_UPD = SYSDATE
WHERE COD_COMERCIO = P_COD_COMERCIO;
-- COMMIT;
END IF;
EXCEPTION
WHEN NO_DATA_FOUND THEN
NULL;
INSERT INTO CREDITOPY.DOCUMENTOS_COMERCIOS
(ID_COND_COMERCIO,
COD_COMERCIO,
USER_COMERCIO,
FECHA_ACEPT,
--FECHA_UPD,
ID_TIPO_DOC)
VALUES
(SEQ_DOCUMENTOS_COMERCIOS.NEXTVAL,
P_COD_COMERCIO,
P_USUARIO,
SYSDATE,
--FECHA_UPD,
--ID_TIPO_DOC
1);
END;
P_CODRETORNO := 0;
P_MSGRETORNO := 'OK';
COMMIT;
P_SQLCODE := SQLCODE;
P_SQLERRN := SQLERRM;
EXCEPTION
WHEN OTHERS THEN
P_CODRETORNO := -1;
P_MSGRETORNO := 'Error en pr_set_condiciones_comercios';
P_SQLCODE := SQLCODE;
P_SQLERRN := SQLERRM;
END PR_SET_CONDICIONES_COMERCIOS;
-----------------
------
/*
INFO. PROCEDIMIENTO PARA ENCAPSULAR PETICION DE CARGOS DE DEBITOS DE DIMO
*/
/****************************************************************************************************
AUTOR: FELICIANO AMARILLA
FECHA: 02/10/2023
PROPÓSITO: PROCEDIMIENTO QUE DEVUELVE LOS DATOS DEL CARGO PARA DIMO
******************************************************************************************************/
PROCEDURE sp_CargoTxsDimo(--PI_FECHA_OPERACION IN DATE,
PI_CANAL IN VARCHAR2,
PI_TIPO_TRANSACCION IN VARCHAR2,
PI_COD_SERVICIO IN VARCHAR2,
PI_EF_ORIGINANTE IN NUMBER,
PI_CUENTA_ORIGINANTE IN VARCHAR2,
PI_TIPO_CUENTA_ORIGEN IN VARCHAR2,
PI_EF_DESTINATARIO IN NUMBER,
PI_CUENTA_DESTINATARIO IN VARCHAR2,
PI_TIPO_CUENTA_DESTINO IN VARCHAR2,
PI_MONTO_TRANSACCION IN NUMBER,
PO_SQLCODE OUT NUMBER,
PO_SQLERRM OUT VARCHAR2,
po_cursor OUT SYS_REFCURSOR) IS
V_SQLCODE NUMBER;
V_SQLERRM VARCHAR2(4000);
V_PAGADOR VARCHAR2(4000);
V_MONTO_CARGO NUMBER;
V_RUBRO_CARGO NUMBER;
V_GLOSA_PARA_USUARIO VARCHAR2(4000);
V_ID_CARGO NUMBER;
V_ID_RANGO NUMBER;
V_CURSOR SYS_REFCURSOR;
V_EMISOR_CABAL_ORIGINANTE NUMBER;
V_AFINIDAD_CABAL_ORIGINANTE NUMBER;
V_CARTERA_CABAL_ORIGINANTE NUMBER;
FUNCTION FN_GET_EMISOR_CABAL(VN_TARJETA IN VARCHAR2) RETURN NUMBER IS
VN_EMISOR NUMBER;
BEGIN
SELECT T.EMISOR
INTO VN_EMISOR
FROM CREDITOPY.TARJETAS T
WHERE T.TARJETA = CREDITOPY.FC_PAN2CRIPTO(PI_CUENTA_ORIGINANTE);
RETURN VN_EMISOR;
EXCEPTION
WHEN NO_DATA_FOUND THEN
VN_EMISOR := 0;
RETURN VN_EMISOR;
WHEN OTHERS THEN
RAISE;
END FN_GET_EMISOR_CABAL;
FUNCTION fn_get_afinidad RETURN NUMBER IS
v_afinidad NUMBER;
BEGIN
SELECT c.grupo_afinidad
INTO v_afinidad
FROM creditopy.tarjetas t, creditopy.cuentas c
WHERE t.tarjeta = creditopy.fc_pan2cripto(PI_CUENTA_ORIGINANTE)
and c.numero_cuenta= t.numero_cuenta;
RETURN v_afinidad;
EXCEPTION
WHEN NO_DATA_FOUND THEN
v_afinidad := 0;
RETURN v_afinidad;
WHEN OTHERS THEN
RAISE;
END fn_get_afinidad;
FUNCTION fn_get_cartera RETURN NUMBER IS
v_cartera NUMBER;
BEGIN
SELECT c.cartera
INTO v_cartera
FROM creditopy.tarjetas t, creditopy.cuentas c
WHERE t.tarjeta = creditopy.fc_pan2cripto(PI_CUENTA_ORIGINANTE)
and c.numero_cuenta= t.numero_cuenta;
RETURN v_cartera;
EXCEPTION
WHEN NO_DATA_FOUND THEN
v_cartera := 0;
RETURN v_cartera;
WHEN OTHERS THEN
RAISE;
END fn_get_cartera;
BEGIN
PR_LOGGING('CARGO_DIMO',
'01',
'PKG_DIMO_CEIBO.sp_CargoTxsDimo. PARAMETROS RECIBIDOS.' ||
' PI_CANAL:' ||PI_CANAL ||
' PI_TIPO_TRANSACCION:' ||PI_TIPO_TRANSACCION ||
' PI_COD_SERVICIO:' ||PI_COD_SERVICIO ||
' PI_EF_ORIGINANTE:' ||PI_EF_ORIGINANTE ||
' PI_CUENTA_ORIGINANTE:' ||PI_CUENTA_ORIGINANTE ||
' PI_TIPO_CUENTA_ORIGEN:' ||PI_TIPO_CUENTA_ORIGEN ||
' PI_EF_DESTINATARIO:' ||PI_EF_DESTINATARIO ||
' PI_CUENTA_DESTINATARIO:' ||PI_CUENTA_DESTINATARIO ||
' PI_TIPO_CUENTA_DESTINO:' ||PI_TIPO_CUENTA_DESTINO ||
' PI_MONTO_TRANSACCION:' ||PI_MONTO_TRANSACCION ||
'FIN');
-- VR_CARGO_X_TR.Emisor_Cabal_Destinatario := fn_get_emisor_cabal(PI_CUENTA_DESTINATARIO);
V_EMISOR_CABAL_ORIGINANTE := fn_get_emisor_cabal(PI_CUENTA_ORIGINANTE);
V_AFINIDAD_CABAL_ORIGINANTE := fn_get_afinidad;
V_CARTERA_CABAL_ORIGINANTE := fn_get_cartera;
--PKG_DIMO_CEIBO_feli.PR_RETORNA_CARGO_DEBITO_v2
PKG_DIMO_CEIBO.PR_RETORNA_CARGO_DEBITO (PI_FECHA_OPERACION => SYSDATE,
PI_CANAL => PI_CANAL, --CEIBO (POS, ATM,)/ SICOOP
PI_CUENTA_ORIGINANTE => PI_CUENTA_ORIGINANTE, --CEIBO / SICOOP
PI_EF_ORIGINANTE => PI_EF_ORIGINANTE, --CEIBO / SICOOP
PI_MONTO_TRANSACCION => PI_MONTO_TRANSACCION, --CEIBO / SICOOP
PI_TIPO_TRANSACCION => PI_TIPO_TRANSACCION, -- SICOOP
PI_COD_SERVICIO => PI_COD_SERVICIO, -- SICOOP
PI_TIPO_CUENTA_ORIGEN => PI_TIPO_CUENTA_ORIGEN, -- SICOOP
PI_EF_DESTINATARIO => PI_EF_DESTINATARIO, -- SICOOP
PI_CUENTA_DESTINATARIO => PI_CUENTA_DESTINATARIO, -- SICOOP
PI_TIPO_CUENTA_DESTINO => PI_TIPO_CUENTA_DESTINO, -- SICOOP
PI_EMISOR => V_EMISOR_CABAL_ORIGINANTE, --CEIBO / SICOOP
PI_AFINIDAD => V_AFINIDAD_CABAL_ORIGINANTE, --CEIBO / SICOOP
PI_CARTERA => V_CARTERA_CABAL_ORIGINANTE, --CEIBO / SICOOP
PI_RAMO_COMERCIO => NULL, --CEIBO
PI_COD_COMERCIO => NULL, --CEIBO
PO_SQLCODE =>PO_SQLCODE, -- V_SQLCODE,
PO_SQLERRM =>PO_SQLERRM, -- V_SQLERRM,
P_PAGADOR => V_PAGADOR,
--P_APLICACION_DEL_CARGO OUT VARCHAR2,
P_MONTO_CARGO => V_MONTO_CARGO,
P_RUBRO_CARGO => V_RUBRO_CARGO,
-- P_CODIGO_IMPUESTO OUT NUMBER,
P_ID_CARGO => V_ID_CARGO,
P_ID_RANGO => V_ID_RANGO,
P_GLOSA_PARA_USUARIO => V_GLOSA_PARA_USUARIO,
PO_CURSOR => PO_CURSOR);
--P_PAGADOR :=V_PAGADOR ;
--P_MONTO_CARGO := V_MONTO_CARGO;
--P_RUBRO_CARGO := V_RUBRO_CARGO;
--P_ID_CARGO := V_ID_CARGO;
--P_ID_RANGO := V_ID_RANGO;
--P_GLOSA_PARA_USUARIO := V_GLOSA_PARA_USUARIO;
EXCEPTION
WHEN OTHERS THEN
PR_LOGGING('CARGO_DIMO',
'01',
'ERROR EN PKG_DIMO_CEIBO.sp_CargoTxsDimo. PARAMETROS RECIBIDOS.' ||
' PI_CANAL:' ||PI_CANAL ||
' PI_TIPO_TRANSACCION:' ||PI_TIPO_TRANSACCION ||
' PI_COD_SERVICIO:' ||PI_COD_SERVICIO ||
' PI_EF_ORIGINANTE:' ||PI_EF_ORIGINANTE ||
' PI_CUENTA_ORIGINANTE:' ||PI_CUENTA_ORIGINANTE ||
' PI_TIPO_CUENTA_ORIGEN:' ||PI_TIPO_CUENTA_ORIGEN ||
' PI_EF_DESTINATARIO:' ||PI_EF_DESTINATARIO ||
' PI_CUENTA_DESTINATARIO:' ||PI_CUENTA_DESTINATARIO ||
' PI_TIPO_CUENTA_DESTINO:' ||PI_TIPO_CUENTA_DESTINO ||
' PI_MONTO_TRANSACCION:' ||PI_MONTO_TRANSACCION ||
'FIN');
END sp_CargoTxsDimo;
-----------
/*
INFO. PROCEDIMIENTO PARA CAMBIAR EL NUMERO DE TICKET
*/
/****************************************************************************************************
AUTOR: OCTAVIO VILLASANTI
FECHA: 19/07/2024
PROPÓSITO: PROCEDIMIENTO QUE ACTUALIZA EL NUMERO DE TICKET EN LA TABLA UUID Y OLPY
**************************************************************************************************** */
PROCEDURE pr_actualizar_ticket_sicoop(cp_ticket in VARCHAR2,
cp_uid_session in VARCHAR2,
np_codigo out number,
cp_descripcion out VARCHAR2) IS
vc_tarjeta VARCHAR2(20);
vc_ticket VARCHAR2(16);
BEGIN
-- Buscar en SICOOP_UUID
SELECT NUM_CUENTA_ORIGEN, NRO_TICKET_RRN
INTO vc_tarjeta, vc_ticket
FROM SICOOP_UUID@OLPY
WHERE IDSESION_UUID = cp_uid_session;
--Encriptar tarjeta
vc_tarjeta := fc_pan2cripto(vc_tarjeta);
-- Actualizar LOG_TRANSACC_CR
UPDATE LOG_TRANSACC_CR@OLPY
SET NRO_TICKET = cp_ticket
WHERE NRO_TARJETA = vc_tarjeta
AND NRO_TICKET = vc_ticket;
-- Verificar si se actualizo LOG_TRANSACC_CR
IF SQL%ROWCOUNT = 0 THEN
np_codigo := 2;
cp_descripcion := 'No se actualizo el registro en LOG_TRANSACC_CR.';
ROLLBACK;
RETURN;
END IF;
-- Actualizar SICOOP_UUID
UPDATE SICOOP_UUID@OLPY
SET NRO_TICKET_RRN = cp_ticket
WHERE IDSESION_UUID = cp_uid_session
AND NRO_TICKET_RRN = vc_ticket;
-- Verificar si se actualizo SICOOP_UUID
IF SQL%ROWCOUNT = 0 THEN
np_codigo := 3;
cp_descripcion := 'No se actualizo el registro en SICOOP_UUID.';
ROLLBACK;
RETURN;
END IF;
-- Confirmar las transacciones
COMMIT;
np_codigo := 0;
cp_descripcion := 'Operacion completada correctamente. Codigo de salida: 0';
EXCEPTION
WHEN NO_DATA_FOUND THEN
np_codigo := 1;
cp_descripcion := 'No se encontraron registros para este UUID.';
WHEN TOO_MANY_ROWS THEN
np_codigo := 4;
cp_descripcion := 'Existe mas de un registro para este UUID.';
WHEN OTHERS THEN
np_codigo := SQLCODE;
cp_descripcion := SQLERRM;
ROLLBACK;
END;
-----------
BEGIN
-- Initialization
--sp_setearValoresSession;
PV_BITACORA_ID := GET_PROCESO_ID;
PV_USUARIO := NVL(PV_USUARIO, CC_USUARIO_DIMO);
END PKG_DIMO_CEIBO;