rerobe-js-orm 2.4.2 → 2.4.8

package/lib/form-states/ProductCollection/ProductCollectionFormState.d.ts

@@ -0,0 +1,12 @@
+import FormState from '../FormState';
+import ProductCollection from '../../models/ProductCollection';
+export default class ProductCollectionFormState extends FormState {
+    fields: ProductCollectionFormFields;
+    props: CompleteProductCollection;
+    opts: {
+        tagOptions: string[];
+    };
+    constructor(props?: any, opts?: any);
+    createProductCollection(): ProductCollection;
+    private fieldFactory;
+}

package/lib/form-states/ProductCollection/ProductCollectionFormState.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const FormState_1 = require("../FormState");
+const ProductCollection_1 = require("../../models/ProductCollection");
+const ProductCollectionFromFormState_1 = require("../../factories/ProductCollection/ProductCollectionFromFormState");
+// @ts-ignore
+const lodash_1 = require("lodash");
+class ProductCollectionFormState extends FormState_1.default {
+    constructor(props, opts) {
+        super();
+        this.props = new ProductCollection_1.default(props).toObj();
+        this.opts = opts;
+        this.fields.preTitle = this.fieldFactory('textInput', 'preTitle');
+        this.fields.title = this.fieldFactory('textInput', 'title');
+        this.fields.subTitle = this.fieldFactory('textInput', 'subTitle');
+        this.fields.description = this.fieldFactory('textInput', 'description');
+        this.fields.type = this.fieldFactory('singleSelect', 'type');
+        this.fields.imgUrl = this.fieldFactory('textInput', 'imgUrl');
+        this.fields.refinements = this.fieldFactory('singleSelect', 'refinements');
+        this.fields.tags = this.fieldFactory('multiSelect', 'tags', []);
+        this.fields.collectionId = this.fieldFactory('textInput', 'collectionId');
+    }
+    createProductCollection() {
+        const productCollectionFactory = new ProductCollectionFromFormState_1.default();
+        return productCollectionFactory.createProductCollection(this);
+    }
+    fieldFactory(fieldType, fieldKey, fieldOptions) {
+        let options = fieldOptions || [];
+        if (fieldType === 'singleSelect') {
+            const selectedValue = this.props[fieldKey] || '';
+            const valid = !!this.props[fieldKey];
+            const onChangeHandler = (val) => this.singleSelectChangeHandler(fieldKey, val);
+            return {
+                options,
+                selectedValue,
+                valid,
+                onChangeHandler,
+            };
+        }
+        if (fieldType === 'textInput') {
+            const inputValue = this.props[fieldKey] || '';
+            const valid = !!this.props[fieldKey];
+            let onChangeHandler = (val) => this.textInputChangeHandler(fieldKey, String(val));
+            if (fieldKey === 'collectionId') {
+                onChangeHandler = (val) => this.textInputChangeHandler(fieldKey, lodash_1.camelCase(String(val)));
+            }
+            return {
+                inputValue,
+                valid,
+                onChangeHandler,
+            };
+        }
+        if (fieldType === 'multiSelect') {
+            let selectedValues = [];
+            let valid = true;
+            const onChangeHandler = (val) => this.multiSelectChangeHandler(fieldKey, val);
+            if (fieldKey === 'tags') {
+                if (this.props.tags) {
+                    if (Array.isArray(this.props.tags)) {
+                        selectedValues = this.props.tags;
+                    }
+                }
+                if (this.opts && this.opts.tagOptions && this.opts.tagOptions.length > 0) {
+                    options = this.utilities.uniqObjArray([...options, ...this.opts.tagOptions.map((t) => ({ label: t, value: t }))], 'value');
+                }
+                valid = true;
+            }
+            return {
+                options,
+                selectedValues,
+                valid,
+                onChangeHandler,
+            };
+        }
+        return {
+            valid: false,
+        };
+    }
+}
+exports.default = ProductCollectionFormState;

package/lib/{models/FormStates → form-states}/SellRequest/SellRequestFormState.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const FormState_1 = require("../FormState");
-const Product_1 = require("../../../models/Product");
+const Product_1 = require("../../models/Product");
 class SellRequestFormState extends FormState_1.default {
     constructor(sellRequest) {
         super();

package/lib/{models/FormStates → form-states}/User/UserFormState.d.ts

@@ -1,5 +1,5 @@
 import FormState from '../FormState';
-import User from '../../User';
+import User from '../../models/User';
 export default class UserFormState extends FormState {
     fields: UserFormFields;
     props: UserAttributes;

package/lib/{models/FormStates → form-states}/User/UserFormState.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const FormState_1 = require("../FormState");
-const User_1 = require("../../User");
-const UserFromFormState_1 = require("../../../factories/User/UserFromFormState");
+const User_1 = require("../../models/User");
+const UserFromFormState_1 = require("../../factories/User/UserFromFormState");
 class UserFormState extends FormState_1.default {
     constructor(props) {
         super();

package/lib/helpers/AnalyticsHelpers.js

@@ -13,16 +13,16 @@ class AnalyticsHelpers {
             id: documentId,
             address: prepareAddressTraits(addresses),
             title,
-            createdAt: prepareCreatedOrUpdatedAt(createdAt)
+            createdAt: prepareCreatedOrUpdatedAt(createdAt),
         };
         // Step 2. Pass other user attributes to traits obj
         const traitsObj = {
             updatedAt: prepareCreatedOrUpdatedAt(updatedAt),
-            isSeller
+            isSeller,
         };
         return {
             userId: documentId || '',
-            traits: Object.assign(Object.assign({}, reservedTraitsObj), traitsObj)
+            traits: Object.assign(Object.assign({}, reservedTraitsObj), traitsObj),
         };
     }
 }

package/lib/helpers/OrderHelpers.d.ts

@@ -4,4 +4,9 @@ export default class OrderHelpers {
     getPaymentTypeUsingTags(tags: string | null | undefined): string | null;
     getSalesChannelUsingTags(tags: string | null | undefined): string | null;
     buildLineItemFromProduct(product: CompleteProduct, currencyCode: string, quantity?: number): ReRobeOrderLineItem;
+    toFixedPointPrice(price: number | string): string;
+    getAmountSumByField(array: OrderRefund[], fieldKey: string): number;
+    getOrderInfoWithRefundsAndFulfillments(order: CompleteOrder): OrderWithRefundsAndFulfillmentsInfoObj;
+    getUpdatedOrderObjWithRefunds(orderObj: CompleteOrder, refundObj: OrderRefund): CompleteOrder;
+    getUpdatedOrderObjWithFulfillment(orderObj: CompleteOrder, fulfillmentObj: FulfillmentAdmin, totalUnfulfilledItems: number): CompleteOrder;
 }

package/lib/helpers/OrderHelpers.js

@@ -77,5 +77,112 @@ class OrderHelpers {
             productId: product.documentId,
         };
     }
+    toFixedPointPrice(price) {
+        return Number(price).toFixed(2);
+    }
+    getAmountSumByField(array, fieldKey) {
+        return array.map((item) => Number(item[fieldKey].amount)).reduce((a, b) => a + b, 0);
+    }
+    getOrderInfoWithRefundsAndFulfillments(order) {
+        var _a;
+        const orderRefunds = order.refunds ? [...order.refunds] : [];
+        const orderFulfillment = order.fulfillments ? [...order.fulfillments] : [];
+        const preparedOrder = {
+            documentId: order.documentId || '',
+            name: order.name || '',
+            currencyCode: order.currencyCode,
+            fulfillmentStatus: order.fulfillmentStatus || '',
+            totalDiscount: order.totalDiscount ? Object.assign({}, order.totalDiscount) : { amount: 0 },
+            totalTax: order.totalTax ? Object.assign({}, order.totalTax) : { amount: 0 },
+            subtotalPrice: order.subtotalPrice ? Object.assign({}, order.subtotalPrice) : { amount: 0 },
+            totalRefunded: order.totalRefunded ? Object.assign({}, order.totalRefunded) : { amount: 0 },
+            totalShippingPrice: order.totalShippingPrice ? Object.assign({}, order.totalShippingPrice) : { amount: 0 },
+            totalPrice: order.totalPrice ? Object.assign({}, order.totalPrice) : { amount: 0 },
+            activeLineItems: !order.lineItems || !order.lineItems.length
+                ? []
+                : order.lineItems.map((item) => (Object.assign(Object.assign({}, item), { unfulfilledQuantity: Number(item.quantity), fulfilledQuantity: 0, refundedQuantity: 0, canceledQuantity: 0 }))),
+            discountType: 'Custom discount',
+            shippingRate: 'Custom shipping rate',
+            unfulfilledItems: [],
+            fulfilledItems: [],
+            refundedItems: [],
+            canceledItems: [],
+            refunds: orderRefunds,
+        };
+        if (!preparedOrder.activeLineItems.length) {
+            return preparedOrder;
+        }
+        if (orderFulfillment.length) {
+            preparedOrder.activeLineItems = preparedOrder.activeLineItems.map((item) => {
+                const currentItem = item.productId;
+                const fulfilledWithRefundedQuantity = orderFulfillment.reduce((result, { fulfillmentLineItems }) => {
+                    if (fulfillmentLineItems.length) {
+                        const fulfillmentProdItem = fulfillmentLineItems.find((fli) => fli.lineItem.productId === currentItem);
+                        if (fulfillmentProdItem) {
+                            result = result + Number(fulfillmentProdItem.quantity);
+                        }
+                    }
+                    return result;
+                }, 0);
+                return Object.assign(Object.assign({}, item), { unfulfilledQuantity: item.unfulfilledQuantity - fulfilledWithRefundedQuantity, fulfilledQuantity: fulfilledWithRefundedQuantity });
+            });
+            preparedOrder.fulfilledItems = preparedOrder.activeLineItems.filter(({ fulfilledQuantity }) => fulfilledQuantity > 0);
+        }
+        preparedOrder.unfulfilledItems = preparedOrder.activeLineItems.filter(({ unfulfilledQuantity }) => unfulfilledQuantity > 0);
+        if (!orderRefunds.length) {
+            return preparedOrder;
+        }
+        preparedOrder.totalDiscount.amount =
+            Number(order.totalDiscount.amount) - this.getAmountSumByField(orderRefunds, 'refundDiscount');
+        preparedOrder.subtotalPrice.amount =
+            Number(order.subtotalPrice.amount) - this.getAmountSumByField(orderRefunds, 'subtotalRefunded');
+        preparedOrder.totalShippingPrice.amount =
+            Number(((_a = order.totalShippingPrice) === null || _a === void 0 ? void 0 : _a.amount) || 0) - this.getAmountSumByField(orderRefunds, 'refundShipping');
+        preparedOrder.totalPrice.amount =
+            Number(order.totalPrice.amount) - this.getAmountSumByField(orderRefunds, 'totalRefunded');
+        const lineItemsWithQuantityInfo = preparedOrder.activeLineItems.map((item) => {
+            const currentItem = item.productId;
+            const refundedAndCanceledQuantity = orderRefunds.reduce((result, { refundLineItems }) => {
+                if (refundLineItems.length) {
+                    const refundProdItem = refundLineItems.find(({ lineItem }) => lineItem.productId === currentItem);
+                    if (refundProdItem) {
+                        result.refundedQuantity = result.refundedQuantity + Number(refundProdItem.quantityRefund);
+                        result.canceledQuantity = result.canceledQuantity + Number(refundProdItem.quantityCancel);
+                    }
+                }
+                return result;
+            }, { refundedQuantity: 0, canceledQuantity: 0 });
+            // 3. fulfilledQuantity = (sum of order.fulfillment) - refundedQuantity
+            // 4. quantity = unfulfilled quantity (prev quantity - sum of order.fulfillment) - cancelled
+            return Object.assign(Object.assign(Object.assign({}, item), { fulfilledQuantity: Number(item.fulfilledQuantity) - refundedAndCanceledQuantity.refundedQuantity, unfulfilledQuantity: Number(item.unfulfilledQuantity) - refundedAndCanceledQuantity.canceledQuantity }), refundedAndCanceledQuantity);
+        });
+        preparedOrder.activeLineItems = lineItemsWithQuantityInfo.filter(({ unfulfilledQuantity, fulfilledQuantity }) => unfulfilledQuantity + fulfilledQuantity > 0);
+        preparedOrder.unfulfilledItems = lineItemsWithQuantityInfo.filter(({ unfulfilledQuantity }) => unfulfilledQuantity > 0);
+        preparedOrder.fulfilledItems = lineItemsWithQuantityInfo.filter(({ fulfilledQuantity }) => fulfilledQuantity > 0);
+        preparedOrder.refundedItems = lineItemsWithQuantityInfo.filter(({ refundedQuantity }) => refundedQuantity > 0);
+        preparedOrder.canceledItems = lineItemsWithQuantityInfo.filter(({ canceledQuantity }) => canceledQuantity > 0);
+        return preparedOrder;
+    }
+    getUpdatedOrderObjWithRefunds(orderObj, refundObj) {
+        const updatedOrder = Object.assign(Object.assign({}, orderObj), { refunds: orderObj.refunds ? [...orderObj.refunds] : [], totalRefunded: orderObj.totalRefunded ? Object.assign({}, orderObj.totalRefunded) : { amount: 0 } });
+        const totalRefundedAmount = Number(updatedOrder.totalRefunded.amount) + Number(refundObj.totalRefunded.amount);
+        updatedOrder.refunds = [...updatedOrder.refunds, Object.assign({}, refundObj)];
+        updatedOrder.totalRefunded.amount = Number(totalRefundedAmount).toFixed(2);
+        updatedOrder.financialStatus =
+            Number(orderObj.totalPrice.amount) - totalRefundedAmount > 0 ? 'PARTIALLY_REFUNDED' : 'REFUNDED';
+        return updatedOrder;
+    }
+    getUpdatedOrderObjWithFulfillment(orderObj, fulfillmentObj, totalUnfulfilledItems) {
+        const updatedOrder = Object.assign(Object.assign({}, orderObj), { fulfillments: orderObj.fulfillments ? [...orderObj.fulfillments] : [] });
+        const fulfilledItemsQuantity = !fulfillmentObj.fulfillmentLineItems.length
+            ? 0
+            : fulfillmentObj.fulfillmentLineItems
+                .map(({ quantity }) => Number(quantity))
+                .reduce((a, b) => a + b, 0);
+        updatedOrder.fulfillments = [...updatedOrder.fulfillments, fulfillmentObj];
+        updatedOrder.fulfillmentStatus =
+            totalUnfulfilledItems - fulfilledItemsQuantity > 0 ? 'PARTIALLY_FULFILLED' : 'FULFILLED';
+        return updatedOrder;
+    }
 }
 exports.default = OrderHelpers;

package/lib/helpers/ProductCollectionHelpers.d.ts

@@ -0,0 +1,4 @@
+export default class ProductCollectionHelpers {
+    getFiltersByCollectionConditions(collectionRefinementsVal: ProductRefinements): FiltersObj;
+    getCollectionRefinementsFromFilters(filtersList: FiltersObj): ProductRefinements;
+}

package/lib/helpers/ProductCollectionHelpers.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class ProductCollectionHelpers {
+    getFiltersByCollectionConditions(collectionRefinementsVal) {
+        if (!collectionRefinementsVal && !Object.keys(collectionRefinementsVal).length) {
+            return {};
+        }
+        return Object.keys(collectionRefinementsVal).reduce((result, key) => {
+            const keyName = key.replace('Refinement', '');
+            result[keyName] = collectionRefinementsVal[key];
+            return result;
+        }, {});
+    }
+    getCollectionRefinementsFromFilters(filtersList) {
+        if (!filtersList && !Object.keys(filtersList).length) {
+            return {};
+        }
+        return Object.keys(filtersList).reduce((result, key) => {
+            if (!filtersList[key].length) {
+                return result;
+            }
+            result[`${key}Refinement`] = [...filtersList[key]];
+            return result;
+        }, {});
+    }
+}
+exports.default = ProductCollectionHelpers;

package/lib/helpers/ReRobeProductHelpers.d.ts

@@ -7,10 +7,16 @@ export default class ReRobeProductHelpers {
     static sizeCommentPretty(sizeComment: string): string;
     static getSizeLabel(clothingSize: string[], shoeSize: string, jeanSize: string): string;
     static generateArrForDetailsBulletList(productObj: CompleteProduct): string[];
+    static autoCreateFullDescriptionHTML(productObj: CompleteProduct, customHeading?: string): string;
+    static autoCreateFullSwedishDescriptionForTraderaHTML(productDescription: string, merchantName?: string): string;
     static prepareProductForMutation(productObj: CompleteProduct, mediaInputArr?: {
         originalSource: string;
     }[]): CompleteProduct;
+    static createTimestampsForStates(productObj: CompleteProduct): {
+        [key: string]: number;
+    };
     static getSubtitle(title: string): string;
     static sizeFinder(sizeLabel: string, sizeToMatch: string): boolean;
+    static convertReRobeSizeToStandardSize(productObj: CompleteProduct): string;
     static buildLineItem(productObj: CompleteProduct, quantity?: number): ProductLineItem;
 }