forge-bot/acquire-core-x
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Wave E/F: 업무흐름 tpcall 오케스트레이션 + 크로스브랜치 교착 제거

Browse source 
477개 서비스를 tpcall 체인으로 연결하고(2 → 477), 그 과정에서 드러난
런타임 결함들을 실행 검증으로 잡아냈다.

체인 오케스트레이션 (Wave E)
- 매입/승인/정산/지급/대사/원장/마감/마스터/전문 흐름을 모듈 간 tpcall 로 연결
- 호출그래프 553노드 494엣지, 순환 0, SELFCALL 0
- 핵심 경로: ACQUIRE→RECONCILE→SETTLE→ST_MDR→LG_SETTLEPOST (6단, XA 2PC)

런타임 결함 수정 (Wave F) — 정적 게이트로는 잡히지 않던 것들
1. 모듈내 체인 자기교착: 모듈 서버 카피가 1이면 SETTLE→ST_MDR 처럼 같은
   서버로 되돌아오는 호출이 자기 요청을 못 꺼내 TPETIME. 카피 4로 상향.
2. 크로스브랜치 핫로우 교착: 한 글로벌 트랜잭션의 형제 XA 브랜치가 같은 행을
   UPDATE 하면 같은 트랜잭션이라 락이 안 풀려 타임아웃까지 블록된다.
   - mg_channel: 비소유자 96개 서비스의 UPDATE 제거, STAN 은 시퀀스 채번으로
     (실제 전문 스위치 방식). 생애주기 소유자 7개만 UPDATE 유지.
   - lg_merch_bal: ACQ_SETTLELINK 의 LG_SETTLEPOST 다이아몬드 호출 제거.
     교착일 뿐 아니라 같은 정산건이 원장에 이중 전기되는 회계 오류였다.
   - cl_close_log / py_payout / lg_account_bal: CHAIN 마커로 쓰기 소유자 일원화.
     py_payout 건은 피호출자가 호출자의 미커밋 승인을 볼 수 없어 기능적으로도
     동작 불능이었다.
3. cm_log PK 충돌: st 131개 파일이 max(log_id)+1 로 채번해 nextval 을 쓰는
   피호출자와 동일 PK 를 INSERT, 미커밋 인덱스 엔트리에 걸려 블록. 전부
   nextval('cm_log_seq') 로 전환.
4. strncpy 스택 파괴: cmdb_get_param 이 strncpy(out, h_val, 127) 로 항상 128
   바이트를 써서, bizdate[16] 을 넘기는 호출부 133곳이 매번 호출자 스택 112
   바이트를 훼손했다. 인접 ecpg 호스트 변수가 오염돼 서버 카피가 세그폴트.
   DB 락 대기가 0인데 60초 블록되는 증상의 원인. cm_code/py_payout_reject 동일.
5. ACQ_CANCEL→LIMIT_RST 입력계약 불일치: 카드번호를 안 실어 보내 항상 거절.
   승인원장에서 카드를 끌어오고, 무승인 매입은 한도원복을 생략하도록 수정.
6. mgdb_channel_bump_stan: 활동 채널 전체를 한 번에 잠그는 다중행 UPDATE
   (호출자 0인 잠복 지뢰). 시퀀스 채번 + 집계 조회로 교체.

화면
- 기본값을 실존 시드 키로 부팅 시 조회해 덮어쓴다. 기존 플레이스홀더
  (card_limit 에 없는 카드, 8자리 영업일)로는 처리성 화면이 전부 거절당했다.
- 게이트웨이가 단일 스레드 직렬 루프라 기본값 조회도 순차로 수행.

검증 (실측)
- 통합 빌드: modules=11 servers=11 batches=506, error 0
- 도메인: 45 프로세스, 1,466 서비스 AVAIL
- 체인 전수 스모크 477/477 응답, TPETIME/TPEABORT 0건, 최대 530ms
- AUTH: 수정 전 60초 블록→TPEABORT, 수정 후 0.215초 ok:true
- 6단 매입 체인 COMMIT OK, 미결 2PC 0

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
hyeongwoo 2026-07-21 14:55:49 +00:00
parent 4cede852a0
commit 074d244bba
654 changed files with 36008 additions and 2805 deletions
Download patch file Download diff file Expand all files Collapse all files

53
app/src/cl/svc/CL_AMTXCHECK.pgc
View file

@ -162,6 +162,59 @@ void CL_AMTXCHECK(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_AMTXCHECK 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_AXPURSETT 연동 (매입 대 정산 금액 교차 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_AXPURSETT 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_AMTXCHECK", 0L);
userlog("[CL_AMTXCHECK] 체인 호출 -> VL_AXPURSETT bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_AXPURSETT", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_AMTXCHECK] tpcall(VL_AXPURSETT) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9631);
Bchg(b, T_MSG, 0, "매입-정산 금액교차 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_AMTXCHECK] VL_AXPURSETT 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_AMTXCHECK] VL_AXPURSETT 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_APPRDELEG.pgc
View file

@ -170,6 +170,59 @@ void CL_APPRDELEG(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_APPRDELEG 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: CL_APPRSTAT 연동 (승인 위임 후 승인상태 갱신) ====
* 동일 글로벌 트랜잭션이지만 CL_APPRSTAT 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_APPRDELEG", 0L);
userlog("[CL_APPRDELEG] 체인 호출 -> CL_APPRSTAT bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("CL_APPRSTAT", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_APPRDELEG] tpcall(CL_APPRSTAT) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9663);
Bchg(b, T_MSG, 0, "위임 승인상태 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_APPRDELEG] CL_APPRSTAT 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_APPRDELEG] CL_APPRSTAT 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

69
app/src/cl/svc/CL_APPRFINAL.pgc
View file

@ -29,8 +29,12 @@ void CL_APPRFINAL(TPSVCINFO *p)
long h_kcid;
char h_zbuf[192];
EXEC SQL END DECLARE SECTION;
/* 체인 하위 호출 표식/위임 상태 (섹션4 의 행소유권 판정에 사용) */
char ch_mark[16], ch_ustat[8];
int in_chain = 0;
h_bizdate[0] = 0; h_period[0] = 0; h_zbuf[0] = 0;
z_msg[0] = 0; z_buf[0] = 0; h_zopen = 0; h_zsev = 0;
ch_mark[0] = 0; ch_ustat[0] = 0;
/* --- 섹션9: 진입 로깅 --- */
@ -40,6 +44,20 @@ void CL_APPRFINAL(TPSVCINFO *p)
h_cid = getl(b, T_ID1);
gets_(b, T_STR1, h_memo, sizeof(h_memo));
/* 체인 하위 호출 판별 (T_STR8 = "CHAIN"): 상위 서비스(CL_APPRL2)가 이미 자기
* XA 브랜치에서 cl_close_log(close_id) 행을 잠근 채 이 서비스를 부른 상태다.
* 같은 글로벌 트랜잭션의 다른 XA 브랜치가 그 행을 다시 UPDATE 하면 서로의
* 미커밋 행락을 기다려 트랜잭션 타임아웃까지 교착된다. 게다가 상위가 방금
* 전이시킨 상태는 이 브랜치에서 보이지 않아 상태판정도 틀어진다.
* 따라서 체인 하위에서는 (1) 상태판정을 전문(T_STATUS)값 기준으로 하고,
* (2) 행 UPDATE 는 생략한 뒤 확정할 상태/메모를 전문에 실어 소유자(상위)에게
* 위임한다. 업무 판정/집계/이력 적재는 그대로 수행한다. */
gets_(b, T_STR8, ch_mark, sizeof(ch_mark));
if (strcmp(ch_mark, "CHAIN") == 0) {
in_chain = 1;
userlog("CL_APPRFINAL 체인 하위 호출 - cl_close_log(%ld) 행 쓰기는 상위 브랜치에 위임", h_cid);
}
/* --- 섹션1: 입력 검증부 --- */
if (h_cid <= 0) {
setl(b, T_RC, 5601);
@ -56,6 +74,17 @@ void CL_APPRFINAL(TPSVCINFO *p)
}
if (sqlca.sqlcode < 0) { setl(b, T_RC, 5603); FAIL(b); }
st = h_status[0];
/* 체인 하위: 상위가 방금 전이시킨 상태는 미커밋이라 위 SELECT 에 안 보인다.
* 상위가 전문에 실어 준 T_STATUS 를 유효 현재상태로 삼는다(owner-writes 규율). */
if (in_chain) {
char ch_cur[8]; ch_cur[0] = 0;
gets_(b, T_STATUS, ch_cur, sizeof(ch_cur));
if (ch_cur[0] != 0) {
st = ch_cur[0];
strncpy(h_status, ch_cur, sizeof(h_status)-1); h_status[sizeof(h_status)-1] = 0;
userlog("CL_APPRFINAL 체인 하위 - 전문 상태(%c)를 유효 현재상태로 사용", st);
}
}
/* --- 섹션3: 상태전이 가능여부 분기부 --- */
if (!(st == 'C')) {
@ -73,21 +102,37 @@ void CL_APPRFINAL(TPSVCINFO *p)
else strcpy(newmemo, "APPR:FINAL");
{ char nm[128]; strncpy(nm, newmemo, sizeof(nm)-1); nm[sizeof(nm)-1]=0;
strncpy(h_memo, nm, sizeof(h_memo)-1); h_memo[sizeof(h_memo)-1]=0; }
EXEC SQL UPDATE cl_close_log
SET status = 'A', memo = :h_memo, updated_at = now()
WHERE close_id = :h_cid;
if (sqlca.sqlcode < 0) {
setl(b, T_RC, 5606);
Bchg(b, T_MSG, 0, "상태전이 실패", 0L); FAIL(b);
}
if (sqlca.sqlerrd[2] != 1) {
setl(b, T_RC, 5607);
Bchg(b, T_MSG, 0, "전이 대상행 수 이상", 0L); FAIL(b);
strcpy(ch_ustat, "A");
if (!in_chain) {
/* 행 소유자 브랜치: 직접 전이한다 */
EXEC SQL UPDATE cl_close_log
SET status = 'A', memo = :h_memo, updated_at = now()
WHERE close_id = :h_cid;
if (sqlca.sqlcode < 0) {
setl(b, T_RC, 5606);
Bchg(b, T_MSG, 0, "상태전이 실패", 0L); FAIL(b);
}
if (sqlca.sqlerrd[2] != 1) {
setl(b, T_RC, 5607);
Bchg(b, T_MSG, 0, "전이 대상행 수 이상", 0L); FAIL(b);
}
} else {
/* 체인 하위 브랜치: 행 UPDATE 를 하지 않고 확정할 상태/메모를 상위에 위임한다.
* 상위(행 소유자)가 tpcall 복귀 후 자기 브랜치에서 한 번만 반영한다. */
Bchg(b, T_STR7, 0, ch_ustat, 0L);
Bchg(b, T_STR6, 0, h_memo, 0L);
userlog("CL_APPRFINAL 체인 하위 - 전이(status=%s memo=%s) 를 상위 소유자에 위임 close_id=%ld",
ch_ustat, h_memo, h_cid);
}
/* --- 섹션6: 전이 후 상태 재확인부 --- */
EXEC SQL SELECT status INTO :h_status FROM cl_close_log WHERE close_id = :h_cid;
if (sqlca.sqlcode < 0) { setl(b, T_RC, 5608); FAIL(b); }
if (!in_chain) {
EXEC SQL SELECT status INTO :h_status FROM cl_close_log WHERE close_id = :h_cid;
if (sqlca.sqlcode < 0) { setl(b, T_RC, 5608); FAIL(b); }
} else {
/* 위임분은 아직 미반영이므로 확정 예정 상태로 응답 계약을 채운다 */
strncpy(h_status, ch_ustat, sizeof(h_status)-1); h_status[sizeof(h_status)-1] = 0;
}
Bchg(b, T_STATUS, 0, h_status, 0L);
o_count = h_cnt; o_rc = 0;
snprintf(o_msg, sizeof(o_msg), "최종 승인(A) 처리완료 상태=%c", h_status[0]);

94
app/src/cl/svc/CL_APPRL1.pgc
View file

@ -170,6 +170,100 @@ void CL_APPRL1(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_APPRL1 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: CL_APPRL2 연동 (1차 승인 후 2차 승인 요청) ====
* 동일 글로벌 트랜잭션이지만 CL_APPRL2 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_APPRL1", 0L);
/* 체인 표식: 하위(CL_APPRL2/CL_APPRFINAL)는 cl_close_log 행을 직접
* UPDATE 하지 않고 확정 상태를 T_STR7/T_STR6 로 위임한다.
* 이 행의 소유자는 방금 전이시킨 이 브랜치이므로, 반영도 여기서 한다
* (형제 XA 브랜치 간 동일행 쓰기 = 미커밋 행락 교착 방지). */
Bchg(b, T_STR8, 0, "CHAIN", 0L);
/* 하위 승인단계는 '이 서비스의 전이 이전' 상태를 기준으로 진입 가능여부를
* 판정한다(기존 동작과 동일: 하위 브랜치는 상위의 미커밋 전이를 못 본다).
* 그 판정 기준값을 전문으로 명시 전달한다. */
{ char cx0_pre[4]; cx0_pre[0] = st; cx0_pre[1] = 0;
if (cx0_pre[0] != 0) Bchg(b, T_STATUS, 0, cx0_pre, 0L); }
Bdel(b, T_STR7, 0); Bdel(b, T_STR6, 0);
userlog("[CL_APPRL1] 체인 호출 -> CL_APPRL2 bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("CL_APPRL2", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_APPRL1] tpcall(CL_APPRL2) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9671);
Bchg(b, T_MSG, 0, "2차 승인 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_APPRL1] CL_APPRL2 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_APPRL1] CL_APPRL2 체인 정상 완료 bd=%s", cx0_bd);
/* --- 위임 반영부: 하위 승인단계들이 위임한 cl_close_log 확정 전이를
* 행 소유자인 이 브랜치에서 단 한 번만 반영한다. --- */
{
char dg_st[8], dg_memo[128];
dg_st[0] = 0; dg_memo[0] = 0;
gets_(b, T_STR7, dg_st, sizeof(dg_st));
gets_(b, T_STR6, dg_memo, sizeof(dg_memo));
if (dg_st[0] != 0) {
strncpy(h_status, dg_st, sizeof(h_status)-1); h_status[sizeof(h_status)-1] = 0;
if (dg_memo[0] != 0) {
strncpy(h_memo, dg_memo, sizeof(h_memo)-1); h_memo[sizeof(h_memo)-1] = 0;
}
h_kcid = cx0_id1;
EXEC SQL UPDATE cl_close_log
SET status = :h_status, memo = :h_memo, updated_at = now()
WHERE close_id = :h_kcid;
if (sqlca.sqlcode < 0) {
setl(b, T_RC, 5609);
Bchg(b, T_MSG, 0, "승인 체인 위임 반영 실패", 0L); FAIL(b);
}
if (sqlca.sqlerrd[2] != 1) {
setl(b, T_RC, 5610);
Bchg(b, T_MSG, 0, "승인 체인 위임 대상행 수 이상", 0L); FAIL(b);
}
strncpy(cx0_st, h_status, sizeof(cx0_st)-1); cx0_st[sizeof(cx0_st)-1] = 0;
userlog("[CL_APPRL1] 위임 반영 완료 close_id=%ld status=%s", h_kcid, h_status);
Bdel(b, T_STR7, 0); Bdel(b, T_STR6, 0);
}
}
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

164
app/src/cl/svc/CL_APPRL2.pgc
View file

@ -29,8 +29,12 @@ void CL_APPRL2(TPSVCINFO *p)
long h_kcid;
char h_zbuf[192];
EXEC SQL END DECLARE SECTION;
/* 체인 하위 호출 표식/위임 상태 (섹션4 의 행소유권 판정에 사용) */
char ch_mark[16], ch_ustat[8];
int in_chain = 0;
h_bizdate[0] = 0; h_period[0] = 0; h_zbuf[0] = 0;
z_msg[0] = 0; z_buf[0] = 0; h_zopen = 0; h_zsev = 0;
ch_mark[0] = 0; ch_ustat[0] = 0;
/* --- 섹션9: 진입 로깅 --- */
@ -40,6 +44,20 @@ void CL_APPRL2(TPSVCINFO *p)
h_cid = getl(b, T_ID1);
gets_(b, T_STR1, h_memo, sizeof(h_memo));
/* 체인 하위 호출 판별 (T_STR8 = "CHAIN"): 상위 서비스(CL_APPRL1/CL_APPROVE/
* CL_APPRREQ)가 이미 자기 XA 브랜치에서 cl_close_log(close_id) 행을 잠근 채
* 이 서비스를 부른 상태다. 같은 글로벌 트랜잭션의 다른 XA 브랜치가 그 행을
* 다시 UPDATE 하면 서로의 미커밋 행락을 기다려 트랜잭션 타임아웃까지 교착된다.
* 게다가 상위가 방금 전이시킨 상태는 이 브랜치에서 보이지 않아 상태판정도 틀어진다.
* 따라서 체인 하위에서는 (1) 상태판정을 전문(T_STATUS)값 기준으로 하고,
* (2) 행 UPDATE 는 생략한 뒤 확정할 상태/메모를 전문에 실어 소유자(상위)에게
* 위임한다. 업무 판정/집계/이력 적재는 그대로 수행한다. */
gets_(b, T_STR8, ch_mark, sizeof(ch_mark));
if (strcmp(ch_mark, "CHAIN") == 0) {
in_chain = 1;
userlog("CL_APPRL2 체인 하위 호출 - cl_close_log(%ld) 행 쓰기는 상위 브랜치에 위임", h_cid);
}
/* --- 섹션1: 입력 검증부 --- */
if (h_cid <= 0) {
setl(b, T_RC, 5601);
@ -56,6 +74,17 @@ void CL_APPRL2(TPSVCINFO *p)
}
if (sqlca.sqlcode < 0) { setl(b, T_RC, 5603); FAIL(b); }
st = h_status[0];
/* 체인 하위: 상위가 방금 전이시킨 상태는 미커밋이라 위 SELECT 에 안 보인다.
* 상위가 전문에 실어 준 T_STATUS 를 유효 현재상태로 삼는다(owner-writes 규율). */
if (in_chain) {
char ch_cur[8]; ch_cur[0] = 0;
gets_(b, T_STATUS, ch_cur, sizeof(ch_cur));
if (ch_cur[0] != 0) {
st = ch_cur[0];
strncpy(h_status, ch_cur, sizeof(h_status)-1); h_status[sizeof(h_status)-1] = 0;
userlog("CL_APPRL2 체인 하위 - 전문 상태(%c)를 유효 현재상태로 사용", st);
}
}
/* --- 섹션3: 상태전이 가능여부 분기부 --- */
if (!(st == 'C')) {
@ -73,21 +102,37 @@ void CL_APPRL2(TPSVCINFO *p)
else strcpy(newmemo, "APPR:L2");
{ char nm[128]; strncpy(nm, newmemo, sizeof(nm)-1); nm[sizeof(nm)-1]=0;
strncpy(h_memo, nm, sizeof(h_memo)-1); h_memo[sizeof(h_memo)-1]=0; }
EXEC SQL UPDATE cl_close_log
SET status = 'C', memo = :h_memo, updated_at = now()
WHERE close_id = :h_cid;
if (sqlca.sqlcode < 0) {
setl(b, T_RC, 5606);
Bchg(b, T_MSG, 0, "상태전이 실패", 0L); FAIL(b);
}
if (sqlca.sqlerrd[2] != 1) {
setl(b, T_RC, 5607);
Bchg(b, T_MSG, 0, "전이 대상행 수 이상", 0L); FAIL(b);
strcpy(ch_ustat, "C");
if (!in_chain) {
/* 행 소유자 브랜치: 직접 전이한다 */
EXEC SQL UPDATE cl_close_log
SET status = 'C', memo = :h_memo, updated_at = now()
WHERE close_id = :h_cid;
if (sqlca.sqlcode < 0) {
setl(b, T_RC, 5606);
Bchg(b, T_MSG, 0, "상태전이 실패", 0L); FAIL(b);
}
if (sqlca.sqlerrd[2] != 1) {
setl(b, T_RC, 5607);
Bchg(b, T_MSG, 0, "전이 대상행 수 이상", 0L); FAIL(b);
}
} else {
/* 체인 하위 브랜치: 행 UPDATE 를 하지 않고 확정할 상태/메모를 상위에 위임한다.
* 상위(행 소유자)가 tpcall 복귀 후 자기 브랜치에서 한 번만 반영한다. */
Bchg(b, T_STR7, 0, ch_ustat, 0L);
Bchg(b, T_STR6, 0, h_memo, 0L);
userlog("CL_APPRL2 체인 하위 - 전이(status=%s memo=%s) 를 상위 소유자에 위임 close_id=%ld",
ch_ustat, h_memo, h_cid);
}
/* --- 섹션6: 전이 후 상태 재확인부 --- */
EXEC SQL SELECT status INTO :h_status FROM cl_close_log WHERE close_id = :h_cid;
if (sqlca.sqlcode < 0) { setl(b, T_RC, 5608); FAIL(b); }
if (!in_chain) {
EXEC SQL SELECT status INTO :h_status FROM cl_close_log WHERE close_id = :h_cid;
if (sqlca.sqlcode < 0) { setl(b, T_RC, 5608); FAIL(b); }
} else {
/* 위임분은 아직 미반영이므로 확정 예정 상태로 응답 계약을 채운다 */
strncpy(h_status, ch_ustat, sizeof(h_status)-1); h_status[sizeof(h_status)-1] = 0;
}
Bchg(b, T_STATUS, 0, h_status, 0L);
o_count = h_cnt; o_rc = 0;
snprintf(o_msg, sizeof(o_msg), "2차 승인(L2) 처리완료 상태=%c", h_status[0]);
@ -170,6 +215,101 @@ void CL_APPRL2(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_APPRL2 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: CL_APPRFINAL 연동 (2차 승인 후 최종 승인 확정) ====
* 동일 글로벌 트랜잭션이지만 CL_APPRFINAL 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_APPRL2", 0L);
/* 체인 표식: 하위(CL_APPRFINAL)는 cl_close_log 행을 직접 UPDATE 하지 않고
* 확정 상태를 T_STR7/T_STR6 로 위임한다(형제 브랜치 행락 교착 방지). */
Bchg(b, T_STR8, 0, "CHAIN", 0L);
/* 하위 승인단계는 '이 서비스의 전이 이전' 상태를 기준으로 진입 가능여부를
* 판정한다(기존 동작과 동일: 하위 브랜치는 상위의 미커밋 전이를 못 본다).
* 그 판정 기준값을 전문으로 명시 전달한다. */
{ char cx0_pre[4]; cx0_pre[0] = st; cx0_pre[1] = 0;
if (cx0_pre[0] != 0) Bchg(b, T_STATUS, 0, cx0_pre, 0L); }
Bdel(b, T_STR7, 0); Bdel(b, T_STR6, 0);
userlog("[CL_APPRL2] 체인 호출 -> CL_APPRFINAL bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("CL_APPRFINAL", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_APPRL2] tpcall(CL_APPRFINAL) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9661);
Bchg(b, T_MSG, 0, "최종승인 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_APPRL2] CL_APPRFINAL 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_APPRL2] CL_APPRFINAL 체인 정상 완료 bd=%s", cx0_bd);
/* --- 위임 반영부: 하위가 위임한 cl_close_log 확정 전이를 소유자 브랜치에서
* 단 한 번 반영한다. CL_APPRL2 자신이 체인 하위였다면 행 소유자가 아니므로
* 반영하지 않고 위임값을 그대로 상위로 흘려보낸다. --- */
{
char dg_st[8], dg_memo[128];
dg_st[0] = 0; dg_memo[0] = 0;
gets_(b, T_STR7, dg_st, sizeof(dg_st));
gets_(b, T_STR6, dg_memo, sizeof(dg_memo));
if (dg_st[0] != 0 && !in_chain) {
strncpy(h_status, dg_st, sizeof(h_status)-1); h_status[sizeof(h_status)-1] = 0;
if (dg_memo[0] != 0) {
strncpy(h_memo, dg_memo, sizeof(h_memo)-1); h_memo[sizeof(h_memo)-1] = 0;
}
h_kcid = cx0_id1;
EXEC SQL UPDATE cl_close_log
SET status = :h_status, memo = :h_memo, updated_at = now()
WHERE close_id = :h_kcid;
if (sqlca.sqlcode < 0) {
setl(b, T_RC, 5609);
Bchg(b, T_MSG, 0, "최종승인 위임 반영 실패", 0L); FAIL(b);
}
if (sqlca.sqlerrd[2] != 1) {
setl(b, T_RC, 5610);
Bchg(b, T_MSG, 0, "최종승인 위임 대상행 수 이상", 0L); FAIL(b);
}
strncpy(cx0_st, h_status, sizeof(cx0_st)-1); cx0_st[sizeof(cx0_st)-1] = 0;
userlog("[CL_APPRL2] 위임 반영 완료 close_id=%ld status=%s", h_kcid, h_status);
Bdel(b, T_STR7, 0); Bdel(b, T_STR6, 0);
} else if (dg_st[0] != 0) {
userlog("[CL_APPRL2] 체인 하위이므로 위임(status=%s)을 상위로 전달", dg_st);
}
}
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

94
app/src/cl/svc/CL_APPROVE.pgc
View file

@ -171,6 +171,100 @@ void CL_APPROVE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_APPROVE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: CL_APPRL2 연동 (승인 처리 후 2차 승인 확정) ====
* 동일 글로벌 트랜잭션이지만 CL_APPRL2 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_APPROVE", 0L);
/* 체인 표식: 하위(CL_APPRL2/CL_APPRFINAL)는 cl_close_log 행을 직접
* UPDATE 하지 않고 확정 상태를 T_STR7/T_STR6 로 위임한다.
* 이 행의 소유자는 방금 전이시킨 이 브랜치이므로, 반영도 여기서 한다
* (형제 XA 브랜치 간 동일행 쓰기 = 미커밋 행락 교착 방지). */
Bchg(b, T_STR8, 0, "CHAIN", 0L);
/* 하위 승인단계는 '이 서비스의 전이 이전' 상태를 기준으로 진입 가능여부를
* 판정한다(기존 동작과 동일: 하위 브랜치는 상위의 미커밋 전이를 못 본다).
* 그 판정 기준값을 전문으로 명시 전달한다. */
{ char cx0_pre[4]; cx0_pre[0] = st; cx0_pre[1] = 0;
if (cx0_pre[0] != 0) Bchg(b, T_STATUS, 0, cx0_pre, 0L); }
Bdel(b, T_STR7, 0); Bdel(b, T_STR6, 0);
userlog("[CL_APPROVE] 체인 호출 -> CL_APPRL2 bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("CL_APPRL2", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_APPROVE] tpcall(CL_APPRL2) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9673);
Bchg(b, T_MSG, 0, "승인처리 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_APPROVE] CL_APPRL2 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_APPROVE] CL_APPRL2 체인 정상 완료 bd=%s", cx0_bd);
/* --- 위임 반영부: 하위 승인단계들이 위임한 cl_close_log 확정 전이를
* 행 소유자인 이 브랜치에서 단 한 번만 반영한다. --- */
{
char dg_st[8], dg_memo[128];
dg_st[0] = 0; dg_memo[0] = 0;
gets_(b, T_STR7, dg_st, sizeof(dg_st));
gets_(b, T_STR6, dg_memo, sizeof(dg_memo));
if (dg_st[0] != 0) {
strncpy(h_status, dg_st, sizeof(h_status)-1); h_status[sizeof(h_status)-1] = 0;
if (dg_memo[0] != 0) {
strncpy(h_memo, dg_memo, sizeof(h_memo)-1); h_memo[sizeof(h_memo)-1] = 0;
}
h_kcid = cx0_id1;
EXEC SQL UPDATE cl_close_log
SET status = :h_status, memo = :h_memo, updated_at = now()
WHERE close_id = :h_kcid;
if (sqlca.sqlcode < 0) {
setl(b, T_RC, 5609);
Bchg(b, T_MSG, 0, "승인 체인 위임 반영 실패", 0L); FAIL(b);
}
if (sqlca.sqlerrd[2] != 1) {
setl(b, T_RC, 5610);
Bchg(b, T_MSG, 0, "승인 체인 위임 대상행 수 이상", 0L); FAIL(b);
}
strncpy(cx0_st, h_status, sizeof(cx0_st)-1); cx0_st[sizeof(cx0_st)-1] = 0;
userlog("[CL_APPROVE] 위임 반영 완료 close_id=%ld status=%s", h_kcid, h_status);
Bdel(b, T_STR7, 0); Bdel(b, T_STR6, 0);
}
}
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_APPRREJECT.pgc
View file

@ -171,6 +171,59 @@ void CL_APPRREJECT(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_APPRREJECT 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: CL_ESCALATE 연동 (승인 반려 시 상위 에스컬레이션) ====
* 동일 글로벌 트랜잭션이지만 CL_ESCALATE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_APPRREJECT", 0L);
userlog("[CL_APPRREJECT] 체인 호출 -> CL_ESCALATE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("CL_ESCALATE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_APPRREJECT] tpcall(CL_ESCALATE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9662);
Bchg(b, T_MSG, 0, "반려 에스컬레이션 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_APPRREJECT] CL_ESCALATE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_APPRREJECT] CL_ESCALATE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

94
app/src/cl/svc/CL_APPRREQ.pgc
View file

@ -171,6 +171,100 @@ void CL_APPRREQ(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_APPRREQ 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: CL_APPRL2 연동 (승인 요청 접수 후 2차 승인 라우팅) ====
* 동일 글로벌 트랜잭션이지만 CL_APPRL2 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_APPRREQ", 0L);
/* 체인 표식: 하위(CL_APPRL2/CL_APPRFINAL)는 cl_close_log 행을 직접
* UPDATE 하지 않고 확정 상태를 T_STR7/T_STR6 로 위임한다.
* 이 행의 소유자는 방금 전이시킨 이 브랜치이므로, 반영도 여기서 한다
* (형제 XA 브랜치 간 동일행 쓰기 = 미커밋 행락 교착 방지). */
Bchg(b, T_STR8, 0, "CHAIN", 0L);
/* 하위 승인단계는 '이 서비스의 전이 이전' 상태를 기준으로 진입 가능여부를
* 판정한다(기존 동작과 동일: 하위 브랜치는 상위의 미커밋 전이를 못 본다).
* 그 판정 기준값을 전문으로 명시 전달한다. */
{ char cx0_pre[4]; cx0_pre[0] = st; cx0_pre[1] = 0;
if (cx0_pre[0] != 0) Bchg(b, T_STATUS, 0, cx0_pre, 0L); }
Bdel(b, T_STR7, 0); Bdel(b, T_STR6, 0);
userlog("[CL_APPRREQ] 체인 호출 -> CL_APPRL2 bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("CL_APPRL2", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_APPRREQ] tpcall(CL_APPRL2) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9672);
Bchg(b, T_MSG, 0, "승인요청 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_APPRREQ] CL_APPRL2 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_APPRREQ] CL_APPRL2 체인 정상 완료 bd=%s", cx0_bd);
/* --- 위임 반영부: 하위 승인단계들이 위임한 cl_close_log 확정 전이를
* 행 소유자인 이 브랜치에서 단 한 번만 반영한다. --- */
{
char dg_st[8], dg_memo[128];
dg_st[0] = 0; dg_memo[0] = 0;
gets_(b, T_STR7, dg_st, sizeof(dg_st));
gets_(b, T_STR6, dg_memo, sizeof(dg_memo));
if (dg_st[0] != 0) {
strncpy(h_status, dg_st, sizeof(h_status)-1); h_status[sizeof(h_status)-1] = 0;
if (dg_memo[0] != 0) {
strncpy(h_memo, dg_memo, sizeof(h_memo)-1); h_memo[sizeof(h_memo)-1] = 0;
}
h_kcid = cx0_id1;
EXEC SQL UPDATE cl_close_log
SET status = :h_status, memo = :h_memo, updated_at = now()
WHERE close_id = :h_kcid;
if (sqlca.sqlcode < 0) {
setl(b, T_RC, 5609);
Bchg(b, T_MSG, 0, "승인 체인 위임 반영 실패", 0L); FAIL(b);
}
if (sqlca.sqlerrd[2] != 1) {
setl(b, T_RC, 5610);
Bchg(b, T_MSG, 0, "승인 체인 위임 대상행 수 이상", 0L); FAIL(b);
}
strncpy(cx0_st, h_status, sizeof(cx0_st)-1); cx0_st[sizeof(cx0_st)-1] = 0;
userlog("[CL_APPRREQ] 위임 반영 완료 close_id=%ld status=%s", h_kcid, h_status);
Bdel(b, T_STR7, 0); Bdel(b, T_STR6, 0);
}
}
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_BALVERIFY.pgc
View file

@ -171,6 +171,59 @@ void CL_BALVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_BALVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_LEDGBAL 연동 (마감 원장잔액 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_LEDGBAL 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_BALVERIFY", 0L);
userlog("[CL_BALVERIFY] 체인 호출 -> VL_LEDGBAL bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_LEDGBAL", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_BALVERIFY] tpcall(VL_LEDGBAL) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9613);
Bchg(b, T_MSG, 0, "원장잔액 검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_BALVERIFY] VL_LEDGBAL 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_BALVERIFY] VL_LEDGBAL 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CANCEL.pgc
View file

@ -165,6 +165,59 @@ void CL_CANCEL(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CANCEL 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_REVERSE 연동 (마감 취소 대상 전표의 원장 역분개) ====
* 동일 글로벌 트랜잭션이지만 LG_REVERSE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CANCEL", 0L);
userlog("[CL_CANCEL] 체인 호출 -> LG_REVERSE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_REVERSE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CANCEL] tpcall(LG_REVERSE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9698);
Bchg(b, T_MSG, 0, "마감취소 역분개 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CANCEL] LG_REVERSE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CANCEL] LG_REVERSE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CHKALL.pgc
View file

@ -162,6 +162,59 @@ void CL_CHKALL(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CHKALL 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_CROSSCHK 연동 (마감 전수 점검의 교차 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_CROSSCHK 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CHKALL", 0L);
userlog("[CL_CHKALL] 체인 호출 -> VL_CROSSCHK bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_CROSSCHK", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CHKALL] tpcall(VL_CROSSCHK) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9612);
Bchg(b, T_MSG, 0, "마감 교차검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CHKALL] VL_CROSSCHK 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CHKALL] VL_CROSSCHK 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CHKPENDING.pgc
View file

@ -151,6 +151,59 @@ void CL_CHKPENDING(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CHKPENDING 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_LONGOPEN 연동 (장기 미결 건 잔여 점검) ====
* 동일 글로벌 트랜잭션이지만 VL_LONGOPEN 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CHKPENDING", 0L);
userlog("[CL_CHKPENDING] 체인 호출 -> VL_LONGOPEN bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_LONGOPEN", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CHKPENDING] tpcall(VL_LONGOPEN) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9641);
Bchg(b, T_MSG, 0, "장기미결 점검 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CHKPENDING] VL_LONGOPEN 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CHKPENDING] VL_LONGOPEN 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CHKUNMATCH.pgc
View file

@ -151,6 +151,59 @@ void CL_CHKUNMATCH(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CHKUNMATCH 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_PURNOAPPR 연동 (승인 없는 매입 잔여 점검) ====
* 동일 글로벌 트랜잭션이지만 VL_PURNOAPPR 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CHKUNMATCH", 0L);
userlog("[CL_CHKUNMATCH] 체인 호출 -> VL_PURNOAPPR bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_PURNOAPPR", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CHKUNMATCH] tpcall(VL_PURNOAPPR) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9639);
Bchg(b, T_MSG, 0, "미승인매입 점검 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CHKUNMATCH] VL_PURNOAPPR 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CHKUNMATCH] VL_PURNOAPPR 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CHKVOID.pgc
View file

@ -151,6 +151,59 @@ void CL_CHKVOID(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CHKVOID 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_CANCELMIS 연동 (취소 불일치 잔여 점검) ====
* 동일 글로벌 트랜잭션이지만 VL_CANCELMIS 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CHKVOID", 0L);
userlog("[CL_CHKVOID] 체인 호출 -> VL_CANCELMIS bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_CANCELMIS", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CHKVOID] tpcall(VL_CANCELMIS) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9640);
Bchg(b, T_MSG, 0, "취소불일치 점검 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CHKVOID] VL_CANCELMIS 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CHKVOID] VL_CANCELMIS 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CHNVERIFY.pgc
View file

@ -171,6 +171,59 @@ void CL_CHNVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CHNVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_CHANSPLIT 연동 (채널별 마감 분할 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_CHANSPLIT 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CHNVERIFY", 0L);
userlog("[CL_CHNVERIFY] 체인 호출 -> VL_CHANSPLIT bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_CHANSPLIT", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CHNVERIFY] tpcall(VL_CHANSPLIT) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9622);
Bchg(b, T_MSG, 0, "채널마감 분할검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CHNVERIFY] VL_CHANSPLIT 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CHNVERIFY] VL_CHANSPLIT 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CNTVERIFY.pgc
View file

@ -170,6 +170,59 @@ void CL_CNTVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CNTVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_RULECOUNT 연동 (마감 룰 적용 건수 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_RULECOUNT 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CNTVERIFY", 0L);
userlog("[CL_CNTVERIFY] 체인 호출 -> VL_RULECOUNT bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_RULECOUNT", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CNTVERIFY] tpcall(VL_RULECOUNT) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9625);
Bchg(b, T_MSG, 0, "룰 건수검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CNTVERIFY] VL_RULECOUNT 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CNTVERIFY] VL_RULECOUNT 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CNTXCHECK.pgc
View file

@ -162,6 +162,59 @@ void CL_CNTXCHECK(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CNTXCHECK 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_AXSETTPAY 연동 (정산 대 지급 건수 교차 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_AXSETTPAY 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CNTXCHECK", 0L);
userlog("[CL_CNTXCHECK] 체인 호출 -> VL_AXSETTPAY bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_AXSETTPAY", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CNTXCHECK] tpcall(VL_AXSETTPAY) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9632);
Bchg(b, T_MSG, 0, "정산-지급 건수교차 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CNTXCHECK] VL_AXSETTPAY 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CNTXCHECK] VL_AXSETTPAY 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CORPCLOSE.pgc
View file

@ -215,6 +215,59 @@ void CL_CORPCLOSE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CORPCLOSE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_CORPSUM 연동 (법인 마감 확정분의 법인집계 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_CORPSUM 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CORPCLOSE", 0L);
userlog("[CL_CORPCLOSE] 체인 호출 -> LG_CORPSUM bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_CORPSUM", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CORPCLOSE] tpcall(LG_CORPSUM) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9693);
Bchg(b, T_MSG, 0, "법인마감 집계 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CORPCLOSE] LG_CORPSUM 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CORPCLOSE] LG_CORPSUM 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_CORPVERIFY.pgc
View file

@ -170,6 +170,59 @@ void CL_CORPVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_CORPVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_REPORT 연동 (법인 마감 보고자료 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_REPORT 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_CORPVERIFY", 0L);
userlog("[CL_CORPVERIFY] 체인 호출 -> VL_REPORT bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_REPORT", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_CORPVERIFY] tpcall(VL_REPORT) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9621);
Bchg(b, T_MSG, 0, "법인마감 보고검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_CORPVERIFY] VL_REPORT 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_CORPVERIFY] VL_REPORT 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

106
app/src/cl/svc/CL_DAILY.pgc
View file

@ -167,6 +167,112 @@ void CL_DAILY(TPSVCINFO *p)
setl(b, T_RC, o_rc);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_DAILY cid=%ld bizdate=%s 일마감 완료", cid, bizdate);
/* ==== 10) 업무흐름 체인: VL_SALES 연동 (일마감 착수 전 매출 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SALES 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_DAILY", 0L);
userlog("[CL_DAILY] 체인 호출 -> VL_SALES bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SALES", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_DAILY] tpcall(VL_SALES) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9681);
Bchg(b, T_MSG, 0, "일마감 사전 매출검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_DAILY] VL_SALES 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_DAILY] VL_SALES 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
/* ==== 11) 업무흐름 체인: LG_CLOSE_LINK 연동 (일마감 확정분의 원장 마감연계) ====
* 동일 글로벌 트랜잭션이지만 LG_CLOSE_LINK 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx1_rlen = 0, cx1_sub = 0;
long cx1_rc, cx1_id1, cx1_id2, cx1_amt;
long cx1_a5, cx1_a6, cx1_a7, cx1_a8, cx1_m2, cx1_m3;
char cx1_bd[16], cx1_mid[64], cx1_st[16], cx1_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx1_rc = getl(b, T_RC); cx1_id1 = getl(b, T_ID1); cx1_id2 = getl(b, T_ID2);
cx1_amt = getl(b, T_AMOUNT);
cx1_a5 = getl(b, T_ARG5); cx1_a6 = getl(b, T_ARG6);
cx1_a7 = getl(b, T_ARG7); cx1_a8 = getl(b, T_ARG8);
cx1_m2 = getl(b, T_AMT2); cx1_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx1_st, sizeof(cx1_st));
gets_(b, T_MSG, cx1_msg, sizeof(cx1_msg));
gets_(b, T_BIZDATE, cx1_bd, sizeof(cx1_bd));
gets_(b, T_MERCHANT, cx1_mid, sizeof(cx1_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx1_id1);
setl(b, T_AMOUNT, cx1_amt);
if (cx1_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx1_bd, 0L);
if (cx1_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx1_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_DAILY", 0L);
userlog("[CL_DAILY] 체인 호출 -> LG_CLOSE_LINK bd=%s id=%ld amt=%ld",
cx1_bd, cx1_id1, cx1_amt);
if (tpcall("LG_CLOSE_LINK", (char *)b, 0L, (char **)&b, &cx1_rlen, 0L) < 0) {
userlog("[CL_DAILY] tpcall(LG_CLOSE_LINK) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9682);
Bchg(b, T_MSG, 0, "일마감 원장연계 체인 실패", 0L);
FAIL(b);
}
cx1_sub = getl(b, T_RC);
if (cx1_sub != 0)
userlog("[CL_DAILY] LG_CLOSE_LINK 경고 통보 rc=%ld — 상위 판단 계속", cx1_sub);
else
userlog("[CL_DAILY] LG_CLOSE_LINK 체인 정상 완료 bd=%s", cx1_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx1_rc); setl(b, T_ID1, cx1_id1); setl(b, T_ID2, cx1_id2);
setl(b, T_AMOUNT, cx1_amt);
setl(b, T_ARG5, cx1_a5); setl(b, T_ARG6, cx1_a6);
setl(b, T_ARG7, cx1_a7); setl(b, T_ARG8, cx1_a8);
setl(b, T_AMT2, cx1_m2); setl(b, T_AMT3, cx1_m3);
if (cx1_st[0] != 0) Bchg(b, T_STATUS, 0, cx1_st, 0L);
if (cx1_msg[0] != 0) Bchg(b, T_MSG, 0, cx1_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_DAYVERIFY.pgc
View file

@ -170,6 +170,59 @@ void CL_DAYVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_DAYVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SALES 연동 (일마감 매출 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SALES 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_DAYVERIFY", 0L);
userlog("[CL_DAYVERIFY] 체인 호출 -> VL_SALES bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SALES", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_DAYVERIFY] tpcall(VL_SALES) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9614);
Bchg(b, T_MSG, 0, "일마감 매출검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_DAYVERIFY] VL_SALES 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_DAYVERIFY] VL_SALES 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_DIFFCHK.pgc
View file

@ -150,6 +150,59 @@ void CL_DIFFCHK(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_DIFFCHK 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_AMOUNT 연동 (마감 차이 금액 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_AMOUNT 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_DIFFCHK", 0L);
userlog("[CL_DIFFCHK] 체인 호출 -> VL_AMOUNT bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_AMOUNT", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_DIFFCHK] tpcall(VL_AMOUNT) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9643);
Bchg(b, T_MSG, 0, "차이 금액검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_DIFFCHK] VL_AMOUNT 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_DIFFCHK] VL_AMOUNT 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_DIVCLOSE.pgc
View file

@ -215,6 +215,59 @@ void CL_DIVCLOSE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_DIVCLOSE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_DEPTSUM 연동 (사업부 마감 확정분의 부서집계 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_DEPTSUM 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_DIVCLOSE", 0L);
userlog("[CL_DIVCLOSE] 체인 호출 -> LG_DEPTSUM bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_DEPTSUM", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_DIVCLOSE] tpcall(LG_DEPTSUM) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9694);
Bchg(b, T_MSG, 0, "사업부마감 집계 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_DIVCLOSE] LG_DEPTSUM 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_DIVCLOSE] LG_DEPTSUM 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_DUPCHK.pgc
View file

@ -157,6 +157,59 @@ void CL_DUPCHK(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_DUPCHK 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_DUP 연동 (마감 대상 중복 점검) ====
* 동일 글로벌 트랜잭션이지만 VL_DUP 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_DUPCHK", 0L);
userlog("[CL_DUPCHK] 체인 호출 -> VL_DUP bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_DUP", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_DUPCHK] tpcall(VL_DUP) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9642);
Bchg(b, T_MSG, 0, "중복 점검 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_DUPCHK] VL_DUP 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_DUPCHK] VL_DUP 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_FEECROSS.pgc
View file

@ -161,6 +161,59 @@ void CL_FEECROSS(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_FEECROSS 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SUMFEECHK 연동 (수수료 합계 교차 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SUMFEECHK 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_FEECROSS", 0L);
userlog("[CL_FEECROSS] 체인 호출 -> VL_SUMFEECHK bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SUMFEECHK", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_FEECROSS] tpcall(VL_SUMFEECHK) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9637);
Bchg(b, T_MSG, 0, "수수료 합계교차 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_FEECROSS] VL_SUMFEECHK 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_FEECROSS] VL_SUMFEECHK 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_FEEVERIFY.pgc
View file

@ -171,6 +171,59 @@ void CL_FEEVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_FEEVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_FEE 연동 (마감 수수료 산출 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_FEE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_FEEVERIFY", 0L);
userlog("[CL_FEEVERIFY] 체인 호출 -> VL_FEE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_FEE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_FEEVERIFY] tpcall(VL_FEE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9624);
Bchg(b, T_MSG, 0, "수수료 검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_FEEVERIFY] VL_FEE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_FEEVERIFY] VL_FEE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_FORCECLOSE.pgc
View file

@ -208,6 +208,59 @@ void CL_FORCECLOSE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_FORCECLOSE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_CLOSE_LINK 연동 (강제 마감 확정분의 원장 마감연계) ====
* 동일 글로벌 트랜잭션이지만 LG_CLOSE_LINK 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_FORCECLOSE", 0L);
userlog("[CL_FORCECLOSE] 체인 호출 -> LG_CLOSE_LINK bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_CLOSE_LINK", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_FORCECLOSE] tpcall(LG_CLOSE_LINK) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9696);
Bchg(b, T_MSG, 0, "강제마감 원장연계 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_FORCECLOSE] LG_CLOSE_LINK 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_FORCECLOSE] LG_CLOSE_LINK 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_HALFCLOSE.pgc
View file

@ -208,6 +208,59 @@ void CL_HALFCLOSE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_HALFCLOSE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_ROLLTB 연동 (반기마감 확정분의 이월 시산표 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_ROLLTB 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_HALFCLOSE", 0L);
userlog("[CL_HALFCLOSE] 체인 호출 -> LG_ROLLTB bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_ROLLTB", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_HALFCLOSE] tpcall(LG_ROLLTB) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9687);
Bchg(b, T_MSG, 0, "반기마감 이월시산 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_HALFCLOSE] LG_ROLLTB 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_HALFCLOSE] LG_ROLLTB 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_HYVERIFY.pgc
View file

@ -170,6 +170,59 @@ void CL_HYVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_HYVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SUMFEE 연동 (반기마감 수수료 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SUMFEE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_HYVERIFY", 0L);
userlog("[CL_HYVERIFY] 체인 호출 -> VL_SUMFEE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SUMFEE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_HYVERIFY] tpcall(VL_SUMFEE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9619);
Bchg(b, T_MSG, 0, "반기마감 수수료검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_HYVERIFY] VL_SUMFEE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_HYVERIFY] VL_SUMFEE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_MAINCLOSE.pgc
View file

@ -207,6 +207,59 @@ void CL_MAINCLOSE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_MAINCLOSE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_CLOSE_LINK 연동 (본마감 확정분의 원장 마감연계) ====
* 동일 글로벌 트랜잭션이지만 LG_CLOSE_LINK 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_MAINCLOSE", 0L);
userlog("[CL_MAINCLOSE] 체인 호출 -> LG_CLOSE_LINK bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_CLOSE_LINK", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_MAINCLOSE] tpcall(LG_CLOSE_LINK) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9695);
Bchg(b, T_MSG, 0, "본마감 원장연계 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_MAINCLOSE] LG_CLOSE_LINK 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_MAINCLOSE] LG_CLOSE_LINK 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_MERCLOSE.pgc
View file

@ -215,6 +215,59 @@ void CL_MERCLOSE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_MERCLOSE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_MERCHPROOF 연동 (가맹점 마감 확정분의 잔액증명 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_MERCHPROOF 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_MERCLOSE", 0L);
userlog("[CL_MERCLOSE] 체인 호출 -> LG_MERCHPROOF bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_MERCHPROOF", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_MERCLOSE] tpcall(LG_MERCHPROOF) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9692);
Bchg(b, T_MSG, 0, "가맹점마감 증명 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_MERCLOSE] LG_MERCHPROOF 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_MERCLOSE] LG_MERCHPROOF 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_MERXCHECK.pgc
View file

@ -162,6 +162,59 @@ void CL_MERXCHECK(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_MERXCHECK 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_RIMERCH 연동 (가맹점 참조무결성 교차 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_RIMERCH 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_MERXCHECK", 0L);
userlog("[CL_MERXCHECK] 체인 호출 -> VL_RIMERCH bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_RIMERCH", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_MERXCHECK] tpcall(VL_RIMERCH) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9633);
Bchg(b, T_MSG, 0, "가맹점 참조무결성 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_MERXCHECK] VL_RIMERCH 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_MERXCHECK] VL_RIMERCH 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_MIDCLOSE.pgc
View file

@ -208,6 +208,59 @@ void CL_MIDCLOSE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_MIDCLOSE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_MERCHBAL 연동 (중간마감 확정분의 가맹점 잔액 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_MERCHBAL 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_MIDCLOSE", 0L);
userlog("[CL_MIDCLOSE] 체인 호출 -> LG_MERCHBAL bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_MERCHBAL", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_MIDCLOSE] tpcall(LG_MERCHBAL) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9691);
Bchg(b, T_MSG, 0, "중간마감 가맹점잔액 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_MIDCLOSE] LG_MERCHBAL 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_MIDCLOSE] LG_MERCHBAL 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_MONTHLY.pgc
View file

@ -208,6 +208,59 @@ void CL_MONTHLY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_MONTHLY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_MONTHLYSUM 연동 (월마감 확정분의 원장 월집계 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_MONTHLYSUM 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_MONTHLY", 0L);
userlog("[CL_MONTHLY] 체인 호출 -> LG_MONTHLYSUM bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_MONTHLYSUM", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_MONTHLY] tpcall(LG_MONTHLYSUM) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9683);
Bchg(b, T_MSG, 0, "월마감 원장집계 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_MONTHLY] LG_MONTHLYSUM 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_MONTHLY] LG_MONTHLYSUM 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_MONVERIFY.pgc
View file

@ -170,6 +170,59 @@ void CL_MONVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_MONVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SUMMARY 연동 (월마감 요약 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SUMMARY 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_MONVERIFY", 0L);
userlog("[CL_MONVERIFY] 체인 호출 -> VL_SUMMARY bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SUMMARY", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_MONVERIFY] tpcall(VL_SUMMARY) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9615);
Bchg(b, T_MSG, 0, "월마감 요약검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_MONVERIFY] VL_SUMMARY 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_MONVERIFY] VL_SUMMARY 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_NETCROSS.pgc
View file

@ -161,6 +161,59 @@ void CL_NETCROSS(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_NETCROSS 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SETTLE 연동 (정산 순액 교차 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SETTLE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_NETCROSS", 0L);
userlog("[CL_NETCROSS] 체인 호출 -> VL_SETTLE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SETTLE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_NETCROSS] tpcall(VL_SETTLE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9636);
Bchg(b, T_MSG, 0, "정산 순액교차 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_NETCROSS] VL_SETTLE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_NETCROSS] VL_SETTLE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_NETVERIFY.pgc
View file

@ -171,6 +171,59 @@ void CL_NETVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_NETVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_NEGNET 연동 (마감 순액 음수 이상 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_NEGNET 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_NETVERIFY", 0L);
userlog("[CL_NETVERIFY] 체인 호출 -> VL_NEGNET bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_NEGNET", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_NETVERIFY] tpcall(VL_NEGNET) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9623);
Bchg(b, T_MSG, 0, "순액 음수검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_NETVERIFY] VL_NEGNET 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_NETVERIFY] VL_NEGNET 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_POSTTRIG.pgc
View file

@ -148,6 +148,59 @@ void CL_POSTTRIG(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_POSTTRIG 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: ST_DAILYCLOSE 연동 (마감 후처리로 정산 일마감 트리거) ====
* 동일 글로벌 트랜잭션이지만 ST_DAILYCLOSE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_POSTTRIG", 0L);
userlog("[CL_POSTTRIG] 체인 호출 -> ST_DAILYCLOSE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("ST_DAILYCLOSE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_POSTTRIG] tpcall(ST_DAILYCLOSE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9652);
Bchg(b, T_MSG, 0, "정산 일마감 트리거 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_POSTTRIG] ST_DAILYCLOSE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_POSTTRIG] ST_DAILYCLOSE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_PRECHECK.pgc
View file

@ -159,6 +159,59 @@ void CL_PRECHECK(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_PRECHECK 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_REQUIRED 연동 (마감 착수 전 필수항목 점검) ====
* 동일 글로벌 트랜잭션이지만 VL_REQUIRED 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_PRECHECK", 0L);
userlog("[CL_PRECHECK] 체인 호출 -> VL_REQUIRED bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_REQUIRED", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_PRECHECK] tpcall(VL_REQUIRED) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9638);
Bchg(b, T_MSG, 0, "마감 필수항목 점검 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_PRECHECK] VL_REQUIRED 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_PRECHECK] VL_REQUIRED 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_QTRVERIFY.pgc
View file

@ -170,6 +170,59 @@ void CL_QTRVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_QTRVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SUMRECON 연동 (분기마감 대사 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SUMRECON 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_QTRVERIFY", 0L);
userlog("[CL_QTRVERIFY] 체인 호출 -> VL_SUMRECON bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SUMRECON", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_QTRVERIFY] tpcall(VL_SUMRECON) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9616);
Bchg(b, T_MSG, 0, "분기마감 대사검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_QTRVERIFY] VL_SUMRECON 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_QTRVERIFY] VL_SUMRECON 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_QUARTER.pgc
View file

@ -208,6 +208,59 @@ void CL_QUARTER(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_QUARTER 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_PERIODTB 연동 (분기마감 확정분의 기간 시산표 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_PERIODTB 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_QUARTER", 0L);
userlog("[CL_QUARTER] 체인 호출 -> LG_PERIODTB bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_PERIODTB", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_QUARTER] tpcall(LG_PERIODTB) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9684);
Bchg(b, T_MSG, 0, "분기마감 기간시산 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_QUARTER] LG_PERIODTB 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_QUARTER] LG_PERIODTB 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_RECLOSE.pgc
View file

@ -172,6 +172,59 @@ void CL_RECLOSE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_RECLOSE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_REVERSE 연동 (재마감 대상 전표의 원장 역분개) ====
* 동일 글로벌 트랜잭션이지만 LG_REVERSE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_RECLOSE", 0L);
userlog("[CL_RECLOSE] 체인 호출 -> LG_REVERSE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_REVERSE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_RECLOSE] tpcall(LG_REVERSE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9697);
Bchg(b, T_MSG, 0, "재마감 역분개 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_RECLOSE] LG_REVERSE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_RECLOSE] LG_REVERSE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_RECON.pgc
View file

@ -171,6 +171,59 @@ void CL_RECON(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_RECON 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SUMRECON 연동 (마감 대사 합계 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SUMRECON 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_RECON", 0L);
userlog("[CL_RECON] 체인 호출 -> VL_SUMRECON bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SUMRECON", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_RECON] tpcall(VL_SUMRECON) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9644);
Bchg(b, T_MSG, 0, "마감 대사 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_RECON] VL_SUMRECON 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_RECON] VL_SUMRECON 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_ROLLBACK.pgc
View file

@ -162,6 +162,59 @@ void CL_ROLLBACK(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_ROLLBACK 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_REVERSE 연동 (마감 롤백 대상 전표의 원장 역분개) ====
* 동일 글로벌 트랜잭션이지만 LG_REVERSE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_ROLLBACK", 0L);
userlog("[CL_ROLLBACK] 체인 호출 -> LG_REVERSE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_REVERSE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_ROLLBACK] tpcall(LG_REVERSE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9699);
Bchg(b, T_MSG, 0, "마감롤백 역분개 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_ROLLBACK] LG_REVERSE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_ROLLBACK] LG_REVERSE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_SEGVERIFY.pgc
View file

@ -170,6 +170,59 @@ void CL_SEGVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_SEGVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SUMNETCHK 연동 (세그먼트 마감 순액 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SUMNETCHK 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_SEGVERIFY", 0L);
userlog("[CL_SEGVERIFY] 체인 호출 -> VL_SUMNETCHK bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SUMNETCHK", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_SEGVERIFY] tpcall(VL_SUMNETCHK) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9620);
Bchg(b, T_MSG, 0, "세그먼트 순액검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_SEGVERIFY] VL_SUMNETCHK 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_SEGVERIFY] VL_SUMNETCHK 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_SEMIMONTH.pgc
View file

@ -207,6 +207,59 @@ void CL_SEMIMONTH(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_SEMIMONTH 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_CORPSUM 연동 (반월마감 확정분의 법인집계 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_CORPSUM 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_SEMIMONTH", 0L);
userlog("[CL_SEMIMONTH] 체인 호출 -> LG_CORPSUM bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_CORPSUM", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_SEMIMONTH] tpcall(LG_CORPSUM) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9690);
Bchg(b, T_MSG, 0, "반월마감 법인집계 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_SEMIMONTH] LG_CORPSUM 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_SEMIMONTH] LG_CORPSUM 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_SNAPSHOT.pgc
View file

@ -175,6 +175,59 @@ void CL_SNAPSHOT(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_SNAPSHOT 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_TRIALBAL 연동 (마감 스냅샷 생성 시 시산표 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_TRIALBAL 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_SNAPSHOT", 0L);
userlog("[CL_SNAPSHOT] 체인 호출 -> LG_TRIALBAL bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_TRIALBAL", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_SNAPSHOT] tpcall(LG_TRIALBAL) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9686);
Bchg(b, T_MSG, 0, "스냅샷 시산표 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_SNAPSHOT] LG_TRIALBAL 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_SNAPSHOT] LG_TRIALBAL 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_SNAPXCHECK.pgc
View file

@ -162,6 +162,59 @@ void CL_SNAPXCHECK(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_SNAPXCHECK 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_AXLEDGDC 연동 (스냅샷 대 원장 차대 교차 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_AXLEDGDC 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_SNAPXCHECK", 0L);
userlog("[CL_SNAPXCHECK] 체인 호출 -> VL_AXLEDGDC bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_AXLEDGDC", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_SNAPXCHECK] tpcall(VL_AXLEDGDC) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9634);
Bchg(b, T_MSG, 0, "스냅샷 차대교차 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_SNAPXCHECK] VL_AXLEDGDC 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_SNAPXCHECK] VL_AXLEDGDC 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_STCROSS.pgc
View file

@ -162,6 +162,59 @@ void CL_STCROSS(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_STCROSS 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_RISETTLE 연동 (정산 참조무결성 교차 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_RISETTLE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_STCROSS", 0L);
userlog("[CL_STCROSS] 체인 호출 -> VL_RISETTLE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_RISETTLE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_STCROSS] tpcall(VL_RISETTLE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9635);
Bchg(b, T_MSG, 0, "정산 참조무결성 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_STCROSS] VL_RISETTLE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_STCROSS] VL_RISETTLE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_TENDAY.pgc
View file

@ -207,6 +207,59 @@ void CL_TENDAY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_TENDAY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_DEPTSUM 연동 (순(10일)마감 확정분의 부서집계 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_DEPTSUM 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_TENDAY", 0L);
userlog("[CL_TENDAY] 체인 호출 -> LG_DEPTSUM bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_DEPTSUM", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_TENDAY] tpcall(LG_DEPTSUM) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9689);
Bchg(b, T_MSG, 0, "순마감 부서집계 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_TENDAY] LG_DEPTSUM 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_TENDAY] LG_DEPTSUM 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_TRIGSETTLE.pgc
View file

@ -148,6 +148,59 @@ void CL_TRIGSETTLE(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_TRIGSETTLE 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: SETTLE 연동 (마감 확정에 따른 정산 실행 트리거) ====
* 동일 글로벌 트랜잭션이지만 SETTLE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_TRIGSETTLE", 0L);
userlog("[CL_TRIGSETTLE] 체인 호출 -> SETTLE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("SETTLE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_TRIGSETTLE] tpcall(SETTLE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9651);
Bchg(b, T_MSG, 0, "정산 트리거 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_TRIGSETTLE] SETTLE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_TRIGSETTLE] SETTLE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_VERIFY.pgc
View file

@ -171,6 +171,59 @@ void CL_VERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_VERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_BALANCE 연동 (마감 확정 전 잔액 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_BALANCE 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_VERIFY", 0L);
userlog("[CL_VERIFY] 체인 호출 -> VL_BALANCE bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_BALANCE", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_VERIFY] tpcall(VL_BALANCE) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9611);
Bchg(b, T_MSG, 0, "마감 잔액검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_VERIFY] VL_BALANCE 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_VERIFY] VL_BALANCE 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_WEEKLY.pgc
View file

@ -207,6 +207,59 @@ void CL_WEEKLY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_WEEKLY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_ACCTSUM 연동 (주마감 확정분의 계정집계 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_ACCTSUM 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_WEEKLY", 0L);
userlog("[CL_WEEKLY] 체인 호출 -> LG_ACCTSUM bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_ACCTSUM", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_WEEKLY] tpcall(LG_ACCTSUM) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9688);
Bchg(b, T_MSG, 0, "주마감 계정집계 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_WEEKLY] LG_ACCTSUM 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_WEEKLY] LG_ACCTSUM 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_WEEKVERIFY.pgc
View file

@ -170,6 +170,59 @@ void CL_WEEKVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_WEEKVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SUMTXNCNT 연동 (주마감 거래건수 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SUMTXNCNT 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_WEEKVERIFY", 0L);
userlog("[CL_WEEKVERIFY] 체인 호출 -> VL_SUMTXNCNT bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SUMTXNCNT", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_WEEKVERIFY] tpcall(VL_SUMTXNCNT) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9618);
Bchg(b, T_MSG, 0, "주마감 건수검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_WEEKVERIFY] VL_SUMTXNCNT 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_WEEKVERIFY] VL_SUMTXNCNT 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_YEAREND.pgc
View file

@ -208,6 +208,59 @@ void CL_YEAREND(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_YEAREND 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: LG_SPANTB 연동 (연마감 확정분의 구간 시산표 연동) ====
* 동일 글로벌 트랜잭션이지만 LG_SPANTB 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_YEAREND", 0L);
userlog("[CL_YEAREND] 체인 호출 -> LG_SPANTB bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("LG_SPANTB", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_YEAREND] tpcall(LG_SPANTB) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9685);
Bchg(b, T_MSG, 0, "연마감 구간시산 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_YEAREND] LG_SPANTB 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_YEAREND] LG_SPANTB 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}

53
app/src/cl/svc/CL_YEARVERIFY.pgc
View file

@ -170,6 +170,59 @@ void CL_YEARVERIFY(TPSVCINFO *p)
setl(b, T_GROSS, o_amount);
Bchg(b, T_MSG, 0, o_msg, 0L);
userlog("CL_YEARVERIFY 완료: rc=%ld count=%ld amount=%ld", o_rc, o_count, o_amount);
/* ==== 10) 업무흐름 체인: VL_SUMGROSS 연동 (연마감 총액 정합성 검증) ====
* 동일 글로벌 트랜잭션이지만 VL_SUMGROSS 는 별도 XA 브랜치에서 수행된다.
* 위에서 적재/갱신한 행은 아직 미커밋이라 하위 브랜치에서 보이지 않으므로
* 판단에 필요한 값은 전문(UBF)에 실어 전달한다(owner-writes 규율).
* 호출 실패는 보상 없이 FAIL(b) -> 글로벌 트랜잭션 전체 롤백. */
{
long cx0_rlen = 0, cx0_sub = 0;
long cx0_rc, cx0_id1, cx0_id2, cx0_amt;
long cx0_a5, cx0_a6, cx0_a7, cx0_a8, cx0_m2, cx0_m3;
char cx0_bd[16], cx0_mid[64], cx0_st[16], cx0_msg[192];
/* 응답 계약 스냅샷 (하위 서비스가 덮어쓴 뒤 복원하기 위함) */
cx0_rc = getl(b, T_RC); cx0_id1 = getl(b, T_ID1); cx0_id2 = getl(b, T_ID2);
cx0_amt = getl(b, T_AMOUNT);
cx0_a5 = getl(b, T_ARG5); cx0_a6 = getl(b, T_ARG6);
cx0_a7 = getl(b, T_ARG7); cx0_a8 = getl(b, T_ARG8);
cx0_m2 = getl(b, T_AMT2); cx0_m3 = getl(b, T_AMT3);
gets_(b, T_STATUS, cx0_st, sizeof(cx0_st));
gets_(b, T_MSG, cx0_msg, sizeof(cx0_msg));
gets_(b, T_BIZDATE, cx0_bd, sizeof(cx0_bd));
gets_(b, T_MERCHANT, cx0_mid, sizeof(cx0_mid));
/* 하위 서비스가 쓸 값을 전문에 적재 (미커밋 행 조회 의존 금지) */
setl(b, T_ID1, cx0_id1);
setl(b, T_AMOUNT, cx0_amt);
if (cx0_bd[0] != 0) Bchg(b, T_BIZDATE, 0, cx0_bd, 0L);
if (cx0_mid[0] != 0) Bchg(b, T_MERCHANT, 0, cx0_mid, 0L);
Bchg(b, T_SVCNAME, 0, "CL_YEARVERIFY", 0L);
userlog("[CL_YEARVERIFY] 체인 호출 -> VL_SUMGROSS bd=%s id=%ld amt=%ld",
cx0_bd, cx0_id1, cx0_amt);
if (tpcall("VL_SUMGROSS", (char *)b, 0L, (char **)&b, &cx0_rlen, 0L) < 0) {
userlog("[CL_YEARVERIFY] tpcall(VL_SUMGROSS) 실패: %s", tpstrerror(tperrno));
setl(b, T_RC, 9617);
Bchg(b, T_MSG, 0, "연마감 총액검증 체인 실패", 0L);
FAIL(b);
}
cx0_sub = getl(b, T_RC);
if (cx0_sub != 0)
userlog("[CL_YEARVERIFY] VL_SUMGROSS 경고 통보 rc=%ld — 상위 판단 계속", cx0_sub);
else
userlog("[CL_YEARVERIFY] VL_SUMGROSS 체인 정상 완료 bd=%s", cx0_bd);
/* 응답 계약 복원: 원 서비스의 출력 필드는 하위 결과로 바뀌지 않는다 */
setl(b, T_RC, cx0_rc); setl(b, T_ID1, cx0_id1); setl(b, T_ID2, cx0_id2);
setl(b, T_AMOUNT, cx0_amt);
setl(b, T_ARG5, cx0_a5); setl(b, T_ARG6, cx0_a6);
setl(b, T_ARG7, cx0_a7); setl(b, T_ARG8, cx0_a8);
setl(b, T_AMT2, cx0_m2); setl(b, T_AMT3, cx0_m3);
if (cx0_st[0] != 0) Bchg(b, T_STATUS, 0, cx0_st, 0L);
if (cx0_msg[0] != 0) Bchg(b, T_MSG, 0, cx0_msg, 0L);
}
OK(b);
}