extrtrx.cpp

ISO 8583 with c++ for financial transaction standard

        antoi(isoFields.field3.uProcCde.stTranCde.chTran_Cde,2)==B24_OPCODE_BUYING_DEVOLUTION_CANCEL ||
        // Anul. Devolucion compra (debito NO se procesa)
        antoi(isoFields.field3.uProcCde.stTranCde.chTran_Cde,2)==B24_OPCODE_BUYING_PREAUTH ||
        // Preautorizacion NO se procesa
        antoi(isoFields.field3.uProcCde.stTranCde.chTran_Cde,2)==B24_OPCODE_BUYING_PREAUTH_CANCEL )
        // Anul. Preautorizacion NO se procesa
    {
        glLogg.Put("############# PARSEO DE TRX EXTRACT-ATM-POS #############\n");    
        glLogg.Put("Devolucion/Anul.Devol.Compra se procesan BATCH, resultado:<%i>\n", wRespCde);            
        ///////////////////////////////////////////////////////////////////////
        // Formatear campo ISO #44, RESP_DATA, saldo y disponible
        FormatField44_RESP_DATA( NULL, NULL );
        // Formatear campo ISO #122, SECNDRY_RSRVD3_PRVT
        FormatField122_SECNDRY_RSRVD3_PRVT();
        // Formatear campo ISO #123, SECNDRY_RSRVD4_PRVT, "DEPOSIT AMMOUNT"
        FormatField123_SECNDRY_RSRVD4_PRVT();
        // Borrar campos no validos en la rta. : 43,48,52,63
        isoMsg.DeleteField ( 43 );
        isoMsg.DeleteField ( 48 );
        isoMsg.DeleteField ( 52 );
        isoMsg.DeleteField ( 63 );
        // Borrar campo 120, OPCIONALMENTE PODRIAN NO VENIR EN UN REQUERIMIENTO 
        isoMsg.DeleteField ( 120 );        
        glLogg.Put("### Fin ###\n");
        // Denegada, no se procesa, segun sea ON/OFF, sera 91 o 06
        return (wRespCde);        
        ///////////////////////////////////////////////////////////////////////
    }    
    else
        // Retornar lo que este implementado por omision
        return ProcessGeneric();
    /////////////////////////////////////////////////////////
}
WORD TrxResEXTRACT::ProcessAutServicePayment(WORD wCause,boolean_t bIsRvsl)    // Pagos Automatico de Servs.
{
    // Metodo generico de procesamiento de transaccion
    return ProcessGeneric();
}
WORD TrxResEXTRACT::ProcessCreditNote(WORD wCause,boolean_t bIsRvsl)        // Nota de credito
{
    // Metodo generico de procesamiento de transaccion
    return ProcessGeneric();
}
WORD TrxResEXTRACT::ProcessDebitNote(WORD wCause,boolean_t bIsRvsl)            // Nota de debito
{
    // Metodo generico de procesamiento de transaccion
    return ProcessGeneric();
}
WORD TrxResEXTRACT::ProcessReversal(WORD wCause)            // Reverso generico        
{
    //////////////////////////////////////////////////////////////////////
    // Respuesta default
    WORD wRespCde   = CISO_EXTERNAL_DECLINE_I;    
    WORD wRspCdeLen = 2;
    CHAR szRespCode[3] = {"21"}; // CISO_REV_HARDWARE_ERROR=21
    // Por default, ante reversos parciales, reversa completo el original y 
    // genera un nuevo movimiento por el monto realmente dispensado.
    // Si este comportamiento es distinto en el sistema siendo implementado,
    // simplemente re-definir este metodo virtual en la superclase que hereda
    // a esta clase,  y omitir este nuevo movimiento.
    const boolean_t bIMPACT_PARTIAL_REV = is_true;

    // Precondicion = Descomponer mensaje ISO-8583 en campos estructurados 
    wRespCde = ProcessInit();
    // Verificar TIMEOUT para FORZADO (220), y aplicar nuevo codigo de reversa (reverso triple)
    // Control de Reverso Triple : Similar al Reverso Doble, solo que se agregar el time-out 
    // del ATM, caso en que BASE24 vuelve a enviar un tercer reverso pero sobre el forzado
    // 220, con motivo de reverso en 68 y con leyenda "*** REVERSAL FOR LATE/UNSOL RESPONSE ***".
    // Controlado por HOST24, este motivo de reverso se cambia a 168, para diferenciarlo de un
    // time-out comun.
    if(VerifyReversalForLateResponse( is_true )==CISO_REV_TIMEOUT_ADVICE)
    {
        // Modificar codigo de reversa para que impacte el forzado
        // por CCISO_REV_HARDWARE_ERROR = 21
        isoMsg.SetField(39, &(wRspCdeLen=2), (PBYTE)szRespCode,    2 );
    };

    //////////////////////////////////////////////////
    // Metodo generico de procesamiento de transaccion
    wRespCde = ProcessGeneric();
    //////////////////////////////////////////////////

    ///////////////////////////////////////////////////////////////////////////////////
    // Si es REVERSO PARCIAl, y solamente en ese caso, debe re-generarse un movimiento
    // solo por el monto realmente dispensado, debitado o acreditado : Eso lo dice el 
    // campo #95 del mensaje ISO8583. El monto original se informa en el campo #4.
    // Entonces : Si el reverso completo fue OK...
    ///////////////////////////////////////////////////////////////////////////////////
    if( (CISO_APPROVED_I == wRespCde && is_true == bIMPACT_PARTIAL_REV)
        &&
        // Si es REVERSO PARCIAL, resp-cde=32
        (antoi(isoFields.field39.chRespCde,2)==CISO_REV_PARTIAL)            
        &&
        ////////////////////////////////////////////////////////////////////////////////////////////
        // NO SE REVERSA PARCIALMENTE EL FAST-CASH
        antoi(isoFields.field3.uProcCde.stTranCde.chTran_Cde,2)!=B24_OPCODE_BUYING_CASH_BACK
        &&
        antoi(isoFields.field3.uProcCde.stTranCde.chTran_Cde,2)!=B24_OPCODE_BUYING_CASH_BACK_CANCEL
        &&
        ////////////////////////////////////////////////////////////////////////////////////////////
        // Si DIFIERE el monto original del realmente dispensado... (PARTIAL RVSL)
        // (monto original es MAYOR o IGUAL al dispensado)
        (strncmp(isoFields.field4.chAmmount,isoFields.field95.chReversalAmmount,
                sizeof(isoFields.field4.chAmmount))>=0)            
        &&
        // Y el monto efectivamente dispensado NO es blancos
        (strncmp(isoFields.field95.chReversalAmmount, "            ",
                sizeof(isoFields.field95.chReversalAmmount))!=0) 
        &&
        // y NO sea ceros
        (strncmp(isoFields.field95.chReversalAmmount, "000000000000",
                sizeof(isoFields.field95.chReversalAmmount))!=0) 
      )
    {            
        // Copiar el monto dispensado como monto original, y...
        wRspCdeLen = 12;
        isoMsg.SetField(4,&(wRspCdeLen=12), (PBYTE)isoFields.field95.chReversalAmmount,12);
        // ...indicar que es un FORZADO (220)....
        isoMsg.SetMsgTypeId((PBYTE)CISO_MSGTYPE_FINANCIAL_ADV,4);
        // ...con MOTIVO DE FORZADO/REVERSO = 32...
        isoMsg.SetField(39,&(wRspCdeLen=2), (PBYTE)CEXTR_REV_PARTIAL, 2);
        // ...aplicar la transaccion por el monto realmente dispensado
        wRespCde = ProcessGeneric();
        /////////////////////////////////////////////////////////////////
        // ...volver a REVERSO (420), ya que la respuesta debe ser un 430        
        isoMsg.SetMsgTypeId((PBYTE)CISO_MSGTYPE_REVERSAL,4);
        /////////////////////////////////////////////////////////////////
    };
    ///////////////////////////////////////////////////////////////////////////////////
    return (wRespCde);

}


///////////////////////////////////////////////////////////////////////
// Procesamiento de Transacciones ATM EXTRACT genericas, no en particular.
///////////////////////////////////////////////////////////////////////
WORD TrxResEXTRACT::ProcessGeneric(void)
{    
    // Respuesta default, metodo base siempre RECHAZA la transaccion
    // Quien debe implementar la resolucion de la misma, es la clase
    // especializada....
    WORD wRespCode = CISO_EXTERNAL_DECLINE_I;

    ///////////////////////////////////////////////////////////////////
    // Verificar si fue rechazada y era un SAF que debia impactarse
    if ( (isoMsg.IsFinancialAdvice() || isoMsg.IsValidReversal() ) 
         && 
         ( wRespCode != CISO_SYSTEM_FAILURE_I && wRespCode != CISO_APPROVED_I)
        )
    {
        // Forzar el envio a SAF LOCAL cuando es SAF online que no 
        // pudo impactarse debido a cualquier tipo de error en el HOST.
        wRespCode = CISO_SYSTEM_FAILURE_I;
    };
    ///////////////////////////////////////////////////////////////////
    // Backup de resultado de ejecucion hacia la clase base
    wProcRespCde = wRespCode;        
    // Retornar codigo de rta.
    return (wRespCode);
}//end-ProcessGeneric



///////////////////////////////////////////////////////////////////////////////////
// Mapear codigo de respuesta EXTRACT hacia RED LINK    
// El codigo EXTRACT es de 7 digitos, tal que si todos son blancos es aprobada,
// y sino es un error de codigo alfanumerico que se mapea segun indican esta tablas
///////////////////////////////////////////////////////////////////////////////////
short TrxResEXTRACT::Mapear_RespCde_EXTRACT_REDLINK(char *szEXTRACT, char *szLINK, short nLen)
{
    // Precondicion     
    if(NULL == szEXTRACT || NULL == szLINK || nLen <= 0)
        // Postcondicion : 0=OK, -1=ERROR
        return (-1);
    // Segun codigo de error EXTRACT, mapear el respectivo Link en ISO8583:    
    switch( antoi(szEXTRACT,min(nLen,3)) )    
    {
        case 0  : /*  Falta de fondos en la cuenta  */ 
            strcpy( szLINK, CISO_APPROVED ); break; 
        default:   /* DEFAULT */
            strcpy( szLINK, CISO_GENERIC_ERROR);break; 
    };
    ////////////////////////////////////////////////////////////////
    // Postcondicion : 0=OK, -1=ERROR
    return (0);
};

//////////////////////////////////////////////////////////////////////////////////
// Mapeo de codigo de transaccion Red Link ISO hacia EXTRACT Red Link
//////////////////////////////////////////////////////////////////////////////////
short TrxResEXTRACT::Transformar_TranCde_EXTRACT_REDLINK(  msgEXTRACT *pextractBuff )
{
    // Variable de soporte, estatica y local, ya que se retorna a la salida de la funcion
    static char chBuffer[sizeof(PROCCDE_ISO)+1]= { 0x00 };
    // Puntero para struct-casting
    PROCCDE_ISO    *pstB24TranCode = (PROCCDE_ISO *)chBuffer;

    /* precondicion */
    if(!pextractBuff)
        return (-1);
    
    /*************************************************************************/
    /* Mapeo de codigo de transaccion Red Link ISO hacia EXTRACT Red Link    */
    /* utilizando un metodo de la clase base : "TranslateTranCode_ISO_B24"   */
    /*************************************************************************/
    strncpy( chBuffer,  pextractBuff->cuerpo.stTRAN_CDE.T_CDE, sizeof(pextractBuff->cuerpo.stTRAN_CDE));
    /* Pasar a STRING ALFANUMERICO, invocando metodo base "TranslateTranCode_ISO_B24" */
    strncpy( pextractBuff->cuerpo.stTRAN_CDE.T_CDE,              
             TranslateTranCode_ISO_B24( chBuffer ), sizeof(pextractBuff->cuerpo.stTRAN_CDE) );

    /* Postcondicion : Codigo de Transaccion Mapeado : 0=OK, -1=ERROR */
    return ( 0 );
};

///////////////////////////////////////////////////////////
// Verificar moneda de transaccion y cotizacion
// boolean_t *pbCrossXfer = es transferencia cruzada ?
// char chChangeOper  = 'C'=compra, 'V'=venta de moneda ?
// return boolean_t = Aplica tipo de cambio 'S','N' ?
///////////////////////////////////////////////////////////
boolean_t TrxResEXTRACT::Verificar_Cotizacion_y_Moneda(msgEXTRACT *pextractBuff , 
                                                    boolean_t *pbCrossXfer,
                                                    char *chChangeOper )
{
    boolean_t bApplyChange = is_false; /* inicialmente, no aplica tipo de cambio */
    boolean_t bCrossXfer   = is_false; /* transferencia cruzada ? */
    /* precondicion */
    if(!pextractBuff || !pbCrossXfer)
        return (is_false);


    /***********************************************************************************/
    /*