OFBiz › OFBiz - Commits

[ofbiz-framework] branch trunk updated: Improved: Convert CostService.xml minilang to groovy

_‹ Previous Topic Next Topic _›

Classic

List

Threaded

1 message

danwatford

[ofbiz-framework] branch trunk updated: Improved: Convert CostService.xml minilang to groovy

This is an automated email from the ASF dual-hosted git repository.

danwatford pushed a commit to branch trunk
in repository https://gitbox.apache.org/repos/asf/ofbiz-framework.git

The following commit(s) were added to refs/heads/trunk by this push:
new 8a96462 Improved: Convert CostService.xml minilang to groovy
8a96462 is described below

commit 8a964625385a2fa097679446c5d6435265eb50b0
Author: SebastianEcomify <[hidden email]>
AuthorDate: Sun Feb 21 12:38:21 2021 +0100

Improved: Convert CostService.xml minilang to groovy

(OFBIZ-11595)

Thanks: Sebastian Berg for implementation
---
.../accounting/config/arithmetic.properties | 1 +
.../accounting/servicedef/services_cost.xml | 8 +-
.../groovyScripts/product/cost/CostServices.groovy | 512 +++++++++++++++++
.../product/minilang/product/cost/CostServices.xml | 613 ---------------------
applications/product/servicedef/services_cost.xml | 32 +-
5 files changed, 533 insertions(+), 633 deletions(-)

diff --git a/applications/accounting/config/arithmetic.properties b/applications/accounting/config/arithmetic.properties
index 5dea2b2..567ea63 100644
--- a/applications/accounting/config/arithmetic.properties
+++ b/applications/accounting/config/arithmetic.properties
@@ -41,6 +41,7 @@ order.rounding = ROUND_HALF_UP
finaccount.decimals = 2
finaccount.rounding = ROUND_HALF_UP
finaccount.roundingSimpleMethod = HalfUp
+finaccount.roundingGroovyMethod = HALF_UP

# Most companies would want their sales tax calculations ALWAYS to round up (ie, 100.081 becomes 100.09)
# This could be ROUND_CEILING or ROUND_UP. (The difference is that ROUND_CEILING rounds towards positive infinity,
diff --git a/applications/accounting/servicedef/services_cost.xml b/applications/accounting/servicedef/services_cost.xml
index 00ba413..ef02a17 100644
--- a/applications/accounting/servicedef/services_cost.xml
+++ b/applications/accounting/servicedef/services_cost.xml
@@ -81,8 +81,8 @@ under the License.
<auto-attributes include="pk" mode="IN" optional="false"/>
</service>

- <service name="updateProductAverageCostOnReceiveInventory" default-entity-name="ProductAverageCost" engine="simple"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="updateProductAverageCostOnReceiveInventory" auth="true">
+ <service name="updateProductAverageCostOnReceiveInventory" default-entity-name="ProductAverageCost" engine="groovy"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="updateProductAverageCostOnReceiveInventory" auth="true">
<description>Update a Product Average Cost record on receive inventory</description>
<permission-service service-name="acctgCostPermissionCheck" main-action="UPDATE"/>
<attribute name="facilityId" type="String" mode="IN" optional="false"/>
@@ -91,8 +91,8 @@ under the License.
<attribute name="inventoryItemId" type="String" mode="IN" optional="false"/>
</service>

- <service name="getProductAverageCost" engine="simple"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="getProductAverageCost" auth="true">
+ <service name="getProductAverageCost" engine="groovy"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="getProductAverageCost" auth="true">
<description>Get Average cost of a product</description>
<attribute name="inventoryItem" type="org.apache.ofbiz.entity.GenericValue" mode="IN" optional="true"/>
<attribute name="unitCost" type="BigDecimal" mode="OUT" optional="false"/>
diff --git a/applications/product/groovyScripts/product/cost/CostServices.groovy b/applications/product/groovyScripts/product/cost/CostServices.groovy
new file mode 100644
index 0000000..53a9b4f
--- /dev/null
+++ b/applications/product/groovyScripts/product/cost/CostServices.groovy
@@ -0,0 +1,512 @@
+/*
+ * 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 java.math.RoundingMode
+
+import org.apache.ofbiz.base.util.UtilDateTime
+import org.apache.ofbiz.base.util.UtilProperties
+import org.apache.ofbiz.entity.GenericValue
+import org.apache.ofbiz.entity.condition.EntityCondition
+import org.apache.ofbiz.entity.condition.EntityOperator
+import org.apache.ofbiz.entity.util.EntityUtil
+import org.apache.ofbiz.service.ServiceUtil
+
+
+/**
+ * Cancels CostComponents
+ * @return
+ */
+def cancelCostComponents() {
+ Map costsAndMap = [:]
+ if (parameters.costComponentId) {
+ costsAndMap.costComponentId = parameters.costComponentId
+ }
+ if (parameters.productId) {
+ costsAndMap.productId = parameters.productId
+ }
+ if (parameters.costUomId) {
+ costsAndMap.costUomId = parameters.costUomId
+ }
+ if (parameters.costComponentTypeId) {
+ costsAndMap.costComponentTypeId = parameters.costComponentTypeId
+ }
+ List existingCosts = from("CostComponent").where(costsAndMap).filterByDate().queryList()
+ for (GenericValue existingCost : existingCosts) {
+ existingCost.thruDate = UtilDateTime.nowTimestamp()
+ existingCost.store()
+ }
+ return success()
+}
+
+/**
+ * Create a CostComponent and cancel the existing ones
+ * @return
+ */
+def recreateCostComponent() {
+ Map result = success()
+ // The existing costs of the same type are expired
+ Map costsAndMap = [:]
+ if (parameters.productId) {
+ costsAndMap.productId = parameters.productId
+ }
+ if (parameters.costUomId) {
+ costsAndMap.costUomId = parameters.costUomId
+ }
+ if (parameters.costComponentTypeId) {
+ costsAndMap.costComponentTypeId = parameters.costComponentTypeId
+ }
+ List existingCosts = from("CostComponent").where(costsAndMap).filterByDate().queryList()
+ for (GenericValue existingCost : existingCosts) {
+ existingCost.thruDate = UtilDateTime.nowTimestamp()
+ existingCost.store()
+ }
+ // The new cost is created
+ GenericValue newEntity = makeValue("CostComponent")
+ newEntity.setNonPKFields(parameters)
+ newEntity.costComponentId = delegator.getNextSeqId("CostComponent")
+ if (!newEntity.fromDate) {
+ newEntity.fromDate = UtilDateTime.nowTimestamp()
+ }
+ newEntity.create()
+ result.costComponentId = newEntity.costComponentId
+ return result
+}
+
+// Services to get the product and tasks costs
+
+/**
+ * Gets the product's costs (from CostComponent or ProductPrice)
+ * @return
+ */
+def getProductCost() {
+ Map result = success()
+ Map inputMap
+ String inputString = "${parameters.costComponentTypePrefix}_%"
+ EntityCondition condition = EntityCondition.makeCondition(
+ EntityCondition.makeCondition("productId", parameters.productId),
+ EntityCondition.makeCondition("costUomId", parameters.currencyUomId),
+ EntityCondition.makeCondition("costComponentTypeId", EntityOperator.LIKE , inputString)
+ )
+ List costComponents = from("CostComponent").where(condition).filterByDate().queryList()
+ BigDecimal productCost = (BigDecimal) 0
+ for (GenericValue costComponent : costComponents) {
+ productCost += costComponent.cost
+ // set field="productCost" value="${costComponent.cost + productCost}" type="BigDecimal"/
+ }
+ productCost = productCost.setScale(6)
+ // if the cost is zero, and the product is a variant, get the cost of the virtual
+ if (productCost == (BigDecimal) 0) {
+ GenericValue product = from("Product").where(parameters).queryOne()
+ Map assocAndMap = [productIdTo: product.productId, productAssocTypeId: "PRODUCT_VARIANT"]
+ GenericValue virtualAssoc = from("ProductAssoc").where(assocAndMap).filterByDate().queryFirst()
+ if (virtualAssoc) {
+ inputMap = [productId: virtualAssoc.productId, currencyUomId: parameters.currencyUomId, costComponentTypePrefix: parameters.costComponentTypePrefix]
+ Map serviceResult = run service: "getProductCost", with: inputMap
+ productCost = serviceResult.productCost
+ }
+ }
+ // if the cost is zero, get the purchase cost from the SupplierProduct
+ if (productCost == (BigDecimal) 0) {
+ List orderByList = [
+ "+supplierPrefOrderId",
+ "+lastPrice"
+ ]
+ Map costsAndMap = [productId: parameters.productId, currencyUomId: parameters.currencyUomId]
+ List priceCosts = from("SupplierProduct").where(costsAndMap).orderBy(orderByList).queryList()
+ priceCosts = EntityUtil.filterByDate(priceCosts, UtilDateTime.nowTimestamp(), "availableFromDate", "availableThruDate", true)
+ if (priceCosts) {
+ GenericValue priceCost = priceCosts.get(0)
+ if (priceCost.lastPrice) {
+ productCost = priceCost.lastPrice
+ }
+ }
+ // if the cost is zero, get the purchase cost from the SupplierProduct in a different currency and try to convert
+ if (productCost == (BigDecimal) 0) {
+ costsAndMap = [productId: parameters.productId]
+ priceCosts = from("SupplierProduct").where(costsAndMap).orderBy(orderByList).queryList()
+ priceCosts = EntityUtil.filterByDate(priceCosts, UtilDateTime.nowTimestamp(), "avalableFromDate", "availableThruDate", true)
+ if (priceCosts) {
+ GenericValue priceCost = priceCosts.get(0)
+ if (priceCost.lastPrice) {
+ // we try to convert the lastPrice to the desired currency
+ inputMap = [originalValue: priceCost.lastPrice, uomId: priceCost.currencyUomId, uomIdTo: parameters.currencyUomId]
+ Map serviceResultCU
+ try {
+ serviceResultCU = dispatcher.runSync("convertUom", inputMap, 7200, true)
+ } catch (Exception e) {
+ serviceResultCU = ServiceUtil.returnError(e.toString())
+ }
+ productCost = serviceResultCU.convertedValue
+ // if currency conversion fails then a 0 cost will be returned
+ if (!productCost) {
+ logWarning("Currency conversion failed for ProductCost lookup; unable to convert from ${priceCost.currencyUomId} to ${parameters.currencyUomId}")
+ productCost = (BigDecimal) 0
+ }
+ }
+ }
+ }
+ }
+ // <if-compare field="productCost" operator="equals" value="0" type="BigDecimal">
+ // <clear-field field="costsAndMap"/>
+ // <set from-field="parameters.productId" field="costsAndMap.productId"/>
+ // <set from-field="parameters.currencyUomId" field="costsAndMap.currencyUomId"/>
+ // <set from-field="parameters.productPriceTypeId" field="costsAndMap.productPriceTypeId"/>
+ // <find-by-and entity-name="ProductPrice" map="costsAndMap" list="priceCosts"/>
+ // <filter-list-by-date list="priceCosts"/>
+ // <first-from-list list="priceCosts" entry="priceCost"/>
+ // <if-not-empty field="priceCost.price">
+ // <set from-field="priceCost.price" field="productCost"/>
+ // </if-not-empty>
+ // </if-compare>
+ result.productCost = productCost
+ return result
+}
+
+/**
+ * Gets the production run task's costs
+ * @return
+ */
+def getTaskCost() {
+ Map result = success()
+ Map costsByType = [:]
+ GenericValue setupCost
+ GenericValue usageCost
+ // First of all, the estimated task time is computed
+ Map inputMap = parameters
+ inputMap.taskId = parameters.workEffortId
+ Map serviceResult = run service: "getEstimatedTaskTime", with: inputMap
+ Long totalEstimatedTaskTime = serviceResult.estimatedTaskTime
+ BigDecimal setupTime = serviceResult.setupTime
+ BigDecimal estimatedTaskTime = totalEstimatedTaskTime - setupTime
+ estimatedTaskTime = estimatedTaskTime.setScale(6)
+
+ GenericValue task = from("WorkEffort").where(parameters).queryOne()
+ if (task) {
+ GenericValue fixedAsset = delegator.getRelatedOne("FixedAsset", task, false)
+ Map costsAndMap = [amountUomId: parameters.currencyUomId, fixedAssetStdCostTypeId: "SETUP_COST"]
+ List setupCosts = delegator.getRelated("FixedAssetStdCost", costsAndMap, null, fixedAsset, false)
+ setupCosts = EntityUtil.filterByDate(setupCosts)
+ // <filter-list-by-and list-name="costs" map-name="costsAndMap"/>
+ setupCost = setupCosts.get(0)
+ costsAndMap.fixedAssetStdCostTypeId = "USAGE_COST"
+ List usageCosts = delegator.getRelated("FixedAssetStdCost", costsAndMap, null, fixedAsset, false)
+ usageCosts = EntityUtil.filterByDate(usageCosts)
+ usageCost = usageCosts.get(0)
+ }
+ BigDecimal taskCost = (estimatedTaskTime * (usageCost ? usageCost.amount : 0)) + (setupTime * (setupCost ? setupCost.amount : 0))
+ taskCost = taskCost.setScale(6)
+
+ // Time is converted from milliseconds to hours
+ taskCost /= 3600000
+ taskCost = taskCost.setScale(6)
+
+ // Now compute the costs derived from CostComponentCalc records associated with the task
+ List weccs = delegator.getRelated("WorkEffortCostCalc", null, null, task, false)
+ weccs = EntityUtil.filterByDate(weccs)
+ for (GenericValue wecc : weccs) {
+ GenericValue costComponentCalc = delegator.getRelatedOne("CostComponentCalc", wecc, false)
+ GenericValue customMethod = delegator.getRelatedOne("CustomMethod", costComponentCalc, false)
+ if (!customMethod) {
+ if (costComponentCalc.perMilliSecond) {
+ if (costComponentCalc.perMilliSecond != (BigDecimal) 0) {
+ BigDecimal totalCostComponentTime = totalEstimatedTaskTime / costComponentCalc.perMilliSecond
+ totalCostComponentTime = totalCostComponentTime.setScale(6)
+ BigDecimal totalCostComponentCost = totalCostComponentTime * costComponentCalc.variableCost
+ totalCostComponentCost += costComponentCalc.fixedCost
+ totalCostComponentCost = totalCostComponentCost.setScale(6)
+ costsByType."${wecc.costComponentTypeId}" = totalCostComponentCost
+ }
+ }
+ } else {
+ // FIXME: formulas are still not supported for standard costs
+ }
+ }
+ result.taskCost = taskCost
+ result.costsByType = costsByType
+ return result
+}
+
+// services to automatically generate cost information
+
+/**
+ * Calculates estimated costs for all the products
+ * @return
+ */
+def calculateAllProductsCosts() {
+ // filter-by-date="true"
+ List products = from("Product").orderBy("-billOfMaterialLevel").select("productId").queryList()
+ Map inMap = [currencyUomId: parameters.currencyUomId, costComponentTypePrefix: parameters.costComponentTypePrefix]
+ for (GenericValue product : products) {
+ inMap.productId = product.productId
+ run service: "calculateProductCosts", with: inMap
+ }
+ return success()
+}
+
+/**
+ * Calculates the product's cost
+ * @return
+ */
+def calculateProductCosts() {
+ Map result = success()
+ Map totalCostsByType = [:]
+ BigDecimal totalProductCost = (BigDecimal) 0
+ BigDecimal totalTaskCost = (BigDecimal) 0
+ BigDecimal totalOtherTaskCost = (BigDecimal) 0
+ // the existing costs are expired
+ Map cancelMap = [costComponentTypeId: (String) "${parameters.costComponentTypePrefix}_ROUTE_COST", productId: parameters.productId, costUomId: parameters.currencyUomId]
+ run service: "cancelCostComponents", with: cancelMap
+ cancelMap.costComponentTypeId = (String) "${parameters.costComponentTypePrefix}_MAT_COST"
+ run service: "cancelCostComponents", with: cancelMap
+ // calculate the total materials' cost
+ Map callSvcMap = [productId: parameters.productId]
+ Map serviceResult = run service: "getManufacturingComponents", with: callSvcMap
+ List componentsMap = serviceResult.componentsMap
+ if (componentsMap) {
+ for (Map componentMap : componentsMap) {
+ GenericValue product = componentMap.product
+ Map inputMap = [productId: product.productId, currencyUomId: parameters.currencyUomId, costComponentTypePrefix: parameters.costComponentTypePrefix]
+ Map serviceResultGPC = run service: "getProductCost", with: inputMap
+ BigDecimal productCost = serviceResultGPC.productCost
+ totalProductCost += componentMap.quantity * productCost
+ totalProductCost = totalProductCost.setScale(6)
+ }
+ } else {
+ Map inputMap = [productId: parameters.productId, currencyUomId: parameters.currencyUomId, costComponentTypePrefix: parameters.costComponentTypePrefix]
+ Map serviceResultGPC = run service: "getProductCost", with: inputMap
+ BigDecimal productCost = serviceResultGPC.productCost
+ totalProductCost += productCost
+ totalProductCost = totalProductCost.setScale(6)
+ }
+ // calculate the total tasks' cost
+ callSvcMap.ignoreDefaultRouting = "Y"
+ Map serviceResultGPR = run service: "getProductRouting", with: callSvcMap
+ List tasks = serviceResultGPR.tasks
+ GenericValue routing = serviceResultGPR.routing
+ for (GenericValue task : tasks) {
+ callSvcMap = [workEffortId: task.workEffortIdTo, currencyUomId: parameters.currencyUomId, productId: parameters.productId, routingId: routing.workEffortId]
+ Map serviceResultGTC = run service: "getTaskCost", with: callSvcMap
+ BigDecimal taskCost = serviceResultGTC.taskCost
+ Map costsByType = serviceResultGTC.costsByType
+ totalTaskCost += taskCost
+ totalTaskCost = totalTaskCost.setScale(6)
+ for (Map.Entry entry : costsByType.entrySet()) {
+ if (totalCostsByType."${entry.key}") {
+ totalCostsByType."${entry.key}" = entry.value + totalCostByType."${entry.key}"
+ } else {
+ totalCostsByType."${entry.key}" = entry.value
+ }
+ totalOtherTaskCost += entry.value
+ totalOtherTaskCost = totalOtherTaskCost.setScale(6)
+ totalCostsByType."${entry.key}" = (totalCostsByType."${entry.key}").setScale(6)
+ }
+ }
+ BigDecimal totalCost = totalTaskCost + totalProductCost + totalOtherTaskCost
+ totalCost = totalCost.setScale(6)
+
+ // The CostComponent records are created.
+ if (totalTaskCost > (BigDecimal) 0) {
+ callSvcMap = [costComponentTypeId: (String) "${parameters.costComponentTypePrefix}_ROUTE_COST", productId: parameters.productId, costUomId: parameters.currencyUomId, cost: totalTaskCost]
+ run service: "recreateCostComponent", with: callSvcMap
+ }
+ if (totalProductCost > (BigDecimal) 0) {
+ callSvcMap = [costComponentTypeId: (String) "${parameters.costComponentTypePrefix}_MAT_COST", productId: parameters.productId, costUomId: parameters.currencyUomId, cost: totalProductCost]
+ run service: "recreateCostComponent", with: callSvcMap
+ }
+ for (Map.Entry entry : totalCostsByType.entrySet()) {
+ String costType = entry.getKey()
+ BigDecimal totalCostAmount = entry.getValue()
+ callSvcMap = [costComponentTypeId: "${parameters.costComponentTypePrefix}_${costType}", productId: parameters.productId, costUomId: parameters.currencyUomId, cost: totalCostAmount]
+ run service: "recreateCostComponent", with: callSvcMap
+ }
+ // Now compute the costs derived from CostComponentCalc records associated with the product
+ List productCostComponentCalcs = from("ProductCostComponentCalc").where(productId: parameters.productId).filterByDate().orderBy("sequenceNum").queryList()
+ for (GenericValue productCostComponentCalc : productCostComponentCalcs) {
+ GenericValue costComponentCalc = delegator.getRelatedOne("CostComponentCalc", productCostComponentCalc, false)
+ GenericValue customMethod = delegator.getRelatedOne("CustomMethod", costComponentCalc, false)
+ if (!customMethod) {
+ // TODO: not supported for CostComponentCalc entries directly associated to a product
+ logWarning("Unable to create cost component for cost component calc with id [${costComponentCalc.costComponentCalcId}] because customMethod is not set")
+ } else {
+ Map customMethodParameters = [productCostComponentCalc: productCostComponentCalc, costComponentCalc: costComponentCalc, currencyUomId: parameters.currencyUomId, costComponentTypePrefix: parameters.costComponentTypePrefix, baseCost: totalCost]
+ Map serviceResultCM = run service: "${customMethod.customMethodName}", with: customMethodParameters
+ BigDecimal productCostAdjustment = serviceResultCM.productCostAdjustment
+ callSvcMap = [costComponentTypeId: (String) "${parameters.costComponentTypePrefix}_${productCostComponentCalc.costComponentTypeId}", productId: productCostComponentCalc.productId, costUomId: parameters.currencyUomId, cost: productCostAdjustment]
+ run service: "recreateCostComponent", with: callSvcMap
+ // set field="totalCost" value="${totalCost + productCostAdjustment}" type="BigDecimal"/
+ totalCost += productCostAdjustment
+ totalCost = totalCost.setScale(6)
+ }
+ }
+ result.totalCost = totalCost
+ return result
+}
+
+/**
+ * Calculate inventory average cost for a product
+ * @return
+ */
+def calculateProductAverageCost() {
+ Map result = success()
+ EntityCondition condition = EntityCondition.makeCondition(
+ EntityCondition.makeCondition("productId", parameters.productId),
+ EntityCondition.makeCondition("unitCost", EntityOperator.NOT_EQUAL, null)
+ )
+ if (parameters.facilityId) {
+ condition = EntityCondition.makeCondition(condition, EntityCondition.makeCondition("facilityId", parameters.facilityId))
+ }
+ if (parameters.ownerPartyId) {
+ condition = EntityCondition.makeCondition(condition, EntityCondition.makeCondition("ownerPartyId", parameters.ownerPartyId))
+ }
+
+ List inventoryItems = from("InventoryItem").where(condition).select("quantityOnHandTotal", "unitCost", "currencyUomId").queryList()
+ BigDecimal totalQuantityOnHand = (BigDecimal) 0
+ BigDecimal totalInventoryCost = (BigDecimal) 0
+ BigDecimal absValOfTotalQOH = (BigDecimal) 0
+ BigDecimal absValOfTotalInvCost = (BigDecimal) 0
+ Boolean differentCurrencies = false
+ String currencyUomId
+ for (GenericValue inventoryItem : inventoryItems) {
+ totalQuantityOnHand += inventoryItem.quantityOnHandTotal
+ if (!currencyUomId) {
+ currencyUomId = inventoryItem.currencyUomId
+ }
+ if (!differentCurrencies) {
+ if (currencyUomId == inventoryItem.currencyUomId) {
+ totalInventoryCost += (inventoryItem.unitCost * inventoryItem.quantityOnHandTotal)
+
+ // calculation of absolute values of QOH and total inventory cost
+ if (inventoryItem.quantityOnHandTotal < (BigDecimal) 0) {
+ absValOfTotalQOH = absValOfTotalQOH - inventoryItem.quantityOnHandTotal
+ absValOfTotalInvCost = absValOfTotalInvCost + (-1 * inventoryItem.quantityOnHandTotal * inventoryItem.unitCost)
+ } else {
+ absValOfTotalQOH += inventoryItem.quantityOnHandTotal
+ absValOfTotalInvCost = absValOfTotalInvCost + (inventoryItem.quantityOnHandTotal * inventoryItem.unitCost)
+ }
+ } else {
+ differentCurrencies = true
+ }
+ }
+ }
+ BigDecimal productAverageCost = (BigDecimal) 0
+ if (absValOfTotalQOH != (BigDecimal) 0) {
+ productAverageCost = absValOfTotalInvCost / absValOfTotalQOH
+ }
+ result.totalQuantityOnHand = totalQuantityOnHand.setScale(2, RoundingMode.HALF_EVEN)
+ if (!differentCurrencies) {
+ result.totalInventoryCost = totalInventoryCost.setScale(2, RoundingMode.HALF_EVEN)
+ result.productAverageCost = productAverageCost.setScale(2, RoundingMode.HALF_EVEN)
+ result.currencyUomId = currencyUomId
+ }
+ return result
+}
+
+/**
+ * Update a Product Average Cost record on receive inventory
+ * @return
+ */
+def updateProductAverageCostOnReceiveInventory() {
+ GenericValue inventoryItem = from("InventoryItem").where(parameters).queryOne()
+ String organizationPartyId = inventoryItem?.ownerPartyId
+ if (!organizationPartyId) {
+ GenericValue facility = from("Facility").where(parameters).queryOne()
+ organizationPartyId = facility?.ownerPartyId
+ if (!organizationPartyId) {
+ GenericValue productStore = delegator.getRelatedOne("ProductStore", facility, false)
+ organizationPartyId = productStore?.ownerPartyId
+ if (!organizationPartyId) {
+ String errorMessage = UtilProperties.getMessage("ProductUiLabels", "ProductOwnerPartyIsMissing", locale)
+ logError(errorMessage)
+ return error(errorMessage)
+ }
+ }
+ }
+ GenericValue productAverageCost = from("ProductAverageCost").where(productId: parameters.productId, facilityId: parameters.facilityId, productAverageCostTypeId: "SIMPLE_AVG_COST", organizationPartyId: organizationPartyId).filterByDate().queryFirst()
+ // <log level="always" message="In updateProductAverageCostOnReceiveInventory found productAverageCost: ${productAverageCost}"/>
+ Map productAverageCostMap = parameters
+ productAverageCostMap.productAverageCostTypeId = "SIMPLE_AVG_COST"
+ productAverageCostMap.organizationPartyId = organizationPartyId
+ Map updateProductAverageCostMap = [:]
+ if (!productAverageCost) {
+ productAverageCostMap.averageCost = inventoryItem.unitCost
+ } else {
+ // Expire existing one and calculate average cost
+ updateProductAverageCostMap << productAverageCost
+ updateProductAverageCostMap.thurDate = UtilDateTime.nowTimestamp()
+ run service: "updateProductAverageCost", with: updateProductAverageCostMap
+
+ Map serviceInMap = [productId: parameters.productId, facilityId: parameters.facilityId]
+ Map serviceResultGIABF = run service: "getInventoryAvailableByFacility", with: serviceInMap
+ BigDecimal quantityOnHandTotal = serviceResultGIABF.quantityOnHandTotal
+ BigDecimal oldProductQuantity = quantityOnHandTotal - parameters.quantityAccepted
+ BigDecimal averageCost = ((productAverageCost.averageCost * oldProductQuantity) + (inventoryItem.unitCost * parameters.quantityAccepted))/(quantityOnHandTotal)
+ int roundingDecimal = UtilProperties.getPropertyAsInteger("arithmetic", "finaccout.decimals", 2)
+ String roundingMode = UtilProperties.getPropertyValue("arithmetic", "finaccount.roundingGroovyMethod", "HALF_UP")
+ averageCost = averageCost.setScale(roundingDecimal, RoundingMode."${roundingMode}")
+ productAverageCostMap.averageCost = averageCost
+ productAverageCostMap.fromDate = UtilDateTime.nowTimestamp()
+ }
+ // <log level="info" message="In updateProductAverageCostOnReceiveInventory creating new average cost with productAverageCostMap: ${productAverageCostMap}"/>
+ run service: "createProductAverageCost", with: productAverageCostMap
+ logInfo("For facilityId ${parameters.facilityId}, Average cost of product ${parameters.productId} is set from ${updateProductAverageCostMap.averageCost} to ${productAverageCostMap.averageCost}")
+ return success()
+}
+
+// Service to get the average cost of product
+def getProductAverageCost() {
+ Map result = success()
+ GenericValue productAverageCost
+ BigDecimal unitCost
+ GenericValue inventoryItem = parameters.inventoryItem
+ Map getPartyAcctgPrefMap = [organizationPartyId: inventoryItem.ownerPartyId]
+ Map serviceResult = run service: "getPartyAccountingPreferences", with: getPartyAcctgPrefMap
+ GenericValue partyAccountingPreference = serviceResult.partyAccountingPreference
+ if (partyAccountingPreference.cogsMethodId == "COGS_AVG_COST") {
+ // TODO: handle productAverageCostTypeId for WEIGHTED_AVG_COST and MOVING_AVG_COST
+ productAverageCost = from("ProductAverageCost")
+ .where(productAverageCostTypeId: "SIMPLE_AVG_COST", organizationPartyId: inventoryItem.ownerPartyId, productId: inventoryItem.productId, facilityId: inventoryItem.facilityId)
+ .filterByDate()
+ .queryFirst()
+ }
+ if (productAverageCost) {
+ unitCost = productAverageCost.averageCost
+ } else {
+ unitCost = inventoryItem.unitCost
+ }
+ result.unitCost = unitCost
+ return result
+}
+
+/**
+ * Formula that creates a cost component equal to a percentage of total product cost
+ * @return
+ */
+def productCostPercentageFormula() {
+ Map result = success()
+ GenericValue productCostComponentCalc = parameters.productCostComponentCalc
+ GenericValue costComponentCalc = parameters.costComponentCalc
+ Map inputMap = [productId: productCostComponentCalc.productId, currencyUomId: parameters.currencyUomId, costComponentTypePrefix: parameters.costComponentTypePrefix]
+ Map serviceResult = run service: "getProductCost", with: inputMap
+ BigDecimal productCost = serviceResult.productCost
+ // set field="productCostAdjustment" value="${parameters.baseCost * costComponentCalc.fixedCost}" type="BigDecimal"/
+ BigDecimal productCostAdjustment = costComponentCalc.fixedCost * parameters.baseCost
+ productCostAdjustment = productCostAdjustment.setScale(6)
+ result.productCostAdjustment = productCostAdjustment
+ return result
+}
diff --git a/applications/product/minilang/product/cost/CostServices.xml b/applications/product/minilang/product/cost/CostServices.xml
deleted file mode 100644
index 7951f18..0000000
--- a/applications/product/minilang/product/cost/CostServices.xml
+++ /dev/null
@@ -1,613 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-
-
-<simple-methods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xmlns="http://ofbiz.apache.org/Simple-Method" xsi:schemaLocation="http://ofbiz.apache.org/Simple-Method http://ofbiz.apache.org/dtds/simple-methods.xsd">
- 
- <simple-method method-name="cancelCostComponents" short-description="Cancels CostComponents">
- <set from-field="parameters.costComponentId" field="costsAndMap.costComponentId"/>
- <set from-field="parameters.productId" field="costsAndMap.productId"/>
- <set from-field="parameters.costUomId" field="costsAndMap.costUomId"/>
- <set from-field="parameters.costComponentTypeId" field="costsAndMap.costComponentTypeId"/>
- <find-by-and entity-name="CostComponent" map="costsAndMap" list="existingCosts"/>
- <filter-list-by-date list="existingCosts"/>
- <iterate list="existingCosts" entry="existingCost">
- <now-timestamp field="existingCost.thruDate"/>
- <store-value value-field="existingCost"/>
- </iterate>
- </simple-method>
- <simple-method method-name="recreateCostComponent" short-description="Create a CostComponent and cancel the existing ones">
- 
- <set from-field="parameters.productId" field="costsAndMap.productId"/>
- <set from-field="parameters.costUomId" field="costsAndMap.costUomId"/>
- <set from-field="parameters.costComponentTypeId" field="costsAndMap.costComponentTypeId"/>
- <find-by-and entity-name="CostComponent" map="costsAndMap" list="existingCosts"/>
- <filter-list-by-date list="existingCosts"/>
- <iterate list="existingCosts" entry="existingCost">
- <now-timestamp field="existingCost.thruDate"/>
- <store-value value-field="existingCost"/>
- </iterate>
- 
- <make-value entity-name="CostComponent" value-field="newEntity"/>
- <set-nonpk-fields map="parameters" value-field="newEntity"/>
- <sequenced-id sequence-name="CostComponent" field="newEntity.costComponentId"/>
- <if-empty field="newEntity.fromDate">
- <now-timestamp field="newEntity.fromDate"/>
- </if-empty>
- <create-value value-field="newEntity"/>
- <field-to-result field="newEntity.costComponentId" result-name="costComponentId"/>
- </simple-method>
-
- 
- <simple-method method-name="getProductCost" short-description="Gets the product's costs (from CostComponent or ProductPrice)">
- <entity-condition entity-name="CostComponent" list="costComponents" filter-by-date="true">
- <condition-list>
- <condition-expr field-name="productId" operator="equals" from-field="parameters.productId"/>
- <condition-expr field-name="costUomId" operator="equals" from-field="parameters.currencyUomId"/>
- <condition-expr field-name="costComponentTypeId" operator="like" value="${parameters.costComponentTypePrefix}_%"/>
- </condition-list>
- </entity-condition>
- <set field="productCost" value="0" type="BigDecimal"/>
- <iterate list="costComponents" entry="costComponent">
- <calculate field="productCost" decimal-scale="6">
- <calcop operator="add" field="costComponent.cost">
- <calcop operator="get" field="productCost"/>
- </calcop>
- </calculate>
- 
- </iterate>
- 
- <if-compare field="productCost" operator="equals" value="0" type="BigDecimal">
- <entity-one entity-name="Product" value-field="product"/>
- <set from-field="product.productId" field="assocAndMap.productIdTo"/>
- <set value="PRODUCT_VARIANT" field="assocAndMap.productAssocTypeId"/>
- <find-by-and entity-name="ProductAssoc" map="assocAndMap" list="virtualAssocs"/>
- <filter-list-by-date list="virtualAssocs"/>
- <first-from-list list="virtualAssocs" entry="virtualAssoc"/>
- <if-not-empty field="virtualAssoc">
- <set from-field="virtualAssoc.productId" field="inputMap.productId"/>
- <set from-field="parameters.currencyUomId" field="inputMap.currencyUomId"/>
- <set from-field="parameters.costComponentTypePrefix" field="inputMap.costComponentTypePrefix"/>
- <call-service service-name="getProductCost" in-map-name="inputMap">
- <result-to-field result-name="productCost"/>
- </call-service>
- </if-not-empty>
- </if-compare>
- 
- <if-compare field="productCost" operator="equals" value="0" type="BigDecimal">
- <set field="orderByList[]" value="+supplierPrefOrderId"/>
- <set field="orderByList[]" value="+lastPrice"/>
- <clear-field field="costsAndMap"/>
- <set from-field="parameters.productId" field="costsAndMap.productId"/>
- <set from-field="parameters.currencyUomId" field="costsAndMap.currencyUomId"/>
- <find-by-and entity-name="SupplierProduct" map="costsAndMap" list="priceCosts" order-by-list="orderByList"/>
- <filter-list-by-date list="priceCosts" from-field-name="availableFromDate" thru-field-name="availableThruDate"/>
- <first-from-list list="priceCosts" entry="priceCost"/>
- <if-not-empty field="priceCost.lastPrice">
- <set from-field="priceCost.lastPrice" field="productCost"/>
- </if-not-empty>
- 
- <if-compare field="productCost" operator="equals" value="0" type="BigDecimal">
- <clear-field field="costsAndMap"/>
- <set from-field="parameters.productId" field="costsAndMap.productId"/>
- <find-by-and entity-name="SupplierProduct" map="costsAndMap" list="priceCosts" order-by-list="orderByList"/>
- <filter-list-by-date list="priceCosts" from-field-name="availableFromDate" thru-field-name="availableThruDate"/>
- <first-from-list list="priceCosts" entry="priceCost"/>
- <if-not-empty field="priceCost.lastPrice">
- 
- <clear-field field="inputMap"/>
- <set from-field="priceCost.lastPrice" field="inputMap.originalValue"/>
- <set from-field="priceCost.currencyUomId" field="inputMap.uomId"/>
- <set from-field="parameters.currencyUomId" field="inputMap.uomIdTo"/>
-
- <call-service service-name="convertUom" in-map-name="inputMap" require-new-transaction="true" break-on-error="false">
- <result-to-field result-name="convertedValue" field="productCost"/>
- </call-service>
-
- 
- <if-empty field="productCost">
- <log level="warning" message="Currency conversion failed for ProductCost lookup; unable to convert from ${priceCost.currencyUomId} to ${parameters.currencyUomId}"/>
- <set field="productCost" value="0" type="BigDecimal"/>
- </if-empty>
- </if-not-empty>
- </if-compare>
- </if-compare>
- 
- <field-to-result field="productCost"/>
- </simple-method>
- <simple-method method-name="getTaskCost" short-description="Gets the production run task's costs">
- 
- <set-service-fields service-name="getEstimatedTaskTime" map="parameters" to-map="inputMap"/>
- <set from-field="parameters.workEffortId" field="inputMap.taskId"/>
- <call-service service-name="getEstimatedTaskTime" in-map-name="inputMap">
- <result-to-field result-name="estimatedTaskTime" field="totalEstimatedTaskTime"/>
- <result-to-field result-name="setupTime"/>
- </call-service>
-
- <calculate field="estimatedTaskTime" decimal-scale="6">
- <calcop operator="subtract" field="totalEstimatedTaskTime">
- <calcop operator="get" field="setupTime"/>
- </calcop>
- </calculate>
-
- <entity-one entity-name="WorkEffort" value-field="task"/>
- <if-not-empty field="task">
- <get-related-one value-field="task" relation-name="FixedAsset" to-value-field="fixedAsset"/>
- <set from-field="parameters.currencyUomId" field="costsAndMap.amountUomId"/>
- <set value="SETUP_COST" field="costsAndMap.fixedAssetStdCostTypeId"/>
- <get-related value-field="fixedAsset" relation-name="FixedAssetStdCost" map="costsAndMap" list="setupCosts"/>
- <filter-list-by-date list="setupCosts"/>
- 
- <first-from-list list="setupCosts" entry="setupCost"/>
- <set value="USAGE_COST" field="costsAndMap.fixedAssetStdCostTypeId"/>
- <get-related value-field="fixedAsset" relation-name="FixedAssetStdCost" map="costsAndMap" list="usageCosts"/>
- <filter-list-by-date list="usageCosts"/>
- <first-from-list list="usageCosts" entry="usageCost"/>
- </if-not-empty>
- <calculate field="taskCost" decimal-scale="6">
- <calcop operator="add">
- <calcop operator="multiply" field="estimatedTaskTime">
- <calcop operator="get" field="usageCost.amount"/>
- </calcop>
- <calcop operator="multiply" field="setupTime">
- <calcop operator="get" field="setupCost.amount"/>
- </calcop>
- </calcop>
- </calculate>
-
- 
- <calculate field="taskCost" decimal-scale="6">
- <calcop operator="divide" field="taskCost">
- <number value="3600000"/>
- </calcop>
- </calculate>
-
- 
- <get-related relation-name="WorkEffortCostCalc" list="weccs" value-field="task"/>
- <filter-list-by-date list="weccs"/>
- <iterate list="weccs" entry="wecc">
- <clear-field field="totalCostComponentCost"/>
- <clear-field field="totalCostComponentTime"/>
- <get-related-one relation-name="CostComponentCalc" to-value-field="costComponentCalc" value-field="wecc"/>
- <get-related-one relation-name="CustomMethod" to-value-field="customMethod" value-field="costComponentCalc"/>
- <if-empty field="customMethod">
- <if-not-empty field="costComponentCalc.perMilliSecond">
- <if-compare operator="not-equals" value="0" field="costComponentCalc.perMilliSecond" type="BigDecimal">
- <calculate field="totalCostComponentTime" decimal-scale="6">
- <calcop operator="divide" field="totalEstimatedTaskTime">
- <calcop operator="get" field="costComponentCalc.perMilliSecond"/>
- </calcop>
- </calculate>
- <calculate field="totalCostComponentCost" decimal-scale="6">
- <calcop operator="multiply" field="totalCostComponentTime">
- <calcop operator="get" field="costComponentCalc.variableCost"/>
- </calcop>
- </calculate>
- <calculate field="totalCostComponentCost" decimal-scale="6">
- <calcop operator="add" field="totalCostComponentCost">
- <calcop operator="get" field="costComponentCalc.fixedCost"/>
- </calcop>
- </calculate>
- <set field="costsByType.${wecc.costComponentTypeId}" from-field="totalCostComponentCost"/>
- </if-compare>
- </if-not-empty>
- <else>
- 
- </else>
- </if-empty>
- </iterate>
- <field-to-result field="taskCost"/>
- <field-to-result field="costsByType"/>
- </simple-method>
-
- 
- <simple-method method-name="calculateAllProductsCosts" short-description="Calculates estimated costs for all the products">
- 
- <entity-condition entity-name="Product" list="products">
- <select-field field-name="productId"/>
- <order-by field-name="-billOfMaterialLevel"/>
- </entity-condition>
- <set from-field="parameters.currencyUomId" field="inMap.currencyUomId"/>
- <set from-field="parameters.costComponentTypePrefix" field="inMap.costComponentTypePrefix"/>
- <iterate list="products" entry="product">
- <set from-field="product.productId" field="inMap.productId"/>
- <call-service service-name="calculateProductCosts" in-map-name="inMap"/>
- </iterate>
- </simple-method>
- <simple-method method-name="calculateProductCosts" short-description="Calculates the product's cost">
- 
- <set value="${parameters.costComponentTypePrefix}_ROUTE_COST" field="cancelMap.costComponentTypeId"/>
- <set from-field="parameters.productId" field="cancelMap.productId"/>
- <set from-field="parameters.currencyUomId" field="cancelMap.costUomId"/>
- <call-service service-name="cancelCostComponents" in-map-name="cancelMap"/>
- <set value="${parameters.costComponentTypePrefix}_MAT_COST" field="cancelMap.costComponentTypeId"/>
- <call-service service-name="cancelCostComponents" in-map-name="cancelMap"/>
- 
- <set from-field="parameters.productId" field="callSvcMap.productId"/>
- <call-service service-name="getManufacturingComponents" in-map-name="callSvcMap">
- <result-to-field result-name="componentsMap"/>
- </call-service>
- <if-not-empty field="componentsMap">
- <iterate list="componentsMap" entry="componentMap">
- <clear-field field="inputMap"/>
- <set field="product" from-field="componentMap.product"/>
- <set field="inputMap.productId" from-field="product.productId"/>
- <set field="inputMap.currencyUomId" from-field="parameters.currencyUomId"/>
- <set field="inputMap.costComponentTypePrefix" from-field="parameters.costComponentTypePrefix"/>
- <call-service service-name="getProductCost" in-map-name="inputMap">
- <result-to-field result-name="productCost"/>
- </call-service>
- <calculate field="totalProductsCost" decimal-scale="6">
- <calcop operator="add" field="totalProductsCost">
- <calcop operator="multiply" field="componentMap.quantity">
- <calcop operator="get" field="productCost"/>
- </calcop>
- </calcop>
- </calculate>
- </iterate>
- <else>
- <clear-field field="inputMap"/>
- <set field="inputMap.productId" from-field="parameters.productId"/>
- <set field="inputMap.currencyUomId" from-field="parameters.currencyUomId"/>
- <set field="inputMap.costComponentTypePrefix" from-field="parameters.costComponentTypePrefix"/>
- <call-service service-name="getProductCost" in-map-name="inputMap">
- <result-to-field result-name="productCost"/>
- </call-service>
- <calculate field="totalProductsCost" decimal-scale="6">
- <calcop operator="get" field="productCost"/>
- </calculate>
- </else>
- </if-not-empty>
- 
- <set field="callSvcMap.ignoreDefaultRouting" value="Y"/>
- <call-service service-name="getProductRouting" in-map-name="callSvcMap">
- <result-to-field result-name="tasks"/>
- <result-to-field result-name="routing"/>
- </call-service>
- <iterate list="tasks" entry="task">
- <clear-field field="callSvcMap"/>
- <set from-field="task.workEffortIdTo" field="callSvcMap.workEffortId"/>
- <set from-field="parameters.currencyUomId" field="callSvcMap.currencyUomId"/>
- <set from-field="parameters.productId" field="callSvcMap.productId"/>
- <set from-field="routing.workEffortId" field="callSvcMap.routingId"/>
- <call-service service-name="getTaskCost" in-map-name="callSvcMap">
- <result-to-field result-name="taskCost" field="taskCost"/>
- <result-to-field result-name="costsByType" field="costsByType"/>
- </call-service>
- <calculate field="totalTaskCost" decimal-scale="6">
- <calcop operator="add" field="totalTaskCost">
- <calcop operator="get" field="taskCost"/>
- </calcop>
- </calculate>
- <iterate-map map="costsByType" key="costType" value="costAmount">
- <if-not-empty field="totalCostsByType.${costType}">
- <calculate field="totalCostsByType.${costType}" decimal-scale="6">
- <calcop operator="add" field="costAmount">
- <calcop operator="get" field="totalCostsByType.${costType}"/>
- </calcop>
- </calculate>
- <else>
- <set field="totalCostsByType.${costType}" from-field="costAmount"/>
- </else>
- </if-not-empty>
- <calculate field="totalOtherTaskCost" decimal-scale="6">
- <calcop operator="add" field="totalOtherTaskCost">
- <calcop operator="get" field="costAmount"/>
- </calcop>
- </calculate>
- </iterate-map>
- </iterate>
-
- <calculate field="totalCost" decimal-scale="6">
- <calcop operator="add" field="totalTaskCost">
- <calcop operator="get" field="totalProductsCost"/>
- <calcop operator="get" field="totalOtherTaskCost"/>
- </calcop>
- </calculate>
-
- 
- <if-not-empty field="totalTaskCost">
- <if-compare field="totalTaskCost" operator="greater" value="0" type="BigDecimal">
- <clear-field field="callSvcMap"/>
- <set value="${parameters.costComponentTypePrefix}_ROUTE_COST" field="callSvcMap.costComponentTypeId"/>
- <set from-field="parameters.productId" field="callSvcMap.productId"/>
- <set from-field="parameters.currencyUomId" field="callSvcMap.costUomId"/>
- <set from-field="totalTaskCost" field="callSvcMap.cost"/>
- <call-service service-name="recreateCostComponent" in-map-name="callSvcMap"/>
- </if-compare>
- </if-not-empty>
- <if-not-empty field="totalProductsCost">
- <if-compare field="totalProductsCost" operator="greater" value="0" type="BigDecimal">
- <clear-field field="callSvcMap"/>
- <set value="${parameters.costComponentTypePrefix}_MAT_COST" field="callSvcMap.costComponentTypeId"/>
- <set from-field="parameters.productId" field="callSvcMap.productId"/>
- <set from-field="parameters.currencyUomId" field="callSvcMap.costUomId"/>
- <set from-field="totalProductsCost" field="callSvcMap.cost"/>
- <call-service service-name="recreateCostComponent" in-map-name="callSvcMap"/>
- </if-compare>
- </if-not-empty>
- <iterate-map map="totalCostsByType" key="costType" value="totalCostAmount">
- <clear-field field="callSvcMap"/>
- <set value="${parameters.costComponentTypePrefix}_${costType}" field="callSvcMap.costComponentTypeId"/>
- <set from-field="parameters.productId" field="callSvcMap.productId"/>
- <set from-field="parameters.currencyUomId" field="callSvcMap.costUomId"/>
- <set from-field="totalCostAmount" field="callSvcMap.cost"/>
- <call-service service-name="recreateCostComponent" in-map-name="callSvcMap"/>
- </iterate-map>
-
- 
- <entity-condition entity-name="ProductCostComponentCalc" list="productCostComponentCalcs" filter-by-date="true">
- <condition-expr field-name="productId" from-field="parameters.productId"/>
- <order-by field-name="sequenceNum"/>
- </entity-condition>
- <iterate list="productCostComponentCalcs" entry="productCostComponentCalc">
- <get-related-one relation-name="CostComponentCalc" to-value-field="costComponentCalc" value-field="productCostComponentCalc"/>
- <get-related-one relation-name="CustomMethod" to-value-field="customMethod" value-field="costComponentCalc"/>
- <if-empty field="customMethod">
- 
- <log level="warning" message="Unable to create cost component for cost component calc with id [${costComponentCalc.costComponentCalcId}] because customMethod is not set"/>
- <else>
- <clear-field field="customMethodParameters"/>
- <set field="customMethodParameters.productCostComponentCalc" from-field="productCostComponentCalc"/>
- <set field="customMethodParameters.costComponentCalc" from-field="costComponentCalc"/>
- <set from-field="parameters.currencyUomId" field="customMethodParameters.currencyUomId"/>
- <set from-field="parameters.costComponentTypePrefix" field="customMethodParameters.costComponentTypePrefix"/>
- <set from-field="totalCost" field="customMethodParameters.baseCost"/>
- <call-service service-name="${customMethod.customMethodName}" in-map-name="customMethodParameters">
- <result-to-field result-name="productCostAdjustment"/>
- </call-service>
- <clear-field field="callSvcMap"/>
- <set value="${parameters.costComponentTypePrefix}_${productCostComponentCalc.costComponentTypeId}" field="callSvcMap.costComponentTypeId"/>
- <set from-field="productCostComponentCalc.productId" field="callSvcMap.productId"/>
- <set from-field="parameters.currencyUomId" field="callSvcMap.costUomId"/>
- <set from-field="productCostAdjustment" field="callSvcMap.cost"/>
- <call-service service-name="recreateCostComponent" in-map-name="callSvcMap"/>
- 
- <calculate field="totalCost" decimal-scale="6">
- <calcop operator="add" field="totalCost">
- <calcop operator="get" field="productCostAdjustment"/>
- </calcop>
- </calculate>
- </else>
- </if-empty>
- </iterate>
-
- <field-to-result field="totalCost"/>
- </simple-method>
- <simple-method method-name="calculateProductAverageCost" short-description="Calculate inventory average cost for a product">
- <entity-condition entity-name="InventoryItem" list="inventoryItems">
- <condition-list>
- <condition-expr field-name="productId" from-field="parameters.productId"/>
- <condition-expr field-name="facilityId" from-field="parameters.facilityId" ignore-if-empty="true"/>
- <condition-expr field-name="ownerPartyId" from-field="parameters.ownerPartyId" ignore-if-empty="true"/>
- <condition-expr field-name="unitCost" operator="not-equals" from-field="nullField"/>
- </condition-list>
- <select-field field-name="quantityOnHandTotal"/>
- <select-field field-name="unitCost"/>
- <select-field field-name="currencyUomId"/>
- </entity-condition>
- <set field="totalQuantityOnHand" type="BigDecimal" value="0"/>
- <set field="totalInventoryCost" type="BigDecimal" value="0"/>
- <set field="absValOfTotalQOH" type="BigDecimal" value="0"/>
- <set field="absValOfTotalInvCost" type="BigDecimal" value="0"/>
- <set field="differentCurrencies" type="Boolean" value="false"/>
- <iterate list="inventoryItems" entry="inventoryItem">
- <calculate field="totalQuantityOnHand">
- <calcop operator="add" >
- <calcop operator="get" field="totalQuantityOnHand"/>
- <calcop operator="get" field="inventoryItem.quantityOnHandTotal"/>
- </calcop>
- </calculate>
-
- <if-empty field="currencyUomId">
- <set field="currencyUomId" from-field="inventoryItem.currencyUomId"/>
- </if-empty>
- <if-compare field="differentCurrencies" operator="equals" value="false" type="Boolean">
- <if-compare-field field="inventoryItem.currencyUomId" operator="equals" to-field="currencyUomId">
- <calculate field="totalInventoryCost" type="BigDecimal">
- <calcop operator="add">
- <calcop operator="get" field="totalInventoryCost"/>
- <calcop operator="multiply">
- <calcop operator="get" field="inventoryItem.quantityOnHandTotal"/>
- <calcop operator="get" field="inventoryItem.unitCost"/>
- </calcop>
- </calcop>
- </calculate>
-
- 
- <if-compare field="inventoryItem.quantityOnHandTotal" operator="less" value="0">
- <calculate field="absValOfTotalQOH">
- <calcop operator="add">
- <calcop operator="get" field="absValOfTotalQOH"/>
- <calcop operator="negative" field="inventoryItem.quantityOnHandTotal"/>
- </calcop>
- </calculate>
- <calculate field="absValOfTotalInvCost" type="BigDecimal">
- <calcop operator="add">
- <calcop operator="get" field="absValOfTotalInvCost"/>
- <calcop operator="multiply">
- <calcop operator="negative" field="inventoryItem.quantityOnHandTotal"/>
- <calcop operator="get" field="inventoryItem.unitCost"/>
- </calcop>
- </calcop>
- </calculate>
- <else>
- <calculate field="absValOfTotalQOH">
- <calcop operator="add" >
- <calcop operator="get" field="absValOfTotalQOH"/>
- <calcop operator="get" field="inventoryItem.quantityOnHandTotal"/>
- </calcop>
- </calculate>
- <calculate field="absValOfTotalInvCost" type="BigDecimal">
- <calcop operator="add">
- <calcop operator="get" field="absValOfTotalInvCost"/>
- <calcop operator="multiply">
- <calcop operator="get" field="inventoryItem.quantityOnHandTotal"/>
- <calcop operator="get" field="inventoryItem.unitCost"/>
- </calcop>
- </calcop>
- </calculate>
- </else>
- </if-compare>
- <else>
- <set field="differentCurrencies" type="Boolean" value="true"/>
- </else>
- </if-compare-field>
- </if-compare>
- </iterate>
-
- <if-compare field="absValOfTotalQOH" operator="not-equals" value="0" type="BigDecimal">
- <calculate field="productAverageCost" type="BigDecimal">
- <calcop operator="divide">
- <calcop operator="get" field="absValOfTotalInvCost"/>
- <calcop operator="get" field="absValOfTotalQOH"/>
- </calcop>
- </calculate>
- <else>
- <set field="productAverageCost" type="BigDecimal" value="0"/>
- </else>
- </if-compare>
- <field-to-result field="totalQuantityOnHand"/>
- <if-compare field="differentCurrencies" operator="equals" value="false" type="Boolean">
- <field-to-result field="totalInventoryCost"/>
- <field-to-result field="productAverageCost"/>
- <field-to-result field="currencyUomId"/>
- </if-compare>
- </simple-method>
-
- <simple-method method-name="updateProductAverageCostOnReceiveInventory" short-description="Update a Product Average Cost record on receive inventory">
- <entity-one entity-name="InventoryItem" value-field="inventoryItem"/>
- <set field="organizationPartyId" from-field="inventoryItem.ownerPartyId"/>
- <if-empty field="organizationPartyId">
- <entity-one entity-name="Facility" value-field="facility" auto-field-map="true"/>
- <set field="organizationPartyId" from-field="facility.ownerPartyId"/>
- <if-empty field="organizationPartyId">
- <get-related-one relation-name="ProductStore" to-value-field="productStore" value-field="facility"/>
- <set field="organizationPartyId" from-field="productStore.ownerPartyId"/>
- <if-empty field="organizationPartyId">
- <add-error error-list-name="error_list">
- <fail-property resource="ProductUiLabels" property="ProductOwnerPartyIsMissing"/>
- </add-error>
- </if-empty>
- <check-errors/>
- </if-empty>
- </if-empty>
-
- <entity-and entity-name="ProductAverageCost" list="productAverageCostList" filter-by-date="true">
- <field-map field-name="productId" from-field="parameters.productId"/>
- <field-map field-name="facilityId" from-field="parameters.facilityId"/>
- <field-map field-name="productAverageCostTypeId" value="SIMPLE_AVG_COST"/>
- <field-map field-name="organizationPartyId"/>
- </entity-and>
- <first-from-list list="productAverageCostList" entry="productAverageCost"/>
-
- 
-
- <set-service-fields service-name="createProductAverageCost" map="parameters" to-map="productAverageCostMap"/>
- <set field="productAverageCostMap.productAverageCostTypeId" value="SIMPLE_AVG_COST"/>
- <set field="productAverageCostMap.organizationPartyId" from-field="organizationPartyId"/>
- <if-empty field="productAverageCost">
- <set field="productAverageCostMap.averageCost" from-field="inventoryItem.unitCost"/>
- <else>
- 
- <set-service-fields service-name="updateProductAverageCost" map="productAverageCost" to-map="updateProductAverageCostMap"/>
- <now-timestamp field="updateProductAverageCostMap.thruDate"/>
- <call-service service-name="updateProductAverageCost" in-map-name="updateProductAverageCostMap"/>
-
- <set field="serviceInMap.productId" from-field="parameters.productId"/>
- <set field="serviceInMap.facilityId" from-field="parameters.facilityId"/>
- <call-service service-name="getInventoryAvailableByFacility" in-map-name="serviceInMap">
- <result-to-field result-name="quantityOnHandTotal"/>
- </call-service>
-
- <set field="oldProductQuantity" value="${quantityOnHandTotal - parameters.quantityAccepted}" type="BigDecimal"/>
- <set field="productAverageCostMap.averageCost" value="${((productAverageCost.averageCost * oldProductQuantity) + (inventoryItem.unitCost * parameters.quantityAccepted))/(quantityOnHandTotal)}" type="BigDecimal"/>
- <property-to-field resource="arithmetic" property="finaccount.decimals" field="roundingDecimals" default="2"/>
- <property-to-field resource="arithmetic" property="finaccount.roundingSimpleMethod" field="roundingMode" default="HalfUp"/>
- <calculate field="productAverageCostMap.averageCost" type="BigDecimal" decimal-scale="${roundingDecimals}" rounding-mode="${roundingMode}">
- <calcop operator="get" field="productAverageCostMap.averageCost"/>
- </calculate>
-
- <now-timestamp field="productAverageCostMap.fromDate"/>
- </else>
- </if-empty>
-
- 
- <call-service service-name="createProductAverageCost" in-map-name="productAverageCostMap"/>
- <log level="info" message="For facilityId ${parameters.facilityId}, Average cost of product ${parameters.productId} is set from ${updateProductAverageCostMap.averageCost} to ${productAverageCostMap.averageCost}"/>
- </simple-method>
-
- <simple-method method-name="getProductAverageCost" short-description="Service to get the average cost of product">
- <set field="inventoryItem" from-field="parameters.inventoryItem"/>
- <set field="getPartyAcctgPrefMap.organizationPartyId" from-field="inventoryItem.ownerPartyId"/>
- <call-service service-name="getPartyAccountingPreferences" in-map-name="getPartyAcctgPrefMap">
- <result-to-field result-name="partyAccountingPreference"/>
- </call-service>
- <if-compare field="partyAccountingPreference.cogsMethodId" operator="equals" value="COGS_AVG_COST">
- <entity-and entity-name="ProductAverageCost" list="productAverageCostList" filter-by-date="true">
- <field-map field-name="productAverageCostTypeId" value="SIMPLE_AVG_COST"/> 
- <field-map field-name="organizationPartyId" from-field="inventoryItem.ownerPartyId"/>
- <field-map field-name="productId" from-field="inventoryItem.productId"/>
- <field-map field-name="facilityId" from-field="inventoryItem.facilityId"/>
- </entity-and>
- <first-from-list list="productAverageCostList" entry="productAverageCost"/>
- </if-compare>
- <if-not-empty field="productAverageCost">
- <set field="unitCost" from-field="productAverageCost.averageCost" type="BigDecimal"/>
- <else>
- <set field="unitCost" from-field="inventoryItem.unitCost" type="BigDecimal"/>
- </else>
- </if-not-empty>
- <field-to-result field="unitCost"/>
- </simple-method>
-
- <simple-method method-name="productCostPercentageFormula" short-description="Formula that creates a cost component equal to a percentage of total product cost">
- <set field="productCostComponentCalc" from-field="parameters.productCostComponentCalc"/>
- <set field="costComponentCalc" from-field="parameters.costComponentCalc"/>
- <set field="inputMap.productId" from-field="productCostComponentCalc.productId"/>
- <set field="inputMap.currencyUomId" from-field="parameters.currencyUomId"/>
- <set field="inputMap.costComponentTypePrefix" from-field="parameters.costComponentTypePrefix"/>
- <call-service service-name="getProductCost" in-map-name="inputMap">
- <result-to-field result-name="productCost"/>
- </call-service>
- 
- <calculate field="productCostAdjustment" type="BigDecimal" decimal-scale="6">
- <calcop operator="multiply" field="costComponentCalc.fixedCost">
- <calcop operator="get" field="parameters.baseCost"/>
- </calcop>
- </calculate>
- <field-to-result field="productCostAdjustment"/>
- </simple-method>
-</simple-methods>
diff --git a/applications/product/servicedef/services_cost.xml b/applications/product/servicedef/services_cost.xml
index 4bfad3b..8b1d5fb 100644
--- a/applications/product/servicedef/services_cost.xml
+++ b/applications/product/servicedef/services_cost.xml
@@ -39,14 +39,14 @@ under the License.
<description>Delete a CostComponent</description>
<auto-attributes include="pk" mode="IN" optional="false"/>
</service>
- <service name="recreateCostComponent" default-entity-name="CostComponent" engine="simple"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="recreateCostComponent" auth="true">
+ <service name="recreateCostComponent" default-entity-name="CostComponent" engine="groovy"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="recreateCostComponent" auth="true">
<description>Create a CostComponent and cancel the existing ones</description>
<auto-attributes include="nonpk" mode="IN" optional="true"/>
<auto-attributes include="pk" mode="OUT" optional="false"/>
</service>
- <service name="cancelCostComponents" engine="simple"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="cancelCostComponents" auth="true">
+ <service name="cancelCostComponents" engine="groovy"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="cancelCostComponents" auth="true">
<description>Cancels CostComponent</description>
<attribute mode="IN" name="costComponentId" optional="true" type="String"/>
<attribute mode="IN" name="productId" optional="true" type="String"/>
@@ -67,8 +67,8 @@ under the License.
<description>Delete a Example</description>
<auto-attributes include="pk" mode="IN" optional="false"/>
</service>
- <service name="getProductCost" engine="simple" auth="true"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="getProductCost">
+ <service name="getProductCost" engine="groovy" auth="true"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="getProductCost">
<description>Gets the product's costs from CostComponent entries</description>
<attribute mode="IN" name="productId" optional="false" type="String"/>
<attribute mode="IN" name="currencyUomId" optional="false" type="String"/>
@@ -79,8 +79,8 @@ under the License.
</type-validate>
</attribute>
</service>
- <service name="getTaskCost" engine="simple" auth="true"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="getTaskCost">
+ <service name="getTaskCost" engine="groovy" auth="true"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="getTaskCost">
<description>Gets the production run task's costs</description>
<attribute mode="IN" name="workEffortId" optional="false" type="String"/>
<attribute mode="IN" name="currencyUomId" optional="false" type="String"/>
@@ -93,22 +93,22 @@ under the License.
</attribute>
<attribute mode="OUT" name="costsByType" type="Map" optional="true"/>
</service>
- <service name="calculateProductCosts" engine="simple" auth="true"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="calculateProductCosts">
+ <service name="calculateProductCosts" engine="groovy" auth="true"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="calculateProductCosts">
<description>Calculates the product's costs. If the product does not have cost component defined, will use the BOM to calculate the cost.</description>
<attribute mode="IN" name="productId" optional="false" type="String"/>
<attribute mode="IN" name="currencyUomId" optional="false" type="String"/>
<attribute mode="IN" name="costComponentTypePrefix" optional="false" type="String"/>
<attribute mode="OUT" name="totalCost" type="BigDecimal"/>
</service>
- <service name="calculateAllProductsCosts" engine="simple" auth="true" transaction-timeout="7200"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="calculateAllProductsCosts">
+ <service name="calculateAllProductsCosts" engine="groovy" auth="true" transaction-timeout="7200"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="calculateAllProductsCosts">
<description>Calculates estimated costs for all the products</description>
<attribute mode="IN" name="currencyUomId" optional="false" type="String"/>
<attribute mode="IN" name="costComponentTypePrefix" optional="false" type="String"/>
</service>
- <service name="calculateProductAverageCost" engine="simple" auth="true"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="calculateProductAverageCost">
+ <service name="calculateProductAverageCost" engine="groovy" auth="true"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="calculateProductAverageCost">
<description>Calculate inventory average cost for a product</description>
<attribute name="productId" type="String" mode="IN"/>
<attribute name="facilityId" type="String" mode="IN" optional="true"/>
@@ -128,8 +128,8 @@ under the License.
<attribute name="baseCost" type="BigDecimal" mode="IN" optional="false"/>
<attribute name="productCostAdjustment" type="BigDecimal" mode="OUT" optional="false"/>
</service>
- <service name="productCostPercentageFormula" engine="simple"
- location="component://product/minilang/product/cost/CostServices.xml" invoke="productCostPercentageFormula" auth="true">
+ <service name="productCostPercentageFormula" engine="groovy"
+ location="component://product/groovyScripts/product/cost/CostServices.groovy" invoke="productCostPercentageFormula" auth="true">
<description>Formula that creates a cost component equal to a percentage of total product cost</description>
<implements service="productCostCalcInterface"/>
</service>