@chevre/domain 23.2.0-alpha.9 → 24.0.0-alpha.0

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

@@ -1,41 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment';
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../../lib/index';
-
-// tslint:disable-next-line:max-func-body-length
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
-
-    const aggregateDate = new Date();
-    const runsFrom: Date = moment(aggregateDate)
-        .utc()
-        // .tz('Asia/Tokyo')
-        .add(-1, 'days')
-        .startOf('days')
-        .toDate();
-    const runsThrough: Date = moment(aggregateDate)
-        .utc()
-        // .tz('Asia/Tokyo')
-        .add(-1, 'days')
-        .endOf('days')
-        .toDate();
-
-    const result = await taskRepo.aggregateTask({
-        project: {
-            id: { $ne: 'sskts-development' }
-        },
-        runsFrom,
-        runsThrough
-    });
-    console.dir(result, { depth: null });
-}
-
-main()
-    .then(() => {
-        console.log('success!');
-    })
-    .catch(console.error);

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

@@ -1,71 +0,0 @@
-// 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 = await chevre.repository.Event.createInstance(mongoose.connection);
-    const taskRepo = await chevre.repository.Task.createInstance(mongoose.connection);
-
-    const events = <Pick<
-        chevre.factory.event.screeningEvent.IEvent,
-        'id' | 'typeOf' | 'startDate' | 'project'
-    >[]>await eventRepo.projectEventFields(
-        {
-            typeOf: chevre.factory.eventType.ScreeningEvent,
-            project: { id: { $eq: PROJECT.id } },
-            startFrom: moment()
-                .add(-1, 'days')
-                .toDate()
-            // startFrom: moment().add(-1, 'day').toDate(),
-            // startThrough: moment().add(1, 'day').toDate(),
-            // startThrough: now
-        },
-        ['typeOf', 'startDate', 'project']
-    );
-
-    // console.log(events);
-    console.log(events.length);
-    // return;
-
-    const tasks: chevre.factory.task.aggregateScreeningEvent.IAttributes[] = [];
-    for (const { id, typeOf, startDate, project } 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, id }
-        };
-        // const aggregateUseActionsTask: chevre.factory.task.aggregateUseActionsOnEvent.IAttributes = {
-        //     name: chevre.factory.taskName.AggregateUseActionsOnEvent,
-        //     project: { typeOf: chevre.factory.organizationType.Project, id: project.id },
-        //     status: chevre.factory.taskStatus.Ready,
-        //     runsAt: new Date(),
-        //     remainingNumberOfTries: 1,
-        //     numberOfTried: 0,
-        //     executionResults: [],
-        //     data: { typeOf, id }
-        // };
-        tasks.push(aggregateTask);
-        console.log('task created', project.id, id, startDate);
-    }
-
-    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/aggregation/searchAggregateReservations.ts

@@ -1,33 +0,0 @@
-// tslint:disable:no-console
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../../lib/index';
-
-const project = { id: <string>process.env.PROJECT_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 aggregateReservationRepo = await chevre.repository.AggregateReservation.createInstance(mongoose.connection);
-    const aggregateReservations = await aggregateReservationRepo.searchWithReservationForId(
-        {
-            limit: 100,
-            page: 1,
-            project: { id: { $eq: project.id } },
-            reservationFor: {
-                id: { $eq: EVENT_ID },
-                typeOf: chevre.factory.eventType.ScreeningEvent
-            }
-        },
-        ['aggregateOffer']
-    );
-    console.log('aggregateReservations:', aggregateReservations);
-}
-
-main()
-    .then(() => {
-        console.log('success!');
-    })
-    .catch(console.error);

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

@@ -1,67 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment';
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../../lib/index';
-
-// tslint:disable-next-line:max-func-body-length
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const assetTransactionRepo = await chevre.repository.AssetTransaction.createInstance(mongoose.connection);
-
-    const cursor = assetTransactionRepo.getCursor(
-        {
-            typeOf: { $eq: chevre.factory.assetTransactionType.Pay },
-            startDate: {
-                $gte: moment()
-                    // tslint:disable-next-line:no-magic-numbers
-                    .add(-3, 'days')
-                    .toDate()
-            },
-            'object.typeOf': {
-                $exists: true,
-                $in: [
-                    // chevre.factory.service.paymentService.PaymentServiceType.FaceToFace,
-                    // chevre.factory.service.paymentService.PaymentServiceType.MovieTicket,
-                    chevre.factory.service.paymentService.PaymentServiceType.CreditCard
-                ]
-            }
-        },
-        {
-        }
-    );
-    console.log('docs found');
-
-    let i = 0;
-    let ticketTokenCount = 0;
-    await cursor.eachAsync(async (doc) => {
-        i += 1;
-        const payTransaction = <chevre.factory.assetTransaction.pay.ITransaction>doc.toObject();
-
-        const ticketTokenByInstrument = payTransaction.instrument?.find((instrument) => instrument.typeOf === 'Ticket')?.ticketToken;
-        if (typeof ticketTokenByInstrument === 'string' && ticketTokenByInstrument !== '') {
-            console.log(
-                ticketTokenByInstrument,
-                ' ticket token exists.',
-                payTransaction.project.id, payTransaction.typeOf, payTransaction.object.typeOf,
-                payTransaction.startDate, payTransaction.transactionNumber, i
-            );
-            ticketTokenCount += 1;
-        } else {
-            console.log(
-                ticketTokenByInstrument,
-                ' ticket token does not exists.',
-                payTransaction.project.id, payTransaction.typeOf, payTransaction.object.typeOf,
-                payTransaction.startDate, payTransaction.transactionNumber, i
-            );
-        }
-    });
-
-    console.log(i, 'docs checked');
-    console.log(ticketTokenCount, 'ticketToken exist');
-}
-
-main()
-    .then()
-    .catch(console.error);

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

@@ -1,149 +0,0 @@
-// tslint:disable:no-console
-import * as moment from 'moment';
-import * as mongoose from 'mongoose';
-import * as redis from 'redis';
-
-import { chevre } from '../../../../lib/index';
-
-const project = { id: String(process.env.PROJECT_ID) };
-const { EVENT_ID, OFFER_ID, APPLICATION_ID, OFFER_TOKEN } = process.env;
-
-// tslint:disable-next-line:max-func-body-length
-async function main() {
-    if (typeof EVENT_ID !== 'string'
-        || typeof OFFER_ID !== 'string'
-        || typeof APPLICATION_ID !== 'string') {
-        throw new Error('environment variables required');
-    }
-
-    const redisClient = 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 redisClient.connect();
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const transactionNumberRepo = await chevre.repository.TransactionNumber.createInstance({
-        connection: mongoose.connection
-    });
-    const { transactionNumber } = await transactionNumberRepo.publishByTimestamp({ startDate: new Date() });
-    const provider: chevre.factory.reservation.IProvider = {
-        id: '59d20831e53ebc2b4e774466',
-        typeOf: chevre.factory.organizationType.Corporation
-    };
-
-    const { transaction } = await (await chevre.service.assetTransaction.createService()).reserve.start(
-        {
-            project: { id: project.id, typeOf: chevre.factory.organizationType.Project },
-            typeOf: chevre.factory.assetTransactionType.Reserve,
-            transactionNumber,
-            agent: { ...provider, name: 'sample agent name' },
-            object: {
-                acceptedOffer: [{
-                    /**
-                     * オファーID
-                     */
-                    id: OFFER_ID,
-                    /**
-                     * アイテム情報
-                     * 予約の詳細指定など
-                     */
-                    itemOffered: {
-                        serviceOutput: {
-                            typeOf: chevre.factory.reservationType.EventReservation,
-                            reservedTicket: {
-                                /**
-                                 * チケット識別子
-                                 * 指定された場合、決済カードの対象チケット識別子と関連付けされます
-                                 * /^[0-9a-zA-Z]{8,16}$/
-                                 */
-                                // identifier?: string;
-                                // issuedBy?: ReservationFactory.IUnderName;
-                                typeOf: 'Ticket',
-                                ticketedSeat: {
-                                    typeOf: chevre.factory.placeType.Seat,
-                                    seatNumber: 'A-01',
-                                    seatRow: '',
-                                    seatSection: 'Default'
-                                }
-                            }
-                        }
-                    }
-                }],
-                reservationFor: {
-                    id: EVENT_ID,
-                    offers: {
-                        // token: OFFER_TOKEN,
-                        // identifier: 'LegacyReservation'
-                    }
-                }
-            },
-            expires: moment()
-                // tslint:disable-next-line:no-magic-numbers
-                .add(5, 'seconds')
-                .toDate(),
-            validateEvent: false,
-            validateEventOfferPeriod: true,
-            validateAppliesToMovieTicket: true,
-            instrument: [
-                ...(typeof OFFER_TOKEN === 'string') ? [{ ticketToken: OFFER_TOKEN, typeOf: <'Ticket'>'Ticket' }] : []
-            ],
-            availableAtOrFrom: { id: APPLICATION_ID }
-            // stockHoldUntilDaysAfterEventEnd: STOCK_HOLD_UNTIL_DAYS_AFTER_EVENT_END
-        },
-        { maxReservationGracePeriodInDays: 93 }
-    )(
-        {
-            advanceBookingRequirement: await chevre.repository.AdvanceBookingRequirement.createInstance(mongoose.connection),
-            authorization: await chevre.repository.Authorization.createInstance(mongoose.connection),
-            project: await chevre.repository.Project.createInstance(mongoose.connection),
-            stockHolder: await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection }),
-            event: await chevre.repository.Event.createInstance(mongoose.connection),
-            eventOffer: await chevre.repository.EventOffer.createInstance(mongoose.connection),
-            eventSeries: await chevre.repository.EventSeries.createInstance(mongoose.connection),
-            issuer: await chevre.repository.Issuer.createInstance(mongoose.connection),
-            member: await chevre.repository.Member.createInstance(mongoose.connection),
-            memberProgram: await chevre.repository.MemberProgram.createInstance(mongoose.connection),
-            offer: await chevre.repository.Offer.createInstance(mongoose.connection),
-            offerCatalog: await chevre.repository.OfferCatalog.createInstance(mongoose.connection),
-            offerCatalogItem: await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection),
-            offerRateLimit: await chevre.repository.rateLimit.Offer.createInstance(redisClient),
-            paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
-            priceSpecification: await chevre.repository.PriceSpecification.createInstance(mongoose.connection),
-            product: await chevre.repository.Product.createInstance(mongoose.connection),
-            productOffer: await chevre.repository.ProductOffer.createInstance(mongoose.connection),
-            seat: await chevre.repository.place.Seat.createInstance(mongoose.connection),
-            setting: await chevre.repository.Setting.createInstance(mongoose.connection),
-            task: await chevre.repository.Task.createInstance(mongoose.connection),
-            ticket: await chevre.repository.Ticket.createInstance(mongoose.connection),
-            assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection)
-        },
-        new chevre.settings.Settings({
-            abortedTasksWithoutReport: [],
-            numTryConfirmReserveTransaction: 10,
-            deliverOrderLimit: 1,
-            coa: { timeout: 20000 },
-            gmo: {
-                timeout: 5000,
-                timeoutBackground: 5000,
-                useFetch: true
-            },
-            movieticketReserve: {
-                timeout: 5000,
-                timeoutCheck: 5000,
-                minIntervalBetweenPayAndRefund: 1,
-                credentialsExpireInSeconds: 300
-            },
-            // useAssetTransactionSyncProcessing: process.env.USE_ASSET_TRANSACTION_SYNC_PROCESSING === '1',
-            useExperimentalFeature: false
-        })
-    );
-    console.log('transaction:', transaction);
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

package/example/src/chevre/attendIfNotAttended.ts

@@ -1,31 +0,0 @@
-// tslint:disable:no-console
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../lib/index';
-
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI);
-
-    const reservationRepo = await chevre.repository.Reservation.createInstance(mongoose.connection);
-
-    const reservation = await reservationRepo.attendIfNotAttended(
-        {
-            id: '948926445022844-0',
-            now: new Date()
-        }
-    );
-    console.log('reservation found', reservation);
-
-    // await reservationRepo.cancel(
-    //     {
-    //         id: '948926445022844-0',
-    //         previousReservationStatus: chevre.factory.reservationStatusType.ReservationConfirmed,
-    //         modifiedTime: new Date()
-    //     }
-    // );
-    // console.log('reservation canceled');
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

package/example/src/chevre/authorizeEventServiceOffer.ts

@@ -1,122 +0,0 @@
-// tslint:disable:no-console
-import * as mongoose from 'mongoose';
-import * as redis from 'redis';
-
-import { chevre } from '../../../lib/index';
-
-const project = {
-    id: String(process.env.PROJECT_ID),
-    typeOf: <chevre.factory.organizationType.Project>chevre.factory.organizationType.Project
-};
-
-// tslint:disable-next-line:max-func-body-length
-async function main() {
-    const redisClient = 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 redisClient.connect();
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const action = await (await chevre.service.offer.createService()).event.authorize(
-        {
-            project: project,
-            object: {
-                acceptedOffer: [],
-                reservationFor: {
-                    id: 'bmcvkft63',
-                    offers: {
-                        // validForMemberTier: {
-                        //     token: 'xx',
-                        //     isTierOf: { identifier: 'DefaultMemberProgram' }
-                        // }
-                    }
-
-                }
-            },
-            agent: { id: 'xxx' },
-            transaction: { id: 'xxx' },
-            validateEventOfferPeriod: true,
-            validateEvent: false,
-            store: { id: 'xxx' },
-            instrument: []
-        },
-        {
-            noOfferSpecified: true,
-            maxReservationGracePeriodInDays: 93
-        }
-    )(
-        {
-            action: await chevre.repository.Action.createInstance(mongoose.connection),
-            advanceBookingRequirement: await chevre.repository.AdvanceBookingRequirement.createInstance(mongoose.connection),
-            assetTransaction: await chevre.repository.AssetTransaction.createInstance(mongoose.connection),
-            authorization: await chevre.repository.Authorization.createInstance(mongoose.connection),
-            event: await chevre.repository.Event.createInstance(mongoose.connection),
-            eventOffer: await chevre.repository.EventOffer.createInstance(mongoose.connection),
-            eventSeries: await chevre.repository.EventSeries.createInstance(mongoose.connection),
-            issuer: await chevre.repository.Issuer.createInstance(mongoose.connection),
-            member: await chevre.repository.Member.createInstance(mongoose.connection),
-            memberProgram: await chevre.repository.MemberProgram.createInstance(mongoose.connection),
-            stockHolder: await chevre.repository.StockHolder.createInstance({ connection: mongoose.connection }),
-            offer: await chevre.repository.Offer.createInstance(mongoose.connection),
-            offerCatalog: await chevre.repository.OfferCatalog.createInstance(mongoose.connection),
-            offerCatalogItem: await chevre.repository.OfferCatalogItem.createInstance(mongoose.connection),
-            offerRateLimit: await chevre.repository.rateLimit.Offer.createInstance(redisClient),
-            orderInTransaction: await chevre.repository.OrderInTransaction.createInstance(mongoose.connection),
-            orderNumber: await chevre.repository.OrderNumber.createInstance({ connection: mongoose.connection }),
-            paymentService: await chevre.repository.PaymentService.createInstance(mongoose.connection),
-            priceSpecification: await chevre.repository.PriceSpecification.createInstance(mongoose.connection),
-            product: await chevre.repository.Product.createInstance(mongoose.connection),
-            productOffer: await chevre.repository.ProductOffer.createInstance(mongoose.connection),
-            project: await chevre.repository.Project.createInstance(mongoose.connection),
-            seat: await chevre.repository.place.Seat.createInstance(mongoose.connection),
-            setting: await chevre.repository.Setting.createInstance(mongoose.connection),
-            task: await chevre.repository.Task.createInstance(mongoose.connection),
-            ticket: await chevre.repository.Ticket.createInstance(mongoose.connection),
-            transaction: await chevre.repository.Transaction.createInstance(mongoose.connection),
-            transactionNumber: await chevre.repository.TransactionNumber.createInstance({ connection: mongoose.connection })
-        },
-        new chevre.settings.Settings({
-            // notification: {
-            //     // tslint:disable-next-line:no-magic-numbers
-            //     timeout: (process.env.TRIGGER_WEBHOOK_TIMEOUT !== undefined) ? Number(process.env.TRIGGER_WEBHOOK_TIMEOUT) : 15000,
-            //     useFetchAPI: process.env.USE_FETCH_API === '1',
-            //     secretKey: (typeof process.env.TRIGGER_WEBHOOK_SECRET_KEY === 'string')
-            //         ? process.env.TRIGGER_WEBHOOK_SECRET_KEY
-            //         : '',
-            //     headerIdentifier: (typeof process.env.TRIGGER_WEBHOOK_HEADER_IDENTIFIER === 'string')
-            //         ? process.env.TRIGGER_WEBHOOK_HEADER_IDENTIFIER
-            //         : ''
-            // },
-            abortedTasksWithoutReport: (typeof process.env.ABORTED_TASKS_WITHOUT_REPORT === 'string')
-                ? process.env.ABORTED_TASKS_WITHOUT_REPORT.split(' ')
-                : [],
-            numTryConfirmReserveTransaction: (typeof process.env.NUM_TRY_CONFIRM_RESERVE_TRANSACTION === 'string')
-                ? Number(process.env.NUM_TRY_CONFIRM_RESERVE_TRANSACTION)
-                // tslint:disable-next-line:no-magic-numbers
-                : 10,
-            deliverOrderLimit: (typeof process.env.DELIVER_ORDER_LIMIT === 'string')
-                ? Number(process.env.DELIVER_ORDER_LIMIT)
-                : 1,
-            coa: {
-                // tslint:disable-next-line:no-magic-numbers
-                timeout: (typeof process.env.COA_TIMEOUT === 'string') ? Number(process.env.COA_TIMEOUT) : 20000
-            },
-            gmo: <any>{
-                useFetch: process.env.GMO_USE_FETCH === '1'
-            },
-            movieticketReserve: <any>{
-            },
-            // useAssetTransactionSyncProcessing: process.env.USE_ASSET_TRANSACTION_SYNC_PROCESSING === '1',
-            useExperimentalFeature: process.env.USE_EXPERIMENTAL_FEATURE === '1'
-        })
-    );
-    console.log('authorized.', action);
-}
-
-main()
-    .then(console.log)
-    .catch(console.error);

package/example/src/chevre/categoryCode/checkUniqueness.ts

@@ -1,69 +0,0 @@
-// tslint:disable:no-console no-magic-numbers
-import * as mongoose from 'mongoose';
-
-import { chevre } from '../../../../lib/index';
-
-// tslint:disable-next-line:max-func-body-length
-async function main() {
-    await mongoose.connect(<string>process.env.MONGOLAB_URI, { autoIndex: false });
-
-    const categoryCodeRepo = await chevre.repository.CategoryCode.createInstance(mongoose.connection);
-
-    const cursor = categoryCodeRepo.getCursor(
-        {
-            // _id: { $eq: '68f5d32176b5f6b689ff24a6' },
-            // 'project.id': { $eq: project.id },
-            // 'additionalProperty.name': { $exists: true, $eq: PROPERTY_NAME }
-            'inCodeSet.identifier': { $ne: chevre.factory.movieTicketType.CategorySetIdentifier.MovieTicketType }
-        },
-        {
-            _id: 1,
-            codeValue: 1,
-            project: 1,
-            inCodeSet: 1,
-            name: 1,
-            typeOf: 1
-        }
-    );
-    console.log('docs found');
-
-    let i = 0;
-    let notUniqueCount = 0;
-    await cursor.eachAsync(async (doc) => {
-        i += 1;
-        const categoryCode: Pick<
-            chevre.factory.categoryCode.ICategoryCode,
-            'codeValue' | 'id' | 'inCodeSet' | 'name' | 'project' | 'typeOf'
-        > = doc.toObject();
-
-        // console.log('unique?', categoryCode.project.id, categoryCode.id, categoryCode.codeValue, i);
-
-        const sameCodeValues = (await categoryCodeRepo.projectCategoryCodeFields(
-            {
-                project: { id: { $eq: categoryCode.project.id } },
-                codeValue: { $eq: categoryCode.codeValue }
-                // inCodeSet:{identifier:{$}}
-            },
-            ['codeValue', 'inCodeSet']
-        )).filter(
-            ({ inCodeSet }) => <unknown>inCodeSet.identifier !== chevre.factory.movieTicketType.CategorySetIdentifier.MovieTicketType
-        );
-        // console.log(sameCodeValues, 'sameCodeValues found', categoryCode.project.id, categoryCode.id, categoryCode.codeValue, i);
-
-        const isUnique = sameCodeValues.length === 1;
-        if (isUnique) {
-            // console.log(
-            //     'unique.', categoryCode.project.id, categoryCode.id, categoryCode.codeValue, i);
-        } else {
-            notUniqueCount += 1;
-            console.log('not unique.', categoryCode.project.id, categoryCode.id, categoryCode.codeValue, i);
-        }
-    });
-
-    console.log(i, 'docs checked');
-    console.log(notUniqueCount, 'docs not unique');
-}
-
-main()
-    .then()
-    .catch(console.error);

package/example/src/chevre/changeOrderStatus.ts

@@ -1,29 +0,0 @@
-// 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);