@chevre/domain 15.65.0-alpha.9 → 20.0.0-alpha.1

package/README.md

@@ -3,11 +3,10 @@
 [![npm (scoped)](https://img.shields.io/npm/v/@chevre/domain.svg)](https://www.npmjs.com/package/@chevre/domain)
 [![CircleCI](https://circleci.com/gh/chevre-jp/domain.svg?style=svg)](https://circleci.com/gh/chevre-jp/domain)
 [![Coverage Status](https://coveralls.io/repos/github/chevre-jp/domain/badge.svg?branch=master)](https://coveralls.io/github/chevre-jp/domain?branch=master)
-[![Dependency Status](https://img.shields.io/david/chevre-jp/domain.svg)](https://david-dm.org/chevre-jp/domain)
-[![Known Vulnerabilities](https://snyk.io/test/github/chevre-jp/domain/badge.svg?targetFile=package.json)](https://snyk.io/test/github/chevre-jp/domain?targetFile=package.json)
+[![Known Vulnerabilities](https://snyk.io/test/github/chevre-jp/domain/badge.svg)](https://snyk.io/test/github/chevre-jp/domain)
 [![npm](https://img.shields.io/npm/dm/@chevre/domain.svg)](https://nodei.co/npm/@chevre/domain/)
 
-在庫管理サービスドメイン
+Node.js client library for using Chevre backend programming.
 
 ## Table of contents
 
@@ -18,26 +17,34 @@
 ## Usage
 
 ```shell
-npm install --save @chevre/domain
-```
-
-```Node.js
-const chevre = require("@chevre/domain");
+npm install @chevre/domain
 ```
 
 ### Environment variables
 
-| Name                           | Required | Value           | Purpose                           |
-| ------------------------------ | -------- | --------------- | --------------------------------- |
-| `ABORTED_TASKS_WITHOUT_REPORT` | false    |                 | Aborted task names without report |
-| `DEBUG`                        | false    | chevre-domain:* | Debug                             |
-| `COA_ENDPOINT`                 | false    |                 | COA API Settings                  |
-| `COA_REFRESH_TOKEN`            | false    |                 | COA API Settings                  |
-| `INFORM_PAYMENT_URL`           | false    |                 | Inform payment URL                |
-| `INFORM_RESERVATION_URL`       | false    |                 | Inform reservation URL            |
-| `INFORM_USE_RESERVATION_URL`   | false    |                 | Inform use reservation action URL |
-| `LINE_NOTIFY_URL`              | false    |                 | LINE Notify Settings              |
-| `LINE_NOTIFY_ACCESS_TOKEN`     | false    |                 | LINE Notify Settings              |
+| Name                             | Required | Value           | Purpose                        |
+| -------------------------------- | -------- | --------------- | ------------------------------ |
+| `AWS_ACCESS_KEY_ID`              | true     |                 | AWS access key                 |
+| `AWS_SECRET_ACCESS_KEY`          | true     |                 | AWS secret access key          |
+| `CHEVRE_AUTHORIZE_SERVER_DOMAIN` | true     |                 | Chevre credentials             |
+| `CHEVRE_CLIENT_ID`               | true     |                 | Chevre credentials             |
+| `CHEVRE_CLIENT_SECRET`           | true     |                 | Chevre credentials             |
+| `CHEVRE_ENDPOINT`                | true     |                 | Chevre credentials             |
+| `CUSTOM_SEARCH_ENGINE_ID`        | true     |                 | Google Custom Search Engine ID |
+| `COA_ENDPOINT`                   | true     |                 | COA credentilas                |
+| `COA_REFRESH_TOKEN`              | true     |                 | credentilas                    |
+| `DEBUG`                          | false    | chevre-domain:* | Debug                          |
+| `GOOGLE_API_KEY`                 | true     |                 | Google API Key                 |
+| `INFORM_ORDER_URL`               | false    |                 | Inform Order URLs              |
+| `INFORM_TRANSACTION_URL`         | false    |                 | Inform Transaction URLs        |
+| `LINE_NOTIFY_URL`                | true     |                 | LINE Notify URL                |
+| `LINE_NOTIFY_ACCESS_TOKEN`       | true     |                 | LINE Notify access token       |
+| `SENDGRID_API_KEY`               | true     |                 | SendGrid API key               |
+| `COA_TIMEOUT`                    | false    |                 | Timeout settings               |
+| `GMO_TIMEOUT`                    | false    |                 | Timeout settings               |
+| `MVTK_TIMEOUT`                   | false    |                 | Timeout settings               |
+| `TRIGGER_WEBHOOK_TIMEOUT`        | false    |                 | Timeout settings               |
+
 
 ## Code Samples
 

package/example/src/chevre/accountBlanceTest.ts

@@ -0,0 +1,24 @@
+// 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);
+
+    const accountRepo = new chevre.repository.Account(mongoose.connection);
+
+    // 不要な所有権を削除
+    const result = await accountRepo.authorizeAmount({
+        accountNumber: '139151625010963',
+        amount: 10,
+        transaction: <any>{ id: 'test' },
+        force: false
+    });
+    console.log('result:', result);
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/aggregateAllEvents.ts

@@ -0,0 +1,55 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+const project = { typeOf: chevre.factory.organizationType.Project, id: String(process.env.PROJECT_ID) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const eventRepo = new chevre.repository.Event(mongoose.connection);
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+
+    const now = new Date();
+
+    const events = await eventRepo.search<chevre.factory.eventType.ScreeningEvent>({
+        typeOf: chevre.factory.eventType.ScreeningEvent,
+        project: { id: { $eq: project.id } },
+        startFrom: now
+        // startFrom: moment().add(-1, 'day').toDate(),
+        // startThrough: moment().add(1, 'day').toDate(),
+        // startThrough: now
+    });
+
+    // console.log(events);
+    console.log(events.length);
+    // return;
+
+    const tasks = [];
+    for (const event of events) {
+        const aggregateTask: chevre.factory.task.aggregateScreeningEvent.IAttributes = {
+            name: chevre.factory.taskName.AggregateScreeningEvent,
+            project: { typeOf: chevre.factory.organizationType.Project, id: project.id },
+            status: chevre.factory.taskStatus.Ready,
+            runsAt: new Date(),
+            remainingNumberOfTries: 1,
+            numberOfTried: 0,
+            executionResults: [],
+            data: { typeOf: event.typeOf, id: event.id }
+        };
+        tasks.push(aggregateTask);
+        console.log('task created', event.id);
+    }
+
+    console.log('creating...', tasks.length, 'tasks');
+    const result = await taskRepo.taskModel.insertMany(tasks, { ordered: false, rawResult: true });
+    console.log('result:', { ...result, ops: undefined, insertedIds: undefined });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/aggregateAllEvents2.ts

@@ -0,0 +1,52 @@
+/**
+ * イベント集計タスク実行
+ */
+import { chevre } from '../../../lib/index';
+
+import * as mongoose from 'mongoose';
+import * as redis from 'redis';
+
+const redisClient = redis.createClient({
+    port: Number(<string>process.env.REDIS_PORT),
+    host: <string>process.env.REDIS_HOST,
+    password: <string>process.env.REDIS_KEY,
+    tls: (process.env.REDIS_TLS_SERVERNAME !== undefined) ? { servername: process.env.REDIS_TLS_SERVERNAME } : undefined
+});
+
+export async function aggregateScreeningEvent() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    let count = 0;
+
+    const MAX_NUBMER_OF_PARALLEL_TASKS = 10;
+    const INTERVAL_MILLISECONDS = 100;
+
+    setInterval(
+        async () => {
+            if (count > MAX_NUBMER_OF_PARALLEL_TASKS) {
+                return;
+            }
+
+            count += 1;
+
+            try {
+                console.log('executing...', count);
+                await chevre.service.task.executeByName({
+                    name: chevre.factory.taskName.AggregateScreeningEvent
+                })({ connection: mongoose.connection, redisClient: redisClient });
+                console.log('executed', count);
+            } catch (error) {
+                console.error(error);
+            }
+
+            count -= 1;
+        },
+        INTERVAL_MILLISECONDS
+    );
+}
+
+aggregateScreeningEvent()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/aggregateReservationOnProject.ts

@@ -0,0 +1,32 @@
+// 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 };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    // const now = new Date();
+    await chevre.service.aggregation.project.aggregate({
+        project: { id: project.id },
+        reservationFor: {
+            startFrom: moment('2022-01-01T00:00:00+09:00')
+                .toDate(),
+            startThrough: moment('2022-01-31T23:59:59+09:00')
+                .toDate(),
+        }
+    })({
+        project: new chevre.repository.Project(mongoose.connection),
+        reservation: new chevre.repository.Reservation(mongoose.connection),
+        task: new chevre.repository.Task(mongoose.connection)
+    });
+}
+
+main()
+    .then(() => {
+        console.log('success!');
+    })
+    .catch(console.error);

package/example/src/chevre/assetTransaction/searchGMOTrade.ts

@@ -0,0 +1,27 @@
+// 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 productRepo = new chevre.repository.Product(mongoose.connection);
+    const sellerRepo = new chevre.repository.Seller(mongoose.connection);
+    const assetTransactionRepo = new chevre.repository.AssetTransaction(mongoose.connection);
+
+    const result = await chevre.service.assetTransaction.pay.searchGMOTrade({
+        transactionNumber: '020518441863622'
+    })({
+        product: productRepo,
+        seller: sellerRepo,
+        assetTransaction: assetTransactionRepo
+    });
+    console.log(result);
+    // return;
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/checkOffersAppliesToMovieTicket.ts

@@ -0,0 +1,56 @@
+// 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) };
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const offerRepo = new chevre.repository.Offer(mongoose.connection);
+
+    const cursor = offerRepo.getCursor(
+        {
+            // 'project.id': { $eq: project.id }
+            'priceSpecification.appliesToMovieTicket': {
+                $exists: true,
+                $type: 'array'
+                // $not: { $type: 'array' }
+            }
+        },
+        {
+            // _id: 1,
+            // ownedFrom: 1,
+            // typeOfGood: 1
+        }
+    );
+    console.log('offers found');
+
+    let i = 0;
+    let isArrayCount = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const offer = <chevre.factory.offer.IUnitPriceOffer>doc.toObject();
+        const applieToMovieTicket = offer.priceSpecification?.appliesToMovieTicket;
+        if (Array.isArray(applieToMovieTicket)) {
+            console.log('is Array', offer.project.id, offer.id, i);
+            isArrayCount += 1;
+        } else if (typeof (<any>applieToMovieTicket)?.typeOf === 'string') {
+            console.log('is not array', offer.project.id, offer.id, i);
+            updateCount += 1;
+        } else {
+            console.log('no applieToMovieTicket', offer.project.id, offer.id, i);
+        }
+    });
+
+    console.log(i, 'offers checked');
+    console.log(isArrayCount, 'isArrayCount');
+    console.log(updateCount, 'offers updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/checkOrderMembershipTasks.ts

@@ -0,0 +1,127 @@
+// tslint:disable:no-console
+// import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+import { migrateUser } from './migrateCognitoUser';
+
+const project = { id: String(process.env.PROJECT_ID) };
+export const USERPOOL_ID_OLD = String(process.env.USERPOOL_ID_OLD);
+export const USERPOOL_ID_NEW = String(process.env.USERPOOL_ID_NEW);
+export const ISS_PREFIX = 'https://cognito-idp.ap-northeast-1.amazonaws.com/';
+
+// tslint:disable-next-line:max-func-body-length
+export async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const taskRepo = new chevre.repository.Task(mongoose.connection);
+
+    // const now = new Date();
+    const cursor = await taskRepo.taskModel.find(
+        {
+            // _id: { $eq: '60398ca3bdadde000a308709' },
+            status: { $eq: chevre.factory.taskStatus.Ready },
+            name: { $eq: chevre.factory.taskName.OrderProgramMembership },
+            'project.id': { $eq: project.id }
+        },
+        {
+            // _id: 1,
+        }
+    )
+        .sort({ runsAt: chevre.factory.sortType.Ascending })
+        .cursor();
+    console.log('tasks found');
+
+    let i = 0;
+    let notFoundCount = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const task = <chevre.factory.task.ITask<chevre.factory.taskName.OrderProgramMembership>>doc.toObject();
+
+        const owner = <chevre.factory.person.IPerson>task.data.agent;
+        let iss =
+            (<chevre.factory.propertyValue.IPropertyValue<string>[] | undefined>owner.identifier)?.find((p) => p.name === 'iss')?.value;
+        if (typeof iss === 'string') {
+            iss = iss.replace(ISS_PREFIX, '');
+        }
+
+        // 新会員ならok
+        if (iss === USERPOOL_ID_NEW) {
+            console.log('already new userPool', task.runsAt, i, notFoundCount);
+        } else {
+            // 旧会員の場合、新会員の存在確認
+            console.log(
+                'checking...',
+                task.runsAt,
+                owner.id, owner.memberOf?.membershipNumber, i, notFoundCount);
+            const personRepo = new chevre.repository.Person({ userPoolId: USERPOOL_ID_NEW });
+
+            try {
+                const newUserAttributes = await personRepo.getUserAttributes({ username: `SSKTS_${owner.id}` });
+                const newUserId = newUserAttributes.additionalProperty?.find((p) => p.name === 'sub')?.value;
+                const person = await personRepo.findById({ userId: String(newUserId) });
+                console.log(
+                    'found',
+                    task.runsAt,
+                    owner.id,
+                    owner.memberOf?.membershipNumber,
+                    person.id, i, notFoundCount);
+
+                // 所有権の所有者を新会員に置換
+                const newOwner: chevre.factory.person.IPerson = {
+                    ...owner,
+                    id: person.id,
+                    identifier: [
+                        ...(Array.isArray(person.identifier)) ? person.identifier : [],
+                        // 手動移行した証拠を残す
+                        { name: 'dataAgentMigratedManually', value: '1' }
+                    ]
+                };
+
+                updateCount += 1;
+                console.log(
+                    'updating data.agent...',
+                    task.runsAt,
+                    owner.id,
+                    owner.memberOf?.membershipNumber,
+                    person.id, i, notFoundCount, updateCount);
+                const result = await taskRepo.taskModel.updateOne(
+                    { _id: task.id },
+                    { 'data.agent': newOwner }
+                )
+                    .exec();
+                console.log(
+                    'data.agent updated',
+                    task.runsAt,
+                    owner.id,
+                    owner.memberOf?.membershipNumber,
+                    person.id, i, notFoundCount, updateCount,
+                    result);
+
+            } catch (error) {
+                // NotFoundエラーは、新ユーザープールでのユーザーがまだ存在しないだけ
+                if (error.code === 'UserNotFoundException') {
+                    notFoundCount += 1;
+                    console.log(
+                        'not found',
+                        task.runsAt,
+                        owner.id, owner.memberOf?.membershipNumber, i, notFoundCount);
+                    // migrateUser
+                    await migrateUser({ id: owner.id });
+                } else {
+                    throw error;
+                }
+            }
+        }
+    });
+
+    console.log(i, 'infos checked');
+    console.log(notFoundCount, 'people not found');
+    console.log(updateCount, 'tasks updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/cleanAccountingReports.ts

@@ -0,0 +1,57 @@
+// tslint:disable:no-console
+import * as moment from 'moment';
+import * as mongoose from 'mongoose';
+
+import { chevre } from '../../../lib/index';
+
+// const project = { id: '' };
+// const MASKED_PROFILE = '****';
+
+async function main() {
+    await mongoose.connect(<string>process.env.MONGOLAB_URI);
+
+    const accountingReportRepo = new chevre.repository.AccountingReport(mongoose.connection);
+
+    const cursor = await accountingReportRepo.accountingReportModel.find(
+        {
+            'mainEntity.orderDate': {
+                $lt: moment()
+                    .add(-1, 'year')
+                    .toDate()
+            }
+        },
+        {
+            // _id: 1,
+        }
+    )
+        // .limit(10)
+        .sort({ 'mainEntity.orderDate': chevre.factory.sortType.Descending })
+        .cursor();
+    console.log('reports found');
+
+    let i = 0;
+    let updateCount = 0;
+    await cursor.eachAsync(async (doc) => {
+        i += 1;
+        const accountingReport = doc.toObject();
+
+        console.log(
+            'deleting report...',
+            accountingReport.id, accountingReport.mainEntity.orderNumber, accountingReport.mainEntity.orderDate, i);
+        await accountingReportRepo.accountingReportModel.findByIdAndDelete(
+            accountingReport.id
+        )
+            .exec();
+        updateCount += 1;
+        console.log(
+            'report deleted',
+            accountingReport.id, accountingReport.mainEntity.orderNumber, accountingReport.mainEntity.orderDate, i);
+    });
+
+    console.log(i, 'reports checked');
+    console.log(updateCount, 'reports updated');
+}
+
+main()
+    .then()
+    .catch(console.error);

package/example/src/chevre/copyRedisKeys.ts

@@ -0,0 +1,102 @@
+// tslint:disable:no-console
+import * as redis from 'redis';
+// import * as mongoose from 'mongoose';
+
+// import { chevre } from '../../../lib/index';
+
+async function main() {
+
+    const client = redis.createClient({
+        host: process.env.REDIS_HOST,
+        port: Number(process.env.REDIS_PORT),
+        password: process.env.REDIS_KEY,
+        tls: { servername: process.env.REDIS_HOST }
+    });
+
+    const newClient = redis.createClient({
+        host: process.env.NEW_REDIS_HOST,
+        port: Number(process.env.NEW_REDIS_PORT),
+        password: process.env.NEW_REDIS_KEY
+    });
+
+    client.keys('chevre:itemAvailability:screeningEvent:*', async (err, keysreply) => {
+        console.log(err, keysreply.length, 'keys found');
+        const targetKeys = keysreply;
+
+        await Promise.all(targetKeys.map(async (targetKey) => {
+            const newKey = targetKey;
+
+            return new Promise<void>((resolve, reject) => {
+                client.hgetall(targetKey, (hgetallerr, reply) => {
+                    console.log('reply:', reply);
+                    if (hgetallerr !== null) {
+                        reject(hgetallerr);
+                    } else {
+                        if (reply !== null) {
+                            client.ttl(targetKey, (__, ttl) => {
+                                console.log('ttl:', ttl);
+                                const args = Object.keys(reply)
+                                    .reduce(
+                                        (a: any[], b) => {
+                                            return [...a, b, reply[b]];
+                                        },
+                                        []
+                                    );
+                                console.log(args.length, 'args ready');
+
+                                newClient.multi()
+                                    .hmset(newKey, ...args)
+                                    .expire(newKey, ttl)
+                                    .exec((hmsetErr, execreply) => {
+                                        console.log('hmset result:', hmsetErr, execreply);
+                                        resolve();
+                                    });
+                            });
+                        } else {
+                            reject(new Error('targetKey not found'));
+                        }
+                    }
+                });
+            });
+        }));
+    });
+
+    client.keys('chevre:reservationNumber:*', async (err, keysreply) => {
+        console.log(err, keysreply.length, 'keys found');
+        const targetKeys = keysreply;
+
+        await Promise.all(targetKeys.map(async (targetKey) => {
+            const newKey = targetKey;
+
+            return new Promise<void>((resolve, reject) => {
+                client.get(targetKey, (hgetallerr, reply) => {
+                    console.log('reply:', reply);
+                    if (hgetallerr !== null) {
+                        reject(hgetallerr);
+                    } else {
+                        if (reply !== null) {
+                            client.ttl(targetKey, (__, ttl) => {
+                                console.log('ttl:', ttl);
+                                const args = reply;
+
+                                newClient.multi()
+                                    .set(newKey, args)
+                                    .expire(newKey, ttl)
+                                    .exec((setErr, execreply) => {
+                                        console.log('set result:', setErr, execreply);
+                                        resolve();
+                                    });
+                            });
+                        } else {
+                            reject(new Error('targetKey not found'));
+                        }
+                    }
+                });
+            });
+        }));
+    });
+}
+
+main()
+    .then(console.log)
+    .catch(console.error);

package/example/src/chevre/createSeats.ts

@@ -0,0 +1,59 @@
+// tslint:disable:no-console
+import * as  fs from 'fs';
+
+const columns = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W'];
+const rows = [
+    { column: 'A', min: 4, max: 22 },
+    { column: 'B', min: 4, max: 22 },
+    { column: 'C', min: 3, max: 23 },
+    { column: 'D', min: 3, max: 23 },
+    { column: 'E', min: 3, max: 23 },
+    { column: 'F', min: 2, max: 24 },
+    { column: 'G', min: 2, max: 24 },
+    { column: 'H', min: 1, max: 24 },
+    { column: 'I', min: 1, max: 24 },
+    { column: 'J', min: 1, max: 24 },
+    { column: 'K', min: 1, max: 24 },
+    { column: 'L', min: 1, max: 24 },
+    { column: 'M', min: 1, max: 24 },
+    { column: 'N', min: 1, max: 24 },
+    { column: 'O', min: 1, max: 24 },
+    { column: 'P', min: 1, max: 24 },
+    { column: 'Q', min: 1, max: 24 },
+    { column: 'R', min: 1, max: 24 },
+    { column: 'S', min: 4, max: 21 },
+    { column: 'T', min: 4, max: 21 },
+    { column: 'U', min: 4, max: 21 },
+    { column: 'V', min: 1, max: 24 },
+    { column: 'W', min: 1, max: 24 }
+];
+
+const seats: {
+    branchCode: string;
+    typeOf: 'Seat';
+}[] = [];
+columns.forEach((column) => {
+    const row = rows.find((r) => r.column === column);
+
+    if (row !== undefined) {
+        const seatsByRow: {
+            branchCode: string;
+            typeOf: 'Seat';
+        }[] = [];
+        // tslint:disable-next-line:no-increment-decrement
+        for (let i = row.min; i <= row.max; i++) {
+            seatsByRow.push(
+                {
+                    branchCode: `${column}-${i}`,
+                    typeOf: 'Seat'
+                }
+            );
+        }
+
+        seats.push(...seatsByRow);
+    }
+});
+
+console.log(seats);
+// tslint:disable-next-line:non-literal-fs-path
+fs.writeFileSync(`${__dirname}/createSeatsResult.json`, JSON.stringify(seats, null, '    '));