private void generateAndAddOrder() {
Entity order =
dataDefinitionService.get(L_ORDERS_PLUGIN_IDENTIFIER, L_ORDERS_MODEL_ORDER).create();
long dateFrom = generateRandomDate();
long dateTo = generateRandomDate(dateFrom);
Preconditions.checkArgument(dateTo > dateFrom, "Order was finished before it was started !");
Entity product = getRandomProduct();
Entity technology =
(getDefaultTechnologyForProduct(product) == null)
? getRandomProduct()
: getDefaultTechnologyForProduct(product);
String number = generateString(CHARS_AND_DIGITS, RANDOM.nextInt(34) + 5);
order.setField(L_NUMBER, number);
order.setField(L_NAME, getNameFromNumberAndPrefix("Order-", number));
order.setField("dateFrom", new Date(dateFrom));
order.setField("dateTo", new Date(dateTo));
order.setField(STATE_L, "01pending");
order.setField(L_BASIC_MODEL_PRODUCT, product);
order.setField("plannedQuantity", RANDOM.nextInt(100) + 100);
order.setField("doneQuantity", RANDOM.nextInt(100) + 1);
order.setField(L_TECHNOLOGY_MODEL_TECHNOLOGY, technology);
order.setField("externalSynchronized", true);
order.setField("typeOfProductionRecording", "01basic");
order.setField("trackingRecordTreatment", "01duringProduction");
dataDefinitionService.get(L_ORDERS_PLUGIN_IDENTIFIER, L_ORDERS_MODEL_ORDER).save(order);
}
private void generateAndAddOperation() {
Entity operation =
dataDefinitionService.get(TECHNOLOGIES_PLUGIN, L_TECHNOLOGY_MODEL_OPERATION).create();
String number = generateString(CHARS_ONLY, RANDOM.nextInt(40) + 5);
operation.setField(L_NUMBER, number);
operation.setField("name", getNameFromNumberAndPrefix("Operation-", number));
operation.setField(L_BASIC_MODEL_STAFF, getRandomStaff());
operation.setField(L_BASIC_MODEL_WORKSTATION_TYPE, getRandomMachine());
operation.setField(L_TPZ, RANDOM.nextInt(1000));
operation.setField(L_TJ, RANDOM.nextInt(1000));
operation.setField("productionInOneCycle", RANDOM.nextInt(20));
operation.setField(L_NEXT_OPERATION_AFTER_PRODUCED_TYPE, RANDOM.nextInt(10));
operation.setField(
"machineUtilization", numberService.setScale(new BigDecimal(RANDOM.nextDouble()).abs()));
operation.setField(
"laborUtilization", numberService.setScale(new BigDecimal(RANDOM.nextDouble()).abs()));
operation.setField("nextOperationAfterProducedQuantity", RANDOM.nextInt(15));
operation.setField(L_NEXT_OPERATION_AFTER_PRODUCED_TYPE, "01all");
operation.setField("timeNextOperation", RANDOM.nextInt(30));
operation.setField("nextOperationAfterProducedQuantity", "0");
if (isEnabledOrEnabling("costNormsForOperation")) {
operation.setField("pieceworkCost", RANDOM.nextInt(100));
operation.setField("machineHourlyCost", RANDOM.nextInt(100));
operation.setField("laborHourlyCost", RANDOM.nextInt(100));
operation.setField("numberOfOperations", RANDOM.nextInt(10) + 1);
}
dataDefinitionService.get(TECHNOLOGIES_PLUGIN, L_TECHNOLOGY_MODEL_OPERATION).save(operation);
}
private void generateAndAddWorkPlan() {
Entity workPlan = dataDefinitionService.get("workPlans", "workPlan").create();
workPlan.setField(
L_NAME,
getNameFromNumberAndPrefix(
"WorkPlan-", 5 + generateString(CHARS_AND_DIGITS, RANDOM.nextInt(45))));
workPlan.setField("date", new Date(generateRandomDate()));
workPlan.setField(
"worker",
getNameFromNumberAndPrefix(
"Worker-", 5 + generateString(CHARS_AND_DIGITS, RANDOM.nextInt(45))));
workPlan.setField("generated", false);
workPlan.setField("type", "01noDistinction");
workPlan = workPlan.getDataDefinition().save(workPlan);
List<Entity> allOrders =
dataDefinitionService.get("orders", L_ORDERS_MODEL_ORDER).find().list().getEntities();
int iters = RANDOM.nextInt(allOrders.size() / 30 + 1);
for (int i = 0; i < iters; i++) {
addWorkPlanComponent(workPlan, allOrders);
}
}
private void generateDictionaryItem(final String name) {
Entity dictionary = getDictionaryByName(name);
Entity item = dataDefinitionService.get("qcadooModel", "dictionaryItem").create();
item.setField("dictionary", dictionary);
item.setField(L_NAME, generateString(CHARS_ONLY, 8));
dataDefinitionService.get("qcadooModel", "dictionaryItem").save(item);
}
private void generateAndAddStaff() {
Entity staff =
dataDefinitionService.get(L_BASIC_PLUGIN_IDENTIFIER, L_BASIC_MODEL_STAFF).create();
String number = generateString(DIGITS_ONLY, RANDOM.nextInt(40) + 5);
staff.setField(L_NUMBER, number);
staff.setField(L_NAME, getNameFromNumberAndPrefix("Staff-", number));
staff.setField("surname", generateString(CHARS_ONLY, RANDOM.nextInt(12)));
staff.setField("post", generateString(CHARS_ONLY, RANDOM.nextInt(5)));
dataDefinitionService.get(L_BASIC_PLUGIN_IDENTIFIER, L_BASIC_MODEL_STAFF).save(staff);
}
private void addSubstituteComponent(
final Entity substitute, final Entity product, final double quantity) {
Entity substituteComponent =
dataDefinitionService.get(L_BASIC_PLUGIN_IDENTIFIER, "substituteComponent").create();
substituteComponent.setField(
"quantity", numberService.setScale(new BigDecimal(quantity + 1).abs()));
substituteComponent.setField(L_BASIC_MODEL_PRODUCT, product);
substituteComponent.setField("substitute", substitute);
dataDefinitionService
.get(L_BASIC_PLUGIN_IDENTIFIER, "substituteComponent")
.save(substituteComponent);
}
private void generateAndAddShift(final String locale) {
Entity shift = dataDefinitionService.get(L_BASIC_PLUGIN_IDENTIFIER, "shift").create();
shift.setField(
L_NAME,
getNameFromNumberAndPrefix("Shift-", generateString(CHARS_ONLY, RANDOM.nextInt(40) + 5)));
for (int i = 0; i < SHIFT_HOURS.length; i++) {
shift.setField(WORK_SHIFT[i], RANDOM.nextBoolean());
shift.setField(SHIFT_HOURS[i], generateWorkingHours(locale));
}
dataDefinitionService.get(L_BASIC_PLUGIN_IDENTIFIER, "shift").save(shift);
}
private void addSubstituteToProduct(final Entity product) {
Entity substitute = dataDefinitionService.get(L_BASIC_PLUGIN_IDENTIFIER, "substitute").create();
String number = generateString(DIGITS_ONLY, RANDOM.nextInt(34) + 5);
substitute.setField(L_NUMBER, number);
substitute.setField(L_NAME, getNameFromNumberAndPrefix("ProductSubstitute-", number));
substitute.setField(L_BASIC_MODEL_PRODUCT, product);
substitute.setField("priority", RANDOM.nextInt(7));
substitute =
dataDefinitionService.get(L_BASIC_PLUGIN_IDENTIFIER, "substitute").save(substitute);
addSubstituteComponent(
substitute, getRandomProduct(), RANDOM.nextInt(997) * RANDOM.nextDouble());
}
private Entity getCompany(final String number) {
return dataDefinitionService
.get(SamplesConstants.BASIC_PLUGIN_IDENTIFIER, SamplesConstants.BASIC_MODEL_COMPANY)
.find()
.add(SearchRestrictions.eq("number", number))
.uniqueResult();
}
public BigDecimal getQuantityOfProductInWarehouse(
final Entity warehouse, final Entity product, Entity position) {
BigDecimal quantity = BigDecimal.ZERO;
Entity resource = position.getBelongsToField(PositionFields.RESOURCE);
Entity reservation = reservationsService.getReservationForPosition(position);
if (resource != null) {
quantity = resource.getDecimalField(ResourceFields.AVAILABLE_QUANTITY);
} else {
List<Entity> resources =
dataDefinitionService
.get(
MaterialFlowResourcesConstants.PLUGIN_IDENTIFIER,
MaterialFlowResourcesConstants.MODEL_RESOURCE)
.find()
.add(SearchRestrictions.belongsTo(ResourceFields.LOCATION, warehouse))
.add(SearchRestrictions.belongsTo(ResourceFields.PRODUCT, product))
.list()
.getEntities();
for (Entity res : resources) {
quantity = quantity.add(res.getDecimalField(ResourceFields.AVAILABLE_QUANTITY));
}
}
if (reservation != null) {
quantity = quantity.add(reservation.getDecimalField(ReservationFields.QUANTITY));
}
return quantity;
}
public Entity createProductEntity(final ParsedProduct product) {
Entity productEntity =
dataDefinitionService
.get(SfcSimpleConstants.PLUGIN_IDENTIFIER, SfcSimpleConstants.MODEL_IMPORTED_PRODUCT)
.create();
switch (EppParser.ProductType.valueOf(product.getField(FIELD_TYPE))) {
case ARTICLE:
productEntity.setField(FIELD_TYPE, "01article");
break;
case SERVICE:
productEntity.setField(FIELD_TYPE, "02service");
break;
case PACK:
productEntity.setField(FIELD_TYPE, "03pack");
break;
case SET:
productEntity.setField(FIELD_TYPE, "04set");
break;
default:
throw new IllegalStateException("unknown product type");
}
productEntity.setField(FIELD_IDENTIFICATION_CODE, product.getIdentificationCode());
productEntity.setField("ean", product.getField("ean"));
productEntity.setField(FIELD_NAME, product.getField(FIELD_NAME));
productEntity.setField("description", product.getField("description"));
productEntity.setField(FIELD_UNIT, product.getField(FIELD_UNIT));
productEntity.setField(FIELD_CONVERTED, 0);
return productEntity;
}
public Entity createResource(
final Entity position,
final Entity warehouse,
final Entity resource,
final BigDecimal quantity,
Object date) {
DataDefinition resourceDD =
dataDefinitionService.get(
MaterialFlowResourcesConstants.PLUGIN_IDENTIFIER,
MaterialFlowResourcesConstants.MODEL_RESOURCE);
Entity newResource = resourceDD.create();
if (position != null) {
Entity document = position.getBelongsToField(PositionFields.DOCUMENT);
if (document != null) {
Entity user = document.getBelongsToField(DocumentFields.USER);
newResource.setField(
ResourceFields.USER_NAME,
user.getStringField(_FIRST_NAME) + " " + user.getStringField(L_LAST_NAME));
}
}
newResource.setField(ResourceFields.TIME, date);
newResource.setField(ResourceFields.LOCATION, warehouse);
newResource.setField(
ResourceFields.PRODUCT, resource.getBelongsToField(PositionFields.PRODUCT));
newResource.setField(ResourceFields.QUANTITY, quantity);
newResource.setField(ResourceFields.AVAILABLE_QUANTITY, quantity);
newResource.setField(ResourceFields.RESERVED_QUANTITY, BigDecimal.ZERO);
newResource.setField(ResourceFields.PRICE, resource.getField(PositionFields.PRICE));
newResource.setField(ResourceFields.BATCH, resource.getField(PositionFields.BATCH));
newResource.setField(
ResourceFields.EXPIRATION_DATE, resource.getField(PositionFields.EXPIRATION_DATE));
newResource.setField(
ResourceFields.PRODUCTION_DATE, resource.getField(PositionFields.PRODUCTION_DATE));
newResource.setField(
ResourceFields.STORAGE_LOCATION, resource.getField(ResourceFields.STORAGE_LOCATION));
newResource.setField(
ResourceFields.ADDITIONAL_CODE, resource.getField(ResourceFields.ADDITIONAL_CODE));
newResource.setField(ResourceFields.CONVERSION, resource.getField(ResourceFields.CONVERSION));
newResource.setField(
ResourceFields.PALLET_NUMBER, resource.getField(ResourceFields.PALLET_NUMBER));
newResource.setField(
ResourceFields.TYPE_OF_PALLET, resource.getField(ResourceFields.TYPE_OF_PALLET));
newResource.setField(ResourceFields.GIVEN_UNIT, resource.getField(ResourceFields.GIVEN_UNIT));
BigDecimal quantityInAdditionalUnit =
numberService.setScale(
quantity.multiply(resource.getDecimalField(ResourceFields.CONVERSION)));
newResource.setField(ResourceFields.QUANTITY_IN_ADDITIONAL_UNIT, quantityInAdditionalUnit);
setResourceAttributesFromResource(newResource, resource);
resourceStockService.addResourceStock(newResource);
return resourceDD.save(newResource);
}
protected Entity findDictionaryItemByName(final String name) {
return dataDefinitionService
.get("qcadooModel", "dictionaryItem")
.find()
.add(SearchRestrictions.eq(NAME, name))
.uniqueResult();
}
public void showCopyOfTechnology(
final ViewDefinitionState view, final ComponentState state, final String[] args) {
Long orderId = (Long) state.getFieldValue();
if (orderId != null) {
Entity order =
dataDefinitionService
.get(OrdersConstants.PLUGIN_IDENTIFIER, OrdersConstants.MODEL_ORDER)
.get(orderId);
if (OrderType.WITH_PATTERN_TECHNOLOGY
.getStringValue()
.equals(order.getField(OrderFields.ORDER_TYPE))
&& (order.getBelongsToField(OrderFields.TECHNOLOGY_PROTOTYPE) == null)) {
state.addMessage("order.technology.patternTechnology.not.set", MessageType.INFO);
return;
}
Long technologyId = order.getBelongsToField(OrderFields.TECHNOLOGY).getId();
Map<String, Object> parameters = Maps.newHashMap();
parameters.put("form.id", technologyId);
String url = "../page/orders/copyOfTechnologyDetails.html";
view.redirectTo(url, false, true, parameters);
}
}
public Entity findDictionaryItemByTechnicalCode(final String technicalCode) {
return dataDefinitionService
.get("qcadooModel", "dictionaryItem")
.find()
.add(SearchRestrictions.eq(TECHNICAL_CODE, technicalCode))
.uniqueResult();
}
/**
* Creates position with given field values (with the same base and given unit)
*
* @param product
* @param quantity
* @param price
* @param batch
* @param expirationDate
* @param productionDate
* @param resource
* @return Created position entity
*/
public Entity createPosition(
final Entity product,
final BigDecimal quantity,
final BigDecimal price,
final String batch,
final Date productionDate,
final Date expirationDate,
final Entity resource) {
DataDefinition positionDD =
dataDefinitionService.get(
MaterialFlowResourcesConstants.PLUGIN_IDENTIFIER,
MaterialFlowResourcesConstants.MODEL_POSITION);
Entity position = positionDD.create();
position.setField(PositionFields.PRODUCT, product);
position.setField(PositionFields.QUANTITY, quantity);
position.setField(PositionFields.GIVEN_QUANTITY, quantity);
position.setField(PositionFields.GIVEN_UNIT, product.getStringField(ProductFields.UNIT));
position.setField(PositionFields.PRICE, price);
position.setField(PositionFields.BATCH, batch);
position.setField(PositionFields.PRODUCTION_DATE, productionDate);
position.setField(PositionFields.EXPIRATION_DATE, expirationDate);
position.setField(PositionFields.RESOURCE, resource);
return position;
}
private Entity generateFormEntity(final ViewDefinitionState view) {
DataDefinition dd =
dataDefinitionService.get(BasicConstants.PLUGIN_IDENTIFIER, BasicConstants.MODEL_PRODUCT);
FormComponent form = getForm(view);
Entity formEntity = form.getEntity();
GridComponent parentsGrid = (GridComponent) view.getComponentByReference("parents");
if (parentsGrid.getSelectedEntities().isEmpty()) {
return null;
}
Long productId = parentsGrid.getSelectedEntities().get(0).getId();
if (productId == null) {
throw new FormValidationException("basic.productFamiliesTree.noProductSelected");
}
Entity product = dd.get(productId);
List<Entity> tree = productsFamiliesTreeService.getHierarchyProductsTree(product);
EntityTree entityTree = EntityTreeUtilsService.getDetachedEntityTree(tree);
formEntity.setId(productId);
formEntity.setField(PRODUCT_FAMILY_CHILDREN_TREE, entityTree);
return formEntity;
}
@Test
public final void shouldGetPpsForOrderReturnNullIfPpsDoesNotExists() {
// given
Long givenOrderId = 1L;
given(
dataDefinitionService.get(
ProductionPerShiftConstants.PLUGIN_IDENTIFIER,
ProductionPerShiftConstants.MODEL_PRODUCTION_PER_SHIFT))
.willReturn(dataDefinition);
SearchQueryBuilder searchCriteriaBuilder = mock(SearchQueryBuilder.class);
given(
dataDefinition.find(
"select id as ppsId from #productionPerShift_productionPerShift where order.id = :orderId"))
.willReturn(searchCriteriaBuilder);
given(searchCriteriaBuilder.setMaxResults(Mockito.anyInt())).willReturn(searchCriteriaBuilder);
given(searchCriteriaBuilder.setLong(Mockito.anyString(), Mockito.eq(givenOrderId)))
.willReturn(searchCriteriaBuilder);
given(searchCriteriaBuilder.uniqueResult()).willReturn(null);
// when
final Long resultPpsId = ppsHelper.getPpsIdForOrder(givenOrderId);
// then
Assert.assertNull(resultPpsId);
}
@Before
public final void init() {
workPlanService = new WorkPlansServiceImpl();
dataDefinitionService = mock(DataDefinitionService.class);
TranslationService translationService = mock(TranslationService.class);
workPlan = mock(Entity.class);
workPlanDD = mock(DataDefinition.class);
when(dataDefinitionService.get(
WorkPlansConstants.PLUGIN_IDENTIFIER, WorkPlansConstants.MODEL_WORK_PLAN))
.thenReturn(workPlanDD);
when(translationService.translate(
Mockito.anyString(), Mockito.any(Locale.class), Mockito.anyString()))
.thenReturn(TRANSLATED_STRING);
when(workPlanDD.getName()).thenReturn(WorkPlansConstants.MODEL_WORK_PLAN);
when(workPlanDD.getPluginIdentifier()).thenReturn(WorkPlansConstants.PLUGIN_IDENTIFIER);
when(workPlanDD.get(Mockito.anyLong())).thenReturn(workPlan);
when(workPlan.getDataDefinition()).thenReturn(workPlanDD);
when(workPlan.getId()).thenReturn(1L);
ReflectionTestUtils.setField(workPlanService, "dataDefinitionService", dataDefinitionService);
ReflectionTestUtils.setField(workPlanService, "translationService", translationService);
}
@Override
public Set<ImportedOrder> getImportedOrders(final Set<Long> orderIds) {
Set<ImportedOrder> result = new HashSet<ImportedOrder>();
for (Long importedOrderId : orderIds) {
Entity orderEntity =
dataDefinitionService
.get(SfcSimpleConstants.PLUGIN_IDENTIFIER, SfcSimpleConstants.MODEL_IMPORTED_ORDER)
.get(importedOrderId);
ImportedOrder order = new ImportedOrder(importedOrderId);
order.setNumber(orderEntity.getStringField(FIELD_NUMBER));
order.setDrawDate((Date) orderEntity.getField(FIELD_DRAW_DATE));
order.setRealizationDate((Date) orderEntity.getField(FIELD_REALIZATION_DATE));
for (Entity orderProductEntity : orderEntity.getHasManyField("orderProducts")) {
ImportedProduct orderItemProduct =
createImportedProduct(orderProductEntity.getBelongsToField("product"), true);
if (orderItemProduct != null) {
ImportedOrderItem orderItem = new ImportedOrderItem();
orderItem.setProduct(orderItemProduct);
orderItem.setQuantity((BigDecimal) orderProductEntity.getField(FIELD_QUANTITY));
order.addItem(orderItem);
}
}
result.add(order);
}
return result;
}
private void generateAndAddWorkstationType() {
Entity machine =
dataDefinitionService
.get(L_BASIC_PLUGIN_IDENTIFIER, L_BASIC_MODEL_WORKSTATION_TYPE)
.create();
String number = generateString(CHARS_AND_DIGITS, RANDOM.nextInt(40) + 5);
machine.setField(L_NAME, getNameFromNumberAndPrefix("Workstation type-", number));
machine.setField(L_NUMBER, number);
machine.setField("description", generateString(CHARS_ONLY, RANDOM.nextInt(100)));
dataDefinitionService
.get(L_BASIC_PLUGIN_IDENTIFIER, L_BASIC_MODEL_WORKSTATION_TYPE)
.save(machine);
}
private Entity addOperationComponent(
final Entity technology,
final Entity parent,
final Entity operation,
final int productsComponentsQuantity) {
Preconditions.checkNotNull(technology, "Technology entity is null");
Entity operationComponent =
dataDefinitionService
.get(L_TECHNOLOGIES_PLUGIN_IDENTIFIER, "technologyOperationComponent")
.create();
int productInComponentQuantity = RANDOM.nextInt(productsComponentsQuantity);
int productOutComponentQuantity = productsComponentsQuantity - productInComponentQuantity;
operationComponent.setField(
L_NAME, "operationComponent" + generateString(CHARS_AND_DIGITS, 15));
operationComponent.setField(L_NUMBER, generateString(CHARS_AND_DIGITS, 20));
operationComponent.setField(L_TECHNOLOGY_MODEL_TECHNOLOGY, technology);
operationComponent.setField("parent", parent);
operationComponent.setField(L_TECHNOLOGY_MODEL_OPERATION, operation);
operationComponent.setField("entityType", L_TECHNOLOGY_MODEL_OPERATION);
operationComponent.setField(L_TPZ, operation.getField(L_TPZ));
operationComponent.setField(L_TJ, operation.getField(L_TJ));
operationComponent.setField("machineUtilization", operation.getField("machineUtilization"));
operationComponent.setField("laborUtilization", operation.getField("laborUtilization"));
operationComponent.setField("productionInOneCycle", operation.getField("productionInOneCycle"));
operationComponent.setField(
L_NEXT_OPERATION_AFTER_PRODUCED_TYPE,
operation.getField(L_NEXT_OPERATION_AFTER_PRODUCED_TYPE));
operationComponent.setField("nextOperationAfterProducedQuantity", "0");
operationComponent.setField("timeNextOperation", operation.getField("timeNextOperation"));
operationComponent = operationComponent.getDataDefinition().save(operationComponent);
List<Entity> listOut = new LinkedList<Entity>();
Entity productOut = null;
for (int i = 0; i < productOutComponentQuantity; i++) {
productOut = getRandomProduct();
while (listOut.contains(productOut)) {
productOut = getRandomProduct();
}
listOut.add(productOut);
generateAndAddOperationProductOutComponent(
operationComponent, new BigDecimal(RANDOM.nextInt(50) + 5), productOut);
}
List<Entity> listIn = new LinkedList<Entity>();
Entity productIn = null;
for (int i = 0; i < productInComponentQuantity; i++) {
productIn = getRandomProduct();
while (listIn.contains(productIn)) {
productIn = getRandomProduct();
}
listIn.add(productIn);
generateAndAddOperationProductInComponent(
operationComponent, new BigDecimal(RANDOM.nextInt(50) + 5), productIn);
}
return operationComponent;
}
protected void addCompany(final Map<String, String> values) {
Entity company =
dataDefinitionService
.get(SamplesConstants.BASIC_PLUGIN_IDENTIFIER, SamplesConstants.BASIC_MODEL_COMPANY)
.create();
LOG.debug(
"id: "
+ values.get("id")
+ "number: "
+ values.get("number")
+ " companyFullName "
+ values.get("companyfullname")
+ " tax "
+ values.get("tax")
+ " street "
+ values.get("street")
+ " house "
+ values.get("house")
+ " flat "
+ values.get("flat")
+ " zipCode "
+ values.get("zipcode")
+ " city "
+ values.get("city")
+ " state "
+ values.get("state")
+ " country "
+ values.get("country")
+ " email "
+ values.get(EMAIL)
+ " website "
+ values.get("website")
+ " phone "
+ values.get("phone")
+ " owner "
+ values.get("owner"));
company.setField("number", values.get("number"));
company.setField(NAME, values.get(NAME));
company.setField("tax", values.get("tax"));
company.setField("street", values.get("street"));
company.setField("house", values.get("house"));
company.setField("flat", values.get("flat"));
company.setField("zipCode", values.get("zipcode"));
company.setField("city", values.get("city"));
company.setField("state", values.get("state"));
company.setField("country", values.get("country"));
company.setField(EMAIL, values.get(EMAIL));
company.setField("website", values.get("website"));
company.setField("phone", values.get("phone"));
company.setField("owner", values.get("owner"));
if (LOG.isDebugEnabled()) {
LOG.debug("Add test company item {company=" + company.getField(NAME) + "}");
}
company.getDataDefinition().save(company);
}
public void setOrderAsConverted(final ImportedOrder order) {
DataDefinition importedOrderDataDefinition =
dataDefinitionService.get(
SfcSimpleConstants.PLUGIN_IDENTIFIER, SfcSimpleConstants.MODEL_IMPORTED_ORDER);
Entity importedOrder = importedOrderDataDefinition.get(order.getOriginalEntityId());
importedOrder.setField(FIELD_CONVERTED, "1");
importedOrderDataDefinition.save(importedOrder);
}
public void deleteOrderProducts(final Entity orderEntity) {
for (Entity orrderProductEntity : orderEntity.getHasManyField("orderProducts")) {
dataDefinitionService
.get(
SfcSimpleConstants.PLUGIN_IDENTIFIER, SfcSimpleConstants.MODEL_IMPORTED_ORDER_PRODUCT)
.delete(orrderProductEntity.getId());
}
}
public void setProductAsConverted(final ImportedProduct product) {
DataDefinition importedProductDataDefinition =
dataDefinitionService.get(
SfcSimpleConstants.PLUGIN_IDENTIFIER, SfcSimpleConstants.MODEL_IMPORTED_PRODUCT);
Entity importedProduct = importedProductDataDefinition.get(product.getOriginalEntityId());
importedProduct.setField(FIELD_CONVERTED, "1");
importedProductDataDefinition.save(importedProduct);
}
@RequestMapping(value = "developReport/hql", method = RequestMethod.POST)
public ModelAndView executeHql(@RequestParam(L_HQL) final String hql) {
if (!showReportDevelopment) {
return new ModelAndView(new RedirectView("/"));
}
try {
List<Entity> entities =
dataDefinitionService.get("qcadooPlugin", "plugin").find(hql).list().getEntities();
if (entities.isEmpty()) {
return new ModelAndView(L_QCADOO_REPORT_HQL)
.addObject(L_HQL, hql)
.addObject("isEmpty", true);
} else {
DataDefinition dataDefinition = entities.get(0).getDataDefinition();
List<String> headers = new ArrayList<String>();
if (!isDynamicDataDefinition(dataDefinition)) {
headers.add("id");
}
headers.addAll(dataDefinition.getFields().keySet());
List<List<String>> rows = new ArrayList<List<String>>();
for (Entity entity : entities) {
List<String> row = new ArrayList<String>();
if (!isDynamicDataDefinition(dataDefinition)) {
row.add(String.valueOf(entity.getId()));
}
for (String field : dataDefinition.getFields().keySet()) {
if (entity.getField(field) == null) {
row.add("");
} else if (entity.getField(field) instanceof EntityList) {
row.add("[]");
} else {
row.add(String.valueOf(entity.getField(field)));
}
}
rows.add(row);
}
return new ModelAndView(L_QCADOO_REPORT_HQL)
.addObject(L_HQL, hql)
.addObject("headers", headers)
.addObject("rows", rows)
.addObject("isOk", true);
}
} catch (Exception e) {
return showException(L_QCADOO_REPORT_HQL, e).addObject(L_HQL, hql);
}
}
private Entity getRandomEntity(final String pluginIdentifier, final String modelName) {
SearchCriteriaBuilder searchBuilder =
dataDefinitionService.get(pluginIdentifier, modelName).find();
int totalNumberOfEntities = searchBuilder.list().getTotalNumberOfEntities();
return searchBuilder
.setMaxResults(1)
.setFirstResult(RANDOM.nextInt(totalNumberOfEntities))
.uniqueResult();
}
@Before
public void init() {
MockitoAnnotations.initMocks(this);
DataDefinition materialCostsComponentDD = mock(DataDefinition.class);
given(materialCostsComponentDD.create()).willReturn(createdEntity);
DataDefinitionService dataDefinitionService = mock(DataDefinitionService.class);
given(
dataDefinitionService.get(
CostNormsForMaterialsConstants.PLUGIN_IDENTIFIER,
CostNormsForMaterialsConstants.MODEL_TECHNOLOGY_INST_OPER_PRODUCT_IN_COMP))
.willReturn(materialCostsComponentDD);
orderMaterialCostsEntityBuilder = new OrderMaterialCostsEntityBuilderImpl();
ReflectionTestUtils.setField(
orderMaterialCostsEntityBuilder, "dataDefinitionService", dataDefinitionService);
}
public Entity createResource(
final Entity document, final Entity warehouse, final Entity position, final Object date) {
DataDefinition resourceDD =
dataDefinitionService.get(
MaterialFlowResourcesConstants.PLUGIN_IDENTIFIER,
MaterialFlowResourcesConstants.MODEL_RESOURCE);
Entity product = position.getBelongsToField(PositionFields.PRODUCT);
Entity resource = resourceDD.create();
Entity user = document.getBelongsToField(DocumentFields.USER);
resource.setField(
ResourceFields.USER_NAME,
user.getStringField(_FIRST_NAME) + " " + user.getStringField(L_LAST_NAME));
resource.setField(ResourceFields.TIME, date);
resource.setField(ResourceFields.LOCATION, warehouse);
resource.setField(ResourceFields.PRODUCT, position.getBelongsToField(PositionFields.PRODUCT));
resource.setField(ResourceFields.QUANTITY, position.getField(PositionFields.QUANTITY));
resource.setField(ResourceFields.RESERVED_QUANTITY, BigDecimal.ZERO);
resource.setField(
ResourceFields.AVAILABLE_QUANTITY, position.getDecimalField(PositionFields.QUANTITY));
resource.setField(ResourceFields.PRICE, position.getField(PositionFields.PRICE));
resource.setField(ResourceFields.BATCH, position.getField(PositionFields.BATCH));
resource.setField(
ResourceFields.EXPIRATION_DATE, position.getField(PositionFields.EXPIRATION_DATE));
resource.setField(
ResourceFields.PRODUCTION_DATE, position.getField(PositionFields.PRODUCTION_DATE));
resource.setField(
ResourceFields.STORAGE_LOCATION, position.getField(PositionFields.STORAGE_LOCATION));
resource.setField(
ResourceFields.ADDITIONAL_CODE, position.getField(PositionFields.ADDITIONAL_CODE));
resource.setField(
ResourceFields.PALLET_NUMBER, position.getField(PositionFields.PALLET_NUMBER));
resource.setField(
ResourceFields.TYPE_OF_PALLET, position.getField(PositionFields.TYPE_OF_PALLET));
resource.setField(ResourceFields.WASTE, position.getField(PositionFields.WASTE));
if (StringUtils.isEmpty(product.getStringField(ProductFields.ADDITIONAL_UNIT))) {
resource.setField(ResourceFields.GIVEN_UNIT, product.getField(ProductFields.UNIT));
resource.setField(
ResourceFields.QUANTITY_IN_ADDITIONAL_UNIT, position.getField(PositionFields.QUANTITY));
resource.setField(ResourceFields.CONVERSION, BigDecimal.ONE);
} else {
resource.setField(ResourceFields.GIVEN_UNIT, position.getField(PositionFields.GIVEN_UNIT));
resource.setField(
ResourceFields.QUANTITY_IN_ADDITIONAL_UNIT,
position.getField(PositionFields.GIVEN_QUANTITY));
resource.setField(ResourceFields.CONVERSION, position.getField(PositionFields.CONVERSION));
}
setResourceAttributesFromPosition(resource, position);
resourceStockService.addResourceStock(resource);
return resourceDD.save(resource);
}