@chevre/domain 21.5.0 → 21.6.0-alpha.1

package/example/src/chevre/migrateEventOrganizer.ts

@@ -1,11 +1,11 @@
 // tslint:disable:no-console
-// import * as moment from 'moment';
+import * as moment from 'moment';
 import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
 
 // const project = { id: String(process.env.PROJECT_ID) };
-// const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
@@ -17,20 +17,20 @@ async function main() {
     const cursor = eventRepo.getCursor(
         {
             // 'project.id': { $eq: project.id },
-            // 'project.id': { $ne: EXCLUDED_PROJECT_ID },
+            'project.id': { $ne: EXCLUDED_PROJECT_ID },
             typeOf: {
                 $in: [
-                    chevre.factory.eventType.ScreeningEvent,
+                    // chevre.factory.eventType.ScreeningEvent,
                     chevre.factory.eventType.ScreeningEventSeries
                 ]
             },
-            organizer: { $exists: false }
-            // startDate: {
-            //     $gte: moment()
-            //         // tslint:disable-next-line:no-magic-numbers
-            //         .add(-6, 'months')
-            //         .toDate()
-            // }
+            organizer: { $exists: true },
+            startDate: {
+                $gte: moment()
+                    // tslint:disable-next-line:no-magic-numbers
+                    .add(-3, 'months')
+                    .toDate()
+            }
         },
         {
             _id: 1,
@@ -46,6 +46,7 @@ async function main() {
 
     let i = 0;
     let updateCount = 0;
+    let invalidOrganizerCount = 0;
     await cursor.eachAsync(async (doc) => {
         i += 1;
         const event: Pick<
@@ -57,48 +58,54 @@ async function main() {
         > = doc.toObject();
 
         const organizerId = event.organizer?.id;
+
+        let movieTheaterId: string;
+        let movieTheaterBranchCode: string;
+        if (event.typeOf === chevre.factory.eventType.ScreeningEventSeries) {
+            movieTheaterId = event.location.id;
+            movieTheaterBranchCode = event.location.branchCode;
+        } else {
+            movieTheaterId = event.superEvent.location.id;
+            movieTheaterBranchCode = event.superEvent.location.branchCode;
+        }
+        const movieTheaters = <Pick<
+            chevre.factory.place.movieTheater.IPlaceWithoutScreeningRoom,
+            'parentOrganization' | 'branchCode'
+        >[]>
+            await placeRepo.searchMovieTheaters(
+                {
+                    limit: 1,
+                    page: 1,
+                    project: { id: { $eq: event.project.id } },
+                    id: { $eq: movieTheaterId }
+                },
+                ['parentOrganization', 'branchCode'],
+                []
+            );
+        const movieTheater = movieTheaters.shift();
+        const sellerId = movieTheater?.parentOrganization?.id;
+        console.log(
+            'movieTheater found',
+            event.project.id, event.id, event.startDate, 'sellerId:', sellerId,
+            'movieTheaterId:', movieTheaterId,
+            'movieTheaterBranchCode:', movieTheaterBranchCode,
+            i
+        );
+
         const alreadyMigrated = typeof organizerId === 'string';
 
         if (alreadyMigrated) {
             console.log('already exist...', event.project.id, event.id, event.startDate, organizerId, i);
-        } else {
-            let movieTheaterId: string;
-            let movieTheaterBranchCode: string;
-            if (event.typeOf === chevre.factory.eventType.ScreeningEventSeries) {
-                movieTheaterId = event.location.id;
-                movieTheaterBranchCode = event.location.branchCode;
+            if (organizerId === sellerId) {
+                console.log('organizerId is valid', event.project.id, event.id, event.startDate, organizerId, i);
             } else {
-                movieTheaterId = event.superEvent.location.id;
-                movieTheaterBranchCode = event.superEvent.location.branchCode;
-            }
-            const movieTheaters = <Pick<
-                chevre.factory.place.movieTheater.IPlaceWithoutScreeningRoom,
-                'parentOrganization' | 'branchCode'
-            >[]>
-                await placeRepo.searchMovieTheaters(
-                    {
-                        limit: 1,
-                        page: 1,
-                        project: { id: { $eq: event.project.id } },
-                        id: { $eq: movieTheaterId }
-                    },
-                    ['parentOrganization', 'branchCode'],
-                    []
-                );
-            const movieTheater = movieTheaters.shift();
-            const sellerId = movieTheater?.parentOrganization?.id;
-            console.log(
-                'movieTheater found',
-                event.project.id, event.id, event.startDate, 'sellerId:', sellerId,
-                'movieTheaterId:', movieTheaterId,
-                'movieTheaterBranchCode:', movieTheaterBranchCode,
-                i
-            );
-            // if (typeof sellerId !== 'string') {
-            //     throw new Error('movieTheater not found');
-            // }
-            if (typeof sellerId === 'string') {
-                const newOrganizer: chevre.factory.event.screeningEventSeries.IOrganizer = {
+                invalidOrganizerCount += 1;
+
+                // organizerを修正する
+                if (typeof sellerId !== 'string') {
+                    throw new Error('movieTheater not found');
+                }
+                const fixedOrganizer: chevre.factory.event.screeningEventSeries.IOrganizer = {
                     id: sellerId
                 };
                 console.log('updating event...', event.project.id, event.id, event.startDate, i);
@@ -107,17 +114,39 @@ async function main() {
                     id: event.id,
                     attributes: <any>{
                         typeOf: event.typeOf,
-                        organizer: newOrganizer
+                        organizer: fixedOrganizer
                     }
                 });
                 updateCount += 1;
                 console.log('updated.', event.project.id, event.id, event.startDate, i);
             }
+        } else {
+            throw new Error('organizer not found');
+            // if (typeof sellerId !== 'string') {
+            //     throw new Error('movieTheater not found');
+            // }
+            // if (typeof sellerId === 'string') {
+            //     const newOrganizer: chevre.factory.event.screeningEventSeries.IOrganizer = {
+            //         id: sellerId
+            //     };
+            //     console.log('updating event...', event.project.id, event.id, event.startDate, i);
+            //     await eventRepo.updatePartiallyById({
+            //         project: { id: event.project.id },
+            //         id: event.id,
+            //         attributes: <any>{
+            //             typeOf: event.typeOf,
+            //             organizer: newOrganizer
+            //         }
+            //     });
+            //     updateCount += 1;
+            //     console.log('updated.', event.project.id, event.id, event.startDate, i);
+            // }
         }
     });
 
     console.log(i, 'events checked');
     console.log(updateCount, 'events updated');
+    console.log(invalidOrganizerCount, 'invalid');
 }
 
 main()

package/example/src/chevre/migrateMovieAvailabilityStarts.ts

@@ -0,0 +1,70 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: String(process.env.PROJECT_ID) };
+// const EXCLUDED_PROJECT_ID = process.env.EXCLUDED_PROJECT_ID;
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const creativeWorkRepo = new chevre.repository.CreativeWork(mongoose.connection);
+
+    const cursor = creativeWorkRepo.getCursor(
+        {
+            'offers.availabilityEnds': { $exists: true }
+        },
+        {}
+    );
+    console.log('creativeWorks found');
+
+    let i = 0;
+    let updateCount = 0;
+    let datePublishedUndefinedCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const movie: chevre.factory.creativeWork.movie.ICreativeWork = doc.toObject();
+
+        const availabilityEnds = movie.offers.availabilityEnds;
+        let availabilityStarts = movie.offers.availabilityStarts;
+        const createdAt: Date = (<any>movie).createdAt;
+        if (!(createdAt instanceof Date)) {
+            throw new Error('createdAt not Date');
+        }
+        const alreadyMigrated = availabilityStarts instanceof Date;
+
+        if (alreadyMigrated) {
+            console.log('already exist...', movie.project.id, movie.id, movie.identifier, availabilityStarts, availabilityEnds, i);
+        } else {
+            if (movie.datePublished === undefined) {
+                console.error('movie.datePublished undefined', movie.project.id, movie.id, movie.identifier, i);
+                // throw new Error('movie.datePublished undefined');
+                datePublishedUndefinedCount += 1;
+            }
+
+            availabilityStarts = (movie.datePublished !== undefined)
+                ? moment(movie.datePublished)
+                    .toDate()
+                : moment(createdAt)
+                    .toDate();
+            console.log('updating movie...', movie.project.id, movie.id, movie.identifier, availabilityStarts, availabilityEnds, i);
+            await creativeWorkRepo.saveMovie(<any>{
+                id: String(movie.id),
+                'offers.availabilityStarts': availabilityStarts
+            });
+            updateCount += 1;
+            console.log('updated.', movie.project.id, movie.id, movie.identifier, availabilityStarts, availabilityEnds, i);
+        }
+    });
+
+    console.log(i, 'creativeWorks checked');
+    console.log(updateCount, 'creativeWorks updated');
+    console.log(datePublishedUndefinedCount, 'datePublishedUndefinedCount');
+}
+
+main()
+    .then()
+    .catch(console.error);

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

@@ -237,6 +237,21 @@ export declare class MongoRepository {
             };
         };
     }): Promise<import("mongodb").DeleteResult>;
+    /**
+     * 興行(プロダクト)から削除する
+     */
+    deleteManyByItemOfferedId(params: {
+        project: {
+            id: string;
+        };
+        offers: {
+            itemOffered: {
+                id: {
+                    $in: string[];
+                };
+            };
+        };
+    }): Promise<import("mongodb").DeleteResult>;
     deleteByProject(params: {
         project: {
             id: string;

package/lib/chevre/repo/event.js

@@ -954,6 +954,18 @@ class MongoRepository {
                 .exec();
         });
     }
+    /**
+     * 興行(プロダクト)から削除する
+     */
+    deleteManyByItemOfferedId(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.eventModel.deleteMany({
+                'project.id': { $eq: params.project.id },
+                'offers.itemOffered.id': { $exists: true, $in: params.offers.itemOffered.id.$in }
+            })
+                .exec();
+        });
+    }
     deleteByProject(params) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.eventModel.deleteMany({

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

@@ -71,6 +71,21 @@ export declare class MongoRepository {
         attributes: factory.unitPriceOffer.IUnitPriceOffer;
         upsert?: boolean;
     }[]): Promise<void>;
+    /**
+     * プロダクトIDからアドオンを除外する
+     */
+    pullAddOns(params: {
+        project: {
+            id: string;
+        };
+        addOn: {
+            itemOffered: {
+                id: {
+                    $in: string[];
+                };
+            };
+        };
+    }): Promise<import("mongodb").UpdateResult | undefined>;
     deleteById(params: {
         id: string;
     }): Promise<void>;

package/lib/chevre/repo/offer.js

@@ -494,6 +494,27 @@ class MongoRepository {
             }
         });
     }
+    /**
+     * プロダクトIDからアドオンを除外する
+     */
+    pullAddOns(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.addOn.itemOffered.id.$in.length === 0) {
+                return;
+            }
+            return this.offerModel.updateMany({
+                'project.id': { $eq: params.project.id },
+                'addOn.itemOffered.id': { $exists: true, $in: params.addOn.itemOffered.id.$in }
+            }, {
+                $pull: {
+                    addOn: {
+                        'itemOffered.id': { $in: params.addOn.itemOffered.id.$in }
+                    }
+                }
+            })
+                .exec();
+        });
+    }
     deleteById(params) {
         return __awaiter(this, void 0, void 0, function* () {
             yield this.offerModel.findOneAndRemove({ _id: params.id })

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

@@ -52,6 +52,20 @@ export declare class MongoRepository {
             };
         };
     }): Promise<void>;
+    pullItemListElement(params: {
+        project: {
+            id: string;
+        };
+        $pull: {
+            itemListElement: {
+                $elemMatch: {
+                    id: {
+                        $in: string[];
+                    };
+                };
+            };
+        };
+    }): Promise<import("mongodb").UpdateResult | undefined>;
     search(params: factory.offerCatalog.ISearchConditions): Promise<(Omit<factory.offerCatalog.IOfferCatalog, 'itemListElement'> & {
         numberOfItems?: number;
     })[]>;

package/lib/chevre/repo/offerCatalog.js

@@ -178,6 +178,27 @@ class MongoRepository {
                 .exec();
         });
     }
+    pullItemListElement(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.$pull.itemListElement.$elemMatch.id.$in.length === 0) {
+                return;
+            }
+            return this.offerCatalogModel.updateMany({
+                'project.id': { $eq: params.project.id },
+                'itemListElement.id': {
+                    $exists: true,
+                    $in: params.$pull.itemListElement.$elemMatch.id.$in
+                }
+            }, {
+                $pull: {
+                    itemListElement: {
+                        id: { $in: params.$pull.itemListElement.$elemMatch.id.$in }
+                    }
+                }
+            })
+                .exec();
+        });
+    }
     search(params) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {

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

@@ -68,6 +68,14 @@ export declare class MongoRepository {
          */
         createIfNotExist?: boolean;
     }): Promise<factory.product.IProduct>;
+    deleteByHasOfferCatalog(params: {
+        project: {
+            id: string;
+        };
+        hasOfferCatalog: {
+            id: string;
+        };
+    }): Promise<import("mongodb").DeleteResult>;
     /**
      * プロジェクト指定で削除する
      */

package/lib/chevre/repo/product.js

@@ -371,6 +371,15 @@ class MongoRepository {
             return doc.toObject();
         });
     }
+    deleteByHasOfferCatalog(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.productModel.deleteMany({
+                'project.id': { $eq: params.project.id },
+                'hasOfferCatalog.id': { $exists: true, $eq: params.hasOfferCatalog.id }
+            })
+                .exec();
+        });
+    }
     /**
      * プロジェクト指定で削除する
      */

package/lib/chevre/service/event/createEvent.js

@@ -37,7 +37,7 @@ function createEvent(params) {
                         const firstCreatingEventParams = creatingEventParams[0];
                         const movieTheaters = yield repos.place.searchMovieTheaters({
                             project: { id: { $eq: actionAttributes.project.id } }
-                        }, ['_id', 'branchCode', 'kanaName', 'name'], []);
+                        }, ['_id', 'branchCode', 'kanaName', 'name', 'parentOrganization'], []);
                         creatingEventParams = movieTheaters.map((movieTheater) => {
                             const location = {
                                 branchCode: movieTheater.branchCode,
@@ -46,8 +46,13 @@ function createEvent(params) {
                                 name: movieTheater.name,
                                 typeOf: factory.placeType.MovieTheater
                             };
+                            const organizer = {
+                                id: movieTheater.parentOrganization.id
+                            };
                             return {
-                                attributes: Object.assign(Object.assign({}, firstCreatingEventParams.attributes), { location })
+                                attributes: Object.assign(Object.assign({}, firstCreatingEventParams.attributes), { location,
+                                    // organizerがfirstCreatingEventParamsにそろってしまうbug対応(2023-08-03~)
+                                    organizer })
                             };
                         });
                     }

package/lib/chevre/service/task/onResourceUpdated/onResourceDeleted.d.ts

@@ -5,6 +5,8 @@ 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 PaymentServiceProviderRepo } from '../../../repo/paymentServiceProvider';
 import { MongoRepository as PlaceRepo } from '../../../repo/place';
 import { MongoRepository as ProductRepo } from '../../../repo/product';
@@ -18,6 +20,8 @@ export declare function onResourceDeleted(params: factory.task.onResourceUpdated
     event: EventRepo;
     member: MemberRepo;
     paymentServiceProvider: PaymentServiceProviderRepo;
+    offer: OfferRepo;
+    offerCatalog: OfferCatalogRepo;
     place: PlaceRepo;
     product: ProductRepo;
     productOffer: ProductOfferRepo;

package/lib/chevre/service/task/onResourceUpdated/onResourceDeleted.js

@@ -41,8 +41,21 @@ function onResourceDeleted(params) {
                         ids: params.id
                     })(repos);
                     break;
+                case factory.offerType.Offer:
+                    yield deleteResourcesByOffer({
+                        project: { id: params.project.id },
+                        ids: params.id
+                    })(repos);
+                    break;
+                case 'OfferCatalog':
+                    yield deleteResourcesByOfferCatalog({
+                        project: { id: params.project.id },
+                        ids: params.id
+                    })(repos);
+                    break;
                 default:
-                // no op
+                    // no op
+                    throw new factory.errors.NotImplemented(`${params.typeOf} onDeleted not implemented`);
             }
         }
     });
@@ -228,3 +241,95 @@ function deleteResourcesBySeller(params) {
         }
     });
 }
+function deleteResourcesByOffer(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        if (params.ids.length !== 1) {
+            throw new factory.errors.Argument('id', 'id.length must be 1');
+        }
+        for (const offerId of params.ids) {
+            const deleteActionAttributes = {
+                agent: { id: params.project.id, typeOf: factory.organizationType.Project },
+                object: { id: offerId, typeOf: factory.offerType.Offer },
+                project: { id: params.project.id, typeOf: factory.organizationType.Project },
+                typeOf: factory.actionType.DeleteAction
+            };
+            let deleteResult;
+            const action = yield repos.action.start(deleteActionAttributes);
+            try {
+                // カタログからpullItemListElement
+                const updateCatalogResult = yield repos.offerCatalog.pullItemListElement({
+                    project: { id: params.project.id },
+                    $pull: { itemListElement: { $elemMatch: { id: { $in: [offerId] } } } }
+                });
+                deleteResult = { updateCatalogResult };
+            }
+            catch (error) {
+                try {
+                    const actionError = Object.assign(Object.assign({}, error), { message: error.message, name: error.name });
+                    yield repos.action.giveUp({ typeOf: deleteActionAttributes.typeOf, id: action.id, error: actionError });
+                }
+                catch (_) {
+                    // no op
+                }
+                throw error;
+            }
+            yield repos.action.complete({ typeOf: deleteActionAttributes.typeOf, id: action.id, result: deleteResult });
+        }
+    });
+}
+function deleteResourcesByOfferCatalog(params) {
+    return (repos) => __awaiter(this, void 0, void 0, function* () {
+        if (params.ids.length !== 1) {
+            throw new factory.errors.Argument('id', 'id.length must be 1');
+        }
+        for (const catalogId of params.ids) {
+            const deleteActionAttributes = {
+                agent: { id: params.project.id, typeOf: factory.organizationType.Project },
+                object: { id: catalogId, typeOf: 'OfferCatalog' },
+                project: { id: params.project.id, typeOf: factory.organizationType.Project },
+                typeOf: factory.actionType.DeleteAction
+            };
+            let deleteResult;
+            const action = yield repos.action.start(deleteActionAttributes);
+            try {
+                // カタログからプロダクト検索
+                const productsWithCatalog = yield repos.product.search({
+                    project: { id: { $eq: params.project.id } },
+                    hasOfferCatalog: { id: { $eq: catalogId } }
+                }, ['_id'], []);
+                let deleteEventResult;
+                let updateOfferResult;
+                if (productsWithCatalog.length > 0) {
+                    const deletingProductIds = productsWithCatalog.map((product) => product.id);
+                    // 興行を設定されたイベント削除
+                    deleteEventResult = yield repos.event.deleteManyByItemOfferedId({
+                        project: { id: params.project.id },
+                        offers: { itemOffered: { id: { $in: deletingProductIds } } }
+                    });
+                    // アドオンから除外
+                    updateOfferResult = yield repos.offer.pullAddOns({
+                        project: { id: params.project.id },
+                        addOn: { itemOffered: { id: { $in: deletingProductIds } } }
+                    });
+                }
+                // プロダクト削除
+                const deleteProductResult = yield repos.product.deleteByHasOfferCatalog({
+                    project: { id: params.project.id },
+                    hasOfferCatalog: { id: catalogId }
+                });
+                deleteResult = { deleteEventResult, deleteProductResult, updateOfferResult };
+            }
+            catch (error) {
+                try {
+                    const actionError = Object.assign(Object.assign({}, error), { message: error.message, name: error.name });
+                    yield repos.action.giveUp({ typeOf: deleteActionAttributes.typeOf, id: action.id, error: actionError });
+                }
+                catch (_) {
+                    // no op
+                }
+                throw error;
+            }
+            yield repos.action.complete({ typeOf: deleteActionAttributes.typeOf, id: action.id, result: deleteResult });
+        }
+    });
+}

package/lib/chevre/service/task/onResourceUpdated.js

@@ -17,6 +17,8 @@ const categoryCode_1 = require("../../repo/categoryCode");
 const creativeWork_1 = require("../../repo/creativeWork");
 const event_1 = require("../../repo/event");
 const member_1 = require("../../repo/member");
+const offer_1 = require("../../repo/offer");
+const offerCatalog_1 = require("../../repo/offerCatalog");
 const paymentServiceProvider_1 = require("../../repo/paymentServiceProvider");
 const place_1 = require("../../repo/place");
 const product_1 = require("../../repo/product");
@@ -37,6 +39,8 @@ function call(data) {
             creativeWork: new creativeWork_1.MongoRepository(connectionSettings.connection),
             event: new event_1.MongoRepository(connectionSettings.connection),
             member: new member_1.MongoRepository(connectionSettings.connection),
+            offer: new offer_1.MongoRepository(connectionSettings.connection),
+            offerCatalog: new offerCatalog_1.MongoRepository(connectionSettings.connection),
             paymentServiceProvider: new paymentServiceProvider_1.MongoRepository(connectionSettings.connection),
             place: new place_1.MongoRepository(connectionSettings.connection),
             product: new product_1.MongoRepository(connectionSettings.connection),

package/package.json

@@ -9,8 +9,8 @@
     }
   ],
   "dependencies": {
-    "@chevre/factory": "4.321.1",
-    "@cinerino/sdk": "3.162.1",
+    "@chevre/factory": "4.323.0",
+    "@cinerino/sdk": "3.162.2",
     "@motionpicture/coa-service": "9.2.0",
     "@motionpicture/gmo-service": "5.2.0",
     "@sendgrid/mail": "6.4.0",
@@ -117,5 +117,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "21.5.0"
+  "version": "21.6.0-alpha.1"
 }