@chevre/domain 21.9.0-alpha.1 → 21.9.0-alpha.11

package/example/src/chevre/searchEventTicketOffers.ts

@@ -28,6 +28,7 @@ async function main() {
     const { ticketOffers } = await chevre.service.offer.event.searchEventTicketOffers({
         event: { id: 'ale6qiedq' },
         onlyValid: true,
+        priceSpecification: {},
         validateOfferRateLimit: true,
         addSortIndex: true,
         useIncludeInDataCatalog: true,

package/example/src/chevre/{searchOfferCatalogs.ts → searchOfferCatalogItems.ts}

@@ -9,23 +9,33 @@ mongoose.Model.on('index', (...args) => {
 });
 
 async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: true });
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
 
-    const catalogRepo = new chevre.repository.OfferCatalog(mongoose.connection);
+    const catalogItemRepo = new chevre.repository.OfferCatalogItem(mongoose.connection);
 
     console.log('searching...');
-    const catalogs = await catalogRepo.search(
+    const catalogs = await catalogItemRepo.search(
         {
             project: { id: { $eq: PROJECT_ID } },
-            identifier: { $eq: '0001' },
             sort: { identifier: chevre.factory.sortType.Descending },
             limit: 2,
             page: 1,
             itemListElement: { typeOf: { $eq: 'Offer' } }
+            // id: { $in: ['xxx'] }
         }
     );
-    console.log('catalogs found', catalogs.map((catalog) => `${catalog.identifier} ${catalog.numberOfItems} ${catalog.itemListElementTypeOf}`));
+    console.log(catalogs[0]?.id, typeof catalogs[0]?.id);
+    console.log('catalogs found', catalogs.map((catalog) => `${catalog.id} ${catalog.identifier} ${catalog.numberOfItems} ${catalog.itemListElementTypeOf}`));
     console.log(catalogs.length);
+
+    const numCatalogs = await catalogItemRepo.count(
+        {
+            project: { id: { $eq: PROJECT_ID } },
+            itemListElement: { typeOf: { $eq: 'Offer' } }
+            // id: { $in: ['xxx'] }
+        }
+    );
+    console.log('numCatalogs:', numCatalogs);
 }
 
 main()

package/example/src/chevre/searchOffersByCatalog.ts

@@ -14,10 +14,17 @@ async function main() {
         page: 1,
         // ids: ['xx', 'xxx', '1001', '901'],
         subOfferCatalog: {
-            id: 'xxx'
+            id: '0001',
+            isOfferCatalogItem: false
         },
         excludeAppliesToMovieTicket: false,
-        useIncludeInDataCatalog: true
+        useIncludeInDataCatalog: false,
+        priceSpecification: {
+            // appliesToMovieTicket: {
+            //     serviceOutput: { typeOf: { $eq: 'SurfRock' } },
+            //     serviceType: { $exists: true }
+            // }
+        }
     });
     // console.log(offers);
     console.log(offers.map((offer) => {

package/lib/chevre/repo/aggregateOffer.d.ts

@@ -11,18 +11,19 @@ export type IUnitPriceOfferFromAggregateOffer = factory.unitPriceOffer.IUnitPric
         id: string;
     };
 };
+type ISearchConditions = factory.unitPriceOffer.ISearchConditions;
 /**
  * 集計オファーリポジトリ
  */
 export declare class MongoRepository {
     private readonly aggregateOfferModel;
     constructor(connection: Connection);
-    static CREATE_AGGREGATE_OFFERS_MATCH_CONDITIONS(params: factory.unitPriceOffer.ISearchConditions): IMatchStage[];
+    static CREATE_AGGREGATE_OFFERS_MATCH_CONDITIONS(params: ISearchConditions): IMatchStage[];
     static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): {
         [field: string]: AnyExpression;
     };
-    count(params: Omit<factory.unitPriceOffer.ISearchConditions, 'limit' | 'page' | 'sort'>): Promise<number>;
-    search(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection): Promise<factory.aggregateOffer.IAggregateOffer[]>;
+    count(params: Omit<ISearchConditions, 'limit' | 'page' | 'sort'>): Promise<number>;
+    search(params: ISearchConditions, projection?: IProjection): Promise<factory.aggregateOffer.IAggregateOffer[]>;
     pushIncludedInDataCatalog(params: {
         project: {
             id: string;
@@ -58,5 +59,90 @@ export declare class MongoRepository {
             };
         };
     }): Promise<void>;
+    pushIncludedInOfferCatalogItem(params: {
+        project: {
+            id: string;
+        };
+        id: {
+            $in: string[];
+        };
+        $push: {
+            includedInOfferCatalogItem: {
+                /**
+                 * サブカタログID
+                 */
+                id: {
+                    $eq: string;
+                };
+                includedInDataCatalog: {
+                    /**
+                     * カタログID
+                     */
+                    id: {
+                        $eq: string;
+                    };
+                };
+            };
+        };
+    }): Promise<void>;
+    /**
+     * サブカタログを含み、かつ、新しいカタログに含まれない集計オファーからサブカタログを除外
+     */
+    pullIncludedInOfferCatalogItem(params: {
+        project: {
+            id: string;
+        };
+        id?: {
+            $nin?: string[];
+        };
+        $pull: {
+            includedInOfferCatalogItem: {
+                $elemMatch: {
+                    /**
+                     * サブカタログID
+                     */
+                    id: {
+                        $eq: string;
+                    };
+                    includedInDataCatalog: {
+                        /**
+                         * カタログID
+                         */
+                        id: {
+                            $eq: string;
+                        };
+                    };
+                };
+            };
+        };
+    }): Promise<void>;
+    /**
+     * カタログに属するサブカタログを全て除外する
+     */
+    pullIncludedInOfferCatalogItemByCatalogId(params: {
+        project: {
+            id: string;
+        };
+        $pull: {
+            includedInOfferCatalogItem: {
+                $elemMatch: {
+                    includedInDataCatalog: {
+                        /**
+                         * カタログID
+                         */
+                        id: {
+                            $eq: string;
+                        };
+                    };
+                };
+            };
+        };
+    }): Promise<void>;
+    deleteById(params: {
+        project: {
+            id: string;
+        };
+        id: string;
+    }): Promise<void>;
 }
 export {};

package/lib/chevre/repo/aggregateOffer.js

@@ -558,5 +558,95 @@ class MongoRepository {
                 .exec();
         });
     }
+    pushIncludedInOfferCatalogItem(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!Array.isArray(params.id.$in) || params.id.$in.length === 0) {
+                return;
+            }
+            // if (params.$push.includedInOfferCatalogItem.$each.length === 0) {
+            //     return;
+            // }
+            const newIncludedInOfferCatalogItem = {
+                id: params.$push.includedInOfferCatalogItem.id.$eq,
+                typeOf: 'OfferCatalog',
+                includedInDataCatalog: { id: params.$push.includedInOfferCatalogItem.includedInDataCatalog.id.$eq, typeOf: 'OfferCatalog' }
+            };
+            const result = yield this.aggregateOfferModel.updateMany({
+                'project.id': { $eq: params.project.id },
+                _id: { $in: params.id.$in }
+            }, {
+                // newIncludedInOfferCatalogItemsのユニークネスを保証する
+                $addToSet: { 'offers.$[].includedInOfferCatalogItem': newIncludedInOfferCatalogItem }
+            })
+                .exec();
+            debug('result', result);
+        });
+    }
+    /**
+     * サブカタログを含み、かつ、新しいカタログに含まれない集計オファーからサブカタログを除外
+     */
+    pullIncludedInOfferCatalogItem(params) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            const idNin = (_a = params.id) === null || _a === void 0 ? void 0 : _a.$nin;
+            yield this.aggregateOfferModel.updateMany(Object.assign({ 'project.id': { $eq: params.project.id }, 'offers.includedInOfferCatalogItem': {
+                    $elemMatch: {
+                        id: { $exists: true, $eq: params.$pull.includedInOfferCatalogItem.$elemMatch.id.$eq },
+                        'includedInDataCatalog.id': {
+                            $exists: true,
+                            $eq: params.$pull.includedInOfferCatalogItem.$elemMatch.includedInDataCatalog.id.$eq
+                        }
+                    }
+                } }, (Array.isArray(idNin)) ? { _id: { $nin: idNin } } : undefined), {
+                $pull: {
+                    'offers.$[].includedInOfferCatalogItem': {
+                        id: { $exists: true, $eq: params.$pull.includedInOfferCatalogItem.$elemMatch.id.$eq },
+                        'includedInDataCatalog.id': {
+                            $exists: true,
+                            $eq: params.$pull.includedInOfferCatalogItem.$elemMatch.includedInDataCatalog.id.$eq
+                        }
+                    }
+                }
+            })
+                .exec();
+        });
+    }
+    /**
+     * カタログに属するサブカタログを全て除外する
+     */
+    pullIncludedInOfferCatalogItemByCatalogId(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.aggregateOfferModel.updateMany({
+                'project.id': { $eq: params.project.id },
+                'offers.includedInOfferCatalogItem': {
+                    $elemMatch: {
+                        'includedInDataCatalog.id': {
+                            $exists: true,
+                            $eq: params.$pull.includedInOfferCatalogItem.$elemMatch.includedInDataCatalog.id.$eq
+                        }
+                    }
+                }
+            }, {
+                $pull: {
+                    'offers.$[].includedInOfferCatalogItem': {
+                        'includedInDataCatalog.id': {
+                            $exists: true,
+                            $eq: params.$pull.includedInOfferCatalogItem.$elemMatch.includedInDataCatalog.id.$eq
+                        }
+                    }
+                }
+            })
+                .exec();
+        });
+    }
+    deleteById(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.aggregateOfferModel.findOneAndRemove({
+                _id: { $eq: params.id },
+                'project.id': { $eq: params.project.id }
+            }, { projection: { _id: 1 } })
+                .exec();
+        });
+    }
 }
 exports.MongoRepository = MongoRepository;

package/lib/chevre/repo/mongoose/schemas/offerCatalogItem.d.ts

@@ -0,0 +1,92 @@
+/// <reference types="mongoose/types/aggregate" />
+/// <reference types="mongoose/types/callback" />
+/// <reference types="mongoose/types/collection" />
+/// <reference types="mongoose/types/connection" />
+/// <reference types="mongoose/types/cursor" />
+/// <reference types="mongoose/types/document" />
+/// <reference types="mongoose/types/error" />
+/// <reference types="mongoose/types/expressions" />
+/// <reference types="mongoose/types/helpers" />
+/// <reference types="mongoose/types/middlewares" />
+/// <reference types="mongoose/types/indexes" />
+/// <reference types="mongoose/types/models" />
+/// <reference types="mongoose/types/mongooseoptions" />
+/// <reference types="mongoose/types/pipelinestage" />
+/// <reference types="mongoose/types/populate" />
+/// <reference types="mongoose/types/query" />
+/// <reference types="mongoose/types/schemaoptions" />
+/// <reference types="mongoose/types/schematypes" />
+/// <reference types="mongoose/types/session" />
+/// <reference types="mongoose/types/types" />
+/// <reference types="mongoose/types/utility" />
+/// <reference types="mongoose/types/validation" />
+/// <reference types="mongoose/types/virtuals" />
+/// <reference types="mongoose/types/inferschematype" />
+import { Schema } from 'mongoose';
+declare const modelName = "OfferCatalogItem";
+/**
+ * オファーカタログアイテムスキーマ
+ */
+declare const schema: Schema<any, import("mongoose").Model<any, any, any, any, any, any>, {}, {}, {}, {}, {
+    collection: string;
+    id: true;
+    read: string;
+    writeConcern: import("mongodb").WriteConcern;
+    strict: true;
+    strictQuery: false;
+    timestamps: {
+        createdAt: string;
+        updatedAt: string;
+    };
+    toJSON: {
+        getters: false;
+        virtuals: false;
+        minimize: false;
+        versionKey: false;
+    };
+    toObject: {
+        getters: false;
+        virtuals: true;
+        minimize: false;
+        versionKey: false;
+    };
+}, {
+    typeOf: string;
+    additionalProperty: any[];
+    identifier: string;
+    itemListElement: any[];
+    name?: any;
+    project?: any;
+    alternateName?: any;
+    description?: any;
+    itemOffered?: any;
+    dateSynced?: Date | undefined;
+    relatedOffer?: any;
+}, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<{
+    typeOf: string;
+    additionalProperty: any[];
+    identifier: string;
+    itemListElement: any[];
+    name?: any;
+    project?: any;
+    alternateName?: any;
+    description?: any;
+    itemOffered?: any;
+    dateSynced?: Date | undefined;
+    relatedOffer?: any;
+}>> & Omit<import("mongoose").FlatRecord<{
+    typeOf: string;
+    additionalProperty: any[];
+    identifier: string;
+    itemListElement: any[];
+    name?: any;
+    project?: any;
+    alternateName?: any;
+    description?: any;
+    itemOffered?: any;
+    dateSynced?: Date | undefined;
+    relatedOffer?: any;
+}> & {
+    _id: import("mongoose").Types.ObjectId;
+}, never>>;
+export { modelName, schema };

package/lib/chevre/repo/mongoose/schemas/offerCatalogItem.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.modelName = void 0;
+const mongoose_1 = require("mongoose");
+const writeConcern_1 = require("../writeConcern");
+const modelName = 'OfferCatalogItem';
+exports.modelName = modelName;
+/**
+ * オファーカタログアイテムスキーマ
+ */
+const schema = new mongoose_1.Schema({
+    project: mongoose_1.SchemaTypes.Mixed,
+    identifier: {
+        type: String,
+        required: true
+    },
+    name: mongoose_1.SchemaTypes.Mixed,
+    description: mongoose_1.SchemaTypes.Mixed,
+    alternateName: mongoose_1.SchemaTypes.Mixed,
+    typeOf: {
+        type: String,
+        required: true
+    },
+    itemListElement: [mongoose_1.SchemaTypes.Mixed],
+    itemOffered: mongoose_1.SchemaTypes.Mixed,
+    additionalProperty: [mongoose_1.SchemaTypes.Mixed],
+    dateSynced: Date,
+    relatedOffer: mongoose_1.SchemaTypes.Mixed
+}, {
+    collection: 'offerCatalogItems',
+    id: true,
+    read: 'primaryPreferred',
+    writeConcern: writeConcern_1.writeConcern,
+    strict: true,
+    strictQuery: false,
+    timestamps: {
+        createdAt: 'createdAt',
+        updatedAt: 'updatedAt'
+    },
+    toJSON: {
+        getters: false,
+        virtuals: false,
+        minimize: false,
+        versionKey: false
+    },
+    toObject: {
+        getters: false,
+        virtuals: true,
+        minimize: false,
+        versionKey: false
+    }
+});
+exports.schema = schema;
+schema.index({ createdAt: 1 }, { name: 'searchByCreatedAt' });
+schema.index({ updatedAt: 1 }, { name: 'searchByUpdatedAt' });

package/lib/chevre/repo/offer.d.ts

@@ -17,6 +17,7 @@ export type IUnitPriceOfferFromAggregateOffer = factory.unitPriceOffer.IUnitPric
 export declare class MongoRepository {
     private readonly aggregateOfferModel;
     private readonly offerCatalogModel;
+    private readonly offerCatalogItemModel;
     constructor(connection: Connection);
     static CREATE_AGGREGATE_OFFERS_MATCH_CONDITIONS(params: Omit<factory.unitPriceOffer.ISearchConditions, 'limit' | 'page' | 'sort'>): IMatchStage[];
     static CREATE_AGGREGATE_OFFERS_PROJECTION(params: IProjection): {
@@ -32,6 +33,7 @@ export declare class MongoRepository {
              * サブカタログID
              */
             id: string;
+            isOfferCatalogItem: boolean;
         };
         projection?: IProjection;
     }): Promise<{
@@ -51,6 +53,7 @@ export declare class MongoRepository {
              * サブカタログID
              */
             id: string;
+            isOfferCatalogItem: boolean;
         };
         availableAtOrFrom?: {
             id?: string;
@@ -74,12 +77,17 @@ export declare class MongoRepository {
              * サブカタログID
              */
             id: string;
+            isOfferCatalogItem: boolean;
         };
         availableAtOrFrom?: {
             id?: string;
         };
         unacceptedPaymentMethod?: string[];
         excludeAppliesToMovieTicket: boolean;
+        /**
+         * 適用決済カード条件
+         */
+        priceSpecification: Pick<factory.unitPriceOffer.IPriceSpecificationSearchConditions, 'appliesToMovieTicket'>;
         onlyValid?: boolean;
         useIncludeInDataCatalog: boolean;
         limit?: number;
@@ -111,12 +119,6 @@ export declare class MongoRepository {
         limit?: number;
         page?: number;
     }): Promise<Pick<factory.priceSpecification.unitPrice.IAppliesToMovieTicket, 'serviceOutput'>[]>;
-    findAggregateOfferById(params: {
-        project: {
-            id: string;
-        };
-        id: string;
-    }): Promise<factory.aggregateOffer.IAggregateOffer>;
     count(params: Omit<factory.unitPriceOffer.ISearchConditions, 'limit' | 'page' | 'sort'>): Promise<number>;
     search(params: factory.unitPriceOffer.ISearchConditions, projection?: IProjection): Promise<IUnitPriceOfferFromAggregateOffer[]>;
     save(params: factory.unitPriceOffer.IUnitPriceOffer & {
@@ -144,12 +146,6 @@ export declare class MongoRepository {
             };
         };
     }): Promise<import("mongodb").UpdateResult | undefined>;
-    deleteById(params: {
-        project: {
-            id: string;
-        };
-        id: string;
-    }): Promise<void>;
     /**
      * サブカタログから集計オファーIDリストを検索する
      */