@chevre/domain 21.7.0-alpha.14 → 21.7.0-alpha.15

package/example/src/chevre/createDeleteTransactionTasksIfNotExist.ts

@@ -0,0 +1,98 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const ONE_YEAR_IN_DAYS = 365;
+type IDeletingTransaction = Pick<
+    chevre.factory.transaction.placeOrder.ITransaction,
+    'id' | 'project' | 'typeOf' | 'startDate' | 'endDate' | 'object'
+>;
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
+
+    const now = new Date();
+    const endDateLt: Date = moment(now)
+        // tslint:disable-next-line:no-magic-numbers
+        .add(-ONE_YEAR_IN_DAYS, 'days')
+        .toDate();
+
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+    const transactionRepo = new chevre.repository.Transaction(mongoose.connection);
+
+    const deletingTransactions = <IDeletingTransaction[]>await transactionRepo.search<chevre.factory.transactionType.PlaceOrder>(
+        {
+            limit: 100,
+            page: 1,
+            sort: { startDate: chevre.factory.sortType.Ascending },
+            typeOf: chevre.factory.transactionType.PlaceOrder,
+            statuses: [
+                chevre.factory.transactionStatusType.Canceled,
+                chevre.factory.transactionStatusType.Confirmed,
+                chevre.factory.transactionStatusType.Expired
+            ],
+            endThrough: endDateLt,
+            inclusion: ['_id', 'project', 'typeOf', 'startDate', 'endDate', 'object'],
+            exclusion: []
+        }
+    );
+
+    let i = 0;
+    let updateCount = 0;
+    for (const deletingTransaction of deletingTransactions) {
+        i += 1;
+        const transaction: IDeletingTransaction = deletingTransaction;
+        console.log('checking...', transaction.project.id, transaction.id, transaction.startDate, transaction.endDate, i);
+
+        const isEndDateBefore = transaction.endDate !== undefined && moment(transaction.endDate)
+            .isBefore(endDateLt);
+        if (isEndDateBefore) {
+            const runsAt: Date = moment(transaction.endDate)
+                .add(ONE_YEAR_IN_DAYS, 'days')
+                .toDate();
+
+            updateCount += 1;
+            const deleteTransactionTask: chevre.factory.task.deleteTransaction.IAttributes = {
+                project: transaction.project,
+                name: chevre.factory.taskName.DeleteTransaction,
+                status: chevre.factory.taskStatus.Ready,
+                runsAt,
+                remainingNumberOfTries: 3,
+                numberOfTried: 0,
+                executionResults: [],
+                data: {
+                    object: {
+                        specifyingMethod: chevre.factory.task.deleteTransaction.SpecifyingMethod.Id,
+                        endDate: transaction.endDate,
+                        id: transaction.id,
+                        object: {
+                            ...(typeof transaction.object.confirmationNumber === 'string')
+                                ? { confirmationNumber: transaction.object.confirmationNumber }
+                                : undefined,
+                            ...(typeof transaction.object.orderNumber === 'string')
+                                ? { orderNumber: transaction.object.orderNumber }
+                                : undefined
+                        },
+                        project: transaction.project,
+                        startDate: transaction.startDate,
+                        typeOf: transaction.typeOf
+                    }
+                }
+            };
+            console.log(
+                'saving task...',
+                deleteTransactionTask.runsAt, transaction.project.id, transaction.id, transaction.startDate, transaction.endDate, i);
+            await taskRepo.createDeleteTransactionTaskIfNotExist(deleteTransactionTask, { emitImmediately: false });
+            console.log('task saved', transaction.project.id, transaction.id, transaction.startDate, transaction.endDate, i);
+        }
+    }
+
+    console.log(i, 'transactions checked');
+    console.log(updateCount, 'transactions updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

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

@@ -31,6 +31,10 @@ export declare class MongoRepository {
         id: string;
     }[]>;
     createInformTaskIfNotExist(params: factory.task.IAttributes<factory.taskName.TriggerWebhook>, options: IOptionOnCreate): Promise<void>;
+    /**
+     * 取引削除タスク冪等作成
+     */
+    createDeleteTransactionTaskIfNotExist(params: factory.task.IAttributes<factory.taskName.DeleteTransaction>, options: IOptionOnCreate): Promise<void>;
     executeById(params: {
         id: string;
         executor: {

package/lib/chevre/repo/task.js

@@ -206,6 +206,30 @@ class MongoRepository {
             }
         });
     }
+    /**
+     * 取引削除タスク冪等作成
+     */
+    createDeleteTransactionTaskIfNotExist(params, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (params.data.object.specifyingMethod !== factory.task.deleteTransaction.SpecifyingMethod.Id) {
+                throw new factory.errors.NotImplemented(`only ${factory.task.deleteTransaction.SpecifyingMethod.Id} implemented`);
+            }
+            const createdTask = yield this.taskModel.findOneAndUpdate({
+                'project.id': { $eq: params.project.id },
+                name: { $eq: params.name },
+                'data.object.id': { $exists: true, $eq: params.data.object.id }
+            }, { $setOnInsert: params }, { new: true, upsert: true })
+                .select({ _id: 1 })
+                .exec();
+            if (options.emitImmediately) {
+                task_2.taskEventEmitter.emitTaskStatusChanged({
+                    id: createdTask.id,
+                    name: params.name,
+                    status: factory.taskStatus.Ready
+                });
+            }
+        });
+    }
     executeById(params) {
         return __awaiter(this, void 0, void 0, function* () {
             const doc = yield this.taskModel.findOneAndUpdate({

package/package.json

@@ -117,5 +117,5 @@
     "postversion": "git push origin --tags",
     "prepublishOnly": "npm run clean && npm run build && npm test && npm run doc"
   },
-  "version": "21.7.0-alpha.14"
+  "version": "21.7.0-alpha.15"
 }