/**
* Performs a cascade delete on a party.
*
* <p>One reason this method can fail is that there were relationships with entities that are not
* being deleted. If a party is not being deleted like it should, the developer should take a look
* at the exception thrown by this method to see if any relations were violated. If there were
* violations, consider adding the entities to the CASCADE array above.
*
* <p>XXX Warning, this method is very brittle. It is essentially emulating the ON DELETE CASCADE
* functionality of well featured databases, but very poorly. As the datamodel evolves, this
* method would have to be updated.
*/
public static void deleteCrmParty(String partyId, Delegator delegator)
throws GenericEntityException {
// remove related entities from constant list
for (int i = 0; i < CRM_PARTY_DELETE_CASCADE.length; i++) {
String entityName = CRM_PARTY_DELETE_CASCADE[i][0];
String fieldName = CRM_PARTY_DELETE_CASCADE[i][1];
Map<String, Object> input = UtilMisc.<String, Object>toMap(fieldName, partyId);
delegator.removeByAnd(entityName, input);
}
// remove communication events
GenericValue party = delegator.findByPrimaryKey("Party", UtilMisc.toMap("partyId", partyId));
List<GenericValue> commEvnts = FastList.<GenericValue>newInstance();
commEvnts.addAll(party.getRelated("ToCommunicationEvent"));
commEvnts.addAll(party.getRelated("FromCommunicationEvent"));
for (GenericValue commEvnt : commEvnts) {
commEvnt.removeRelated("CommunicationEventRole");
commEvnt.removeRelated("CommunicationEventWorkEff");
commEvnt.removeRelated("CommEventContentAssoc");
delegator.removeValue(commEvnt);
}
// finally remove party
delegator.removeValue(party);
}
/*
* Returns the value of a given ShipmentPackageContent record. Calculated by working out the total value (from the OrderItems) of all ItemIssuances
* for the ShipmentItem then dividing that by the total quantity issued for the same to get an average item value then multiplying that by the package
* content quantity.
* Note: No rounding of the calculation is performed so you will need to round it to the accuracy that you require
*/
public static BigDecimal getShipmentPackageContentValue(GenericValue shipmentPackageContent) {
BigDecimal quantity = shipmentPackageContent.getBigDecimal("quantity");
BigDecimal value = new BigDecimal("0");
// lookup the issuance to find the order
List<GenericValue> issuances = null;
try {
GenericValue shipmentItem = shipmentPackageContent.getRelatedOne("ShipmentItem");
issuances = shipmentItem.getRelated("ItemIssuance");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
BigDecimal totalIssued = BigDecimal.ZERO;
BigDecimal totalValue = BigDecimal.ZERO;
if (UtilValidate.isNotEmpty(issuances)) {
for (GenericValue issuance : issuances) {
// we only need one
BigDecimal issuanceQuantity = issuance.getBigDecimal("quantity");
BigDecimal issuanceCancelQuantity = issuance.getBigDecimal("cancelQuantity");
if (issuanceCancelQuantity != null) {
issuanceQuantity = issuanceQuantity.subtract(issuanceCancelQuantity);
}
// get the order item
GenericValue orderItem = null;
try {
orderItem = issuance.getRelatedOne("OrderItem");
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (orderItem != null) {
// get the value per unit - (base price * amount)
BigDecimal selectedAmount = orderItem.getBigDecimal("selectedAmount");
if (selectedAmount == null || selectedAmount.compareTo(BigDecimal.ZERO) <= 0) {
selectedAmount = BigDecimal.ONE;
}
BigDecimal unitPrice = orderItem.getBigDecimal("unitPrice");
BigDecimal itemValue = unitPrice.multiply(selectedAmount);
// total value for package (per unit * quantity)
totalIssued = totalIssued.add(issuanceQuantity);
totalValue = totalValue.add(itemValue.multiply(issuanceQuantity));
}
}
}
// take the average value of the issuances and multiply it by the shipment package content
// quantity
value = totalValue.divide(totalIssued, 10, BigDecimal.ROUND_HALF_EVEN).multiply(quantity);
return value;
}
/** Returns a list of survey response IDs for a shopping list item */
public static List<String> getItemSurveyInfo(GenericValue item) {
List<String> responseIds = FastList.newInstance();
List<GenericValue> surveyResp = null;
try {
surveyResp = item.getRelated("ShoppingListItemSurvey", null, null, false);
} catch (GenericEntityException e) {
Debug.logError(e, module);
}
if (UtilValidate.isNotEmpty(surveyResp)) {
for (GenericValue resp : surveyResp) {
responseIds.add(resp.getString("surveyResponseId"));
}
}
return responseIds;
}
/**
* Fills the specialized shopping list with the current shopping cart if one exists (if not leaves
* it alone)
*/
public static void fillAutoSaveList(ShoppingCart cart, LocalDispatcher dispatcher)
throws GeneralException {
if (cart != null && dispatcher != null) {
GenericValue userLogin = ShoppingListEvents.getCartUserLogin(cart);
Delegator delegator = cart.getDelegator();
String autoSaveListId = cart.getAutoSaveListId();
if (autoSaveListId == null) {
autoSaveListId =
getAutoSaveListId(delegator, dispatcher, null, userLogin, cart.getProductStoreId());
cart.setAutoSaveListId(autoSaveListId);
}
GenericValue shoppingList =
EntityQuery.use(delegator)
.from("ShoppingList")
.where("shoppingListId", autoSaveListId)
.queryOne();
Integer currentListSize = 0;
if (UtilValidate.isNotEmpty(shoppingList)) {
List<GenericValue> shoppingListItems =
shoppingList.getRelated("ShoppingListItem", null, null, false);
if (UtilValidate.isNotEmpty(shoppingListItems)) {
currentListSize = shoppingListItems.size();
}
}
try {
String[] itemsArray = makeCartItemsArray(cart);
if (itemsArray != null && itemsArray.length != 0) {
addBulkFromCart(
delegator,
dispatcher,
cart,
userLogin,
autoSaveListId,
null,
itemsArray,
false,
false);
} else if (itemsArray.length == 0 && currentListSize != 0) {
clearListInfo(delegator, autoSaveListId);
}
} catch (IllegalArgumentException e) {
throw new GeneralException(e.getMessage(), e);
}
}
}
public static void getCategoriesWithNoParent(ServletRequest request, String attributeName) {
Delegator delegator = (Delegator) request.getAttribute("delegator");
Collection<GenericValue> results = FastList.newInstance();
try {
Collection<GenericValue> allCategories =
delegator.findList("ProductCategory", null, null, null, null, false);
for (GenericValue curCat : allCategories) {
Collection<GenericValue> parentCats =
curCat.getRelated("CurrentProductCategoryRollup", null, null, true);
if (parentCats.isEmpty()) results.add(curCat);
}
} catch (GenericEntityException e) {
Debug.logWarning(e, module);
}
request.setAttribute(attributeName, results);
}
public static String addListToCart(
Delegator delegator,
LocalDispatcher dispatcher,
ShoppingCart cart,
String prodCatalogId,
String shoppingListId,
boolean includeChild,
boolean setAsListItem,
boolean append)
throws java.lang.IllegalArgumentException {
String errMsg = null;
// no list; no add
if (shoppingListId == null) {
errMsg =
UtilProperties.getMessage(
resource_error, "shoppinglistevents.choose_shopping_list", cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
// get the shopping list
GenericValue shoppingList = null;
List<GenericValue> shoppingListItems = null;
try {
shoppingList =
EntityQuery.use(delegator)
.from("ShoppingList")
.where("shoppingListId", shoppingListId)
.queryOne();
if (shoppingList == null) {
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.error_getting_shopping_list_and_items",
cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
shoppingListItems = shoppingList.getRelated("ShoppingListItem", null, null, false);
if (shoppingListItems == null) {
shoppingListItems = FastList.newInstance();
}
// include all items of child lists if flagged to do so
if (includeChild) {
List<GenericValue> childShoppingLists =
shoppingList.getRelated("ChildShoppingList", null, null, false);
for (GenericValue v : childShoppingLists) {
List<GenericValue> items = v.getRelated("ShoppingListItem", null, null, false);
shoppingListItems.addAll(items);
}
}
} catch (GenericEntityException e) {
Debug.logError(e, "Problems getting ShoppingList and ShoppingListItem records", module);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.error_getting_shopping_list_and_items",
cart.getLocale());
throw new IllegalArgumentException(errMsg);
}
// no items; not an error; just mention that nothing was added
if (UtilValidate.isEmpty(shoppingListItems)) {
errMsg =
UtilProperties.getMessage(
resource_error, "shoppinglistevents.no_items_added", cart.getLocale());
return errMsg;
}
// check if we are to clear the cart first
if (!append) {
cart.clear();
// Prevent the system from creating a new shopping list every time the cart is restored for
// anonymous user.
cart.setAutoSaveListId(shoppingListId);
}
// get the survey info for all the items
Map<String, List<String>> shoppingListSurveyInfo = getItemSurveyInfos(shoppingListItems);
// add the items
StringBuilder eventMessage = new StringBuilder();
for (GenericValue shoppingListItem : shoppingListItems) {
String productId = shoppingListItem.getString("productId");
BigDecimal quantity = shoppingListItem.getBigDecimal("quantity");
Timestamp reservStart = shoppingListItem.getTimestamp("reservStart");
BigDecimal reservLength = shoppingListItem.getBigDecimal("reservLength");
BigDecimal reservPersons = shoppingListItem.getBigDecimal("reservPersons");
// String accommodationMapId = shoppingListItem.getString("accommodationMapId");
// String accommodationSpotId = shoppingListItem.getString("accommodationSpotId");
String configId = shoppingListItem.getString("configId");
try {
String listId = shoppingListItem.getString("shoppingListId");
String itemId = shoppingListItem.getString("shoppingListItemSeqId");
Map<String, Object> attributes = FastMap.newInstance();
// list items are noted in the shopping cart
if (setAsListItem) {
attributes.put("shoppingListId", listId);
attributes.put("shoppingListItemSeqId", itemId);
}
// check if we have existing survey responses to append
if (shoppingListSurveyInfo.containsKey(listId + "." + itemId)
&& UtilValidate.isNotEmpty(shoppingListSurveyInfo.get(listId + "." + itemId))) {
attributes.put("surveyResponses", shoppingListSurveyInfo.get(listId + "." + itemId));
}
ProductConfigWrapper configWrapper = null;
if (UtilValidate.isNotEmpty(configId)) {
configWrapper =
ProductConfigWorker.loadProductConfigWrapper(
delegator,
dispatcher,
configId,
productId,
cart.getProductStoreId(),
prodCatalogId,
cart.getWebSiteId(),
cart.getCurrency(),
cart.getLocale(),
cart.getAutoUserLogin());
}
// TODO: add code to check for survey response requirement
// i cannot get the addOrDecrease function to accept a null reservStart field: i get a null
// pointer exception a null constant works....
if (reservStart == null) {
cart.addOrIncreaseItem(
productId,
null,
quantity,
null,
null,
null,
null,
null,
null,
attributes,
prodCatalogId,
configWrapper,
null,
null,
null,
dispatcher);
} else {
cart.addOrIncreaseItem(
productId,
null,
quantity,
reservStart,
reservLength,
reservPersons,
null,
null,
null,
null,
null,
attributes,
prodCatalogId,
configWrapper,
null,
null,
null,
dispatcher);
}
Map<String, Object> messageMap = UtilMisc.<String, Object>toMap("productId", productId);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.added_product_to_cart",
messageMap,
cart.getLocale());
eventMessage.append(errMsg).append("\n");
} catch (CartItemModifyException e) {
Debug.logWarning(
e,
UtilProperties.getMessage(
resource_error, "OrderProblemsAddingItemFromListToCart", cart.getLocale()));
Map<String, Object> messageMap = UtilMisc.<String, Object>toMap("productId", productId);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.problem_adding_product_to_cart",
messageMap,
cart.getLocale());
eventMessage.append(errMsg).append("\n");
} catch (ItemNotFoundException e) {
Debug.logWarning(
e, UtilProperties.getMessage(resource_error, "OrderProductNotFound", cart.getLocale()));
Map<String, Object> messageMap = UtilMisc.<String, Object>toMap("productId", productId);
errMsg =
UtilProperties.getMessage(
resource_error,
"shoppinglistevents.problem_adding_product_to_cart",
messageMap,
cart.getLocale());
eventMessage.append(errMsg).append("\n");
}
}
if (eventMessage.length() > 0) {
return eventMessage.toString();
}
// all done
return ""; // no message to return; will simply reply as success
}
public static String timeSheetChecker(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpSession session = request.getSession();
Delegator delegator = (Delegator) session.getAttribute("delegator");
GenericValue userLogin = (GenericValue) session.getAttribute("userLogin");
List<Map<String, Object>> noTimeEntryList = new LinkedList<Map<String, Object>>();
String partyId = userLogin.getString("partyId");
Timestamp now = UtilDateTime.nowTimestamp();
Timestamp weekStart = UtilDateTime.getWeekStart(now);
if (UtilValidate.isEmpty(delegator)) {
delegator = (Delegator) request.getAttribute("delegator");
}
try {
// should be scrum team or scrum master.
EntityConditionList<EntityExpr> exprOrs =
EntityCondition.makeCondition(
UtilMisc.toList(
EntityCondition.makeCondition("roleTypeId", EntityOperator.EQUALS, "SCRUM_TEAM"),
EntityCondition.makeCondition(
"roleTypeId", EntityOperator.EQUALS, "SCRUM_MASTER")),
EntityOperator.OR);
EntityConditionList<EntityCondition> exprAnds =
EntityCondition.makeCondition(
UtilMisc.toList(
exprOrs,
EntityCondition.makeCondition("partyId", EntityOperator.EQUALS, partyId)),
EntityOperator.AND);
List<GenericValue> partyRoleList =
EntityQuery.use(delegator).from("PartyRole").where(exprAnds).queryList();
if (UtilValidate.isNotEmpty(partyRoleList)) {
List<GenericValue> timesheetList =
EntityQuery.use(delegator)
.from("Timesheet")
.where("partyId", partyId, "statusId", "TIMESHEET_IN_PROCESS")
.cache(true)
.queryList();
if (UtilValidate.isNotEmpty(timesheetList)) {
for (GenericValue timesheetMap : timesheetList) {
String timesheetId = timesheetMap.getString("timesheetId");
Timestamp timesheetDate = timesheetMap.getTimestamp("fromDate");
// check monday - friday
for (int i = 0; i < 5; i++) {
Timestamp realTimeDate = UtilDateTime.addDaysToTimestamp(timesheetDate, i);
Timestamp nowStartDate = UtilDateTime.getDayStart(now);
// compare week and compare date
if ((timesheetDate.compareTo(weekStart) <= 0)
&& (realTimeDate.compareTo(nowStartDate) < 0)) {
// check time entry
List<GenericValue> timeEntryList =
timesheetMap.getRelated(
"TimeEntry",
UtilMisc.toMap(
"partyId",
partyId,
"timesheetId",
timesheetId,
"fromDate",
realTimeDate),
null,
false);
// check EmplLeave
List<GenericValue> emplLeaveList =
EntityQuery.use(delegator)
.from("EmplLeave")
.where("partyId", partyId, "fromDate", realTimeDate)
.cache(true)
.queryList();
if (UtilValidate.isEmpty(timeEntryList) && UtilValidate.isEmpty(emplLeaveList)) {
Map<String, Object> noEntryMap = new HashMap<String, Object>();
noEntryMap.put("timesheetId", timesheetId);
noTimeEntryList.add(noEntryMap);
break;
}
}
}
}
}
}
} catch (GenericEntityException EntEx) {
EntEx.printStackTrace();
Debug.logError(EntEx.getMessage(), module);
}
if (UtilValidate.isNotEmpty(noTimeEntryList)) {
StringBuilder warningDataBuffer = new StringBuilder();
int size = noTimeEntryList.size();
for (Map<String, Object> dataMap : noTimeEntryList) {
if (--size == 0) {
warningDataBuffer.append(dataMap.get("timesheetId"));
} else {
warningDataBuffer.append(dataMap.get("timesheetId")).append(", ");
}
warningDataBuffer.append(dataMap.get("timesheetId"));
}
String warningData = warningDataBuffer.toString();
Debug.logInfo("The following time sheet no time entry: [" + warningData + "]", module);
request.setAttribute(
"_ERROR_MESSAGE_",
UtilProperties.getMessage(
"scrumUiLabels",
"ScrumTimesheetWarningMessage",
UtilMisc.toMap("warningMessage", warningData),
UtilHttp.getLocale(request)));
}
return "success";
}
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);
}
}