@Override
protected boolean shouldHandleEvent(final SendReadyForPickupMessageEvent event) {
final AbstractOrderModel order = event.getProcess().getConsignment().getOrder();
ServicesUtil.validateParameterNotNullStandardMessage("event.order", order);
final BaseSiteModel site = order.getSite();
ServicesUtil.validateParameterNotNullStandardMessage("event.order.site", site);
return SiteChannel.TELCO.equals(site.getChannel());
}
@Override
protected boolean shouldHandleEvent(final OrderCancelledEvent event) {
final OrderModel order = event.getProcess().getOrder();
ServicesUtil.validateParameterNotNullStandardMessage("event.order", order);
final BaseSiteModel site = order.getSite();
ServicesUtil.validateParameterNotNullStandardMessage("event.order.site", site);
return SiteChannel.B2C.equals(site.getChannel());
}
/** {@inheritDoc} */
@Override
public Map<String, Collection<Object>> getAssignedVariantAttributes(
final ProductModel baseProduct) {
validateParameterNotNullStandardMessage("baseProduct", baseProduct);
final Map<String, Collection<Object>> result = new HashMap<String, Collection<Object>>();
final Collection<VariantProductModel> variantModelList = baseProduct.getVariants();
final List<VariantAttributeDescriptorModel> vadList =
getVariantAttributesForVariantType(baseProduct.getVariantType());
// iterate trough all variants to get the qualifier with appropriate values
for (final VariantProductModel variant : variantModelList) {
for (final VariantAttributeDescriptorModel item : vadList) {
Collection values = result.get(item.getQualifier());
if (values == null) {
values = new LinkedHashSet();
result.put(item.getQualifier(), values);
}
// there is no chance to read the attribute value in SL, because it"s not a part of the
// model.
// final Object value = variant.getAttributeProvider().getAttribute(item.getQualifier());
// Currently the jalo-solution has to be used
values.add(getVariantAttributeValue(variant, item.getQualifier()));
}
}
if (LOG.isDebugEnabled()) {
LOG.debug(result.size() + " variant attributes with assigned values found");
}
return result;
}
/** {@inheritDoc} */
@Override
public Collection<VariantProductModel> getVariantProductForAttributeValues(
final ProductModel baseProduct, final Map<String, Object> filterValues) {
validateParameterNotNullStandardMessage("baseProduct", baseProduct);
final Collection<VariantProductModel> result = new ArrayList<VariantProductModel>();
final List<VariantAttributeDescriptorModel> vadList =
getVariantAttributesForVariantType(baseProduct.getVariantType());
final Collection<VariantProductModel> allBaseProductVariants = baseProduct.getVariants();
if (filterValues == null || filterValues.isEmpty()) {
// no filter defined - no results.
if (LOG.isDebugEnabled()) {
LOG.debug("The filter values haven't been set, no matching variants in cases like this.");
}
return result;
}
// iterate through all variants and filter those with matching qualifier and values
for (final VariantProductModel variant : allBaseProductVariants) {
boolean add = true;
for (final Iterator<Map.Entry<String, Object>> iterator = filterValues.entrySet().iterator();
iterator.hasNext(); ) {
if (!add) {
break; // the filter element, which has been checked doesn't match, skip checking of
// addtional filter elements, go to next variant.
}
final Map.Entry entry = iterator.next();
final String filterKey = (String) entry.getKey();
final Object filterValue = entry.getValue();
// compare the filterKey and filterValue with all attributes (qualifier-value) of the
// variantType.
for (final VariantAttributeDescriptorModel attrDesc : vadList) {
final String qualifier = attrDesc.getQualifier();
final Object variantAttributeValue = getVariantAttributeValue(variant, qualifier);
if (!(filterKey.equals(qualifier)
&& (filterValue == variantAttributeValue
|| (filterValue != null && filterValue.equals(variantAttributeValue))))) {
add = false;
} else {
add =
true; // the current filter key and values matches for the current variant, go to
// next filter-element to check it.
break;
}
}
}
if (add) {
result.add(variant);
}
}
if (LOG.isDebugEnabled()) {
LOG.debug(result.size() + " matching variants have been found.");
}
return result;
}
@Override
public List<ProductModel> findAccessoriesByVendorCompatibility(
final String manufacturerName,
final String classificationClassCode,
final String classificationAttributeCode,
final String productTypeCode) {
validateParameterNotNullStandardMessage("classificationClassCode", classificationClassCode);
validateParameterNotNullStandardMessage(
"classificationAttributeCode", classificationAttributeCode);
validateParameterNotNullStandardMessage("manufacturerName", manufacturerName);
validateParameterNotNullStandardMessage("productTypeCode", productTypeCode);
final FlexibleSearchQuery query = new FlexibleSearchQuery(FIND_PRODUCTS_BY_VENDORCDOE_QUERY);
query.addQueryParameter("brand", manufacturerName);
query.addQueryParameter("classificationClassCode", classificationClassCode);
query.addQueryParameter("classificationAttributeCode", classificationAttributeCode);
query.addQueryParameter("itemType", getItemType(productTypeCode));
return this.getFlexibleSearchService().<ProductModel>search(query).getResult();
}
/**
* Helper method used to extract Property Content Value from the requestData
*
* @param requestData
* @return value of property
*/
protected double getPropertyContentValue(final QuotationRequestData requestData) {
final String coverRequired =
requestData.getProperties().get(FinancialfacadesConstants.PROPERTY_DETAILS_COVER_REQUIRED);
if (PRO_TYPE_CONTENT_ONLY.equalsIgnoreCase(coverRequired)
|| PRO_TYPE_BUILDING_AND_CONTENT.equalsIgnoreCase(coverRequired)) {
validateParameterNotNullStandardMessage(
"Property Is Standard 50000 Content Cover",
requestData
.getProperties()
.get(FinancialfacadesConstants.PROPERTY_DETAILS_IS_STANDARD_50000_CONTENT_COVER));
final String isStandard =
requestData
.getProperties()
.get(FinancialfacadesConstants.PROPERTY_DETAILS_IS_STANDARD_50000_CONTENT_COVER);
if (PRO_STANDARD_YES.equalsIgnoreCase(isStandard)) {
return 50000;
} else {
validateParameterNotNullStandardMessage(
"Property Defined Content Cover",
requestData
.getProperties()
.get(FinancialfacadesConstants.PROPERTY_DETAILS_CONTENT_COVER_MULTIPLE_OF_10000));
if (StringUtils.isNotEmpty(
requestData
.getProperties()
.get(FinancialfacadesConstants.PROPERTY_DETAILS_CONTENT_COVER_MULTIPLE_OF_10000))) {
return Double.valueOf(
requestData
.getProperties()
.get(
FinancialfacadesConstants
.PROPERTY_DETAILS_CONTENT_COVER_MULTIPLE_OF_10000))
.doubleValue();
} else {
return NumberUtils.DOUBLE_ZERO;
}
}
}
return NumberUtils.DOUBLE_ZERO;
}
/** {@inheritDoc} */
@Override
public VariantTypeModel getVariantTypeForCode(final String code) {
validateParameterNotNullStandardMessage("code", code);
final ComposedTypeModel composedTypeModel = typeService.getComposedTypeForCode(code);
if (!(composedTypeModel instanceof VariantTypeModel)) {
throw new UnknownIdentifierException(
"There is no variant type '" + code + "' (found composed type instead)");
}
return (VariantTypeModel) composedTypeModel;
}
@Override
public void updateCustomer(final CustomerData customerData) throws DuplicateUidException {
validateParameterNotNullStandardMessage("customerData", customerData);
final EnergizerB2BCustomerModel energizerB2BCustomerModel;
if (StringUtils.isEmpty(customerData.getUid())) {
energizerB2BCustomerModel = this.getModelService().create(EnergizerB2BCustomerModel.class);
energizerB2BCustomerModel.setRegistrationEmailFlag(Boolean.TRUE);
} else {
energizerB2BCustomerModel =
(EnergizerB2BCustomerModel) userService.getUserForUID(customerData.getUid());
}
if (null != customerData && null != energizerB2BCustomerModel) {
energizerCustomerReversePopulator.populate(customerData, energizerB2BCustomerModel);
companyB2BCommerceService.saveModel(energizerB2BCustomerModel);
}
}
