private BigDecimal calculatePricePerUnit(final BigDecimal quantity, final BigDecimal totalPrice) { BigDecimal pricePerUnit = BigDecimal.ZERO; if ((quantity == null) || (BigDecimal.ZERO.compareTo(quantity) == 0)) { pricePerUnit = null; } else { pricePerUnit = totalPrice.divide(quantity, numberService.getMathContext()); } return pricePerUnit; }
private BigDecimal calculateTotalPrice(final BigDecimal quantity, final BigDecimal pricePerUnit) { BigDecimal totalPrice = BigDecimal.ZERO; if ((quantity == null) || (BigDecimal.ZERO.compareTo(quantity) == 0)) { totalPrice = BigDecimal.ZERO; } else { totalPrice = pricePerUnit.multiply(quantity, numberService.getMathContext()); } return totalPrice; }
private Integer calculatePossibleDeviation(Integer progressTime, BigDecimal possibleDeviationPercent) { BigDecimal percent = possibleDeviationPercent.divide(new BigDecimal(100), numberService.getMathContext()); BigDecimal possibleDeviation = percent.multiply(new BigDecimal(progressTime)); return possibleDeviation.intValue(); }
protected void calculateEfficiencyTime(ShiftEfficiencyCalculationHolder calculationHolder, BigDecimal shiftEfficiency, int workersOnLine, BigDecimal scaledNorm) { BigDecimal ratio = scaledNorm.multiply(new BigDecimal(workersOnLine), numberService.getMathContext()); int time = shiftEfficiency.divide(ratio, numberService.getMathContext()).setScale(0, RoundingMode.HALF_UP).intValue(); calculationHolder.addEfficiencyTime(time); }
protected void calculateEfficiencyTime(ShiftEfficiencyCalculationHolder calculationHolder, BigDecimal shiftEfficiency, BigDecimal scaledNorm) { int time = shiftEfficiency.divide(scaledNorm, numberService.getMathContext()).setScale(0, RoundingMode.HALF_UP) .intValue(); calculationHolder.addEfficiencyTime(time); }
private BigDecimal getCoverageQuantity(final List<Entity> coverageProductLoggingCoverages) { BigDecimal coverageQuantity = BigDecimal.ZERO; for (Entity coverageProductLogging : coverageProductLoggingCoverages) { BigDecimal quantity = coverageProductLogging.getDecimalField(CoverageProductLoggingFields.CHANGES); if (quantity != null) { coverageQuantity = coverageQuantity.add(quantity, numberService.getMathContext()); } } return coverageQuantity; }
private BigDecimal multiply(final BigDecimal value, final BigDecimal factor) { if (value == null || factor == null) { return BigDecimal.ZERO; } return numberService.setScaleWithDefaultMathContext(value.multiply(factor, numberService.getMathContext())); }
@Override public BigDecimal getNeededQuantity(final Entity coverageProduct) { BigDecimal reservceMissingQuantity = BigDecimalUtils.convertNullToZero(coverageProduct .getDecimalField(CoverageProductFields.RESERVE_MISSING_QUANTITY)); BigDecimal negotiatiedQuantity = BigDecimalUtils.convertNullToZero(coverageProduct .getDecimalField(CoverageProductFieldsNFOS.NEGOTIATED_QUANTITY)); return reservceMissingQuantity.abs(numberService.getMathContext()).subtract(negotiatiedQuantity, numberService.getMathContext()); }
@Around("checkIfLowerThanMinimum(productId, quantity, minimumState)") public boolean checkIfLowerThanMinimumWithPlanned(final ProceedingJoinPoint pjp, long productId, BigDecimal quantity, BigDecimal minimumState) throws Throwable { if (includeRequirements()) { int ordersIncludePeriod = getOrdersIncludePeriod(); BigDecimal planned = getPlannedQuantity(productId, ordersIncludePeriod); BigDecimal quantityWithoutPlanned = quantity.subtract(planned, numberService.getMathContext()); return quantityWithoutPlanned.compareTo(minimumState) == -1; } else { return (boolean) pjp.proceed(); } }
@Override public void calculateTotalProductsCost(final Entity entity, final String sourceOfMaterialCosts) { Map<Entity, BigDecimal> listProductWithCost = calculateListProductsCostForPlannedQuantity(entity, sourceOfMaterialCosts); BigDecimal result = BigDecimal.ZERO; for (Entry<Entity, BigDecimal> productWithCost : listProductWithCost.entrySet()) { result = result.add(productWithCost.getValue(), numberService.getMathContext()); } entity.setField("totalMaterialCosts", numberService.setScaleWithDefaultMathContext(result)); }
private BigDecimal price(Entity deliveredProduct, Entity currency) { BigDecimal exRate = currency.getDecimalField(CurrencyFields.EXCHANGE_RATE); Optional<BigDecimal> pricePerUnit = Optional.fromNullable(deliveredProduct .getDecimalField(DeliveredProductFields.PRICE_PER_UNIT)); if (!pricePerUnit.isPresent()) { return null; } return exRateExists(exRate) ? numberService.setScaleWithDefaultMathContext(pricePerUnit.get().multiply(exRate, numberService.getMathContext())) : pricePerUnit.get(); }
private Optional<BigDecimal> calculateQuantitiesDifference(final Entity pps, boolean shouldBeCorrected) { Entity order = pps.getBelongsToField(ProductionPerShiftFields.ORDER); BigDecimal sumOfDailyPlannedQuantities = productionPerShiftDataProvider.countSumOfQuantities(pps, shouldBeCorrected); BigDecimal planedQuantityFromOrder = order.getDecimalField(OrderFields.PLANNED_QUANTITY); return Optional.of(planedQuantityFromOrder.subtract(sumOfDailyPlannedQuantities, numberService.getMathContext())); }
public BigDecimal calculateAdditionalQuantity(BigDecimal quantity, BigDecimal conversion, String unit) { BigDecimal additionalQuantity = quantity.multiply(conversion, numberService.getMathContext()); if (dictionaryService.checkIfUnitIsInteger(unit)) { return numberService.setScaleWithDefaultMathContext(additionalQuantity, 0); } return numberService.setScaleWithDefaultMathContext(additionalQuantity); }
private void calculateReservationQuantities(final DataDefinition orderedProductDD, final Entity orderedProduct) { EntityList reservations = orderedProduct.getHasManyField(OrderedProductFields.RESERVATIONS); if (reservations != null) { BigDecimal conversion = orderedProduct.getDecimalField(OrderedProductFields.CONVERSION); for (Entity reservation : reservations) { BigDecimal orderedQuantity = reservation.getDecimalField(OrderedProductReservationFields.ORDERED_QUANTITY); BigDecimal newAdditionalQuantity = orderedQuantity.multiply(conversion, numberService.getMathContext()); newAdditionalQuantity = newAdditionalQuantity.setScale(NumberService.DEFAULT_MAX_FRACTION_DIGITS_IN_DECIMAL, RoundingMode.HALF_UP); reservation.setField(OrderedProductReservationFields.ADDITIONAL_QUANTITY, newAdditionalQuantity); } } }
@Override public BigDecimal calculateProductCostForGivenQuantity(final Entity product, final BigDecimal quantity, final String calculateMaterialCostsMode) { BigDecimal cost = BigDecimalUtils.convertNullToZero(product.getField(ProductsCostFields.forMode( calculateMaterialCostsMode).getStrValue())); BigDecimal costForNumber = BigDecimalUtils.convertNullToOne(product.getDecimalField("costForNumber")); if (BigDecimalUtils.valueEquals(costForNumber, BigDecimal.ZERO)) { costForNumber = BigDecimal.ONE; } BigDecimal costPerUnit = cost.divide(costForNumber, numberService.getMathContext()); return costPerUnit.multiply(quantity, numberService.getMathContext()); }
private BigDecimal calculateQuantityInAdditionalUnit(Entity resource, String unit) { BigDecimal conversion = resource.getDecimalField(ResourceFields.CONVERSION); BigDecimal quantity = resource.getDecimalField(ResourceFields.QUANTITY); boolean isInteger = dictionaryService.checkIfUnitIsInteger(unit); BigDecimal value = quantity.multiply(conversion, numberService.getMathContext()); if (isInteger) { return numberService.setScaleWithDefaultMathContext(value, 0); } else { return value; } }
private void showQuantitiesDeviationNotice(final ViewDefinitionState view, final BigDecimal quantitiesDifference, final String messageKey) { for (ComponentState productionPerShiftForm : view.tryFindComponentByReference("form").asSet()) { productionPerShiftForm.addMessage(messageKey, ComponentState.MessageType.INFO, false, numberService.formatWithMinimumFractionDigits(quantitiesDifference.abs(numberService.getMathContext()), 0)); } }
public void setRemainingQuantity(final Entity order) { BigDecimal remainingAmountOfProductToProduce = BigDecimalUtils.convertNullToZero( order.getDecimalField(OrderFields.PLANNED_QUANTITY)).subtract( BigDecimalUtils.convertNullToZero(order.getDecimalField(OrderFields.AMOUNT_OF_PRODUCT_PRODUCED)), numberService.getMathContext()); order.setField(OrderFields.REMAINING_AMOUNT_OF_PRODUCT_TO_PRODUCE, remainingAmountOfProductToProduce); }
private void calculatePriceUsingTotalCost(final ViewDefinitionState view, FieldComponent quantityField, FieldComponent totalPriceField) { FieldComponent pricePerUnitField = (FieldComponent) view.getComponentByReference(L_PRICE_PER_UNIT); Locale locale = view.getLocale(); BigDecimal quantity = getBigDecimalFromField(quantityField, locale); BigDecimal totalPrice = getBigDecimalFromField(totalPriceField, locale); BigDecimal pricePerUnit = numberService.setScaleWithDefaultMathContext(totalPrice.divide(quantity, numberService.getMathContext())); pricePerUnitField.setFieldValue(numberService.format(pricePerUnit)); pricePerUnitField.requestComponentUpdateState(); }
private void updateCosts(final BigDecimal newQuantity, final Entity orderMaterialCosts, final BigDecimal oldQuantity) { BigDecimal factor = newQuantity.divide(oldQuantity, numberService.getMathContext()); BigDecimal nominalCost = orderMaterialCosts.getDecimalField(TechnologyInstOperProductInCompFields.NOMINAL_COST); BigDecimal lastPurchaseCost = orderMaterialCosts .getDecimalField(TechnologyInstOperProductInCompFields.LAST_PURCHASE_COST); BigDecimal averageCost = orderMaterialCosts.getDecimalField(TechnologyInstOperProductInCompFields.AVERAGE_COST); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.COST_FOR_NUMBER, numberService.setScaleWithDefaultMathContext(newQuantity)); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.NOMINAL_COST, multiply(nominalCost, factor)); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.LAST_PURCHASE_COST, multiply(lastPurchaseCost, factor)); orderMaterialCosts.setField(TechnologyInstOperProductInCompFields.AVERAGE_COST, multiply(averageCost, factor)); }