@chevre/domain 15.65.0-alpha.9 → 20.0.0-alpha.1

package/lib/chevre/service/product.js

@@ -0,0 +1,84 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerService = void 0;
+/**
+ * プロダクトサービス
+ */
+const moment = require("moment");
+const factory = require("../factory");
+const permit_1 = require("./permit");
+function registerService(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        yield Promise.all(params.map((actionAttributes) => __awaiter(this, void 0, void 0, function* () {
+            let serviceOutput = actionAttributes.object;
+            const action = yield repos.action.start(actionAttributes);
+            try {
+                // Permitに有効期間を設定する
+                serviceOutput = yield (0, permit_1.activate)(Object.assign({ typeOf: serviceOutput.typeOf, identifier: String(serviceOutput.identifier), validFrom: moment(serviceOutput.validFrom)
+                        .toDate() }, (serviceOutput.validUntil !== undefined && serviceOutput.validUntil !== null)
+                    ? {
+                        validUntil: moment(serviceOutput.validUntil)
+                            .toDate()
+                    }
+                    : undefined))({ serviceOutput: repos.serviceOutput });
+            }
+            catch (error) {
+                // actionにエラー結果を追加
+                try {
+                    const actionError = Object.assign(Object.assign({}, error), { message: error.message, name: error.name });
+                    yield repos.action.giveUp({ typeOf: action.typeOf, id: action.id, error: actionError });
+                }
+                catch (__) {
+                    // 失敗したら仕方ない
+                }
+                throw error;
+            }
+            // アクション完了
+            const actionResult = {};
+            yield repos.action.complete({ typeOf: action.typeOf, id: action.id, result: actionResult });
+            yield onRegistered(actionAttributes, serviceOutput)(repos);
+        })));
+    });
+}
+exports.registerService = registerService;
+/**
+ * サービス登録後アクション
+ */
+function onRegistered(actionAttributes, __) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        const potentialActions = actionAttributes.potentialActions;
+        const now = new Date();
+        const taskAttributes = [];
+        // tslint:disable-next-line:no-single-line-block-comment
+        /* istanbul ignore else */
+        if (potentialActions !== undefined) {
+            if (Array.isArray(potentialActions.moneyTransfer)) {
+                taskAttributes.push(...potentialActions.moneyTransfer.map((a) => {
+                    return {
+                        project: a.project,
+                        name: factory.taskName.MoneyTransfer,
+                        status: factory.taskStatus.Ready,
+                        runsAt: now,
+                        remainingNumberOfTries: 10,
+                        numberOfTried: 0,
+                        executionResults: [],
+                        data: a
+                    };
+                }));
+            }
+        }
+        // タスク保管
+        yield Promise.all(taskAttributes.map((taskAttribute) => __awaiter(this, void 0, void 0, function* () {
+            return repos.task.save(taskAttribute);
+        })));
+    });
+}

package/lib/chevre/service/project.d.ts

@@ -0,0 +1,57 @@
+/**
+ * プロジェクトサービス
+ */
+import { MongoRepository as AccountTitleRepo } from '../repo/accountTitle';
+import { MongoRepository as ActionRepo } from '../repo/action';
+import { MongoRepository as AssetTransactionRepo } from '../repo/assetTransaction';
+import { MongoRepository as CategoryCodeRepo } from '../repo/categoryCode';
+import { MongoRepository as CreativeWorkRepo } from '../repo/creativeWork';
+import { MongoRepository as EventRepo } from '../repo/event';
+import { MongoRepository as MemberRepo } from '../repo/member';
+import { MongoRepository as OfferRepo } from '../repo/offer';
+import { MongoRepository as OfferCatalogRepo } from '../repo/offerCatalog';
+import { MongoRepository as PlaceRepo } from '../repo/place';
+import { MongoRepository as PriceSpecificationRepo } from '../repo/priceSpecification';
+import { MongoRepository as ProductRepo } from '../repo/product';
+import { MongoRepository as ProjectRepo } from '../repo/project';
+import { MongoRepository as ReservationRepo } from '../repo/reservation';
+import { MongoRepository as SellerRepo } from '../repo/seller';
+import { MongoRepository as TaskRepo } from '../repo/task';
+export declare function deleteProject(params: {
+    id: string;
+}): (repos: {
+    accountTitle: AccountTitleRepo;
+    action: ActionRepo;
+    categoryCode: CategoryCodeRepo;
+    creativeWork: CreativeWorkRepo;
+    event: EventRepo;
+    member: MemberRepo;
+    offer: OfferRepo;
+    offerCatalog: OfferCatalogRepo;
+    place: PlaceRepo;
+    priceSpecification: PriceSpecificationRepo;
+    product: ProductRepo;
+    project: ProjectRepo;
+    reservation: ReservationRepo;
+    seller: SellerRepo;
+    task: TaskRepo;
+    assetTransaction: AssetTransactionRepo;
+}) => Promise<void>;
+export declare function cleanUpDatabaseByProject(params: {
+    id: string;
+}): (repos: {
+    accountTitle: AccountTitleRepo;
+    action: ActionRepo;
+    assetTransaction: AssetTransactionRepo;
+    categoryCode: CategoryCodeRepo;
+    creativeWork: CreativeWorkRepo;
+    event: EventRepo;
+    offer: OfferRepo;
+    offerCatalog: OfferCatalogRepo;
+    place: PlaceRepo;
+    priceSpecification: PriceSpecificationRepo;
+    product: ProductRepo;
+    reservation: ReservationRepo;
+    seller: SellerRepo;
+    task: TaskRepo;
+}) => Promise<void>;

package/lib/chevre/service/project.js

@@ -0,0 +1,40 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanUpDatabaseByProject = exports.deleteProject = void 0;
+function deleteProject(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        yield cleanUpDatabaseByProject(params)(repos);
+        yield repos.member.deleteByProject({ project: { id: params.id } });
+        yield repos.project.deleteById({ id: params.id });
+    });
+}
+exports.deleteProject = deleteProject;
+function cleanUpDatabaseByProject(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        // プロジェクトに所属する全データをリポジトリから削除する
+        yield repos.accountTitle.deleteByProject({ project: { id: params.id } });
+        yield repos.action.deleteByProject({ project: { id: params.id } });
+        yield repos.assetTransaction.deleteByProject({ project: { id: params.id } });
+        yield repos.categoryCode.deleteByProject({ project: { id: params.id } });
+        yield repos.creativeWork.deleteByProject({ project: { id: params.id } });
+        yield repos.event.deleteByProject({ project: { id: params.id } });
+        yield repos.offer.deleteByProject({ project: { id: params.id } });
+        yield repos.offerCatalog.deleteByProject({ project: { id: params.id } });
+        yield repos.place.deleteByProject({ project: { id: params.id } });
+        yield repos.priceSpecification.deleteByProject({ project: { id: params.id } });
+        yield repos.product.deleteByProject({ project: { id: params.id } });
+        yield repos.reservation.deleteByProject({ project: { id: params.id } });
+        yield repos.seller.deleteByProject({ project: { id: params.id } });
+        yield repos.task.deleteByProject({ project: { id: params.id } });
+    });
+}
+exports.cleanUpDatabaseByProject = cleanUpDatabaseByProject;

package/lib/chevre/service/report/ownershipInfo.d.ts

@@ -0,0 +1,25 @@
+import * as factory from '../../factory';
+/**
+ * 所有権レポートインターフェース
+ */
+export interface IOwnershipInfoReport {
+    id: string;
+    identifier: string;
+    ownedBy: {
+        typeOf: string;
+        id: string;
+    };
+    typeOfGood: {
+        typeOf: string;
+        id?: string;
+        identifier?: string;
+    };
+    ownedFrom: string;
+    ownedThrough: string;
+    seller: {
+        id?: string;
+    };
+}
+export declare function ownershipInfo2report(params: {
+    ownershipInfo: factory.ownershipInfo.IOwnershipInfo<factory.ownershipInfo.IGood>;
+}): IOwnershipInfoReport;

package/lib/chevre/service/report/ownershipInfo.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ownershipInfo2report = void 0;
+const moment = require("moment");
+function ownershipInfo2report(params) {
+    var _a, _b, _c;
+    const ownershipInfo = params.ownershipInfo;
+    return {
+        id: ownershipInfo.id,
+        identifier: String(ownershipInfo.identifier),
+        ownedBy: (Array.isArray(ownershipInfo.ownedBy))
+            ? {
+                typeOf: (_a = ownershipInfo.ownedBy[0]) === null || _a === void 0 ? void 0 : _a.typeOf,
+                id: String((_b = ownershipInfo.ownedBy[0]) === null || _b === void 0 ? void 0 : _b.id)
+            }
+            : {
+                typeOf: ownershipInfo.ownedBy.typeOf,
+                id: String(ownershipInfo.ownedBy.id)
+            },
+        typeOfGood: {
+            typeOf: ownershipInfo.typeOfGood.typeOf,
+            id: ownershipInfo.typeOfGood.id,
+            identifier: ownershipInfo.typeOfGood.identifier
+        },
+        ownedFrom: moment(ownershipInfo.ownedFrom)
+            .toISOString(),
+        ownedThrough: moment(ownershipInfo.ownedThrough)
+            .toISOString(),
+        seller: {
+            id: (_c = ownershipInfo.acquiredFrom) === null || _c === void 0 ? void 0 : _c.id
+        }
+    };
+}
+exports.ownershipInfo2report = ownershipInfo2report;

package/lib/chevre/service/report/telemetry.d.ts

@@ -0,0 +1,317 @@
+/**
+ * データ測定サービス
+ * 実験的実装中
+ */
+import * as repository from '../../repository';
+import * as factory from '../../factory';
+export declare type TelemetryOperation<T> = (repos: {
+    telemetry: repository.Telemetry;
+}) => Promise<T>;
+export declare type TaskOperation<T> = (repos: {
+    task: repository.Task;
+}) => Promise<T>;
+export declare type TransactionOperation<T> = (repos: {
+    transaction: repository.Transaction;
+}) => Promise<T>;
+export declare type TaskAndTransactionOperation<T> = (repos: {
+    task: repository.Task;
+    transaction: repository.Transaction;
+}) => Promise<T>;
+export declare type TaskAndTransactionAndActionOperation<T> = (repos: {
+    task: repository.Task;
+    transaction: repository.Transaction;
+    action: repository.Action;
+}) => Promise<T>;
+export declare type TransactionAndActionOperation<T> = (repos: {
+    transaction: repository.Transaction;
+    action: repository.Action;
+}) => Promise<T>;
+export declare type TaskAndTelemetryAndTransactionOperation<T> = (repos: {
+    task: repository.Task;
+    telemetry: repository.Telemetry;
+    transaction: repository.Transaction;
+    action: repository.Action;
+}) => Promise<T>;
+export interface IGlobalFlowTaskResultByName {
+    name: factory.taskName;
+    /**
+     * 集計期間中に作成されたタスク数
+     */
+    numberOfCreated: number;
+    /**
+     * 集計期間中に実行されたタスク数
+     */
+    numberOfExecuted: number;
+    /**
+     * 集計期間中に中止されたタスク数
+     */
+    numberOfAborted: number;
+    /**
+     * 合計待ち時間
+     */
+    totalLatencyInMilliseconds: number;
+    /**
+     * 最大待ち時間
+     */
+    maxLatencyInMilliseconds: number;
+    /**
+     * 最小待ち時間
+     */
+    minLatencyInMilliseconds: number;
+    /**
+     * 合計試行回数
+     */
+    totalNumberOfTrials: number;
+    /**
+     * 最大試行回数
+     */
+    maxNumberOfTrials: number;
+    /**
+     * 最小試行回数
+     */
+    minNumberOfTrials: number;
+}
+/**
+ * フローデータ
+ * https://en.wikipedia.org/wiki/Stock_and_flow
+ */
+export interface IGlobalFlowResult {
+    tasks: IGlobalFlowTaskResultByName[];
+    measuredFrom: Date;
+    measuredThrough: Date;
+}
+/**
+ * ストックデータ
+ * https://en.wikipedia.org/wiki/Stock_and_flow
+ */
+export interface IGlobalStockResult {
+    tasks: {
+        numberOfUnexecuted: number;
+    };
+    measuredAt: Date;
+}
+export interface ISellerFlowTransactionResultByAction {
+    /**
+     * アクション数合計値(期限切れ取引)
+     */
+    totalNumberOfActionsOnExpired: number;
+    /**
+     * 最大アクション数(期限切れ取引)
+     */
+    maxNumberOfActionsOnExpired: number;
+    /**
+     * 最小アクション数(期限切れ取引)
+     */
+    minNumberOfActionsOnExpired: number;
+    /**
+     * 平均アクション数(期限切れ取引)
+     */
+    averageNumberOfActionsOnExpired: number;
+}
+export interface ISellerFlowTransactionResult {
+    /**
+     * 集計期間中に開始された取引数
+     */
+    numberOfStarted: number;
+    /**
+     * 集計期間中に開始されてその後成立した取引数
+     */
+    numberOfStartedAndConfirmed: number;
+    /**
+     * 集計期間中に開始されてその後期限切れになった取引数
+     */
+    numberOfStartedAndExpired: number;
+    /**
+     * 集計期間中に成立した取引数
+     */
+    numberOfConfirmed: number;
+    /**
+     * 集計期間中に期限切れになった取引数
+     */
+    numberOfExpired: number;
+    /**
+     * 取引の合計所要時間(ミリ秒)
+     */
+    totalRequiredTimeInMilliseconds: number;
+    /**
+     * 取引の最大所要時間(ミリ秒)
+     */
+    maxRequiredTimeInMilliseconds: number;
+    /**
+     * 取引の最小所要時間(ミリ秒)
+     */
+    minRequiredTimeInMilliseconds: number;
+    /**
+     * 取引の平均所要時間(ミリ秒)
+     */
+    averageRequiredTimeInMilliseconds: number;
+    /**
+     * イベントまでの合計残り時間(ミリ秒)
+     */
+    totalTimeLeftUntilEventInMilliseconds: number;
+    /**
+     * イベントまでの最大残り時間(ミリ秒)
+     */
+    maxTimeLeftUntilEventInMilliseconds: number;
+    /**
+     * イベントまでの最小残り時間(ミリ秒)
+     */
+    minTimeLeftUntilEventInMilliseconds: number;
+    /**
+     * イベントまでの平均残り時間(ミリ秒)
+     */
+    averageTimeLeftUntilEventInMilliseconds: number;
+    /**
+     * 取引の合計金額(yen)
+     */
+    totalAmount: number;
+    /**
+     * 最大金額
+     */
+    maxAmount: number;
+    /**
+     * 最小金額
+     */
+    minAmount: number;
+    /**
+     * 平均金額
+     */
+    averageAmount: number;
+    /**
+     * アクション数合計値(成立取引)
+     */
+    totalNumberOfActionsOnConfirmed: number;
+    /**
+     * 最大アクション数(成立取引)
+     */
+    maxNumberOfActionsOnConfirmed: number;
+    /**
+     * 最小アクション数(成立取引)
+     */
+    minNumberOfActionsOnConfirmed: number;
+    /**
+     * 注文アイテム数合計値
+     */
+    totalNumberOfOrderItems: number;
+    /**
+     * 最大注文アイテム数
+     */
+    maxNumberOfOrderItems: number;
+    /**
+     * 最小注文アイテム数
+     */
+    minNumberOfOrderItems: number;
+    /**
+     * 平均注文アイテム数
+     */
+    averageNumberOfOrderItems: number;
+    /**
+     * 平均アクション数(成立取引)
+     */
+    averageNumberOfActionsOnConfirmed: number;
+}
+/**
+ * 販売者が対象のフローデータ
+ */
+export interface ISellerFlowResult {
+    transactions: ISellerFlowTransactionResult & ISellerFlowTransactionResultByAction;
+    measuredFrom: Date;
+    measuredThrough: Date;
+}
+/**
+ * 販売者が対象のストックデータ
+ */
+export interface ISellerStockResult {
+    transactions: {
+        numberOfUnderway: number;
+    };
+    measuredAt: Date;
+}
+export declare enum TelemetryScope {
+    Global = "Global",
+    Seller = "Seller"
+}
+export declare enum TelemetryPurposeType {
+    Flow = "Flow",
+    Stock = "Stock"
+}
+export interface IGlobalObect {
+    scope: TelemetryScope;
+    measuredAt: Date;
+}
+export interface ISellerObect {
+    scope: TelemetryScope;
+    measuredAt: Date;
+    sellerId: string;
+}
+/**
+ * 測定データインターフェース
+ */
+export interface ITelemetry {
+    object: any;
+    result: any;
+    startDate: Date;
+    endDate: Date;
+    purpose: {
+        typeOf: TelemetryPurposeType;
+    };
+}
+export interface IGlobalStockTelemetry extends ITelemetry {
+    object: IGlobalObect;
+    result: IGlobalStockResult;
+}
+export interface IGlobalFlowTelemetry extends ITelemetry {
+    object: IGlobalObect;
+    result: IGlobalFlowResult;
+}
+export interface ISellerStockTelemetry extends ITelemetry {
+    object: ISellerObect;
+    result: ISellerStockResult;
+}
+export interface ISellerFlowTelemetry extends ITelemetry {
+    object: ISellerObect;
+    result: ISellerFlowResult;
+}
+export declare function searchGlobalFlow(searchConditions: {
+    measuredFrom: Date;
+    measuredThrough: Date;
+}): TelemetryOperation<IGlobalFlowTelemetry[]>;
+export declare function searchGlobalStock(searchConditions: {
+    measuredFrom: Date;
+    measuredThrough: Date;
+}): TelemetryOperation<IGlobalStockTelemetry[]>;
+export declare function searchSellerFlow(searchConditions: {
+    measuredFrom: Date;
+    measuredThrough: Date;
+}): TelemetryOperation<ISellerFlowTelemetry[]>;
+export declare function searchSellerStock(searchConditions: {
+    measuredFrom: Date;
+    measuredThrough: Date;
+}): TelemetryOperation<ISellerStockTelemetry[]>;
+/**
+ * 計測データを検索する
+ * @param searchConditions.measuredFrom 計測日時from
+ * @param searchConditions.measuredThrough 計測日時through
+ */
+export declare function search(searchConditions: {
+    measuredFrom: Date;
+    measuredThrough: Date;
+    scope: TelemetryScope;
+    purpose: TelemetryPurposeType;
+}): (repos: {
+    telemetry: repository.Telemetry;
+}) => Promise<ITelemetry[]>;
+/**
+ * フロー測定データを作成する
+ */
+export declare function createFlow(target: {
+    measuredAt: Date;
+    sellerId?: string;
+}): TaskAndTelemetryAndTransactionOperation<void>;
+/**
+ * ストック測定データを作成する
+ */
+export declare function createStock(target: {
+    measuredAt: Date;
+    sellerId?: string;
+}): TaskAndTelemetryAndTransactionOperation<void>;