handle.cpre

商业银行前置系统

/*
 * This is a part of the Application Preconsole
 * - Channel Access - ATM.
 * Copyright (C) 2000-2000 ABC.SDC.
 * All rights reserved.
 *
 * This source code is only intended as a supplement to the
 * Application Preconsole Reference and related
 * electronic documentation provided with the library.
 * See these sources for detailed information regarding the
 * Application Preconsole product.
 *
 * Update record:
 * 2001-08-05 TianLei       - create implementation file for
 *                            atm transaction handling
 */

#include "ap.h"
#include "apcs.h"
#include "apca.h"
#include "atm.h"

EXEC SQL INCLUDE sqlca;

RESULT GetAtm(PATMSTRU patmstru, PCSTR pszAddr)
{
    EXEC SQL BEGIN DECLARE SECTION;
    char szAtmNo[LEN_ATMNO + 1];
    char szAddr[LEN_ADDR + 1];
    char szEncryptKey[SIZE_KEY * 2 + 1];
    char szWorkKey[SIZE_KEY * 2 + 1];
    EXEC SQL END DECLARE SECTION;
    
    strcpy(szAddr, pszAddr);

    EXEC SQL SELECT atmno, encryptkey, workkey FROM atm 
             INTO :szAtmNo, :szEncryptKey, :szWorkKey
             WHERE addr = :szAddr;

    if (sqlca.sqlcode == SQLCODE_NOTFOUND)
        return INVALID;
        
    ASSERT_SQL_NORMAL();

    strcpy(patmstru->szAtmNo, szAtmNo);
    ShiftCharToHex(szEncryptKey, patmstru->cEncryptKey, SIZE_KEY);
    ShiftCharToHex(szWorkKey, patmstru->cWorkKey, SIZE_KEY);

    return NORMAL;
}

void GetDateTimeDays(PSTR pszDateTimeDays)
{
    time_t _time_t;
    time(&_time_t);

    strftime(pszDateTimeDays, SIZE_DATETIMEDAYS + 1, "%y%m%d%H%M%y%j",
             localtime(&_time_t));
}

void GetAtmDate(PSTR pszDate)
{
    TIMESTRU timestru;

    timestru = GetTime();
    sprintf(pszDate, "%04d%02d%02d", timestru.nYear, timestru.nMon,
            timestru.nDay);
}

void GetAtmTime(PSTR pszTime)
{
    TIMESTRU timestru;

    timestru = GetTime();
    sprintf(pszTime, "%02d%02d%02d", timestru.nHour, timestru.nMin,
            timestru.nSec);
}

#define OFFSET_SEQNO 6

void SetAtmReqSeqNo(PSTR pszReqSeqNo, PCSTR pcReqSeqNo)
{
    TIMESTRU timestru;

    timestru = GetTime();
    
    sprintf(pszReqSeqNo, "%02d%02d%02d", timestru.nYear % 100, timestru.nMon,
            timestru.nDay);

    memcpy(pszReqSeqNo + OFFSET_SEQNO, pcReqSeqNo, SIZE_REQSEQNO);
}

#define LEN_DAYS 3
#define LEN_YEAR 2
#define LEN_DATE 6
#define LEN_TIME 4

void SetDateTimeDays(PCSTR pszDate, PCSTR pszTime, PSTR pszDateTimeDays)
{
    time_t _time_t;
    TIMESTRU timestru;

    char szDays[LEN_DAYS + 1];
    char szYear[LEN_YEAR + 1];
    char szDate[LEN_DATE + 1];
    char szTime[LEN_TIME + 1];

    bufclr(szYear);
    bufclr(szDate);
    bufclr(szTime);
    bufclr(szDays);

    time(&_time_t);
    strftime(szDays, sizeof(szDays), "%j", localtime(&_time_t));

    memcpy(szYear, pszDate + 2, LEN_YEAR);
    memcpy(szDate, pszDate + 2, LEN_DATE);
    memcpy(szTime, pszTime, LEN_TIME);

    sprintf(pszDateTimeDays, "%6s%4s%2s%3s", szDate, szTime, szYear, szDays);
}

RESULT GetExpDate(PCSTR pszTrack2, PSTR pszExpDate)
{
    PSTR pszSign;

    DETECT_NULL(pszSign = strchr(pszTrack2, '='));
    memcpy(pszExpDate, pszSign + 1, AP_LEN_EXPDATE);

    if (!ApCsIsValidExpDate(pszExpDate))
        strcpy(pszExpDate, "9912");

    return NORMAL;
}

RESULT WriteReject(char cMsg[SIZE_MSG_ATM], PCSTR pszRejectCode,
                   PCSTR pszReqSeqNo)
{
    char szDateTimeDays[SIZE_DATETIMEDAYS + 1];
    REJECTSTRU rejectstru;

    memset(cMsg, 0, SIZE_MSG_ATM);

    rejectstru.cTfc = 'A';
    rejectstru.cTpc = 'G';
    rejectstru.cOperateMode = 'P';
    rejectstru.cLimitFlag = 1;

    memset(szDateTimeDays, 0, sizeof(szDateTimeDays));
    GetDateTimeDays(szDateTimeDays);

    memcpy(rejectstru.cDateTime, szDateTimeDays, SIZE_DATETIMEDAYS);
    memcpy(rejectstru.cRejectCode, pszRejectCode, SIZE_REJECTCODE);
    memcpy(rejectstru.cReqSeqNo, pszReqSeqNo, SIZE_REQSEQNO);

    VERIFY_NORMAL(ApCaRecord(&rejectstru, sizeof(rejectstru), "atm", TRUE));
    memcpy(cMsg, &rejectstru, sizeof(rejectstru));
    return NORMAL;
}

char* FormatAccNo(char* pszAccNo)
{
    UINT n;
    for (n = SIZE_ACCNO - 1; n > 0; n--)
        if (pszAccNo[n] == '?')
            pszAccNo[n] = 0;

    return pszAccNo;
}

#define ASSURE(b) \
    { \
        if (!VERIFY(b)) \
        { \
            memset(cMsg, 0, SIZE_MSG_ATM); \
            VERIFY_NORMAL(WriteReject(cMsg, "0998", \
                                      szReqSeqNo + OFFSET_SEQNO)); \
            DeleteXml(&xmlstruReq); \
            DeleteXml(&xmlstruResp); \
            return EXCEPTION; \
        } \
    }

#define ASSURE_NORMAL(r) \
    { \
        RESULT rTemp = (r); \
        if (!VERIFY_NORMAL(rTemp)) \
        { \
            memset(cMsg, 0, SIZE_MSG_ATM); \
            VERIFY_NORMAL(WriteReject(cMsg, "0998", \
                                      szReqSeqNo + OFFSET_SEQNO)); \
            DeleteXml(&xmlstruReq); \
            DeleteXml(&xmlstruResp); \
            return rTemp; \
        } \
    }

RESULT HandleRqk(char cMsg[SIZE_MSG_ATM], char szMsgLen[6 + 1], ATMSTRU atmstru)
{
    char szDateTimeDays[SIZE_DATETIMEDAYS + 1];
    RQKRESPSTRU rqkrespstru;

    rqkrespstru.cTfc = 'A';
    rqkrespstru.cTpc = 'B';
    rqkrespstru.cOperateMode = 'P';

    memset(szDateTimeDays, 0, sizeof(szDateTimeDays));
    GetDateTimeDays(szDateTimeDays);

    memcpy(rqkrespstru.cDateTime, szDateTimeDays, SIZE_DATETIMEDAYS);
    memcpy(rqkrespstru.cNewKey, atmstru.cWorkKey, SIZE_KEY);
    memcpy(rqkrespstru.cReqSeqNo, cMsg + (sizeof(RQKSTRU) - SIZE_REQSEQNO),
           SIZE_REQSEQNO);

    VERIFY_NORMAL(ApCaRecord(&rqkrespstru, sizeof(rqkrespstru), "atm", TRUE));

	memset(cMsg, 0, SIZE_MSG_ATM);    
    memcpy(cMsg, &rqkrespstru, sizeof(rqkrespstru));
	sprintf(szMsgLen, "%6d", sizeof(rqkrespstru));
    return NORMAL;
}

RESULT HandleInq(char cMsg[SIZE_MSG_ATM], char szMsgLen[6 + 1], ATMSTRU atmstru)
{
    XMLSTRU xmlstruReq;
    XMLSTRU xmlstruResp;

    PXMLSTRU pxmlstruReq;
    PXMLSTRU pxmlstruResp;

    PINQSTRU pinqstru;
    INQACCEPTSTRU inqacceptstru;
    INQREJECTSTRU inqrejectstru;

    char szReqId[AP_LEN_ID + 1];
    char szReqDate[AP_LEN_DATE + 1];
    char szReqTime[AP_LEN_TIME + 1];
    char szReqSeqNo[AP_LEN_SEQNO + 1];

    char szAccNo[AP_LEN_ACCNO + 1];
    char szAtmAccNo[SIZE_ACCNO + 1];
    char szExpDate[AP_LEN_EXPDATE + 1];
    char szTrack2[AP_LEN_TRACK2 + 1];
    char szTrack3[AP_LEN_TRACK3 + 1];
    char szAccPwd[AP_LEN_ACCPWD + 1];

    char szRespCode[AP_LEN_RESPCODE + 1];
    char szRespSeqNo[AP_LEN_SEQNO + 1];
    char szRespDate[AP_LEN_DATE + 1];
    char szRespTime[AP_LEN_TIME + 1];
    char szDateTimeDays[SIZE_DATETIMEDAYS + 1];
    char szBal[AP_LEN_BAL + 1];
    char szAvailBal[AP_LEN_BAL + 1];

    memset(&inqacceptstru, '0', sizeof(inqacceptstru));
    memset(&inqrejectstru, '0', sizeof(inqrejectstru));

    memset(&xmlstruReq, 0, sizeof(xmlstruReq));
    memset(&xmlstruResp, 0, sizeof(xmlstruResp));

    bufclr(szReqId);
    bufclr(szReqDate);
    bufclr(szReqTime);
    bufclr(szReqSeqNo);

    bufclr(szAccNo);
    bufclr(szAtmAccNo);
    bufclr(szExpDate);
    bufclr(szTrack2);
    bufclr(szTrack3);
    bufclr(szAccPwd);

    bufclr(szRespCode);
    bufclr(szRespSeqNo);
    bufclr(szRespDate);
    bufclr(szRespTime);
    bufclr(szDateTimeDays);
    bufclr(szBal);
    bufclr(szAvailBal);

    pxmlstruReq = &xmlstruReq;
    pxmlstruResp = &xmlstruResp;

    /*
     * Convert string to xml.
     */

    pinqstru = (PINQSTRU)cMsg;
    
    memcpy(szReqId , atmstru.szAtmNo, AP_LEN_ID);

	SetAtmReqSeqNo(szReqSeqNo, pinqstru->cReqSeqNo);

    memcpy(szAtmAccNo, pinqstru->cAccNo, SIZE_ACCNO);
    memcpy(szTrack2, pinqstru->cTrack2, AP_LEN_TRACK2);
    memcpy(szTrack3, pinqstru->cTrack3, AP_LEN_TRACK3);

    EncryptTrack2(szTrack2, -1);
    EncryptTrack3(szTrack3, -1);

    ASSURE_NORMAL(GetExpDate(szTrack2, szExpDate))

    EncryptAtm(szAtmAccNo, pinqstru->cEncryptData, -1);
    
    memcpy(szAccPwd, pinqstru->cEncryptData + 10, AP_LEN_ACCPWD);

    strcpy(szAccNo, szAtmAccNo);
    GetAtmDate(szReqDate);
    GetAtmTime(szReqTime);

    ASSURE_NORMAL(CreateXml(pxmlstruReq, FALSE, AP_PATH_ROOT, NULL))

    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_MSGTYPE, AP_MSGTYPE_SUBMITREQ))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_TRANSCODE, AP_TRANSCODE_CS_QUERYBAL))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_REQDATE, szReqDate))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_REQTIME, szReqTime))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_REQID, szReqId))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_REQSEQNO, szReqSeqNo))

    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_ACCNO, FormatAccNo(szAccNo)))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_EXPDATE, szExpDate))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_TRACK2, szTrack2))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_TRACK3, szTrack3))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_TRACKVERIFY, "Y"))
    ASSURE_NORMAL(AP_INSERT_EXT(AP_PATH_ACCPWD, szAccPwd))

    ASSURE_NORMAL(ApCaSubmit(pxmlstruReq, pxmlstruResp))

    /*
     * Convert xml to string.
     */

    memset(cMsg, 0, SIZE_MSG_ATM);
   
    AP_DEMAND_EXT(AP_PATH_RESPCODE, szRespCode);
    AP_DEMAND_EXT(AP_PATH_RESPDATE, szRespDate);
    AP_DEMAND_EXT(AP_PATH_RESPTIME, szRespTime);

    SetDateTimeDays(szRespDate, szRespTime, szDateTimeDays);

    if (strcmp(szRespCode, AP_RESPCODE_ACCEPT) != 0)
    {
        inqrejectstru.cTfc = 'A';
        inqrejectstru.cTpc = 'G';
        inqrejectstru.cOperateMode = 'P';
        inqrejectstru.cLimitFlag = '1';

        memcpy(inqrejectstru.cDateTime, szDateTimeDays, SIZE_DATETIMEDAYS);
        memcpy(inqrejectstru.cRejectCode, szRespCode, SIZE_REJECTCODE);
        memcpy(inqrejectstru.cReqSeqNo, szReqSeqNo + 6, SIZE_REQSEQNO);

        VERIFY_NORMAL(ApCaRecord(&inqrejectstru, sizeof(inqrejectstru), "atm",
                                 TRUE));
                                 
        memcpy(cMsg, &inqrejectstru, sizeof(inqrejectstru));
		sprintf(szMsgLen, "%6d", sizeof(inqrejectstru));
    }
    else
    {
        VERIFY_NORMAL(AP_DEMAND_EXT(AP_PATH_AVAILBAL, szAvailBal));
        VERIFY_NORMAL(AP_DEMAND_EXT(AP_PATH_BAL, szBal));
        VERIFY_NORMAL(AP_DEMAND_EXT(AP_PATH_RESPSEQNO, szRespSeqNo));

        sprintf(szAvailBal, "%-11.2lf", atof(szAvailBal));
        sprintf(szBal, "%-11.2lf", atof(szBal));

        inqacceptstru.cTfc = 'A';
        inqacceptstru.cTpc = 'R';
        inqacceptstru.cOperateMode = 'P';
        inqacceptstru.cLimitFlag = '1';
        inqacceptstru.cAccepted = '1';
        inqacceptstru.cAvailBalSign = atof(szAvailBal) >= 0 ? '+' : '-';
        inqacceptstru.cBalSign = atof(szBal) >= 0 ? '+' : '-';

        memcpy(inqacceptstru.cAccNo, szAtmAccNo, SIZE_ACCNO);
        memcpy(inqacceptstru.cDateTime, szDateTimeDays, SIZE_DATETIMEDAYS);
        memcpy(inqacceptstru.cAvailBal, szAvailBal, SIZE_BAL);
        memcpy(inqacceptstru.cBal, szBal, SIZE_BAL);
        memcpy(inqacceptstru.cRespSeqNo, szRespSeqNo, SIZE_RESPSEQNO);
        memcpy(inqacceptstru.cReqSeqNo, szReqSeqNo + 6, SIZE_REQSEQNO);

        VERIFY_NORMAL(ApCaRecord(&inqacceptstru, sizeof(inqacceptstru), "atm",
                                 TRUE));
                               
        memcpy(cMsg, &inqacceptstru, sizeof(inqacceptstru));
		sprintf(szMsgLen, "%6d", sizeof(inqacceptstru));
    }

    DeleteXml(&xmlstruReq);
    DeleteXml(&xmlstruResp);

    return NORMAL;
}

RESULT HandleCwd(char cMsg[SIZE_MSG_ATM], char szMsgLen[6 + 1], ATMSTRU atmstru)
{
    XMLSTRU xmlstruReq;
    XMLSTRU xmlstruResp;

    PXMLSTRU pxmlstruReq;
    PXMLSTRU pxmlstruResp;

    PCWDSTRU pcwdstru;
    CWDACCEPTSTRU cwdacceptstru;
    CWDREJECTSTRU cwdrejectstru;
    CWDBALLACKSTRU cwdballackstru;

    char szReqId[AP_LEN_ID + 1];
    char szReqDate[AP_LEN_DATE + 1];
    char szReqTime[AP_LEN_TIME + 1];
    char szReqSeqNo[AP_LEN_SEQNO + 1];

    char szAccNo[AP_LEN_ACCNO + 1];
    char szAtmAccNo[SIZE_ACCNO + 1];