@chevre/domain 20.4.0-alpha.9 → 20.4.0

package/example/src/chevre/aggregateEventReservation.ts

@@ -16,11 +16,12 @@ async function main() {
 
     // const now = new Date();
     await chevre.service.aggregation.event.aggregateScreeningEvent({
-        id: 'alb35u7m4'
+        id: String(process.env.EVENT_ID)
     })({
         event: new chevre.repository.Event(mongoose.connection),
         eventAvailability: new chevre.repository.itemAvailability.ScreeningEvent(client),
         offer: new chevre.repository.Offer(mongoose.connection),
+        offerCatalog: new chevre.repository.OfferCatalog(mongoose.connection),
         offerRateLimit: new chevre.repository.rateLimit.Offer(client),
         place: new chevre.repository.Place(mongoose.connection),
         product: new chevre.repository.Product(mongoose.connection),

package/example/src/chevre/deleteMovieTicketCategoryChargePriceSpecs.ts

@@ -0,0 +1,21 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: process.env.PROJECT_ID };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const priceSpecificationRepo = new chevre.repository.PriceSpecification(mongoose.connection);
+
+    const result = await priceSpecificationRepo.deleteUnnecessaryMovieTicketTypeChargePriceSpecs({
+        project: { id: project.id }
+    });
+    console.log('deleted', result);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/{deleteReservationTicketUnderNames.ts → deleteTasksByName.ts}

@@ -8,9 +8,11 @@ import { chevre } from '../../../lib/index';
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI);
 
-    const reservationRepo = new chevre.repository.Reservation(mongoose.connection);
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
 
-    const result = await reservationRepo.deleteReservedTicketUnderName();
+    const result = await taskRepo.deleteByName({
+        name: <any>'deleteAuthorization'
+    });
 
     console.log('deleted', result);
 }

package/example/src/chevre/reIndex.ts

@@ -0,0 +1,25 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const priceSpecificationRepo = new chevre.repository.PriceSpecification(mongoose.connection);
+    const result = await priceSpecificationRepo.reIndex();
+    console.log(result);
+}
+
+main()
+    .then()
+    .catch(console.error);
+// setInterval(
+//     () => {
+//         main()
+//             .then()
+//             .catch(console.error);
+//     },
+//     // tslint:disable-next-line:no-magic-numbers
+//     60000
+// );

package/example/src/chevre/searchEventTicketOffers.ts

@@ -22,11 +22,13 @@ async function main() {
     const productRepo = new chevre.repository.Product(mongoose.connection);
 
     const { ticketOffers } = await chevre.service.offer.event.searchEventTicketOffers({
-        event: { id: 'al9ew43f5' },
+        event: { id: 'ale6qiedq' },
         onlyValid: true,
-        sort: true,
-        validateOfferRateLimit: true
-        // ...(typeof sellerId === 'string') ? { seller: { id: sellerId } } : undefined,
+        validateOfferRateLimit: true,
+        addSortIndex: true,
+        limit: 100,
+        page: 1,
+        searchAddOns: true
         // ...(typeof availableAtId === 'string') ? { store: { id: availableAtId } } : undefined
     })({
         event: eventRepo,
@@ -35,6 +37,7 @@ async function main() {
         priceSpecification: priceSpecificationRepo,
         product: productRepo
     });
+    console.log(ticketOffers.map((o) => o.sortIndex));
     console.log(ticketOffers.length);
 }
 

package/example/src/chevre/searchOfferCatalogs.ts

@@ -1,28 +1,26 @@
 // tslint:disable:no-console
-// import * as redis from 'redis';
 import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
 
+const PROJECT_ID = process.env.PROJECT_ID;
+
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI);
 
-    const offerCatalogRepo = new chevre.repository.OfferCatalog(mongoose.connection);
+    const catalogRepo = new chevre.repository.OfferCatalog(mongoose.connection);
 
-    const catalogs = await offerCatalogRepo.search({
-        limit: 100,
-        page: 1,
-        // id: { $in: ['0001'] },
-        itemListElement: {
-            id: {
-                $all: ['901', '3001']
-                // $in: ['1001'],
-                // $nin: ['1005']
-            }
-        },
-        itemOffered: { typeOf: { $eq: chevre.factory.product.ProductType.EventService } }
-    });
-    console.log(catalogs);
+    console.log('searching...');
+    const catalogs = await catalogRepo.search(
+        {
+            project: { id: { $eq: PROJECT_ID } },
+            identifier: { $eq: '0001' },
+            sort: { identifier: chevre.factory.sortType.Descending },
+            limit: 2,
+            page: 1
+        }
+    );
+    console.log('catalogs found', catalogs.map((catalog) => `${catalog.identifier} ${catalog.numberOfItems}`));
     console.log(catalogs.length);
 }
 

package/example/src/chevre/searchOffersByCatalog.ts

@@ -9,13 +9,14 @@ async function main() {
 
     const offerRepo = new chevre.repository.Offer(mongoose.connection);
 
-    const offers = await offerRepo.findOffersByOfferCatalogId({
+    const { offers } = await offerRepo.findOffersByOfferCatalogId({
         ids: ['al96nqj7z', 'xxx', '1001'],
         // ids: ['xx', 'xxx'],
         offerCatalog: {
             id: '0001'
             // id: 'xxx'
         },
+        excludeAppliesToMovieTicket: false,
         sort: true
     });
     console.log(offers.map((o) => o.id));

package/example/src/chevre/searchProductOffers.ts

@@ -0,0 +1,38 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const PROJECT_ID = process.env.PROJECT_ID;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const offerRepo = new chevre.repository.Offer(mongoose.connection);
+    const productRepo = new chevre.repository.Product(mongoose.connection);
+
+    const { offers } = await chevre.service.offer.product.search({
+        ids: ['7k7bbepxp', 'yyyyyy'],
+        project: { id: String(PROJECT_ID) },
+        itemOffered: { id: '62b90fef5b3eb4000b75150f' },
+        // seller?: {
+        //     id: string;
+        // },
+        // availableAt?: {
+        //     id: string;
+        // },
+        onlyValid: true,
+        // limit?: number,
+        // page?: number,
+        addSortIndex: false
+    })({
+        offer: offerRepo,
+        product: productRepo
+    });
+    console.log(offers.map((o) => `${o.sortIndex} ${o.id}`));
+    console.log(offers.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchTasks.ts

@@ -0,0 +1,22 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+
+    const tasks = await taskRepo.search({
+        limit: 100,
+        page: 1,
+        id: { $eq: '63b7a54d8ba861284895937f' }
+    });
+    console.log(tasks);
+    console.log(tasks.length);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/unsetUnnecessaryFields.ts

@@ -6,19 +6,14 @@ import { chevre } from '../../../lib/index';
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI);
 
-    const accountRepo = new chevre.repository.Account(mongoose.connection);
-    const permitRepo = new chevre.repository.ServiceOutput(mongoose.connection);
+    const offerRepo = new chevre.repository.Offer(mongoose.connection);
 
-    let updateResult = await accountRepo.unsetUnnecessaryFields({
-        filter: { status: { $exists: true } },
-        $unset: { status: 1 }
+    let updateResult: any;
+    updateResult = await offerRepo.unsetUnnecessaryFields({
+        filter: { 'category.project': { $exists: true } },
+        $unset: { 'category.project': 1 }
     });
-    console.log('accounts unset.', updateResult);
-    updateResult = await permitRepo.unsetUnnecessaryFields({
-        filter: { 'paymentAccount.accountType': { $exists: true } },
-        $unset: { 'paymentAccount.accountType': 1 }
-    });
-    console.log('permits unset', updateResult);
+    console.log('offers unset', updateResult);
 }
 
 main()

package/lib/chevre/errorHandler.js

@@ -19,6 +19,7 @@ function handleMongoError(error) {
     if (handledError instanceof mongoose_1.mongo.MongoError) {
         switch (handledError.code) {
             case MongoErrorCode.DuplicateKey:
+                handledError = new factory_1.errors.AlreadyInUse('', [], `Some fields already in use. code:${handledError.code} message:${handledError.message}`);
                 // no op
                 break;
             case MongoErrorCode.MaxTimeMSExpired:

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

@@ -47,18 +47,13 @@ export declare class MongoRepository {
     /**
      * タスク未エクスポートの取引をひとつ取得してエクスポートを開始する
      */
-    startExportTasks<T extends factory.account.transactionType>(status: factory.transactionStatusType): Promise<factory.account.transaction.ITransaction<T> | null>;
     /**
      * タスクエクスポートリトライ
      * TODO updatedAtを基準にしているが、タスクエクスポートトライ日時を持たせた方が安全か？
      */
-    reexportTasks(params: {
-        intervalInMinutes: number;
-    }): Promise<void>;
     /**
      * タスクをエクスポート済に変更する
      */
-    setTasksExportedById(transactionId: string): Promise<void>;
     /**
      * 取引を期限切れにする
      */

package/lib/chevre/repo/accountTransaction.js

@@ -76,7 +76,7 @@ class MongoRepository {
      */
     start(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.transactionModel.create(Object.assign(Object.assign({}, params), { status: factory.transactionStatusType.InProgress, startDate: new Date(), endDate: undefined, tasksExportationStatus: factory.transactionTasksExportationStatus.Unexported }))
+            return this.transactionModel.create(Object.assign(Object.assign({}, params), { status: factory.transactionStatusType.InProgress, startDate: new Date(), endDate: undefined }))
                 .then((doc) => doc.toObject());
         });
     }
@@ -94,7 +94,7 @@ class MongoRepository {
                         $in: [factory.transactionStatusType.InProgress, factory.transactionStatusType.Confirmed]
                     }
                 }, {
-                    $setOnInsert: Object.assign(Object.assign({}, params), { status: factory.transactionStatusType.InProgress, startDate: startDate, endDate: undefined, tasksExportationStatus: factory.transactionTasksExportationStatus.Unexported })
+                    $setOnInsert: Object.assign(Object.assign({}, params), { status: factory.transactionStatusType.InProgress, startDate: startDate, endDate: undefined })
                 }, {
                     new: true,
                     upsert: true
@@ -225,50 +225,56 @@ class MongoRepository {
     /**
      * タスク未エクスポートの取引をひとつ取得してエクスポートを開始する
      */
-    startExportTasks(status) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.transactionModel.findOneAndUpdate({
-                status: status,
-                tasksExportationStatus: factory.transactionTasksExportationStatus.Unexported
-            }, { tasksExportationStatus: factory.transactionTasksExportationStatus.Exporting }, { new: true })
-                .exec()
-                // tslint:disable-next-line:no-null-keyword
-                .then((doc) => (doc === null) ? null : doc.toObject());
-        });
-    }
+    // public async startExportTasks<T extends factory.account.transactionType>(
+    //     status: factory.transactionStatusType
+    // ): Promise<factory.account.transaction.ITransaction<T> | null> {
+    //     return this.transactionModel.findOneAndUpdate(
+    //         {
+    //             status: status,
+    //             tasksExportationStatus: factory.transactionTasksExportationStatus.Unexported
+    //         },
+    //         { tasksExportationStatus: factory.transactionTasksExportationStatus.Exporting },
+    //         { new: true }
+    //     )
+    //         .exec()
+    //         // tslint:disable-next-line:no-null-keyword
+    //         .then((doc) => (doc === null) ? null : doc.toObject());
+    // }
     // tslint:disable-next-line:no-suspicious-comment
     /**
      * タスクエクスポートリトライ
      * TODO updatedAtを基準にしているが、タスクエクスポートトライ日時を持たせた方が安全か？
      */
-    reexportTasks(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.transactionModel.updateMany({
-                tasksExportationStatus: factory.transactionTasksExportationStatus.Exporting,
-                updatedAt: {
-                    $lt: moment()
-                        .add(-params.intervalInMinutes, 'minutes')
-                        .toDate()
-                }
-            }, {
-                tasksExportationStatus: factory.transactionTasksExportationStatus.Unexported
-            })
-                .exec();
-        });
-    }
+    // public async reexportTasks(params: { intervalInMinutes: number }): Promise<void> {
+    //     await this.transactionModel.updateMany(
+    //         {
+    //             tasksExportationStatus: factory.transactionTasksExportationStatus.Exporting,
+    //             updatedAt: {
+    //                 $lt: moment()
+    //                     .add(-params.intervalInMinutes, 'minutes')
+    //                     .toDate()
+    //             }
+    //         },
+    //         {
+    //             tasksExportationStatus: factory.transactionTasksExportationStatus.Unexported
+    //         }
+    //     )
+    //         .exec();
+    // }
     /**
      * タスクをエクスポート済に変更する
      */
-    setTasksExportedById(transactionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.transactionModel.findByIdAndUpdate(transactionId, {
-                tasksExportationStatus: factory.transactionTasksExportationStatus.Exported,
-                tasksExportedAt: moment()
-                    .toDate()
-            })
-                .exec();
-        });
-    }
+    // public async setTasksExportedById(transactionId: string): Promise<void> {
+    //     await this.transactionModel.findByIdAndUpdate(
+    //         transactionId,
+    //         {
+    //             tasksExportationStatus: factory.transactionTasksExportationStatus.Exported,
+    //             tasksExportedAt: moment()
+    //                 .toDate()
+    //         }
+    //     )
+    //         .exec();
+    // }
     /**
      * 取引を期限切れにする
      */

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

@@ -35,13 +35,6 @@ export declare class MongoRepository {
     }): Promise<IObject>;
     count(params: factory.authorization.ISearchConditions): Promise<number>;
     search(params: factory.authorization.ISearchConditions): Promise<factory.authorization.IAuthorization[]>;
-    deleteByCode(params: {
-        code: string;
-    }): Promise<{
-        n?: number;
-        ok?: number;
-        deletedCount?: number;
-    } | null>;
     /**
      * 有効期限を一定期間過ぎた承認を削除する
      */

package/lib/chevre/repo/code.js

@@ -204,23 +204,6 @@ class MongoRepository {
                 .then((docs) => docs.map((doc) => doc.toObject()));
         });
     }
-    deleteByCode(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return this.authorizationModel.deleteOne({
-                code: { $exists: true, $eq: params.code }
-            })
-                .exec()
-                .then((result) => {
-                return {
-                    n: result === null || result === void 0 ? void 0 : result.n,
-                    // opTime: result.opTime,
-                    ok: result === null || result === void 0 ? void 0 : result.ok,
-                    // operationTime,
-                    deletedCount: result === null || result === void 0 ? void 0 : result.deletedCount
-                };
-            });
-        });
-    }
     /**
      * 有効期限を一定期間過ぎた承認を削除する
      */

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

@@ -10,7 +10,7 @@ export interface IUpdateAggregateReservationParams {
     $set: {
         updatedAt: Date;
         aggregateReservation: factory.event.screeningEvent.IAggregateReservation;
-        aggregateOffer: factory.event.screeningEvent.IAggregateOffer;
+        aggregateOffer?: factory.event.screeningEvent.IAggregateOffer;
         maximumAttendeeCapacity?: number;
         remainingAttendeeCapacity?: number;
         checkInCount?: number;
@@ -141,9 +141,10 @@ export declare class MongoRepository {
     }, update: IUpdateAggregateReservationParams | IUpdateAggregateUseActionsParams): Promise<factory.event.IEvent<T>>;
     bulkWrite(bulkWriteOps: any[]): Promise<BulkWriteOpResultObject>;
     getCursor(conditions: any, projection: any): import("mongoose").QueryCursor<any>;
-    deleteUnnecessaryProjectAttributesById(params: {
-        id: string;
-    }): Promise<void>;
+    unsetUnnecessaryFields(params: {
+        filter: any;
+        $unset: any;
+    }): Promise<import("mongoose").UpdateWriteOpResult>;
     aggregateEvent(params: {
         project?: {
             id?: {

package/lib/chevre/repo/event.js

@@ -638,14 +638,14 @@ class MongoRepository {
         return __awaiter(this, void 0, void 0, function* () {
             const conditions = MongoRepository.CREATE_MONGO_CONDITIONS(params);
             const positiveProjectionExists = (projection !== undefined && projection !== null)
-                ? Object.keys(projection)
-                    .some((key) => projection[key] !== 0)
+                ? Object.values(projection)
+                    .some((value) => value !== 0)
                 : false;
             const query = this.eventModel.find({ $and: conditions }, 
             // :1対応(2023-01-25~)
             (positiveProjectionExists)
                 ? projection
-                : Object.assign({ __v: 0, createdAt: 0, updatedAt: 0 }, projection));
+                : Object.assign(Object.assign({}, projection), { __v: 0, createdAt: 0, updatedAt: 0 }));
             if (typeof params.limit === 'number') {
                 const page = (typeof params.page === 'number') ? params.page : 1;
                 query.limit(params.limit)
@@ -680,14 +680,14 @@ class MongoRepository {
     findById(params, projection) {
         return __awaiter(this, void 0, void 0, function* () {
             const positiveProjectionExists = (projection !== undefined && projection !== null)
-                ? Object.keys(projection)
-                    .some((key) => projection[key] !== 0)
+                ? Object.values(projection)
+                    .some((value) => value !== 0)
                 : false;
             const doc = yield this.eventModel.findOne({ _id: params.id }, 
             // :1対応(2023-01-25~)
             (positiveProjectionExists)
                 ? projection
-                : Object.assign({ __v: 0, createdAt: 0, updatedAt: 0 }, projection))
+                : Object.assign(Object.assign({}, projection), { __v: 0, createdAt: 0, updatedAt: 0 }))
                 .exec();
             if (doc === null) {
                 throw new factory.errors.NotFound(this.eventModel.modelName);
@@ -751,18 +751,9 @@ class MongoRepository {
             .sort({ startDate: factory.sortType.Descending })
             .cursor();
     }
-    deleteUnnecessaryProjectAttributesById(params) {
+    unsetUnnecessaryFields(params) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.eventModel.updateOne({
-                _id: { $eq: params.id }
-            }, {
-                $unset: {
-                    'location.project': 1,
-                    'workPerformed.project': 1,
-                    'superEvent.location.project': 1,
-                    'superEvent.workPerformed.project': 1
-                }
-            })
+            return this.eventModel.updateMany(params.filter, { $unset: params.$unset })
                 .exec();
         });
     }

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

@@ -25,15 +25,10 @@ const schema = new mongoose.Schema({
     },
     agent: mongoose.SchemaTypes.Mixed,
     recipient: mongoose.SchemaTypes.Mixed,
-    error: mongoose.SchemaTypes.Mixed,
-    result: mongoose.SchemaTypes.Mixed,
     object: mongoose.SchemaTypes.Mixed,
     expires: Date,
     startDate: Date,
     endDate: Date,
-    dateReturned: Date,
-    tasksExportedAt: Date,
-    tasksExportationStatus: String,
     potentialActions: mongoose.SchemaTypes.Mixed
 }, {
     collection: 'accountTransactions',

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

@@ -10,14 +10,17 @@ const writeConcern = { j: true, w: 'majority', wtimeout: 10000 };
  */
 const schema = new mongoose.Schema({
     project: mongoose.SchemaTypes.Mixed,
-    typeOf: String,
+    typeOf: {
+        type: String,
+        required: true
+    },
     member: mongoose.SchemaTypes.Mixed
 }, {
     collection: 'members',
     id: true,
     read: 'primaryPreferred',
     writeConcern: writeConcern,
-    strict: false,
+    strict: true,
     useNestedStrict: true,
     timestamps: {
         createdAt: 'createdAt',

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

@@ -11,8 +11,6 @@ const writeConcern = { j: true, w: 'majority', wtimeout: 10000 };
 const schema = new mongoose.Schema({
     project: mongoose.SchemaTypes.Mixed,
     _id: String,
-    // Stringに変更(2022-08-08~)
-    // identifier: mongoose.SchemaTypes.Mixed,
     identifier: String,
     typeOf: String,
     name: mongoose.SchemaTypes.Mixed,
@@ -21,16 +19,16 @@ const schema = new mongoose.Schema({
     color: mongoose.SchemaTypes.Mixed,
     additionalProperty: [mongoose.SchemaTypes.Mixed],
     alternateName: mongoose.SchemaTypes.Mixed,
-    acceptedPaymentMethod: mongoose.SchemaTypes.Mixed,
-    addOn: mongoose.SchemaTypes.Mixed,
-    availableAddOn: mongoose.SchemaTypes.Mixed,
+    // acceptedPaymentMethod: mongoose.SchemaTypes.Mixed, // 削除(2023-02-27~)
+    addOn: [mongoose.SchemaTypes.Mixed],
+    // availableAddOn: mongoose.SchemaTypes.Mixed, // 削除(2023-02-27~)
     availability: String,
-    availabilityEnds: Date,
-    availabilityStarts: Date,
-    availableAtOrFrom: mongoose.SchemaTypes.Mixed,
+    // availabilityEnds: Date, // 削除(2023-02-27~)
+    // availabilityStarts: Date, // 削除(2023-02-27~)
+    availableAtOrFrom: [mongoose.SchemaTypes.Mixed],
     hasMerchantReturnPolicy: mongoose.SchemaTypes.Mixed,
     itemOffered: mongoose.SchemaTypes.Mixed,
-    price: Number,
+    // price: Number, // 削除(2023-02-27~)
     priceCurrency: String,
     priceSpecification: mongoose.SchemaTypes.Mixed,
     eligibleCustomerType: mongoose.SchemaTypes.Mixed,
@@ -196,6 +194,18 @@ schema.index({ additionalProperty: 1, 'priceSpecification.price': 1 }, {
         additionalProperty: { $exists: true }
     }
 });
+schema.index({ validFrom: 1, 'priceSpecification.price': 1 }, {
+    name: 'searchByValidFrom',
+    partialFilterExpression: {
+        validFrom: { $exists: true }
+    }
+});
+schema.index({ validThrough: 1, 'priceSpecification.price': 1 }, {
+    name: 'searchByValidThrough',
+    partialFilterExpression: {
+        validThrough: { $exists: true }
+    }
+});
 mongoose.model(modelName, schema)
     .on('index', 
 // tslint:disable-next-line:no-single-line-block-comment