trxres.cpp

ISO 8583 with c++ for financial transaction standard

            sprintf(szYYYYMMDD_Cap,pszDATE_Mask, cnYearDigits , nYear, isoFields.field17.chMMDD,
                isoFields.field17.chMMDD+2 );
    }
    // Ok, returnar
    return TRUE;
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Verifica si el reverso es por rta. tardia de nuestro host hacia el switch financiero
WORD TrxBaseResolution::VerifyReversalForLateResponse(boolean_t bIsReversal)
{
    // Es reverso ?
    if( (bIsReversal == is_true) && isoMsg.IsValidReversal() )
    {
        // Codigo de reverso si hubiera
        WORD wRevCode = antoi(isoFields.field39.chRespCde,2);
        // Verificar campos ISO cargados
        if(is_false == isoFields.bLoaded)
            ProcessInit(); // Parsear y cargar campos ISO en estructuras            
        ///////////////////////////////////////////////////////////////////////////////
        // REGLA DE REVERSOS : Si existe mas de 1 reverso : 
        // El 1ro es siempre por timeout (68) y se aplica al requerimiento 0200,
        // pero no a los forzados 220
        // El 2do, si el codigo es distinto de 68, se aplica al forzado 220.
        // El 2do, si el codigo es igual a 68 y es "REVERSAL FOR LATE", se aplica
        // al 0210, pero si no contiene "REVERSAL FOR LATE", se aplica al forzado, 220.
        // El 3er reverso se aplica.
        ///////////////////////////////////////////////////////////////////////////////
        if((strstr(isoFields.field43.chData, 
            "REVERSAL FOR LATE/UNSOL RESPONSE") != NULL)
            && 
            (wRevCode == CISO_REV_TIMEOUT))
            // TIMEOUT para REQUERIMIENTOS (200)
            return CISO_REV_TIMEOUT; // 68
        else if((strstr(isoFields.field43.chData, 
            "REVERSAL FOR LATE/UNSOL RESPONSE") == NULL)
            && 
            (wRevCode == CISO_REV_TIMEOUT))
            // TIMEOUT para FORZADO (220)
            return CISO_REV_TIMEOUT_ADVICE ; // 168
        else
            // OTROS CODIGOS DE REVERSOS
            return wRevCode ;
    }
    else
        // NO ES REVERSO
        return 0;
};

///////////////////////////////////////////////////////////////////////
// Extraer el TRACK-2 desde el campo TRACK-2 ISO, hasta el FIELD SEPARATOR
PCHAR TrxBaseResolution::ExtractCardnumFromTrack2( const TRACK2_ISO *pstTrack2ISO)
{    
    char *pszSeparator    = NULL,
         *pszBegin        = (char *)pstTrack2ISO,
         chAfterSeparator = 'N'; /* reemplaza despues del separador ? */
    // Variable de soporte, estatica y local, ya que se retorna a la salida de la funcion
    static TRACK2_ISO    stTrack2Cardnum;

    // Precondicion
    if(!pstTrack2ISO)
        return NULL;


    ///////////////////////////////////////////////////////////////////////////////////
    // Buscar separador NO NUMERICO, primer digito despues del nro. de tarjeta
    // Limpiar con blancos los digitos DETRAS del separador no numerico
    for( pszSeparator = (char *)pstTrack2ISO;
        // Mientras haya caracteres y la longitud no exceda el maximo ISO de 37 digitos
        pszSeparator != NULL       &&    /* no sea nulo */
        pszSeparator >= pszBegin   &&    /* sea mayor al inicio del track-2 */
        (pszSeparator - pszBegin) <= 37; /* hasta 37 digitos */
        pszSeparator++ )
    {
        // Si es separador o digito numerico, reemplazarlo con BLANCO
        if((*pszSeparator >= '0' && *pszSeparator <= '9'))        // ASCII-48 a 57
        {
            /* Si ya paso el separador de TRACK, reemplazar igual */
            if( 'Y' == chAfterSeparator )
                (*pszSeparator) = ' ';
            else
                continue;
        }
        else if((*pszSeparator >= 'A' && *pszSeparator <= 'Z')) // ASCII-65 a 90
        {
            chAfterSeparator = 'Y';
            (*pszSeparator) = ' ';
        }
        else if((*pszSeparator >= '!' && *pszSeparator <= '/')) // ASCII-33 a 48
        {
            chAfterSeparator = 'Y';
            (*pszSeparator) = ' ';
        }
        else if((*pszSeparator) == '=') // ASCII-61
        {
            chAfterSeparator = 'Y';
            (*pszSeparator) = ' ';
        }
        else
        {
            chAfterSeparator = 'Y';
            (*pszSeparator) = ' ';
        }; /* end-if */
    }; /* end-for */
    ///////////////////////////////////////////////////////////////////////////////////
    // Retornar el CARD-NUM desde el TRACK-2
    stTrack2Cardnum = (*pstTrack2ISO);
    stTrack2Cardnum.stTrack2.chFiller[0] = 0x00;
    return (stTrack2Cardnum.stTrack2.chData);
};
/////////////////////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////////////////////
// Inicio de Procesamiento de transacciones en general
WORD TrxBaseResolution::ProcessInit(void)
{
    WORD  wLen     = 0;
    PBYTE pbBuffer = NULL;

    // Inicializar los campos extractados del mensaje ISO
    memset( &isoFields, ' ', sizeof isoFields);
    // Senal de carga a falso
    isoFields.bLoaded = is_false;

    // Extractar los campos del mensaje y dejarlos listos para usar en cada transaccion
    // Desde el campo siguiente el SECONDARY-BITMAP, que es el campo 1.
    for(short iIndex=2; iIndex < 128; iIndex++)
    {
        switch(iIndex)
        {        
        case 3 : pbBuffer = (PBYTE)&isoFields.field3; wLen = sizeof(isoFields.field3); break;
        case 4 : pbBuffer = (PBYTE)&isoFields.field4; wLen = sizeof(isoFields.field4); break;
        case 5 : pbBuffer = (PBYTE)&isoFields.field5; wLen = sizeof(isoFields.field5); break;
        case 6 : pbBuffer = (PBYTE)&isoFields.field6; wLen = sizeof(isoFields.field6); break;
        case 7 : pbBuffer = (PBYTE)&isoFields.field7; wLen = sizeof(isoFields.field7); break;
        case 8 : pbBuffer = (PBYTE)&isoFields.field8; wLen = sizeof(isoFields.field8); break;
        case 9 : pbBuffer = (PBYTE)&isoFields.field9; wLen = sizeof(isoFields.field9); break;
        case 10: pbBuffer = (PBYTE)&isoFields.field10; wLen = sizeof(isoFields.field10); break;
        case 11: pbBuffer = (PBYTE)&isoFields.field11; wLen = sizeof(isoFields.field11); break;
        case 12: pbBuffer = (PBYTE)&isoFields.field12; wLen = sizeof(isoFields.field12); break;
        case 13: pbBuffer = (PBYTE)&isoFields.field13; wLen = sizeof(isoFields.field13); break;
        case 14: pbBuffer = (PBYTE)&isoFields.field14; wLen = sizeof(isoFields.field14); break;
        case 15: pbBuffer = (PBYTE)&isoFields.field15; wLen = sizeof(isoFields.field15); break;
        case 16: pbBuffer = (PBYTE)&isoFields.field16; wLen = sizeof(isoFields.field16); break;
        case 17: pbBuffer = (PBYTE)&isoFields.field17; wLen = sizeof(isoFields.field17); break;
        case 18: pbBuffer = (PBYTE)&isoFields.field18; wLen = sizeof(isoFields.field18); break;
        case 19: pbBuffer = (PBYTE)&isoFields.field19; wLen = sizeof(isoFields.field19); break;
        case 20: pbBuffer = (PBYTE)&isoFields.field20; wLen = sizeof(isoFields.field20); break;
        case 21: pbBuffer = (PBYTE)&isoFields.field21; wLen = sizeof(isoFields.field21); break;
        case 22: pbBuffer = (PBYTE)&isoFields.field22; wLen = sizeof(isoFields.field22); break;
        case 23: pbBuffer = (PBYTE)&isoFields.field23; wLen = sizeof(isoFields.field23); break;
        case 24: pbBuffer = (PBYTE)&isoFields.field24; wLen = sizeof(isoFields.field24); break;
        case 25: pbBuffer = (PBYTE)&isoFields.field25; wLen = sizeof(isoFields.field25); break;
        case 26: pbBuffer = (PBYTE)&isoFields.field26; wLen = sizeof(isoFields.field26); break;
        case 27: pbBuffer = (PBYTE)&isoFields.field27; wLen = sizeof(isoFields.field27); break;
        case 28: pbBuffer = (PBYTE)&isoFields.field28; wLen = sizeof(isoFields.field28); break;
        case 29: pbBuffer = (PBYTE)&isoFields.field29; wLen = sizeof(isoFields.field29); break;
        case 30: pbBuffer = (PBYTE)&isoFields.field30; wLen = sizeof(isoFields.field30); break;
        case 31: pbBuffer = (PBYTE)&isoFields.field31; wLen = sizeof(isoFields.field31); break;
        case 32: pbBuffer = (PBYTE)&isoFields.field32; wLen = sizeof(isoFields.field32); break;
        case 33: pbBuffer = (PBYTE)&isoFields.field33; wLen = sizeof(isoFields.field33); break;
        case 34: pbBuffer = (PBYTE)&isoFields.field34; wLen = sizeof(isoFields.field34); break;
        case 35: pbBuffer = (PBYTE)&isoFields.field35; wLen = sizeof(isoFields.field35); break;
        case 36: pbBuffer = (PBYTE)&isoFields.field36; wLen = sizeof(isoFields.field36); break;
        case 37: pbBuffer = (PBYTE)&isoFields.field37; wLen = sizeof(isoFields.field37); break;
        case 38: pbBuffer = (PBYTE)&isoFields.field38; wLen = sizeof(isoFields.field38); break;
        case 39: pbBuffer = (PBYTE)&isoFields.field39; wLen = sizeof(isoFields.field39); break;
        case 40: pbBuffer = (PBYTE)&isoFields.field40; wLen = sizeof(isoFields.field40); break;
        case 41: pbBuffer = (PBYTE)&isoFields.field41; wLen = sizeof(isoFields.field41); break;
        case 42: pbBuffer = (PBYTE)&isoFields.field42; wLen = sizeof(isoFields.field42); break;
        case 43: pbBuffer = (PBYTE)&isoFields.field43; wLen = sizeof(isoFields.field43); break;
        case 44: pbBuffer = (PBYTE)&isoFields.field44; wLen = sizeof(isoFields.field44); break;
        case 45: pbBuffer = (PBYTE)&isoFields.field45; wLen = sizeof(isoFields.field45); break;
        case 46: pbBuffer = (PBYTE)&isoFields.field46; wLen = sizeof(isoFields.field46); break;
        case 47: pbBuffer = (PBYTE)&isoFields.field47; wLen = sizeof(isoFields.field47); break;
        case 48: pbBuffer = (PBYTE)&isoFields.field48; wLen = sizeof(isoFields.field48); break;
        case 49: pbBuffer = (PBYTE)&isoFields.field49; wLen = sizeof(isoFields.field49); break;
        case 50: pbBuffer = (PBYTE)&isoFields.field50; wLen = sizeof(isoFields.field50); break;
        case 51: pbBuffer = (PBYTE)&isoFields.field51; wLen = sizeof(isoFields.field51); break;
        case 52: pbBuffer = (PBYTE)&isoFields.field52; wLen = sizeof(isoFields.field52); break;
        case 53: pbBuffer = (PBYTE)&isoFields.field53; wLen = sizeof(isoFields.field53); break;
        case 54: pbBuffer = (PBYTE)&isoFields.field54; wLen = sizeof(isoFields.field54); break;
        case 55: pbBuffer = (PBYTE)&isoFields.field55; wLen = sizeof(isoFields.field55); break;
        case 56: pbBuffer = (PBYTE)&isoFields.field56; wLen = sizeof(isoFields.field56); break;
        case 57: pbBuffer = (PBYTE)&isoFields.field57; wLen = sizeof(isoFields.field57); break;
        case 58: pbBuffer = (PBYTE)&isoFields.field58; wLen = sizeof(isoFields.field58); break;
        case 59: pbBuffer = (PBYTE)&isoFields.field59; wLen = sizeof(isoFields.field59); break;
        case 60: pbBuffer = (PBYTE)&isoFields.field60; wLen = sizeof(isoFields.field60); break;
        case 61: pbBuffer = (PBYTE)&isoFields.field61; wLen = sizeof(isoFields.field61); break;
        case 62: pbBuffer = (PBYTE)&isoFields.field62; wLen = sizeof(isoFields.field62); break;
        case 63: pbBuffer = (PBYTE)&isoFields.field63; wLen = sizeof(isoFields.field63); break;
        case 64: pbBuffer = (PBYTE)&isoFields.field64; wLen = sizeof(isoFields.field64); break;
        case 90: pbBuffer = (PBYTE)&isoFields.field90; wLen = sizeof(isoFields.field90); break;
        case 95: pbBuffer = (PBYTE)&isoFields.field95; wLen = sizeof(isoFields.field95); break;
        case 99: pbBuffer = (PBYTE)&isoFields.field99; wLen = sizeof(isoFields.field99); break;
        case 100: pbBuffer = (PBYTE)&isoFields.field100; wLen = sizeof(isoFields.field100); break;
        case 102: pbBuffer = (PBYTE)&isoFields.field102; wLen = sizeof(isoFields.field102); break;
        case 103: pbBuffer = (PBYTE)&isoFields.field103; wLen = sizeof(isoFields.field103); break;
        case 120: pbBuffer = (PBYTE)&isoFields.field120; wLen = sizeof(isoFields.field120); break;
        case 122: pbBuffer = (PBYTE)&isoFields.field122; wLen = sizeof(isoFields.field122); break;
        case 123: pbBuffer = (PBYTE)&isoFields.field123; wLen = sizeof(isoFields.field123); break;
        case 125: pbBuffer = (PBYTE)&isoFields.field125; wLen = sizeof(isoFields.field125); break;
        case 126: pbBuffer = (PBYTE)&isoFields.field126; wLen = sizeof(isoFields.field126); break;
        case 127: pbBuffer = (PBYTE)&isoFields.field127; wLen = sizeof(isoFields.field127); break;
        default: wLen = 0; pbBuffer = NULL; break;
        }
        
        if(!isoMsg.GetField( iIndex, &wLen, pbBuffer, wLen ))
        {
        }
    }
    // Senal de carga a verdadero
    isoFields.bLoaded = is_true;
    // Ok, APROBADO por default
    return 0;
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////