"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const uuid_1 = require("oak-domain/lib/utils/uuid");
const constants_1 = require("../config/constants");
const assert_1 = tslib_1.__importDefault(require("assert"));
const shipClazz_1 = require("../utils/shipClazz");
const ship_1 = require("../utils/ship");
const triggers = [
    {
        name: '当虚拟或自提类型的ship创建后自动发货',
        entity: 'ship',
        action: 'create',
        when: 'commit',
        strict: 'makeSure',
        asRoot: true,
        check: (operation) => ['virtual', 'pickup'].includes(operation.data.type),
        fn: async ({ ids }, context, option) => {
            for (const id of ids) {
                await context.operate('ship', {
                    id: await (0, uuid_1.generateNewIdAsync)(),
                    action: 'ship',
                    data: {},
                    filter: {
                        id,
                    }
                }, option);
            }
            return;
        },
    },
    {
        name: '当物流类的ship创建后自动下单',
        entity: 'ship',
        action: 'create',
        when: 'commit',
        strict: 'makeSure',
        asRoot: true,
        check: (operation) => ['express'].includes(operation.data.type),
        fn: async ({ ids }, context, option) => {
            (0, assert_1.default)(ids.length === 1);
            const id = ids[0];
            const [ship] = await context.select('ship', {
                data: {
                    id: 1,
                    entity: 1,
                    entityId: 1,
                    shipServiceId: 1,
                },
                filter: {
                    id
                }
            }, { dontCollect: true, forUpdate: true });
            const { entity, entityId } = ship;
            if (entity && entityId) {
                const shipClazz = await (0, shipClazz_1.getShipClazz)(entity, entityId, context);
                const extraShipId = await shipClazz.eOrder(id, context);
                return {
                    extraShipId,
                };
            }
        }
    },
    {
        // todo，deposit的ship和  shipClazz中有配置wechatShip且可获取openId的order的ship
        entity: 'ship',
        name: '当虚拟的ship变为shipping状态时，调用小程序发货信息录入接口',
        action: 'ship',
        when: 'before',
        asRoot: true,
        priority: 99,
        fn: async ({ operation }, context) => {
            const { data, filter } = operation;
            const [ship] = await context.select('ship', {
                data: {
                    id: 1,
                    type: 1,
                    deposit$ship: {
                        $entity: 'deposit',
                        data: {
                            id: 1,
                        },
                    },
                    entity: 1,
                    entityId: 1,
                    shipServiceId: 1,
                    shipOrder$ship: {
                        $entity: 'shipOrder',
                        data: {
                            id: 1,
                            orderId: 1,
                        }
                    },
                    wechatMpShip: {
                        id: 1,
                        applicationId: 1,
                    }
                },
                filter,
            }, {});
            const { id: shipId, type, deposit$ship: deposits, shipOrder$ship, shipServiceId, entity, entityId, wechatMpShip } = ship || {};
            if (deposits && deposits.length > 0) {
                //充值 （此时该充值必定为受发货限制的小程序上的充值）
                await (0, ship_1.uploadShippingInfo)(shipId, context);
                return 1;
            }
            if (shipOrder$ship && shipOrder$ship.length > 0) {
                //订单
                const clazz = await (0, shipClazz_1.getShipClazz)(entity, entityId, context);
                const { openId } = await clazz.getReceiverInfo(shipOrder$ship.map((ele) => ele.orderId), wechatMpShip?.applicationId, context);
                if (openId) {
                    //当存在openId时调用小程序发货信息录入
                    await (0, ship_1.uploadShippingInfo)(shipId, context);
                    return 1;
                }
            }
            return 0;
        }
    },
    {
        entity: 'ship',
        name: '当ship状态发生变化时，尝试向订阅者推送',
        action: ['ship', 'receive', 'giveUp', 'reject'],
        when: 'after',
        fn: async ({ operation }, context, option) => {
            const { filter, id } = operation;
            const { id: shipId } = filter;
            if (shipId) {
                context.saveOperationToEvent(id, `${constants_1.DATA_SUBSCRIBER_KEYS.shipStateChanged}-${shipId}`);
            }
            return 1;
        }
    },
    {
        name: '当物流创建时，赋上对应的物流系统对象',
        entity: 'ship',
        action: 'create',
        when: 'before',
        priority: 75,
        check: (operation) => operation.data.shipOrder$ship && operation.data.shipOrder$ship.length > 0,
        fn: async ({ operation }, context) => {
            const { data } = operation;
            let count = 0;
            if (data instanceof Array) {
                for (const d of data) {
                    const { shipServiceId, shipOrder$ship } = d;
                    if (shipServiceId) {
                        const result = await (0, shipClazz_1.getShipEntity)(shipServiceId, shipOrder$ship.map(ele => ele.data.orderId), context);
                        if (result) {
                            d.entity = result[0];
                            d.entityId = result[1];
                            count++;
                        }
                    }
                }
            }
            else {
                const { shipServiceId, shipOrder$ship } = data;
                if (shipServiceId) {
                    const result = await (0, shipClazz_1.getShipEntity)(shipServiceId, shipOrder$ship.map(ele => ele.data.orderId), context);
                    if (result) {
                        data.entity = result[0];
                        data.entityId = result[1];
                        count++;
                    }
                }
            }
            return count;
        }
    },
    {
        name: '当物流类的ship取消后，调用外部接口取消下单',
        entity: 'ship',
        action: 'cancel',
        when: 'commit',
        strict: 'makeSure',
        asRoot: true,
        filter: {
            type: 'express',
            entity: {
                $exists: true,
            },
            extraShipId: {
                $exists: true,
            },
        },
        fn: async ({ ids }, context, option) => {
            (0, assert_1.default)(ids.length === 1);
            const id = ids[0];
            const [ship] = await context.select('ship', {
                data: {
                    id: 1,
                    entity: 1,
                    entityId: 1,
                    shipServiceId: 1,
                    extraShipId: 1,
                },
                filter: {
                    id
                }
            }, { dontCollect: true, forUpdate: true });
            const { entity, entityId, extraShipId } = ship;
            if (entity && entityId && extraShipId) {
                const shipClazz = await (0, shipClazz_1.getShipClazz)(entity, entityId, context);
                await shipClazz.cancelOrder(extraShipId, context);
            }
        }
    },
    {
        name: '当ship签收后，调用小程序确认收货提醒',
        entity: 'ship',
        action: 'receive',
        when: 'commit',
        asRoot: true,
        filter: {
            receiveAt: {
                $exists: true,
            }
        },
        fn: async ({ ids }, context, option) => {
            (0, assert_1.default)(ids.length === 1);
            const id = ids[0];
            const [ship] = await context.select('ship', {
                data: {
                    id: 1,
                    entity: 1,
                    entityId: 1,
                    shipServiceId: 1,
                    extraShipId: 1,
                    receiveAt: 1,
                    shipOrder$ship: {
                        $entity: 'shipOrder',
                        data: {
                            id: 1,
                            orderId: 1,
                        }
                    },
                    wechatMpShip: {
                        id: 1,
                        applicationId: 1,
                    }
                },
                filter: {
                    id
                }
            }, { dontCollect: true, forUpdate: true });
            const { entity, entityId, extraShipId, shipOrder$ship, wechatMpShip } = ship;
            if (entity && entityId && extraShipId && shipOrder$ship) {
                const shipClazz = await (0, shipClazz_1.getShipClazz)(entity, entityId, context);
                const { openId } = await shipClazz.getReceiverInfo(shipOrder$ship.map((ele) => ele.orderId), wechatMpShip?.applicationId, context);
                if (openId) {
                    //当存在openId时调用小程序发货信息录入
                    await (0, ship_1.notifyConfirmReceive)(id, context);
                    return 1;
                }
            }
        }
    },
];
exports.default = triggers;