/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
import org.apache.ofbiz.accounting.invoice.InvoiceWorker
import org.apache.ofbiz.base.util.Debug
import org.apache.ofbiz.base.util.UtilDateTime
import org.apache.ofbiz.base.util.UtilFormatOut
import org.apache.ofbiz.base.util.UtilProperties
import org.apache.ofbiz.entity.condition.EntityCondition
import org.apache.ofbiz.entity.condition.EntityOperator
import org.apache.ofbiz.entity.GenericValue
import org.apache.ofbiz.entity.util.EntityUtil
import org.apache.ofbiz.service.ModelService
import org.apache.ofbiz.service.ServiceUtil
import java.sql.Timestamp

def createPayment() {
    if (!security.hasEntityPermission("ACCOUNTING", "_CREATE", parameters.userLogin) && (!security.hasEntityPermission("PAY_INFO", "_CREATE", parameters.userLogin) && userLogin.partyId != parameters.partyIdFrom && userLogin.partyId != parameters.partyIdTo)) {
        return error(UtilProperties.getResourceBundleMap("AccountingUiLabels", locale)?.AccountingCreatePaymentPermissionError)
    }

    GenericValue payment = makeValue("Payment")
    payment.paymentId = parameters.paymentId ?: delegator.getNextSeqId("Payment")
    paymentId = payment.paymentId
    parameters.statusId = parameters.statusId ?: "PMNT_NOT_PAID"

    if (parameters.paymentMethodId) {
        GenericValue paymentMethod = from("PaymentMethod").where("paymentMethodId", parameters.paymentMethodId).queryOne()
        if (parameters.paymentMethodTypeId != paymentMethod.paymentMethodTypeId) {
            logInfo("Replacing passed payment method type [" + parameters.paymentMethodTypeId + "] with payment method type [" + paymentMethod.paymentMethodTypeId + "] for payment method [" + parameters.paymentMethodId +"]")
            parameters.paymentMethodTypeId = paymentMethod.paymentMethodTypeId
        }
    }

    if (parameters.paymentPreferenceId) {
        GenericValue orderPaymentPreference = from("OrderPaymentPreference").where("orderPaymentPreferenceId", parameters.paymentPreferenceId).queryOne()
        parameters.paymentId = parameters.paymentId ?: orderPaymentPreference.paymentMethodId
        parameters.paymentMethodTypeId = parameters.paymentMethodTypeId ?: orderPaymentPreference.paymentMethodTypeId
    }

    if (!parameters.paymentMethodTypeId) {
        return error(UtilProperties.getResourceBundleMap("AccountingUiLabels", locale)?.AccountingPaymentMethodIdPaymentMethodTypeIdNullError)
    }

    payment.setNonPKFields(parameters)
    payment.effectiveDate = payment.effectiveDate ?: UtilDateTime.nowTimestamp()
    delegator.create(payment)
    Map result = success()
    result.paymentId = paymentId
    return result
}
def getInvoicePaymentInfoList() {
    // Create a list with information on payment due dates and amounts for the invoice
    GenericValue invoice;
    List invoicePaymentInfoList = []
    if (!parameters.invoice) {
        invoice = from("Invoice").where("invoiceId", parameters.invoiceId).queryOne()
    } else {
        invoice = parameters.invoice
    }

    BigDecimal invoiceTotalAmount = InvoiceWorker.getInvoiceTotal(invoice)
    BigDecimal invoiceTotalAmountPaid = InvoiceWorker.getInvoiceApplied(invoice)

    List invoiceTerms = from("InvoiceTerm").where("invoiceId", invoice.invoiceId).queryList()

    BigDecimal remainingAppliedAmount = invoiceTotalAmountPaid
    BigDecimal computedTotalAmount = (BigDecimal) 0

    Map invoicePaymentInfo = [:]

    for (invoiceTerm in invoiceTerms) {
        termType = from("TermType").where("termTypeId", invoiceTerm.termTypeId).cache(true).queryOne()
        if ("FIN_PAYMENT_TERM" == termType.parentTypeId) {
            invoicePaymentInfo = [:]
            invoicePaymentInfo.invoiceId = invoice.invoiceId
            invoicePaymentInfo.invoiceTermId = invoiceTerm.invoiceTermId
            invoicePaymentInfo.termTypeId = invoiceTerm.termTypeId
            invoicePaymentInfo.dueDate = UtilDateTime.getDayEnd(invoice.invoiceDate, invoiceTerm.termDays)

            BigDecimal invoiceTermAmount = (invoiceTerm.termValue * invoiceTotalAmount ) / 100
            invoicePaymentInfo.amount = invoiceTermAmount
            computedTotalAmount = computedTotalAmount + (BigDecimal) invoicePaymentInfo.amount

            if (remainingAppliedAmount >= invoiceTermAmount) {
                invoicePaymentInfo.paidAmount = invoiceTermAmount
                remainingAppliedAmount = remainingAppliedAmount - invoiceTermAmount
            } else {
                invoicePaymentInfo.paidAmount = remainingAppliedAmount
                remainingAppliedAmount = (BigDecimal) 0
            }
            invoicePaymentInfo.outstandingAmount = invoicePaymentInfo.amount - invoicePaymentInfo.paidAmount
            invoicePaymentInfoList.add(invoicePaymentInfo)
        }
    }

    if (remainingAppliedAmount > 0.0 || invoiceTotalAmount <= 0.0 || computedTotalAmount < invoiceTotalAmount) {
        invoicePaymentInfo = [:]
        invoiceTerm = from("InvoiceTerm").where("invoiceId", invoice.invoiceId, "termTypeId", "FIN_PAYMENT_TERM").queryFirst()
        if (invoiceTerm) {
            invoicePaymentInfo.termTypeId = invoiceTerm.termTypeId
            invoicePaymentInfo.dueDate = UtilDateTime.getDayEnd(invoice.invoiceDate, invoiceTerm.termDays)
        } else {
            invoicePaymentInfo.dueDate = UtilDateTime.getDayEnd(invoice.invoiceDate)
        }
        invoicePaymentInfo.invoiceId = invoice.invoiceId
        invoicePaymentInfo.amount = invoiceTotalAmount - computedTotalAmount
        invoicePaymentInfo.paidAmount = remainingAppliedAmount
        invoicePaymentInfo.outstandingAmount = invoicePaymentInfo.amount - invoicePaymentInfo.paidAmount
        invoicePaymentInfoList.add(invoicePaymentInfo)
    }
    Map result = success()
    result.invoicePaymentInfoList = invoicePaymentInfoList
    return result
}
def updatePayment() {
    Map lookupPayment = makeValue("Payment")
    lookupPayment.setPKFields(parameters)
    GenericValue payment = from("Payment").where("paymentId", lookupPayment.paymentId).queryOne()
    if (!security.hasEntityPermission("ACCOUNTING", "_UPDATE", parameters.userLogin) &&
        (!security.hasEntityPermission("PAY_INFO", "_UPDATE", parameters.userLogin) &&
        userLogin.partyId != payment.partyIdFrom && userLogin.partyId != payment.partyIdTo)) {
        return error(UtilProperties.getResourceBundleMap("AccountingUiLabels", locale)?.AccountingUpdatePaymentPermissionError)
    }
    if ("PMNT_NOT_PAID" != payment.statusId) {
        // check if only status change
        GenericValue newPayment = makeValue("Payment")
        GenericValue oldPayment = makeValue("Payment")
        newPayment.setNonPKFields(payment)
        oldPayment.setNonPKFields(payment)
        newPayment.setNonPKFields(parameters)

        // fields :- comments, paymentRefNum, finAccountTransId, statusIhStatus does not allow an update of the information are editable for Payment
        oldPayment.statusId = newPayment.statusId
        oldPayment.comments = newPayment.comments
        oldPayment.paymentRefNum = newPayment.paymentRefNum ?: null
        oldPayment.finAccountTransId = newPayment.finAccountTransId ?: null
        if (!oldPayment.equals(newPayment)) {
            return error(UtilProperties.getResourceBundleMap("AccountingUiLabels", locale)?.AccountingPSUpdateNotAllowedBecauseOfStatus)
        }
    }
    statusIdSave = payment.statusId  // do not allow status change here
    payment.setNonPKFields(parameters)
    payment.statusId = statusIdSave  // do not allow status change here
    payment.effectiveDate = payment.effectiveDate ?: UtilDateTime.nowTimestamp()
    if (payment.paymentMethodId) {
        paymentMethod = from("PaymentMethod").where("paymentMethodId", payment.paymentMethodId).queryOne()
        if (payment.paymentMethodTypeId != paymentMethod.paymentMethodTypeId) {
            logInfo("Replacing passed payment method type [" + parameters.paymentMethodTypeId + "] with payment method type [" +
                paymentMethod.paymentMethodTypeId + "] for payment method [" + parameters.paymentMethodId +"]")
        }
        payment.paymentMethodTypeId = paymentMethod.paymentMethodTypeId
    }
    payment.store()
    if (parameters.statusId) {
        if (parameters.statusId != statusIdSave) {
            Map param = dispatcher.getDispatchContext().makeValidContext('setPaymentStatus', ModelService.IN_PARAM, parameters)
            param.paymentId = payment.paymentId
            serviceResult = run service: 'setPaymentStatus', with: param
            if (!ServiceUtil.isSuccess(serviceResult)) return error(serviceResult)
        }
    }
    return success()
}
def createPaymentAndApplicationForParty() {
    paymentAmount = 0
    List invoiceIds = []
    Map result = success()
    parameters.invoices.each { invoice ->
        if ("INVOICE_READY" == invoice.statusId) {
            Map serviceContext = dispatcher.getDispatchContext().makeValidContext('getInvoicePaymentInfoList', ModelService.IN_PARAM, invoice)
            serviceContext.userLogin = userLogin
            serviceResult = run service: 'getInvoicePaymentInfoList', with: serviceContext
            if (ServiceUtil.isError(serviceResult)) return serviceResult
            invoicePaymentInfo = serviceResult.invoicePaymentInfoList[0]
            paymentAmount += invoicePaymentInfo.outstandingAmount
        } else {
            return error(UtilProperties.getMessage("AccountingUiLabels", "AccountingInvoicesRequiredInReadyStatus", parameters.locale))
        }
    }
    if (paymentAmount > 0) {
        serviceResult = run service: 'getPartyAccountingPreferences', with: parameters
        if (ServiceUtil.isError(serviceResult)) return serviceResult
        partyAcctgPreference = serviceResult.partyAccountingPreference
        Map createPaymentMap = [:]
        createPaymentMap.paymentTypeId = "VENDOR_PAYMENT"
        createPaymentMap.partyIdFrom = parameters.organizationPartyId
        createPaymentMap.currencyUomId = partyAcctgPreference.baseCurrencyUomId
        createPaymentMap.partyIdTo = parameters.partyId
        createPaymentMap.statusId = "PMNT_SENT"
        createPaymentMap.amount = paymentAmount
        createPaymentMap.paymentMethodTypeId = parameters.paymentMethodTypeId
        createPaymentMap.paymentMethodId = parameters.paymentMethodId
        createPaymentMap.paymentRefNum = parameters.checkStartNumber
        createPaymentMap.userLogin = userLogin
        serviceResult = run service: 'createPayment', with: createPaymentMap
        if (ServiceUtil.isError(serviceResult)) return serviceResult
        paymentId = serviceResult.paymentId
        result.paymentId = paymentId

        parameters.invoices.each {invoice ->
        if ("INVOICE_READY" == invoice.statusId) {
            Map serviceContext = dispatcher.getDispatchContext().makeValidContext('getInvoicePaymentInfoList', ModelService.IN_PARAM, invoice)
            serviceContext.userLogin = userLogin
            serviceResult = run service: 'getInvoicePaymentInfoList', with: serviceContext
            if (ServiceUtil.isError(serviceResult)) return serviceResult
            invoicePaymentInfo = serviceResult.invoicePaymentInfoList[0]
            if (invoicePaymentInfo.outstandingAmount > 0) {
                Map createPaymentApplicationMap = [:]
                createPaymentApplicationMap.paymentId =  paymentId
                createPaymentApplicationMap.amountApplied = invoicePaymentInfo.outstandingAmount
                createPaymentApplicationMap.invoiceId = invoice.invoiceId
                serviceResult = run service: 'createPaymentApplication', with: createPaymentApplicationMap
                if (ServiceUtil.isError(serviceResult)) return serviceResult
            }
        }
        invoiceIds.add(invoice.invoiceId)
        }
    }
    result.invoiceIds = invoiceIds
    result.amount =  paymentAmount
    return result
}
def getPaymentRunningTotal(){
    paymentIds = parameters.paymentIds;
    runningTotal = 0;
    payments = from("Payment").where(EntityCondition.makeCondition("paymentId", EntityOperator.IN, paymentIds)).queryList()
    if (payments) {
        for (GenericValue payment : payments) {
            runningTotal = runningTotal + payment.amount;
        }
    }

    if (parameters.organizationPartyId) {
        serviceCtx = [
                organizationPartyId: parameters.organizationPartyId,
                userLogin: userLogin
        ]
        serviceResult = dispatcher.runSync('getPartyAccountingPreferences', serviceCtx);
        partyAcctgPreference = serviceResult.partyAccountingPreference;

        if (partyAcctgPreference.baseCurrencyUomId) {
            currencyUomId = partyAcctgPreference.baseCurrencyUomId;
        } else {
            currencyUomId = UtilProperties.getPropertyValue('general.properties', 'currency.uom.id.default');
        }
    } else  {
        currencyUomId = UtilProperties.getPropertyValue('general.properties', 'currency.uom.id.default');
    }

    paymentRunningTotal = UtilFormatOut.formatCurrency(runningTotal, currencyUomId, locale);

    result = success()
    result.paymentRunningTotal = paymentRunningTotal
    return result
}
def createPaymentContent() {
    GenericValue newEntity = makeValue("PaymentContent")
    newEntity.setPKFields(parameters, true)
    newEntity.setNonPKFields(parameters, true)

    if (!newEntity.fromDate) {
        Timestamp nowTimestamp = UtilDateTime.nowTimestamp()
        newEntity.fromDate  = nowTimestamp
    }
    newEntity.create()

    result = run service: 'updateContent', with: parameters
    if (ServiceUtil.isError(result)) return result

    Map result = success()
    result.contentId = newEntity.contentId
    result.paymentId = newEntity.paymentId
    result.paymentContentTypeId = newEntity.paymentContentTypeId
    return result
}
//TODO: This can be converted into entity-auto with a seca rule for updateContent
def updatePaymentContent() {
    serviceResult = success()
    GenericValue lookupPKMap = makeValue("PaymentContent")
    lookupPKMap.setPKFields(parameters, true)

    GenericValue lookedUpValue = findOne("PaymentContent", lookupPKMap, false)
    if (lookedUpValue) {
        lookedUpValue.setNonPKFields(parameters)
        lookedUpValue.store()
        result = run service: 'updateContent', with: parameters
        if (ServiceUtil.isError(result)) return result
        return serviceResult
    } else {
        return ServiceUtil.returnError("Error getting Payment Content")
    }
}
def massChangePaymentStatus() {
    serviceResult = success()
    Map setPaymentStatusMap = [:]
    parameters.paymentIds.each{ paymentId ->
        setPaymentStatusMap.paymentId = paymentId
        setPaymentStatusMap.statusId = parameters.statusId
        setPaymentStatusMap.userLogin = parameters.userLogin
        result = run service: 'setPaymentStatus', with: setPaymentStatusMap
        if (ServiceUtil.isError(result)) return result
        setPaymentStatusMap.clear()
    }
    return serviceResult
}
def getInvoicePaymentInfoListByDueDateOffset(){

    filteredInvoicePaymentInfoList = []

    Timestamp asOfDate = UtilDateTime.getDayEnd(UtilDateTime.nowTimestamp(), (long) parameters.daysOffset);

    exprList = [EntityCondition.makeCondition("invoiceTypeId", EntityOperator.EQUALS, parameters.invoiceTypeId),
                EntityCondition.makeCondition("statusId", EntityOperator.NOT_EQUAL, "INVOICE_CANCELLED"),
                EntityCondition.makeCondition("statusId", EntityOperator.NOT_EQUAL, "INVOICE_PAID")
    ]
    if (parameters.partyId) {
        exprList.add(EntityCondition.makeCondition("partyId", EntityOperator.EQUALS, parameters.partyId))
    }
    if (parameters.partyIdFrom) {
        exprList.add(EntityCondition.makeCondition("partyIdFrom", EntityOperator.EQUALS, parameters.partyIdFrom))
    }

    condition = EntityCondition.makeCondition(exprList, EntityOperator.AND);

    invoices = from("Invoice").where(condition).orderBy("invoiceDate").queryList();

    if (invoices) {
        for (GenericValue invoice : invoices) {
            getInvoicePaymentInfoListInMap = [:]
            getInvoicePaymentInfoListInMap.put("invoice", invoice);
            getInvoicePaymentInfoListInMap.put("userLogin", userLogin);
            serviceResult = run service: 'getInvoicePaymentInfoList', with: getInvoicePaymentInfoListInMap
            if (ServiceUtil.isError(serviceResult)) return result
            invoicePaymentInfoList = serviceResult.invoicePaymentInfoList;
            if (invoicePaymentInfoList) {
                invoicePaymentInfoList.each { invoicePaymentInfo ->
                    if (invoicePaymentInfo.outstandingAmount.compareTo(BigDecimal.ZERO) > 0 && invoicePaymentInfo.dueDate.before(asOfDate)) {
                        filteredInvoicePaymentInfoList.add(invoicePaymentInfo);
                    }
                }
            }
        }
    }

    result = success()
    result.invoicePaymentInfoList = filteredInvoicePaymentInfoList
    return result
}

def getPaymentGroupReconciliationId() {
    paymentGroupMember = from("PaymentGroupMember").where("paymentGroupId", parameters.paymentGroupId).queryFirst()
    glReconciliationId = null;
    Map result = success()
    if (paymentGroupMember) {
        payment = paymentGroupMember.getRelatedOne('Payment', false)
        finAccountTrans = payment.getRelatedOne('FinAccountTrans', false)
        if (finAccountTrans) {
            glReconciliationId = finAccountTrans.glReconciliationId
        }
    }
    result.glReconciliationId = glReconciliationId
    return result
}

def createPaymentAndApplication() {
    Map result = success()
    Map createPaymentCtx = dispatcher.getDispatchContext().makeValidContext('createPayment', 'IN', parameters)
    Map createPaymentResp = dispatcher.runSync('createPayment', createPaymentCtx)

    if (ServiceUtil.isError(createPaymentResp)) return createPaymentResp

    Map createPaymentApplicationCtx = dispatcher.getDispatchContext().makeValidContext('createPaymentApplication', 'IN', parameters)
    createPaymentApplicationCtx.paymentId = createPaymentResp.paymentId
    createPaymentApplicationCtx.amountApplied = parameters.amount
    Map createPaymentApplicationResp = dispatcher.runSync('createPaymentApplication', createPaymentApplicationCtx)

    if (ServiceUtil.isError(createPaymentApplicationResp)) return createPaymentApplicationResp

    result.put("paymentId", createPaymentResp.paymentId)
    result.put("paymentApplicationId", createPaymentApplicationResp.paymentApplicationId)
    return result

}

def createFinAccoutnTransFromPayment() {
    serviceResult = success()
    Map createFinAccountTransMap = dispatcher.getDispatchContext().makeValidContext('setPaymentStatus', ModelService.IN_PARAM, parameters)
    createFinAccountTransMap.finAccountTransTypeId = 'WITHDRAWAL'
    createFinAccountTransMap.partyId  = parameters.organizationPartyId
    createFinAccountTransMap.transactionDate = UtilDateTime.nowTimestamp()
    createFinAccountTransMap.entryDate = UtilDateTime.nowTimestamp()
    createFinAccountTransMap.statusId = 'FINACT_TRNS_CREATED'
    createFinAccountTransMap.comments = "Pay to ${parameters.partyId} for invoice Ids - ${parameters.invoiceIds}"
    result = run service: 'createFinAccountTrans', with: createFinAccountTransMap
    if (ServiceUtil.isError(result)) {
        return ServiceUtil.returnError(ServiceUtil.getErrorMessage(result))
    }
    Map updatePaymentMap = [:]
    updatePaymentMap.finAccountTransId = result.finAccountTransId
    updatePaymentMap.paymentId = parameters.paymentId
    result = run service: 'updatePayment', with: updatePaymentMap
    if (ServiceUtil.isError(result)) {
        return ServiceUtil.returnError(ServiceUtil.getErrorMessage(result))
    }
    return serviceResult
}

def quickSendPayment() {
    Map result = success()
    Map updatePaymentCtx = dispatcher.getDispatchContext().makeValidContext('updatePayment', 'IN', parameters)
    Map updatePaymentResp = dispatcher.runSync('updatePayment', updatePaymentCtx)

    if (ServiceUtil.isError(updatePaymentResp)) return updatePaymentResp

    Map setPaymentStatusCtx = dispatcher.getDispatchContext().makeValidContext('setPaymentStatus', 'IN', parameters)
    setPaymentStatusCtx.statusId = "PMNT_SENT"
    Map setPaymentStatusResp = dispatcher.runSync('setPaymentStatus', setPaymentStatusCtx)

    if (ServiceUtil.isError(setPaymentStatusResp)) return setPaymentStatusResp

    return result

}

/**
 * Service to cancel payment batch
 */
def cancelPaymentBatch() {
    List<GenericValue> paymentGroupMemberAndTransList = from("PmtGrpMembrPaymentAndFinAcctTrans").where("paymentGroupId", parameters.paymentGroupId).queryList()

    if (paymentGroupMemberAndTransList) {
        GenericValue paymentGroupMemberAndTrans = EntityUtil.getFirst(paymentGroupMemberAndTransList)
        if ("FINACT_TRNS_APPROVED" == paymentGroupMemberAndTrans.finAccountTransStatusId) {
            return error(UtilProperties.getMessage('AccountingErrorUiLabels', 'AccountingTransactionIsAlreadyReconciled', locale))
        }

        for (GenericValue paymentGroupMember : paymentGroupMemberAndTransList) {
            Map expirePaymentGroupMemberMap = dispatcher.getDispatchContext().makeValidContext("expirePaymentGroupMember", "IN", paymentGroupMember)
            result = runService("expirePaymentGroupMember", expirePaymentGroupMemberMap)
            if (ServiceUtil.isError(result)) return result

            GenericValue finAccountTrans = from("FinAccountTrans").where("finAccountTransId", paymentGroupMember.finAccountTransId).queryOne()
            if (finAccountTrans) {
                Map setFinAccountTransStatusMap = dispatcher.getDispatchContext().makeValidContext("setFinAccountTransStatus", "IN", finAccountTrans)
                setFinAccountTransStatusMap.statusId = "FINACT_TRNS_CANCELED"
                result = runService("setFinAccountTransStatus", setFinAccountTransStatusMap)
                if (ServiceUtil.isError(result)) return result
            }
        }
    }
}

def getPayments() {
    payments = []
    if (parameters.paymentGroupId) {
        paymentGroupMembers = from("PaymentGroupMember").where("paymentGroupId", parameters.paymentGroupId).filterByDate().queryList()
        if (paymentGroupMembers) {
            paymentIds = EntityUtil.getFieldListFromEntityList(paymentGroupMembers, "paymentId", true)
            payments = from("Payment").where(EntityCondition.makeCondition("paymentId", EntityOperator.IN, paymentIds)).queryList()
        }
    }
    if (parameters.finAccountTransId) {
        payments = from("Payment").where("finAccountTransId", parameters.finAccountTransId).queryList()
    }
    result = success()
    result.payments = payments
    return result
}

def cancelCheckRunPayments() {
    paymentGroupMemberAndTransList = from("PmtGrpMembrPaymentAndFinAcctTrans").where("paymentGroupId", parameters.paymentGroupId).queryList()
    if (paymentGroupMemberAndTransList) {
        paymentGroupMemberAndTrans = EntityUtil.getFirst(paymentGroupMemberAndTransList)
        if ("FINACT_TRNS_APPROVED" != paymentGroupMemberAndTrans.finAccountTransStatusId) {
            for (GenericValue paymentGroupMemberAndTrans : paymentGroupMemberAndTransList) {
                payment = from("Payment").where("paymentId", paymentGroupMemberAndTrans.paymentId).queryOne()
                Map voidPaymentMap = dispatcher.getDispatchContext().makeValidContext("voidPayment", "IN", payment)
                result = runService("voidPayment", voidPaymentMap)
                if (ServiceUtil.isError(result)) return result
                Map expirePaymentGroupMemberMap = dispatcher.getDispatchContext().makeValidContext("expirePaymentGroupMember", "IN", paymentGroupMemberAndTrans)
                result = runService("expirePaymentGroupMember", expirePaymentGroupMemberMap)
                if (ServiceUtil.isError(result)) return result
            }
        } else {
            return error(UtilProperties.getMessage("AccountingErrorUiLabels", "AccountingCheckIsAlreadyIssued", locale))
        }
    }
    return success()
}