@chevre/domain 21.4.0-alpha.0 → 21.4.0-alpha.10

package/example/src/chevre/cleanActions.ts

@@ -0,0 +1,23 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const actionRepo = new chevre.repository.Action(mongoose.connection);
+
+    const result = await actionRepo.deleteStartDatePassedCertainPeriod({
+        $lt: moment()
+            // tslint:disable-next-line:no-magic-numbers
+            .add(-548, 'days')
+            .toDate()
+    });
+    console.log(result);
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/createManyEventsIfNotExist.ts

@@ -5,6 +5,10 @@ import * as mongoose from 'mongoose';
 import { chevre } from '../../../lib/index';
 
 const PROJECT_ID = String(process.env.PROJECT_ID);
+const ORGANIZER_ID = process.env.ORGANIZER_ID;
+if (typeof ORGANIZER_ID !== 'string' || ORGANIZER_ID.length === 0) {
+    throw new Error('ORGANIZER_ID undefined');
+}
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
@@ -15,6 +19,7 @@ async function main() {
     const result = await eventRepo.createManyIfNotExist<chevre.factory.eventType.ScreeningEvent>([
         {
             attributes: {
+                organizer: { id: String(ORGANIZER_ID) },
                 typeOf: chevre.factory.eventType.ScreeningEvent,
                 project: { id: PROJECT_ID, typeOf: chevre.factory.organizationType.Project },
                 name: {
@@ -184,6 +189,7 @@ async function main() {
         },
         {
             attributes: {
+                organizer: { id: String(ORGANIZER_ID) },
                 typeOf: chevre.factory.eventType.ScreeningEvent,
                 project: { id: PROJECT_ID, typeOf: chevre.factory.organizationType.Project },
                 name: {

package/example/src/chevre/migrateEventOrganizer.ts

@@ -0,0 +1,112 @@
+// 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: true });
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+    const placeRepo = new chevre.repository.Place(mongoose.connection);
+
+    const cursor = eventRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id },
+            // 'project.id': { $ne: EXCLUDED_PROJECT_ID },
+            typeOf: {
+                $in: [
+                    chevre.factory.eventType.ScreeningEvent,
+                    chevre.factory.eventType.ScreeningEventSeries
+                ]
+            }
+            // startDate: {
+            //     $gte: moment()
+            //         // tslint:disable-next-line:no-magic-numbers
+            //         .add(-6, 'months')
+            //         .toDate()
+            // }
+        },
+        {
+            _id: 1,
+            project: 1,
+            location: 1,
+            superEvent: 1,
+            startDate: 1,
+            typeOf: 1,
+            organizer: 1
+        }
+    );
+    console.log('events found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const event: Pick<
+            chevre.factory.event.IEvent<chevre.factory.eventType.ScreeningEvent>,
+            'id' | 'project' | 'location' | 'startDate' | 'typeOf' | 'organizer' | 'superEvent'
+        > | Pick<
+            chevre.factory.event.IEvent<chevre.factory.eventType.ScreeningEventSeries>,
+            'id' | 'project' | 'location' | 'startDate' | 'typeOf' | 'organizer'
+        > = doc.toObject();
+
+        const organizerId = event.organizer?.id;
+        const alreadyMigrated = typeof organizerId === 'string';
+
+        if (alreadyMigrated) {
+            console.log('already exist...', event.project.id, event.id, event.startDate, organizerId, i);
+        } else {
+            let movieTheaterId: string;
+            if (event.typeOf === chevre.factory.eventType.ScreeningEventSeries) {
+                movieTheaterId = event.location.id;
+            } else {
+                movieTheaterId = event.superEvent.location.id;
+            }
+            const movieTheaters = <Pick<chevre.factory.place.movieTheater.IPlaceWithoutScreeningRoom, 'parentOrganization'>[]>
+                await placeRepo.searchMovieTheaters(
+                    {
+                        limit: 1,
+                        page: 1,
+                        project: { id: { $eq: event.project.id } },
+                        id: { $eq: movieTheaterId }
+                    },
+                    ['parentOrganization'],
+                    []
+                );
+            const movieTheater = movieTheaters.shift();
+            const sellerId = movieTheater?.parentOrganization?.id;
+            console.log('movieTheater found', event.project.id, event.id, event.startDate, 'sellerId:', sellerId, i);
+            // 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');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/searchEvents.ts

@@ -10,14 +10,6 @@ async function main() {
 
     const eventRepo = new chevre.repository.Event(mongoose.connection);
 
-    const event = await eventRepo.findById(
-        { id: 'al6aff83y' },
-        {
-            name: 1
-        }
-    );
-    console.log('event found', event);
-
     const events = await eventRepo.search(
         {
             limit: 100,
@@ -25,7 +17,7 @@ async function main() {
             sort: { startDate: 1 },
             typeOf: chevre.factory.eventType.ScreeningEvent,
             project: { id: { $eq: PROJECT_ID } },
-            id: { $in: ['al6aff83y'] }
+            id: { $eq: 'al6aff83y' }
         },
         {
             name: 1

package/example/src/chevre/searchProductOffers.ts

@@ -3,34 +3,25 @@ import * as mongoose from 'mongoose';
 
 import { chevre } from '../../../lib/index';
 
-const PROJECT_ID = process.env.PROJECT_ID;
+const PROJECT_ID = String(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 productOfferRepo = new chevre.repository.ProductOffer(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
+    const offers = await productOfferRepo.search({
+        project: { id: { $eq: PROJECT_ID } }
+        // seller: { id: { $eq: 'xxx' } }
     });
-    console.log(offers.map((o) => `${o.sortIndex} ${o.id}`));
+    console.log(offers);
     console.log(offers.length);
+
+    // await productOfferRepo.deleteOne({
+    //     project: { id: PROJECT_ID },
+    //     seller: { id: 'xxx' },
+    //     itemOffered: { id: 'xxx' }
+    // });
 }
 
 main()

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

@@ -163,6 +163,12 @@ export declare class MongoRepository {
         };
         entranceGateIdentifier: string;
     }): Promise<IUseActionCountByOffer[]>;
+    /**
+     * 開始日時を一定期間過ぎたアクションを削除する
+     */
+    deleteStartDatePassedCertainPeriod(params: {
+        $lt: Date;
+    }): Promise<any>;
     /**
      * 終了日時を一定期間過ぎたアクションを削除する
      */

package/lib/chevre/repo/action.js

@@ -713,6 +713,19 @@ class MongoRepository {
                 .exec();
         });
     }
+    /**
+     * 開始日時を一定期間過ぎたアクションを削除する
+     */
+    deleteStartDatePassedCertainPeriod(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.actionModel.deleteMany({
+                startDate: {
+                    $lt: params.$lt
+                }
+            })
+                .exec();
+        });
+    }
     /**
      * 終了日時を一定期間過ぎたアクションを削除する
      */

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

@@ -121,6 +121,9 @@ export declare class MongoRepository {
      * イベント部分更新
      */
     updatePartiallyById<T extends factory.eventType>(params: {
+        project: {
+            id: string;
+        };
         id: string;
         attributes: IAttributes4patchUpdate<T>;
     }): Promise<factory.event.IEvent<T>>;
@@ -143,15 +146,11 @@ export declare class MongoRepository {
         oldEventId: string;
         attributes: factory.event.IAttributes<factory.eventType.ScreeningEvent>;
     }): Promise<factory.event.IEvent<factory.eventType.ScreeningEvent>>;
-    count<T extends factory.eventType>(params: ISearchConditions<T>): Promise<number>;
     /**
      * イベントを検索する
      */
     search<T extends factory.eventType>(params: ISearchConditions<T>, projection?: IProjection): Promise<factory.event.IEvent<T>[]>;
     searchIds<T extends factory.eventType>(params: ISearchConditions<T>): Promise<string[]>;
-    findById<T extends factory.eventType>(params: {
-        id: string;
-    }, projection?: IProjection): Promise<factory.event.IEvent<T>>;
     findMinimizedIndividualEventById<T extends factory.eventType.ScreeningEvent | factory.eventType.Event>(params: {
         id: string;
     }): Promise<IMinimizedIndividualEvent<T>>;
@@ -159,9 +158,15 @@ export declare class MongoRepository {
      * イベントをキャンセルする
      */
     cancel(params: {
+        project: {
+            id: string;
+        };
         id: string;
     }): Promise<void>;
     deleteById(params: {
+        project: {
+            id: string;
+        };
         id: string;
     }): Promise<void>;
     deleteByProject(params: {