@chevre/domain 25.2.0-alpha.2 → 25.2.0-alpha.3

package/lib/chevre/service/transaction/placeOrder/confirm/prepareUnitPriceOfferConditions.d.ts

@@ -0,0 +1,17 @@
+import type { OfferRepo } from '../../../../repo/offer/unitPriceInCatalog';
+import { factory } from '../../../../factory';
+export type IAuthorizeEventServiceOffer = factory.action.authorize.offer.eventService.IAction;
+type IOrderAcceptedOffer = Pick<factory.order.IAcceptedOffer, 'itemOffered' | 'offeredThrough' | 'serialNumber' | 'priceSpecification' | 'id'>;
+export declare function createAuthorizeOfferResultsExpected(params: {
+    authorizeEventServiceOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
+}): Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
+declare function prepareUnitPriceOfferConditions(params: {
+    project: {
+        id: string;
+    };
+    acceptedOffers: IOrderAcceptedOffer[];
+    authorizeEventServiceOfferActions: IAuthorizeEventServiceOffer[];
+}): (repos: {
+    offer: OfferRepo;
+}) => Promise<Pick<IAuthorizeEventServiceOffer, "id" | "result">[]>;
+export { prepareUnitPriceOfferConditions };

package/lib/chevre/service/transaction/placeOrder/confirm/prepareUnitPriceOfferConditions.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthorizeOfferResultsExpected = createAuthorizeOfferResultsExpected;
+exports.prepareUnitPriceOfferConditions = prepareUnitPriceOfferConditions;
+const util_1 = require("util");
+const factory_1 = require("../../../../factory");
+function acceptedOffers2authorizeResult(params) {
+    const { acceptedOffers4result, unitPriceOffers } = params;
+    const programMembershipUsed = acceptedOffers2programMembershipUsed({ acceptedOffers: acceptedOffers4result });
+    // オファーIDごとに集計
+    const offerIds = [...new Set(acceptedOffers4result.map((o) => String(o.id)))];
+    const offers = offerIds.map((offerId) => {
+        const acceptedOffer = unitPriceOffers.find(({ id }) => id === offerId);
+        if (acceptedOffer === undefined) {
+            throw new factory_1.factory.errors.Internal(`acceptedOffer not found [id:${offerId}]`);
+        }
+        const amountOfThisGood = acceptedOffers4result.filter(({ id }) => id === offerId).length;
+        const { acceptedPaymentMethod, priceSpecification } = acceptedOffer;
+        const unitPriceSpec = priceSpecification;
+        if (unitPriceSpec === undefined) {
+            throw new factory_1.factory.errors.Internal(`unitPriceSpec not found [id:${offerId}]`);
+        }
+        const { eligibleQuantity } = unitPriceSpec;
+        return {
+            id: offerId,
+            includesObject: { amountOfThisGood },
+            typeOf: factory_1.factory.offerType.Offer,
+            priceSpecification: {
+                ...(eligibleQuantity !== undefined) ? { eligibleQuantity } : undefined,
+            },
+            ...(acceptedPaymentMethod !== undefined) ? { acceptedPaymentMethod } : undefined
+        };
+    });
+    return {
+        amount: [],
+        itemOffered: {
+            serviceOutput: { programMembershipUsed } // add programMembershipUsed required(2024-08-15~)
+        },
+        offers
+    };
+}
+function acceptedOffers2programMembershipUsed(params) {
+    const programMembershipUsed = [];
+    const permitIdentifiers = [];
+    params.acceptedOffers.forEach(({ itemOffered }) => {
+        if (itemOffered.programMembershipUsed?.typeOf === factory_1.factory.programMembership.ProgramMembershipType.ProgramMembership) {
+            // メンバーシップコードに対してユニークに集計
+            if (!permitIdentifiers.includes(itemOffered.programMembershipUsed.identifier)) {
+                permitIdentifiers.push(itemOffered.programMembershipUsed.identifier);
+                const issuedThroughTypeOf = itemOffered.programMembershipUsed.issuedThrough.typeOf;
+                if (issuedThroughTypeOf === factory_1.factory.service.paymentService.PaymentServiceType.FaceToFace) {
+                    programMembershipUsed.push({
+                        typeOf: factory_1.factory.permit.PermitType.Permit,
+                        identifier: itemOffered.programMembershipUsed.identifier,
+                        issuedThrough: { typeOf: issuedThroughTypeOf }
+                    });
+                }
+                else {
+                    programMembershipUsed.push({
+                        typeOf: factory_1.factory.permit.PermitType.Permit,
+                        identifier: itemOffered.programMembershipUsed.identifier,
+                        issuedThrough: { typeOf: issuedThroughTypeOf, id: itemOffered.programMembershipUsed.issuedThrough.id }
+                    });
+                }
+            }
+        }
+    });
+    return programMembershipUsed;
+}
+function createAuthorizeOfferResultsExpected(params) {
+    return params.authorizeEventServiceOfferActions.map((a) => {
+        return {
+            id: a.id,
+            result: a.result
+        };
+    });
+}
+function prepareUnitPriceOfferConditions(params) {
+    return async (repos) => {
+        const conditions = [];
+        const offerIds = [...new Set(params.acceptedOffers.map((o) => String(o.id)))];
+        const unitPriceOffers = await repos.offer.search({
+            id: { $in: offerIds }
+        });
+        for (const authorizeEventServiceOfferAction of params.authorizeEventServiceOfferActions) {
+            if (authorizeEventServiceOfferAction.result === undefined) {
+                throw new Error('authorizeEventServiceOfferAction.result should exist');
+            }
+            const acceptedOffers4action = params.acceptedOffers.filter(((offer) => {
+                return offer.serialNumber === authorizeEventServiceOfferAction.instrument.transactionNumber;
+            }));
+            conditions.push({
+                id: authorizeEventServiceOfferAction.id,
+                result: {
+                    typeOf: authorizeEventServiceOfferAction.result.typeOf,
+                    priceCurrency: authorizeEventServiceOfferAction.result.priceCurrency,
+                    price: authorizeEventServiceOfferAction.result.price,
+                    ...acceptedOffers2authorizeResult({
+                        acceptedOffers4result: acceptedOffers4action,
+                        unitPriceOffers
+                    })
+                }
+            });
+        }
+        // 承認アクションと比較する
+        for (const authorizeEventServiceOfferAction of params.authorizeEventServiceOfferActions) {
+            const conditionExpected = conditions.find(({ id }) => id === authorizeEventServiceOfferAction.id);
+            const resultMatched = (0, util_1.isDeepStrictEqual)(conditionExpected?.result, authorizeEventServiceOfferAction.result);
+            console.log('resultMatched?', resultMatched, authorizeEventServiceOfferAction.id, authorizeEventServiceOfferAction.instrument.transactionNumber);
+            if (!resultMatched) {
+                console.log(conditionExpected?.result, authorizeEventServiceOfferAction.result);
+            }
+        }
+        return conditions;
+    };
+}

package/lib/chevre/service/transaction/placeOrder/confirm/validation.d.ts

@@ -39,5 +39,8 @@ export declare function validateEventOffers(params: {
         price: number;
     };
     paymentMethods: factory.order.IReferencedInvoice[];
-    authorizeEventServiceOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'instrument' | 'object' | 'result'>[];
+    /**
+     * 承認アクションのresultに条件が保管されているはず(2026-07-06時点で)
+     */
+    authorizeEventServiceOfferActions: Pick<IAuthorizeEventServiceOffer, 'id' | 'result'>[];
 }): void;

package/lib/chevre/service/transaction/placeOrder/confirm.d.ts

@@ -5,6 +5,7 @@ import type { AssetTransactionRepo } from '../../../repo/assetTransaction';
 import type { AuthorizationRepo } from '../../../repo/authorization';
 import type { ConfirmationNumberRepo } from '../../../repo/confirmationNumber';
 import type { MessageRepo } from '../../../repo/message';
+import type { OfferRepo } from '../../../repo/offer/unitPriceInCatalog';
 import type { OrderInTransactionRepo } from '../../../repo/orderInTransaction';
 import type { ProjectRepo } from '../../../repo/project';
 import type { SettingRepo } from '../../../repo/setting';
@@ -19,6 +20,7 @@ interface IConfirmOperationRepos {
     assetTransaction: AssetTransactionRepo;
     authorization: AuthorizationRepo;
     message: MessageRepo;
+    offer: OfferRepo;
     project: ProjectRepo;
     placeOrder: PlaceOrderRepo;
     orderInTransaction: OrderInTransactionRepo;

package/lib/chevre/service/transaction/placeOrder/confirm.js

@@ -12,6 +12,7 @@ const factory_2 = require("../../order/placeOrder/factory");
 const orderedItem_1 = require("../../order/placeOrder/factory/orderedItem");
 const result_1 = require("./confirm/factory/result");
 const potentialActions_1 = require("./confirm/potentialActions");
+const prepareUnitPriceOfferConditions_1 = require("./confirm/prepareUnitPriceOfferConditions");
 const publishCode_1 = require("./confirm/publishCode");
 const validation_1 = require("./confirm/validation");
 const publishConfirmationNumberIfNotExist_1 = require("./publishConfirmationNumberIfNotExist");
@@ -114,6 +115,14 @@ function confirm(params, options) {
             project: { id: transaction.project.id }
         }))
             .filter(({ serialNumber }) => typeof serialNumber === 'string' && serialNumbers.includes(serialNumber));
+        // 単価オファーの全適用条件を検証するために、単価オファーを参照(2026-07-06~)
+        if (transaction.project.id === 'cinerino') {
+            await (0, prepareUnitPriceOfferConditions_1.prepareUnitPriceOfferConditions)({
+                project: { id: transaction.project.id, },
+                acceptedOffers,
+                authorizeEventServiceOfferActions
+            })({ offer: repos.offer });
+        }
         // authorizePaymentActionsからpayTransactionsを参照(2024-06-20~)
         let payTransactions = [];
         // 決済承認アクションのinstrument依存をobject依存へ変更(2025-12-14~)

package/package.json

@@ -91,5 +91,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "version": "25.2.0-alpha.2"
+  "version": "25.2.0-alpha.3"
 }