@chevre/domain 20.2.0-alpha.9 → 20.2.0

package/lib/chevre/repo/mongoose/model/aggregation.d.ts

@@ -0,0 +1,7 @@
+import * as mongoose from 'mongoose';
+declare const modelName = "Aggregation";
+/**
+ * 集計スキーマ
+ */
+declare const schema: mongoose.Schema<mongoose.Document<any, any, any>, mongoose.Model<mongoose.Document<any, any, any>, any, any>, undefined, {}>;
+export { modelName, schema };

package/lib/chevre/repo/mongoose/model/aggregation.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.modelName = void 0;
+const mongoose = require("mongoose");
+const modelName = 'Aggregation';
+exports.modelName = modelName;
+const writeConcern = { j: true, w: 'majority', wtimeout: 10000 };
+/**
+ * 集計スキーマ
+ */
+const schema = new mongoose.Schema({}, {
+    collection: 'aggregations',
+    id: true,
+    read: 'primaryPreferred',
+    writeConcern: writeConcern,
+    strict: false,
+    useNestedStrict: true,
+    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' });
+mongoose.model(modelName, schema)
+    .on('index', 
+// tslint:disable-next-line:no-single-line-block-comment
+/* istanbul ignore next */
+(error) => {
+    if (error !== undefined) {
+        // tslint:disable-next-line:no-console
+        console.error(error);
+    }
+});

package/lib/chevre/repo/mongoose/model/event.js

@@ -30,12 +30,13 @@ const schema = new mongoose.Schema({
     startDate: Date,
     workPerformed: mongoose.SchemaTypes.Mixed,
     superEvent: mongoose.SchemaTypes.Mixed,
-    videoFormat: [mongoose.SchemaTypes.Mixed],
-    soundFormat: [mongoose.SchemaTypes.Mixed],
+    videoFormat: mongoose.SchemaTypes.Mixed,
+    soundFormat: mongoose.SchemaTypes.Mixed,
     subtitleLanguage: mongoose.SchemaTypes.Mixed,
     dubLanguage: mongoose.SchemaTypes.Mixed,
     kanaName: String,
-    hasOfferCatalog: mongoose.SchemaTypes.Mixed,
+    // 不要なので廃止(2023-01-23~)
+    // hasOfferCatalog: mongoose.SchemaTypes.Mixed,
     offers: mongoose.SchemaTypes.Mixed,
     maximumAttendeeCapacity: { type: Number },
     remainingAttendeeCapacity: { type: Number },

package/lib/chevre/repo/mongoose/model/offer.js

@@ -41,7 +41,8 @@ const schema = new mongoose.Schema({
     eligibleRegion: mongoose.SchemaTypes.Mixed,
     eligibleSeatingType: mongoose.SchemaTypes.Mixed,
     eligibleSubReservation: mongoose.SchemaTypes.Mixed,
-    // eligibleMovieTicketType: String,
+    // settings追加(2023-01-26~)
+    settings: mongoose.SchemaTypes.Mixed,
     validFrom: Date,
     validThrough: Date,
     validRateLimit: mongoose.SchemaTypes.Mixed

package/lib/chevre/repo/mongoose/model/project.js

@@ -10,6 +10,12 @@ const writeConcern = { j: true, w: 'majority', wtimeout: 10000 };
  */
 const schema = new mongoose.Schema({
     _id: String,
+    aggregateReservation: mongoose.SchemaTypes.Mixed,
+    alternateName: String,
+    logo: String,
+    name: String,
+    settings: mongoose.SchemaTypes.Mixed,
+    subscription: mongoose.SchemaTypes.Mixed,
     typeOf: {
         type: String,
         required: true
@@ -19,7 +25,7 @@ const schema = new mongoose.Schema({
     id: true,
     read: 'primaryPreferred',
     writeConcern: writeConcern,
-    strict: false,
+    strict: true,
     useNestedStrict: true,
     timestamps: {
         createdAt: 'createdAt',

package/lib/chevre/repo/mongoose/model/telemetry.js

@@ -5,41 +5,17 @@ const mongoose = require("mongoose");
 const modelName = 'Telemetry';
 exports.modelName = modelName;
 const writeConcern = { j: true, w: 'majority', wtimeout: 10000 };
-const purposeSchema = new mongoose.Schema({
-    typeOf: String
-}, {
-    id: false,
-    _id: false,
-    strict: false
-});
-const objectSchema = new mongoose.Schema({
-    measuredAt: Date
-}, {
-    id: false,
-    _id: false,
-    strict: false
-});
-const resultSchema = new mongoose.Schema({}, {
-    id: false,
-    _id: false,
-    strict: false
-});
-const errorSchema = new mongoose.Schema({}, {
-    id: false,
-    _id: false,
-    strict: false
-});
 /**
  * 測定スキーマ
  */
 const schema = new mongoose.Schema({
     project: mongoose.SchemaTypes.Mixed,
-    result: resultSchema,
-    error: errorSchema,
-    object: objectSchema,
+    result: mongoose.SchemaTypes.Mixed,
+    error: mongoose.SchemaTypes.Mixed,
+    object: mongoose.SchemaTypes.Mixed,
     startDate: Date,
     endDate: Date,
-    purpose: purposeSchema
+    purpose: mongoose.SchemaTypes.Mixed
 }, {
     collection: 'telemetries',
     id: true,

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

@@ -13,9 +13,19 @@ export declare class MongoRepository {
      * カタログに登録されたオファーの順序は保証される
      */
     findOffersByOfferCatalogId(params: {
+        /**
+         * 指定したIDのオファーだけ取得する場合
+         */
+        ids?: string[];
         offerCatalog: {
             id: string;
         };
+        availableAtOrFrom?: {
+            id?: string;
+        };
+        limit?: number;
+        page?: number;
+        sort: boolean;
     }): Promise<factory.unitPriceOffer.IUnitPriceOffer[]>;
     findById(params: {
         id: string;

package/lib/chevre/repo/offer.js

@@ -301,27 +301,58 @@ class MongoRepository {
      * カタログに登録されたオファーの順序は保証される
      */
     findOffersByOfferCatalogId(params) {
+        var _a;
         return __awaiter(this, void 0, void 0, function* () {
-            const offerCatalog = yield this.offerCatalogModel.findById(params.offerCatalog.id, {
-                __v: 0,
-                createdAt: 0,
-                updatedAt: 0
-            })
-                .exec()
-                .then((doc) => {
-                if (doc === null) {
-                    throw new factory.errors.NotFound(this.offerCatalogModel.modelName);
+            // aggregateで再実装(2023-01-26~)
+            const matchStages = [{ $match: { _id: { $eq: params.offerCatalog.id } } }];
+            if (Array.isArray(params.ids)) {
+                matchStages.push({
+                    $match: { 'itemListElement.id': { $exists: true, $in: params.ids } }
+                });
+            }
+            const aggregate = this.offerCatalogModel.aggregate([
+                { $unwind: '$itemListElement' },
+                ...matchStages,
+                {
+                    $project: {
+                        _id: 0,
+                        id: '$itemListElement.id'
+                    }
                 }
-                return doc.toObject();
-            });
-            const sortedOfferIds = (Array.isArray(offerCatalog.itemListElement))
-                ? offerCatalog.itemListElement.map((element) => element.id)
+            ]);
+            const itemListElements = yield aggregate.exec();
+            const sortedOfferIds = (Array.isArray(itemListElements))
+                ? itemListElements.map((element) => element.id)
                 : [];
+            // const offerCatalog = await this.offerCatalogModel.findById(
+            //     params.offerCatalog.id,
+            //     {
+            //         itemListElement: 1
+            //     }
+            // )
+            //     .exec()
+            //     .then((doc) => {
+            //         if (doc === null) {
+            //             throw new factory.errors.NotFound(this.offerCatalogModel.modelName);
+            //         }
+            //         return <Pick<factory.offerCatalog.IOfferCatalog, 'itemListElement'>>doc.toObject();
+            //     });
+            // let sortedOfferIds: string[] = (Array.isArray(offerCatalog.itemListElement))
+            //     ? offerCatalog.itemListElement.map((element) => element.id)
+            //     : [];
+            // const filteredIds = params.ids;
+            // if (Array.isArray(filteredIds)) {
+            //     sortedOfferIds = sortedOfferIds.filter((id) => filteredIds.includes(id));
+            // }
             let offers = [];
             if (sortedOfferIds.length > 0) {
-                offers = yield this.search({ id: { $in: sortedOfferIds } });
-                // sorting
-                offers = offers.sort((a, b) => sortedOfferIds.indexOf(String(a.id)) - sortedOfferIds.indexOf(String(b.id)));
+                offers = yield this.search(Object.assign({ id: { $in: sortedOfferIds } }, (typeof ((_a = params.availableAtOrFrom) === null || _a === void 0 ? void 0 : _a.id) === 'string')
+                    ? { availableAtOrFrom: { id: { $eq: params.availableAtOrFrom.id } } }
+                    : undefined));
+                if (params.sort) {
+                    // sorting
+                    offers = offers.sort((a, b) => sortedOfferIds.indexOf(String(a.id)) - sortedOfferIds.indexOf(String(b.id)));
+                }
             }
             return offers;
         });

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

@@ -41,7 +41,13 @@ export declare class MongoRepository {
      */
     findByOrderNumber(params: {
         orderNumber: string;
+        inclusion: string[];
+        exclusion: string[];
     }): Promise<factory.order.IOrder>;
+    findByOrderNumberAndReservationId(params: {
+        orderNumber: string;
+        reservationId: string;
+    }): Promise<Pick<factory.order.IOrder, 'orderNumber' | 'orderStatus' | 'typeOf'>>;
     /**
      * 注文番号で削除する
      */

package/lib/chevre/repo/order.js

@@ -693,7 +693,11 @@ class MongoRepository {
                 .exec();
             // NotFoundであれば状態確認
             if (doc === null) {
-                const order = yield this.findByOrderNumber(params);
+                const order = yield this.findByOrderNumber({
+                    orderNumber: params.orderNumber,
+                    inclusion: [],
+                    exclusion: []
+                });
                 // tslint:disable-next-line:no-single-line-block-comment
                 /* istanbul ignore next */
                 if (order.orderStatus === params.orderStatus) {
@@ -732,7 +736,11 @@ class MongoRepository {
                 .exec();
             // NotFoundであれば状態確認
             if (doc === null) {
-                const order = yield this.findByOrderNumber(params);
+                const order = yield this.findByOrderNumber({
+                    orderNumber: params.orderNumber,
+                    inclusion: [],
+                    exclusion: []
+                });
                 // tslint:disable-next-line:no-single-line-block-comment
                 /* istanbul ignore next */
                 if (order.orderStatus === factory.orderStatus.OrderReturned) {
@@ -771,11 +779,49 @@ class MongoRepository {
      */
     findByOrderNumber(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            const doc = yield this.orderModel.findOne({ orderNumber: params.orderNumber }, {
-                __v: 0,
-                createdAt: 0,
-                updatedAt: 0
-            })
+            let projection = {};
+            if (Array.isArray(params.inclusion) && params.inclusion.length > 0) {
+                params.inclusion.forEach((field) => {
+                    projection[field] = 1;
+                });
+            }
+            else {
+                projection = {
+                    __v: 0,
+                    createdAt: 0,
+                    updatedAt: 0
+                };
+                if (Array.isArray(params.exclusion) && params.exclusion.length > 0) {
+                    params.exclusion.forEach((field) => {
+                        projection[field] = 0;
+                    });
+                }
+            }
+            const doc = yield this.orderModel.findOne({ orderNumber: params.orderNumber }, projection)
+                .exec();
+            if (doc === null) {
+                throw new factory.errors.NotFound(this.orderModel.modelName);
+            }
+            return doc.toObject();
+        });
+    }
+    findByOrderNumberAndReservationId(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const projection = {
+                orderStatus: 1,
+                typeOf: 1,
+                orderNumber: 1,
+                _id: 0
+            };
+            const doc = yield this.orderModel.findOne({
+                orderNumber: { $eq: params.orderNumber },
+                acceptedOffers: {
+                    $elemMatch: {
+                        'itemOffered.typeOf': { $in: [factory.reservationType.BusReservation, factory.reservationType.EventReservation] },
+                        'itemOffered.id': { $eq: params.reservationId }
+                    }
+                }
+            }, projection)
                 .exec();
             if (doc === null) {
                 throw new factory.errors.NotFound(this.orderModel.modelName);

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

@@ -1,12 +1,14 @@
 import { Connection } from 'mongoose';
 import * as factory from '../factory';
 declare type IScreeningRoomSectionWithoutContainsPlace = Omit<factory.place.screeningRoomSection.IPlace, 'containsPlace'>;
+export declare type IScreeningRoomFoundByBranchCode = Pick<factory.place.screeningRoom.IPlace, 'typeOf' | 'branchCode' | 'name' | 'containsPlace'>;
 /**
  * 施設リポジトリ
  */
 export declare class MongoRepository {
     private readonly placeModel;
     constructor(connection: Connection);
+    static CREATE_BUS_STOP_MONGO_CONDITIONS(params: factory.place.busStop.ISearchConditions): any[];
     static CREATE_MOVIE_THEATER_MONGO_CONDITIONS(params: factory.place.movieTheater.ISearchConditions): any[];
     /**
      * 施設を保管する
@@ -19,7 +21,6 @@ export declare class MongoRepository {
         };
         branchCode: string;
     }): Promise<factory.place.movieTheater.IPlace>;
-    countMovieTheaters(params: factory.place.movieTheater.ISearchConditions): Promise<number>;
     /**
      * 施設検索
      */
@@ -79,6 +80,16 @@ export declare class MongoRepository {
         };
     }): Promise<void>;
     searchScreeningRooms(searchConditions: factory.place.screeningRoom.ISearchConditions): Promise<Omit<factory.place.screeningRoom.IPlace, 'containsPlace'>[]>;
+    findScreeningRoomsByBranchCode(params: {
+        branchCode: {
+            $eq: string;
+        };
+        containedInPlace: {
+            id: {
+                $eq: string;
+            };
+        };
+    }): Promise<IScreeningRoomFoundByBranchCode>;
     createSeat(seat: factory.place.seat.IPlace): Promise<void>;
     updateSeat(seat: factory.place.seat.IPlace, $unset: any): Promise<void>;
     searchSeats(params: factory.place.seat.ISearchConditions): Promise<factory.place.seat.IPlace[]>;
@@ -114,6 +125,20 @@ export declare class MongoRepository {
             id: string;
         };
     }): Promise<void>;
+    saveBusStop(params: factory.place.busStop.IPlace): Promise<factory.place.busStop.IPlace>;
+    findBusStopByBranchCode(params: {
+        project: {
+            id: string;
+        };
+        branchCode: string;
+    }): Promise<factory.place.movieTheater.IPlace>;
+    searchBusStops(params: factory.place.busStop.ISearchConditions): Promise<factory.place.busStop.IPlace[]>;
+    findBusStopById(params: {
+        id: string;
+    }, projection?: any): Promise<factory.place.busStop.IPlace>;
+    deleteBusStopById(params: {
+        id: string;
+    }): Promise<void>;
     getCursor(conditions: any, projection: any): import("mongoose").QueryCursor<any>;
 }
 export {};