sk-front-lib 0.19.14 → 0.19.16

package/crud/sk-order.service.d.ts

@@ -28,9 +28,28 @@ export declare class SkOrderService {
     }): Observable<any>;
     updateAdminShippingStatus(id: string, data: any): Observable<any>;
     deleteAdminOrders(orders: ISkOrderList[]): Observable<any>;
+    /**
+     * Design Ref: vbank-cancel-toss §4.2 — 사용자 자가 취소 (Plan FR-11).
+     *
+     * data 페이로드는 PaymentType별로 가변 필드:
+     *   - 공통: cancelType, cancelDesc, agree
+     *   - TRANSFER 분기: bankName, bankAcc, bankOwner (기존 보존)
+     *   - VBANK 분기 (NEW): vbankRefundIntent + (intent=ALREADY_DEPOSITED일 때만) vbankRefundBankCode/AccountNumber/HolderName
+     *
+     * 백엔드 OrderReqDTO.Cancel과 키 정합 필수 (drift 시 토스 환불 누락 위험).
+     * Optional 필드들은 Angular `formGroup.value`가 disable된 컨트롤을 자동 제외하므로
+     * 호출 측은 단순히 formGroup.value를 그대로 전달하면 됨.
+     */
     cancelOrder(id: string, data: {
         cancelType: SkOrderCancelType;
         cancelDesc: String;
+        bankName?: string;
+        bankAcc?: string;
+        bankOwner?: string;
+        vbankRefundIntent?: 'ALREADY_DEPOSITED' | 'NOT_YET_DEPOSITED';
+        vbankRefundBankCode?: string;
+        vbankRefundAccountNumber?: string;
+        vbankRefundHolderName?: string;
     }): Observable<SkOrderDetail>;
     startProgress(id: string, data: ISkOrderReqProgress): Observable<SkOrderStatus>;
     moveToMyOrder(id: string): Observable<string>;

package/esm2020/crud/sk-order.service.mjs

@@ -84,6 +84,18 @@ export class SkOrderService {
     deleteAdminOrders(orders) {
         return this._apiService.delete(`/api/admin/orders/${orders.map(order => order.id).join(',')}`);
     }
+    /**
+     * Design Ref: vbank-cancel-toss §4.2 — 사용자 자가 취소 (Plan FR-11).
+     *
+     * data 페이로드는 PaymentType별로 가변 필드:
+     *   - 공통: cancelType, cancelDesc, agree
+     *   - TRANSFER 분기: bankName, bankAcc, bankOwner (기존 보존)
+     *   - VBANK 분기 (NEW): vbankRefundIntent + (intent=ALREADY_DEPOSITED일 때만) vbankRefundBankCode/AccountNumber/HolderName
+     *
+     * 백엔드 OrderReqDTO.Cancel과 키 정합 필수 (drift 시 토스 환불 누락 위험).
+     * Optional 필드들은 Angular `formGroup.value`가 disable된 컨트롤을 자동 제외하므로
+     * 호출 측은 단순히 formGroup.value를 그대로 전달하면 됨.
+     */
     cancelOrder(id, data) {
         return this._apiService.put(`/api/public/orders/${id}/cancel`, data)
             .pipe(map(result => result.data));
@@ -130,4 +142,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.2.10", ngImpo
                     providedIn: 'root'
                 }]
         }], ctorParameters: function () { return [{ type: i1.SkApiService }]; } });
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sk-order.service.js","sourceRoot":"","sources":["../../../../projects/sk-front-lib/crud/src/sk-order.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpParams } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\n\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nimport { ApiPageable, ApiPageableParam, SkApiService } from 'sk-front-lib/api';\nimport {\n    ISkOrderCount,\n    ISkOrderDetail,\n    ISkOrderList,\n    ISkOrderLog,\n    ISkOrderReqProgress,\n    ISkShippingFee,\n    ISkValidateCoupon, SkOrderCancelType,\n    SkOrderDetail,\n    SkOrderStatus,\n    SkShippingMethod\n} from 'sk-front-lib/model';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SkOrderService {\n\n    constructor(private _apiService: SkApiService) {\n    }\n\n    getAdminOrders(params: ApiPageableParam = new ApiPageableParam()): Observable<ApiPageable<ISkOrderList>> {\n        return this._apiService.getPageable(`/api/admin/orders`, params.buildHttpParams())\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getAdminOrdersCount(): Observable<ISkOrderCount> {\n        return this._apiService.get(`/api/admin/orders/count`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getAdminOrder(id: string): Observable<SkOrderDetail> {\n        return this._apiService.get<ISkOrderDetail>(`/api/admin/orders/${id}`)\n            .pipe(\n                map(result => new SkOrderDetail(result.data))\n            );\n    }\n\n    getMyOrders(): Observable<ISkOrderList[]> {\n        return this._apiService.get<ISkOrderList[]>(`/api/public/orders/me`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getMyLatestOrders(): Observable<ISkOrderList[]> {\n        return this._apiService.get<ISkOrderList[]>(`/api/public/orders/me/latest`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getOrderDetail(id: string): Observable<SkOrderDetail> {\n        return this._apiService.get<ISkOrderDetail>(`/api/public/orders/${id}`)\n            .pipe(\n                map(result => new SkOrderDetail(result.data))\n            );\n    }\n\n    getOrderStatus(id: string): Observable<SkOrderStatus> {\n        return this._apiService.get<SkOrderStatus>(`/api/public/orders/${id}/status`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getOrderLogs(id: string): Observable<ISkOrderLog[]> {\n        return this._apiService.get<ISkOrderLog[]>(`/api/admin/orders/${id}/logs`)\n            .pipe(\n                map(result => result.data || [])\n            );\n    }\n\n    createAdminOrder(data: any): Observable<SkOrderDetail> {\n        return this._apiService.post<ISkOrderDetail>(`/api/admin/orders`, data)\n            .pipe(\n                map(result => new SkOrderDetail(result.data))\n            );\n    }\n\n    addOrderLog(id: string, message: string): Observable<any> {\n        return this._apiService.post(`/api/admin/orders/${id}/logs`, {message})\n            .pipe(\n                map(result => result.data || [])\n            );\n    }\n\n    updateAdminOrderBaseInfo(id: string, data: any): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/info`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminConfirmTransferPayment(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/confirm-payment/transfer`, null)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminCancel(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/cancel`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminCancelForce(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/cancel/force`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminProcessStart(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/process-start`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminComplete(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/complete`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminPayment(id: string, data: { txId: string, cardName: string, cardQuota: string }): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/update-payment`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminShippingStatus(id: string, data: any): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/update-shipping-status`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    deleteAdminOrders(orders: ISkOrderList[]): Observable<any> {\n        return this._apiService.delete<any>(`/api/admin/orders/${orders.map(order => order.id).join(',')}`);\n    }\n\n    cancelOrder(id: string, data: {cancelType: SkOrderCancelType, cancelDesc: String}): Observable<SkOrderDetail> {\n        return this._apiService.put<SkOrderDetail>(`/api/public/orders/${id}/cancel`, data)\n            .pipe(map(result => result.data))\n    }\n\n    startProgress(id: string, data: ISkOrderReqProgress): Observable<SkOrderStatus> {\n        return this._apiService.put<SkOrderStatus>(`/api/public/orders/${id}/progress`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    moveToMyOrder(id: string): Observable<string> {\n        return this._apiService.put<string>(`/api/public/orders/${id}/move`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getAdminShippingFeeList(): Observable<ISkShippingFee[]> {\n        return this._apiService.get<ISkShippingFee[]>(`/api/admin/orders/shipping-fees`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    createAdminShippingFee(data: ISkShippingFee): Observable<ISkShippingFee> {\n        return this._apiService.post<ISkShippingFee>(`/api/admin/orders/shipping-fees`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminShippingFee(id: number, data: ISkShippingFee): Observable<ISkShippingFee> {\n        return this._apiService.put<ISkShippingFee>(`/api/admin/orders/shipping-fees/${id}`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    deleteAdminShippingFee(id: number): Observable<any> {\n        return this._apiService.delete<any>(`/api/admin/orders/shipping-fees/${id}`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    calculateShippingFee(id: string, method: SkShippingMethod, zipCode: string, serials: string[] = []): Observable<number> {\n        return this._apiService.get<number>(`/api/public/orders/${id}/calculate-shipping-fee`, new HttpParams().append('method', method).append('zipCode', zipCode).append('serials', serials.join(',')))\n            .pipe(\n                map(result => result.data || 0)\n            );\n    }\n\n    validateCoupon(id: string, serials: string[]): Observable<ISkValidateCoupon> {\n        return this._apiService.post<ISkValidateCoupon>(`/api/public/orders/${id}/check-coupon`, {\n            couponSerials: serials\n        }).pipe(\n            map(result => result.data || {discountAmount: 0, couponData: []})\n        );\n    }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sk-order.service.js","sourceRoot":"","sources":["../../../../projects/sk-front-lib/crud/src/sk-order.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpParams } from '@angular/common/http';\nimport { Injectable } from '@angular/core';\n\nimport { Observable } from 'rxjs';\nimport { map } from 'rxjs/operators';\n\nimport { ApiPageable, ApiPageableParam, SkApiService } from 'sk-front-lib/api';\nimport {\n    ISkOrderCount,\n    ISkOrderDetail,\n    ISkOrderList,\n    ISkOrderLog,\n    ISkOrderReqProgress,\n    ISkShippingFee,\n    ISkValidateCoupon, SkOrderCancelType,\n    SkOrderDetail,\n    SkOrderStatus,\n    SkShippingMethod\n} from 'sk-front-lib/model';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class SkOrderService {\n\n    constructor(private _apiService: SkApiService) {\n    }\n\n    getAdminOrders(params: ApiPageableParam = new ApiPageableParam()): Observable<ApiPageable<ISkOrderList>> {\n        return this._apiService.getPageable(`/api/admin/orders`, params.buildHttpParams())\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getAdminOrdersCount(): Observable<ISkOrderCount> {\n        return this._apiService.get(`/api/admin/orders/count`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getAdminOrder(id: string): Observable<SkOrderDetail> {\n        return this._apiService.get<ISkOrderDetail>(`/api/admin/orders/${id}`)\n            .pipe(\n                map(result => new SkOrderDetail(result.data))\n            );\n    }\n\n    getMyOrders(): Observable<ISkOrderList[]> {\n        return this._apiService.get<ISkOrderList[]>(`/api/public/orders/me`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getMyLatestOrders(): Observable<ISkOrderList[]> {\n        return this._apiService.get<ISkOrderList[]>(`/api/public/orders/me/latest`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getOrderDetail(id: string): Observable<SkOrderDetail> {\n        return this._apiService.get<ISkOrderDetail>(`/api/public/orders/${id}`)\n            .pipe(\n                map(result => new SkOrderDetail(result.data))\n            );\n    }\n\n    getOrderStatus(id: string): Observable<SkOrderStatus> {\n        return this._apiService.get<SkOrderStatus>(`/api/public/orders/${id}/status`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getOrderLogs(id: string): Observable<ISkOrderLog[]> {\n        return this._apiService.get<ISkOrderLog[]>(`/api/admin/orders/${id}/logs`)\n            .pipe(\n                map(result => result.data || [])\n            );\n    }\n\n    createAdminOrder(data: any): Observable<SkOrderDetail> {\n        return this._apiService.post<ISkOrderDetail>(`/api/admin/orders`, data)\n            .pipe(\n                map(result => new SkOrderDetail(result.data))\n            );\n    }\n\n    addOrderLog(id: string, message: string): Observable<any> {\n        return this._apiService.post(`/api/admin/orders/${id}/logs`, {message})\n            .pipe(\n                map(result => result.data || [])\n            );\n    }\n\n    updateAdminOrderBaseInfo(id: string, data: any): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/info`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminConfirmTransferPayment(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/confirm-payment/transfer`, null)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminCancel(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/cancel`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminCancelForce(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/cancel/force`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminProcessStart(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/process-start`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminComplete(id: string): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/complete`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminPayment(id: string, data: { txId: string, cardName: string, cardQuota: string }): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/update-payment`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminShippingStatus(id: string, data: any): Observable<any> {\n        return this._apiService.put<any>(`/api/admin/orders/${id}/update-shipping-status`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    deleteAdminOrders(orders: ISkOrderList[]): Observable<any> {\n        return this._apiService.delete<any>(`/api/admin/orders/${orders.map(order => order.id).join(',')}`);\n    }\n\n    /**\n     * Design Ref: vbank-cancel-toss §4.2 — 사용자 자가 취소 (Plan FR-11).\n     *\n     * data 페이로드는 PaymentType별로 가변 필드:\n     *   - 공통: cancelType, cancelDesc, agree\n     *   - TRANSFER 분기: bankName, bankAcc, bankOwner (기존 보존)\n     *   - VBANK 분기 (NEW): vbankRefundIntent + (intent=ALREADY_DEPOSITED일 때만) vbankRefundBankCode/AccountNumber/HolderName\n     *\n     * 백엔드 OrderReqDTO.Cancel과 키 정합 필수 (drift 시 토스 환불 누락 위험).\n     * Optional 필드들은 Angular `formGroup.value`가 disable된 컨트롤을 자동 제외하므로\n     * 호출 측은 단순히 formGroup.value를 그대로 전달하면 됨.\n     */\n    cancelOrder(id: string, data: {\n        cancelType: SkOrderCancelType,\n        cancelDesc: String,\n        // TRANSFER 분기 (기존)\n        bankName?: string,\n        bankAcc?: string,\n        bankOwner?: string,\n        // VBANK 분기 (NEW — vbank-cancel-toss)\n        vbankRefundIntent?: 'ALREADY_DEPOSITED' | 'NOT_YET_DEPOSITED',\n        vbankRefundBankCode?: string,\n        vbankRefundAccountNumber?: string,\n        vbankRefundHolderName?: string\n    }): Observable<SkOrderDetail> {\n        return this._apiService.put<SkOrderDetail>(`/api/public/orders/${id}/cancel`, data)\n            .pipe(map(result => result.data))\n    }\n\n    startProgress(id: string, data: ISkOrderReqProgress): Observable<SkOrderStatus> {\n        return this._apiService.put<SkOrderStatus>(`/api/public/orders/${id}/progress`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    moveToMyOrder(id: string): Observable<string> {\n        return this._apiService.put<string>(`/api/public/orders/${id}/move`, {})\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    getAdminShippingFeeList(): Observable<ISkShippingFee[]> {\n        return this._apiService.get<ISkShippingFee[]>(`/api/admin/orders/shipping-fees`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    createAdminShippingFee(data: ISkShippingFee): Observable<ISkShippingFee> {\n        return this._apiService.post<ISkShippingFee>(`/api/admin/orders/shipping-fees`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    updateAdminShippingFee(id: number, data: ISkShippingFee): Observable<ISkShippingFee> {\n        return this._apiService.put<ISkShippingFee>(`/api/admin/orders/shipping-fees/${id}`, data)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    deleteAdminShippingFee(id: number): Observable<any> {\n        return this._apiService.delete<any>(`/api/admin/orders/shipping-fees/${id}`)\n            .pipe(\n                map(result => result.data)\n            );\n    }\n\n    calculateShippingFee(id: string, method: SkShippingMethod, zipCode: string, serials: string[] = []): Observable<number> {\n        return this._apiService.get<number>(`/api/public/orders/${id}/calculate-shipping-fee`, new HttpParams().append('method', method).append('zipCode', zipCode).append('serials', serials.join(',')))\n            .pipe(\n                map(result => result.data || 0)\n            );\n    }\n\n    validateCoupon(id: string, serials: string[]): Observable<ISkValidateCoupon> {\n        return this._apiService.post<ISkValidateCoupon>(`/api/public/orders/${id}/check-coupon`, {\n            couponSerials: serials\n        }).pipe(\n            map(result => result.data || {discountAmount: 0, couponData: []})\n        );\n    }\n}\n"]}

package/esm2020/model/lib/payment.mjs

@@ -33,9 +33,42 @@ export function getSkPaymentStatusText(status) {
         case SkPaymentStatus.NaverPG:
             return '네이버페이';
         case SkPaymentStatus.Vbank:
-            return '가상계좌 (토스)';
+            // Plan SC-B / FR-04 — PG 브랜드 노출 제거 (vbank-payment-phase3)
+            return '가상계좌';
         default:
             return status;
     }
 }
-//# sourceMappingURL=data:application/json;base64,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
+/**
+ * Design Ref: §3.1 — 가상계좌(VBANK) 은행코드 → 은행명 매핑.
+ * Plan SC-G: sk-api VbankBankCodeMap.MAP과 14개 엔트리 정합 유지.
+ *
+ * MUST sync with: sk-api/src/main/java/works/skullacy/api/domain/commerce/payment/util/VbankBankCodeMap.java
+ * Drift check:    gap-detector rule — Object.keys(VBANK_BANK_CODE_MAP).length === 14
+ */
+export const VBANK_BANK_CODE_MAP = Object.freeze({
+    '03': 'IBK기업은행',
+    '06': 'KB국민은행',
+    '07': 'Sh수협은행',
+    '11': 'NH농협은행',
+    '20': '우리은행',
+    '31': 'iM뱅크(대구)',
+    '32': '부산은행',
+    '34': '광주은행',
+    '37': '전북은행',
+    '39': '경남은행',
+    '45': '새마을금고',
+    '71': '우체국예금보험',
+    '81': '하나은행',
+    '88': '신한은행', // 금결원 088
+});
+/**
+ * VBANK 은행코드를 은행명으로 변환. 알 수 없는 코드는 null 반환.
+ * (백엔드 toName은 fallback으로 code 자체 반환 — 프론트는 표시 제어 용이성을 위해 null. Design §3.1 Note 참조)
+ */
+export function getVbankBankName(code) {
+    if (!code)
+        return null;
+    return VBANK_BANK_CODE_MAP[code] ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/fesm2015/sk-front-lib-crud.mjs

@@ -1157,6 +1157,18 @@ class SkOrderService {
     deleteAdminOrders(orders) {
         return this._apiService.delete(`/api/admin/orders/${orders.map(order => order.id).join(',')}`);
     }
+    /**
+     * Design Ref: vbank-cancel-toss §4.2 — 사용자 자가 취소 (Plan FR-11).
+     *
+     * data 페이로드는 PaymentType별로 가변 필드:
+     *   - 공통: cancelType, cancelDesc, agree
+     *   - TRANSFER 분기: bankName, bankAcc, bankOwner (기존 보존)
+     *   - VBANK 분기 (NEW): vbankRefundIntent + (intent=ALREADY_DEPOSITED일 때만) vbankRefundBankCode/AccountNumber/HolderName
+     *
+     * 백엔드 OrderReqDTO.Cancel과 키 정합 필수 (drift 시 토스 환불 누락 위험).
+     * Optional 필드들은 Angular `formGroup.value`가 disable된 컨트롤을 자동 제외하므로
+     * 호출 측은 단순히 formGroup.value를 그대로 전달하면 됨.
+     */
     cancelOrder(id, data) {
         return this._apiService.put(`/api/public/orders/${id}/cancel`, data)
             .pipe(map(result => result.data));