@daffodil/order 0.39.11 → 0.40.1

package/fesm2020/daffodil-order-driver-magento-2.4.1.mjs

@@ -0,0 +1,646 @@
+import { daffAdd, daffSubtract } from '@daffodil/core';
+import { DaffOrderTotalTypeEnum, DaffOrderItemType } from '@daffodil/order';
+import * as i1 from '@damienwebdev/apollo-angular';
+import { gql } from '@damienwebdev/apollo-angular';
+import { daffBuildFragmentNameSpread, daffBuildFragmentDefinition } from '@daffodil/core/graphql';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injectable, Inject, NgModule } from '@angular/core';
+import { throwError } from 'rxjs';
+import { map, catchError } from 'rxjs/operators';
+import { DaffOrderInvalidAPIResponseError, DaffOrderNotFoundError, DaffOrderDriver } from '@daffodil/order/driver';
+import { daffTransformMagentoError } from '@daffodil/driver/magento';
+import { DaffCartNotFoundError } from '@daffodil/cart/driver';
+import { CommonModule } from '@angular/common';
+
+var MagentoOrderItemType;
+(function (MagentoOrderItemType) {
+    MagentoOrderItemType["Simple"] = "simple";
+    MagentoOrderItemType["Configurable"] = "configurable";
+    MagentoOrderItemType["Bundle"] = "bundle";
+})(MagentoOrderItemType || (MagentoOrderItemType = {}));
+;
+;
+;
+;
+;
+
+function transformTotals(totals) {
+    return [
+        {
+            label: 'Grand Total',
+            type: DaffOrderTotalTypeEnum.GrandTotal,
+            value: totals.grand_total.value,
+            sort_order: 1,
+        },
+        {
+            label: 'Subtotal',
+            type: DaffOrderTotalTypeEnum.Subtotal,
+            value: totals.subtotal.value,
+            sort_order: 0,
+        },
+        {
+            label: 'Shipping',
+            type: DaffOrderTotalTypeEnum.Shipping,
+            value: totals.total_shipping.value,
+            sort_order: 2,
+        },
+        {
+            label: 'Tax',
+            type: DaffOrderTotalTypeEnum.Tax,
+            value: totals.total_tax.value,
+            sort_order: 3,
+        },
+        {
+            label: 'Discount',
+            type: DaffOrderTotalTypeEnum.Discount,
+            value: totals.discounts.reduce((acc, discount) => daffAdd(acc, discount.amount.value), 0),
+            sort_order: 4,
+        },
+    ];
+}
+function transformCouponDiscount(discount) {
+    return {
+        code: discount.label,
+    };
+}
+function transformConfigurableOption(option) {
+    return {
+        attribute_label: option.label,
+        value_label: option.value,
+    };
+}
+function transformBundleOption(option) {
+    return {
+        option_label: option.label,
+        value_label: option.values && option.values[0] && option.values[0].product_name,
+    };
+}
+function transformAdditionalItemFields(item) {
+    switch (item.product_type) {
+        case MagentoOrderItemType.Bundle:
+            return {
+                type: DaffOrderItemType.Composite,
+                options: item.bundle_options.map(transformBundleOption),
+            };
+        case MagentoOrderItemType.Configurable:
+            return {
+                type: DaffOrderItemType.Configurable,
+                attributes: item.selected_options.map(transformConfigurableOption),
+            };
+        case MagentoOrderItemType.Simple:
+            return {
+                type: DaffOrderItemType.Simple,
+            };
+        default:
+            return {};
+    }
+}
+function transformItem(item, order, qty) {
+    const discount = item.discounts.reduce((acc, d) => daffAdd(acc, d.amount.value), 0);
+    const rowTotal = qty * item.product_sale_price.value;
+    const rowTotalWithDiscount = qty * daffSubtract(item.product_sale_price.value, discount);
+    return {
+        type: DaffOrderItemType.Simple,
+        id: null,
+        item_id: null,
+        qty_ordered: item.quantity_ordered,
+        qty_canceled: item.quantity_canceled,
+        qty_fulfilled: item.quantity_shipped,
+        qty,
+        image: {
+            url: item.product_url_key,
+            id: null,
+            label: null,
+        },
+        order_id: order.id,
+        created_at: null,
+        updated_at: null,
+        product_id: null,
+        parent_item_id: null,
+        sku: item.product_sku,
+        name: item.product_name,
+        weight: null,
+        price: item.product_sale_price.value,
+        discount_percent: Math.floor(discount / item.product_sale_price.value * 100),
+        discount_amount: discount,
+        tax_percent: null,
+        tax_amount: null,
+        row_total: rowTotal,
+        row_total_with_discount: rowTotalWithDiscount,
+        row_weight: null,
+        tax_before_discount: null,
+        ...transformAdditionalItemFields(item),
+    };
+}
+function transformAddress(address, order) {
+    return {
+        order_id: order.id,
+        prefix: address.prefix,
+        suffix: address.suffix,
+        firstname: address.firstname,
+        middlename: address.middlename,
+        lastname: address.lastname,
+        telephone: address.telephone,
+        email: null,
+        street: address.street[0],
+        street2: address.street[1],
+        city: address.city,
+        region: address.region_code,
+        country: address.country_code,
+        postcode: address.postcode,
+    };
+}
+function transformShipmentItem(shipmentItem, order) {
+    return {
+        item: transformItem(shipmentItem.order_item, order, shipmentItem.quantity_shipped),
+        qty: shipmentItem.quantity_shipped,
+    };
+}
+function transformShipmentTracking(tracking) {
+    return {
+        tracking_number: tracking.number,
+        tracking_url: null,
+        carrier: tracking.carrier,
+        title: tracking.title,
+        carrier_logo: null,
+    };
+}
+function transformShipment(shipment, order) {
+    return {
+        carrier: order.carrier,
+        carrier_title: null,
+        code: null,
+        method: order.shipping_method,
+        method_description: null,
+        tracking: shipment.tracking.map(transformShipmentTracking),
+        items: shipment.items.map(item => transformShipmentItem(item, order)),
+    };
+}
+function transformPayment(payment, order) {
+    const findAdditionalData = key => {
+        const index = payment.additional_data.findIndex(({ name }) => name === key);
+        return index > -1 ? payment.additional_data[index].value : null;
+    };
+    return {
+        id: null,
+        payment_id: null,
+        order_id: order.id,
+        created_at: null,
+        updated_at: null,
+        method: payment.type,
+        cc_type: findAdditionalData('cc_type'),
+        cc_last4: findAdditionalData('cc_last4'),
+        cc_owner: findAdditionalData('cc_owner'),
+        cc_exp_month: findAdditionalData('cc_exp_month'),
+        cc_exp_year: findAdditionalData('cc_exp_year'),
+    };
+}
+function transformInvoiceItem(invoiceItem, order) {
+    return {
+        item: transformItem(invoiceItem.order_item, order, invoiceItem.quantity_invoiced),
+        qty: invoiceItem.quantity_invoiced,
+    };
+}
+function transformInvoice(invoice, order, payment) {
+    return {
+        totals: transformTotals(invoice.total),
+        billing_address: transformAddress(order.billing_address, order),
+        shipping_address: transformAddress(order.shipping_address, order),
+        payment: transformPayment(payment, order),
+        items: invoice.items.map(item => transformInvoiceItem(item, order)),
+        shipping_method: null,
+    };
+}
+function transformCreditItem(creditItem, order) {
+    return {
+        item: transformItem(creditItem.order_item, order, creditItem.quantity_refunded),
+        qty: creditItem.quantity_refunded,
+    };
+}
+function transformCredit(credit, order) {
+    return {
+        totals: transformTotals(credit.total),
+        billing_address: transformAddress(order.billing_address, order),
+        shipping_address: transformAddress(order.shipping_address, order),
+        payment: transformPayment(order.payment_methods[0], order),
+        items: credit.items.map(item => transformCreditItem(item, order)),
+        shipping_method: null,
+    };
+}
+/**
+ * Transforms the MagentoOrder from the magento order query into a DaffOrder.
+ */
+function daffMagentoTransformOrder(order) {
+    return {
+        extra_attributes: order,
+        id: order.number,
+        customer_id: null,
+        updated_at: null,
+        created_at: order.order_date,
+        status: order.status,
+        totals: transformTotals(order.total),
+        applied_codes: order.total.discounts.map(transformCouponDiscount),
+        items: order.items.map(item => transformItem(item, order, item.quantity_ordered)),
+        billing_addresses: [
+            transformAddress(order.billing_address, order),
+        ],
+        shipping_addresses: [
+            transformAddress(order.shipping_address, order),
+        ],
+        shipments: order.shipments.map(shipment => transformShipment(shipment, order)),
+        payment: transformPayment(order.payment_methods[0], order),
+        // TODO: find out if the index is the correct payment for invoice
+        invoices: order.invoices.map((invoice, index) => transformInvoice(invoice, order, order.payment_methods[index])),
+        credits: order.credit_memos.map(credit => transformCredit(credit, order)),
+    };
+}
+
+;
+;
+
+;
+;
+
+const orderAddressFragment = gql `
+  fragment orderAddress on OrderAddress {
+    city
+    company
+    country_code
+    fax
+    firstname
+    middlename
+    lastname
+    postcode
+    prefix
+    region
+    region_code
+    street
+    suffix
+    telephone
+  }
+`;
+
+const orderBundleItemSelectedOptionFragment = gql `
+  fragment orderBundleItemSelectedOption on ItemSelectedBundleOption {
+    label
+    values {
+      product_name
+    }
+  }
+`;
+const orderItemFragment = gql `
+  fragment orderItem on OrderItemInterface {
+    quantity_ordered
+    quantity_canceled
+    quantity_shipped
+    quantity_invoiced
+    product_url_key
+    product_sku
+    product_name
+    product_type
+    product_sale_price {
+      value
+    }
+    discounts {
+      amount {
+        value
+      }
+    }
+    selected_options {
+      label
+      value
+    }
+    ... on BundleOrderItem {
+      bundle_options {
+        ...orderBundleItemSelectedOption
+      }
+    }
+  }
+  ${orderBundleItemSelectedOptionFragment}
+`;
+
+const orderCreditItemFragment = gql `
+  fragment orderCreditItem on CreditMemoItemInterface {
+    quantity_refunded
+    order_item {
+      ...orderItem
+    }
+  }
+  ${orderItemFragment}
+`;
+
+const orderCreditTotalFragment = gql `
+  fragment orderCreditTotal on CreditMemoTotal {
+    discounts {
+      amount {
+        value
+      }
+      label
+    }
+    grand_total {
+      value
+    }
+    subtotal {
+      value
+    }
+    total_tax {
+      value
+    }
+    total_shipping {
+      value
+    }
+  }
+`;
+
+const orderCreditFragment = gql `
+  fragment orderCredit on CreditMemo {
+    items {
+      ...orderCreditItem
+    }
+    total {
+      ...orderCreditTotal
+    }
+  }
+  ${orderCreditItemFragment}
+  ${orderCreditTotalFragment}
+`;
+
+const orderInvoiceItemFragment = gql `
+  fragment orderInvoiceItem on InvoiceItemInterface {
+    quantity_invoiced
+    order_item {
+      ...orderItem
+    }
+  }
+  ${orderItemFragment}
+`;
+
+const orderInvoiceTotalFragment = gql `
+  fragment orderInvoiceTotal on InvoiceTotal {
+    discounts {
+      amount {
+        value
+      }
+      label
+    }
+    grand_total {
+      value
+    }
+    subtotal {
+      value
+    }
+    total_tax {
+      value
+    }
+    total_shipping {
+      value
+    }
+  }
+`;
+
+const orderInvoiceFragment = gql `
+  fragment orderInvoice on Invoice {
+    items {
+      ...orderInvoiceItem
+    }
+    total {
+      ...orderInvoiceTotal
+    }
+  }
+  ${orderInvoiceItemFragment}
+  ${orderInvoiceTotalFragment}
+`;
+
+const orderPaymentFragment = gql `
+  fragment orderPayment on OrderPaymentMethod {
+    name
+    type
+    additional_data {
+      name
+      value
+    }
+  }
+`;
+
+const orderShipmentItemFragment = gql `
+  fragment orderShipmentItem on ShipmentItemInterface {
+    quantity_shipped
+    order_item {
+      ...orderItem
+    }
+  }
+  ${orderItemFragment}
+`;
+
+const orderShipmentTrackingFragment = gql `
+  fragment orderShipmentTracking on ShipmentTracking {
+    number
+    carrier
+    title
+  }
+`;
+
+const orderShipmentFragment = gql `
+  fragment orderShipment on OrderShipment {
+    tracking {
+      ...orderShipmentTracking
+    }
+    items {
+      ...orderShipmentItem
+    }
+  }
+  ${orderShipmentItemFragment}
+  ${orderShipmentTrackingFragment}
+`;
+
+const orderTotalFragment = gql `
+  fragment orderTotal on OrderTotal {
+    discounts {
+      amount {
+        value
+      }
+      label
+    }
+    grand_total {
+      value
+    }
+    subtotal {
+      value
+    }
+    total_tax {
+      value
+    }
+    total_shipping {
+      value
+    }
+  }
+`;
+
+const orderFragment = gql `
+  fragment order on GraycoreGuestOrder {
+    id
+    order_date
+    status
+    carrier
+    number
+    shipping_method
+    items {
+      ...orderItem
+    }
+    billing_address {
+      ...orderAddress
+    }
+    shipping_address {
+      ...orderAddress
+    }
+    shipments {
+      ...orderShipment
+    }
+    payment_methods {
+      ...orderPayment
+    }
+    invoices {
+      ...orderInvoice
+    }
+    credit_memos {
+      ...orderCredit
+    }
+    total {
+      ...orderTotal
+    }
+  }
+  ${orderItemFragment}
+  ${orderShipmentFragment}
+  ${orderPaymentFragment}
+  ${orderInvoiceFragment}
+  ${orderCreditFragment}
+  ${orderAddressFragment}
+  ${orderTotalFragment}
+`;
+
+const getGuestOrders = (extraOrderFragments = []) => gql `
+  query MagentoGetGuestOrders($cartId: String!) {
+    graycoreGuestOrders(cartId: $cartId) {
+      items {
+        ...order
+        ${daffBuildFragmentNameSpread(...extraOrderFragments)}
+      }
+    }
+  }
+  ${orderFragment}
+  ${daffBuildFragmentDefinition(...extraOrderFragments)}
+`;
+
+/**
+ * An multi-provider injection token for providing extra GraphQL fragments that will be spread into order queries.
+ * This can be used to retrieve additional data that is not covered by the standard Daffodil interfaces.
+ * The data will appear in DaffOrder#extra_attributes.
+ *
+ * Fragment structure is platform-specific and this feature should be used with care.
+ */
+const DaffMagentoExtraOrderFragments = new InjectionToken('DaffMagentoExtraOrderFragments', { factory: () => [] });
+
+var MagentoOrderGraphQlErrorCode;
+(function (MagentoOrderGraphQlErrorCode) {
+    MagentoOrderGraphQlErrorCode["CART_NOT_FOUND"] = "graphql-no-such-entity";
+})(MagentoOrderGraphQlErrorCode || (MagentoOrderGraphQlErrorCode = {}));
+
+const DaffOrderMagentoErrorMap = {
+    [MagentoOrderGraphQlErrorCode.CART_NOT_FOUND]: DaffCartNotFoundError,
+};
+
+function transformMagentoOrderError(error) {
+    return daffTransformMagentoError(error, DaffOrderMagentoErrorMap);
+}
+
+const validateGetOrdersResponse = (response) => {
+    if (response.data?.graycoreGuestOrders?.items) {
+        if (response.data.graycoreGuestOrders.items.reduce((acc, order) => acc && !!(order.billing_address
+            && order.shipping_address
+            && order.payment_methods), true)) {
+            return response;
+        }
+        else {
+            throw new DaffOrderInvalidAPIResponseError('One of the orders does not contain required fields.');
+        }
+    }
+    else {
+        throw new DaffOrderInvalidAPIResponseError('Get orders response does not contain a valid list of orders.');
+    }
+};
+
+/**
+ * A service for making Magento GraphQL queries for orders.
+ *
+ * @inheritdoc
+ */
+class DaffOrderMagentoService {
+    constructor(apollo, extraOrderFragments) {
+        this.apollo = apollo;
+        this.extraOrderFragments = extraOrderFragments;
+    }
+    list(cartId) {
+        return this.apollo.query({
+            query: getGuestOrders(this.extraOrderFragments),
+            variables: {
+                cartId,
+            },
+        }).pipe(map(validateGetOrdersResponse), map(result => result.data.graycoreGuestOrders.items.map(daffMagentoTransformOrder)), catchError(err => throwError(transformMagentoOrderError(err))));
+    }
+    get(orderId, cartId) {
+        return this.list(cartId).pipe(map(orders => {
+            for (const order of orders) {
+                if (order.id === orderId) {
+                    return order;
+                }
+            }
+            // order not found
+            throw new DaffOrderNotFoundError(`Could not find an order with ID ${orderId}`);
+        }));
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffOrderMagentoService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffOrderMagentoService, deps: [{ token: i1.Apollo }, { token: DaffMagentoExtraOrderFragments }], target: i0.ɵɵFactoryTarget.Injectable });
+/** @nocollapse */ /** @nocollapse */ DaffOrderMagentoService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffOrderMagentoService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffOrderMagentoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.Apollo }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [DaffMagentoExtraOrderFragments]
+                }] }]; } });
+
+class DaffOrderMagentoDriverModule {
+    static forRoot() {
+        return {
+            ngModule: DaffOrderMagentoDriverModule,
+            providers: [
+                {
+                    provide: DaffOrderDriver,
+                    useExisting: DaffOrderMagentoService,
+                },
+            ],
+        };
+    }
+}
+/** @nocollapse */ /** @nocollapse */ DaffOrderMagentoDriverModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffOrderMagentoDriverModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+/** @nocollapse */ /** @nocollapse */ DaffOrderMagentoDriverModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffOrderMagentoDriverModule, imports: [CommonModule] });
+/** @nocollapse */ /** @nocollapse */ DaffOrderMagentoDriverModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffOrderMagentoDriverModule, imports: [[
+            CommonModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.0", ngImport: i0, type: DaffOrderMagentoDriverModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [
+                        CommonModule,
+                    ],
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { DaffMagentoExtraOrderFragments, DaffOrderMagentoDriverModule, DaffOrderMagentoService, MagentoOrderItemType, daffMagentoTransformOrder, getGuestOrders, orderAddressFragment, orderFragment, orderInvoiceFragment, orderItemFragment, orderPaymentFragment, orderShipmentFragment, orderShipmentItemFragment, orderShipmentTrackingFragment };
+//# sourceMappingURL=daffodil-order-driver-magento-2.4.1.mjs.map