handle.cpre

商业银行前置系统

    bufclr(szTrack3);
    bufclr(szEntryMode);
    
    nSize = SIZE_ENTRYMODE;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_ENTRYMODE, szEntryMode,
                                  &nSize));

    if (memcmp(szEntryMode, "01", 2) == 0)
        return NORMAL;

    DETECT(memcmp(szEntryMode, "02", 2) == 0);

    nSize = SIZE_TRACK3_MAX;
    GetBitInIso8583(piso8583stru, BIT_TRACK3, szTrack3, &nSize);

    if (nSize == 0)
        return NORMAL;

    for (n = 0; n < nSize; n++)
        if (szTrack3[n] == 'D')
            szTrack3[n] = '=';

    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_TRACK3, szTrack3));
    return NORMAL;
}

RESULT GetReqId(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    char szTermId[SIZE_TERMID + 1];
    UINT nSize;

    bufclr(szTermId);
    
    nSize = SIZE_TERMID;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_TERMID, szTermId, &nSize));

    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_REQID, szTermId));
    return NORMAL;
}


RESULT GetReqSeqNoInReverse(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    UINT nSize;
    char szBatchNo[SIZE_BATCHNO_MAX + 1];
    char szOrgTrace[SIZE_ORGTRACE_MAX + 1];    
    char szOrgReqSeqNo[AP_LEN_SEQNO + 1];       
    
    bufclr(szBatchNo);
    bufclr(szOrgTrace);
    bufclr(szOrgReqSeqNo);

    nSize = SIZE_ORGTRACE_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_ORGTRACE, szOrgTrace,
                                  &nSize));

    DETECT(nSize == SIZE_ORGTRACE_MAX);
    
    nSize = SIZE_BATCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_BATCHNO, szBatchNo,
                                  &nSize));
                                  
    DETECT(nSize == SIZE_BATCHNO_MAX);
    
    sprintf(szOrgReqSeqNo, "%6s%6s", szBatchNo, szOrgTrace);

    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_REQSEQNO, szOrgReqSeqNo));
    return NORMAL;
}

RESULT GetReqSeqNo(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    UINT nSize;
    char szBatchNo[SIZE_BATCHNO_MAX + 1];
    char szTrace[SIZE_TRACE + 1];    
    char szReqSeqNo[AP_LEN_SEQNO + 1];       
    
    bufclr(szBatchNo);
    bufclr(szTrace);
    bufclr(szReqSeqNo);

    nSize = SIZE_TRACE;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_TRACE, szTrace, &nSize));

    nSize = SIZE_BATCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_BATCHNO, szBatchNo,
                                  &nSize));
                                  
    DETECT(nSize == SIZE_BATCHNO_MAX);
    
    sprintf(szReqSeqNo, "%6s%6s", szBatchNo, szTrace);

    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_REQSEQNO, szReqSeqNo));
    return NORMAL;
}

/*
 * 与GetReqSeqNo不同的是，GetReqSeqNoExt在取得BATCHNO时是从
 * BIT_VOUCHNOBATCHNO域中分解得来的。
 */

RESULT GetReqSeqNoExt(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    UINT nSize;
    char szVouchNoBatchNo[SIZE_VOUCHNOBATCHNO_MAX + 1];
    char szTrace[SIZE_TRACE + 1];    
    char szReqSeqNo[AP_LEN_SEQNO + 1];       
    
    bufclr(szVouchNoBatchNo);
    bufclr(szTrace);
    bufclr(szReqSeqNo);
    
    nSize = SIZE_TRACE;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_TRACE, szTrace, &nSize));

    nSize = SIZE_VOUCHNOBATCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_VOUCHNOBATCHNO, 
                                  szVouchNoBatchNo, &nSize));
                                  
    DETECT(nSize == SIZE_VOUCHNOBATCHNO_MAX);
    
    sprintf(szReqSeqNo, "%6s%6s", szVouchNoBatchNo + SIZE_VOUCHNO, szTrace);

    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_REQSEQNO, szReqSeqNo));
    return NORMAL;
}

RESULT GetOrgAuthCode(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    UINT nSize;
    char szOrgAuthCode[SIZE_ORGAUTHCODE_MAX + 1];

    bufclr(szOrgAuthCode);

    nSize = SIZE_ORGAUTHCODE_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_ORGAUTHCODE, szOrgAuthCode,
                                  &nSize));

    DETECT(nSize == SIZE_ORGAUTHCODE_MAX);
    
    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_AUTHCODE, szOrgAuthCode));
    return NORMAL;
}

RESULT GetOrgVouchNo(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    UINT nSize;
    char szOrgVouchNo[SIZE_ORGVOUCHNO_MAX + 1];

    bufclr(szOrgVouchNo);

    nSize = SIZE_ORGVOUCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_ORGVOUCHNO, szOrgVouchNo,
                                  &nSize));
  
    DETECT(nSize == SIZE_ORGVOUCHNO_MAX);
    
    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_ORGVOUCHNO, szOrgVouchNo));
    return NORMAL;
}

RESULT GetVouchNo(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    UINT nSize;
    char szVouchNoBatchNo[SIZE_VOUCHNOBATCHNO_MAX + 1];
    char szVouchNo[AP_LEN_VOUCHNO + 1];

    bufclr(szVouchNo);
    bufclr(szVouchNoBatchNo);

    nSize = SIZE_VOUCHNOBATCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_VOUCHNOBATCHNO, 
                                  szVouchNoBatchNo, &nSize));

    DETECT(nSize == SIZE_VOUCHNOBATCHNO_MAX);
    
    memcpy(szVouchNo, szVouchNoBatchNo, AP_LEN_VOUCHNO);

    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_VOUCHNO, szVouchNo));
    return NORMAL;
}

RESULT GetBatchNo(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    UINT nSize;
    char szBatchNo[SIZE_BATCHNO_MAX + 1];

    bufclr(szBatchNo);

    nSize = SIZE_BATCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_BATCHNO, szBatchNo, &nSize));
                                  
    DETECT(nSize == SIZE_BATCHNO_MAX);

    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_BATCHNO, szBatchNo));
    return NORMAL;
}

/*
 * 与GetBatchNo不同的是，GetBatchNoExt在取得BATCHNO时是从
 * BIT_VOUCHNOBATCHNO域中分解得来的。
 */

RESULT GetBatchNoExt(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    UINT nSize;
    char szVouchNoBatchNo[SIZE_VOUCHNOBATCHNO_MAX + 1];

    bufclr(szVouchNoBatchNo);

    nSize = SIZE_VOUCHNOBATCHNO_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_VOUCHNOBATCHNO, 
                                  szVouchNoBatchNo, &nSize));
                                  
    DETECT(nSize == SIZE_VOUCHNOBATCHNO_MAX);

    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_BATCHNO, 
                                szVouchNoBatchNo + SIZE_VOUCHNO));
    return NORMAL;
}

RESULT GetSettle(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruReq)
{
    UINT nSize;
    char szSettleData[SIZE_SETTLEDATA_MAX + 1];
    char szFundType[SIZE_FUNDTYPE + 1];
    char szDebitNum[AP_LEN_NUM + 1];
    char szDebitAmt[AP_LEN_AMT + 1];
    char szCreditNum[AP_LEN_NUM + 1];
    char szCreditAmt[AP_LEN_AMT + 1];

    bufclr(szSettleData);
    bufclr(szFundType);
    bufclr(szDebitNum);
    bufclr(szDebitAmt);
    bufclr(szCreditNum);
    bufclr(szCreditAmt);

    nSize = SIZE_SETTLEDATA_MAX;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_SETTLEDATA,
                                  szSettleData, &nSize));

    memcpy(szFundType, szSettleData, SIZE_FUNDTYPE);

    memcpy(szDebitNum, szSettleData + 3, 3);
    memcpy(szDebitAmt, szSettleData + 6, 12);
    sprintf(szDebitAmt, "%19.2lf", atof(szDebitAmt) / 100);

    memcpy(szCreditNum, szSettleData + 18, 3);
    memcpy(szCreditAmt, szSettleData + 21, 12);
    sprintf(szCreditAmt, "%19.2lf", atof(szCreditAmt) / 100);

    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_CURRTYPE, szFundType));
    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_DEBITNUM, szDebitNum));
    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_DEBITAMT, szDebitAmt));
    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_CREDITNUM, szCreditNum));
    ASSERT_NORMAL(AP_INSERT_EXT(AP_PATH_CREDITAMT, szCreditAmt));
    return NORMAL;
}

RESULT FillRespIso8583(PISO8583STRU piso8583stru, PCSTR pszRespCode)
{
    char szMsgId[SIZE_MSGID + 1];
    UINT nSize;

    bufclr(szMsgId);

    nSize = SIZE_MSGID;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_MSGID, szMsgId, &nSize));

    szMsgId[2] = '1';
    SetBitInIso8583(piso8583stru, BIT_MSGID, szMsgId, SIZE_MSGID);
    
    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_RESPCODE, pszRespCode,
                                  SIZE_RESPCODE));
    return NORMAL;
}

RESULT SetRespCode(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szRespCode[AP_LEN_RESPCODE + 1];
    UINT n = 0;
    
    bufclr(szRespCode);
    AP_DEMAND_EXT(AP_PATH_RESPCODE, szRespCode);

    while (pszRespCode[n][0] != NULL)
    {
        if (strcmp(pszRespCode[n][0], szRespCode) == 0)
        {
            strcpy(szRespCode, pszRespCode[n][1]);
            break;
        }
        n++;
    }
    
    if (pszRespCode[n][0] == NULL)
        strcpy(szRespCode, "12");
    
    ASSERT_NORMAL(FillRespIso8583(piso8583stru, szRespCode));
    return NORMAL;
}

void AddNum(PSTR pszNum)
{
    UINT n;

    n = atol(pszNum) + 1;

    if (n > 1E6)
        n = 1;

    sprintf(pszNum, "%06ld", n);
}

RESULT UpdatePos(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    EXEC SQL BEGIN DECLARE SECTION;
    char szBatchNo[SIZE_BATCHNO + 1];
    char szTrace[SIZE_TRACE + 1];
    char szTermId[SIZE_TERMID + 1];
    char szVouchNo[SIZE_VOUCHNO + 1];
    EXEC SQL END DECLARE SECTION;

    char szTransCode[AP_LEN_TRANSCODE + 1];
    char szVouchNoBatchNo[SIZE_VOUCHNOBATCHNO_MAX + 1];
    UINT nSize;
    
    bufclr(szBatchNo);
    bufclr(szTrace);
    bufclr(szTermId);
    bufclr(szVouchNo);
    bufclr(szTransCode);
    bufclr(szVouchNoBatchNo);

    AP_DEMAND_EXT(AP_PATH_REQID, szTermId);
    AP_DEMAND_EXT(AP_PATH_TRANSCODE, szTransCode);

    nSize = SIZE_TRACE;
    ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_TRACE, szTrace,
                                  &nSize));

    if (ApIsRespCode(pxmlstruResp, AP_RESPCODE_ACCEPT))
    {
        nSize = SIZE_VOUCHNOBATCHNO_MAX;
        ASSERT_NORMAL(GetBitInIso8583(piso8583stru, BIT_VOUCHNOBATCHNO, 
                                      szVouchNoBatchNo, &nSize));

        if (nSize == SIZE_BATCHNO_MAX)
            memcpy(szBatchNo, szVouchNoBatchNo, SIZE_BATCHNO);

        else
        {
            memcpy(szVouchNo, szVouchNoBatchNo, SIZE_VOUCHNO);
            memcpy(szBatchNo, szVouchNoBatchNo + SIZE_VOUCHNO, SIZE_BATCHNO);
        }

        if (strcmp(szTransCode, AP_TRANSCODE_CS_SETTLE) == 0)
            AddNum(szBatchNo);

        if (strcmp(szVouchNo, "") == 0)
            EXEC SQL UPDATE pos SET batchno = :szBatchNo, trace = :szTrace
                     WHERE termid = :szTermId;
        else
        {
            AddNum(szVouchNo);
            EXEC SQL UPDATE pos SET batchno = :szBatchNo,
                                    vouchno = :szVouchNo,
                                    trace = :szTrace
                     WHERE termid = :szTermId;
        }
    }
    else
        EXEC SQL UPDATE pos SET trace = :szTrace WHERE termid = :szTermId;

    ASSERT_SQL_NORMAL();
    return NORMAL;
}

RESULT SetAuthCode(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szAuthCode[AP_LEN_AUTHCODE + 1];
    UINT nSize;

    bufclr(szAuthCode);
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_AUTHCODE, szAuthCode));

    ASSERT_NORMAL(SetBitInIso8583(piso8583stru, BIT_AUTHCODE, szAuthCode,
                                  SIZE_AUTHCODE));
    return NORMAL;
}

RESULT SetBal(PISO8583STRU piso8583stru, PXMLSTRU pxmlstruResp)
{
    char szBal[AP_LEN_BAL + 1];           
    char szAvailBal[AP_LEN_BAL + 1];           
    char szCurrType[AP_LEN_CURRTYPE + 1];
    char szPosBal[SIZE_BAL_MAX + 1];
    UINT nSize;
    double dAmt;

    bufclr(szBal);
    bufclr(szAvailBal);
    bufclr(szCurrType);
    bufclr(szPosBal);
    
    if (AP_DEMAND_EXT(AP_PATH_CURRTYPE, szCurrType) != NORMAL)
        strcpy(szCurrType, AP_CURRTYPE_CNY);

    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_BAL, szBal));
    ASSERT_NORMAL(AP_DEMAND_EXT(AP_PATH_AVAILBAL, szAvailBal));
    
    memcpy(szPosBal, szCurrType, 3);
    
    dAmt = atof(szBal);
    if (dAmt >= 0)
    {
        szPosBal[3] = 'C';
        sprintf(&szPosBal[4], "%10.2lf", dAmt);
    }
    else
    {
        szPosBal[3] = 'D';
        sprintf(&szPosBal[4], "%10.2lf", -dAmt);
    }
    
    dAmt = atof(szAvailBal);
    if (dAmt >= 0)
    {
        szPosBal[14] = 'C';
        sprintf(&szPosBal[15], "%10.2lf", dAmt);