@vendure/dashboard 3.2.0 → 3.2.2

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/api/mv.resolver.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "MultivendorResolver", {
-    enumerable: true,
-    get: function() {
-        return MultivendorResolver;
-    }
-});
-const _graphql = require("@nestjs/graphql");
-const _core = require("@vendure/core");
-const _mvservice = require("../service/mv.service");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-function _ts_decorate(decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-function _ts_metadata(k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-function _ts_param(paramIndex, decorator) {
-    return function(target, key) {
-        decorator(target, key, paramIndex);
-    };
-}
-class MultivendorResolver {
-    registerNewSeller(ctx, args) {
-        return this.multivendorService.registerNewSeller(ctx, args.input);
-    }
-    constructor(multivendorService){
-        _define_property(this, "multivendorService", void 0);
-        this.multivendorService = multivendorService;
-    }
-}
-_ts_decorate([
-    (0, _graphql.Mutation)(),
-    (0, _core.Transaction)(),
-    (0, _core.Allow)(_core.Permission.Public),
-    _ts_param(0, (0, _core.Ctx)()),
-    _ts_param(1, (0, _graphql.Args)()),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _core.RequestContext === "undefined" ? Object : _core.RequestContext,
-        Object
-    ]),
-    _ts_metadata("design:returntype", void 0)
-], MultivendorResolver.prototype, "registerNewSeller", null);
-MultivendorResolver = _ts_decorate([
-    (0, _graphql.Resolver)(),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-        typeof _mvservice.MultivendorService === "undefined" ? Object : _mvservice.MultivendorService
-    ])
-], MultivendorResolver);

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/api/mv.resolver.js.map

@@ -1 +0,0 @@
-"{\"version\":3,\"sources\":[\"C:\\\\Development\\\\vendure\\\\vendure\\\\packages\\\\dev-server\\\\example-plugins\\\\multivendor-plugin\\\\api\\\\mv.resolver.ts\"],\"sourcesContent\":[\"import { Args, Mutation, Resolver } from '@nestjs/graphql';\\r\\nimport { Allow, Ctx, Permission, RequestContext, Transaction } from '@vendure/core';\\r\\n\\r\\nimport { MultivendorService } from '../service/mv.service';\\r\\nimport { CreateSellerInput } from '../types';\\r\\n\\r\\n@Resolver()\\r\\nexport class MultivendorResolver {\\r\\n    constructor(private multivendorService: MultivendorService) {}\\r\\n\\r\\n    @Mutation()\\r\\n    @Transaction()\\r\\n    @Allow(Permission.Public)\\r\\n    registerNewSeller(\\r\\n        @Ctx() ctx: RequestContext,\\r\\n        @Args() args: { input: { shopName: string; seller: CreateSellerInput } },\\r\\n    ) {\\r\\n        return this.multivendorService.registerNewSeller(ctx, args.input);\\r\\n    }\\r\\n}\\r\\n\"],\"names\":[\"MultivendorResolver\",\"registerNewSeller\",\"ctx\",\"args\",\"multivendorService\",\"input\",\"constructor\",\"Public\"],\"mappings\":\";;;;+BAOaA;;;eAAAA;;;yBAP4B;sBAC2B;2BAEjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAI5B,MAAMA;IAMTC,kBACI,AAAOC,GAAmB,EAC1B,AAAQC,IAAgE,EAC1E;QACE,OAAO,IAAI,CAACC,kBAAkB,CAACH,iBAAiB,CAACC,KAAKC,KAAKE,KAAK;IACpE;IAVAC,YAAY,AAAQF,kBAAsC,CAAE;;aAAxCA,qBAAAA;IAAyC;AAWjE;;;;sCAPsBG\"}"

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-order-process.js

@@ -1,110 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "multivendorOrderProcess", {
-    enumerable: true,
-    get: function() {
-        return multivendorOrderProcess;
-    }
-});
-const _generatedtypes = require("@vendure/common/lib/generated-types");
-const _core = require("@vendure/core");
-let connection;
-let orderService;
-let channelService;
-let requestContextService;
-const multivendorOrderProcess = {
-    init (injector) {
-        connection = injector.get(_core.TransactionalConnection);
-        orderService = injector.get(_core.OrderService);
-        channelService = injector.get(_core.ChannelService);
-        requestContextService = injector.get(_core.RequestContextService);
-    },
-    async onTransitionStart (fromState, toState, data) {
-        const { ctx, order } = data;
-        if (fromState === 'AddingItems' && toState === 'ArrangingPayment') {
-            for (const line of data.order.lines){
-                if (!line.shippingLineId) {
-                    return 'not all lines have shipping';
-                }
-            }
-        }
-        // Aggregate orders are allowed to transition to these states without validating
-        // fulfillments, since aggregate orders do not have fulfillments, but will get
-        // transitioned based on the status of the sellerOrders' fulfillments.
-        if (order.type !== _generatedtypes.OrderType.Aggregate) {
-            if (toState === 'PartiallyShipped') {
-                const orderWithFulfillments = await findOrderWithFulfillments(ctx, order.id);
-                if (!(0, _core.orderItemsArePartiallyShipped)(orderWithFulfillments)) {
-                    return `message.cannot-transition-unless-some-order-items-shipped`;
-                }
-            }
-            if (toState === 'Shipped') {
-                const orderWithFulfillments = await findOrderWithFulfillments(ctx, order.id);
-                if (!(0, _core.orderItemsAreShipped)(orderWithFulfillments)) {
-                    return `message.cannot-transition-unless-all-order-items-shipped`;
-                }
-            }
-            if (toState === 'PartiallyDelivered') {
-                const orderWithFulfillments = await findOrderWithFulfillments(ctx, order.id);
-                if (!(0, _core.orderItemsArePartiallyDelivered)(orderWithFulfillments)) {
-                    return `message.cannot-transition-unless-some-order-items-delivered`;
-                }
-            }
-            if (toState === 'Delivered') {
-                const orderWithFulfillments = await findOrderWithFulfillments(ctx, order.id);
-                if (!(0, _core.orderItemsAreDelivered)(orderWithFulfillments)) {
-                    return `message.cannot-transition-unless-all-order-items-delivered`;
-                }
-            }
-        }
-    },
-    async onTransitionEnd (fromState, toState, data) {
-        const { ctx, order } = data;
-        if (order.type === _generatedtypes.OrderType.Seller) {
-            const aggregateOrder = await orderService.getAggregateOrder(ctx, order);
-            if (aggregateOrder) {
-                // Create a new RequestContext on the default Channel, since the current
-                // RequestContext may be scoped to the Seller channel, and will not be able to
-                // update the AggregateOrder.
-                const defaultChannel = await channelService.getDefaultChannel();
-                const defaultChannelCtx = await requestContextService.create({
-                    apiType: 'admin',
-                    channelOrToken: defaultChannel,
-                    req: ctx.req,
-                    languageCode: ctx.languageCode,
-                    user: ctx.activeUserId ? new _core.User({
-                        id: ctx.activeUserId
-                    }) : undefined
-                });
-                // This part is responsible for automatically updating the state of the aggregate Order
-                // based on the fulfillment state of all the associated seller Orders.
-                const otherSellerOrders = (await orderService.getSellerOrders(ctx, aggregateOrder)).filter((so)=>!(0, _core.idsAreEqual)(so.id, order.id));
-                const sellerOrderStates = [
-                    ...otherSellerOrders.map((so)=>so.state),
-                    toState
-                ];
-                if (sellerOrderStates.every((state)=>state === 'Shipped')) {
-                    await orderService.transitionToState(defaultChannelCtx, aggregateOrder.id, 'Shipped');
-                } else if (sellerOrderStates.every((state)=>state === 'Delivered')) {
-                    await orderService.transitionToState(defaultChannelCtx, aggregateOrder.id, 'Delivered');
-                } else if (sellerOrderStates.some((state)=>state === 'Delivered')) {
-                    await orderService.transitionToState(defaultChannelCtx, aggregateOrder.id, 'PartiallyDelivered');
-                } else if (sellerOrderStates.some((state)=>state === 'Shipped')) {
-                    await orderService.transitionToState(defaultChannelCtx, aggregateOrder.id, 'PartiallyShipped');
-                }
-            }
-        }
-    }
-};
-async function findOrderWithFulfillments(ctx, id) {
-    return await connection.getEntityOrThrow(ctx, _core.Order, id, {
-        relations: [
-            'lines',
-            'fulfillments',
-            'fulfillments.lines',
-            'fulfillments.lines.fulfillment'
-        ]
-    });
-}

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-order-process.js.map

@@ -1 +0,0 @@
-"{\"version\":3,\"sources\":[\"C:\\\\Development\\\\vendure\\\\vendure\\\\packages\\\\dev-server\\\\example-plugins\\\\multivendor-plugin\\\\config\\\\mv-order-process.ts\"],\"sourcesContent\":[\"import { OrderType } from '@vendure/common/lib/generated-types';\\nimport { ID } from '@vendure/common/lib/shared-types';\\nimport {\\n    ChannelService,\\n    CustomOrderProcess,\\n    idsAreEqual,\\n    Order,\\n    orderItemsAreDelivered,\\n    orderItemsArePartiallyDelivered,\\n    orderItemsArePartiallyShipped,\\n    orderItemsAreShipped,\\n    OrderService,\\n    RequestContext,\\n    RequestContextService,\\n    TransactionalConnection,\\n    User,\\n} from '@vendure/core';\\n\\nlet connection: TransactionalConnection;\\nlet orderService: OrderService;\\nlet channelService: ChannelService;\\nlet requestContextService: RequestContextService;\\n\\nexport const multivendorOrderProcess: CustomOrderProcess<any> = {\\n    init(injector) {\\n        connection = injector.get(TransactionalConnection);\\n        orderService = injector.get(OrderService);\\n        channelService = injector.get(ChannelService);\\n        requestContextService = injector.get(RequestContextService);\\n    },\\n\\n    async onTransitionStart(fromState, toState, data) {\\n        const { ctx, order } = data;\\n        if (fromState === 'AddingItems' && toState === 'ArrangingPayment') {\\n            for (const line of data.order.lines) {\\n                if (!line.shippingLineId) {\\n                    return 'not all lines have shipping';\\n                }\\n            }\\n        }\\n\\n        // Aggregate orders are allowed to transition to these states without validating\\n        // fulfillments, since aggregate orders do not have fulfillments, but will get\\n        // transitioned based on the status of the sellerOrders' fulfillments.\\n        if (order.type !== OrderType.Aggregate) {\\n            if (toState === 'PartiallyShipped') {\\n                const orderWithFulfillments = await findOrderWithFulfillments(ctx, order.id);\\n                if (!orderItemsArePartiallyShipped(orderWithFulfillments)) {\\n                    return `message.cannot-transition-unless-some-order-items-shipped`;\\n                }\\n            }\\n            if (toState === 'Shipped') {\\n                const orderWithFulfillments = await findOrderWithFulfillments(ctx, order.id);\\n                if (!orderItemsAreShipped(orderWithFulfillments)) {\\n                    return `message.cannot-transition-unless-all-order-items-shipped`;\\n                }\\n            }\\n            if (toState === 'PartiallyDelivered') {\\n                const orderWithFulfillments = await findOrderWithFulfillments(ctx, order.id);\\n                if (!orderItemsArePartiallyDelivered(orderWithFulfillments)) {\\n                    return `message.cannot-transition-unless-some-order-items-delivered`;\\n                }\\n            }\\n            if (toState === 'Delivered') {\\n                const orderWithFulfillments = await findOrderWithFulfillments(ctx, order.id);\\n                if (!orderItemsAreDelivered(orderWithFulfillments)) {\\n                    return `message.cannot-transition-unless-all-order-items-delivered`;\\n                }\\n            }\\n        }\\n    },\\n    async onTransitionEnd(fromState, toState, data) {\\n        const { ctx, order } = data;\\n        if (order.type === OrderType.Seller) {\\n            const aggregateOrder = await orderService.getAggregateOrder(ctx, order);\\n            if (aggregateOrder) {\\n                // Create a new RequestContext on the default Channel, since the current\\n                // RequestContext may be scoped to the Seller channel, and will not be able to\\n                // update the AggregateOrder.\\n                const defaultChannel = await channelService.getDefaultChannel();\\n                const defaultChannelCtx = await requestContextService.create({\\n                    apiType: 'admin',\\n                    channelOrToken: defaultChannel,\\n                    req: ctx.req,\\n                    languageCode: ctx.languageCode,\\n                    user: ctx.activeUserId ? new User({ id: ctx.activeUserId }) : undefined,\\n                });\\n\\n                // This part is responsible for automatically updating the state of the aggregate Order\\n                // based on the fulfillment state of all the associated seller Orders.\\n                const otherSellerOrders = (await orderService.getSellerOrders(ctx, aggregateOrder)).filter(\\n                    so => !idsAreEqual(so.id, order.id),\\n                );\\n\\n                const sellerOrderStates = [...otherSellerOrders.map(so => so.state), toState];\\n                if (sellerOrderStates.every(state => state === 'Shipped')) {\\n                    await orderService.transitionToState(defaultChannelCtx, aggregateOrder.id, 'Shipped');\\n                } else if (sellerOrderStates.every(state => state === 'Delivered')) {\\n                    await orderService.transitionToState(defaultChannelCtx, aggregateOrder.id, 'Delivered');\\n                } else if (sellerOrderStates.some(state => state === 'Delivered')) {\\n                    await orderService.transitionToState(\\n                        defaultChannelCtx,\\n                        aggregateOrder.id,\\n                        'PartiallyDelivered',\\n                    );\\n                } else if (sellerOrderStates.some(state => state === 'Shipped')) {\\n                    await orderService.transitionToState(\\n                        defaultChannelCtx,\\n                        aggregateOrder.id,\\n                        'PartiallyShipped',\\n                    );\\n                }\\n            }\\n        }\\n    },\\n};\\n\\nasync function findOrderWithFulfillments(ctx: RequestContext, id: ID): Promise<Order> {\\n    return await connection.getEntityOrThrow(ctx, Order, id, {\\n        relations: ['lines', 'fulfillments', 'fulfillments.lines', 'fulfillments.lines.fulfillment'],\\n    });\\n}\\n\"],\"names\":[\"multivendorOrderProcess\",\"connection\",\"orderService\",\"channelService\",\"requestContextService\",\"init\",\"injector\",\"get\",\"TransactionalConnection\",\"OrderService\",\"ChannelService\",\"RequestContextService\",\"onTransitionStart\",\"fromState\",\"toState\",\"data\",\"ctx\",\"order\",\"line\",\"lines\",\"shippingLineId\",\"type\",\"OrderType\",\"Aggregate\",\"orderWithFulfillments\",\"findOrderWithFulfillments\",\"id\",\"orderItemsArePartiallyShipped\",\"orderItemsAreShipped\",\"orderItemsArePartiallyDelivered\",\"orderItemsAreDelivered\",\"onTransitionEnd\",\"Seller\",\"aggregateOrder\",\"getAggregateOrder\",\"defaultChannel\",\"getDefaultChannel\",\"defaultChannelCtx\",\"create\",\"apiType\",\"channelOrToken\",\"req\",\"languageCode\",\"user\",\"activeUserId\",\"User\",\"undefined\",\"otherSellerOrders\",\"getSellerOrders\",\"filter\",\"so\",\"idsAreEqual\",\"sellerOrderStates\",\"map\",\"state\",\"every\",\"transitionToState\",\"some\",\"getEntityOrThrow\",\"Order\",\"relations\"],\"mappings\":\"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\"}"

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-order-seller-strategy.js

@@ -1,134 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "MultivendorSellerStrategy", {
-    enumerable: true,
-    get: function() {
-        return MultivendorSellerStrategy;
-    }
-});
-const _core = require("@vendure/core");
-const _constants = require("../constants");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-class MultivendorSellerStrategy {
-    init(injector) {
-        this.entityHydrator = injector.get(_core.EntityHydrator);
-        this.channelService = injector.get(_core.ChannelService);
-        this.paymentService = injector.get(_core.PaymentService);
-        this.paymentMethodService = injector.get(_core.PaymentMethodService);
-        this.connection = injector.get(_core.TransactionalConnection);
-        this.orderService = injector.get(_core.OrderService);
-        this.options = injector.get(_constants.MULTIVENDOR_PLUGIN_OPTIONS);
-    }
-    async setOrderLineSellerChannel(ctx, orderLine) {
-        await this.entityHydrator.hydrate(ctx, orderLine.productVariant, {
-            relations: [
-                'channels'
-            ]
-        });
-        const defaultChannel = await this.channelService.getDefaultChannel();
-        // If a ProductVariant is assigned to exactly 2 Channels, then one is the default Channel
-        // and the other is the seller's Channel.
-        if (orderLine.productVariant.channels.length === 2) {
-            const sellerChannel = orderLine.productVariant.channels.find((c)=>!(0, _core.idsAreEqual)(c.id, defaultChannel.id));
-            if (sellerChannel) {
-                return sellerChannel;
-            }
-        }
-    }
-    async splitOrder(ctx, order) {
-        const partialOrders = new Map();
-        for (const line of order.lines){
-            const sellerChannelId = line.sellerChannelId;
-            if (sellerChannelId) {
-                let partialOrder = partialOrders.get(sellerChannelId);
-                if (!partialOrder) {
-                    partialOrder = {
-                        channelId: sellerChannelId,
-                        shippingLines: [],
-                        lines: [],
-                        state: 'ArrangingPayment'
-                    };
-                    partialOrders.set(sellerChannelId, partialOrder);
-                }
-                partialOrder.lines.push(line);
-            }
-        }
-        for (const partialOrder of partialOrders.values()){
-            const shippingLineIds = new Set(partialOrder.lines.map((l)=>l.shippingLineId));
-            partialOrder.shippingLines = order.shippingLines.filter((shippingLine)=>shippingLineIds.has(shippingLine.id));
-        }
-        return [
-            ...partialOrders.values()
-        ];
-    }
-    async afterSellerOrdersCreated(ctx, aggregateOrder, sellerOrders) {
-        const paymentMethod = await this.connection.rawConnection.getRepository(_core.PaymentMethod).findOne({
-            where: {
-                code: _constants.CONNECTED_PAYMENT_METHOD_CODE
-            }
-        });
-        if (!paymentMethod) {
-            return;
-        }
-        const defaultChannel = await this.channelService.getDefaultChannel();
-        for (const sellerOrder of sellerOrders){
-            const sellerChannel = sellerOrder.channels.find((c)=>!(0, _core.idsAreEqual)(c.id, defaultChannel.id));
-            if (!sellerChannel) {
-                throw new _core.InternalServerError(`Could not determine Seller Channel for Order ${sellerOrder.code}`);
-            }
-            sellerOrder.surcharges = [
-                await this.createPlatformFeeSurcharge(ctx, sellerOrder)
-            ];
-            await this.orderService.applyPriceAdjustments(ctx, sellerOrder);
-            await this.entityHydrator.hydrate(ctx, sellerChannel, {
-                relations: [
-                    'seller'
-                ]
-            });
-            const result = await this.orderService.addPaymentToOrder(ctx, sellerOrder.id, {
-                method: paymentMethod.code,
-                metadata: {
-                    transfer_group: aggregateOrder.code,
-                    connectedAccountId: sellerChannel.seller?.customFields.connectedAccountId
-                }
-            });
-            if ((0, _core.isGraphQlErrorResult)(result)) {
-                throw new _core.InternalServerError(result.message);
-            }
-        }
-    }
-    async createPlatformFeeSurcharge(ctx, sellerOrder) {
-        const platformFee = Math.round(sellerOrder.totalWithTax * -(this.options.platformFeePercent / 100));
-        return this.connection.getRepository(ctx, _core.Surcharge).save(new _core.Surcharge({
-            taxLines: [],
-            sku: this.options.platformFeeSKU,
-            description: 'Platform fee',
-            listPrice: platformFee,
-            listPriceIncludesTax: true,
-            order: sellerOrder
-        }));
-    }
-    constructor(){
-        _define_property(this, "entityHydrator", void 0);
-        _define_property(this, "channelService", void 0);
-        _define_property(this, "paymentService", void 0);
-        _define_property(this, "paymentMethodService", void 0);
-        _define_property(this, "connection", void 0);
-        _define_property(this, "orderService", void 0);
-        _define_property(this, "options", void 0);
-    }
-}

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-order-seller-strategy.js.map

@@ -1 +0,0 @@
-"{\"version\":3,\"sources\":[\"C:\\\\Development\\\\vendure\\\\vendure\\\\packages\\\\dev-server\\\\example-plugins\\\\multivendor-plugin\\\\config\\\\mv-order-seller-strategy.ts\"],\"sourcesContent\":[\"import {\\r\\n    ChannelService,\\r\\n    EntityHydrator,\\r\\n    ID,\\r\\n    idsAreEqual,\\r\\n    Injector,\\r\\n    InternalServerError,\\r\\n    isGraphQlErrorResult,\\r\\n    Order,\\r\\n    OrderLine,\\r\\n    OrderSellerStrategy,\\r\\n    OrderService,\\r\\n    PaymentMethod,\\r\\n    PaymentMethodService,\\r\\n    PaymentService,\\r\\n    RequestContext,\\r\\n    SplitOrderContents,\\r\\n    Surcharge,\\r\\n    TransactionalConnection,\\r\\n} from '@vendure/core';\\r\\n\\r\\nimport { CONNECTED_PAYMENT_METHOD_CODE, MULTIVENDOR_PLUGIN_OPTIONS } from '../constants';\\r\\nimport { MultivendorPluginOptions } from '../types';\\r\\n\\r\\ndeclare module '@vendure/core/dist/entity/custom-entity-fields' {\\r\\n    interface CustomSellerFields {\\r\\n        connectedAccountId: string;\\r\\n    }\\r\\n}\\r\\n\\r\\nexport class MultivendorSellerStrategy implements OrderSellerStrategy {\\r\\n    private entityHydrator: EntityHydrator;\\r\\n    private channelService: ChannelService;\\r\\n    private paymentService: PaymentService;\\r\\n    private paymentMethodService: PaymentMethodService;\\r\\n    private connection: TransactionalConnection;\\r\\n    private orderService: OrderService;\\r\\n    private options: MultivendorPluginOptions;\\r\\n\\r\\n    init(injector: Injector) {\\r\\n        this.entityHydrator = injector.get(EntityHydrator);\\r\\n        this.channelService = injector.get(ChannelService);\\r\\n        this.paymentService = injector.get(PaymentService);\\r\\n        this.paymentMethodService = injector.get(PaymentMethodService);\\r\\n        this.connection = injector.get(TransactionalConnection);\\r\\n        this.orderService = injector.get(OrderService);\\r\\n        this.options = injector.get(MULTIVENDOR_PLUGIN_OPTIONS);\\r\\n    }\\r\\n\\r\\n    async setOrderLineSellerChannel(ctx: RequestContext, orderLine: OrderLine) {\\r\\n        await this.entityHydrator.hydrate(ctx, orderLine.productVariant, { relations: ['channels'] });\\r\\n        const defaultChannel = await this.channelService.getDefaultChannel();\\r\\n\\r\\n        // If a ProductVariant is assigned to exactly 2 Channels, then one is the default Channel\\r\\n        // and the other is the seller's Channel.\\r\\n        if (orderLine.productVariant.channels.length === 2) {\\r\\n            const sellerChannel = orderLine.productVariant.channels.find(\\r\\n                c => !idsAreEqual(c.id, defaultChannel.id),\\r\\n            );\\r\\n            if (sellerChannel) {\\r\\n                return sellerChannel;\\r\\n            }\\r\\n        }\\r\\n    }\\r\\n\\r\\n    async splitOrder(ctx: RequestContext, order: Order): Promise<SplitOrderContents[]> {\\r\\n        const partialOrders = new Map<ID, SplitOrderContents>();\\r\\n        for (const line of order.lines) {\\r\\n            const sellerChannelId = line.sellerChannelId;\\r\\n            if (sellerChannelId) {\\r\\n                let partialOrder = partialOrders.get(sellerChannelId);\\r\\n                if (!partialOrder) {\\r\\n                    partialOrder = {\\r\\n                        channelId: sellerChannelId,\\r\\n                        shippingLines: [],\\r\\n                        lines: [],\\r\\n                        state: 'ArrangingPayment',\\r\\n                    };\\r\\n                    partialOrders.set(sellerChannelId, partialOrder);\\r\\n                }\\r\\n                partialOrder.lines.push(line);\\r\\n            }\\r\\n        }\\r\\n\\r\\n        for (const partialOrder of partialOrders.values()) {\\r\\n            const shippingLineIds = new Set(partialOrder.lines.map(l => l.shippingLineId));\\r\\n            partialOrder.shippingLines = order.shippingLines.filter(shippingLine =>\\r\\n                shippingLineIds.has(shippingLine.id),\\r\\n            );\\r\\n        }\\r\\n\\r\\n        return [...partialOrders.values()];\\r\\n    }\\r\\n\\r\\n    async afterSellerOrdersCreated(ctx: RequestContext, aggregateOrder: Order, sellerOrders: Order[]) {\\r\\n        const paymentMethod = await this.connection.rawConnection.getRepository(PaymentMethod).findOne({\\r\\n            where: {\\r\\n                code: CONNECTED_PAYMENT_METHOD_CODE,\\r\\n            },\\r\\n        });\\r\\n        if (!paymentMethod) {\\r\\n            return;\\r\\n        }\\r\\n        const defaultChannel = await this.channelService.getDefaultChannel();\\r\\n        for (const sellerOrder of sellerOrders) {\\r\\n            const sellerChannel = sellerOrder.channels.find(c => !idsAreEqual(c.id, defaultChannel.id));\\r\\n            if (!sellerChannel) {\\r\\n                throw new InternalServerError(\\r\\n                    `Could not determine Seller Channel for Order ${sellerOrder.code}`,\\r\\n                );\\r\\n            }\\r\\n            sellerOrder.surcharges = [await this.createPlatformFeeSurcharge(ctx, sellerOrder)];\\r\\n            await this.orderService.applyPriceAdjustments(ctx, sellerOrder);\\r\\n            await this.entityHydrator.hydrate(ctx, sellerChannel, { relations: ['seller'] });\\r\\n            const result = await this.orderService.addPaymentToOrder(ctx, sellerOrder.id, {\\r\\n                method: paymentMethod.code,\\r\\n                metadata: {\\r\\n                    transfer_group: aggregateOrder.code,\\r\\n                    connectedAccountId: sellerChannel.seller?.customFields.connectedAccountId,\\r\\n                },\\r\\n            });\\r\\n            if (isGraphQlErrorResult(result)) {\\r\\n                throw new InternalServerError(result.message);\\r\\n            }\\r\\n        }\\r\\n    }\\r\\n\\r\\n    private async createPlatformFeeSurcharge(ctx: RequestContext, sellerOrder: Order) {\\r\\n        const platformFee = Math.round(sellerOrder.totalWithTax * -(this.options.platformFeePercent / 100));\\r\\n        return this.connection.getRepository(ctx, Surcharge).save(\\r\\n            new Surcharge({\\r\\n                taxLines: [],\\r\\n                sku: this.options.platformFeeSKU,\\r\\n                description: 'Platform fee',\\r\\n                listPrice: platformFee,\\r\\n                listPriceIncludesTax: true,\\r\\n                order: sellerOrder,\\r\\n            }),\\r\\n        );\\r\\n    }\\r\\n}\\r\\n\"],\"names\":[\"MultivendorSellerStrategy\",\"init\",\"injector\",\"entityHydrator\",\"get\",\"EntityHydrator\",\"channelService\",\"ChannelService\",\"paymentService\",\"PaymentService\",\"paymentMethodService\",\"PaymentMethodService\",\"connection\",\"TransactionalConnection\",\"orderService\",\"OrderService\",\"options\",\"MULTIVENDOR_PLUGIN_OPTIONS\",\"setOrderLineSellerChannel\",\"ctx\",\"orderLine\",\"hydrate\",\"productVariant\",\"relations\",\"defaultChannel\",\"getDefaultChannel\",\"channels\",\"length\",\"sellerChannel\",\"find\",\"c\",\"idsAreEqual\",\"id\",\"splitOrder\",\"order\",\"partialOrders\",\"Map\",\"line\",\"lines\",\"sellerChannelId\",\"partialOrder\",\"channelId\",\"shippingLines\",\"state\",\"set\",\"push\",\"values\",\"shippingLineIds\",\"Set\",\"map\",\"l\",\"shippingLineId\",\"filter\",\"shippingLine\",\"has\",\"afterSellerOrdersCreated\",\"aggregateOrder\",\"sellerOrders\",\"paymentMethod\",\"rawConnection\",\"getRepository\",\"PaymentMethod\",\"findOne\",\"where\",\"code\",\"CONNECTED_PAYMENT_METHOD_CODE\",\"sellerOrder\",\"InternalServerError\",\"surcharges\",\"createPlatformFeeSurcharge\",\"applyPriceAdjustments\",\"result\",\"addPaymentToOrder\",\"method\",\"metadata\",\"transfer_group\",\"connectedAccountId\",\"seller\",\"customFields\",\"isGraphQlErrorResult\",\"message\",\"platformFee\",\"Math\",\"round\",\"totalWithTax\",\"platformFeePercent\",\"Surcharge\",\"save\",\"taxLines\",\"sku\",\"platformFeeSKU\",\"description\",\"listPrice\",\"listPriceIncludesTax\"],\"mappings\":\"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\"}"

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-payment-handler.js

@@ -1,86 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "multivendorPaymentMethodHandler", {
-    enumerable: true,
-    get: function() {
-        return multivendorPaymentMethodHandler;
-    }
-});
-const _generatedtypes = require("@vendure/common/lib/generated-types");
-const _core = require("@vendure/core");
-const _mvconnectsdk = require("../payment/mv-connect-sdk");
-const sdk = new _mvconnectsdk.MyConnectSdk({
-    apiKey: 'MY_API_KEY'
-});
-const multivendorPaymentMethodHandler = new _core.PaymentMethodHandler({
-    code: 'mv-connect-payment-method',
-    description: [
-        {
-            languageCode: _core.LanguageCode.en,
-            value: 'Multivendor Payment Provider'
-        }
-    ],
-    args: {},
-    createPayment: async (ctx, order, amount, args, metadata)=>{
-        if (order.type === _generatedtypes.OrderType.Seller) {
-            try {
-                // Create a Transfer payment to the Seller's account
-                const result = await sdk.createTransfer({
-                    amount,
-                    currency: order.currencyCode,
-                    connectedAccountId: metadata.connectedAccountId,
-                    transfer_group: metadata.transfer_group
-                });
-                return {
-                    amount,
-                    state: 'Settled',
-                    transactionId: result.transactionId,
-                    metadata
-                };
-            } catch (err) {
-                return {
-                    amount,
-                    state: 'Declined',
-                    metadata: {
-                        errorMessage: err.message
-                    }
-                };
-            }
-        } else {
-            try {
-                // Create a payment to the platform's account,
-                // and set the `transfer_group` option to later link
-                // with the Seller transfers after the Seller orders
-                // have been created.
-                const result = await sdk.createPayment({
-                    amount,
-                    currency: order.currencyCode,
-                    transfer_group: order.code
-                });
-                return {
-                    amount,
-                    state: 'Settled',
-                    transactionId: result.transactionId,
-                    metadata: {
-                        transfer_group: order.code
-                    }
-                };
-            } catch (err) {
-                return {
-                    amount,
-                    state: 'Declined',
-                    metadata: {
-                        errorMessage: err.message
-                    }
-                };
-            }
-        }
-    },
-    settlePayment: async (ctx, order, payment, args)=>{
-        return {
-            success: true
-        };
-    }
-});

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-payment-handler.js.map

@@ -1 +0,0 @@
-"{\"version\":3,\"sources\":[\"C:\\\\Development\\\\vendure\\\\vendure\\\\packages\\\\dev-server\\\\example-plugins\\\\multivendor-plugin\\\\config\\\\mv-payment-handler.ts\"],\"sourcesContent\":[\"import { OrderType } from '@vendure/common/lib/generated-types';\\r\\nimport {\\r\\n    CreatePaymentResult,\\r\\n    LanguageCode,\\r\\n    PaymentMethodHandler,\\r\\n    SettlePaymentErrorResult,\\r\\n    SettlePaymentResult,\\r\\n} from '@vendure/core';\\r\\n\\r\\nimport { MyConnectSdk } from '../payment/mv-connect-sdk';\\r\\n\\r\\nconst sdk = new MyConnectSdk({ apiKey: 'MY_API_KEY' });\\r\\n\\r\\nexport const multivendorPaymentMethodHandler = new PaymentMethodHandler({\\r\\n    code: 'mv-connect-payment-method',\\r\\n    description: [\\r\\n        {\\r\\n            languageCode: LanguageCode.en,\\r\\n            value: 'Multivendor Payment Provider',\\r\\n        },\\r\\n    ],\\r\\n    args: {},\\r\\n    createPayment: async (ctx, order, amount, args, metadata) => {\\r\\n        if (order.type === OrderType.Seller) {\\r\\n            try {\\r\\n                // Create a Transfer payment to the Seller's account\\r\\n                const result = await sdk.createTransfer({\\r\\n                    amount,\\r\\n                    currency: order.currencyCode,\\r\\n                    connectedAccountId: metadata.connectedAccountId,\\r\\n                    transfer_group: metadata.transfer_group,\\r\\n                });\\r\\n                return {\\r\\n                    amount,\\r\\n                    state: 'Settled' as const,\\r\\n                    transactionId: result.transactionId,\\r\\n                    metadata,\\r\\n                };\\r\\n            } catch (err: any) {\\r\\n                return {\\r\\n                    amount,\\r\\n                    state: 'Declined' as const,\\r\\n                    metadata: {\\r\\n                        errorMessage: err.message,\\r\\n                    },\\r\\n                };\\r\\n            }\\r\\n        } else {\\r\\n            try {\\r\\n                // Create a payment to the platform's account,\\r\\n                // and set the `transfer_group` option to later link\\r\\n                // with the Seller transfers after the Seller orders\\r\\n                // have been created.\\r\\n                const result = await sdk.createPayment({\\r\\n                    amount,\\r\\n                    currency: order.currencyCode,\\r\\n                    transfer_group: order.code,\\r\\n                });\\r\\n                return {\\r\\n                    amount,\\r\\n                    state: 'Settled' as const,\\r\\n                    transactionId: result.transactionId,\\r\\n                    metadata: {\\r\\n                        transfer_group: order.code,\\r\\n                    },\\r\\n                };\\r\\n            } catch (err: any) {\\r\\n                return {\\r\\n                    amount,\\r\\n                    state: 'Declined' as const,\\r\\n                    metadata: {\\r\\n                        errorMessage: err.message,\\r\\n                    },\\r\\n                };\\r\\n            }\\r\\n        }\\r\\n    },\\r\\n    settlePayment: async (ctx, order, payment, args) => {\\r\\n        return { success: true };\\r\\n    },\\r\\n});\\r\\n\"],\"names\":[\"multivendorPaymentMethodHandler\",\"sdk\",\"MyConnectSdk\",\"apiKey\",\"PaymentMethodHandler\",\"code\",\"description\",\"languageCode\",\"LanguageCode\",\"en\",\"value\",\"args\",\"createPayment\",\"ctx\",\"order\",\"amount\",\"metadata\",\"type\",\"OrderType\",\"Seller\",\"result\",\"createTransfer\",\"currency\",\"currencyCode\",\"connectedAccountId\",\"transfer_group\",\"state\",\"transactionId\",\"err\",\"errorMessage\",\"message\",\"settlePayment\",\"payment\",\"success\"],\"mappings\":\";;;;+BAaaA;;;eAAAA;;;gCAba;sBAOnB;8BAEsB;AAE7B,MAAMC,MAAM,IAAIC,0BAAY,CAAC;IAAEC,QAAQ;AAAa;AAE7C,MAAMH,kCAAkC,IAAII,0BAAoB,CAAC;IACpEC,MAAM;IACNC,aAAa;QACT;YACIC,cAAcC,kBAAY,CAACC,EAAE;YAC7BC,OAAO;QACX;KACH;IACDC,MAAM,CAAC;IACPC,eAAe,OAAOC,KAAKC,OAAOC,QAAQJ,MAAMK;QAC5C,IAAIF,MAAMG,IAAI,KAAKC,yBAAS,CAACC,MAAM,EAAE;YACjC,IAAI;gBACA,oDAAoD;gBACpD,MAAMC,SAAS,MAAMnB,IAAIoB,cAAc,CAAC;oBACpCN;oBACAO,UAAUR,MAAMS,YAAY;oBAC5BC,oBAAoBR,SAASQ,kBAAkB;oBAC/CC,gBAAgBT,SAASS,cAAc;gBAC3C;gBACA,OAAO;oBACHV;oBACAW,OAAO;oBACPC,eAAeP,OAAOO,aAAa;oBACnCX;gBACJ;YACJ,EAAE,OAAOY,KAAU;gBACf,OAAO;oBACHb;oBACAW,OAAO;oBACPV,UAAU;wBACNa,cAAcD,IAAIE,OAAO;oBAC7B;gBACJ;YACJ;QACJ,OAAO;YACH,IAAI;gBACA,8CAA8C;gBAC9C,oDAAoD;gBACpD,oDAAoD;gBACpD,qBAAqB;gBACrB,MAAMV,SAAS,MAAMnB,IAAIW,aAAa,CAAC;oBACnCG;oBACAO,UAAUR,MAAMS,YAAY;oBAC5BE,gBAAgBX,MAAMT,IAAI;gBAC9B;gBACA,OAAO;oBACHU;oBACAW,OAAO;oBACPC,eAAeP,OAAOO,aAAa;oBACnCX,UAAU;wBACNS,gBAAgBX,MAAMT,IAAI;oBAC9B;gBACJ;YACJ,EAAE,OAAOuB,KAAU;gBACf,OAAO;oBACHb;oBACAW,OAAO;oBACPV,UAAU;wBACNa,cAAcD,IAAIE,OAAO;oBAC7B;gBACJ;YACJ;QACJ;IACJ;IACAC,eAAe,OAAOlB,KAAKC,OAAOkB,SAASrB;QACvC,OAAO;YAAEsB,SAAS;QAAK;IAC3B;AACJ\"}"

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-shipping-eligibility-checker.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "multivendorShippingEligibilityChecker", {
-    enumerable: true,
-    get: function() {
-        return multivendorShippingEligibilityChecker;
-    }
-});
-const _generatedtypes = require("@vendure/common/lib/generated-types");
-const _sharedconstants = require("@vendure/common/lib/shared-constants");
-const _core = require("@vendure/core");
-let entityHydrator;
-const multivendorShippingEligibilityChecker = new _core.ShippingEligibilityChecker({
-    code: 'multivendor-shipping-eligibility-checker',
-    description: [
-        {
-            languageCode: _generatedtypes.LanguageCode.en,
-            value: 'Multivendor Shipping Eligibility Checker'
-        }
-    ],
-    args: {},
-    init (injector) {
-        entityHydrator = injector.get(_core.EntityHydrator);
-    },
-    check: async (ctx, order, args, method)=>{
-        await entityHydrator.hydrate(ctx, method, {
-            relations: [
-                'channels'
-            ]
-        });
-        await entityHydrator.hydrate(ctx, order, {
-            relations: [
-                'lines.sellerChannel'
-            ]
-        });
-        const sellerChannel = method.channels.find((c)=>c.code !== _sharedconstants.DEFAULT_CHANNEL_CODE);
-        if (!sellerChannel) {
-            return false;
-        }
-        for (const line of order.lines){
-            if (line.sellerChannelId && (0, _core.idsAreEqual)(line.sellerChannelId, sellerChannel.id)) {
-                return true;
-            }
-        }
-        return false;
-    }
-});

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-shipping-eligibility-checker.js.map

@@ -1 +0,0 @@
-"{\"version\":3,\"sources\":[\"C:\\\\Development\\\\vendure\\\\vendure\\\\packages\\\\dev-server\\\\example-plugins\\\\multivendor-plugin\\\\config\\\\mv-shipping-eligibility-checker.ts\"],\"sourcesContent\":[\"import { LanguageCode } from '@vendure/common/lib/generated-types';\\nimport { DEFAULT_CHANNEL_CODE } from '@vendure/common/lib/shared-constants';\\nimport { EntityHydrator, idsAreEqual, ShippingEligibilityChecker } from '@vendure/core';\\n\\nlet entityHydrator: EntityHydrator;\\n\\n/**\\n * @description\\n * Shipping method is eligible if at least one OrderLine is associated with the Seller's Channel.\\n */\\nexport const multivendorShippingEligibilityChecker = new ShippingEligibilityChecker({\\n    code: 'multivendor-shipping-eligibility-checker',\\n    description: [{ languageCode: LanguageCode.en, value: 'Multivendor Shipping Eligibility Checker' }],\\n    args: {},\\n    init(injector) {\\n        entityHydrator = injector.get(EntityHydrator);\\n    },\\n    check: async (ctx, order, args, method) => {\\n        await entityHydrator.hydrate(ctx, method, { relations: ['channels'] });\\n        await entityHydrator.hydrate(ctx, order, { relations: ['lines.sellerChannel'] });\\n        const sellerChannel = method.channels.find(c => c.code !== DEFAULT_CHANNEL_CODE);\\n        if (!sellerChannel) {\\n            return false;\\n        }\\n        for (const line of order.lines) {\\n            if (line.sellerChannelId && idsAreEqual(line.sellerChannelId, sellerChannel.id)) {\\n                return true;\\n            }\\n        }\\n        return false;\\n    },\\n});\\n\"],\"names\":[\"multivendorShippingEligibilityChecker\",\"entityHydrator\",\"ShippingEligibilityChecker\",\"code\",\"description\",\"languageCode\",\"LanguageCode\",\"en\",\"value\",\"args\",\"init\",\"injector\",\"get\",\"EntityHydrator\",\"check\",\"ctx\",\"order\",\"method\",\"hydrate\",\"relations\",\"sellerChannel\",\"channels\",\"find\",\"c\",\"DEFAULT_CHANNEL_CODE\",\"line\",\"lines\",\"sellerChannelId\",\"idsAreEqual\",\"id\"],\"mappings\":\";;;;+BAUaA;;;eAAAA;;;gCAVgB;iCACQ;sBACmC;AAExE,IAAIC;AAMG,MAAMD,wCAAwC,IAAIE,gCAA0B,CAAC;IAChFC,MAAM;IACNC,aAAa;QAAC;YAAEC,cAAcC,4BAAY,CAACC,EAAE;YAAEC,OAAO;QAA2C;KAAE;IACnGC,MAAM,CAAC;IACPC,MAAKC,QAAQ;QACTV,iBAAiBU,SAASC,GAAG,CAACC,oBAAc;IAChD;IACAC,OAAO,OAAOC,KAAKC,OAAOP,MAAMQ;QAC5B,MAAMhB,eAAeiB,OAAO,CAACH,KAAKE,QAAQ;YAAEE,WAAW;gBAAC;aAAW;QAAC;QACpE,MAAMlB,eAAeiB,OAAO,CAACH,KAAKC,OAAO;YAAEG,WAAW;gBAAC;aAAsB;QAAC;QAC9E,MAAMC,gBAAgBH,OAAOI,QAAQ,CAACC,IAAI,CAACC,CAAAA,IAAKA,EAAEpB,IAAI,KAAKqB,qCAAoB;QAC/E,IAAI,CAACJ,eAAe;YAChB,OAAO;QACX;QACA,KAAK,MAAMK,QAAQT,MAAMU,KAAK,CAAE;YAC5B,IAAID,KAAKE,eAAe,IAAIC,IAAAA,iBAAW,EAACH,KAAKE,eAAe,EAAEP,cAAcS,EAAE,GAAG;gBAC7E,OAAO;YACX;QACJ;QACA,OAAO;IACX;AACJ\"}"

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-shipping-line-assignment-strategy.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "MultivendorShippingLineAssignmentStrategy", {
-    enumerable: true,
-    get: function() {
-        return MultivendorShippingLineAssignmentStrategy;
-    }
-});
-const _core = require("@vendure/core");
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-class MultivendorShippingLineAssignmentStrategy {
-    init(injector) {
-        this.entityHydrator = injector.get(_core.EntityHydrator);
-        this.channelService = injector.get(_core.ChannelService);
-    }
-    async assignShippingLineToOrderLines(ctx, shippingLine, order) {
-        // First we need to ensure the required relations are available
-        // to work with.
-        const defaultChannel = await this.channelService.getDefaultChannel();
-        await this.entityHydrator.hydrate(ctx, shippingLine, {
-            relations: [
-                'shippingMethod.channels'
-            ]
-        });
-        const { channels } = shippingLine.shippingMethod;
-        // We assume that, if a ShippingMethod is assigned to exactly 2 Channels,
-        // then one is the default Channel and the other is the seller's Channel.
-        if (channels.length === 2) {
-            const sellerChannel = channels.find((c)=>!(0, _core.idsAreEqual)(c.id, defaultChannel.id));
-            if (sellerChannel) {
-                // Once we have established the seller's Channel, we can filter the OrderLines
-                // that belong to that Channel. The `sellerChannelId` was previously established
-                // in the `OrderSellerStrategy.setOrderLineSellerChannel()` method.
-                return order.lines.filter((line)=>(0, _core.idsAreEqual)(line.sellerChannelId, sellerChannel.id));
-            }
-        }
-        return order.lines;
-    }
-    constructor(){
-        _define_property(this, "entityHydrator", void 0);
-        _define_property(this, "channelService", void 0);
-    }
-}

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/config/mv-shipping-line-assignment-strategy.js.map

@@ -1 +0,0 @@
-"{\"version\":3,\"sources\":[\"C:\\\\Development\\\\vendure\\\\vendure\\\\packages\\\\dev-server\\\\example-plugins\\\\multivendor-plugin\\\\config\\\\mv-shipping-line-assignment-strategy.ts\"],\"sourcesContent\":[\"import {\\r\\n    ChannelService,\\r\\n    EntityHydrator,\\r\\n    idsAreEqual,\\r\\n    Injector,\\r\\n    Order,\\r\\n    OrderSellerStrategy,\\r\\n    RequestContext,\\r\\n    ShippingLine,\\r\\n    ShippingLineAssignmentStrategy,\\r\\n} from '@vendure/core';\\r\\n\\r\\nexport class MultivendorShippingLineAssignmentStrategy implements ShippingLineAssignmentStrategy {\\r\\n    private entityHydrator: EntityHydrator;\\r\\n    private channelService: ChannelService;\\r\\n\\r\\n    init(injector: Injector) {\\r\\n        this.entityHydrator = injector.get(EntityHydrator);\\r\\n        this.channelService = injector.get(ChannelService);\\r\\n    }\\r\\n\\r\\n    async assignShippingLineToOrderLines(ctx: RequestContext, shippingLine: ShippingLine, order: Order) {\\r\\n        // First we need to ensure the required relations are available\\r\\n        // to work with.\\r\\n        const defaultChannel = await this.channelService.getDefaultChannel();\\r\\n        await this.entityHydrator.hydrate(ctx, shippingLine, { relations: ['shippingMethod.channels'] });\\r\\n        const { channels } = shippingLine.shippingMethod;\\r\\n\\r\\n        // We assume that, if a ShippingMethod is assigned to exactly 2 Channels,\\r\\n        // then one is the default Channel and the other is the seller's Channel.\\r\\n        if (channels.length === 2) {\\r\\n            const sellerChannel = channels.find(c => !idsAreEqual(c.id, defaultChannel.id));\\r\\n            if (sellerChannel) {\\r\\n                // Once we have established the seller's Channel, we can filter the OrderLines\\r\\n                // that belong to that Channel. The `sellerChannelId` was previously established\\r\\n                // in the `OrderSellerStrategy.setOrderLineSellerChannel()` method.\\r\\n                return order.lines.filter(line => idsAreEqual(line.sellerChannelId, sellerChannel.id));\\r\\n            }\\r\\n        }\\r\\n        return order.lines;\\r\\n    }\\r\\n}\\r\\n\"],\"names\":[\"MultivendorShippingLineAssignmentStrategy\",\"init\",\"injector\",\"entityHydrator\",\"get\",\"EntityHydrator\",\"channelService\",\"ChannelService\",\"assignShippingLineToOrderLines\",\"ctx\",\"shippingLine\",\"order\",\"defaultChannel\",\"getDefaultChannel\",\"hydrate\",\"relations\",\"channels\",\"shippingMethod\",\"length\",\"sellerChannel\",\"find\",\"c\",\"idsAreEqual\",\"id\",\"lines\",\"filter\",\"line\",\"sellerChannelId\"],\"mappings\":\";;;;+BAYaA;;;eAAAA;;;sBAFN;;;;;;;;;;;;;;AAEA,MAAMA;IAITC,KAAKC,QAAkB,EAAE;QACrB,IAAI,CAACC,cAAc,GAAGD,SAASE,GAAG,CAACC,oBAAc;QACjD,IAAI,CAACC,cAAc,GAAGJ,SAASE,GAAG,CAACG,oBAAc;IACrD;IAEA,MAAMC,+BAA+BC,GAAmB,EAAEC,YAA0B,EAAEC,KAAY,EAAE;QAChG,+DAA+D;QAC/D,gBAAgB;QAChB,MAAMC,iBAAiB,MAAM,IAAI,CAACN,cAAc,CAACO,iBAAiB;QAClE,MAAM,IAAI,CAACV,cAAc,CAACW,OAAO,CAACL,KAAKC,cAAc;YAAEK,WAAW;gBAAC;aAA0B;QAAC;QAC9F,MAAM,EAAEC,QAAQ,EAAE,GAAGN,aAAaO,cAAc;QAEhD,yEAAyE;QACzE,yEAAyE;QACzE,IAAID,SAASE,MAAM,KAAK,GAAG;YACvB,MAAMC,gBAAgBH,SAASI,IAAI,CAACC,CAAAA,IAAK,CAACC,IAAAA,iBAAW,EAACD,EAAEE,EAAE,EAAEX,eAAeW,EAAE;YAC7E,IAAIJ,eAAe;gBACf,8EAA8E;gBAC9E,gFAAgF;gBAChF,mEAAmE;gBACnE,OAAOR,MAAMa,KAAK,CAACC,MAAM,CAACC,CAAAA,OAAQJ,IAAAA,iBAAW,EAACI,KAAKC,eAAe,EAAER,cAAcI,EAAE;YACxF;QACJ;QACA,OAAOZ,MAAMa,KAAK;IACtB;;QA3BA,uBAAQrB,kBAAR,KAAA;QACA,uBAAQG,kBAAR,KAAA;;AA2BJ\"}"

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/constants.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-function _export(target, all) {
-    for(var name in all)Object.defineProperty(target, name, {
-        enumerable: true,
-        get: all[name]
-    });
-}
-_export(exports, {
-    CONNECTED_PAYMENT_METHOD_CODE: function() {
-        return CONNECTED_PAYMENT_METHOD_CODE;
-    },
-    MULTIVENDOR_PLUGIN_OPTIONS: function() {
-        return MULTIVENDOR_PLUGIN_OPTIONS;
-    }
-});
-const CONNECTED_PAYMENT_METHOD_CODE = 'connected-payment-method';
-const MULTIVENDOR_PLUGIN_OPTIONS = Symbol('MULTIVENDOR_PLUGIN_OPTIONS');

package/dist/plugin/.vendure-dashboard-temp/example-plugins/multivendor-plugin/constants.js.map

@@ -1 +0,0 @@
-"{\"version\":3,\"sources\":[\"C:\\\\Development\\\\vendure\\\\vendure\\\\packages\\\\dev-server\\\\example-plugins\\\\multivendor-plugin\\\\constants.ts\"],\"sourcesContent\":[\"export const CONNECTED_PAYMENT_METHOD_CODE = 'connected-payment-method';\\r\\nexport const MULTIVENDOR_PLUGIN_OPTIONS = Symbol('MULTIVENDOR_PLUGIN_OPTIONS');\\r\\n\"],\"names\":[\"CONNECTED_PAYMENT_METHOD_CODE\",\"MULTIVENDOR_PLUGIN_OPTIONS\",\"Symbol\"],\"mappings\":\";;;;;;;;;;;IAAaA,6BAA6B;eAA7BA;;IACAC,0BAA0B;eAA1BA;;;AADN,MAAMD,gCAAgC;AACtC,MAAMC,6BAA6BC,OAAO\"}"