procurement-vuex/src/payment.one.js

Commerce vuex module

import { snakeCase } from 'lodash'
import humps from 'lodash-humps'
import createHumps from 'lodash-humps/lib/createHumps'
import { getField, updateField } from 'vuex-map-fields'
import paymentService from './payment.service'
const { doPostOne, doPatchOne, doFetchOne, doDeleteSelected, doPostOrderBalancePaymentsAuto, doGetPaymentReport } = paymentService
const snakes = createHumps(snakeCase)

export default {
    namespaced: true,
    state: {
        one: null,
        inProgress: true,
        paymentReport: [],
        currentPaymentItem: null
    },
    getters: {
        getField,
    },
    mutations: {
        updateField,
        setOne(state, one) {
            state.one = one;
        },
        setPaymentReport(state, report) {
            state.paymentReport = report;
        },
        setCurrentPaymentItem(state, item) {
            state.currentPaymentItem = item;
        },
        inProgress(state, yesOrNo) {
            state.inProgress = yesOrNo
        },
        removeBusinessEntity(state) {
            if (state.one.businessEntity)
                delete state.one.businessEntity
        },
        removeProviderBusinessEntity(state) {
            if (state.one.providerBusinessEntity || state.one.providerBusinessEntity == null)
                delete state.one.providerBusinessEntity
        },
        removePurchaserBusinessEntity(state) {
            if (state.one.purchaserBusinessEntity)
                delete state.one.purchaserBusinessEntity
        },
        setPurchaseOrderTimeline(state, timeLine) {
            state.purchaseOrderTimeline = timeLine
        },
        setPurchaseOrderCompare(state, compare) {
            state.purchaseOrderCompare = compare
        },
    },
    actions: {
        new({ commit }, { appId,businessEntityId,orderId,serviceId,recipientId }) {
            commit('inProgress', false);
            commit('setOne', {
                appId: appId,
                giverId:businessEntityId,
                serviceId: serviceId,
                referenceType:'purchase_order',
                referenceId:orderId,
                recipientId:recipientId,
                currencyIso3: 'USD',
                amount:0,
                scheduledDate:null,
                metadata:{},
                paid: false
            });
        },
        fetchOne: async ({ commit}, { paymentId, appId, recursive }) => {
            commit('inProgress', true);

            try {
                let payment = await doFetchOne({ paymentId, appId });
                if (payment) {
                    commit('setOne', humps(payment))
                    commit('inProgress', false)
                    }
            }
            // eslint-disable-next-line no-useless-catch
            catch (err) {
                throw err
            }
            finally {
                commit('inProgress', false)
            }
        },
        save: async({ commit, state },{newPaymentId}) => {
            commit('inProgress', true)
            try {
              if (undefined === state.one.id) {
                let postParams = newPaymentId ? snakes(Object.assign({}, state.one, {id : newPaymentId})) :  snakes(Object.assign({}, state.one))
                   
               let payment= await doPostOne(postParams)
                commit('inProgress', false)
      
                return ({ new: true,payment:payment })
              } else {
                let payment=await doPatchOne(snakes(state.one))
                commit('inProgress', false)
      
                return ({ update: true,payment:payment })
              }
            }
            // eslint-disable-next-line no-useless-catch
            catch (err) {
              throw err
            }
            finally {
              commit('inProgress', false)
            }           
        },
        purchaseOrderBalancePaymentsAuto: async({ commit }, {purchaseOrderId}) => {
            commit('inProgress', true)
            try {
               await doPostOrderBalancePaymentsAuto({purchaseOrderId})
                commit('inProgress', false)
      
                return ({ new: true})
            }
            // eslint-disable-next-line no-useless-catch
            catch (err) {
              throw err
            }
            finally {
              commit('inProgress', false)
            }           
        },
        deleteSelected: async ({ commit }, { paymentProofId }) => {
            commit('inProgress', true);
            try {
                await doDeleteSelected({ paymentProofId });
                return ({ deleteSelected: true })
            } catch (err) {
                return ({ deleteSelected: false })
            }
            finally {
                commit('inProgress', false);
            }
        },
        getPaymentReport: async ({ commit}, { purchaseOrderId, specs }) => {
            commit('inProgress', true);

            try {
                let paymentReport = await doGetPaymentReport({ purchaseOrderId, specs });
                if (paymentReport) {
                    commit('setPaymentReport', humps(paymentReport))
                    commit('inProgress', false)
                    return humps(paymentReport)
                }
            }
            // eslint-disable-next-line no-useless-catch
            catch (err) {
                throw err
            }
            finally {
                commit('inProgress', false)
            }
        },
        setCurrentPaymentItem({ commit }, { currentItem }) {
            commit('setCurrentPaymentItem', currentItem);
        },
        setPaymentOne({ commit }, { item }) {
            commit('setOne', item);
        },
    },

}