@chevre/domain 22.0.0-alpha.8 → 22.0.0

package/example/src/chevre/aggregateAllEvents2.ts

@@ -35,12 +35,15 @@ export async function aggregateScreeningEvent() {
             try {
                 console.log('executing...', count);
                 await (await chevre.service.task.createService()).executeByName({
-                    name: chevre.factory.taskName.AggregateScreeningEvent
+                    name: chevre.factory.taskName.AggregateScreeningEvent,
+                    executor: { name: 'sample' }
                 })({
                     connection: mongoose.connection,
                     redisClient,
+                    credentials: {
+                        sendGrid: await chevre.credentials.SendGrid.createInstance({ apiKey: 'xxx' })
+                    },
                     settings: new chevre.settings.Settings({
-                        transactionWebhookUrls: [],
                         onEventChanged: {
                             informEvent: []
                         },
@@ -53,8 +56,9 @@ export async function aggregateScreeningEvent() {
                         onReservationStatusChanged: {
                             informReservation: []
                         },
-                        webhook: {
-                            timeout: 1000
+                        notification: {
+                            timeout: 1000,
+                            useFetchAPI: true
                         },
                         userPoolIdOld: '',
                         userPoolIdNew: '',
@@ -63,11 +67,14 @@ export async function aggregateScreeningEvent() {
                         useOfferRateLimitProjects: [],
                         defaultSenderEmail: 'test@example.com',
                         deliverOrderLimit: 1,
-                        transaction: { confirmedStoragePeriodInDays: 365, canceledStoragePeriodInDays: 365 },
+                        transaction: { informUrls: [], confirmedStoragePeriodInDays: 365, canceledStoragePeriodInDays: 365 },
                         abortedTasksWithoutReport: [],
+                        coa: { timeout: 1000 },
                         gmo: { timeout: 1000, timeoutBackground: 1000, useFetch: true },
                         movieticketReserve: { timeout: 1000, timeoutCheck: 1000 },
-                        numTryConfirmReserveTransaction: 10
+                        numTryConfirmReserveTransaction: 10,
+                        useAssetTransactionSyncProcessing: true,
+                        useExperimentalFeature: false
                     })
                 });
                 console.log('executed', count);

package/example/src/chevre/aggregation/aggregateOffersOnEvent.ts

@@ -1,78 +1,82 @@
 // tslint:disable:no-console
 import * as mongoose from 'mongoose';
-import * as redis from 'redis';
+// import * as redis from 'redis';
 
 import { chevre } from '../../../../lib/index';
 
 const project = { id: <string>process.env.PROJECT_ID };
-const EVENT_ID = String(process.env.EVENT_ID);
+// const EVENT_ID = String(process.env.EVENT_ID);
 
 // tslint:disable-next-line:max-func-body-length
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-    const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
-        socket: {
-            port: Number(<string>process.env.REDIS_PORT),
-            host: <string>process.env.REDIS_HOST
-        },
-        password: <string>process.env.REDIS_KEY
-    });
-    await client.connect();
+    // const client = redis.createClient<redis.RedisDefaultModules, Record<string, never>, Record<string, never>>({
+    //     socket: {
+    //         port: Number(<string>process.env.REDIS_PORT),
+    //         host: <string>process.env.REDIS_HOST
+    //     },
+    //     password: <string>process.env.REDIS_KEY
+    // });
+    // await client.connect();
 
     const aggregateReservationRepo = await chevre.repository.AggregateReservation.createInstance(mongoose.connection);
-    let aggregateReservations = await aggregateReservationRepo.searchWithReservationForId(
+    const aggregateReservations = await aggregateReservationRepo.searchWithReservationForId(
         {
-            limit: 100,
+            limit: 10,
             page: 1,
             project: { id: { $eq: project.id } },
             reservationFor: {
-                id: { $eq: EVENT_ID },
+                id: {
+                    $in: [
+                        'blvcj2vfl', 'blvcj2w48',
+                        'blvcj2wqj', 'blvcj2y1n',
+                        'blvcj2ylh', 'blvcj2z7k',
+                        'blvcj2zqz', 'blvcj30d3',
+                        'blvcj30wo', 'blvcj32as'
+                    ]
+                },
                 typeOf: chevre.factory.eventType.ScreeningEvent
-            }
+            },
+            sort: { 'reservationFor.startDate': 1 }
         },
         ['aggregateEntranceGate', 'aggregateOffer']
     );
     console.log('aggregateReservations:', aggregateReservations);
+    console.log('aggregateReservations:', aggregateReservations.map(({ id }) => id));
 
-    await (await chevre.service.aggregation.createService()).event.aggregateOffers({
-        id: EVENT_ID,
-        typeOf: chevre.factory.eventType.ScreeningEvent
-    })({
-        aggregateReservation: aggregateReservationRepo,
-        event: await chevre.repository.Event.createInstance(mongoose.connection),
-        stockHolder: await chevre.repository.StockHolder.createInstance(client, mongoose.connection),
-        offer: await chevre.repository.Offer.createInstance(mongoose.connection),
-        offerCatalog: await chevre.repository.OfferCatalog.createInstance(mongoose.connection),
-        offerRateLimit: await chevre.repository.rateLimit.Offer.createInstance(client),
-        screeningRoom: await chevre.repository.place.ScreeningRoom.createInstance(mongoose.connection),
-        product: await chevre.repository.Product.createInstance(mongoose.connection),
-        reservation: await chevre.repository.Reservation.createInstance(mongoose.connection),
-        task: await chevre.repository.Task.createInstance(mongoose.connection)
-    });
-    console.log('aggregateReserveAction processed.');
+    // await (await chevre.service.aggregation.createService()).event.aggregateOffers({
+    //     id: EVENT_ID,
+    //     typeOf: chevre.factory.eventType.ScreeningEvent
+    // })({
+    //     aggregateReservation: aggregateReservationRepo,
+    //     event: await chevre.repository.Event.createInstance(mongoose.connection),
+    //     stockHolder: await chevre.repository.StockHolder.createInstance(client, mongoose.connection),
+    //     offer: await chevre.repository.Offer.createInstance(mongoose.connection),
+    //     offerCatalog: await chevre.repository.OfferCatalog.createInstance(mongoose.connection),
+    //     offerRateLimit: await chevre.repository.rateLimit.Offer.createInstance(client),
+    //     screeningRoom: await chevre.repository.place.ScreeningRoom.createInstance(mongoose.connection),
+    //     product: await chevre.repository.Product.createInstance(mongoose.connection),
+    //     reservation: await chevre.repository.Reservation.createInstance(mongoose.connection)
+    // });
+    // console.log('aggregateReserveAction processed.');
 
-    aggregateReservations = await aggregateReservationRepo.searchWithReservationForId(
-        {
-            limit: 1,
-            page: 1,
-            sort: { 'reservationFor.startDate': 1 },
-            project: { id: { $eq: project.id } },
-            reservationFor: {
-                id: {
-                    $eq: EVENT_ID,
-                    $in: [EVENT_ID]
-                },
-                typeOf: chevre.factory.eventType.ScreeningEvent
-                // startFrom: moment()
-                //     .toDate(),
-                // startThrough: moment()
-                //     .add(1, 'minutes')
-                //     .toDate()
-            }
-        },
-        []
-    );
-    console.log('aggregateReservations:', aggregateReservations);
+    // aggregateReservations = await aggregateReservationRepo.searchWithReservationForId(
+    //     {
+    //         limit: 1,
+    //         page: 1,
+    //         sort: { 'reservationFor.startDate': 1 },
+    //         project: { id: { $eq: project.id } },
+    //         reservationFor: {
+    //             id: {
+    //                 $eq: EVENT_ID,
+    //                 $in: [EVENT_ID]
+    //             },
+    //             typeOf: chevre.factory.eventType.ScreeningEvent
+    //         }
+    //     },
+    //     []
+    // );
+    // console.log('aggregateReservations:', aggregateReservations);
 }
 
 main()

package/example/src/chevre/changeOrderStatus.ts

@@ -0,0 +1,29 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+    const result = await orderRepo.changeStatus(
+        {
+            project: {
+                id: project.id
+            },
+            orderNumber: 'CIN1-3723005-2440693',
+            orderStatus: chevre.factory.orderStatus.OrderDelivered,
+            previousOrderStatus: chevre.factory.orderStatus.OrderInTransit
+        }
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+    console.log(result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/projectEventFieldsById.ts

@@ -0,0 +1,35 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+const startTime = process.hrtime();
+import { chevre } from '../../../lib/index';
+const diff = process.hrtime(startTime);
+console.log(`importing chevre took ${diff[0]} seconds and ${diff[1]} nanoseconds.`);
+
+// const PROJECT_ID = process.env.PROJECT_ID;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const eventRepo: chevre.repository.Event = await chevre.repository.Event.createInstance(mongoose.connection);
+
+    const event = await eventRepo.projectFieldsById(
+        {
+            // id: '120162210202407171202250'
+            id: 'blxonxv1m'
+        },
+        // [
+        //     'project', 'organizer', 'typeOf',
+        //     'name', 'doorTime', 'endDate', 'eventStatus',
+        //     'location', 'startDate', 'superEvent',
+        //     'offers'
+        // ]
+        ['project', 'startDate', 'typeOf', 'superEvent.location.id']
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(event, { depth: null });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/projectOrderFieldsById.ts

@@ -0,0 +1,41 @@
+// tslint:disable:no-console
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { id: String(process.env.PROJECT_ID) };
+
+mongoose.Model.on('index', (...args) => {
+    console.error('******** index event emitted. ********\n', args);
+});
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const orderRepo = await chevre.repository.Order.createInstance(mongoose.connection);
+    const result = await orderRepo.projectFieldsById(
+        {
+            id: '66a04d962582d528b3ba6521',
+            inclusion: ['orderNumber']
+        }
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(result, { depth: null });
+
+    const findByOrderNumberResult = await orderRepo.projectFieldsByOrderNumber(
+        {
+            orderNumber: 'CIN0-2152162-0949752',
+            project: { id: project.id },
+            inclusion: [
+                // 'orderNumber', 'orderStatus', 'typeOf',
+                'project'
+            ]
+        }
+    );
+    // tslint:disable-next-line:no-null-keyword
+    console.log(findByOrderNumberResult);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/searchEvents.ts

@@ -6,7 +6,7 @@ import { chevre } from '../../../lib/index';
 const diff = process.hrtime(startTime);
 console.log(`importing chevre took ${diff[0]} seconds and ${diff[1]} nanoseconds.`);
 
-const PROJECT_ID = process.env.PROJECT_ID;
+// const PROJECT_ID = process.env.PROJECT_ID;
 
 async function main() {
     await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
@@ -15,18 +15,19 @@ async function main() {
 
     const events = await eventRepo.search<chevre.factory.eventType.ScreeningEvent>(
         {
-            limit: 100,
+            limit: 1,
             page: 1,
             // sort: { startDate: 1 },
             typeOf: chevre.factory.eventType.ScreeningEvent,
-            project: { id: { $eq: PROJECT_ID } }
-            // id: { $eq: 'al6aff83y' },
-            // typeOfIn: [chevre.factory.eventType.Event, chevre.factory.eventType.ScreeningEvent]
+            // project: { id: { $eq: PROJECT_ID } },
+            // id: { $eq: '120162210202407171202250' }
+            id: { $eq: 'blxonxv1m' }
         },
-        ['_id', 'name'],
+        ['location', 'project', 'startDate', 'typeOf', 'superEvent.location.id', 'offers.itemOffered'],
         []
     );
-    console.log(events);
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(events, { depth: null });
     console.log(events.length, 'events found');
 }
 

package/example/src/chevre/searchOrders.ts

@@ -21,7 +21,7 @@ async function main() {
 
     const orders = await orderRepo.search(
         {
-            limit: 10,
+            limit: 1,
             project: { id: { $eq: project.id } },
             acceptedOffers: {
                 // itemOffered: {
@@ -48,11 +48,21 @@ async function main() {
             // }
         },
         {
-            orderNumber: 1,
-            customer: 1
+            inclusion: {
+                confirmationNumber: 1,
+                // customer: 1,
+                identifier: 1, orderDate: 1, orderNumber: 1, orderStatus: 1,
+                // orderedItem: 1,
+                // paymentMethods: 1,
+                price: 1, priceCurrency: 1, project: 1,
+                // seller: 1,
+                typeOf: 1
+            },
+            exclusion: {}
         }
     );
-    console.log('orders found', orders);
+    // tslint:disable-next-line:no-null-keyword
+    console.dir(orders, { depth: null });
     console.log(orders.length, 'orders found');
 }
 

package/example/src/chevre/sendGrid/filterEmailActivity.ts

@@ -0,0 +1,33 @@
+// tslint:disable:no-console
+// tslint:disable-next-line:no-implicit-dependencies
+import * as client from '@sendgrid/client';
+
+// tslint:disable-next-line:max-func-body-length
+async function main() {
+    client.setApiKey(<string>process.env.SENDGRID_API_KEY);
+
+    const queryParams = {
+        // "query": "from_email=\"email@example.com\"",
+        // "limit": 10
+    };
+
+    const request = {
+        url: `/v3/messages`,
+        method: 'GET',
+        qs: queryParams
+    };
+
+    client.request(request)
+        .then(([response, body]) => {
+            console.log(response.statusCode);
+            console.log(response.body, body);
+        })
+        .catch((error) => {
+            console.error(error);
+        });
+
+}
+
+main()
+    .then()
+    .catch(console.error);

package/lib/chevre/credentials/customSearch.d.ts

@@ -0,0 +1,13 @@
+interface IOptions {
+    engineId: string;
+    apiKey: string;
+}
+/**
+ * GoogleCustomSearch認証情報
+ */
+declare class CustomSearchCredentials {
+    readonly engineId: string;
+    readonly apiKey: string;
+    constructor(options: IOptions);
+}
+export { CustomSearchCredentials };

package/lib/chevre/credentials/customSearch.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomSearchCredentials = void 0;
+/**
+ * GoogleCustomSearch認証情報
+ */
+class CustomSearchCredentials {
+    constructor(options) {
+        const { engineId, apiKey } = options;
+        this.engineId = engineId;
+        this.apiKey = apiKey;
+    }
+}
+exports.CustomSearchCredentials = CustomSearchCredentials;

package/lib/chevre/credentials/lineNotify.d.ts

@@ -0,0 +1,17 @@
+interface IOptions {
+    url: string;
+    accessToken: string;
+    accessTokenAlert: string;
+    accessTokenInfo: string;
+}
+/**
+ * 通知認証情報
+ */
+declare class LINENotifyCredentials {
+    readonly url: string;
+    readonly accessToken: string;
+    readonly accessTokenAlert: string;
+    readonly accessTokenInfo: string;
+    constructor(options: IOptions);
+}
+export { LINENotifyCredentials };

package/lib/chevre/credentials/lineNotify.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LINENotifyCredentials = void 0;
+/**
+ * 通知認証情報
+ */
+class LINENotifyCredentials {
+    constructor(options) {
+        const { url, accessToken, accessTokenAlert, accessTokenInfo } = options;
+        this.url = url;
+        this.accessToken = accessToken;
+        this.accessTokenAlert = accessTokenAlert;
+        this.accessTokenInfo = accessTokenInfo;
+    }
+}
+exports.LINENotifyCredentials = LINENotifyCredentials;

package/lib/chevre/credentials/sendGrid.d.ts

@@ -0,0 +1,11 @@
+interface IOptions {
+    apiKey: string;
+}
+/**
+ * SendGrid認証情報
+ */
+declare class SendGridCredentials {
+    readonly apiKey: string;
+    constructor(options: IOptions);
+}
+export { SendGridCredentials };

package/lib/chevre/credentials/sendGrid.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendGridCredentials = void 0;
+/**
+ * SendGrid認証情報
+ */
+class SendGridCredentials {
+    constructor(options) {
+        const { apiKey } = options;
+        this.apiKey = apiKey;
+    }
+}
+exports.SendGridCredentials = SendGridCredentials;

package/lib/chevre/credentials.d.ts

@@ -1,28 +1,25 @@
-import type { COACredentials } from './credentials/coa';
+import type { CustomSearchCredentials } from './credentials/customSearch';
 import type { JWTCredentials } from './credentials/jwt';
+import type { LINENotifyCredentials } from './credentials/lineNotify';
+import type { SendGridCredentials } from './credentials/sendGrid';
 /**
- * 外部サービスを使用するための認証情報
+ * 外部サービス認証情報
  */
 export declare namespace credentials {
-    const customSearch: {
-        engineId: string;
-        apiKey: string;
-    };
-    const lineNotify: {
-        url: string | undefined;
-        accessToken: string | undefined;
-        accessTokenAlert: string | undefined;
-        accessTokenInfo: string | undefined;
-    };
-    const sendGrid: {
-        apiKey: string | undefined;
-    };
-    type COA = COACredentials;
-    namespace COA {
-        function createInstance(...params: ConstructorParameters<typeof COACredentials>): Promise<COACredentials>;
+    type CustomSearch = CustomSearchCredentials;
+    namespace CustomSearch {
+        function createInstance(...params: ConstructorParameters<typeof CustomSearchCredentials>): Promise<CustomSearchCredentials>;
     }
     type JWT = JWTCredentials;
     namespace JWT {
         function createInstance(...params: ConstructorParameters<typeof JWTCredentials>): Promise<JWTCredentials>;
     }
+    type LINENotify = LINENotifyCredentials;
+    namespace LINENotify {
+        function createInstance(...params: ConstructorParameters<typeof LINENotifyCredentials>): Promise<LINENotifyCredentials>;
+    }
+    type SendGrid = SendGridCredentials;
+    namespace SendGrid {
+        function createInstance(...params: ConstructorParameters<typeof SendGridCredentials>): Promise<SendGridCredentials>;
+    }
 }