/*******************************************************************************
* 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.
*******************************************************************************/
package org.ofbiz.accounting.finaccount;
import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import javolution.util.FastMap;
import org.ofbiz.base.util.Debug;
import org.ofbiz.base.util.GeneralException;
import org.ofbiz.base.util.UtilDateTime;
import org.ofbiz.base.util.UtilMisc;
import org.ofbiz.base.util.UtilProperties;
import org.ofbiz.base.util.UtilValidate;
import org.ofbiz.entity.Delegator;
import org.ofbiz.entity.GenericEntityException;
import org.ofbiz.entity.GenericValue;
import org.ofbiz.entity.condition.EntityCondition;
import org.ofbiz.entity.condition.EntityExpr;
import org.ofbiz.entity.condition.EntityOperator;
import org.ofbiz.entity.util.EntityListIterator;
import org.ofbiz.entity.util.EntityUtil;
import org.ofbiz.order.finaccount.FinAccountHelper;
import org.ofbiz.product.store.ProductStoreWorker;
import org.ofbiz.service.DispatchContext;
import org.ofbiz.service.GenericServiceException;
import org.ofbiz.service.LocalDispatcher;
import org.ofbiz.service.ModelService;
import org.ofbiz.service.ServiceUtil;
public class FinAccountServices {
public static final String module = FinAccountServices.class.getName();
public static final String resourceError = "AccountingErrorUiLabels";
public static Map<String, Object> createAccountAndCredit(DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
String finAccountTypeId = (String) context.get("finAccountTypeId");
String accountName = (String) context.get("accountName");
String finAccountId = (String) context.get("finAccountId");
Locale locale = (Locale) context.get("locale");
// check the type
if (finAccountTypeId == null) {
finAccountTypeId = "SVCCRED_ACCOUNT";
}
if (accountName == null) {
if ("SVCCRED_ACCOUNT".equals(finAccountTypeId)) {
accountName = "Customer Service Credit Account";
} else {
accountName = "Financial Account";
}
}
GenericValue userLogin = (GenericValue) context.get("userLogin");
try {
// find the most recent (active) service credit account for the specified party
String partyId = (String) context.get("partyId");
Map<String, String> lookupMap = UtilMisc.toMap("finAccountTypeId", finAccountTypeId, "ownerPartyId", partyId);
// if a productStoreId is present, restrict the accounts returned using the store's payToPartyId
String productStoreId = (String) context.get("productStoreId");
if (UtilValidate.isNotEmpty(productStoreId)) {
String payToPartyId = ProductStoreWorker.getProductStorePayToPartyId(productStoreId, delegator);
if (UtilValidate.isNotEmpty(payToPartyId)) {
lookupMap.put("organizationPartyId", payToPartyId);
}
}
// if a currencyUomId is present, use it to restrict the accounts returned
String currencyUomId = (String) context.get("currencyUomId");
if (UtilValidate.isNotEmpty(currencyUomId)) {
lookupMap.put("currencyUomId", currencyUomId);
}
// check for an existing account
GenericValue creditAccount;
if (finAccountId != null) {
creditAccount = delegator.findByPrimaryKey("FinAccount", UtilMisc.toMap("finAccountId", finAccountId));
} else {
List<GenericValue> creditAccounts = delegator.findByAnd("FinAccount", lookupMap, UtilMisc.toList("-fromDate"));
creditAccount = EntityUtil.getFirst(EntityUtil.filterByDate(creditAccounts));
}
if (creditAccount == null) {
// create a new service credit account
String createAccountServiceName = "createFinAccount";
if (UtilValidate.isNotEmpty(productStoreId)) {
createAccountServiceName = "createFinAccountForStore";
}
// automatically set the parameters
ModelService createAccountService = dctx.getModelService(createAccountServiceName);
Map<String, Object> createAccountContext = createAccountService.makeValid(context, ModelService.IN_PARAM);
createAccountContext.put("finAccountTypeId", finAccountTypeId);
createAccountContext.put("finAccountName", accountName);
createAccountContext.put("ownerPartyId", partyId);
createAccountContext.put("userLogin", userLogin);
Map<String, Object> createAccountResult = dispatcher.runSync(createAccountServiceName, createAccountContext);
if (ServiceUtil.isError(createAccountResult) || ServiceUtil.isFailure(createAccountResult)) {
return createAccountResult;
}
if (createAccountResult != null) {
String creditAccountId = (String) createAccountResult.get("finAccountId");
if (UtilValidate.isNotEmpty(creditAccountId)) {
creditAccount = delegator.findByPrimaryKey("FinAccount", UtilMisc.toMap("finAccountId", creditAccountId));
// create the owner role
Map<String, Object> roleCtx = FastMap.newInstance();
roleCtx.put("partyId", partyId);
roleCtx.put("roleTypeId", "OWNER");
roleCtx.put("finAccountId", creditAccountId);
roleCtx.put("userLogin", userLogin);
roleCtx.put("fromDate", UtilDateTime.nowTimestamp());
Map<String, Object> roleResp;
try {
roleResp = dispatcher.runSync("createFinAccountRole", roleCtx);
} catch (GenericServiceException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (ServiceUtil.isError(roleResp)) {
return roleResp;
}
finAccountId = creditAccountId; // update the finAccountId for return parameter
}
}
if (creditAccount == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingFinAccountCannotCreditAccount", locale));
}
}
// create the credit transaction
Map<String, Object> transactionMap = FastMap.newInstance();
transactionMap.put("finAccountTransTypeId", "ADJUSTMENT");
transactionMap.put("finAccountId", creditAccount.getString("finAccountId"));
transactionMap.put("partyId", partyId);
transactionMap.put("amount", context.get("amount"));
transactionMap.put("reasonEnumId", context.get("reasonEnumId"));
transactionMap.put("comments", context.get("comments"));
transactionMap.put("userLogin", userLogin);
Map<String, Object> creditTransResult = dispatcher.runSync("createFinAccountTrans", transactionMap);
if (ServiceUtil.isError(creditTransResult) || ServiceUtil.isFailure(creditTransResult)) {
return creditTransResult;
}
} catch (GenericEntityException gee) {
return ServiceUtil.returnError(gee.getMessage());
} catch (GenericServiceException gse) {
return ServiceUtil.returnError(gse.getMessage());
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("finAccountId", finAccountId);
return result;
}
public static Map<String, Object> createFinAccountForStore(DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
GenericValue userLogin = (GenericValue) context.get("userLogin");
String productStoreId = (String) context.get("productStoreId");
String finAccountTypeId = (String) context.get("finAccountTypeId");
Locale locale = (Locale) context.get("locale");
GenericValue productStore = ProductStoreWorker.getProductStore(productStoreId, delegator);
try {
// get the product store id and use it to generate a unique fin account code
GenericValue productStoreFinAccountSetting = delegator.findByPrimaryKeyCache("ProductStoreFinActSetting", UtilMisc.toMap("productStoreId", productStoreId, "finAccountTypeId", finAccountTypeId));
if (productStoreFinAccountSetting == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingFinAccountSetting",
UtilMisc.toMap("productStoreId", productStoreId, "finAccountTypeId", finAccountTypeId), locale));
}
Long accountCodeLength = productStoreFinAccountSetting.getLong("accountCodeLength");
Long accountValidDays = productStoreFinAccountSetting.getLong("accountValidDays");
Long pinCodeLength = productStoreFinAccountSetting.getLong("pinCodeLength");
String requirePinCode = productStoreFinAccountSetting.getString("requirePinCode");
// automatically set the parameters for the create fin account service
ModelService createService = dctx.getModelService("createFinAccount");
Map<String, Object> inContext = createService.makeValid(context, ModelService.IN_PARAM);
Timestamp now = UtilDateTime.nowTimestamp();
// now use our values
String finAccountCode = FinAccountHelper.getNewFinAccountCode(accountCodeLength.intValue(), delegator);
inContext.put("finAccountCode", finAccountCode);
// with pin codes, the account code becomes the ID and the pin becomes the code
if ("Y".equalsIgnoreCase(requirePinCode)) {
String pinCode = FinAccountHelper.getNewFinAccountCode(pinCodeLength.intValue(), delegator);
inContext.put("finAccountPin", pinCode);
}
// set the dates/userlogin
if (UtilValidate.isNotEmpty(accountValidDays)){
inContext.put("thruDate", UtilDateTime.getDayEnd(now, accountValidDays));
}
inContext.put("fromDate", now);
inContext.put("userLogin", userLogin);
// product store payToPartyId
String payToPartyId = ProductStoreWorker.getProductStorePayToPartyId(productStoreId, delegator);
inContext.put("organizationPartyId", payToPartyId);
inContext.put("currencyUomId", productStore.get("defaultCurrencyUomId"));
Map<String, Object> createResult = dispatcher.runSync("createFinAccount", inContext);
if (ServiceUtil.isError(createResult)) {
return createResult;
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("finAccountId", createResult.get("finAccountId"));
result.put("finAccountCode", finAccountCode);
return result;
} catch (GenericEntityException ex) {
return ServiceUtil.returnError(ex.getMessage());
} catch (GenericServiceException ex) {
return ServiceUtil.returnError(ex.getMessage());
}
}
public static Map<String, Object> checkFinAccountBalance(DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
String finAccountId = (String) context.get("finAccountId");
String finAccountCode = (String) context.get("finAccountCode");
Locale locale = (Locale) context.get("locale");
GenericValue finAccount;
if (finAccountId == null) {
try {
finAccount = FinAccountHelper.getFinAccountFromCode(finAccountCode, delegator);
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
} else {
try {
finAccount = delegator.findByPrimaryKey("FinAccount", UtilMisc.toMap("finAccountId", finAccountId));
} catch (GenericEntityException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
}
}
if (finAccount == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingFinAccountNotFound", UtilMisc.toMap("finAccountId", finAccountId), locale));
}
// get the balance
BigDecimal availableBalance = finAccount.getBigDecimal("availableBalance");
BigDecimal balance = finAccount.getBigDecimal("actualBalance");
if (availableBalance == null) {
availableBalance = FinAccountHelper.ZERO;
}
if (balance == null) {
balance = FinAccountHelper.ZERO;
}
String statusId = finAccount.getString("statusId");
Debug.logInfo("FinAccount Balance [" + balance + "] Available [" + availableBalance + "] - Status: " + statusId, module);
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("availableBalance", availableBalance);
result.put("balance", balance);
result.put("statusId", statusId);
return result;
}
public static Map<String, Object> checkFinAccountStatus(DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
String finAccountId = (String) context.get("finAccountId");
Locale locale = (Locale) context.get("locale");
if (finAccountId == null) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingFinAccountNotFound", UtilMisc.toMap("finAccountId", ""), locale));
}
GenericValue finAccount;
try {
finAccount = delegator.findByPrimaryKey("FinAccount", UtilMisc.toMap("finAccountId", finAccountId));
} catch (GenericEntityException ex) {
return ServiceUtil.returnError(ex.getMessage());
}
if (finAccount != null) {
String statusId = finAccount.getString("statusId");
if (statusId == null) statusId = "FNACT_ACTIVE";
BigDecimal balance = finAccount.getBigDecimal("actualBalance");
if (balance == null) {
balance = FinAccountHelper.ZERO;
}
Debug.logInfo("Account #" + finAccountId + " Balance: " + balance + " Status: " + statusId, module);
if ("FNACT_ACTIVE".equals(statusId) && balance.compareTo(FinAccountHelper.ZERO) < 1) {
finAccount.set("statusId", "FNACT_MANFROZEN");
Debug.logInfo("Financial account [" + finAccountId + "] has passed its threshold [" + balance + "] (Frozen)", module);
} else if ("FNACT_MANFROZEN".equals(statusId) && balance.compareTo(FinAccountHelper.ZERO) > 0) {
finAccount.set("statusId", "FNACT_ACTIVE");
Debug.logInfo("Financial account [" + finAccountId + "] has been made current [" + balance + "] (Un-Frozen)", module);
}
try {
finAccount.store();
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
}
return ServiceUtil.returnSuccess();
}
public static Map<String, Object> refundFinAccount(DispatchContext dctx, Map<String, Object> context) {
LocalDispatcher dispatcher = dctx.getDispatcher();
Delegator delegator = dctx.getDelegator();
Locale locale = (Locale) context.get("locale");
GenericValue userLogin = (GenericValue) context.get("userLogin");
String finAccountId = (String) context.get("finAccountId");
Map<String, Object> result = null;
GenericValue finAccount;
try {
finAccount = delegator.findByPrimaryKey("FinAccount", UtilMisc.toMap("finAccountId", finAccountId));
} catch (GenericEntityException e) {
return ServiceUtil.returnError(e.getMessage());
}
if (finAccount != null) {
// check to make sure the account is refundable
if (!"Y".equals(finAccount.getString("isRefundable"))) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingFinAccountIsNotRefundable", locale));
}
// get the actual and available balance
BigDecimal availableBalance = finAccount.getBigDecimal("availableBalance");
BigDecimal actualBalance = finAccount.getBigDecimal("actualBalance");
// if they do not match, then there are outstanding authorizations which need to be settled first
if (actualBalance.compareTo(availableBalance) != 0) {
return ServiceUtil.returnError(UtilProperties.getMessage(resourceError,
"AccountingFinAccountCannotBeRefunded", locale));
}
// now we make sure there is something to refund
if (actualBalance.compareTo(BigDecimal.ZERO) > 0) {
BigDecimal remainingBalance = new BigDecimal(actualBalance.toString());
BigDecimal refundAmount = BigDecimal.ZERO;
List<EntityExpr> exprs = UtilMisc.toList(EntityCondition.makeCondition("finAccountTransTypeId", EntityOperator.EQUALS, "DEPOSIT"),
EntityCondition.makeCondition("finAccountId", EntityOperator.EQUALS, finAccountId));
EntityCondition condition = EntityCondition.makeCondition(exprs, EntityOperator.AND);
EntityListIterator eli = null;
try {
eli = delegator.find("FinAccountTrans", condition, null, null, UtilMisc.toList("-transactionDate"), null);
GenericValue trans;
while (remainingBalance.compareTo(FinAccountHelper.ZERO) < 0 && (trans = eli.next()) != null) {
String orderId = trans.getString("orderId");
String orderItemSeqId = trans.getString("orderItemSeqId");
// make sure there is an order available to refund
if (orderId != null && orderItemSeqId != null) {
GenericValue orderHeader = delegator.findByPrimaryKey("OrderHeader", UtilMisc.toMap("orderId",orderId));
GenericValue productStore = delegator.getRelatedOne("ProductStore", orderHeader);
GenericValue orderItem = delegator.findByPrimaryKey("OrderItem", UtilMisc.toMap("orderId", orderId, "orderItemSeqId", orderItemSeqId));
if (!"ITEM_CANCELLED".equals(orderItem.getString("statusId"))) {
// make sure the item hasn't already been returned
List<GenericValue> returnItems = orderItem.getRelated("ReturnItem");
if (UtilValidate.isEmpty(returnItems)) {
BigDecimal txAmt = trans.getBigDecimal("amount");
BigDecimal refAmt = txAmt;
if (remainingBalance.compareTo(txAmt) == -1) {
refAmt = remainingBalance;
}
remainingBalance = remainingBalance.subtract(refAmt);
refundAmount = refundAmount.add(refAmt);
// create the return header
Map<String, Object> rhCtx = UtilMisc.toMap("returnHeaderTypeId", "CUSTOMER_RETURN", "fromPartyId", finAccount.getString("ownerPartyId"), "toPartyId", productStore.getString("payToPartyId"), "userLogin", userLogin);
Map<String, Object> rhResp = dispatcher.runSync("createReturnHeader", rhCtx);
if (ServiceUtil.isError(rhResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(rhResp));
}
String returnId = (String) rhResp.get("returnId");
// create the return item
Map<String, Object> returnItemCtx = FastMap.newInstance();
returnItemCtx.put("returnId", returnId);
returnItemCtx.put("orderId", orderId);
returnItemCtx.put("description", orderItem.getString("itemDescription"));
returnItemCtx.put("orderItemSeqId", orderItemSeqId);
returnItemCtx.put("returnQuantity", BigDecimal.ONE);
returnItemCtx.put("receivedQuantity", BigDecimal.ONE);
returnItemCtx.put("returnPrice", refAmt);
returnItemCtx.put("returnReasonId", "RTN_NOT_WANT");
returnItemCtx.put("returnTypeId", "RTN_REFUND"); // refund return
returnItemCtx.put("returnItemTypeId", "RET_NPROD_ITEM");
returnItemCtx.put("userLogin", userLogin);
Map<String, Object> retItResp = dispatcher.runSync("createReturnItem", returnItemCtx);
if (ServiceUtil.isError(retItResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(retItResp));
}
String returnItemSeqId = (String) retItResp.get("returnItemSeqId");
// approve the return
Map<String, Object> appRet = UtilMisc.toMap("statusId", "RETURN_ACCEPTED", "returnId", returnId, "userLogin", userLogin);
Map<String, Object> appResp = dispatcher.runSync("updateReturnHeader", appRet);
if (ServiceUtil.isError(appResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(appResp));
}
// "receive" the return - should trigger the refund
Map<String, Object> recRet = UtilMisc.toMap("statusId", "RETURN_RECEIVED", "returnId", returnId, "userLogin", userLogin);
Map<String, Object> recResp = dispatcher.runSync("updateReturnHeader", recRet);
if (ServiceUtil.isError(recResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(recResp));
}
// get the return item
GenericValue returnItem = delegator.findByPrimaryKey("ReturnItem",
UtilMisc.toMap("returnId", returnId, "returnItemSeqId", returnItemSeqId));
GenericValue response = returnItem.getRelatedOne("ReturnItemResponse");
if (response == null) {
throw new GeneralException("No return response found for: " + returnItem.getPrimaryKey());
}
String paymentId = response.getString("paymentId");
// create the adjustment transaction
Map<String, Object> txCtx = FastMap.newInstance();
txCtx.put("finAccountTransTypeId", "ADJUSTMENT");
txCtx.put("finAccountId", finAccountId);
txCtx.put("orderId", orderId);
txCtx.put("orderItemSeqId", orderItemSeqId);
txCtx.put("paymentId", paymentId);
txCtx.put("amount", refAmt.negate());
txCtx.put("partyId", finAccount.getString("ownerPartyId"));
txCtx.put("userLogin", userLogin);
Map<String, Object> txResp = dispatcher.runSync("createFinAccountTrans", txCtx);
if (ServiceUtil.isError(txResp)) {
throw new GeneralException(ServiceUtil.getErrorMessage(txResp));
}
}
}
}
}
} catch (GeneralException e) {
Debug.logError(e, module);
return ServiceUtil.returnError(e.getMessage());
} finally {
if (eli != null) {
try {
eli.close();
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
}
}
// check to make sure we balanced out
if (remainingBalance.compareTo(FinAccountHelper.ZERO) == 1) {
result = ServiceUtil.returnSuccess(UtilProperties.getMessage(resourceError,
"AccountingFinAccountPartiallyRefunded", locale));
}
}
}
if (result == null) {
result = ServiceUtil.returnSuccess();
}
return result;
}
}