Пример #1
0
static int doCustomer(int custid,T_t_customer& tCustomer)
{
	int ret=0;
	ret=DB_t_customer_read_lock_by_cur_and_custid(custid,&tCustomer);
	if(ret)
	{		
		if(DB_NOTFOUND==ret)
			return E_NOTEXIST_CUSTOMER;
		else
			return E_DB_CUSTOMER_R;
	}
	if(tCustomer.status[0]==STATUS_DELETE)
	{
		DB_t_customer_free_lock_cur();
		return E_CUSTOMER_LOGOUT;
	}
	if(tCustomer.eaccflag[0]=='1')
	{
		DB_t_customer_free_lock_cur();
		return E_CUST_EACC_OPENED;
	}
	tCustomer.useflag[0]='1';
	tCustomer.eaccflag[0]='1';
	getfmtsysdatetime(tCustomer.lastsaved);
	ret=DB_t_customer_update_lock_by_cur(&tCustomer);
	if(ret)
	{
		if(DB_NOTFOUND==ret)
			return E_NOTEXIST_CUSTOMER;
		else
			return E_DB_CUSTOMER_U;
	}
	return 0;
}
Пример #2
0
int F820352(TRUSERID * handle, int iRequest, ST_PACK * in_pack, int *pRetCode, char *szMsg)
{

	int ret=0;
	T_t_operator tOperator;

	memset(&tOperator,0,sizeof(tOperator));
	ret=DB_t_operator_read_by_opercode(in_pack->scust_no,&tOperator);
	if(ret)
	{
		if(DB_NOTFOUND==ret)
			return E_OPER_NOT_EXIST;
		else
			return E_DB_OPERATOR_R;
	}
	tOperator.loginflag[0]='0';
	getfmtsysdatetime(tOperator.logouttime);
	ret=DB_t_operator_update_by_opercode(tOperator.opercode,&tOperator);
	if(ret)
	{
		if(DB_NOTFOUND==ret)
		{
			return E_OPER_NOT_EXIST;
		}
		else
		{
			return E_DB_OPERATOR_U;
		}
	}
	return 0;
}
Пример #3
0
int DoFrozeCard(int cardno)
{
    int ret=0;
    CAccTrans *pAccTrans=CAccTrans::getInstance();
    TRANS& trans=pAccTrans->trans;

    T_t_card tCard;
    memset(&tCard,0,sizeof(tCard));
    ret=DB_t_card_read_lock_by_cur_and_cardno(cardno,&tCard);
    if(ret)
    {
        writelog(LOG_ERR,"cardno[%d]",cardno);
        if(DB_NOTFOUND==ret)
            return ERRINFO(E_NOTEXIST_CARDNO,cardno);
        else
            return E_DB_CARD_R;
    }
    des2src(trans.showcardno,tCard.showcardno);
    if(tCard.status[0]!=STATUS_NORMAL)
    {
        DB_t_card_free_lock_by_cur();
        return ERRINFO(E_CARD_LOGOUT,cardno);
    }
    if('1'==tCard.frozeflag[0])
    {
        DB_t_card_free_lock_by_cur();
        return ERRINFO(E_CARD_FREEZE,cardno);
    }
    tCard.frozeflag[0]='1';
    des2src(tCard.frozedate,trans.sysdate);
    ret=getCardVerNo(tCard.cardverno);
    if(ret)
    {
        DB_t_card_free_lock_by_cur();
        return ret;
    }
    getfmtsysdatetime(tCard.lastsaved);
    ret=DB_t_card_update_lock_by_cur(&tCard);
    if(ret)
    {
        writelog(LOG_ERR,"cardno[%d]",cardno);
        if(DB_NOTFOUND==ret)
            return E_NOTEXIST_CARDNO;
        else
            return E_DB_CARD_U;
    }
    T_t_customer customer;
    memset(&customer,0,sizeof(customer));
    if(tCard.custid)
    {
        ret=DB_t_customer_read_by_custid(tCard.custid,&customer);
        if(ret)
        {
            if(DB_NOTFOUND==ret)
                return E_NOTEXIST_CUSTOMER;
            else
                return E_DB_CUSTOMER_R;
        }
        trans.custid=tCard.custid;
        des2src(trans.custname,customer.custname);
    }
    //修改以前的解冻记录为删除状态
    UpdCardVerStatus(cardno,CARDVERTYPE_CARDUNFROZE);
    //更新系统黑名单最大版本号
    ret=SetSysParaVal(SYSPARA_MAXBLACKCARDVERNO,tCard.cardverno);
    if(ret)
    {
        return ret;
    }
    T_t_cardver cardver;
    memset(&cardver,0,sizeof(cardver));
    cardver.cardno=tCard.cardno;
    des2src(cardver.accdate,pAccTrans->trans.sysdate);
    cardver.termid=trans.termid;
    cardver.termseqno=trans.termseqno;
    cardver.cardno=tCard.cardno;
    des2src(cardver.cardphyid,tCard.cardphyid);
    des2src(cardver.stuempno,customer.stuempno);
    cardver.cardvertype=CARDVERTYPE_CARDFROZE;
    cardver.adddelflag[0]=ADDDELFLAG_ADD;
    cardver.status[0]=STATUS_NORMAL;
    des2src(cardver.cardverno,tCard.cardverno);
    ret=DB_t_cardver_add(&cardver);
    if(ret)
    {
        if(DB_REPEAT==ret)
            return E_DB_CARDVER_E;
        else
            return E_DB_CARDVER_I;
    }
    T_t_msglist tMsgList;
    memset(&tMsgList,0,sizeof(tMsgList));
    AddXmlItemInt(tMsgList.reqdata, XML_KEY_CARDID,tCard.cardno);
    AddXmlItemStr(tMsgList.reqdata, XML_KEY_VERNUM,tCard.cardverno);
    AddXmlItemInt(tMsgList.reqdata, XML_KEY_ADDDELSIGN,0);	//增删标志

    tMsgList.funcno = 930005;
    tMsgList.pfuncno = 846307;
    tMsgList.msglevel = MESLIST_PRIORITY_REALTIME;
    tMsgList.msgtype = MESLIST_TYPE_ORDER;
    ret=AddMsgLst(&tMsgList);
    if(ret)
    {
        writelog(LOG_ERR,"AddMsgLst err[%d]",ret);
        return ret;
    }
    des2src(trans.summary,cardver.cardverno);
    return 0;
}
Пример #4
0
static int doReverse(char* oldaccdate,int oldtermid,int oldtermseqno)
{
	//查找操作员流水
	int ret=0;
	T_t_card tCard;
	
	CAccTrans *pAccTrans=CAccTrans::getInstance();
	TRANS& trans=pAccTrans->trans;
	T_t_transdtl transdtl;
	memset(&transdtl,0,sizeof(transdtl));
	ret=DB_t_transdtl_read_lock_by_c0_and_accdate_and_termid_and_termseqno(oldaccdate,oldtermid,oldtermseqno,&transdtl);
	if(ret)
	{
	    if(DB_NOTFOUND==ret)
	        return E_DB_TRANSDTL_N;
	    else
	        return E_DB_TRANSDTL_R;
	}	
	if(trans.cardno!=transdtl.cardno)
	{
		DB_t_transdtl_free_lock_by_c0();
		return E_CARDNO_DIFFER;
	}
	if(transdtl.transcode!=TC_POSDEPOSIT&&
		transdtl.transcode!=TC_POSDEPOSITREV&&
		transdtl.transcode!=TC_SHOPPOSDEPOSIT&&
		transdtl.transcode!=TC_SHOPPOSDEPOSITREV&&
		transdtl.transcode!=TC_CARDDEPOSIT&&
		transdtl.transcode!=TC_CARDDEPOSITREV)
	{
		DB_t_transdtl_free_lock_by_c0();
		return E_TRANSCODE_NOT_SAVING;
	}
	if(transdtl.revflag[0]=='1')
	{
		DB_t_transdtl_free_lock_by_c0();

		memset(&tCard,0,sizeof(tCard));
		ret=DB_t_card_read_by_cardno(transdtl.cardno,&tCard);
		if(ret)
		{
			writelog(LOG_ERR,"cardno[%d]",transdtl.cardno);
			if(DB_NOTFOUND==ret)
				return E_DB_CARD_N;
			else 
				return E_DB_CARD_R;
		}		
		//pAccTrans->remark="该交易已冲正";
		//strcpy(cardphyid,tCard.cardphyid);
		return E_TRANS_REVERSED;
	}
	transdtl.revflag[0]='1';
	ret=DB_t_transdtl_update_lock_by_c0(&transdtl);
	if(ret)
	{
	    return E_DB_TRANSDTL_U;
	}	
	memset(&tCard,0,sizeof(tCard));
	ret=DB_t_card_read_lock_by_cur_and_cardno(transdtl.cardno,&tCard);
	if(ret)
	{
		writelog(LOG_ERR,"cardno[%d]",transdtl.cardno);
		if(DB_NOTFOUND==ret)
			return ERRINFO(E_NOTEXIST_CARDNO,transdtl.cardno);
		else 
			return E_DB_CARD_R;
	}
	if(tCard.status[0]!=STATUS_NORMAL)
	{
		DB_t_card_free_lock_by_cur();
		return ERRINFO(E_CARD_LOGOUT,transdtl.cardno);
	}	
	if('1'==tCard.frozeflag[0])
	{
		DB_t_card_free_lock_by_cur();
		return ERRINFO(E_CARD_FREEZE,transdtl.cardno);
	}
	if('1'==tCard.lossflag[0])
	{
		DB_t_card_free_lock_by_cur();
		return ERRINFO(E_CARD_LOST,transdtl.cardno);
	}	
	if('1'==tCard.badflag[0])
	{
		DB_t_card_free_lock_by_cur();
		return ERRINFO(E_CARD_BADRECORD,transdtl.cardno);
	}	
//	strcpy(cardphyid,tCard.cardphyid);
	getfmtsysdatetime(tCard.lastsaved);
	ret=DB_t_card_update_lock_by_cur(&tCard);
	if(ret)
	{
		if(DB_NOTFOUND==ret)
			return ERRINFO(E_NOTEXIST_CARDNO,transdtl.cardno);
		else 
			return E_DB_CARD_U;
	}	
	ret=UpdateCardBitmap(trans.cardno,trans.cardcnt,CARDBITMAPTYPE_INCREV,0);
	if(ret)
		return ret;
	T_t_transdtl transdtlrev;
	memset(&transdtlrev,0,sizeof(transdtlrev));

	des2src(transdtlrev.transdate,trans.transdate);
	des2src(transdtlrev.transtime,trans.transtime);
	des2src(transdtlrev.accdate,pAccTrans->trans.sysdate);
	strcpy(transdtlrev.acctime,trans.systime);
	transdtlrev.termid=trans.termid;
	transdtlrev.termseqno=trans.termseqno;
	transdtlrev.transcode=trans.transcode;
	transdtlrev.paytype=0;
	transdtlrev.cardno=transdtl.cardno;
	transdtlrev.purseno=transdtl.purseno;
	transdtlrev.cardcnt=trans.cardcnt;
	transdtlrev.cardbefbal=trans.cardbefbal;
	transdtlrev.amount = -transdtl.amount;
	transdtlrev.managefee= -transdtl.managefee;
	transdtlrev.custid=transdtl.custid;
	des2src(transdtlrev.custname,transdtl.custname);
	if(TC_POSDEPOSITREV==transdtl.transcode||
	   TC_SHOPPOSDEPOSITREV==transdtl.transcode)
		transdtlrev.cardaftbal=transdtlrev.cardbefbal+(transdtl.cardbefbal-transdtl.cardaftbal);
	else
		transdtlrev.cardaftbal=transdtlrev.cardbefbal-(transdtl.cardaftbal-transdtl.cardbefbal);	
	if(amtcmp(transdtlrev.cardaftbal,0)<0)
		return ERRINFO(E_CARD_BALANCE_SHORTAGE,transdtlrev.cardaftbal);
	des2src(transdtlrev.opercode,trans.opercode);
	transdtlrev.status[0]=DTLSTATUS_SUCCESS;
	transdtlrev.errcode=0;
	ret=DB_t_transdtl_add(&transdtlrev);
	if(ret)
	{
	  if(DB_REPEAT==ret)
	    return E_DB_TRANSDTL_E;
	  else
	    return E_DB_TRANSDTL_I;
	}		
	ret=pAccTrans->doReverseTrans(oldaccdate,oldtermid,oldtermseqno);	
	if(ret)
		return ret;
	trans.cardaftbal=transdtlrev.cardaftbal;
	trans.transamt=transdtlrev.amount;
	return 0;
}
Пример #5
0
int F846305(TRUSERID *handle,int iRequest,ST_PACK *rPack,int *pRetCode,char *szMsg)
{
    int ret=0;
    int freefeeflag=0;
    CAccTrans *pAccTrans=CAccTrans::getInstance();
    des2src(pAccTrans->trans.opercode,rPack->semp);
    pAccTrans->trans.transcode=TC_CARDRENEW;
    ret=pAccTrans->InitTrans();
    if(ret)
        return ret;
    TRANS& trans=pAccTrans->trans;

    trans.usecardflag=1;
    trans.cardno=rPack->lvol0;
    des2src(trans.showcardno,rPack->sorder0);
    des2src(trans.cardphyid,rPack->sstation0);
    if (!strlen(trans.cardphyid))
        return E_INPUT_CARDPHYID;
//	if (!strlen(trans.showcardno))
//	    return E_INPUT_SHOWCARDNO;
    ST_CPACK aPack;
    ST_PACK *outPack = &(aPack.pack);

    ResetNormalCPack(&aPack,0,1);


    SetCol(handle,0);

    //检查卡
    T_t_card tCard;

    memset(&tCard,0,sizeof(tCard));
    ret=DB_t_card_read_lock_by_cur_and_cardno(trans.cardno,&tCard);
    if(ret)
    {
        writelog(LOG_ERR,"cardno[%d]",trans.cardno);
        if(DB_NOTFOUND==ret)
            return ERRINFO(E_NOTEXIST_CARDNO,trans.cardno);
        else
            return E_DB_CARD_R;
    }
    trans.cardtype=tCard.cardtype;
    trans.feetype=tCard.feetype;
    trans.custid=tCard.custid;
    if(tCard.status[0]!=STATUS_NORMAL)
    {
        DB_t_card_free_lock_by_cur();
        return ERRINFO(E_CARD_LOGOUT,trans.cardno);
    }
    if('1'==tCard.frozeflag[0])
    {
        DB_t_card_free_lock_by_cur();
        return ERRINFO(E_CARD_FREEZE,trans.cardno);
    }
    if('1'==tCard.badflag[0])
    {
        if((CARDBADFLAG_CARDBAL==tCard.badtype[0])||(CARDBADFLAG_ACCBAL==tCard.badtype[0]))
        {
            DB_t_card_free_lock_by_cur();
            ERRTIP("该卡余额错误,请使用坏卡修复功能来处理,不必补办");
            return E_CARD_BAD_AND_NEED_UPDATE;
        }
    }
    //无卡只有挂失或卡物理损坏的情况下才可以补办卡
    if(tCard.lossflag[0]!='1'&&
            tCard.badflag[0]!='1')
    {
        DB_t_card_free_lock_by_cur();
        ERRTIP("该卡状态正常,不能补办");
        return E_COMMON_ERR;
    }
    //检查该客户是否存在未注销的卡
//	ret=IsExistOtherCardByCustid(tCard.custid,tCard.cardno);
    ret=IsExistNormalTmpCardByCustid(tCard.custid);
    if(ret)
    {
        DB_t_card_free_lock_by_cur();
        if(DB_EXIST==ret)
        {
            ERRTIP("该客户存在正常的过渡临时卡,请先注销过渡临时卡再补办");
            return E_EXIST_OTHERCARD;
        }
        else
            return ret;
    }
    if('1'==tCard.badflag[0])
    {
        //检查卡是否到了销卡的时间
        char enddate[9]="";
        ret=calcEndDate(tCard.baddate,pAccTrans->sysPara.iPosdtlMaxDayCnt,enddate);
        if(ret)
        {
            DB_t_card_free_lock_by_cur();
            return ret;
        }
        if(strncmp(enddate,pAccTrans->trans.transdate,8)>0)
        {
            DB_t_card_free_lock_by_cur();
            ERRTIP("请等到期后再补办");
            return ERRINFO(E_BADCARD_RECORDDATE_NOTREACH,enddate);
        }
        if(CARDBADFLAG_QUALITY==tCard.badtype[0])
            freefeeflag=1;
    }
    else if('1'==tCard.lossflag[0])
    {
        char enddate[9]="";
        ret=calcEndDate(tCard.lossdate,pAccTrans->sysPara.iPosdtlMaxDayCnt,enddate);
        if(ret)
        {
            DB_t_card_free_lock_by_cur();
            return ret;
        }
        if(strncmp(enddate,pAccTrans->trans.transdate,8)>0)
        {
            DB_t_card_free_lock_by_cur();
            ERRTIP("请等到期后再补办");
            return ERRINFO(E_CARDLOSSDATE_NOREACH,enddate);
        }
    }
    ret=getCardVerNo(tCard.cardverno);
    if(ret)
    {
        DB_t_card_free_lock_by_cur();
        return ret;
    }
    tCard.status[0]=STATUS_DELETE;
    strcpy(tCard.closedate,trans.transdate);
    getfmtsysdatetime(tCard.lastsaved);
    ret=DB_t_card_update_lock_by_cur(&tCard);
    if(ret)
    {
        writelog(LOG_ERR,"cardno[%d]",tCard.cardno);
        if(DB_NOTFOUND==ret)
            return ERRINFO(E_NOTEXIST_CARDNO,tCard.cardno);
        else
            return E_DB_CARD_U;
    }
    //删除卡库不平表该卡的记录
    ret=DelCardAccDiffByCardno(trans.cardno);
    if(ret)
        return ret;
    T_t_customer tCustomer;

    memset(&tCustomer,0,sizeof(tCustomer));
    if(trans.custid>0)
    {
        ret=DB_t_customer_read_by_custid(trans.custid,&tCustomer);
        if(ret)
        {
            if(DB_NOTFOUND==ret)
                return ERRINFO(E_NOTEXIST_CUSTOMER,trans.custid);
            else
                return E_DB_CUSTOMER_R;
        }
        trans.custid=tCustomer.custid;
        des2src(trans.custname,tCustomer.custname);
        des2src(trans.stuempno,tCustomer.stuempno);
    }

    T_t_cardtyperight cardtyperight;

    memset(&cardtyperight,0,sizeof(cardtyperight));
    ret=DB_t_cardtyperight_read_by_cardtype_and_feetype(tCard.cardtype,tCard.feetype,&cardtyperight);
    if(ret)
    {
        writelog(LOG_ERR,"cardtype[%d]feetype[%d]",tCard.cardtype,tCard.feetype);
        if(DB_NOTFOUND==ret)
            return E_NOCARDTYPERIGHT;
        else
            return E_DB_CARDTYPERIGHT_R;
    }
    ////添加旧卡版本号记录
    T_t_cardver cardver;

    memset(&cardver,0,sizeof(cardver));
    cardver.cardno=tCard.cardno;
    des2src(cardver.accdate,pAccTrans->trans.sysdate);
    cardver.termid=trans.termid;
    cardver.termseqno=trans.termseqno;
    cardver.cardno=tCard.cardno;
    cardver.status[0]=STATUS_NORMAL;
    des2src(cardver.cardphyid,tCard.cardphyid);
    des2src(cardver.stuempno,trans.stuempno);
    cardver.cardvertype=CARDVERTYPE_CARDCLOSE;
    des2src(cardver.cardverno,tCard.cardverno);
    ret=DB_t_cardver_add(&cardver);
    if(ret)
    {
        if(DB_REPEAT==ret)
            return E_DB_CARDVER_E;
        else
            return E_DB_CARDVER_I;
    }
    T_t_card  tCardTest;
    ret=DB_t_card_read_by_cardphyid_and_status(trans.cardphyid,"1",&tCardTest);
    if (ret!=DB_NOTFOUND)
    {
        if (DB_SUCCESS==ret)
            return ERRINFO(E_EXIST_CARDPHYID,trans.cardphyid);
        else
            return E_DB_CARD_R;
    }
    if(pAccTrans->sysPara.bEnableCardMgr)
    {
        //使用新的显示卡号
        ret=DB_t_card_read_by_showcardno_and_status(trans.showcardno,"1",&tCardTest);
        if (ret!=DB_NOTFOUND)
        {
            if (DB_SUCCESS==ret)
                return ERRINFO(E_EXIST_SHOWCARDNO,trans.showcardno);
            else
                return E_DB_CARD_R;
        }
        int cardtype=0;
        ret=UseShowCardNo(trans.opercode,trans.showcardno,cardtype);
        if(ret)
        {
            return ret;
        }
        if(cardtype!=tCard.cardtype)
        {
            return ERRINFO(E_DIFF_CARDTYPE,cardtype,tCard.cardtype);
        }
        T_t_carddtl carddtl;
        memset(&carddtl,0,sizeof(carddtl));

        des2src(carddtl.accdate,pAccTrans->trans.sysdate);
        des2src(carddtl.acctime,trans.systime);
        carddtl.termid=trans.termid;
        carddtl.termseqno=trans.termseqno;
        des2src(carddtl.opercode,trans.opercode);
        carddtl.cardtype=tCard.cardtype;
        carddtl.usetype=CARDUSETYPE_USE;
        carddtl.inoutflag=INOUTFLAG_OUT;
        carddtl.transcnt=1;
        strcpy(carddtl.summary,"补办卡");
        des2src(carddtl.cardphyid,trans.cardphyid);
        des2src(carddtl.showcardno,trans.showcardno);
        ret=DB_t_carddtl_add(&carddtl);
        if(ret)
        {
            if(DB_REPEAT==ret)
                return E_DB_CARDDTL_E;
            else
                return E_DB_CARDDTL_I;
        }
    }
    //使用卡片
    T_t_card  tNewCard;
    memset(&tNewCard,0,sizeof(tNewCard));

    des2src(tNewCard.cardphyid,trans.cardphyid);
    des2src(tNewCard.showcardno,trans.showcardno);
    des2src(tNewCard.expiredate,tCard.expiredate);
    des2src(tNewCard.accno,tCard.accno);
    tNewCard.cardtype=tCard.cardtype;
    tNewCard.feetype=tCard.feetype;
    des2src(tNewCard.cardpwd,tCard.cardpwd);
    tNewCard.custid=tCustomer.custid;
    tNewCard.lossflag[0]='0';
    tNewCard.frozeflag[0]='0';
    tNewCard.badflag[0]='0';
    tNewCard.status[0]=STATUS_NORMAL;
    des2src(tNewCard.opendate,pAccTrans->trans.transdate);
    getfmtsysdatetime(tNewCard.lastsaved);
    ret = getNewUniqNo(KEYTYPE_CARDNO,&tNewCard.cardno);	//获取最大卡号
    if(ret)
    {
        return ret;
    }
    ret=getCardVerNo(tNewCard.cardverno);
    if(ret)
    {
        return ret;
    }
    ret=DB_t_card_add(&tNewCard);
    if(ret)
    {
        if(DB_REPEAT==ret)
            return E_DB_CARD_E;
        else
            return E_DB_CARD_I;
    }
    ////添加新卡版本号记录
//	T_t_cardver cardver;

    memset(&cardver,0,sizeof(cardver));
    des2src(cardver.accdate,pAccTrans->trans.sysdate);
    cardver.termid=trans.termid;
    cardver.termseqno=trans.termseqno;
    cardver.cardno=tNewCard.cardno;
    cardver.status[0]=STATUS_NORMAL;
    des2src(cardver.cardphyid,tNewCard.cardphyid);
    des2src(cardver.stuempno,trans.stuempno);
    cardver.cardvertype=CARDVERTYPE_CARDOPEN;
    des2src(cardver.cardverno,tNewCard.cardverno);
    ret=DB_t_cardver_add(&cardver);
    if(ret)
    {
        if(DB_REPEAT==ret)
            return E_DB_CARDVER_E;
        else
            return E_DB_CARDVER_I;
    }
    //添加换卡记录
    T_t_cardnochange tCardnoChange;

    memset(&tCardnoChange,0,sizeof(tCardnoChange));
    des2src(tCardnoChange.changedate,pAccTrans->trans.sysdate);
    tCardnoChange.oldcardno=tCard.cardno;
    tCardnoChange.newcardno=tNewCard.cardno;
    ret=DB_t_cardnochange_add(&tCardnoChange);
    if(ret)
    {
        if(DB_REPEAT==ret)
            return E_DB_CARDNOCHANGE_E;
        else
            return E_DB_CARDNOCHANGE_I;
    }
    //插入卡位图表
    T_t_cardbitmap tCardBitmap;

    memset(&tCardBitmap,0,sizeof(tCardBitmap));
    tCardBitmap.cardno=tNewCard.cardno;
    tCardBitmap.baseno=0;
    memset(tCardBitmap.bitmap0,'0',sizeof(tCardBitmap.bitmap0));
    memset(tCardBitmap.bitmap1,'0',sizeof(tCardBitmap.bitmap1));
    memset(tCardBitmap.bitmap2,'0',sizeof(tCardBitmap.bitmap2));
    memset(tCardBitmap.bitmap3,'0',sizeof(tCardBitmap.bitmap3));
    memset(tCardBitmap.bitmap4,'0',sizeof(tCardBitmap.bitmap4));
    memset(tCardBitmap.bitmap5,'0',sizeof(tCardBitmap.bitmap5));
    memset(tCardBitmap.bitmap6,'0',sizeof(tCardBitmap.bitmap6));
    memset(tCardBitmap.bitmap7,'0',sizeof(tCardBitmap.bitmap7));
    memset(tCardBitmap.bitmap8,'0',sizeof(tCardBitmap.bitmap8));
    memset(tCardBitmap.bitmap9,'0',sizeof(tCardBitmap.bitmap9));
    tCardBitmap.bitmap0[0]=CARDBITMAPTYPE_INC;
    ret=DB_t_cardbitmap_add(&tCardBitmap);
    if(ret)
    {
        if(DB_REPEAT==ret)
            return E_DB_CARDBITMAP_E;
        else
            return E_DB_CARDBITMAP_I;
    }
    //领取补助
    T_t_account tCardAccount;
    memset(&tCardAccount,0,sizeof(tCardAccount));
    ret=DB_t_account_read_by_cardno_and_purseno(trans.cardno,trans.purseno,&tCardAccount);
    if(ret)
    {
        if(DB_NOTFOUND==ret)
            return ERRINFO(E_CARDNO_PURSENO_NOACCNO,trans.cardno,trans.purseno);
        else
            return E_DB_ACCOUNT_R;
    }
    if(tCardAccount.status[0]!=STATUS_NORMAL)
    {
        return ERRINFO(E_CARDACC_LOGOUT,tCardAccount.accno);
    }
    double subsidyamt=0;
    int maxsubsidyno=0;
    //检查补助信息
    ret = GetSubsidy(tCard.cardno,tCardAccount.subsidyno,0,subsidyamt,maxsubsidyno);
    if(ret)
    {
        writelog(LOG_ERR,"DoGetSubsidy ret=[%d]",ret);
        return ret;
    }
    strcpy(trans.cardaccno,tCardAccount.accno);
    //押金处理
//	double returncashamt=0;
    if(freefeeflag)
    {
        pAccTrans->SetFreeFlag();
    }
    else
    {
        //扣押金
        if(amtcmp(tCardAccount.foregift,0)>0)
        {
            trans.transamt=tCardAccount.foregift;
            trans.inputamt=tCardAccount.foregift;
            trans.fundtype=0;
            pAccTrans->trans.transtype=TRANSTYPE_FOREGIFT2COSTFEE;
            ret=pAccTrans->DoTransByTransType();
            if(ret)
                return ret;
            if(amtcmp(pAccTrans->trans.unusedamt,0)>0)
                return E_INPUT_AMT;
            if(amtcmp(pAccTrans->trans.unusedamt,0)<0)
                return E_AMT_LACK;
        }
    }
    if(amtcmp(tCardAccount.availbal,tCardAccount.lastcardbal)<=0)
        trans.cardbefbal=D4U5(tCardAccount.availbal+tCardAccount.subsidybal);
    else
        trans.cardbefbal=D4U5(tCardAccount.lastcardbal+tCardAccount.subsidybal);

    if(amtcmp(tCardAccount.subsidybal,0)!=0)
    {
        //领取补助
        memset(&tCardAccount,0,sizeof(tCardAccount));
        ret=DB_t_account_read_lock_by_c0_and_accno(trans.cardaccno,&tCardAccount);
        if(ret)
        {
            if(DB_NOTFOUND==ret)
                return ERRINFO(E_NOTEXIST_ACCNO,trans.cardaccno);
            else
                return E_DB_ACCOUNT_R;
        }
        tCardAccount.availbal=D4U5(tCardAccount.availbal+tCardAccount.subsidybal);
        tCardAccount.subsidybal=0;
        ret=DB_t_account_update_lock_by_c0(&tCardAccount);
        if(ret)
        {
            if(DB_NOTFOUND==ret)
                return E_DB_ACCOUNT_U;
            else
                return E_DB_ACCOUNT_R;
        }
    }

    if(amtcmp(tCardAccount.balance-tCardAccount.frozebal,trans.cardbefbal)>0)
    {
        //走长款处理
        trans.transamt=D4U5(tCardAccount.balance-tCardAccount.frozebal-trans.cardbefbal);
        trans.inputamt=trans.transamt;
        trans.fundtype=0;
        pAccTrans->trans.transtype=TRANSTYPE_MORE_CARDBALINCOME;
        ret=pAccTrans->DoTransByTransType();
        if(ret)
            return ret;
        if(amtcmp(pAccTrans->trans.unusedamt,0)>0)
            return E_INPUT_AMT;
        if(amtcmp(pAccTrans->trans.unusedamt,0)<0)
            return E_AMT_LACK;
    }
    trans.cardflag=1;
    trans.usecardflag=1;
    trans.feetype=tCard.feetype;
    trans.fundtype=rPack->lvol9;
    trans.cardcnt=1;
    trans.inputamt=rPack->damt0;
    if(trans.fundtype>4)
    {
        //如果从账户中扣卡成本费,则没有充值业务
        trans.fundtype=0;
        ret=pAccTrans->doFeeTrans();
        if(ret)
            return ret;
    }
    else
    {
        des2src(trans.voucherno,rPack->scust_auth2);
        ret=pAccTrans->doTrans();
        if(ret)
            return ret;
    }
    ret=pAccTrans->doTransEnd();
    if(ret)
        return ret;
    memset(&tCardAccount,0,sizeof(tCardAccount));
    ret=DB_t_account_read_lock_by_c0_and_accno(trans.cardaccno,&tCardAccount);
    if(ret)
    {
        if(DB_NOTFOUND==ret)
            return ERRINFO(E_NOTEXIST_CARDACCNO,trans.cardaccno);
        else
            return E_DB_ACCOUNT_R;
    }
    if(tCardAccount.status[0]!=STATUS_NORMAL)
    {
        DB_t_account_free_lock_by_c0();
        return ERRINFO(E_CARDACC_LOGOUT,tCardAccount.accno);
    }
    //取可用余额作为出卡值
    trans.cardaftbal=tCardAccount.availbal;
    if(amtcmp(trans.cardaftbal,0)<0)
    {
        DB_t_account_free_lock_by_c0();
        return ERRINFO(E_CARD_BALANCE_SHORTAGE,trans.cardaftbal);
    }
    if(amtcmp(trans.cardaftbal,tCardAccount.cardmaxbal)>=0)
    {
        DB_t_account_free_lock_by_c0();
        return ERRINFO(E_AMT_EXCEED_MAX,tCardAccount.cardmaxbal);
    }
    tCardAccount.cardno=tNewCard.cardno;
    tCardAccount.lastcardcnt=1;
    tCardAccount.lastsubsidyno=maxsubsidyno;
    tCardAccount.lastcardbal=trans.cardaftbal;
    des2src(tCardAccount.lasttransdate,trans.transdate);
    ret=DB_t_account_update_lock_by_c0(&tCardAccount);
    if(ret)
    {
        if(DB_NOTFOUND==ret)
            return E_DB_ACCOUNT_U;
        else
            return E_DB_ACCOUNT_R;
    }
    T_t_transdtl transdtl;
    memset(&transdtl,0,sizeof(transdtl));

    strcpy(transdtl.transdate,trans.transdate);
    strcpy(transdtl.transtime,trans.transtime);
    strcpy(transdtl.accdate,trans.sysdate);
    strcpy(transdtl.acctime,trans.systime);
    transdtl.amount=trans.totaltransamt;
    transdtl.managefee=trans.totalfeeamt;
    transdtl.cardno=tNewCard.cardno;
    transdtl.cardcnt=trans.cardcnt;
    transdtl.cardbefbal=trans.cardbefbal;
    transdtl.cardaftbal=trans.cardaftbal;
    transdtl.termid=trans.termid;
    transdtl.termseqno=trans.termseqno;
    transdtl.transcode=trans.transcode;
    transdtl.paytype=trans.fundtype;
    des2src(transdtl.voucherno,trans.voucherno);
    des2src(transdtl.opercode,trans.opercode);
    transdtl.status[0]=DTLSTATUS_SUCCESS;
    transdtl.errcode=0;
    transdtl.custid=tCustomer.custid;
    des2src(transdtl.custname,tCustomer.custname);
    transdtl.showcardno=atol(tNewCard.showcardno);
    ret=DB_t_transdtl_add(&transdtl);
    if(ret)
    {
        if(DB_REPEAT==ret)
            return E_DB_TRANSDTL_E;
        else
            return E_DB_TRANSDTL_I;
    }
    char cardpwd[33]="";
    char key[17]="";

    //get_init_passwd_by_man_id(tCustomer.idno,cardpwd);
    strcpy(key,STATIC_SEED_KEY);
    EncodePwd(key,cardpwd,tNewCard.cardpwd, 1);

    SetCol(handle,F_LVOL1,F_LSAFE_LEVEL2,F_LVOL4,F_LVOL5,
           F_SALL_NAME,F_SPAGER,F_SCERT_NO,
           F_SEMAIL2,F_SMARKET_CODE,F_SDATE0,
           F_LVOL0,F_STX_PWD,F_LVOL8,F_LVOL11,F_LVOL12,
           F_SORDER0,F_SDATE3,F_SEMP,
           F_LWITHDRAW_FLAG,F_LSERIAL1,F_VSMESS,0);
    outPack->lvol1=tNewCard.custid;
    outPack->lsafe_level2=tCustomer.custtype;
    outPack->lvol5=tNewCard.feetype;
    des2src(outPack->sall_name,tCustomer.custname);
    des2src(outPack->spager,tCustomer.stuempno);
    des2src(outPack->scert_no,tCustomer.deptcode);
    des2src(outPack->semail2,tCustomer.idno);
    des2src(outPack->smarket_code,tCustomer.sex);
    des2src(outPack->sdate0,tNewCard.expiredate);
    outPack->lvol0=tNewCard.cardno;
    des2src(outPack->stx_pwd,cardpwd);
    outPack->lvol4=maxsubsidyno;
    outPack->lvol8=D4U5(pAccTrans->trans.cardaftbal*100,0);
    outPack->lvol11=D4U5(tCardAccount.singlemaxamt*100,0);
    outPack->lvol12=D4U5(tCardAccount.daycostmaxamt*100,0);
    des2src(outPack->sorder0,tNewCard.showcardno);
    des2src(outPack->sdate3,pAccTrans->trans.sysdate);
    des2src(outPack->semp,trans.opercode);
    outPack->lwithdraw_flag=trans.termid;
    outPack->lserial1=trans.termseqno;
    sprintf(trans.remark,"%s卡余额%.2lf元",pAccTrans->remark.c_str(),pAccTrans->trans.cardaftbal);
    des2src(outPack->vsmess,trans.remark);
    PutRow(handle,outPack,pRetCode,szMsg);
    return 0;
}
Пример #6
0
int F846105(TRUSERID *handle,int iRequest,ST_PACK *rPack,int *pRetCode,char *szMsg)
{	
	int ret=0;
	CAccTrans *pAccTrans=CAccTrans::getInstance();
	pAccTrans->clear();
	ret=pAccTrans->initOperDtl(rPack->semp);	
	if(ret)
		return ret;
	GetCpackDataString(rPack,pAccTrans->cpackdata);
	pAccTrans->trans.transcode=TC_CARDDISABLE;
	ret=pAccTrans->addOperDtl();
	if(ret)
		return ret;
	
	char showcardno[11]="";
	char opercode[9]="";
	des2src(showcardno,rPack->scust_no);
	des2src(opercode,rPack->semp);
	int cardtype=rPack->lvol0;

	ST_CPACK aPack;
	ST_PACK *outPack = &(aPack.pack);
	
	ResetNormalCPack(&aPack,0,1);

	SetCol(handle,F_VSMESS,0);

	T_t_cardbook tCardBook;
	T_t_cardbook oldtCardBook;

	ret=DB_t_cardbook_open_select_by_c1_and_status("1");
	if(ret)
	{
		return E_DB_CURSOR_DECLARE;
	}

	while(1)
	{
		memset(&tCardBook,0,sizeof(tCardBook));
		ret=DB_t_cardbook_fetch_select_by_c1(&tCardBook);
		if(ret)
		{
			if(DB_NOTFOUND==ret)
				return E_DB_CARDBOOK_N;
			else
				return E_DB_CARDBOOK_R;
		}
		if(strcmp(showcardno,tCardBook.curno)<0)
			continue;
		if(strcmp(showcardno,tCardBook.endno)>0)
			continue;
		break;
	}
	memcpy(&oldtCardBook,&tCardBook,sizeof(oldtCardBook));
	if(strcmp(showcardno,tCardBook.curno)==0)
	{
		if(strcmp(showcardno,tCardBook.endno)==0)
		{
			tCardBook.status[0]=STATUS_LOGOUT;
		}
		else
		{
			getNextShowCardNo(showcardno,1,tCardBook.curno);
			tCardBook.unusedcnt==atof(tCardBook.endno)-atof(tCardBook.curno)+1;
		}
		getfmtsysdatetime(tCardBook.lastsaved);					
		ret=DB_t_cardbook_update_by_recordno(tCardBook.recordno,&tCardBook);
		if(ret)
			return E_DB_CARDBOOK_U; 	
	}
	else
	{
		if(strcmp(showcardno,tCardBook.endno)==0)
		{
			getNextShowCardNo(showcardno,-1,tCardBook.endno);
			tCardBook.unusedcnt=atof(tCardBook.endno)-atof(tCardBook.curno)+1;
			getfmtsysdatetime(tCardBook.lastsaved);					
			ret=DB_t_cardbook_update_by_recordno(tCardBook.recordno,&tCardBook);
			if(ret)
				return E_DB_CARDBOOK_U; 				
		}
		else
		{
			getNextShowCardNo(showcardno,-1,tCardBook.endno);
			tCardBook.unusedcnt=atof(tCardBook.endno)-atof(tCardBook.curno)+1;
			getfmtsysdatetime(tCardBook.lastsaved);
			ret=DB_t_cardbook_update_by_recordno(tCardBook.recordno,&tCardBook);
			if(ret)
				return E_DB_CARDBOOK_U; 
			////////////////////////////////////////////
			getNextShowCardNo(showcardno,1,oldtCardBook.startno);
			ret=getCardBookRecordNo(oldtCardBook.recordno);
			if(ret)
				return ret;
			strcpy(oldtCardBook.curno,oldtCardBook.startno);
			oldtCardBook.unusedcnt=atof(oldtCardBook.endno)-atof(oldtCardBook.curno)+1;
			oldtCardBook.status[0]=STATUS_NORMAL;
			getfmtsysdatetime(oldtCardBook.lastsaved);
			ret=DB_t_cardbook_add(&oldtCardBook);
			if(ret)
				return E_DB_CARDBOOK_I;
		}
		////////////////////////////////////////////
		ret=getCardBookRecordNo(oldtCardBook.recordno);
		if(ret)
			return ret;
		strcpy(oldtCardBook.curno,showcardno);
		strcpy(oldtCardBook.startno,showcardno);
		strcpy(oldtCardBook.endno,showcardno);
		oldtCardBook.usedcnt=1;
		oldtCardBook.status[0]=STATUS_LOGOUT;
		getfmtsysdatetime(oldtCardBook.lastsaved);
		ret=DB_t_cardbook_add(&oldtCardBook);
		if(ret)
			return E_DB_CARDBOOK_I;
	}
	sprintf(outPack->vsmess,"操作员%s号码%s作废成功",opercode,showcardno);
	PutRow(handle,outPack,pRetCode,szMsg);
	return 0;
}
Пример #7
0
static int doReverse(ST_PACK *rPack,char* oldaccdate,int oldtermid,int oldtermseqno)
{
	//查找操作员流水
	int ret=0;
	T_t_card tCard;
	
	CAccTrans *pAccTrans=CAccTrans::getInstance();
	TRANS& trans=pAccTrans->trans;
	trans.cardno=rPack->lvol0;

	T_t_cardtransdtl cardtransdtl;
	memset(&cardtransdtl,0,sizeof(cardtransdtl));
	ret=DB_t_cardtransdtl_read_lock_by_c0_and_accdate_and_termid_and_termseqno(oldaccdate,oldtermid,oldtermseqno,&cardtransdtl);
	if(ret)
	{
	    if(DB_NOTFOUND==ret)
	        return E_DB_CARDTRANSDTL_N;
	    else
	        return E_DB_CARDTRANSDTL_R;
	}	
	if(trans.cardno!=cardtransdtl.cardno)
	{
		DB_t_cardtransdtl_free_lock_by_c0();
		return E_CARDNO_DIFFER;
	}
	if(cardtransdtl.transcode!=TC_POSDRAW&&
		cardtransdtl.transcode!=TC_POSDRAW)
	{
		DB_t_cardtransdtl_free_lock_by_c0();
		return E_TRANSCODE_NOT_DRAW;
	}
	if(cardtransdtl.revflag[0]=='1')
	{
		DB_t_cardtransdtl_free_lock_by_c0();

		memset(&tCard,0,sizeof(tCard));
		ret=DB_t_card_read_by_cardno(cardtransdtl.cardno,&tCard);
		if(ret)
		{
			writelog(LOG_ERR,"cardno[%d]",cardtransdtl.cardno);
			if(DB_NOTFOUND==ret)
				return E_DB_CARD_N;
			else 
				return E_DB_CARD_R;
		}		
		pAccTrans->remark="该交易已冲正";
		//strcpy(cardphyid,tCard.cardphyid);
		return 0;
	}
	cardtransdtl.revflag[0]='1';
	ret=DB_t_cardtransdtl_update_lock_by_c0(&cardtransdtl);
	if(ret)
	{
	    return E_DB_CARDTRANSDTL_U;
	}	
	memset(&tCard,0,sizeof(tCard));
	ret=DB_t_card_read_lock_by_cur_and_cardno(cardtransdtl.cardno,&tCard);
	if(ret)
	{
		writelog(LOG_ERR,"cardno[%d]",cardtransdtl.cardno);
		if(DB_NOTFOUND==ret)
			return E_DB_CARD_N;
		else 
			return E_DB_CARD_R;
	}
	if(tCard.status[0]!=STATUS_NORMAL)
	{
		DB_t_card_free_lock_by_cur();
		return E_CARD_LOGOUT;
	}
	if(tCard.cardattr[CARDSTAT_TYPE_FREEZE]=='1')
	{
		DB_t_card_free_lock_by_cur();
		return E_CARDNO_FREEZE;
	}
	if(tCard.cardattr[CARDSTAT_TYPE_LOST]=='1')
	{
		DB_t_card_free_lock_by_cur();
		return E_CARDNO_LOST;
	}
//	strcpy(cardphyid,tCard.cardphyid);
	getfmtsysdatetime(tCard.lastsaved);
	ret=DB_t_card_update_lock_by_cur(&tCard);
	if(ret)
	{
		writelog(LOG_ERR,"cardno[%d]",tCard.cardno);
		if(DB_NOTFOUND==ret)
			return E_DB_CARD_N;
		else 
			return E_DB_CARD_U;
	}
	T_t_cardtransdtl cardtransdtlrev;
	memset(&cardtransdtlrev,0,sizeof(cardtransdtlrev));

	des2src(cardtransdtlrev.transdate,trans.transdate);
	des2src(cardtransdtlrev.transtime,trans.transtime);
	des2src(cardtransdtlrev.accdate,trans.accdate);
	strcpy(cardtransdtlrev.acctime,trans.acctime);
	cardtransdtlrev.termid=trans.termid;
	cardtransdtlrev.termseqno=trans.termseqno;
	cardtransdtlrev.custid=cardtransdtl.custid;	
	cardtransdtlrev.transcode=trans.transcode;
	cardtransdtlrev.paytype=0;
	cardtransdtlrev.cardno=cardtransdtl.cardno;
	cardtransdtlrev.purseno=cardtransdtl.purseno;
	cardtransdtlrev.cardcnt=rPack->lvol6+1;
	cardtransdtlrev.cardbefbal=rPack->lvol7/100.0;
	cardtransdtlrev.amount=cardtransdtl.amount;
	cardtransdtlrev.cardaftbal=cardtransdtlrev.cardbefbal+(cardtransdtl.cardaftbal-cardtransdtl.cardbefbal);
	des2src(cardtransdtlrev.opercode,trans.opercode);
	cardtransdtlrev.status[0]=DTLSTATUS_SUCCESS;
	cardtransdtlrev.errcode=0;
	ret=DB_t_cardtransdtl_add(&cardtransdtlrev);
	if(ret)
	{
	  if(DB_REPEAT==ret)
	    return E_DB_CARDTRANSDTL_E;
	  else
	    return E_DB_CARDTRANSDTL_I;
	}		
	ret=pAccTrans->doReverseTrans(oldaccdate,oldtermid,oldtermseqno);	
	if(ret)
		return ret;
	trans.cardaftbal=cardtransdtlrev.cardaftbal;
	return 0;
}
Пример #8
0
int F950052(TRUSERID *handle,int iRequest,ST_PACK *rPack,int *pRetCode,char *szMsg)
{
    int ret =0;
    //writelog(LOG_INFO,"start pos deposit");
    cpu_trade_t cpu_trade;
    CAccTrans *pAccTrans=CAccTrans::getInstance();
    TRANS& trans=pAccTrans->trans;
    ret=pAccTrans->CheckCfgUpdate();
    if(ret)
        return ret;
    T_t_authcard tAuthCard;
    T_t_transdtl transdtl;
    T_t_depositoper   tDepositOper;
    T_t_depositoperpos tDepositOperpos;
    T_t_depositshoppos tDepositShoppos;
    T_t_shop 					tDepositShop;
    T_t_account	tAccount;		//帐户表
    T_t_device tDevice;

    ST_CPACK aPack;
    ST_PACK *out_pack = &(aPack.pack);

    memset(&tAuthCard,0,sizeof(tAuthCard));
    memset(&tDepositOper,0,sizeof(tDepositOper));
    memset(&tDepositOperpos,0,sizeof(tDepositOperpos));
    memset(&tDepositShoppos,0,sizeof(tDepositShoppos));
    memset(&tDepositShop,0,sizeof(tDepositShop));
    memset(&tAccount,0,sizeof(tAccount));
    memset(&transdtl,0,sizeof(transdtl));
    int opercardno=rPack->lvol3;			//操作员号
    if(!opercardno)
        return E_INPUTNULL_CARDNO;
    trans.cardflag=1;
    trans.usecardflag=1;
    trans.cardno=rPack->lvol5;
    trans.purseno=PURSE_NO_ONE;
    trans.cardbefbal=rPack->lvol9/100.0;				//入卡金额
    trans.cardcnt= rPack->lvol7;					//入卡金额
    trans.inputamt= rPack->lvol8/100.0;			//充值金额
    trans.fundtype=1;
    transdtl.sysid= rPack->lcert_code;						//上传工作站标识(前置机注册号)
    des2src(transdtl.devphyid, rPack->sdate1);		//物理设备ID
    transdtl.devseqno=rPack->lvol4;					//上传端流水号
    ret=GetDevIdByDevPhyId(&(trans.termid),transdtl.devphyid);
    if (ret)
    {
        writelog(LOG_ERR,"GetDevIdByDevPhyId err[%d] devphy999_id[%s]",ret,transdtl.devphyid);
        return ret;
    }
    ret = DB_t_device_read_by_deviceid(trans.termid,&tDevice);
    if(ret)
    {
        writelog(LOG_ERR," DB_t_device_read_by_deviceid err[%d]",ret);
        return E_DB_DEVICE_R;
    }

    //writelog(LOG_DEBUG,"trans.inputamt[%d]",trans.inputamt);
    T_t_card tCard;
    memset(&tCard,0,sizeof(tCard));
    ret=doCard(trans,tCard);
    if(ret)
    {
        return ret;
    }
    memset(&cpu_trade,0,sizeof cpu_trade);
    cpu_trade.random_key = atoi(rPack->sstock_code);
    cpu_trade.tradeamt = rPack->lvol8;
    cpu_trade.balance = rPack->lvol9;
    cpu_trade.termsno = rPack->lvol4;
    cpu_trade.termid = tDevice.deviceno; // 终端号
    cpu_trade.tradecnt = trans.cardcnt;
    sprintf(cpu_trade.tx_datetime,"%s%s",rPack->spost_code,rPack->spost_code2);

    ret = doCheckMac(&cpu_trade,NULL,out_pack->sstock_code2);
    if(ret)
    {
        writelog(LOG_ERR,"doCheckMac err[%d]",ret);
        return ret;
    }

    trans.feetype=tCard.feetype;
    trans.cardtype=tCard.cardtype;
    ret=UpdateCardBitmap(trans.cardno,trans.cardcnt,CARDBITMAPTYPE_INC,0);
    if(ret)
        return ret;
    // 读取操作员号
    ret = DB_t_authcard_read_by_cardno(opercardno,&tAuthCard);
    if(ret)
    {
        writelog(LOG_ERR,"get operator code from auth card error, auth_card_id[%d]",opercardno);
        if(DB_NOTFOUND == ret)
            return E_DB_AUTHCARD_N;
        else
            return  E_DB_OPERATOR_R;
    }
    if(tAuthCard.status[0]!=STATUS_NORMAL)
    {
        return E_OPERLOGON_UNREG;
    }
    des2src(trans.opercode,tAuthCard.opercode);
    ret=DB_t_depositoper_read_lock_by_c0_and_opercode(trans.opercode,&tDepositOper);
    if(ret)
    {
        if(DB_NOTFOUND==ret)
            return E_DB_DEPOSITOPER_R;
        else
            return E_DB_DEPOSITOPER_N;
    }
    if(tDepositOper.status[0]!=STATUS_NORMAL)
    {
        DB_t_depositoper_free_lock_by_c0();
        return E_DEPOSITOPER_STOP;
    }
    //判断是否是重复交易
    if(tDepositOper.lastdevseqno==transdtl.devseqno)
    {
        DB_t_depositoper_free_lock_by_c0();
        ret=DB_t_transdtl_read_by_transdate_and_devphyid_and_devseqno(
                trans.transdate,tDepositOper.lastdevphyid,tDepositOper.lastdevseqno,
                &transdtl);
        if(ret)
        {
            if(DB_NOTFOUND==ret)
                return E_DB_TRANSDTL_N;
            else
                return E_DB_TRANSDTL_R;
        }
        //if(transdtl.revflag[0]=='1')
        //	return E_TRANSDTL_REV;
        ResetNormalCPack(&aPack,0,1);
        SetCol(handle,0);
        SetCol(handle,F_LVOL5,F_LVOL10,F_LCERT_CODE,0);

        out_pack->lvol5 = transdtl.cardno;
        out_pack->lvol10 = (int)D4U5(transdtl.cardaftbal*100,0);
        out_pack->lcert_code = transdtl.termseqno;
        writelog(LOG_INFO,"该交易已成功,卡号[%d]充值金额[%.2lf]卡余额[%.2lf]",transdtl.cardno,
                 transdtl.amount,transdtl.cardaftbal);
        PutRow(handle,out_pack,pRetCode,szMsg);
        return 0;
    }
    if(strncmp(tDepositOper.lasttransdate,trans.transdate,8)!=0)
    {
        des2src(tDepositOper.lasttransdate,trans.transdate);
        tDepositOper.depositcnt=0;
        tDepositOper.depositamt=0;
    }
    tDepositOper.depositcnt++;
    tDepositOper.depositamt+=trans.inputamt;
    tDepositOper.lastdevseqno=transdtl.devseqno;
    des2src(tDepositOper.lastdevphyid,transdtl.devphyid);
    getfmtsysdatetime(tDepositOper.lastsaved);
    if(amtcmp(tDepositOper.maxdepositamt,0)>0)
    {
        DB_t_depositoper_free_lock_by_c0();
        if(amtcmp(tDepositOper.depositamt,tDepositOper.maxdepositamt)>0)
        {
            return E_OPER_OVER_MAX_DEPOSIT_AMT;
        }
    }
    ret=DB_t_depositoper_update_lock_by_c0(&tDepositOper);
    if(ret)
    {
        return E_DB_DEPOSITOPER_U;
    }
    ret=DB_t_depositshoppos_read_by_deviceid(trans.termid, &tDepositShoppos);

    if(ret)
    {
        if(DB_NOTFOUND==ret)
        {
            writelog(LOG_INFO,"PosDeposit termid[%d] ",trans.termid);
            trans.transcode = TC_POSDEPOSIT;
        }
        else
        {
            return E_DB_DEPOSITSHOPPOS_R;
        }
    }
    else
    {
        writelog(LOG_INFO,"ShopPosDeposit termid[%d] ",trans.termid);
        trans.transcode = TC_SHOPPOSDEPOSIT;
        ret=DB_t_shop_read_by_shopid(tDepositShoppos.shopid, &tDepositShop);
        if(ret)
        {
            if(DB_NOTFOUND==ret)
                return E_DB_SHOP_N;
            else
                return E_DB_SHOP_R;
        }
        if(tDepositShop.status[0]!=STATUS_NORMAL)
        {
            return E_SHOP_LOGOUT;
        }
        des2src(trans.draccno,tDepositShop.accno);
    }
    ret=pAccTrans->InitTrans();
    if(ret)
        return ret;
    //根据卡号和钱包号得到消费者账号(借方)
    ret=DB_t_account_read_by_cardno_and_purseno(trans.cardno, trans.purseno,&tAccount);
    if(ret)
    {
        writelog(LOG_ERR,"DB_t_account_read_by_cardno_and_purseno ret[%d]cardno[%d]",ret,trans.cardno);
        if(DB_NOTFOUND==ret)
            return E_NOTEXIST_ACCNO;
        else
            return E_DB_ACCOUNT_R;
    }
    if(tAccount.lastcardcnt>trans.cardcnt)
    {
        return E_CARDCNT_LT_LASTCARDCNT;
    }
    if(amtcmp(trans.inputamt+trans.cardbefbal,tAccount.cardmaxbal)>0)
        return E_AMT_EXCEED_MAX;
    trans.custid=tCard.custid;
    des2src(trans.craccno,tAccount.accno);
    ret=pAccTrans->doTrans();
    if(ret)
        return ret;
    des2src(transdtl.transdate,trans.transdate);
    des2src(transdtl.transtime,trans.transtime);
    strcpy(transdtl.accdate,trans.sysdate);
    strcpy(transdtl.acctime,trans.systime);
    transdtl.termid=trans.termid;
    transdtl.termseqno=trans.termseqno;
    transdtl.transcode=trans.transcode;
    transdtl.paytype=trans.fundtype;
    des2src(transdtl.voucherno,trans.voucherno);
    transdtl.cardno=trans.cardno;
    transdtl.purseno=trans.purseno;
    transdtl.cardcnt=trans.cardcnt;
    transdtl.cardbefbal=trans.cardbefbal;
    transdtl.amount=trans.totaltransamt;
    transdtl.managefee=trans.totalfeeamt;
    transdtl.cardaftbal=trans.cardaftbal;
    transdtl.custid=trans.custid;
    des2src(transdtl.custname,tAccount.accname);
    des2src(transdtl.opercode,trans.opercode);
    transdtl.status[0]=DTLSTATUS_SUCCESS;
    ret=DB_t_transdtl_add(&transdtl);
    if(ret)
    {
        if(DB_REPEAT==ret)
            return E_DB_TRANSDTL_E;
        else
            return E_DB_TRANSDTL_I;
    }
    sprintf(trans.remark,"卡号%d 充值前卡余额:%.2lf元 卡当前余额:%.2lf元",trans.cardno,trans.cardbefbal,trans.cardaftbal);
    writelog(LOG_INFO,trans.remark);
    ResetNormalCPack(&aPack,0,1);
    SetCol(handle,0);
    SetCol(handle,F_LVOL5,F_LVOL10,F_LCERT_CODE,F_SSTOCK_CODE2,0);

    out_pack->lvol5 = trans.cardno;
    out_pack->lvol10 = (int)D4U5(trans.cardaftbal*100,0);
    out_pack->lcert_code = trans.termseqno;
    PutRow(handle,out_pack,pRetCode,szMsg);
    return 0;
}
Пример #9
0
static int AddCard(T_t_customer& tCustomer,T_t_card& tCard)
{
    //检查卡是否已经使用
    int ret=0;
    char sysdate[9];
    getsysdate(sysdate);

    tCard.status[0]=STATUS_NORMAL;
    ret=DB_t_card_read_by_cardphyid_and_status(tCard.cardphyid,tCard.status,&tCard);
    if(ret!=DB_NOTFOUND)
    {
        if(DB_SUCCESS==ret)
            return E_CARDPHYID_EXIST;
        else
            return E_DB_CARD_R;
    }
    ret=DB_t_card_read_by_showcardno_and_status(tCard.showcardno,tCard.status,&tCard);
    if(ret!=DB_NOTFOUND)
    {
        if(DB_SUCCESS==ret)
            return E_SHOWCARDNO_EXIST;
        else
            return E_DB_CARD_R;
    }
    T_t_cardtype tCardtype;

    memset(&tCardtype,0,sizeof(tCardtype));

    ret=DB_t_cardtype_read_by_cardtype(tCard.cardtype,&tCardtype);
    if(ret)
    {
        if(DB_NOTFOUND==ret)
            return E_DB_CARDTYPE_N;
        else
            return E_DB_CARDTYPE_R;
    }
    //判断到期日期
    if(strlen(tCard.expiredate)<1)
    {
        ret=IsInvalidDateTime(tCustomer.outdate,"YYYYMMDD");
        if(ret==0)
        {
            if(strncmp(tCustomer.outdate,sysdate,8)>0)
            {

                des2src(tCard.expiredate,tCustomer.outdate);
            }
        }
        else
        {

            if(tCardtype.validdays<1)
                return E_NOSET_CARDTYPE_VALIDDAYS;
            ret=calcEndDate(sysdate,tCardtype.validdays,tCard.expiredate);
            if(ret)
                return ret;
        }
    }
    else
    {
        ret=IsInvalidDateTime(tCard.expiredate,"YYYYMMDD");
        if(ret)
            return E_INPUT_EXPIREDATE;
        if(strncmp(tCard.expiredate,sysdate,8)<0)
            return E_INPUT_EXPIREDATE;
    }
    tCard.custid=tCustomer.custid;
    des2src(tCard.stuempno,tCustomer.stuempno);
    memset(tCard.cardattr,'0',sizeof(tCard.cardattr));
    des2src(tCard.opendate,sysdate);
    getfmtsysdatetime(tCard.lastsaved);
    ret = getNewUniqNo(KEYTYPE_CARDNO,&tCard.cardno);	//获取最大卡号
    if(ret)
    {
        return ret;
    }
    ret=DB_t_card_add(&tCard);
    if(ret)
    {
        if(DB_REPEAT==ret)
            return E_DB_CARD_E;
        else
            return E_DB_CARD_I;
    }
    return 0;
}
Пример #10
0
int F843362(TRUSERID *handle,int iRequest,ST_PACK *rPack,int *pRetCode,char *szMsg)
{
	int ret=0;

	CAccTrans *pAccTrans=CAccTrans::getInstance();
	des2src(pAccTrans->trans.opercode,rPack->semp);
	pAccTrans->trans.transcode=MAKETRANSCODEADD(TCM_DEPOSITOPERPOS);
	ret=pAccTrans->InitTrans();
	if(ret)
		return ret;			
	char deviceid[31]="";
	T_t_depositoperpos tDepositOperPos;
	T_t_depositoper tDepositOper;
	T_t_depositshoppos  tDepositShopPos;
	
	memset(&tDepositOperPos,0,sizeof(tDepositOperPos));
	memset(&tDepositOper,0,sizeof(tDepositOper));
	memset(&tDepositShopPos,0,sizeof(tDepositShopPos));
	
	if(!strlen(rPack->vsvarstr1))
	{
		return E_INPUT_DATA_INVAILD;
	}	
	ret=DB_t_depositoper_read_by_opercode(rPack->scust_auth,&tDepositOper);
	if(ret)
	{
		if(DB_NOTFOUND==ret)
			return ERRINFO(E_NOTEXIST_DEPOSITOPER,rPack->scust_auth);
		else
			return E_DB_DEPOSITOPER_R;
	}
	if(tDepositOper.devlimitflag[0]!='1')
	{
		return E_OPER_NO_NEED_DEVICE;
	}
	des2src(tDepositOperPos.opercode,rPack->scust_auth);
	des2src(tDepositOperPos.openoper,rPack->semp);
	getfmtsysdatetime(tDepositOperPos.lastsaved);
	vector<string>  strlist;
	split2list(rPack->vsvarstr1,',',strlist);
	for(int i=0;i<strlist.size();i++)
	{
		tDepositOperPos.deviceid=atoi(strlist[i].c_str());
		//如果操作员不是充值商户操作员则不允许绑定充值商户设备
		ret=DB_t_depositshoppos_read_by_deviceid(tDepositOperPos.deviceid, &tDepositShopPos);
		if(ret)
		{
			if(ret==DB_NOTFOUND)
			{
				if(tDepositOper.shopoperflag[0]=='1')
				{
					return ERRINFO(E_DEVICE_NOTIS_DEPOSITSHOP,tDepositOperPos.deviceid);
				}
			}	
			else
			{
				return E_DB_DEPOSITSHOPPOS_R;

			}
		}
		else
		{
			if(tDepositOper.shopoperflag[0]=='0')
			{
				return ERRINFO(E_DEVICE_IS_DEPOSITSHOP,tDepositOperPos.deviceid);
			}
		}
		SQLCODE=0;
		ret=DB_t_depositoperpos_add(&tDepositOperPos);
		if(ret)
		{
			writelog(LOG_ERR,"opercode[%s]",tDepositOperPos.opercode);
			if(DB_REPEAT==ret)
			{
				return ERRINFO(E_DB_DEPOSITOPERPOS_E,tDepositOperPos.opercode,ltos(tDepositOperPos.deviceid).c_str());
			}
			else
			{
				return E_DB_DEPOSITOPERPOS_I;
			}
		}
	}
	return 0;
}