wholesale-vuex/src/wholesale_commercial_invoice.one.js

Commerce vuex module

import { snakeCase } from 'lodash'
import { getPaymentTypesInArray, getPaymentTypesInObj, createVariantsListFromItemsList } from './common.service.js'
import humps from 'lodash-humps'
import createHumps from 'lodash-humps/lib/createHumps'
import { getField, updateField } from 'vuex-map-fields'
import commercialInvoiceService from './wholesale_commercial_invoice.service'
const { doPostOne, doDeleteSelectedInvoice } = commercialInvoiceService
import wholesaleOrderSnapshotService from "./wholesale_order_snapshot.service";
const { doWholesaleOrderGetSnapshot } = wholesaleOrderSnapshotService;
const snakes = createHumps(snakeCase)

export default {
    namespaced: true,
    state: {
        one: null,
        inProgress: true,
        otherPaymentTypes: [],
        details: null,
        orderSnapshotObj: null,
        orderItemList: [],
        filteredItemsVariantList: [],
        originalItems: null,
        originalOrderItemList:[],
    },
    getters: {
        getField,
    },
    mutations: {
        updateField,
        setOne(state, one) {
            if(!one.shippingAddress ){
                one.shippingAddress={line:'',postcode:'',city:'',country:'',countryIso3:''}
            }
            if(!one.billingAddress){
                one.billingAddress={line:'',postcode:'',city:'',country:'',countryIso3:''}
            }
            if (one.paymentTermsObject) {
                state.otherPaymentTypes=getPaymentTypesInArray(one.paymentTermsObject)
             }
            state.one = one;
        },
        inProgress(state, yesOrNo) {
            state.inProgress = yesOrNo
        },
        removeBusinessEntity(state) {
            if (state.one.businessEntity)
                delete state.one.businessEntity
        },
        addDefaultPaymentType(state, val) {
            if (state.otherPaymentTypes === undefined || state.otherPaymentTypes == null) {
                state.otherPaymentTypes = []
            }
            if (val.type == 'new') {
                state.otherPaymentTypes = []
                state.otherPaymentTypes.splice(0, 0, { type: '', paid: 0, days: 0 })
            }
            else {
                state.otherPaymentTypes.splice(val.index, 0, { type: '', paid: 0, days: 0 })
            }
        },
        deletePaymentTypeRow(state, index) {
            state.otherPaymentTypes.splice(index, 1);
        },
        setOrderItemList(state, list){
            state.originalOrderItemList=JSON.parse(JSON.stringify(list));
        },
        setSnapshotObj(state, one) {
            state.orderSnapshotObj = one;
        },
        setDetails(state, details) {
            state.details = details;
        },
        setOrderItems(state, { items, shipmentDates }) {
        // to save only sipment dates items 
        if (shipmentDates) {
            let newItems = [];
            items.filter((item) => {
            if (
                item.shipmentStartDate === shipmentDates[0] &&
                item.shipmentCancelDate === shipmentDates[1]
            )
            newItems.push(item);
            });
            state.orderItemList = newItems;
            state.originalItems = JSON.parse(JSON.stringify(newItems));
        }
    
        // state.orderItemList = items;
        // state.originalItems = JSON.parse(JSON.stringify(items));
        },
        async searchSnapShotItems(state, data) {
            if(state.orderItemList && state.orderItemList.length)
              state.filteredItemsVariantList = await createVariantsListFromItemsList(
                state.orderItemList
              );
            let shipmentDates = data.shipmentDates;
            if (shipmentDates) {
              let items = [];
              state.filteredItemsVariantList.filter((variant) => {
                if (
                  variant.shipmentStartDate === shipmentDates[0] &&
                  variant.shipmentCancelDate === shipmentDates[1]
                )
                  items.push(variant);
              });
              state.filteredItemsVariantList = items;
            }
            // send all items if no filter
            else {
              state.filteredItemsVariantList = [];
              state.filteredItemsVariantList = state.orderItemList;
            }
          },
    },
    actions: {
        new({ commit }, { salesOrderOne }) {
            commit('inProgress', false);
            commit('setOne', {
                appId: salesOrderOne.appId,
                invoiceDate: salesOrderOne.date,
                shippingAddress: salesOrderOne.shippingAddress,
                billingAddress: salesOrderOne.billingAddress,
                salesteamServiceId : salesOrderOne.salesteamServiceId,

                providerBusinessEntityId : typeof salesOrderOne.providerBusinessEntityId == 'object' ? salesOrderOne.providerBusinessEntityId.id : salesOrderOne.providerBusinessEntityId,

                purchaserBusinessEntityId: typeof salesOrderOne.purchaserBusinessEntityId == 'object' ? salesOrderOne.purchaserBusinessEntityId.id : salesOrderOne.purchaserBusinessEntityId,
                referenceId : salesOrderOne.id,
                referenceType : 'sales_order',
                metadata : { soNumber: salesOrderOne.soNumber },
                soNumber: salesOrderOne.soNumber,                
                date: salesOrderOne.date,                
                status: salesOrderOne.status,                
                orderCcy: salesOrderOne.orderCcy,                
                shippingCost: salesOrderOne.shippingCost,
                paymentTerms: salesOrderOne.paymentTerms,
                itemsFormat: salesOrderOne.itemsFormat,
                shipmentStartDate: salesOrderOne.shipmentStartDate,
                shipmentCancelDate: salesOrderOne.shipmentCancelDate,
                discountPct: salesOrderOne.discountPct,
                discountValue: salesOrderOne.discountValue,                
                commissionPct: salesOrderOne.commissionPct,
                commissionValue: salesOrderOne.commissionValue,
                taxPct: salesOrderOne.taxPct
            });
        },
        fetchProcessingSnapshot: async (
            { commit },
            { wholesaleOrderId, shipmentDates, specs }
          ) => {
            commit("inProgress", true);
      
            try {
              let snapshot = await doWholesaleOrderGetSnapshot({
                  wholesaleOrderId,
                specs,
              });
              if (snapshot) {
                commit("setSnapshotObj", humps(snapshot));
                commit("setOrderItems", { items: humps(snapshot.items), shipmentDates });
                commit("setOrderItemList", (snapshot.items));
                commit("setDetails", humps(snapshot.details));
                commit("searchSnapShotItems", { searchString : '', shipmentDates });
      
                return humps(snapshot);
              }
            } catch (err) {
              throw "error"+ err;
            } finally {
              commit("inProgress", false);
            }
          },
        save: async ({ commit, state }) => {

            commit('inProgress', true);
            try {
                if (state.one && state.one.businessEntity)
                    commit('removeBusinessEntity');

                if (undefined === state.one.id) {
                   if (state.one.paymentTerms === 'Other') {
                        state.one.paymentTermsObject = getPaymentTypesInObj(state.otherPaymentTypes)
                    }
                    let postParams = snakes(Object.assign({}, state.one))

                    let invoiceDetail = await doPostOne(postParams);
                    invoiceDetail = humps(invoiceDetail)
                    commit('setOne', { ...invoiceDetail })
                    
                     commit('inProgress', false);
                   return ({ new: true ,invoiceDetail: invoiceDetail});
                }
            }
            // eslint-disable-next-line no-useless-catch
            catch (err) {
                throw err
            }
            finally {
                commit('inProgress', false)
            }
        },
        addDefaultPaymentType: async ({ commit }, val) => {
            commit('addDefaultPaymentType', val);
        },
        deletePaymentTypeRow: async ({ commit }, index) => {
            commit('deletePaymentTypeRow', index);
        },
        saveEditedItem: async ({ commit },  { editedColumn, item }) => {
            // commit('updatePackedItemType');
         },
         deleteInvoice: async ({ commit }, { invoiceId }) => {
            commit('inProgress', true);
            try {
                await doDeleteSelectedInvoice({ invoiceId });
                return ({ deleteSelected: true })
            } catch (err) {
                return ({ deleteSelected: false })
            }
            finally {
                commit('inProgress', false);
            }
        },
    },

}