private Date findFirstNonEmptyDate(final Entity entity, final Iterable<String> fieldNames) { for (String fieldName : fieldNames) { Date fieldValue = entity.getDateField(fieldName); if (fieldValue != null) { return fieldValue; } } return null; }
private Date getDate(final Entity entity, final String fieldName) { Date fieldValue = entity.getDateField(fieldName); if (fieldValue != null) { return fieldValue; } return null; }
@Override public boolean apply(final Entity order) { return order.getDateField(OrderFields.DATE_FROM) != null; } };
@Override public DateRange apply(final Entity timetableExceptionEntity) { Date from = timetableExceptionEntity.getDateField(ShiftTimetableExceptionFields.FROM_DATE); Date to = timetableExceptionEntity.getDateField(ShiftTimetableExceptionFields.TO_DATE); return new DateRange(from, to); } };
private boolean areDatesCorrect(final Entity previousOrder, final Entity order) { if ((previousOrder.getField(OrderFields.FINISH_DATE) == null) || (order.getField(OrderFields.START_DATE) == null)) { return true; } return previousOrder.getDateField(OrderFields.FINISH_DATE).after(order.getDateField(OrderFields.START_DATE)); }
private boolean checkCoverageDates(final DataDefinition materialRequirementCoverageDD, final Entity materialRequirementCoverage) { Date actualDate = materialRequirementCoverage.getDateField(MaterialRequirementCoverageFields.ACTUAL_DATE); Date coverageToDate = materialRequirementCoverage.getDateField(MaterialRequirementCoverageFields.COVERAGE_TO_DATE); if (coverageToDate.before(actualDate)) { materialRequirementCoverage.addError( materialRequirementCoverageDD.getField(MaterialRequirementCoverageFields.COVERAGE_TO_DATE), "orderSupplies.materialRequirementCoverage.covarageToDate.isBeforeActualDate"); return false; } return true; }
private Date getCoverageProductLoggingDateForDelivery(final Entity delivery, final Date actualDate) { Date coverageDate; Date deliveryDate = delivery.getDateField(DeliveryFields.DELIVERY_DATE); if (deliveryDate.before(actualDate)) { coverageDate = new DateTime(actualDate).plusSeconds(2).toDate(); } else { coverageDate = deliveryDate; } return coverageDate; }
@Override public int compare(final Entity entity1, final Entity entity2) { return ComparisonChain .start() .compare(entity1.getDateField(CoverageProductLoggingFields.DATE), entity2.getDateField(CoverageProductLoggingFields.DATE)) .compare(entity2.getStringField(CoverageProductLoggingFields.EVENT_TYPE), entity1.getStringField(CoverageProductLoggingFields.EVENT_TYPE)).result(); } });
private boolean validateDatesOrder(final DataDefinition dataDefinition, final Entity balanceContext) { Date from = balanceContext.getDateField(BalanceContextFields.FROM_DATE); Date to = balanceContext.getDateField(BalanceContextFields.TO_DATE); if (from.after(to)) { balanceContext.addError(dataDefinition.getField(BalanceContextFields.TO_DATE), "productionBalancePerShift.balanceContext.error.toDateIsBeforeFromDate"); return false; } return true; }
public boolean validateDates(final DataDefinition dataDefinition, final Entity position) { Date productionDate = position.getDateField(PositionFields.PRODUCTION_DATE); Date expirationDate = position.getDateField(PositionFields.EXPIRATION_DATE); if (productionDate != null && expirationDate != null && expirationDate.compareTo(productionDate) < 0) { position.addError(dataDefinition.getField(PositionFields.EXPIRATION_DATE), "materialFlow.error.position.expirationDate.lessThenProductionDate"); return false; } return true; }
private boolean checkOperatorWorkTime(final DataDefinition staffWorkTimeDD, final Entity staffWorkTime) { Date dateFrom = staffWorkTime.getDateField(StaffWorkTimeFields.EFFECTIVE_EXECUTION_TIME_START); Date dateTo = staffWorkTime.getDateField(StaffWorkTimeFields.EFFECTIVE_EXECUTION_TIME_END); if (dateFrom == null || dateTo == null || dateTo.after(dateFrom)) { return true; } staffWorkTime.addError(staffWorkTimeDD.getField(StaffWorkTimeFields.EFFECTIVE_EXECUTION_TIME_END), "productionCounting.productionTracking.productionTrackingError.effectiveExecutionTimeEndBeforeEffectiveExecutionTimeStart"); return false; }
private void fillDatesMRCFO(final Entity mcfo, final Entity order) { mcfo.setField(CoverageForOrderFields.ACTUAL_DATE, new Date()); if (order.getDateField(OrderFields.DATE_FROM) == null) { mcfo.setField(CoverageForOrderFields.COVERAGE_TO_DATE, DateTime.now().plusDays(1).toDate()); return; } mcfo.setField(CoverageForOrderFields.COVERAGE_TO_DATE, order.getDateField(OrderFields.START_DATE)); }
private void addPlannedDateTable(Document document, Entity orderEntity, Locale locale) throws DocumentException { Map<String, String> values = Maps.newLinkedHashMap(); values.put("plannedDateFrom", DateUtils.toDateTimeString(orderEntity.getDateField(OrderFields.DATE_FROM))); values.put("plannedDateTo", DateUtils.toDateTimeString(orderEntity.getDateField(OrderFields.DATE_TO))); addTableToDocument(document, orderEntity, locale, "orders.order.report.date.label", values); }
private Optional<OrderDates> resolveOrderDates(final Entity order) { Date plannedStart = order.getDateField(OrderFields.DATE_FROM); if (plannedStart == null) { return Optional.absent(); } // Order realization end time is not required, thus I've passed some arbitrary values here. return Optional.of(OrderDates.of(order, new DateTime(plannedStart), new DateTime(plannedStart).plusWeeks(1))); }
private Date findCalculatedStartAllOrders(final Entity order) { List<Entity> ordersTimeCalculations = dataDefinitionService .get(TimeNormsConstants.PLUGIN_PRODUCTION_SCHEDULING_IDENTIFIER, TimeNormsConstants.MODEL_ORDER_TIME_CALCULATION) .find().createAlias("order", "ord", JoinType.LEFT) .add(SearchRestrictions.in("ord.id", getOrderAndSubOrders(order.getId()).stream().map(entity -> entity.getId()).collect(Collectors.toList()))) .list().getEntities(); return ordersTimeCalculations.stream().map(e -> e.getDateField(OrderTimeCalculationFields.EFFECTIVE_DATE_FROM)) .min(Comparator.<Date>naturalOrder()).get(); }
@Transactional(propagation = Propagation.REQUIRES_NEW) private void tryGeneratePPS(final Entity order) { Date startDate = findStartDate(order); generateEmptyPpsForOrder(order); order.setField("generatePPS", true); order.setField(OrderFields.START_DATE, startDate); order.setField(OrderFields.FINISH_DATE, new DateTime(order.getDateField(OrderFields.START_DATE)).plusDays(1).toDate()); Entity storedOrder = order.getDataDefinition().save(order); if (!storedOrder.isValid()) { throw new EntityRuntimeException(storedOrder); } }
public void onBeforeRender(final ViewDefinitionState view) { FormComponent form = (FormComponent) view.getComponentByReference("form"); Entity warehouseStockReport = form.getPersistedEntityWithIncludedFormValues(); if (Objects.isNull(warehouseStockReport.getDateField(WarehouseStockReportFields.WAREHOUSE_STOCK_DATE))) { FieldComponent warehouseStockDateField = (FieldComponent) view .getComponentByReference(WarehouseStockReportFields.WAREHOUSE_STOCK_DATE); warehouseStockDateField.setFieldValue(DateUtils.toDateString(new Date())); warehouseStockDateField.requestComponentUpdateState(); } setCriteriaModifierParameters(view, warehouseStockReport); disableForm(view, form, warehouseStockReport); }
private void fillOrderFields(Entity warehouseIssue) { Entity order = dataDefinitionService.get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER).get( warehouseIssue.getBelongsToField(WarehouseIssueFields.ORDER).getId()); if (warehouseIssue.getDateField(WarehouseIssueFields.ORDER_START_DATE) == null) { warehouseIssue.setField(WarehouseIssueFields.ORDER_START_DATE, order.getDateField(OrderFields.START_DATE)); } if (warehouseIssue.getStringField(WarehouseIssueFields.ORDER_PRODUCTION_LINE_NUMBER) == null) { Entity orderProductionLine = order.getBelongsToField(OrderFields.PRODUCTION_LINE); warehouseIssue.setField(WarehouseIssueFields.ORDER_PRODUCTION_LINE_NUMBER, orderProductionLine.getStringField(ProductionLineFields.NUMBER)); } }
private void checkExpirationDate(Entity deliveredProductMulti, Entity position, String fieldname, DataDefinition positionDataDefinition) { Entity delivery = deliveredProductMulti.getBelongsToField(DeliveredProductMultiFields.DELIVERY); Entity location = delivery.getBelongsToField(DeliveryFields.LOCATION); if (location != null) { Date expirationDate = position.getDateField(DeliveredProductMultiPositionFields.EXPIRATION_DATE); boolean requireExpirationDate = location.getBooleanField(LocationFieldsMFR.REQUIRE_EXPIRATION_DATE); if (requireExpirationDate && expirationDate == null) { position.addError(positionDataDefinition.getField(fieldname), "qcadooView.validate.field.error.missing"); } } }
@Override public DeviationSummary apply(final Entity projection) { String deviationCause = projection.getStringField("deviationCause"); LocalDate date = LocalDate.fromDateFields(projection.getDateField("date")); String orderNumber = projection.getStringField("orderNumber"); String productNumber = projection.getStringField("productNumber"); String comment = projection.getStringField("comment"); return new DeviationSummary(deviationCause, date, orderNumber, productNumber, comment); } };