@Override
  public void deleteHUAssignments(
      final Object model, final Collection<I_M_HU> husToUnAssign, final String trxName) {
    Check.assumeNotNull(model, "model not null");
    Check.assumeNotNull(husToUnAssign, "husToUnAssign not null");

    final Properties ctx = InterfaceWrapperHelper.getCtx(model);
    final int adTableId = InterfaceWrapperHelper.getModelTableId(model);
    final int recordId = InterfaceWrapperHelper.getId(model);

    final Set<Integer> huIds = new HashSet<Integer>(husToUnAssign.size());
    for (final I_M_HU hu : husToUnAssign) {
      huIds.add(hu.getM_HU_ID());
    }

    if (huIds.isEmpty()) {
      return;
    }

    final IQueryBuilder<I_M_HU_Assignment> queryBuilder =
        Services.get(IQueryBL.class).createQueryBuilder(I_M_HU_Assignment.class, ctx, trxName);

    //
    // Note that here we don't want to skip anything; we want the HUAssignmentBL to do it's job, so
    // we clean everything up
    queryBuilder
        .addEqualsFilter(I_M_HU_Assignment.COLUMN_AD_Table_ID, adTableId)
        .addEqualsFilter(I_M_HU_Assignment.COLUMN_Record_ID, recordId)
        .addInArrayFilter(I_M_HU_Assignment.COLUMN_M_HU_ID, huIds)
        .create()
        .delete();
  }
  private BigDecimal calculateQtyInvoicedInPriceUOM(final I_C_InvoiceLine invoiceLine) {
    Check.assumeNotNull(invoiceLine, "invoiceLine not null");

    final BigDecimal qty = invoiceLine.getQtyInvoiced();

    Check.assumeNotNull(qty, "qty not null");

    final I_C_UOM priceUOM = invoiceLine.getPrice_UOM();
    if (invoiceLine.getPrice_UOM_ID() <= 0) {
      return qty;
    }
    if (invoiceLine.getM_Product_ID() <= 0) {
      return qty;
    }

    final I_M_Product product = invoiceLine.getM_Product();
    if (product.getC_UOM_ID() <= 0) {
      return qty;
    }

    final Properties ctx = InterfaceWrapperHelper.getCtx(invoiceLine);
    final BigDecimal qtyInPriceUOM =
        Services.get(IUOMConversionBL.class).convertFromProductUOM(ctx, product, priceUOM, qty);

    return qtyInPriceUOM;
  }
  public CalloutMethodPointcut(
      final Class<?> modelClass,
      final Method method,
      final String[] columnNames,
      final boolean paramCalloutFieldRequired,
      final boolean skipIfCopying) {
    super();

    Check.assumeNotNull(modelClass, "modelClass not null");
    this.modelClass = modelClass;

    Check.assumeNotNull(method, "method not null");
    this.method = method;

    Check.assumeNotNull(columnNames, "columnNames not null");
    Check.assume(columnNames.length > 0, "columnNames not empty");

    this.columnNames = new HashSet<String>(columnNames.length);
    for (final String columnName : columnNames) {
      Check.assumeNotNull(columnName, "columnName not null");
      this.columnNames.add(columnName);
    }

    this.paramCalloutFieldRequired = paramCalloutFieldRequired;

    this.skipIfCopying = skipIfCopying;
  }
  public MRPDemandsPool(
      final IMRPContext mrpContext,
      final IMRPNotesCollector mrpNotesCollector,
      final IMRPDemand mrpDemand) {
    super();

    Check.assumeNotNull(mrpContext, "mrpContext not null");
    this._mrpContext = mrpContext;

    Check.assumeNotNull(mrpNotesCollector, "mrpNotesCollector not null");
    this._mrpNotesCollector = mrpNotesCollector;

    Check.assumeNotNull(mrpDemand, LiberoException.class, "mrpDemand not null");

    //
    // Create MRP Demand & Qty that we will need to allocated
    BigDecimal qtyGrossReq = BigDecimal.ZERO;
    final List<IMutableMRPRecordAndQty> mrpDemandAndQtys = new ArrayList<IMutableMRPRecordAndQty>();
    final MRPYield yield = mrpDemand.getYield();
    for (final I_PP_MRP mrpDemandRecord : mrpDemand.getMRPDemandRecords()) {
      final BigDecimal mrpDemandQty = mrpDemandRecord.getQty();
      final BigDecimal mrpDemandQtyWithYield = yield.calculateQtyWithYield(mrpDemandQty);
      final MRPRecordAndQty mrpDemandAndQty =
          new MRPRecordAndQty(mrpDemandRecord, mrpDemandQtyWithYield);

      qtyGrossReq = qtyGrossReq.add(mrpDemandQtyWithYield);
      mrpDemandAndQtys.add(mrpDemandAndQty);
    }

    this.demandDateStartSchedule = mrpDemand.getDateStartSchedule();

    this.qtyNetReqRemaining = qtyGrossReq;
    this.mrpDemandsToAllocate = mrpDemandAndQtys;
  }
  /**
   * Gets {@link HUItemExpectation} for given <code>piItem</code>.
   *
   * @param piItem
   * @return
   * @return {@link HUItemExpectation}; never return null
   */
  public HUItemExpectation<HUExpectation<ParentExpectationType>> huItemExpectation(
      final I_M_HU_PI_Item piItem) {
    Check.assumeNotNull(piItem, "piItem not null");
    Check.assumeNotNull(huItemExpectations, "huItemExpectations not null");

    final List<HUItemExpectation<HUExpectation<ParentExpectationType>>> result = new ArrayList<>();
    for (final HUItemExpectation<HUExpectation<ParentExpectationType>> huItemExpectation :
        huItemExpectations) {
      final I_M_HU_PI_Item current_piItem = huItemExpectation.getM_HU_PI_Item();
      if (current_piItem == null) {
        continue;
      }

      if (current_piItem.getM_HU_PI_Item_ID() != piItem.getM_HU_PI_Item_ID()) {
        continue;
      }

      result.add(huItemExpectation);
    }

    if (result.isEmpty()) {
      throw new IllegalArgumentException("No HU Item Expectation found for " + piItem);
    } else if (result.size() > 1) {
      throw new IllegalArgumentException(
          "More then one HU Item Expectation found for " + piItem + "\n\n" + result);
    }

    return result.get(0);
  }
Beispiel #6
0
  public PlainPackingMaterialDocumentLineSource(
      final I_M_HU_PackingMaterial packingMaterial, final BigDecimal qty) {
    super();
    Check.assumeNotNull(packingMaterial, "packingMaterial not null");
    packingMaterials = Collections.singletonList(packingMaterial);

    Check.assumeNotNull(qty, "qty not null");
    this.qty = qty;
  }
  public CoProductReceiptHUProducer(final I_PP_Cost_Collector cc) {
    super(cc);

    Check.assumeNotNull(cc, "cc not null");
    _costCollector = cc;

    Check.assume(
        cc.getPP_Order_BOMLine_ID() > 0,
        "Order BOM Line shall be set to cost collector when receiving co/bu products: {}",
        cc);
    _ppOrderBOMLine =
        InterfaceWrapperHelper.create(cc.getPP_Order_BOMLine(), I_PP_Order_BOMLine.class);
    Check.assumeNotNull(_ppOrderBOMLine, "ppOrderBOMLine not null");
  }
Beispiel #8
0
  public MutableAttributeSplitRequest(
      final IAttributeStorage parentAttributeStorage,
      final List<IAttributeStorage> attributeStorages,
      final org.compiere.model.I_M_Attribute attribute) {
    super();
    Check.assumeNotNull(parentAttributeStorage, "parentAttributeStorage not null");
    this.parentAttributeStorage = parentAttributeStorage;

    Check.assumeNotNull(attributeStorages, "attributeStorages not null");
    this.attributeStorages = Collections.unmodifiableList(attributeStorages);

    Check.assumeNotNull(attribute, "attribute not null");
    this.attribute = InterfaceWrapperHelper.create(attribute, I_M_Attribute.class);
  }
  @Override
  public final void invoke() {
    Runnable runnableWrapped = getRunnable();
    Check.assumeNotNull(runnableWrapped, "runnable shall be configured");

    // Wrap to Long Operation
    // NOTE: this needs to be wrapped BEFORE "invoke later" or "glass pane" because those will
    // execute the runnable asynchronously
    if (isLongOperation()) {
      runnableWrapped = asLongOperationRunnable(runnableWrapped);
    }

    // Wrap to Exception handled (if needed)
    runnableWrapped = asExceptionHandledRunnable(runnableWrapped);

    // Wrap to invoke later
    // NOTE: this needs to be wrapped after "exception handled" because else the exception won't be
    // catched.
    if (isInvokeLater()) {
      runnableWrapped = asInvokeLaterRunnable(runnableWrapped);
    }

    // Wrap to showing glass pane runnable
    // NOTE: this needs to be wrapped after "long operation", "exception handled" and "invoke later"
    if (isShowGlassPane()) {
      runnableWrapped = asShowGlassPaneRunnable(runnableWrapped);
    }

    //
    // Execute it
    runnableWrapped.run();
  }
  @Override
  public boolean hasMoreLUAssigmentsForSameModelType(final I_M_HU_Assignment luAssignment) {
    Check.assumeNotNull(luAssignment, "luAssignment not null");
    final int luHUId = luAssignment.getM_LU_HU_ID();
    if (luHUId <= 0) {
      return false;
    }

    final int adTableId = luAssignment.getAD_Table_ID();
    final int recordId = luAssignment.getRecord_ID();

    return Services.get(IQueryBL.class)
        .createQueryBuilder(I_M_HU_Assignment.class, luAssignment)
        .addOnlyActiveRecordsFilter() // only active assignments are counted
        .addEqualsFilter(I_M_HU_Assignment.COLUMN_AD_Table_ID, adTableId) // for same kind of model
        .addCompareFilter(
            I_M_HU_Assignment.COLUMN_Record_ID,
            Operator.LESS,
            recordId) // on a model which was created before ours
        .addEqualsFilter(I_M_HU_Assignment.COLUMN_M_LU_HU_ID, luHUId) // for our LU
        .addEqualsFilter(
            I_M_HU_Assignment.COLUMNNAME_VHU_ID,
            luAssignment.getVHU_ID()) // 08564 : also check the vhu
        //
        .create()
        .match();
  }
  private ProcessInfoParameter createProcessInfoParameter(
      final I_C_Queue_WorkPackage_Param workpackageParam) {
    // NOTE to developer: when changing this, make sure you are also changing the counterpart method
    // setParameterValue()

    Check.assumeNotNull(workpackageParam, "workpackageParam not null");

    final String parameterName = workpackageParam.getParameterName();
    final int displayType = workpackageParam.getAD_Reference_ID();
    final Object parameter;
    if (DisplayType.isText(displayType)) {
      parameter = workpackageParam.getP_String();
    } else if (DisplayType.YesNo == displayType) {
      parameter = workpackageParam.getP_String();
    } else if (DisplayType.isNumeric(displayType)) {
      parameter = workpackageParam.getP_Number();
    } else if (DisplayType.isDate(displayType)) {
      parameter = workpackageParam.getP_Date();
    } else {
      throw new AdempiereException(
          "Unsupported display type: "
              + displayType
              + "\n @C_Queue_WorkPackage_Param_ID@: "
              + workpackageParam);
    }

    final Object parameter_To = null; // N/A
    final String info = parameter == null ? "" : String.valueOf(parameter);
    final String info_To = null; // N/A
    return new ProcessInfoParameter(parameterName, parameter, parameter_To, info, info_To);
  }
  private final void addAllocationPerformed(final IMRPDemandToSupplyAllocation alloc) {
    Check.assumeNotNull(alloc, "alloc not null");

    final I_PP_MRP mrpSupplyRecord = alloc.getMRPSupply();
    final BigDecimal mrpSupplyQty = alloc.getQtyAllocated();

    //
    // Check allocated MRP supply and create MRP notes in case something is not ok
    checkMRPSupplyDates(alloc);

    //
    // Update cummulated values
    if (mrpBL.isQtyOnHandReservation(mrpSupplyRecord)) {
      this.qtyOnHandReserved = this.qtyOnHandReserved.add(mrpSupplyQty);
    } else if (mrpBL.isQtyOnHandAnyReservation(mrpSupplyRecord)) {
      // skip any other kind of reservations
    } else {
      final boolean mrpSupplyIsFirm = mrpBL.isReleased(mrpSupplyRecord);
      if (mrpSupplyIsFirm) {
        this.qtyScheduledReceipts = qtyScheduledReceipts.add(mrpSupplyQty);
      }
      this.qtySuppliedTotal = qtySuppliedTotal.add(mrpSupplyQty);
    }

    subtractFromQtyToSupplyRemaining(mrpSupplyQty);

    mrpDemand2supplyAllocations.add(alloc);
  }
  @Override
  public void assertNotChanged(final I_M_HU_LUTU_Configuration lutuConfiguration) {
    Check.assumeNotNull(lutuConfiguration, "lutuConfiguration not null");

    //
    // Check if we were explicitly asked to not check the changes
    final Boolean disableChangeCheckingOnSave =
        InterfaceWrapperHelper.getDynAttribute(
            lutuConfiguration, DYNATTR_DisableChangeCheckingOnSave);
    if (disableChangeCheckingOnSave != null && disableChangeCheckingOnSave == true) {
      return;
    }

    //
    // Make sure LU/TU configuration does not changed (from LUTU Producer perspective)
    final I_M_HU_LUTU_Configuration lutuConfigurationOld =
        InterfaceWrapperHelper.createOld(lutuConfiguration, I_M_HU_LUTU_Configuration.class);
    if (isSameForHUProducer(lutuConfiguration, lutuConfigurationOld)) {
      return;
    }

    //
    // Prevent changing the configuration
    // NOTE: it's safe to throw an english/internal error because mainly this is an internal error
    throw new HUException(
        "Changing already saved LU/TU Configuration is not allowed: " + lutuConfiguration);
  }
Beispiel #14
0
  @Override
  @Cached(cacheName = I_C_ConversionType_Default.Table_Name + "#by#Dimension")
  public I_C_ConversionType retrieveDefaultConversionType(
      @CacheCtx final Properties ctx, final int adClientId, final int adOrgId, final Date date) {
    // NOTE to developer: keep in sync with: getDefaultConversionType_ID database function

    Check.assumeNotNull(date, "date not null");
    final Date dateDay = TimeUtil.trunc(date, TimeUtil.TRUNC_DAY);

    return Services.get(IQueryBL.class)
        .createQueryBuilder(I_C_ConversionType_Default.class, ctx, ITrx.TRXNAME_None)
        .addOnlyActiveRecordsFilter()
        .addInArrayFilter(
            I_C_ConversionType_Default.COLUMN_AD_Client_ID,
            adClientId,
            Env.CTXVALUE_AD_Client_ID_System)
        .addInArrayFilter(
            I_C_ConversionType_Default.COLUMN_AD_Org_ID, adClientId, Env.CTXVALUE_AD_Org_ID_System)
        .addCompareFilter(
            I_C_ConversionType_Default.COLUMN_ValidFrom, Operator.LESS_OR_EQUAL, dateDay)
        //
        .orderBy()
        .addColumn(I_C_ConversionType_Default.COLUMN_ValidFrom, Direction.Descending, Nulls.Last)
        .addColumn(I_C_ConversionType_Default.COLUMN_AD_Client_ID, Direction.Descending, Nulls.Last)
        .addColumn(I_C_ConversionType_Default.COLUMN_AD_Org_ID, Direction.Descending, Nulls.Last)
        .endOrderBy()
        //
        .setLimit(1) // only the first one
        //
        .andCollect(I_C_ConversionType_Default.COLUMN_C_ConversionType_ID)
        .create()
        .firstOnlyNotNull(I_C_ConversionType.class);
  }
  @Override
  public int calculateQtyLUForTotalQtyCUs(
      final I_M_HU_LUTU_Configuration lutuConfiguration,
      final BigDecimal qtyCUsTotal,
      final I_C_UOM qtyCUsTotalUOM) {
    Check.assumeNotNull(lutuConfiguration, "lutuConfiguration not null");

    if (qtyCUsTotal == null || qtyCUsTotal.signum() <= 0) {
      return 0;
    }

    if (isNoLU(lutuConfiguration)) {
      return 0;
    }

    //
    // Calculate how many CUs we need for an LU
    final BigDecimal qtyCUsPerLU =
        lutuConfiguration.getQtyCU().multiply(lutuConfiguration.getQtyTU());
    if (qtyCUsPerLU.signum() <= 0) {
      return 0;
    }

    //
    // Convert the total QtyCU to our internal capacity UOM, to be able to compute using same UOM.
    final Quantity qtyCUsTotal_Converted =
        convertQtyToLUTUConfigurationUOM(qtyCUsTotal, qtyCUsTotalUOM, lutuConfiguration);

    //
    // Calculate how many LUs we need for given total QtyCU (converted to our capacity UOM)
    final int qtyLUs =
        qtyCUsTotal_Converted.getQty().divide(qtyCUsPerLU, 0, RoundingMode.UP).intValueExact();
    return qtyLUs;
  }
  /**
   * Retrieves workpackage parametes as {@link ProcessInfoParameter} list:
   *
   * <ul>
   *   <li>parameters which were directly set to workpackage (i.e. {@link
   *       I_C_Queue_WorkPackage_Param})
   *   <li>fallback: parameters which were set to creator AD_PInstance_ID
   * </ul>
   *
   * @param workpackage
   * @return
   */
  private List<ProcessInfoParameter> retrieveWorkpackageProcessInfoParameters(
      final I_C_Queue_WorkPackage workpackage) {
    Check.assumeNotNull(workpackage, "workpackage not null");

    final Map<String, ProcessInfoParameter> workpackagesParamsMap = new HashMap<>();

    //
    // Load parameters from creator's AD_PInstance_ID
    {
      final Properties ctx = InterfaceWrapperHelper.getCtx(workpackage);
      final int adPInstanceId = extractAD_PInstance_ID(workpackage);
      final IADPInstanceDAO adPInstanceDAO = Services.get(IADPInstanceDAO.class);
      for (final ProcessInfoParameter param :
          adPInstanceDAO.retrieveProcessInfoParameters(ctx, adPInstanceId)) {
        workpackagesParamsMap.put(param.getParameterName(), param);
      }
    }

    //
    // Load parameters which are directly set to this workpackage
    // NOTE: this will OVERRIDE AD_PInstance level parameters
    for (final I_C_Queue_WorkPackage_Param workpackageParam :
        retrieveWorkpackageParametersList(workpackage)) {
      final ProcessInfoParameter param = createProcessInfoParameter(workpackageParam);
      workpackagesParamsMap.put(param.getParameterName(), param);
    }

    return new ArrayList<>(workpackagesParamsMap.values());
  }
  private List<SyncProductSupply> createPlannedSyncProductSupplies(
      final I_C_RfQResponseLine rfqResponseLine) {
    final I_C_Flatrate_Term contract = rfqResponseLine.getC_Flatrate_Term();
    Check.assumeNotNull(contract, "contract not null");

    final List<I_C_RfQResponseLineQty> rfqResponseLineQtys =
        pmmRfQDAO.retrieveResponseLineQtys(rfqResponseLine);
    if (rfqResponseLineQtys.isEmpty()) {
      return ImmutableList.of();
    }

    final String bpartner_uuid = SyncUUIDs.toUUIDString(contract.getDropShip_BPartner());
    final String contractLine_uuid = SyncUUIDs.toUUIDString(contract);
    final String product_uuid = SyncUUIDs.toUUIDString(contract.getPMM_Product());

    final List<SyncProductSupply> plannedSyncProductSupplies =
        new ArrayList<>(rfqResponseLineQtys.size());
    for (final I_C_RfQResponseLineQty rfqResponseLineQty : rfqResponseLineQtys) {
      final SyncProductSupply syncProductSupply = new SyncProductSupply();
      syncProductSupply.setBpartner_uuid(bpartner_uuid);
      syncProductSupply.setContractLine_uuid(contractLine_uuid);
      syncProductSupply.setProduct_uuid(product_uuid);

      syncProductSupply.setDay(rfqResponseLineQty.getDatePromised());
      syncProductSupply.setQty(rfqResponseLineQty.getQtyPromised());
      plannedSyncProductSupplies.add(syncProductSupply);
    }

    return plannedSyncProductSupplies;
  }
 /**
  * Schedule given item to be enqueued in a transaction level workpackage which will be submitted
  * when the transaction is committed.
  *
  * <p>The transaction is extracted from item, using {@link #extractTrxNameFromItem(Object)}.
  *
  * <p>If item has no transaction, a workpackage with given item will be automatically created and
  * enqueued to be processed.
  *
  * @param item
  */
 public final void schedule(final ItemType item) {
   Check.assumeNotNull(item, "Param 'item' is not null");
   // Avoid collecting the item if is not eligible
   if (!isEligibleForScheduling(item)) {
     return;
   }
   scheduleFactory.collect(item);
 }
Beispiel #19
0
  public void markReadyForProcessing(I_C_Queue_WorkPackage... workpackages) {
    Check.assumeNotNull(workpackages, "workpackages not null");
    if (workpackages.length == 0) {
      return;
    }

    markReadyForProcessing(Arrays.asList(workpackages));
  }
Beispiel #20
0
  public void createReversals(final I_PP_Cost_Collector reversalCostCollector) {
    Check.assumeNotNull(reversalCostCollector, "reversalCostCollector not null");

    //
    // Get the original cost collector
    final I_PP_Cost_Collector costCollector = reversalCostCollector.getReversal();
    Check.assumeNotNull(costCollector, "costCollector not null");

    //
    // Get the original cost details
    final List<I_M_CostDetail> costDetails =
        Services.get(IPPCostCollectorDAO.class).retrieveCostDetails(costCollector);

    for (final I_M_CostDetail cd : costDetails) {
      createReversal(cd, reversalCostCollector);
    }
  }
  private IContextAware getContextProviderToUse() {
    if (_contextProvider != null) {
      return InterfaceWrapperHelper.getContextAware(_contextProvider);
    }

    Check.assumeNotNull(_mrpContext, LiberoException.class, "contextProvider shall be set");
    return _mrpContext;
  }
Beispiel #22
0
  @Override
  public I_M_DeliveryDay createDeliveryDay(
      final I_M_TourVersionLine tourVersionLine, final Date deliveryDate, final String trxName) {
    Check.assumeNotNull(tourVersionLine, "tourVersionLine not null");
    Check.assumeNotNull(deliveryDate, "deliveryDate not null");

    final int bpartnerId = tourVersionLine.getC_BPartner_ID();
    final int bpartnerLocationId = tourVersionLine.getC_BPartner_Location_ID();
    final boolean isToBeFetched = tourVersionLine.isToBeFetched();
    final int bufferHours = tourVersionLine.getBufferHours();
    final int seqNo = tourVersionLine.getSeqNo();
    final I_M_TourVersion tourVersion = tourVersionLine.getM_TourVersion();
    final int tourId = tourVersion.getM_Tour_ID();
    final int adOrgId = tourVersion.getAD_Org_ID();

    //
    // Get Preparation Date+Time
    // If we do not have preparation time, do not try to generate.
    final Timestamp preparationTime =
        Services.get(ITourBL.class).getPreparationDateTime(tourVersion, deliveryDate);
    if (preparationTime == null) {
      return null;
    }

    final Properties ctx = InterfaceWrapperHelper.getCtx(tourVersionLine);
    final I_M_DeliveryDay deliveryDay =
        InterfaceWrapperHelper.create(ctx, I_M_DeliveryDay.class, trxName);
    deliveryDay.setC_BPartner_ID(bpartnerId);
    deliveryDay.setAD_Org_ID(adOrgId);
    deliveryDay.setC_BPartner_Location_ID(bpartnerLocationId);
    deliveryDay.setIsManual(false);
    deliveryDay.setM_Tour_ID(tourId);
    deliveryDay.setM_TourVersion(tourVersion);
    deliveryDay.setIsToBeFetched(isToBeFetched);
    deliveryDay.setSeqNo(seqNo);

    // Dates
    deliveryDay.setDeliveryDate(preparationTime);
    deliveryDay.setBufferHours(bufferHours);
    setDeliveryDateTimeMax(deliveryDay);

    InterfaceWrapperHelper.save(deliveryDay);

    return deliveryDay;
  }
Beispiel #23
0
  /* package */ Lock(
      final ILockDatabase lockDatabase,
      final LockOwner owner,
      final boolean isAutoCleanup,
      final int countLocked) {
    super();

    Check.assumeNotNull(lockDatabase, "lockDatabase not null");
    this.lockDatabase = lockDatabase;

    Check.assumeNotNull(owner, "owner not null");
    Check.assume(
        owner.isRealOwnerOrNoOwner(), "owner shall be a real owner or no owner: {}", owner);
    this.owner = owner;

    this.isAutoCleanup = isAutoCleanup;
    _countLocked = countLocked;
  }
  /**
   * @param workpackageProcessorClass workpackage processor class to be used when workpackages are
   *     enqueued.
   */
  public WorkpackagesOnCommitSchedulerTemplate(
      final Class<? extends IWorkpackageProcessor> workpackageProcessorClass) {
    super();

    Check.assumeNotNull(workpackageProcessorClass, "workpackageProcessorClass not null");
    this.workpackageProcessorClass = workpackageProcessorClass;

    this.trxPropertyName = getClass().getSimpleName() + "-" + workpackageProcessorClass.getName();
  }
  @Override
  public I_M_HU_LUTU_Configuration copy(final I_M_HU_LUTU_Configuration lutuConfiguration) {
    Check.assumeNotNull(lutuConfiguration, "lutuConfiguration not null");
    final I_M_HU_LUTU_Configuration lutuConfigurationNew =
        InterfaceWrapperHelper.newInstance(I_M_HU_LUTU_Configuration.class, lutuConfiguration);
    final boolean honorIsCalculated = true;
    InterfaceWrapperHelper.copyValues(lutuConfiguration, lutuConfigurationNew, honorIsCalculated);

    return lutuConfigurationNew;
  }
  @Override
  public List<I_M_ShippingPackage> retrieveShippingPackages(final I_M_Package mpackage) {
    Check.assumeNotNull(mpackage, "mpackage not null");

    return Services.get(IQueryBL.class)
        .createQueryBuilder(I_M_ShippingPackage.class, mpackage)
        .filter(
            new EqualsQueryFilter<I_M_ShippingPackage>(
                I_M_ShippingPackage.COLUMNNAME_M_Package_ID, mpackage.getM_Package_ID()))
        .create()
        .list(I_M_ShippingPackage.class);
  }
  /**
   * Delete MRP Alternative records for given {@link I_DD_OrderLine_Alternative}.
   *
   * @param ddOrderLineAlt
   */
  private void deleteMRPAlternatives(final I_DD_OrderLine_Alternative ddOrderLineAlt) {
    Check.assumeNotNull(ddOrderLineAlt, "ddOrderLineAlt not null");
    final IQueryBL queryBL = Services.get(IQueryBL.class);
    final IQueryBuilder<I_PP_MRP_Alternative> queryBuilder =
        queryBL
            .createQueryBuilder(I_PP_MRP_Alternative.class, ddOrderLineAlt)
            .addEqualsFilter(
                I_PP_MRP_Alternative.COLUMN_DD_OrderLine_Alternative_ID,
                ddOrderLineAlt.getDD_OrderLine_Alternative_ID());

    queryBuilder.create().deleteDirectly();
  }
 private I_AD_Message getMRPCode_AD_Message_ToUse() {
   final Properties ctx = getCtx();
   final String mrpCode = getMRPCode_ToUse();
   I_AD_Message adMessage = adMessageDAO.retrieveByValue(ctx, mrpCode);
   if (adMessage == null) {
     // If MRP code not found, use MRP-999 - unknown error
     adMessage = adMessageDAO.retrieveByValue(ctx, IMRPExecutor.MRP_ERROR_999_Unknown);
   }
   Check.assumeNotNull(
       adMessage, LiberoException.class, "adMessage not null (MRPCode: {0})", mrpCode);
   return adMessage;
 }
  @Override
  public ICompositeQueryFilter<T> removeFilter(final IQueryFilter<T> filter) {
    Check.assumeNotNull(filter, "filter not null");

    if (filters == null || filters.isEmpty()) {
      return this;
    }

    filters.remove(filter);

    return this;
  }
  /**
   * Retrieves MRP Alternative record for given {@link I_DD_OrderLine_Alternative}.
   *
   * @param ddOrderLineAlt
   * @param mrp
   * @return MRP Alternative or <code>null</code>
   */
  private I_PP_MRP_Alternative retrieveMRPAlternative(
      final I_DD_OrderLine_Alternative ddOrderLineAlt, final I_PP_MRP mrp) {
    // Optimization: in case the DD_OrderLine was just created, there is no point to query because
    // there won't be any result for sure
    if (InterfaceWrapperHelper.isJustCreated(ddOrderLineAlt)) {
      return null;
    }

    Check.assumeNotNull(ddOrderLineAlt, "ddOrderLineAlt not null");
    Check.assumeNotNull(mrp, "mrp not null");

    final IQueryBL queryBL = Services.get(IQueryBL.class);
    final IQueryBuilder<I_PP_MRP_Alternative> queryBuilder =
        queryBL
            .createQueryBuilder(I_PP_MRP_Alternative.class, ddOrderLineAlt)
            .addEqualsFilter(
                I_PP_MRP_Alternative.COLUMN_DD_OrderLine_Alternative_ID,
                ddOrderLineAlt.getDD_OrderLine_Alternative_ID())
            .addEqualsFilter(I_PP_MRP_Alternative.COLUMN_PP_MRP_ID, mrp.getPP_MRP_ID());

    return queryBuilder.create().firstOnly(I_PP_MRP_Alternative.class);
  }