/**
* Retrieves a group of user preferences from persistent storage. Call with userPrefGroupTypeId
* and optional userPrefLoginId. If userPrefLoginId isn't specified, then the currently logged-in
* user's userLoginId will be used. The retrieved preferences group is contained in the
* <b>userPrefMap</b> element.
*
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> getUserPreferenceGroup(
DispatchContext ctx, Map<String, ?> context) {
Locale locale = (Locale) context.get("locale");
if (!PreferenceWorker.isValidGetId(ctx, context)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "getPreference.permissionError", locale));
}
Delegator delegator = ctx.getDelegator();
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isEmpty(userPrefGroupTypeId)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "getPreference.invalidArgument", locale));
}
String userLoginId = PreferenceWorker.getUserLoginId(context, true);
Map<String, Object> userPrefMap = null;
try {
Map<String, String> fieldMap =
UtilMisc.toMap("userLoginId", "_NA_", "userPrefGroupTypeId", userPrefGroupTypeId);
userPrefMap =
PreferenceWorker.createUserPrefMap(delegator.findByAnd("UserPreference", fieldMap));
fieldMap.put("userLoginId", userLoginId);
userPrefMap.putAll(
PreferenceWorker.createUserPrefMap(delegator.findByAnd("UserPreference", fieldMap)));
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale));
}
// for the 'DEFAULT' values find the related values in general properties and if found use
// those.
Iterator it = userPrefMap.entrySet().iterator();
Map generalProperties = UtilProperties.getProperties("general");
while (it.hasNext()) {
Map.Entry pairs = (Map.Entry) it.next();
if ("DEFAULT".equals(pairs.getValue())) {
if (UtilValidate.isNotEmpty(generalProperties.get(pairs.getKey()))) {
userPrefMap.put((String) pairs.getKey(), generalProperties.get(pairs.getKey()));
}
}
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("userPrefMap", userPrefMap);
return result;
}
public static List<Map<String, GenericValue>> getPartyPaymentMethodValueMaps(
Delegator delegator, String partyId, Boolean showOld) {
List<Map<String, GenericValue>> paymentMethodValueMaps = FastList.newInstance();
try {
List<GenericValue> paymentMethods =
delegator.findByAnd("PaymentMethod", UtilMisc.toMap("partyId", partyId));
if (!showOld) paymentMethods = EntityUtil.filterByDate(paymentMethods, true);
for (GenericValue paymentMethod : paymentMethods) {
Map<String, GenericValue> valueMap = FastMap.newInstance();
paymentMethodValueMaps.add(valueMap);
valueMap.put("paymentMethod", paymentMethod);
if ("CREDIT_CARD".equals(paymentMethod.getString("paymentMethodTypeId"))) {
GenericValue creditCard = paymentMethod.getRelatedOne("CreditCard");
if (creditCard != null) valueMap.put("creditCard", creditCard);
} else if ("GIFT_CARD".equals(paymentMethod.getString("paymentMethodTypeId"))) {
GenericValue giftCard = paymentMethod.getRelatedOne("GiftCard");
if (giftCard != null) valueMap.put("giftCard", giftCard);
} else if ("EFT_ACCOUNT".equals(paymentMethod.getString("paymentMethodTypeId"))) {
GenericValue eftAccount = paymentMethod.getRelatedOne("EftAccount");
if (eftAccount != null) valueMap.put("eftAccount", eftAccount);
}
}
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
return paymentMethodValueMaps;
}
public static boolean isBinComplete(Delegator delegator, String picklistBinId)
throws GeneralException {
// lookup the items in the bin
List<GenericValue> items;
try {
items = delegator.findByAnd("PicklistItem", UtilMisc.toMap("picklistBinId", picklistBinId));
} catch (GenericEntityException e) {
Debug.logError(e, module);
throw e;
}
if (!UtilValidate.isEmpty(items)) {
for (GenericValue v : items) {
String itemStatus = v.getString("itemStatusId");
if (itemStatus != null) {
if (!"PICKITEM_COMPLETED".equals(itemStatus)) {
return false;
}
}
}
return true;
}
return false;
}
/**
* Retrieve the last deactivation date if the party is currently deactivated.
*
* @param partyId
* @param delegator
* @return the timestamp of last deactivation, null if the party is not deactivated
* @throws GenericEntityNotFoundException
*/
public static Timestamp getDeactivationDate(String partyId, Delegator delegator)
throws GenericEntityException {
// check party current status:
if (isActive(partyId, delegator)) {
return null;
}
// party is currently deactivated, get the deactivation date
try {
List<GenericValue> deactivationDates =
delegator.findByAnd(
"PartyDeactivation",
UtilMisc.toMap("partyId", partyId),
UtilMisc.toList("-deactivationTimestamp"));
if (UtilValidate.isNotEmpty(deactivationDates)) {
return (Timestamp) deactivationDates.get(0).get("deactivationTimestamp");
} else {
Debug.logWarning(
"The party ["
+ partyId
+ "] status is disabled but there is no registered deactivation date.",
MODULE);
}
} catch (GenericEntityException e) {
Debug.logError(e, MODULE);
}
return null;
}
/** Checks if the given party with role is assigned to the user login. */
public static boolean isAssignedToUserLogin(
String partyId, String roleTypeId, GenericValue userLogin) throws GenericEntityException {
Delegator delegator = userLogin.getDelegator();
String roleTypeIdTo =
getFirstValidTeamMemberRoleTypeId(userLogin.getString("partyId"), delegator);
if (roleTypeIdTo == null) {
return false;
}
List<GenericValue> activeRelationships =
EntityUtil.filterByDate(
delegator.findByAnd(
"PartyRelationship",
UtilMisc.toMap(
"partyIdFrom",
partyId,
"roleTypeIdFrom",
roleTypeId,
"partyIdTo",
userLogin.get("partyId"),
"roleTypeIdTo",
roleTypeIdTo,
"partyRelationshipTypeId",
"ASSIGNED_TO")));
return activeRelationships.size() > 0;
}
/**
* Copies a user preference group. Call with fromUserLoginId, userPrefGroupTypeId and optional
* userPrefLoginId. If userPrefLoginId isn't specified, then the currently logged-in user's
* userLoginId will be used.
*
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> copyUserPreferenceGroup(
DispatchContext ctx, Map<String, ?> context) {
Delegator delegator = ctx.getDelegator();
Locale locale = (Locale) context.get("locale");
String userLoginId = PreferenceWorker.getUserLoginId(context, false);
String fromUserLoginId = (String) context.get("fromUserLoginId");
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isEmpty(userLoginId)
|| UtilValidate.isEmpty(userPrefGroupTypeId)
|| UtilValidate.isEmpty(fromUserLoginId)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "copyPreference.invalidArgument", locale));
}
try {
Map<String, String> fieldMap =
UtilMisc.toMap(
"userLoginId", fromUserLoginId, "userPrefGroupTypeId", userPrefGroupTypeId);
List<GenericValue> resultList = delegator.findByAnd("UserPreference", fieldMap);
if (resultList != null) {
for (GenericValue preference : resultList) {
preference.set("userLoginId", userLoginId);
}
delegator.storeAll(resultList);
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "copyPreference.writeFailure", new Object[] {e.getMessage()}, locale));
}
return ServiceUtil.returnSuccess();
}
public static GenericValue getPaymentAddress(Delegator delegator, String partyId) {
List<GenericValue> paymentAddresses = null;
try {
paymentAddresses =
delegator.findByAnd(
"PartyContactMechPurpose",
UtilMisc.toMap("partyId", partyId, "contactMechPurposeTypeId", "PAYMENT_LOCATION"),
UtilMisc.toList("-fromDate"));
paymentAddresses = EntityUtil.filterByDate(paymentAddresses);
} catch (GenericEntityException e) {
Debug.logError(e, "Trouble getting PartyContactMechPurpose entity list", module);
}
// get the address for the primary contact mech
GenericValue purpose = EntityUtil.getFirst(paymentAddresses);
GenericValue postalAddress = null;
if (purpose != null) {
try {
postalAddress =
delegator.findByPrimaryKey(
"PostalAddress",
UtilMisc.toMap("contactMechId", purpose.getString("contactMechId")));
} catch (GenericEntityException e) {
Debug.logError(
e,
"Trouble getting PostalAddress record for contactMechId: "
+ purpose.getString("contactMechId"),
module);
}
}
return postalAddress;
}
public static Map<String, Object> deactivateContact(
DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Security security = dctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = UtilCommon.getLocale(context);
// what contact we're expiring
String contactPartyId = (String) context.get("partyId");
// check that userLogin has CRMSFA_CONTACT_DEACTIVATE permission for this contact
if (!CrmsfaSecurity.hasPartyRelationSecurity(
security, "CRMSFA_CONTACT", "_DEACTIVATE", userLogin, contactPartyId)) {
return UtilMessage.createAndLogServiceError("CrmErrorPermissionDenied", locale, MODULE);
}
// when to expire the contact
Timestamp expireDate = (Timestamp) context.get("expireDate");
if (expireDate == null) {
expireDate = UtilDateTime.nowTimestamp();
}
// in order to deactivate a contact, we expire all party relationships on the expire date
try {
List<GenericValue> partyRelationships =
delegator.findByAnd(
"PartyRelationship",
UtilMisc.toMap("partyIdFrom", contactPartyId, "roleTypeIdFrom", "CONTACT"));
PartyHelper.expirePartyRelationships(partyRelationships, expireDate, dispatcher, userLogin);
} catch (GenericEntityException e) {
return UtilMessage.createAndLogServiceError(
e, "CrmErrorDeactivateContactFail", locale, MODULE);
} catch (GenericServiceException e) {
return UtilMessage.createAndLogServiceError(
e, "CrmErrorDeactivateContactFail", locale, MODULE);
}
// set the party statusId to PARTY_DISABLED and register the PartyDeactivation
try {
GenericValue contactParty =
delegator.findByPrimaryKey("Party", UtilMisc.toMap("partyId", contactPartyId));
contactParty.put("statusId", "PARTY_DISABLED");
contactParty.store();
delegator.create(
"PartyDeactivation",
UtilMisc.toMap("partyId", contactPartyId, "deactivationTimestamp", expireDate));
} catch (GenericEntityException e) {
return UtilMessage.createAndLogServiceError(
e, "CrmErrorDeactivateAccountFail", locale, MODULE);
}
return ServiceUtil.returnSuccess();
}
/**
* Retrieves a single user preference from persistent storage. Call with userPrefTypeId and
* optional userPrefLoginId. If userPrefLoginId isn't specified, then the currently logged-in
* user's userLoginId will be used. The retrieved preference is contained in the
* <b>userPrefMap</b> element.
*
* @param ctx The DispatchContext that this service is operating in.
* @param context Map containing the input arguments.
* @return Map with the result of the service, the output parameters.
*/
public static Map<String, Object> getUserPreference(DispatchContext ctx, Map<String, ?> context) {
Locale locale = (Locale) context.get("locale");
if (!PreferenceWorker.isValidGetId(ctx, context)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "getPreference.permissionError", locale));
}
Delegator delegator = ctx.getDelegator();
String userPrefTypeId = (String) context.get("userPrefTypeId");
if (UtilValidate.isEmpty(userPrefTypeId)) {
return ServiceUtil.returnError(
UtilProperties.getMessage(resource, "getPreference.invalidArgument", locale));
}
String userLoginId = PreferenceWorker.getUserLoginId(context, true);
Map<String, String> fieldMap =
UtilMisc.toMap("userLoginId", userLoginId, "userPrefTypeId", userPrefTypeId);
String userPrefGroupTypeId = (String) context.get("userPrefGroupTypeId");
if (UtilValidate.isNotEmpty(userPrefGroupTypeId)) {
fieldMap.put("userPrefGroupTypeId", userPrefGroupTypeId);
}
Map<String, Object> userPrefMap = null;
try {
GenericValue preference =
EntityUtil.getFirst(delegator.findByAnd("UserPreference", fieldMap));
if (preference != null) {
userPrefMap = PreferenceWorker.createUserPrefMap(preference);
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale));
} catch (GeneralException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
UtilProperties.getMessage(
resource, "getPreference.readFailure", new Object[] {e.getMessage()}, locale));
}
Map<String, Object> result = ServiceUtil.returnSuccess();
result.put("userPrefMap", userPrefMap);
if (userPrefMap != null) {
// Put the value in the result Map too, makes access easier for calling methods.
Object userPrefValue = userPrefMap.get(userPrefTypeId);
if (userPrefValue != null) {
result.put("userPrefValue", userPrefValue);
}
}
return result;
}
public static Map<String, Object> reassignContactResponsibleParty(
DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Security security = dctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = UtilCommon.getLocale(context);
String contactPartyId = (String) context.get("contactPartyId");
String newPartyId = (String) context.get("newPartyId");
// ensure reassign permission on this contact
if (!CrmsfaSecurity.hasPartyRelationSecurity(
security, "CRMSFA_CONTACT", "_REASSIGN", userLogin, contactPartyId)) {
return UtilMessage.createAndLogServiceError("CrmErrorPermissionDenied", locale, MODULE);
}
try {
// we need to expire all the active ASSIGNED_TO relationships from the contact party to the
// new owner party
List<GenericValue> activeAssignedToRelationships =
EntityUtil.filterByDate(
delegator.findByAnd(
"PartyRelationship",
UtilMisc.toMap(
"partyIdFrom",
contactPartyId,
"roleTypeIdFrom",
"CONTACT",
"partyIdTo",
newPartyId,
"partyRelationshipTypeId",
"ASSIGNED_TO")));
PartyHelper.expirePartyRelationships(
activeAssignedToRelationships, UtilDateTime.nowTimestamp(), dispatcher, userLogin);
// reassign relationship using a helper method
boolean result =
createResponsibleContactRelationshipForParty(
newPartyId, contactPartyId, userLogin, delegator, dispatcher);
if (!result) {
return UtilMessage.createAndLogServiceError("CrmErrorReassignFail", locale, MODULE);
}
} catch (GenericServiceException e) {
return UtilMessage.createAndLogServiceError(e, "CrmErrorReassignFail", locale, MODULE);
} catch (GenericEntityException e) {
return UtilMessage.createAndLogServiceError(e, "CrmErrorReassignFail", locale, MODULE);
}
return ServiceUtil.returnSuccess();
}
/** Checks if the given party with role is unassigned. */
public static boolean isUnassigned(Delegator delegator, String partyId, String roleTypeId)
throws GenericEntityException {
List<GenericValue> activeRelationships =
EntityUtil.filterByDate(
delegator.findByAnd(
"PartyRelationship",
UtilMisc.toMap(
"partyIdFrom",
partyId,
"roleTypeIdFrom",
roleTypeId,
"partyRelationshipTypeId",
"ASSIGNED_TO")));
return activeRelationships.size() == 0;
}
public static GenericValue findPartyLatestUserLogin(String partyId, Delegator delegator) {
try {
List<GenericValue> userLoginList =
delegator.findByAnd(
"UserLogin",
UtilMisc.toMap("partyId", partyId),
UtilMisc.toList("-" + ModelEntity.STAMP_FIELD));
return EntityUtil.getFirst(userLoginList);
} catch (GenericEntityException e) {
Debug.logError(
e,
"Error while finding latest UserLogin for party with ID ["
+ partyId
+ "]: "
+ e.toString(),
module);
return null;
}
}
public static Timestamp findPartyLastLoginTime(String partyId, Delegator delegator) {
try {
List<GenericValue> loginHistory =
delegator.findByAnd(
"UserLoginHistory", UtilMisc.toMap("partyId", partyId), UtilMisc.toList("-fromDate"));
GenericValue v = EntityUtil.getFirst(loginHistory);
if (v != null) {
return v.getTimestamp("fromDate");
} else {
return null;
}
} catch (GenericEntityException e) {
Debug.logError(
e,
"Error while finding latest login time for party with ID ["
+ partyId
+ "]: "
+ e.toString(),
module);
return null;
}
}
public static GenericValue findPartyLatestContactMech(
String partyId, String contactMechTypeId, Delegator delegator) {
try {
List<GenericValue> cmList =
delegator.findByAnd(
"PartyAndContactMech",
UtilMisc.toMap("partyId", partyId, "contactMechTypeId", contactMechTypeId),
UtilMisc.toList("-fromDate"));
cmList = EntityUtil.filterByDate(cmList);
return EntityUtil.getFirst(cmList);
} catch (GenericEntityException e) {
Debug.logError(
e,
"Error while finding latest ContactMech for party with ID ["
+ partyId
+ "] TYPE ["
+ contactMechTypeId
+ "]: "
+ e.toString(),
module);
return null;
}
}
public static Map<String, Object> removeContactFromAccount(
DispatchContext dctx, Map<String, Object> context) {
Delegator delegator = dctx.getDelegator();
LocalDispatcher dispatcher = dctx.getDispatcher();
Security security = dctx.getSecurity();
GenericValue userLogin = (GenericValue) context.get("userLogin");
Locale locale = UtilCommon.getLocale(context);
String contactPartyId = (String) context.get("contactPartyId");
String accountPartyId = (String) context.get("accountPartyId");
// ensure update permission on account
if (!CrmsfaSecurity.hasPartyRelationSecurity(
security, "CRMSFA_ACCOUNT", "_UPDATE", userLogin, accountPartyId)) {
return UtilMessage.createAndLogServiceError("CrmErrorPermissionDenied", locale, MODULE);
}
try {
// find and expire all contact relationships between the contact and account
List<GenericValue> relations =
delegator.findByAnd(
"PartyRelationship",
UtilMisc.toMap(
"partyIdTo",
accountPartyId,
"partyIdFrom",
contactPartyId,
"partyRelationshipTypeId",
PartyRelationshipTypeConstants.CONTACT_REL_INV));
PartyHelper.expirePartyRelationships(
relations, UtilDateTime.nowTimestamp(), dispatcher, userLogin);
} catch (GenericServiceException e) {
return UtilMessage.createAndLogServiceError(e, "CrmErrorRemoveContactFail", locale, MODULE);
} catch (GenericEntityException e) {
return UtilMessage.createAndLogServiceError(e, "CrmErrorRemoveContactFail", locale, MODULE);
}
return ServiceUtil.returnSuccess();
}
public static boolean isProductInCategory(
Delegator delegator, String productId, String productCategoryId)
throws GenericEntityException {
if (productCategoryId == null) return false;
if (UtilValidate.isEmpty(productId)) return false;
List<GenericValue> productCategoryMembers =
EntityUtil.filterByDate(
delegator.findByAnd(
"ProductCategoryMember",
UtilMisc.toMap("productCategoryId", productCategoryId, "productId", productId),
null,
true),
true);
if (UtilValidate.isEmpty(productCategoryMembers)) {
// before giving up see if this is a variant product, and if so look up the virtual product
// and check it...
GenericValue product =
delegator.findOne("Product", UtilMisc.toMap("productId", productId), true);
List<GenericValue> productAssocs = ProductWorker.getVariantVirtualAssocs(product);
// this does take into account that a product could be a variant of multiple products, but
// this shouldn't ever really happen...
if (productAssocs != null) {
for (GenericValue productAssoc : productAssocs) {
if (isProductInCategory(
delegator, productAssoc.getString("productId"), productCategoryId)) {
return true;
}
}
}
return false;
} else {
return true;
}
}
public static Map<String, Object> assembleCrmsfaShipmentFormMergeContext(
Delegator delegator,
String orderId,
String shipGroupSeqId,
String shipmentId,
Locale locale) {
Map<String, Object> templateContext = new HashMap<String, Object>();
try {
// Prefer shipment data if shipmentId is provided
if (UtilValidate.isNotEmpty(shipmentId)) {
GenericValue shipment =
delegator.findByPrimaryKey("Shipment", UtilMisc.toMap("shipmentId", shipmentId));
if (UtilValidate.isNotEmpty(shipment)) {
GenericValue shipLoc = shipment.getRelatedOne("DestinationPostalAddress");
if (UtilValidate.isNotEmpty(shipLoc)) {
templateContext.put("orderShippingAddress1", shipLoc.get("address1"));
templateContext.put("orderShippingAddress2", shipLoc.get("address2"));
templateContext.put("orderShippingCity", shipLoc.get("city"));
templateContext.put("orderShippingPostalCode", shipLoc.get("postalCode"));
GenericValue stateProvGeo = shipLoc.getRelatedOne("StateProvinceGeo");
if (UtilValidate.isNotEmpty(stateProvGeo)) {
templateContext.put("orderShippingStateProvince", stateProvGeo.get("geoName"));
}
GenericValue countryGeo = shipLoc.getRelatedOne("CountryGeo");
if (UtilValidate.isNotEmpty(countryGeo)) {
templateContext.put("orderShippingCountry", countryGeo.get("geoName"));
}
}
GenericValue phoneNumber = shipment.getRelatedOne("DestinationTelecomNumber");
if (UtilValidate.isNotEmpty(phoneNumber)) {
String phoneNumberString =
UtilValidate.isEmpty(phoneNumber.getString("countryCode"))
? ""
: phoneNumber.getString("countryCode") + " ";
if (UtilValidate.isNotEmpty(phoneNumber.getString("areaCode"))) {
phoneNumberString += phoneNumber.getString("areaCode") + " ";
}
if (UtilValidate.isNotEmpty(phoneNumber.getString("contactNumber"))) {
phoneNumberString += phoneNumber.getString("contactNumber");
}
templateContext.put("orderShippingPhone", phoneNumberString);
}
GenericValue statusItem = shipment.getRelatedOne("StatusItem");
if (UtilValidate.isNotEmpty(statusItem)) {
templateContext.put("shipmentStatus", statusItem.get("description", locale));
}
}
} else if (UtilValidate.isNotEmpty(orderId)) {
OrderReadHelper orh = new OrderReadHelper(delegator, orderId);
GenericValue shipGroup = orh.getOrderItemShipGroup(shipGroupSeqId);
if (UtilValidate.isEmpty(shipGroup)) {
// Default to the first ship group if no shipGroupSeqId is provided
List shipGroups = orh.getOrderItemShipGroups();
if (UtilValidate.isNotEmpty(shipGroups)) {
shipGroup = (GenericValue) shipGroups.get(0);
}
}
if (UtilValidate.isNotEmpty(shipGroup)) {
GenericValue shipLoc = shipGroup.getRelatedOne("PostalAddress");
if (UtilValidate.isNotEmpty(shipLoc)) {
templateContext.put("orderShippingAddress1", shipLoc.get("address1"));
templateContext.put("orderShippingAddress2", shipLoc.get("address2"));
templateContext.put("orderShippingCity", shipLoc.get("city"));
templateContext.put("orderShippingPostalCode", shipLoc.get("postalCode"));
GenericValue stateProvGeo = shipLoc.getRelatedOne("StateProvinceGeo");
if (UtilValidate.isNotEmpty(stateProvGeo)) {
templateContext.put("orderShippingStateProvince", stateProvGeo.get("geoName"));
}
GenericValue countryGeo = shipLoc.getRelatedOne("CountryGeo");
if (UtilValidate.isNotEmpty(countryGeo)) {
templateContext.put("orderShippingCountry", countryGeo.get("geoName"));
}
}
GenericValue phoneNumber = shipGroup.getRelatedOne("TelecomTelecomNumber");
if (UtilValidate.isNotEmpty(phoneNumber)) {
String phoneNumberString =
UtilValidate.isEmpty(phoneNumber.getString("countryCode"))
? ""
: phoneNumber.getString("countryCode") + " ";
if (UtilValidate.isNotEmpty(phoneNumber.getString("areaCode"))) {
phoneNumberString += phoneNumber.getString("areaCode") + " ";
}
if (UtilValidate.isNotEmpty(phoneNumber.getString("contactNumber"))) {
phoneNumberString += phoneNumber.getString("contactNumber");
}
templateContext.put("orderShippingPhone", phoneNumberString);
}
// Find any shipments relating to this ship group
List<GenericValue> shipments =
delegator.findByAnd(
"Shipment",
UtilMisc.toMap(
"primaryOrderId",
orderId,
"primaryShipGroupSeqId",
shipGroup.getString("shipGroupSeqId")),
UtilMisc.toList("createdStamp DESC"));
GenericValue shipment = EntityUtil.getFirst(shipments);
if (UtilValidate.isNotEmpty(shipment)) {
GenericValue statusItem = shipment.getRelatedOne("StatusItem");
if (UtilValidate.isNotEmpty(statusItem)) {
templateContext.put("shipmentStatus", statusItem.get("description", locale));
}
}
}
}
} catch (GenericEntityException e) {
Debug.logError(e, MODULE);
}
return templateContext;
}
private static List<GenericValue> getTaxAdjustments(
Delegator delegator,
GenericValue product,
GenericValue productStore,
String payToPartyId,
String billToPartyId,
Set<GenericValue> taxAuthoritySet,
BigDecimal itemPrice,
BigDecimal itemQuantity,
BigDecimal itemAmount,
BigDecimal shippingAmount,
BigDecimal orderPromotionsAmount) {
Timestamp nowTimestamp = UtilDateTime.nowTimestamp();
List<GenericValue> adjustments = FastList.newInstance();
if (payToPartyId == null) {
if (productStore != null) {
payToPartyId = productStore.getString("payToPartyId");
}
}
// store expr
EntityCondition storeCond = null;
if (productStore != null) {
storeCond =
EntityCondition.makeCondition(
EntityCondition.makeCondition(
"productStoreId", EntityOperator.EQUALS, productStore.get("productStoreId")),
EntityOperator.OR,
EntityCondition.makeCondition("productStoreId", EntityOperator.EQUALS, null));
} else {
storeCond = EntityCondition.makeCondition("productStoreId", EntityOperator.EQUALS, null);
}
// build the TaxAuthority expressions (taxAuthGeoId, taxAuthPartyId)
List<EntityCondition> taxAuthCondOrList = FastList.newInstance();
// start with the _NA_ TaxAuthority...
taxAuthCondOrList.add(
EntityCondition.makeCondition(
EntityCondition.makeCondition("taxAuthPartyId", EntityOperator.EQUALS, "_NA_"),
EntityOperator.AND,
EntityCondition.makeCondition("taxAuthGeoId", EntityOperator.EQUALS, "_NA_")));
for (GenericValue taxAuthority : taxAuthoritySet) {
EntityCondition taxAuthCond =
EntityCondition.makeCondition(
EntityCondition.makeCondition(
"taxAuthPartyId",
EntityOperator.EQUALS,
taxAuthority.getString("taxAuthPartyId")),
EntityOperator.AND,
EntityCondition.makeCondition(
"taxAuthGeoId", EntityOperator.EQUALS, taxAuthority.getString("taxAuthGeoId")));
taxAuthCondOrList.add(taxAuthCond);
}
EntityCondition taxAuthoritiesCond =
EntityCondition.makeCondition(taxAuthCondOrList, EntityOperator.OR);
try {
EntityCondition productCategoryCond = null;
if (product != null) {
// find the tax categories associated with the product and filter by those, with an IN
// clause or some such
// if this product is variant, find the virtual product id and consider also the categories
// of the virtual
// question: get all categories, or just a special type? for now let's do all categories...
String virtualProductId = null;
if ("Y".equals(product.getString("isVariant"))) {
virtualProductId = ProductWorker.getVariantVirtualId(product);
}
Set<String> productCategoryIdSet = FastSet.newInstance();
EntityCondition productIdCond = null;
if (virtualProductId != null) {
productIdCond =
EntityCondition.makeCondition(
EntityCondition.makeCondition(
"productId", EntityOperator.EQUALS, product.getString("productId")),
EntityOperator.OR,
EntityCondition.makeCondition(
"productId", EntityOperator.EQUALS, virtualProductId));
} else {
productIdCond =
EntityCondition.makeCondition(
"productId", EntityOperator.EQUALS, product.getString("productId"));
}
List<GenericValue> pcmList =
delegator.findList(
"ProductCategoryMember",
productIdCond,
UtilMisc.toSet("productCategoryId", "fromDate", "thruDate"),
null,
null,
true);
pcmList = EntityUtil.filterByDate(pcmList, true);
for (GenericValue pcm : pcmList) {
productCategoryIdSet.add(pcm.getString("productCategoryId"));
}
if (productCategoryIdSet.size() == 0) {
productCategoryCond =
EntityCondition.makeCondition("productCategoryId", EntityOperator.EQUALS, null);
} else {
productCategoryCond =
EntityCondition.makeCondition(
EntityCondition.makeCondition("productCategoryId", EntityOperator.EQUALS, null),
EntityOperator.OR,
EntityCondition.makeCondition(
"productCategoryId", EntityOperator.IN, productCategoryIdSet));
}
} else {
productCategoryCond =
EntityCondition.makeCondition("productCategoryId", EntityOperator.EQUALS, null);
}
// FIXME handles shipping and promo tax. Simple solution, see
// https://issues.apache.org/jira/browse/OFBIZ-4160 for a better one
if (product == null && shippingAmount != null) {
EntityCondition taxShippingCond =
EntityCondition.makeCondition(
EntityCondition.makeCondition("taxShipping", EntityOperator.EQUALS, null),
EntityOperator.OR,
EntityCondition.makeCondition("taxShipping", EntityOperator.EQUALS, "Y"));
if (productCategoryCond != null) {
productCategoryCond =
EntityCondition.makeCondition(
productCategoryCond, EntityOperator.OR, taxShippingCond);
}
}
if (product == null && orderPromotionsAmount != null) {
EntityCondition taxOrderPromotionsCond =
EntityCondition.makeCondition(
EntityCondition.makeCondition("taxPromotions", EntityOperator.EQUALS, null),
EntityOperator.OR,
EntityCondition.makeCondition("taxPromotions", EntityOperator.EQUALS, "Y"));
if (productCategoryCond != null) {
productCategoryCond =
EntityCondition.makeCondition(
productCategoryCond, EntityOperator.OR, taxOrderPromotionsCond);
}
}
// build the main condition clause
List<EntityCondition> mainExprs =
UtilMisc.toList(storeCond, taxAuthoritiesCond, productCategoryCond);
mainExprs.add(
EntityCondition.makeCondition(
EntityCondition.makeCondition("minItemPrice", EntityOperator.EQUALS, null),
EntityOperator.OR,
EntityCondition.makeCondition(
"minItemPrice", EntityOperator.LESS_THAN_EQUAL_TO, itemPrice)));
mainExprs.add(
EntityCondition.makeCondition(
EntityCondition.makeCondition("minPurchase", EntityOperator.EQUALS, null),
EntityOperator.OR,
EntityCondition.makeCondition(
"minPurchase", EntityOperator.LESS_THAN_EQUAL_TO, itemAmount)));
EntityCondition mainCondition = EntityCondition.makeCondition(mainExprs, EntityOperator.AND);
// create the orderby clause
List<String> orderList = UtilMisc.<String>toList("minItemPrice", "minPurchase", "fromDate");
// finally ready... do the rate query
List<GenericValue> lookupList =
delegator.findList(
"TaxAuthorityRateProduct", mainCondition, null, orderList, null, false);
List<GenericValue> filteredList = EntityUtil.filterByDate(lookupList, true);
if (filteredList.size() == 0) {
Debug.logWarning(
"In TaxAuthority Product Rate no records were found for condition:"
+ mainCondition.toString(),
module);
return adjustments;
}
// find the right entry(s) based on purchase amount
for (GenericValue taxAuthorityRateProduct : filteredList) {
BigDecimal taxRate =
taxAuthorityRateProduct.get("taxPercentage") != null
? taxAuthorityRateProduct.getBigDecimal("taxPercentage")
: ZERO_BASE;
BigDecimal taxable = ZERO_BASE;
if (product != null
&& (product.get("taxable") == null
|| (product.get("taxable") != null
&& product.getBoolean("taxable").booleanValue()))) {
taxable = taxable.add(itemAmount);
}
if (shippingAmount != null
&& taxAuthorityRateProduct != null
&& (taxAuthorityRateProduct.get("taxShipping") == null
|| (taxAuthorityRateProduct.get("taxShipping") != null
&& taxAuthorityRateProduct.getBoolean("taxShipping").booleanValue()))) {
taxable = taxable.add(shippingAmount);
}
if (orderPromotionsAmount != null
&& taxAuthorityRateProduct != null
&& (taxAuthorityRateProduct.get("taxPromotions") == null
|| (taxAuthorityRateProduct.get("taxPromotions") != null
&& taxAuthorityRateProduct.getBoolean("taxPromotions").booleanValue()))) {
taxable = taxable.add(orderPromotionsAmount);
}
if (taxable.compareTo(BigDecimal.ZERO) == 0) {
// this should make it less confusing if the taxable flag on the product is not Y/true,
// and there is no shipping and such
continue;
}
// taxRate is in percentage, so needs to be divided by 100
BigDecimal taxAmount =
(taxable.multiply(taxRate))
.divide(PERCENT_SCALE, salestaxCalcDecimals, salestaxRounding);
String taxAuthGeoId = taxAuthorityRateProduct.getString("taxAuthGeoId");
String taxAuthPartyId = taxAuthorityRateProduct.getString("taxAuthPartyId");
// get glAccountId from TaxAuthorityGlAccount entity using the payToPartyId as the
// organizationPartyId
GenericValue taxAuthorityGlAccount =
delegator.findByPrimaryKey(
"TaxAuthorityGlAccount",
UtilMisc.toMap(
"taxAuthPartyId",
taxAuthPartyId,
"taxAuthGeoId",
taxAuthGeoId,
"organizationPartyId",
payToPartyId));
String taxAuthGlAccountId = null;
if (taxAuthorityGlAccount != null) {
taxAuthGlAccountId = taxAuthorityGlAccount.getString("glAccountId");
} else {
// TODO: what to do if no TaxAuthorityGlAccount found? Use some default, or is that done
// elsewhere later on?
}
GenericValue productPrice = null;
if (product != null && taxAuthPartyId != null && taxAuthGeoId != null) {
// find a ProductPrice for the productId and taxAuth* valxues, and see if it has a
// priceWithTax value
Map<String, String> priceFindMap =
UtilMisc.toMap(
"productId",
product.getString("productId"),
"taxAuthPartyId",
taxAuthPartyId,
"taxAuthGeoId",
taxAuthGeoId,
"productPricePurposeId",
"PURCHASE");
List<GenericValue> productPriceList =
delegator.findByAnd("ProductPrice", priceFindMap, UtilMisc.toList("-fromDate"));
productPriceList = EntityUtil.filterByDate(productPriceList, true);
productPrice =
(productPriceList != null && productPriceList.size() > 0)
? productPriceList.get(0)
: null;
// Debug.logInfo("=================== productId=" + product.getString("productId"),
// module);
// Debug.logInfo("=================== productPrice=" + productPrice, module);
}
GenericValue taxAdjValue = delegator.makeValue("OrderAdjustment");
if (productPrice != null && "Y".equals(productPrice.getString("taxInPrice"))) {
// tax is in the price already, so we want the adjustment to be a VAT_TAX adjustment to be
// subtracted instead of a SALES_TAX adjustment to be added
taxAdjValue.set("orderAdjustmentTypeId", "VAT_TAX");
// the amount will be different because we want to figure out how much of the price was
// tax, and not how much tax needs to be added
// the formula is: taxAmount = priceWithTax - (priceWithTax/(1+taxPercentage/100))
BigDecimal taxAmountIncluded =
itemAmount.subtract(
itemAmount.divide(
BigDecimal.ONE.add(
taxRate.divide(PERCENT_SCALE, 4, BigDecimal.ROUND_HALF_UP)),
3,
BigDecimal.ROUND_HALF_UP));
taxAdjValue.set("amountAlreadyIncluded", taxAmountIncluded);
taxAdjValue.set("amount", BigDecimal.ZERO);
} else {
taxAdjValue.set("orderAdjustmentTypeId", "SALES_TAX");
taxAdjValue.set("amount", taxAmount);
}
taxAdjValue.set("sourcePercentage", taxRate);
taxAdjValue.set(
"taxAuthorityRateSeqId", taxAuthorityRateProduct.getString("taxAuthorityRateSeqId"));
// the primary Geo should be the main jurisdiction that the tax is for, and the secondary
// would just be to define a parent or wrapping jurisdiction of the primary
taxAdjValue.set("primaryGeoId", taxAuthGeoId);
taxAdjValue.set("comments", taxAuthorityRateProduct.getString("description"));
if (taxAuthPartyId != null) taxAdjValue.set("taxAuthPartyId", taxAuthPartyId);
if (taxAuthGlAccountId != null) taxAdjValue.set("overrideGlAccountId", taxAuthGlAccountId);
if (taxAuthGeoId != null) taxAdjValue.set("taxAuthGeoId", taxAuthGeoId);
// check to see if this party has a tax ID for this, and if the party is tax exempt in the
// primary (most-local) jurisdiction
if (UtilValidate.isNotEmpty(billToPartyId) && UtilValidate.isNotEmpty(taxAuthGeoId)) {
// see if partyId is a member of any groups, if so honor their tax exemptions
// look for PartyRelationship with partyRelationshipTypeId=GROUP_ROLLUP, the partyIdTo is
// the group member, so the partyIdFrom is the groupPartyId
Set<String> billToPartyIdSet = FastSet.newInstance();
billToPartyIdSet.add(billToPartyId);
List<GenericValue> partyRelationshipList =
EntityUtil.filterByDate(
delegator.findByAndCache(
"PartyRelationship",
UtilMisc.toMap(
"partyIdTo", billToPartyId, "partyRelationshipTypeId", "GROUP_ROLLUP")),
true);
for (GenericValue partyRelationship : partyRelationshipList) {
billToPartyIdSet.add(partyRelationship.getString("partyIdFrom"));
}
handlePartyTaxExempt(
taxAdjValue,
billToPartyIdSet,
taxAuthGeoId,
taxAuthPartyId,
taxAmount,
nowTimestamp,
delegator);
} else {
Debug.logInfo(
"NOTE: A tax calculation was done without a billToPartyId or taxAuthGeoId, so no tax exemptions or tax IDs considered; billToPartyId=["
+ billToPartyId
+ "] taxAuthGeoId=["
+ taxAuthGeoId
+ "]",
module);
}
adjustments.add(taxAdjValue);
if (productPrice != null
&& itemQuantity != null
&& productPrice.getBigDecimal("priceWithTax") != null
&& !"Y".equals(productPrice.getString("taxInPrice"))) {
BigDecimal priceWithTax = productPrice.getBigDecimal("priceWithTax");
BigDecimal price = productPrice.getBigDecimal("price");
BigDecimal baseSubtotal = price.multiply(itemQuantity);
BigDecimal baseTaxAmount =
(baseSubtotal.multiply(taxRate))
.divide(PERCENT_SCALE, salestaxCalcDecimals, salestaxRounding);
// Debug.logInfo("=================== priceWithTax=" + priceWithTax, module);
// Debug.logInfo("=================== enteredTotalPriceWithTax=" +
// enteredTotalPriceWithTax, module);
// Debug.logInfo("=================== calcedTotalPriceWithTax=" + calcedTotalPriceWithTax,
// module);
// tax is not already in price so we want to add it in, but this is a VAT situation so
// adjust to make it as accurate as possible
// for VAT taxes if the calculated total item price plus calculated taxes is different
// from what would be
// expected based on the original entered price with taxes (if the price was entered this
// way), then create
// an adjustment that corrects for the difference, and this correction will be effectively
// subtracted from the
// price and not from the tax (the tax is meant to be calculated based on Tax Authority
// rules and so should
// not be shorted)
// TODO (don't think this is needed, but just to keep it in mind): get this to work with
// multiple VAT tax authorities instead of just one (right now will get incorrect totals
// if there are multiple taxes included in the price)
// TODO add constraint to ProductPrice lookup by any productStoreGroupId associated with
// the current productStore
BigDecimal enteredTotalPriceWithTax = priceWithTax.multiply(itemQuantity);
BigDecimal calcedTotalPriceWithTax = (baseSubtotal).add(baseTaxAmount);
if (!enteredTotalPriceWithTax.equals(calcedTotalPriceWithTax)) {
// if the calced amount is higher than the entered amount we want the value to be
// negative
// to get it down to match the entered amount
// so, subtract the calced amount from the entered amount (ie: correction = entered -
// calced)
BigDecimal correctionAmount =
enteredTotalPriceWithTax.subtract(calcedTotalPriceWithTax);
// Debug.logInfo("=================== correctionAmount=" + correctionAmount, module);
GenericValue correctionAdjValue = delegator.makeValue("OrderAdjustment");
correctionAdjValue.set(
"taxAuthorityRateSeqId",
taxAuthorityRateProduct.getString("taxAuthorityRateSeqId"));
correctionAdjValue.set("amount", correctionAmount);
// don't set this, causes a doubling of the tax rate because calling code adds up all
// tax rates: correctionAdjValue.set("sourcePercentage", taxRate);
correctionAdjValue.set("orderAdjustmentTypeId", "VAT_PRICE_CORRECT");
// the primary Geo should be the main jurisdiction that the tax is for, and the
// secondary would just be to define a parent or wrapping jurisdiction of the primary
correctionAdjValue.set("primaryGeoId", taxAuthGeoId);
correctionAdjValue.set("comments", taxAuthorityRateProduct.getString("description"));
if (taxAuthPartyId != null) correctionAdjValue.set("taxAuthPartyId", taxAuthPartyId);
if (taxAuthGlAccountId != null)
correctionAdjValue.set("overrideGlAccountId", taxAuthGlAccountId);
if (taxAuthGeoId != null) correctionAdjValue.set("taxAuthGeoId", taxAuthGeoId);
adjustments.add(correctionAdjValue);
}
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Problems looking up tax rates", module);
return FastList.newInstance();
}
return adjustments;
}
public static void indexKeywords(GenericValue product, boolean doAll)
throws GenericEntityException {
if (product == null) return;
Timestamp nowTimestamp = UtilDateTime.nowTimestamp();
if (!doAll) {
if ("N".equals(product.getString("autoCreateKeywords"))) {
return;
}
if ("Y".equals(product.getString("isVariant"))
&& "true"
.equals(UtilProperties.getPropertyValue("prodsearch", "index.ignore.variants"))) {
return;
}
Timestamp salesDiscontinuationDate = product.getTimestamp("salesDiscontinuationDate");
if (salesDiscontinuationDate != null
&& salesDiscontinuationDate.before(nowTimestamp)
&& "true"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.ignore.discontinued.sales"))) {
return;
}
}
Delegator delegator = product.getDelegator();
if (delegator == null) return;
String productId = product.getString("productId");
// get these in advance just once since they will be used many times for the multiple strings to
// index
String separators = KeywordSearchUtil.getSeparators();
String stopWordBagOr = KeywordSearchUtil.getStopWordBagOr();
String stopWordBagAnd = KeywordSearchUtil.getStopWordBagAnd();
boolean removeStems = KeywordSearchUtil.getRemoveStems();
Set<String> stemSet = KeywordSearchUtil.getStemSet();
Map<String, Long> keywords = new TreeMap<String, Long>();
List<String> strings = FastList.newInstance();
int pidWeight = 1;
try {
pidWeight =
Integer.parseInt(
UtilProperties.getPropertyValue("prodsearch", "index.weight.Product.productId", "0"));
} catch (Exception e) {
Debug.logWarning("Could not parse weight number: " + e.toString(), module);
}
keywords.put(product.getString("productId").toLowerCase(), Long.valueOf(pidWeight));
// Product fields - default is 0 if not found in the properties file
if (!"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.Product.productName", "0"))) {
addWeightedKeywordSourceString(product, "productName", strings);
}
if (!"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.Product.internalName", "0"))) {
addWeightedKeywordSourceString(product, "internalName", strings);
}
if (!"0"
.equals(
UtilProperties.getPropertyValue("prodsearch", "index.weight.Product.brandName", "0"))) {
addWeightedKeywordSourceString(product, "brandName", strings);
}
if (!"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.Product.description", "0"))) {
addWeightedKeywordSourceString(product, "description", strings);
}
if (!"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.Product.longDescription", "0"))) {
addWeightedKeywordSourceString(product, "longDescription", strings);
}
// ProductFeatureAppl
if (!"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.ProductFeatureAndAppl.description", "0"))
|| !"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.ProductFeatureAndAppl.abbrev", "0"))
|| !"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.ProductFeatureAndAppl.idCode", "0"))) {
// get strings from attributes and features
List<GenericValue> productFeatureAndAppls =
delegator.findByAnd("ProductFeatureAndAppl", UtilMisc.toMap("productId", productId));
for (GenericValue productFeatureAndAppl : productFeatureAndAppls) {
addWeightedKeywordSourceString(productFeatureAndAppl, "description", strings);
addWeightedKeywordSourceString(productFeatureAndAppl, "abbrev", strings);
addWeightedKeywordSourceString(productFeatureAndAppl, "idCode", strings);
}
}
// ProductAttribute
if (!"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.ProductAttribute.attrName", "0"))
|| !"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.ProductAttribute.attrValue", "0"))) {
List<GenericValue> productAttributes =
delegator.findByAnd("ProductAttribute", UtilMisc.toMap("productId", productId));
for (GenericValue productAttribute : productAttributes) {
addWeightedKeywordSourceString(productAttribute, "attrName", strings);
addWeightedKeywordSourceString(productAttribute, "attrValue", strings);
}
}
// GoodIdentification
if (!"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.GoodIdentification.idValue", "0"))) {
List<GenericValue> goodIdentifications =
delegator.findByAnd("GoodIdentification", UtilMisc.toMap("productId", productId));
for (GenericValue goodIdentification : goodIdentifications) {
addWeightedKeywordSourceString(goodIdentification, "idValue", strings);
}
}
// Variant Product IDs
if ("Y".equals(product.getString("isVirtual"))) {
if (!"0"
.equals(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.Variant.Product.productId", "0"))) {
List<GenericValue> variantProductAssocs =
delegator.findByAnd(
"ProductAssoc",
UtilMisc.toMap("productId", productId, "productAssocTypeId", "PRODUCT_VARIANT"));
variantProductAssocs = EntityUtil.filterByDate(variantProductAssocs);
for (GenericValue variantProductAssoc : variantProductAssocs) {
int weight = 1;
try {
weight =
Integer.parseInt(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.Variant.Product.productId", "0"));
} catch (Exception e) {
Debug.logWarning("Could not parse weight number: " + e.toString(), module);
}
for (int i = 0; i < weight; i++) {
strings.add(variantProductAssoc.getString("productIdTo"));
}
}
}
}
String productContentTypes =
UtilProperties.getPropertyValue("prodsearch", "index.include.ProductContentTypes");
for (String productContentTypeId : productContentTypes.split(",")) {
int weight = 1;
try {
// this is defaulting to a weight of 1 because you specified you wanted to index this type
weight =
Integer.parseInt(
UtilProperties.getPropertyValue(
"prodsearch", "index.weight.ProductContent." + productContentTypeId, "1"));
} catch (Exception e) {
Debug.logWarning("Could not parse weight number: " + e.toString(), module);
}
List<GenericValue> productContentAndInfos =
delegator.findByAnd(
"ProductContentAndInfo",
UtilMisc.toMap("productId", productId, "productContentTypeId", productContentTypeId),
null);
for (GenericValue productContentAndInfo : productContentAndInfos) {
addWeightedDataResourceString(productContentAndInfo, weight, strings, delegator, product);
List<GenericValue> alternateViews =
productContentAndInfo.getRelated(
"ContentAssocDataResourceViewTo",
UtilMisc.toMap("caContentAssocTypeId", "ALTERNATE_LOCALE"),
UtilMisc.toList("-caFromDate"));
alternateViews =
EntityUtil.filterByDate(
alternateViews, UtilDateTime.nowTimestamp(), "caFromDate", "caThruDate", true);
for (GenericValue thisView : alternateViews) {
addWeightedDataResourceString(thisView, weight, strings, delegator, product);
}
}
}
if (UtilValidate.isNotEmpty(strings)) {
for (String str : strings) {
// call process keywords method here
KeywordSearchUtil.processKeywordsForIndex(
str, keywords, separators, stopWordBagAnd, stopWordBagOr, removeStems, stemSet);
}
}
List<GenericValue> toBeStored = FastList.newInstance();
int keywordMaxLength =
Integer.parseInt(
UtilProperties.getPropertyValue("prodsearch", "product.keyword.max.length"));
for (Map.Entry<String, Long> entry : keywords.entrySet()) {
if (entry.getKey().length() <= keywordMaxLength) {
GenericValue productKeyword =
delegator.makeValue(
"ProductKeyword",
UtilMisc.toMap(
"productId",
product.getString("productId"),
"keyword",
entry.getKey(),
"keywordTypeId",
"KWT_KEYWORD",
"relevancyWeight",
entry.getValue()));
toBeStored.add(productKeyword);
}
}
if (toBeStored.size() > 0) {
if (Debug.verboseOn())
Debug.logVerbose(
"[KeywordIndex.indexKeywords] Storing "
+ toBeStored.size()
+ " keywords for productId "
+ product.getString("productId"),
module);
if ("true"
.equals(
UtilProperties.getPropertyValue("prodsearch", "index.delete.on_index", "false"))) {
// delete all keywords if the properties file says to
delegator.removeByAnd(
"ProductKeyword", UtilMisc.toMap("productId", product.getString("productId")));
}
delegator.storeAll(toBeStored);
}
}
public static List<GenericValue> getRelatedCategoriesRet(
Delegator delegator,
String attributeName,
String parentId,
boolean limitView,
boolean excludeEmpty,
boolean recursive) {
List<GenericValue> categories = FastList.newInstance();
if (Debug.verboseOn())
Debug.logVerbose("[CategoryWorker.getRelatedCategories] ParentID: " + parentId, module);
List<GenericValue> rollups = null;
try {
rollups =
delegator.findByAnd(
"ProductCategoryRollup",
UtilMisc.toMap("parentProductCategoryId", parentId),
UtilMisc.toList("sequenceNum"),
true);
if (limitView) {
rollups = EntityUtil.filterByDate(rollups, true);
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
}
if (rollups != null) {
// Debug.logInfo("Rollup size: " + rollups.size(), module);
for (GenericValue parent : rollups) {
// Debug.logInfo("Adding child of: " + parent.getString("parentProductCategoryId"), module);
GenericValue cv = null;
try {
cv = parent.getRelatedOne("CurrentProductCategory", true);
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
}
if (cv != null) {
if (excludeEmpty) {
if (!isCategoryEmpty(cv)) {
// Debug.logInfo("Child : " + cv.getString("productCategoryId") + " is not empty.",
// module);
categories.add(cv);
if (recursive) {
categories.addAll(
getRelatedCategoriesRet(
delegator,
attributeName,
cv.getString("productCategoryId"),
limitView,
excludeEmpty,
recursive));
}
}
} else {
categories.add(cv);
if (recursive) {
categories.addAll(
getRelatedCategoriesRet(
delegator,
attributeName,
cv.getString("productCategoryId"),
limitView,
excludeEmpty,
recursive));
}
}
}
}
}
return categories;
}
/**
* Creates and updates a PartyRelationship creating related PartyRoles if needed. A side of the
* relationship is checked to maintain history
*
* @param ctx The DispatchContext that this service is operating in
* @param context Map containing the input parameters
* @return Map with the result of the service, the output parameters
*/
public static Map<String, Object> createUpdatePartyRelationshipAndRoles(
DispatchContext ctx, Map<String, ? extends Object> context) {
Map<String, Object> result = FastMap.newInstance();
Delegator delegator = ctx.getDelegator();
LocalDispatcher dispatcher = ctx.getDispatcher();
try {
List<GenericValue> partyRelationShipList =
PartyRelationshipHelper.getActivePartyRelationships(delegator, context);
if (UtilValidate.isEmpty(
partyRelationShipList)) { // If already exists and active nothing to do: keep the current
// one
String partyId = (String) context.get("partyId");
String partyIdFrom = (String) context.get("partyIdFrom");
String partyIdTo = (String) context.get("partyIdTo");
String roleTypeIdFrom = (String) context.get("roleTypeIdFrom");
String roleTypeIdTo = (String) context.get("roleTypeIdTo");
String partyRelationshipTypeId = (String) context.get("partyRelationshipTypeId");
// Before creating the partyRelationShip, create the partyRoles if they don't exist
GenericValue partyToRole = null;
partyToRole =
delegator.findOne(
"PartyRole",
UtilMisc.toMap("partyId", partyIdTo, "roleTypeId", roleTypeIdTo),
false);
if (partyToRole == null) {
partyToRole =
delegator.makeValue(
"PartyRole", UtilMisc.toMap("partyId", partyIdTo, "roleTypeId", roleTypeIdTo));
partyToRole.create();
}
GenericValue partyFromRole = null;
partyFromRole =
delegator.findOne(
"PartyRole",
UtilMisc.toMap("partyId", partyIdFrom, "roleTypeId", roleTypeIdFrom),
false);
if (partyFromRole == null) {
partyFromRole =
delegator.makeValue(
"PartyRole",
UtilMisc.toMap("partyId", partyIdFrom, "roleTypeId", roleTypeIdFrom));
partyFromRole.create();
}
// Check if there is already a partyRelationship of that type with another party from the
// side indicated
String sideChecked = partyIdFrom.equals(partyId) ? "partyIdFrom" : "partyIdTo";
partyRelationShipList =
delegator.findByAnd(
"PartyRelationship",
UtilMisc.toMap(
sideChecked,
partyId,
"roleTypeIdFrom",
roleTypeIdFrom,
"roleTypeIdTo",
roleTypeIdTo,
"partyRelationshipTypeId",
partyRelationshipTypeId));
// We consider the last one (in time) as sole active (we try to maintain a unique
// relationship and keep changes history)
partyRelationShipList = EntityUtil.filterByDate(partyRelationShipList);
GenericValue oldPartyRelationShip = EntityUtil.getFirst(partyRelationShipList);
if (UtilValidate.isNotEmpty(oldPartyRelationShip)) {
oldPartyRelationShip.setFields(
UtilMisc.toMap("thruDate", UtilDateTime.nowTimestamp())); // Current becomes inactive
oldPartyRelationShip.store();
}
try {
dispatcher.runSync("createPartyRelationship", context); // Create new one
} catch (GenericServiceException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
"Could not create party relationship (write failure): " + e.getMessage());
}
}
} catch (GenericEntityException e) {
Debug.logWarning(e.getMessage(), module);
return ServiceUtil.returnError(
"Could not create party relationship (write failure): " + e.getMessage());
}
result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_SUCCESS);
return result;
}
