001// -------------------------------------------------------------------------------- 002// Copyright 2002-2025 Echo Three, LLC 003// 004// Licensed under the Apache License, Version 2.0 (the "License"); 005// you may not use this file except in compliance with the License. 006// You may obtain a copy of the License at 007// 008// http://www.apache.org/licenses/LICENSE-2.0 009// 010// Unless required by applicable law or agreed to in writing, software 011// distributed under the License is distributed on an "AS IS" BASIS, 012// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 013// See the License for the specific language governing permissions and 014// limitations under the License. 015// -------------------------------------------------------------------------------- 016 017package com.echothree.model.control.offer.server.logic; 018 019import com.echothree.control.user.offer.common.spec.OfferItemUniversalSpec; 020import com.echothree.model.control.accounting.server.logic.CurrencyLogic; 021import com.echothree.model.control.content.server.logic.ContentLogic; 022import com.echothree.model.control.core.common.ComponentVendors; 023import com.echothree.model.control.core.common.EntityTypes; 024import com.echothree.model.control.core.common.exception.InvalidParameterCountException; 025import com.echothree.model.control.core.server.logic.EntityInstanceLogic; 026import com.echothree.model.control.inventory.server.logic.InventoryConditionLogic; 027import com.echothree.model.control.item.common.ItemPriceTypes; 028import com.echothree.model.control.item.common.exception.MissingMaximumUnitPriceException; 029import com.echothree.model.control.item.common.exception.MissingMinimumUnitPriceException; 030import com.echothree.model.control.item.common.exception.MissingUnitPriceException; 031import com.echothree.model.control.item.common.exception.MissingUnitPriceIncrementException; 032import com.echothree.model.control.item.common.exception.UnknownItemPriceException; 033import com.echothree.model.control.item.common.exception.UnknownItemPriceTypeException; 034import com.echothree.model.control.item.server.control.ItemControl; 035import com.echothree.model.control.item.server.logic.ItemLogic; 036import com.echothree.model.control.offer.common.exception.CannotManuallyCreateOfferItemPriceWhenOfferItemPriceFilterSetException; 037import com.echothree.model.control.offer.common.exception.CannotManuallyCreateOfferItemWhenOfferItemSelectorSetException; 038import com.echothree.model.control.offer.common.exception.CannotManuallyDeleteOfferItemPriceWhenOfferItemPriceFilterSetException; 039import com.echothree.model.control.offer.common.exception.CannotManuallyDeleteOfferItemWhenOfferItemSelectorSetException; 040import com.echothree.model.control.offer.common.exception.DuplicateOfferItemException; 041import com.echothree.model.control.offer.common.exception.DuplicateOfferItemPriceException; 042import com.echothree.model.control.offer.common.exception.InvalidItemCompanyException; 043import com.echothree.model.control.offer.common.exception.UnknownOfferItemException; 044import com.echothree.model.control.offer.common.exception.UnknownOfferItemPriceException; 045import com.echothree.model.control.offer.server.control.OfferItemControl; 046import com.echothree.model.control.party.server.control.PartyControl; 047import com.echothree.model.control.uom.server.logic.UnitOfMeasureTypeLogic; 048import com.echothree.model.data.accounting.server.entity.Currency; 049import com.echothree.model.data.inventory.server.entity.InventoryCondition; 050import com.echothree.model.data.item.server.entity.Item; 051import com.echothree.model.data.offer.server.entity.Offer; 052import com.echothree.model.data.offer.server.entity.OfferItem; 053import com.echothree.model.data.offer.server.entity.OfferItemFixedPrice; 054import com.echothree.model.data.offer.server.entity.OfferItemPrice; 055import com.echothree.model.data.offer.server.entity.OfferItemVariablePrice; 056import com.echothree.model.data.offer.server.value.OfferItemFixedPriceValue; 057import com.echothree.model.data.offer.server.value.OfferItemVariablePriceValue; 058import com.echothree.model.data.uom.server.entity.UnitOfMeasureType; 059import com.echothree.util.common.message.ExecutionErrors; 060import com.echothree.util.common.persistence.BasePK; 061import com.echothree.util.server.control.BaseLogic; 062import com.echothree.util.server.message.ExecutionErrorAccumulator; 063import com.echothree.util.server.persistence.EntityPermission; 064import com.echothree.util.server.persistence.Session; 065import com.echothree.util.server.validation.ParameterUtils; 066import java.util.List; 067import javax.enterprise.context.ApplicationScoped; 068import javax.enterprise.inject.spi.CDI; 069 070@ApplicationScoped 071public class OfferItemLogic 072 extends BaseLogic { 073 074 protected OfferItemLogic() { 075 super(); 076 } 077 078 public static OfferItemLogic getInstance() { 079 return CDI.current().select(OfferItemLogic.class).get(); 080 } 081 082 // -------------------------------------------------------------------------------- 083 // Offer Items 084 // -------------------------------------------------------------------------------- 085 086 // This one is intended to be used internally to ensure any dependent actions occur. 087 public OfferItem createOfferItem(final Offer offer, final Item item, final BasePK createdBy) { 088 var offerItemControl = Session.getModelController(OfferItemControl.class); 089 090 return offerItemControl.createOfferItem(offer, item, createdBy); 091 } 092 093 // This one is intended to be used by interactive users of the application to ensure all necessary 094 // validation occurs. 095 public OfferItem createOfferItem(final ExecutionErrorAccumulator eea, final Offer offer, final Item item, 096 final BasePK createdBy) { 097 OfferItem offerItem = null; 098 final var offerDetail = offer.getLastDetail(); 099 100 if(offerDetail.getOfferItemSelector() == null) { 101 var partyControl = Session.getModelController(PartyControl.class); 102 var partyDepartment = partyControl.getPartyDepartment(offerDetail.getDepartmentParty()); 103 var partyDivision = partyControl.getPartyDivision(partyDepartment.getDivisionParty()); 104 var partyCompany = partyControl.getPartyCompany(partyDivision.getCompanyParty()); 105 106 if(partyCompany.getParty().equals(item.getLastDetail().getCompanyParty())) { 107 var offerItemControl = Session.getModelController(OfferItemControl.class); 108 109 offerItem = offerItemControl.getOfferItem(offer, item); 110 111 if(offerItem == null) { 112 offerItem = createOfferItem(offer, item, createdBy); 113 } else { 114 handleExecutionError(DuplicateOfferItemException.class, eea, ExecutionErrors.DuplicateOfferItem.name(), 115 offerDetail.getOfferName(), item.getLastDetail().getItemName()); 116 } 117 } else { 118 handleExecutionError(InvalidItemCompanyException.class, eea, ExecutionErrors.InvalidItemCompany.name(), 119 partyCompany.getPartyCompanyName(), 120 partyControl.getPartyCompany(item.getLastDetail().getCompanyParty()).getPartyCompanyName()); 121 } 122 } else { 123 handleExecutionError(CannotManuallyCreateOfferItemWhenOfferItemSelectorSetException.class, eea, 124 ExecutionErrors.CannotManuallyCreateOfferItemWhenOfferItemSelectorSet.name(), 125 offerDetail.getOfferName()); 126 } 127 128 return offerItem; 129 } 130 131 public OfferItem getOfferItem(final ExecutionErrorAccumulator eea, final Offer offer, final Item item, 132 final EntityPermission entityPermission) { 133 var offerItemControl = Session.getModelController(OfferItemControl.class); 134 var offerItem = offerItemControl.getOfferItem(offer, item, entityPermission); 135 136 if(offerItem == null) { 137 handleExecutionError(UnknownOfferItemException.class, eea, ExecutionErrors.UnknownOfferItem.name(), 138 offer.getLastDetail().getOfferName(), item.getLastDetail().getItemName()); 139 } 140 141 return offerItem; 142 } 143 144 public OfferItem getOfferItem(final ExecutionErrorAccumulator eea, final Offer offer, final Item item) { 145 return getOfferItem(eea, offer, item, EntityPermission.READ_ONLY); 146 } 147 148 public OfferItem getOfferItemForUpdate(final ExecutionErrorAccumulator eea, final Offer offer, final Item item) { 149 return getOfferItem(eea, offer, item, EntityPermission.READ_WRITE); 150 } 151 152 public OfferItem getOfferItemByUniversalSpec(final ExecutionErrorAccumulator eea, final OfferItemUniversalSpec universalSpec, 153 final EntityPermission entityPermission) { 154 var offerName = universalSpec.getOfferName(); 155 var itemName = universalSpec.getItemName(); 156 var nameParameterCount= ParameterUtils.getInstance().countNonNullParameters(offerName, itemName); 157 var possibleEntitySpecs= EntityInstanceLogic.getInstance().countPossibleEntitySpecs(universalSpec); 158 OfferItem offerItem = null; 159 160 if(nameParameterCount == 2 && possibleEntitySpecs == 0) { 161 var offer = OfferLogic.getInstance().getOfferByName(eea, offerName); 162 var item = ItemLogic.getInstance().getItemByName(eea, itemName); 163 164 if(!eea.hasExecutionErrors()) { 165 offerItem = getOfferItem(eea, offer, item); 166 } 167 } else if(nameParameterCount == 0 && possibleEntitySpecs == 1) { 168 var entityInstance = EntityInstanceLogic.getInstance().getEntityInstance(eea, universalSpec, 169 ComponentVendors.ECHO_THREE.name(), EntityTypes.OfferItem.name()); 170 171 if(!eea.hasExecutionErrors()) { 172 var offerItemControl = Session.getModelController(OfferItemControl.class); 173 174 offerItem = offerItemControl.getOfferItemByEntityInstance(entityInstance, entityPermission); 175 } 176 } else { 177 handleExecutionError(InvalidParameterCountException.class, eea, ExecutionErrors.InvalidParameterCount.name()); 178 } 179 180 return offerItem; 181 } 182 183 public OfferItem getOfferItemByUniversalSpec(final ExecutionErrorAccumulator eea, final OfferItemUniversalSpec universalSpec) { 184 return getOfferItemByUniversalSpec(eea, universalSpec, EntityPermission.READ_ONLY); 185 } 186 187 public OfferItem getOfferItemByUniversalSpecForUpdate(final ExecutionErrorAccumulator eea, final OfferItemUniversalSpec universalSpec) { 188 return getOfferItemByUniversalSpec(eea, universalSpec, EntityPermission.READ_WRITE); 189 } 190 191 public void deleteOfferItem(final OfferItem offerItem, final BasePK deletedBy) { 192 var offerItemControl = Session.getModelController(OfferItemControl.class); 193 194 offerItemControl.deleteOfferItem(offerItem, deletedBy); 195 } 196 197 public void deleteOfferItem(final ExecutionErrorAccumulator eea, final OfferItem offerItem, final BasePK deletedBy) { 198 final var offerDetail = offerItem.getOffer().getLastDetail(); 199 200 if(offerDetail.getOfferItemSelector() == null) { 201 deleteOfferItem(offerItem, deletedBy); 202 } else { 203 handleExecutionError(CannotManuallyDeleteOfferItemWhenOfferItemSelectorSetException.class, eea, 204 ExecutionErrors.CannotManuallyDeleteOfferItemWhenOfferItemSelectorSet.name(), 205 offerDetail.getOfferName()); 206 } 207 } 208 209 public void deleteOfferItems(List<OfferItem> offerItems, BasePK deletedBy) { 210 offerItems.forEach((offerItem) -> 211 deleteOfferItem(offerItem, deletedBy) 212 ); 213 } 214 215 public void deleteOfferItemsByOffer(Offer offer, BasePK deletedBy) { 216 var offerItemControl = Session.getModelController(OfferItemControl.class); 217 218 deleteOfferItems(offerItemControl.getOfferItemsByOfferForUpdate(offer), deletedBy); 219 } 220 221 public void deleteOfferItemsByOffers(List<Offer> offers, BasePK deletedBy) { 222 offers.forEach((offer) -> 223 deleteOfferItemsByOffer(offer, deletedBy) 224 ); 225 } 226 227 // -------------------------------------------------------------------------------- 228 // Offer Item Prices 229 // -------------------------------------------------------------------------------- 230 231 public OfferItemPrice createOfferItemPrice(final OfferItem offerItem, final InventoryCondition inventoryCondition, 232 final UnitOfMeasureType unitOfMeasureType, final Currency currency, final BasePK createdBy) { 233 var offerItemControl = Session.getModelController(OfferItemControl.class); 234 235 return offerItemControl.createOfferItemPrice(offerItem, inventoryCondition, unitOfMeasureType, currency, createdBy); 236 } 237 238 public void createOfferItemPrice(final ExecutionErrorAccumulator eea, final String offerName, final String itemName, final String inventoryConditionName, 239 final String unitOfMeasureTypeName, final String currencyIsoName, final String strUnitPrice, final String strMinimumUnitPrice, 240 final String strMaximumUnitPrice, final String strUnitPriceIncrement, final BasePK createdBy) { 241 var offer = OfferLogic.getInstance().getOfferByName(eea, offerName); 242 243 if(eea == null || !eea.hasExecutionErrors()) { 244 final var offerDetail = offer.getLastDetail(); 245 246 if(offerDetail.getOfferItemPriceFilter() == null) { 247 var item = ItemLogic.getInstance().getItemByName(eea, itemName); 248 var inventoryCondition = InventoryConditionLogic.getInstance().getInventoryConditionByName(eea, inventoryConditionName); 249 var currency = CurrencyLogic.getInstance().getCurrencyByName(eea, currencyIsoName); 250 251 if(eea == null || !eea.hasExecutionErrors()) { 252 var itemDetail = item.getLastDetail(); 253 var unitOfMeasureKind = itemDetail.getUnitOfMeasureKind(); 254 var unitOfMeasureType = UnitOfMeasureTypeLogic.getInstance().getUnitOfMeasureTypeByName(eea, 255 unitOfMeasureKind, unitOfMeasureTypeName); 256 257 if(eea == null || !eea.hasExecutionErrors()) { 258 var offerItemControl = Session.getModelController(OfferItemControl.class); 259 var offerItem = offerItemControl.getOfferItem(offer, item); 260 261 if(offerItem != null) { 262 var itemControl = Session.getModelController(ItemControl.class); 263 var itemPrice = itemControl.getItemPrice(item, inventoryCondition, unitOfMeasureType, currency); 264 265 if(itemPrice != null) { 266 var offerItemPrice = offerItemControl.getOfferItemPrice(offerItem, inventoryCondition, 267 unitOfMeasureType, currency); 268 269 if(offerItemPrice == null) { 270 var itemPriceTypeName = itemDetail.getItemPriceType().getItemPriceTypeName(); 271 272 if(itemPriceTypeName.equals(ItemPriceTypes.FIXED.name())) { 273 if(strUnitPrice != null) { 274 var unitPrice = Long.valueOf(strUnitPrice); 275 276 offerItemPrice = OfferItemLogic.getInstance().createOfferItemPrice(offerItem, inventoryCondition, 277 unitOfMeasureType, currency, createdBy); 278 OfferItemLogic.getInstance().createOfferItemFixedPrice(offerItemPrice, unitPrice, createdBy); 279 } else { 280 handleExecutionError(MissingUnitPriceException.class, eea, ExecutionErrors.MissingUnitPrice.name()); 281 } 282 } else if(itemPriceTypeName.equals(ItemPriceTypes.VARIABLE.name())) { 283 Long minimumUnitPrice = null; 284 Long maximumUnitPrice = null; 285 Long unitPriceIncrement = null; 286 287 if(strMinimumUnitPrice != null) { 288 minimumUnitPrice = Long.valueOf(strMinimumUnitPrice); 289 } else { 290 handleExecutionError(MissingMinimumUnitPriceException.class, eea, ExecutionErrors.MissingMinimumUnitPrice.name()); 291 } 292 293 if(strMaximumUnitPrice != null) { 294 maximumUnitPrice = Long.valueOf(strMaximumUnitPrice); 295 } else { 296 handleExecutionError(MissingMaximumUnitPriceException.class, eea, ExecutionErrors.MissingMaximumUnitPrice.name()); 297 } 298 299 if(strUnitPriceIncrement != null) { 300 unitPriceIncrement = Long.valueOf(strUnitPriceIncrement); 301 } else { 302 handleExecutionError(MissingUnitPriceIncrementException.class, eea, ExecutionErrors.MissingUnitPriceIncrement.name()); 303 } 304 305 if(minimumUnitPrice != null && maximumUnitPrice != null && unitPriceIncrement != null) { 306 offerItemPrice = OfferItemLogic.getInstance().createOfferItemPrice(offerItem, inventoryCondition, 307 unitOfMeasureType, currency, createdBy); 308 OfferItemLogic.getInstance().createOfferItemVariablePrice(offerItemPrice, minimumUnitPrice, maximumUnitPrice, 309 unitPriceIncrement, createdBy); 310 } 311 } else { 312 handleExecutionError(UnknownItemPriceTypeException.class, eea, ExecutionErrors.UnknownItemPriceType.name()); 313 } 314 } else { 315 handleExecutionError(DuplicateOfferItemPriceException.class, eea, ExecutionErrors.DuplicateOfferItemPrice.name()); 316 } 317 } else { 318 handleExecutionError(UnknownItemPriceException.class, eea, ExecutionErrors.UnknownItemPrice.name()); 319 } 320 } else { 321 handleExecutionError(UnknownOfferItemException.class, eea, ExecutionErrors.UnknownOfferItem.name(), offerName, itemName); 322 } 323 } 324 } 325 } else { 326 handleExecutionError(CannotManuallyCreateOfferItemPriceWhenOfferItemPriceFilterSetException.class, eea, 327 ExecutionErrors.CannotManuallyCreateOfferItemPriceWhenOfferItemPriceFilterSet.name(), 328 offerDetail.getOfferName()); 329 } 330 } 331 } 332 333 public OfferItemPrice getOfferItemPrice(final ExecutionErrorAccumulator eea, final Offer offer, final Item item, 334 final InventoryCondition inventoryCondition, final UnitOfMeasureType unitOfMeasureType, final Currency currency) { 335 var offerItemControl = Session.getModelController(OfferItemControl.class); 336 var offerItem = offerItemControl.getOfferItem(offer, item); 337 OfferItemPrice offerItemPrice = null; 338 339 if(offerItem != null) { 340 offerItemPrice = offerItemControl.getOfferItemPrice(offerItem, inventoryCondition, unitOfMeasureType, currency); 341 342 if(offerItemPrice == null) { 343 handleExecutionError(UnknownOfferItemPriceException.class, eea, ExecutionErrors.UnknownOfferItemPrice.name(), offer.getLastDetail().getOfferName(), 344 item.getLastDetail().getItemName(), inventoryCondition.getLastDetail().getInventoryConditionName(), 345 unitOfMeasureType.getLastDetail().getUnitOfMeasureTypeName(), currency.getCurrencyIsoName()); 346 } 347 } else { 348 handleExecutionError(UnknownOfferItemException.class, eea, ExecutionErrors.UnknownOfferItem.name(), 349 offer.getLastDetail().getOfferName(), item.getLastDetail().getItemName()); 350 } 351 352 return offerItemPrice; 353 } 354 355 // This one is intended to be used internally to ensure any dependent actions occur. 356 public void deleteOfferItemPrice(final OfferItemPrice offerItemPrice, final BasePK deletedBy) { 357 var offerItemControl = Session.getModelController(OfferItemControl.class); 358 var offerItem = offerItemPrice.getOfferItemForUpdate(); 359 var item = offerItem.getItem(); 360 361 ContentLogic.getInstance().deleteContentCategoryItemByOfferItemPrice(offerItemPrice, deletedBy); 362 363 offerItemControl.deleteOfferItemPrice(offerItemPrice, deletedBy); 364 365 // If all OfferItemPrices have been deleted, delete the OfferItem as well. 366 if(offerItemControl.countOfferItemPricesByItem(item) == 0) { 367 deleteOfferItem(offerItem, deletedBy); 368 } 369 } 370 371 // This one is intended to be used by interactive users of the application to ensure all necessary 372 // validation occurs. 373 public void deleteOfferItemPrice(final ExecutionErrorAccumulator eea, final String offerName, final String itemName, 374 final String inventoryConditionName, final String unitOfMeasureTypeName, final String currencyIsoName, 375 final BasePK deletedBy) { 376 var offer = OfferLogic.getInstance().getOfferByName(eea, offerName); 377 378 if(eea == null || !eea.hasExecutionErrors()) { 379 final var offerDetail = offer.getLastDetail(); 380 381 if(offerDetail.getOfferItemPriceFilter() == null) { 382 var item = ItemLogic.getInstance().getItemByName(eea, itemName); 383 var inventoryCondition = InventoryConditionLogic.getInstance().getInventoryConditionByName(eea, inventoryConditionName); 384 var currency = CurrencyLogic.getInstance().getCurrencyByName(eea, currencyIsoName); 385 386 if(eea == null || !eea.hasExecutionErrors()) { 387 var unitOfMeasureKind = item.getLastDetail().getUnitOfMeasureKind(); 388 var unitOfMeasureType = UnitOfMeasureTypeLogic.getInstance().getUnitOfMeasureTypeByName(eea, 389 unitOfMeasureKind, unitOfMeasureTypeName); 390 391 if(eea == null || !eea.hasExecutionErrors()) { 392 var offerItemControl = Session.getModelController(OfferItemControl.class); 393 var offerItem = offerItemControl.getOfferItem(offer, item); 394 395 if(offerItem != null) { 396 var offerItemPrice = offerItemControl.getOfferItemPriceForUpdate(offerItem, inventoryCondition, 397 unitOfMeasureType, currency); 398 399 if(offerItemPrice != null) { 400 deleteOfferItemPrice(offerItemPrice, deletedBy); 401 } else { 402 handleExecutionError(UnknownOfferItemPriceException.class, eea, ExecutionErrors.UnknownOfferItemPrice.name(), 403 offerName, itemName, inventoryConditionName, unitOfMeasureTypeName, currencyIsoName); 404 } 405 } else { 406 handleExecutionError(UnknownOfferItemException.class, eea, ExecutionErrors.UnknownOfferItem.name(), 407 offerName, itemName); 408 } 409 } 410 } 411 } else { 412 handleExecutionError(CannotManuallyDeleteOfferItemPriceWhenOfferItemPriceFilterSetException.class, eea, 413 ExecutionErrors.CannotManuallyDeleteOfferItemPriceWhenOfferItemPriceFilterSet.name(), 414 offerDetail.getOfferName()); 415 } 416 } 417 } 418 419 public void deleteOfferItemPrices(List<OfferItemPrice> offerItemPrices, BasePK deletedBy) { 420 offerItemPrices.forEach((offerItemPrice) -> 421 deleteOfferItemPrice(offerItemPrice, deletedBy) 422 ); 423 } 424 425 public void deleteOfferItemPricesByOfferItem(OfferItem offerItem, BasePK deletedBy) { 426 var offerItemControl = Session.getModelController(OfferItemControl.class); 427 428 deleteOfferItemPrices(offerItemControl.getOfferItemPricesByOfferItemForUpdate(offerItem), deletedBy); 429 } 430 431 public void deleteOfferItemPricesByItemAndUnitOfMeasureType(Item item, UnitOfMeasureType unitOfMeasureType, BasePK deletedBy) { 432 var offerItemControl = Session.getModelController(OfferItemControl.class); 433 434 deleteOfferItemPrices(offerItemControl.getOfferItemPricesByItemAndUnitOfMeasureTypeForUpdate(item, unitOfMeasureType), deletedBy); 435 } 436 437 // -------------------------------------------------------------------------------- 438 // Offer Item Fixed Prices 439 // -------------------------------------------------------------------------------- 440 441 public OfferItemFixedPrice createOfferItemFixedPrice(final OfferItemPrice offerItemPrice, final Long unitPrice, final BasePK createdBy) { 442 var offerItemControl = Session.getModelController(OfferItemControl.class); 443 444 return offerItemControl.createOfferItemFixedPrice(offerItemPrice, unitPrice, createdBy); 445 } 446 447 public void updateOfferItemFixedPriceFromValue(final OfferItemFixedPriceValue offerItemFixedPriceValue, final BasePK updatedBy) { 448 var offerItemControl = Session.getModelController(OfferItemControl.class); 449 var offerItemFixedPrice = offerItemControl.updateOfferItemFixedPriceFromValue(offerItemFixedPriceValue, updatedBy); 450 451 if(offerItemFixedPrice != null) { 452 ContentLogic.getInstance().updateContentCatalogItemPricesByOfferItemPrice(offerItemFixedPrice.getOfferItemPrice(), updatedBy); 453 } 454 } 455 456 // -------------------------------------------------------------------------------- 457 // Offer Item Variable Prices 458 // -------------------------------------------------------------------------------- 459 460 public OfferItemVariablePrice createOfferItemVariablePrice(final OfferItemPrice offerItemPrice, final Long minimumUnitPrice, 461 final Long maximumUnitPrice, final Long unitPriceIncrement, final BasePK createdBy) { 462 var offerItemControl = Session.getModelController(OfferItemControl.class); 463 464 return offerItemControl.createOfferItemVariablePrice(offerItemPrice, minimumUnitPrice, maximumUnitPrice, unitPriceIncrement, createdBy); 465 } 466 467 public void updateOfferItemVariablePriceFromValue(final OfferItemVariablePriceValue offerItemVariablePriceValue, final BasePK updatedBy) { 468 var offerItemControl = Session.getModelController(OfferItemControl.class); 469 var offerItemVariablePrice = offerItemControl.updateOfferItemVariablePriceFromValue(offerItemVariablePriceValue, updatedBy); 470 471 if(offerItemVariablePrice != null) { 472 ContentLogic.getInstance().updateContentCatalogItemPricesByOfferItemPrice(offerItemVariablePrice.getOfferItemPrice(), updatedBy); 473 } 474 } 475 476}