Examples with Delegator org.apache.ofbiz.entity.Delegator used on opensource projects

Example 81 with Delegator

use of org.apache.ofbiz.entity.Delegator in project ofbiz-framework by apache.

the class WorkEffortServices method getWorkEffortEventsByPeriod.

/**
 * Get Work Efforts by period.
 * <p>
 * This method takes the following parameters:
 * </p>
 * <ul>
 *   <li>start - TimeStamp (Period start date/time)</li>
 *   <li>numPeriods - Integer</li>
 *   <li>periodType - Integer (see java.util.Calendar)</li>
 *   <li>eventStatus - String</li>
 *   <li>partyId - String</li>
 *   <li>partyIds - List</li>
 *   <li>facilityId - String</li>
 *   <li>fixedAssetId - String</li>
 *   <li>filterOutCanceledEvents - Boolean</li>
 *   <li>entityExprList - List</li>
 * </ul>
 * <p>
 * The method will find all matching Work Effort events and return them as a List called
 * <b>periods</b> - one List element per period. It also returns a
 * <b>maxConcurrentEntries</b> Integer - which indicates the maximum number of
 * Work Efforts found in one period.
 * </p>
 * <p>
 * Each <b>periods</b> list element is a Map containing the following
 * key/value pairs:
 * </p>
 * <ul>
 *   <li>start - TimeStamp (Period start date/time)</li>
 *   <li>end - TimeStamp (Period end date/time)</li>
 *   <li>calendarEntries - List of Maps. Each Map contains the following key/value pairs</li>
 *   <li><ul>
 *       <li>workEffort - GenericValue</li>
 *       <li>periodSpan - Integer (Number of periods this Work Effort spans)</li>
 *       <li>startOfPeriod - Boolean (true if this is the first occurrence in the period range)</li>
 *   </ul></li>
 * </ul>
 */
public static Map<String, Object> getWorkEffortEventsByPeriod(DispatchContext ctx, Map<String, ? extends Object> context) {
    /*
         To create testdata for  this function for  fixedasset/facility

        1) go to Manufacturing -> JobShop, then click on "create new Production run":
                https://localhost:8443/manufacturing/control/CreateProductionRun
        2) enter as productId "PROD_MANUF", quantity 1, start date tomorrow and press the submit button
    `    3) in the next screen, click on the "Confirm" link (top part of the sccreen)

        Now you have a confirmed production run (starting tomorrow) happening in facility "WebStoreWarehouse",
        with a task happening in fixed asset "WORKCENTER_COST"

        In the calendars screen, selecting the proper facility you should see the work effort associated to the production run;
        if you select the proper fixed asset you should see the task.

         */
    Delegator delegator = ctx.getDelegator();
    Security security = ctx.getSecurity();
    GenericValue userLogin = (GenericValue) context.get("userLogin");
    Locale locale = (Locale) context.get("locale");
    TimeZone timeZone = (TimeZone) context.get("timeZone");
    Timestamp startDay = (Timestamp) context.get("start");
    Integer numPeriodsInteger = (Integer) context.get("numPeriods");
    String calendarType = (String) context.get("calendarType");
    if (UtilValidate.isEmpty(calendarType)) {
        // This is a bad idea. This causes the service to return only those work efforts that are assigned
        // to the current user even when the service parameters have nothing to do with the current user.
        calendarType = "CAL_PERSONAL";
    }
    String partyId = (String) context.get("partyId");
    Collection<String> partyIds = UtilGenerics.checkCollection(context.get("partyIds"));
    String facilityId = (String) context.get("facilityId");
    String fixedAssetId = (String) context.get("fixedAssetId");
    String workEffortTypeId = (String) context.get("workEffortTypeId");
    Boolean filterOutCanceledEvents = (Boolean) context.get("filterOutCanceledEvents");
    if (filterOutCanceledEvents == null) {
        filterOutCanceledEvents = Boolean.FALSE;
    }
    // To be returned, the max concurrent entries for a single period
    int maxConcurrentEntries = 0;
    Integer periodTypeObject = (Integer) context.get("periodType");
    int periodType = 0;
    if (periodTypeObject != null) {
        periodType = periodTypeObject.intValue();
    }
    int numPeriods = 0;
    if (numPeriodsInteger != null) {
        numPeriods = numPeriodsInteger.intValue();
    }
    // get a timestamp (date) for the beginning of today and for beginning of numDays+1 days from now
    // Commenting this out because it interferes with periods that do not start at the beginning of the day
    Timestamp startStamp = startDay;
    Timestamp endStamp = UtilDateTime.adjustTimestamp(startStamp, periodType, 1, timeZone, locale);
    long periodLen = endStamp.getTime() - startStamp.getTime();
    endStamp = UtilDateTime.adjustTimestamp(startStamp, periodType, numPeriods, timeZone, locale);
    // Get the WorkEfforts
    List<GenericValue> validWorkEfforts = null;
    Collection<String> partyIdsToUse = partyIds;
    if (partyIdsToUse == null) {
        partyIdsToUse = new HashSet<>();
    }
    if (UtilValidate.isNotEmpty(partyId)) {
        if (partyId.equals(userLogin.getString("partyId")) || security.hasEntityPermission("WORKEFFORTMGR", "_VIEW", userLogin)) {
            partyIdsToUse.add(partyId);
        } else {
            return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, "WorkEffortPartyPermissionError", UtilMisc.toMap("partyId", partyId), locale));
        }
    } else {
        if ("CAL_PERSONAL".equals(calendarType) && UtilValidate.isNotEmpty(userLogin.getString("partyId"))) {
            partyIdsToUse.add(userLogin.getString("partyId"));
        }
    }
    // cancelled status id's
    List<EntityCondition> cancelledCheckAndList = UtilMisc.<EntityCondition>toList(EntityCondition.makeCondition("currentStatusId", EntityOperator.NOT_EQUAL, "EVENT_CANCELLED"), EntityCondition.makeCondition("currentStatusId", EntityOperator.NOT_EQUAL, "CAL_CANCELLED"), EntityCondition.makeCondition("currentStatusId", EntityOperator.NOT_EQUAL, "PRUN_CANCELLED"));
    List<EntityCondition> entityExprList = UtilGenerics.checkList(context.get("entityExprList"));
    if (entityExprList == null) {
        entityExprList = getDefaultWorkEffortExprList(calendarType, partyIdsToUse, workEffortTypeId, cancelledCheckAndList);
    }
    if (UtilValidate.isNotEmpty(facilityId)) {
        entityExprList.add(EntityCondition.makeCondition("facilityId", EntityOperator.EQUALS, facilityId));
    }
    if (UtilValidate.isNotEmpty(fixedAssetId)) {
        entityExprList.add(EntityCondition.makeCondition("fixedAssetId", EntityOperator.EQUALS, fixedAssetId));
    }
    // should have at least a start date
    EntityCondition startDateRequired = EntityCondition.makeCondition(UtilMisc.<EntityCondition>toList(EntityCondition.makeCondition("estimatedStartDate", EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition("actualStartDate", EntityOperator.NOT_EQUAL, null)), EntityJoinOperator.OR);
    List<EntityCondition> periodCheckAndlList = UtilMisc.<EntityCondition>toList(startDateRequired, // the startdate should be less than the period end
    EntityCondition.makeCondition(UtilMisc.<EntityCondition>toList(EntityCondition.makeCondition(UtilMisc.<EntityCondition>toList(EntityCondition.makeCondition("actualStartDate", EntityOperator.EQUALS, null), EntityCondition.makeCondition("estimatedStartDate", EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition("estimatedStartDate", EntityOperator.LESS_THAN_EQUAL_TO, endStamp)), EntityJoinOperator.AND), EntityCondition.makeCondition(UtilMisc.<EntityCondition>toList(EntityCondition.makeCondition("actualStartDate", EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition("actualStartDate", EntityOperator.LESS_THAN_EQUAL_TO, endStamp)), EntityJoinOperator.AND)), EntityJoinOperator.OR), // if the completion date is not null then it should be larger than the period start
    EntityCondition.makeCondition(UtilMisc.<EntityCondition>toList(// can also be empty
    EntityCondition.makeCondition(UtilMisc.<EntityCondition>toList(EntityCondition.makeCondition("estimatedCompletionDate", EntityOperator.EQUALS, null), EntityCondition.makeCondition("actualCompletionDate", EntityOperator.EQUALS, null)), EntityJoinOperator.AND), // check estimated value if the actual is not provided
    EntityCondition.makeCondition(UtilMisc.<EntityCondition>toList(EntityCondition.makeCondition("actualCompletionDate", EntityOperator.EQUALS, null), EntityCondition.makeCondition("estimatedCompletionDate", EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition("estimatedCompletionDate", EntityOperator.GREATER_THAN_EQUAL_TO, startStamp)), EntityJoinOperator.AND), // at last check the actual value
    EntityCondition.makeCondition(UtilMisc.<EntityCondition>toList(EntityCondition.makeCondition("actualCompletionDate", EntityOperator.NOT_EQUAL, null), EntityCondition.makeCondition("actualCompletionDate", EntityOperator.GREATER_THAN_EQUAL_TO, startStamp)), EntityJoinOperator.AND)), EntityJoinOperator.OR));
    entityExprList.addAll(periodCheckAndlList);
    try {
        List<GenericValue> tempWorkEfforts = null;
        if (UtilValidate.isNotEmpty(partyIdsToUse)) {
            tempWorkEfforts = EntityQuery.use(delegator).from("WorkEffortAndPartyAssignAndType").where(entityExprList).orderBy("estimatedStartDate").filterByDate().queryList();
        } else {
            tempWorkEfforts = EntityQuery.use(delegator).from("WorkEffort").where(entityExprList).orderBy("estimatedStartDate").queryList();
        }
        if (!"CAL_PERSONAL".equals(calendarType) && UtilValidate.isNotEmpty(fixedAssetId)) {
            // Get "new style" work efforts
            tempWorkEfforts.addAll(EntityQuery.use(delegator).from("WorkEffortAndFixedAssetAssign").where(entityExprList).orderBy("estimatedStartDate").filterByDate().queryList());
        }
        validWorkEfforts = WorkEffortWorker.removeDuplicateWorkEfforts(tempWorkEfforts);
    } catch (GenericEntityException e) {
        Debug.logWarning(e, module);
    }
    // Split the WorkEffort list into a map with entries for each period, period start is the key
    List<Map<String, Object>> periods = new LinkedList<>();
    if (validWorkEfforts != null) {
        List<DateRange> periodRanges = new LinkedList<>();
        for (int i = 0; i < numPeriods; i++) {
            Timestamp curPeriodStart = UtilDateTime.adjustTimestamp(startStamp, periodType, i, timeZone, locale);
            Timestamp curPeriodEnd = UtilDateTime.adjustTimestamp(curPeriodStart, periodType, 1, timeZone, locale);
            curPeriodEnd = new Timestamp(curPeriodEnd.getTime() - 1);
            periodRanges.add(new DateRange(curPeriodStart, curPeriodEnd));
        }
        try {
            // Process recurring work efforts
            Set<GenericValue> exclusions = new HashSet<>();
            Set<GenericValue> inclusions = new HashSet<>();
            DateRange range = new DateRange(startStamp, endStamp);
            Calendar cal = UtilDateTime.toCalendar(startStamp, timeZone, locale);
            for (GenericValue workEffort : validWorkEfforts) {
                if (UtilValidate.isNotEmpty(workEffort.getString("tempExprId"))) {
                    // check if either the workeffort is public or the requested party is a member
                    if (UtilValidate.isNotEmpty(partyIdsToUse) && !"WES_PUBLIC".equals(workEffort.getString("scopeEnumId")) && !partyIdsToUse.contains(workEffort.getString("partyId"))) {
                        continue;
                    }
                    // if the workeffort has actual date time, using temporal expression has no sense
                    if (UtilValidate.isNotEmpty(workEffort.getTimestamp("actualStartDate")) || UtilValidate.isNotEmpty(workEffort.getTimestamp("actualCompletionDate"))) {
                        continue;
                    }
                    TemporalExpression tempExpr = TemporalExpressionWorker.getTemporalExpression(delegator, workEffort.getString("tempExprId"));
                    DateRange weRange = new DateRange(workEffort.getTimestamp("estimatedStartDate"), workEffort.getTimestamp("estimatedCompletionDate"));
                    Set<Date> occurrences = tempExpr.getRange(range, cal);
                    for (Date occurrence : occurrences) {
                        for (DateRange periodRange : periodRanges) {
                            if (periodRange.includesDate(occurrence)) {
                                GenericValue cloneWorkEffort = (GenericValue) workEffort.clone();
                                TimeDuration duration = TimeDuration.fromNumber(workEffort.getDouble("estimatedMilliSeconds"));
                                if (!duration.isZero()) {
                                    Calendar endCal = UtilDateTime.toCalendar(occurrence, timeZone, locale);
                                    Date endDate = duration.addToCalendar(endCal).getTime();
                                    cloneWorkEffort.set("estimatedStartDate", new Timestamp(occurrence.getTime()));
                                    cloneWorkEffort.set("estimatedCompletionDate", new Timestamp(endDate.getTime()));
                                } else {
                                    cloneWorkEffort.set("estimatedStartDate", periodRange.startStamp());
                                    cloneWorkEffort.set("estimatedCompletionDate", periodRange.endStamp());
                                }
                                if (weRange.includes(cloneWorkEffort.getTimestamp("estimatedStartDate"))) {
                                    inclusions.add(cloneWorkEffort);
                                }
                            }
                        }
                    }
                    exclusions.add(workEffort);
                }
            }
            validWorkEfforts.removeAll(exclusions);
            validWorkEfforts.addAll(inclusions);
        } catch (GenericEntityException e) {
            Debug.logWarning(e, module);
        }
        // For each period in the set we check all work efforts to see if they fall within range
        boolean firstEntry = true;
        for (DateRange periodRange : periodRanges) {
            List<Map<String, Object>> curWorkEfforts = new LinkedList<>();
            Map<String, Object> entry = new HashMap<>();
            for (GenericValue workEffort : validWorkEfforts) {
                Timestamp startDate = workEffort.getTimestamp("estimatedStartDate");
                if (workEffort.getTimestamp("actualStartDate") != null) {
                    startDate = workEffort.getTimestamp("actualStartDate");
                }
                Timestamp endDate = workEffort.getTimestamp("estimatedCompletionDate");
                if (workEffort.getTimestamp("actualCompletionDate") != null) {
                    endDate = workEffort.getTimestamp("actualCompletionDate");
                }
                if (endDate == null) {
                    endDate = startDate;
                }
                DateRange weRange = new DateRange(startDate, endDate);
                if (periodRange.intersectsRange(weRange)) {
                    Map<String, Object> calEntry = new HashMap<>();
                    calEntry.put("workEffort", workEffort);
                    long length = ((weRange.end().after(endStamp) ? endStamp.getTime() : weRange.end().getTime()) - (weRange.start().before(startStamp) ? startStamp.getTime() : weRange.start().getTime()));
                    int periodSpan = (int) Math.ceil((double) length / periodLen);
                    if (length % periodLen == 0 && startDate.getTime() > periodRange.start().getTime()) {
                        periodSpan++;
                    }
                    calEntry.put("periodSpan", Integer.valueOf(periodSpan));
                    DateRange calEntryRange = new DateRange((weRange.start().before(startStamp) ? startStamp : weRange.start()), (weRange.end().after(endStamp) ? endStamp : weRange.end()));
                    calEntry.put("calEntryRange", calEntryRange);
                    if (firstEntry) {
                        // If this is the first period any valid entry is starting here
                        calEntry.put("startOfPeriod", Boolean.TRUE);
                        firstEntry = false;
                    } else {
                        boolean startOfPeriod = ((weRange.start().getTime() - periodRange.start().getTime()) >= 0);
                        calEntry.put("startOfPeriod", Boolean.valueOf(startOfPeriod));
                    }
                    curWorkEfforts.add(calEntry);
                }
            }
            int numEntries = curWorkEfforts.size();
            if (numEntries > maxConcurrentEntries) {
                maxConcurrentEntries = numEntries;
            }
            entry.put("start", periodRange.startStamp());
            entry.put("end", periodRange.endStamp());
            entry.put("calendarEntries", curWorkEfforts);
            entry.put("calendarEntriesByDateRange", groupCalendarEntriesByDateRange(periodRange, curWorkEfforts));
            periods.add(entry);
        }
    }
    Map<String, Object> result = new HashMap<>();
    result.put("periods", periods);
    result.put("maxConcurrentEntries", Integer.valueOf(maxConcurrentEntries));
    return result;
}

Example 82 with Delegator

use of org.apache.ofbiz.entity.Delegator in project ofbiz-framework by apache.

the class WorkEffortServices method getWorkEffort.

public static Map<String, Object> getWorkEffort(DispatchContext ctx, Map<String, ? extends Object> context) {
    Delegator delegator = ctx.getDelegator();
    GenericValue userLogin = (GenericValue) context.get("userLogin");
    Security security = ctx.getSecurity();
    Map<String, Object> resultMap = new HashMap<>();
    String workEffortId = (String) context.get("workEffortId");
    GenericValue workEffort = null;
    try {
        workEffort = EntityQuery.use(delegator).from("WorkEffort").where("workEffortId", workEffortId).queryOne();
    } catch (GenericEntityException e) {
        Debug.logWarning(e, module);
    }
    Boolean canView = null;
    List<GenericValue> workEffortPartyAssignments = null;
    Boolean tryEntity = null;
    GenericValue currentStatus = null;
    if (workEffort == null) {
        tryEntity = Boolean.FALSE;
        canView = Boolean.TRUE;
        String statusId = (String) context.get("currentStatusId");
        if (UtilValidate.isNotEmpty(statusId)) {
            try {
                currentStatus = EntityQuery.use(delegator).from("StatusItem").where("statusId", statusId).cache().queryOne();
            } catch (GenericEntityException e) {
                Debug.logWarning(e, module);
            }
        }
    } else {
        // get a list of workEffortPartyAssignments, if empty then this user CANNOT view the event, unless they have permission to view all
        if (userLogin != null && userLogin.get("partyId") != null && workEffortId != null) {
            try {
                workEffortPartyAssignments = EntityQuery.use(delegator).from("WorkEffortPartyAssignment").where("workEffortId", workEffortId, "partyId", userLogin.get("partyId")).queryList();
            } catch (GenericEntityException e) {
                Debug.logWarning(e, module);
            }
        }
        canView = (UtilValidate.isNotEmpty(workEffortPartyAssignments)) ? Boolean.TRUE : Boolean.FALSE;
        if (!canView.booleanValue() && security.hasEntityPermission("WORKEFFORTMGR", "_VIEW", userLogin)) {
            canView = Boolean.TRUE;
        }
        tryEntity = Boolean.TRUE;
        if (workEffort.get("currentStatusId") != null) {
            try {
                currentStatus = EntityQuery.use(delegator).from("StatusItem").where("statusId", workEffort.get("currentStatusId")).cache().queryOne();
            } catch (GenericEntityException e) {
                Debug.logWarning(e, module);
            }
        }
    }
    if (workEffortId != null) {
        resultMap.put("workEffortId", workEffortId);
    }
    if (workEffort != null) {
        resultMap.put("workEffort", workEffort);
    }
    if (canView != null) {
        resultMap.put("canView", canView);
    }
    if (workEffortPartyAssignments != null) {
        resultMap.put("partyAssigns", workEffortPartyAssignments);
    }
    if (tryEntity != null) {
        resultMap.put("tryEntity", tryEntity);
    }
    if (currentStatus != null) {
        resultMap.put("currentStatusItem", currentStatus);
    }
    return resultMap;
}

Example 83 with Delegator

use of org.apache.ofbiz.entity.Delegator in project ofbiz-framework by apache.

the class WorkEffortServices method getProductManufacturingSummaryByFacility.

public static Map<String, Object> getProductManufacturingSummaryByFacility(DispatchContext ctx, Map<String, ? extends Object> context) {
    Delegator delegator = ctx.getDelegator();
    String productId = (String) context.get("productId");
    // optional
    String facilityId = (String) context.get("facilityId");
    Locale locale = (Locale) context.get("locale");
    Map<String, Map<String, Object>> summaryInByFacility = new HashMap<>();
    Map<String, Map<String, Object>> summaryOutByFacility = new HashMap<>();
    try {
        // 
        // Information about the running production runs that are going
        // to produce units of productId by facility.
        // 
        List<EntityCondition> findIncomingProductionRunsConds = new LinkedList<>();
        findIncomingProductionRunsConds.add(EntityCondition.makeCondition("productId", EntityOperator.EQUALS, productId));
        findIncomingProductionRunsConds.add(EntityCondition.makeCondition("statusId", EntityOperator.EQUALS, "WEGS_CREATED"));
        findIncomingProductionRunsConds.add(EntityCondition.makeCondition("workEffortGoodStdTypeId", EntityOperator.EQUALS, "PRUN_PROD_DELIV"));
        if (facilityId != null) {
            findIncomingProductionRunsConds.add(EntityCondition.makeCondition("facilityId", EntityOperator.EQUALS, facilityId));
        }
        List<EntityCondition> findIncomingProductionRunsStatusConds = new LinkedList<>();
        findIncomingProductionRunsStatusConds.add(EntityCondition.makeCondition("currentStatusId", EntityOperator.EQUALS, "PRUN_CREATED"));
        findIncomingProductionRunsStatusConds.add(EntityCondition.makeCondition("currentStatusId", EntityOperator.EQUALS, "PRUN_SCHEDULED"));
        findIncomingProductionRunsStatusConds.add(EntityCondition.makeCondition("currentStatusId", EntityOperator.EQUALS, "PRUN_DOC_PRINTED"));
        findIncomingProductionRunsStatusConds.add(EntityCondition.makeCondition("currentStatusId", EntityOperator.EQUALS, "PRUN_RUNNING"));
        findIncomingProductionRunsConds.add(EntityCondition.makeCondition(findIncomingProductionRunsStatusConds, EntityOperator.OR));
        List<GenericValue> incomingProductionRuns = EntityQuery.use(delegator).from("WorkEffortAndGoods").where(findIncomingProductionRunsConds).orderBy("-estimatedCompletionDate").queryList();
        for (GenericValue incomingProductionRun : incomingProductionRuns) {
            double producedQtyTot = 0.0;
            if ("PRUN_COMPLETED".equals(incomingProductionRun.getString("currentStatusId"))) {
                List<GenericValue> inventoryItems = EntityQuery.use(delegator).from("WorkEffortAndInventoryProduced").where("productId", productId, "workEffortId", incomingProductionRun.getString("workEffortId")).queryList();
                for (GenericValue inventoryItem : inventoryItems) {
                    GenericValue inventoryItemDetail = EntityQuery.use(delegator).from("InventoryItemDetail").where("inventoryItemId", inventoryItem.getString("inventoryItemId")).orderBy("inventoryItemDetailSeqId").queryFirst();
                    if (inventoryItemDetail != null && inventoryItemDetail.get("quantityOnHandDiff") != null) {
                        Double inventoryItemQty = inventoryItemDetail.getDouble("quantityOnHandDiff");
                        producedQtyTot = producedQtyTot + inventoryItemQty.doubleValue();
                    }
                }
            }
            double estimatedQuantity = 0.0;
            if (incomingProductionRun.get("estimatedQuantity") != null) {
                estimatedQuantity = incomingProductionRun.getDouble("estimatedQuantity").doubleValue();
            }
            // the qty that still needs to be produced
            double remainingQuantity = estimatedQuantity - producedQtyTot;
            if (remainingQuantity > 0) {
                incomingProductionRun.set("estimatedQuantity", Double.valueOf(remainingQuantity));
            } else {
                continue;
            }
            String weFacilityId = incomingProductionRun.getString("facilityId");
            Map<String, Object> quantitySummary = UtilGenerics.checkMap(summaryInByFacility.get(weFacilityId));
            if (quantitySummary == null) {
                quantitySummary = new HashMap<>();
                quantitySummary.put("facilityId", weFacilityId);
                summaryInByFacility.put(weFacilityId, quantitySummary);
            }
            Double remainingQuantityTot = (Double) quantitySummary.get("estimatedQuantityTotal");
            if (remainingQuantityTot == null) {
                quantitySummary.put("estimatedQuantityTotal", Double.valueOf(remainingQuantity));
            } else {
                quantitySummary.put("estimatedQuantityTotal", Double.valueOf(remainingQuantity + remainingQuantityTot.doubleValue()));
            }
            List<GenericValue> incomingProductionRunList = UtilGenerics.checkList(quantitySummary.get("incomingProductionRunList"));
            if (incomingProductionRunList == null) {
                incomingProductionRunList = new LinkedList<>();
                quantitySummary.put("incomingProductionRunList", incomingProductionRunList);
            }
            incomingProductionRunList.add(incomingProductionRun);
        }
        // 
        // Information about the running production runs that are going
        // to consume units of productId by facility.
        // 
        List<EntityCondition> findOutgoingProductionRunsConds = new LinkedList<>();
        findOutgoingProductionRunsConds.add(EntityCondition.makeCondition("productId", EntityOperator.EQUALS, productId));
        findOutgoingProductionRunsConds.add(EntityCondition.makeCondition("statusId", EntityOperator.EQUALS, "WEGS_CREATED"));
        findOutgoingProductionRunsConds.add(EntityCondition.makeCondition("workEffortGoodStdTypeId", EntityOperator.EQUALS, "PRUNT_PROD_NEEDED"));
        if (facilityId != null) {
            findOutgoingProductionRunsConds.add(EntityCondition.makeCondition("facilityId", EntityOperator.EQUALS, facilityId));
        }
        List<EntityCondition> findOutgoingProductionRunsStatusConds = new LinkedList<>();
        findOutgoingProductionRunsStatusConds.add(EntityCondition.makeCondition("currentStatusId", EntityOperator.EQUALS, "PRUN_CREATED"));
        findOutgoingProductionRunsStatusConds.add(EntityCondition.makeCondition("currentStatusId", EntityOperator.EQUALS, "PRUN_SCHEDULED"));
        findOutgoingProductionRunsStatusConds.add(EntityCondition.makeCondition("currentStatusId", EntityOperator.EQUALS, "PRUN_DOC_PRINTED"));
        findOutgoingProductionRunsStatusConds.add(EntityCondition.makeCondition("currentStatusId", EntityOperator.EQUALS, "PRUN_RUNNING"));
        findOutgoingProductionRunsConds.add(EntityCondition.makeCondition(findOutgoingProductionRunsStatusConds, EntityOperator.OR));
        List<GenericValue> outgoingProductionRuns = EntityQuery.use(delegator).from("WorkEffortAndGoods").where(findOutgoingProductionRunsConds).orderBy("-estimatedStartDate").queryList();
        for (GenericValue outgoingProductionRun : outgoingProductionRuns) {
            String weFacilityId = outgoingProductionRun.getString("facilityId");
            Double neededQuantity = outgoingProductionRun.getDouble("estimatedQuantity");
            if (neededQuantity == null) {
                neededQuantity = Double.valueOf(0);
            }
            Map<String, Object> quantitySummary = UtilGenerics.checkMap(summaryOutByFacility.get(weFacilityId));
            if (quantitySummary == null) {
                quantitySummary = new HashMap<>();
                quantitySummary.put("facilityId", weFacilityId);
                summaryOutByFacility.put(weFacilityId, quantitySummary);
            }
            Double remainingQuantityTot = (Double) quantitySummary.get("estimatedQuantityTotal");
            if (remainingQuantityTot == null) {
                quantitySummary.put("estimatedQuantityTotal", neededQuantity);
            } else {
                quantitySummary.put("estimatedQuantityTotal", Double.valueOf(neededQuantity.doubleValue() + remainingQuantityTot.doubleValue()));
            }
            List<GenericValue> outgoingProductionRunList = UtilGenerics.checkList(quantitySummary.get("outgoingProductionRunList"));
            if (outgoingProductionRunList == null) {
                outgoingProductionRunList = new LinkedList<>();
                quantitySummary.put("outgoingProductionRunList", outgoingProductionRunList);
            }
            outgoingProductionRunList.add(outgoingProductionRun);
        }
    } catch (GenericEntityException gee) {
        return ServiceUtil.returnError(UtilProperties.getMessage(resourceError, "WorkEffortManufacturingError", UtilMisc.toMap("productId", productId, "errorString", gee.getMessage()), locale));
    }
    Map<String, Object> resultMap = ServiceUtil.returnSuccess();
    resultMap.put("summaryInByFacility", summaryInByFacility);
    resultMap.put("summaryOutByFacility", summaryOutByFacility);
    return resultMap;
}

Example 84 with Delegator

use of org.apache.ofbiz.entity.Delegator in project ofbiz-framework by apache.

the class MacroFormRenderer method renderFieldTitle.

public void renderFieldTitle(Appendable writer, Map<String, Object> context, ModelFormField modelFormField) throws IOException {
    String titleText = modelFormField.getTitle(context);
    String style = modelFormField.getTitleStyle();
    String id = modelFormField.getCurrentContainerId(context);
    StringBuilder sb = new StringBuilder();
    if (UtilValidate.isNotEmpty(titleText)) {
        if (" ".equals(titleText)) {
            executeMacro(writer, "<@renderFormatEmptySpace />");
        } else {
            titleText = UtilHttp.encodeAmpersands(titleText);
            titleText = encode(titleText, modelFormField, context);
            if (UtilValidate.isNotEmpty(modelFormField.getHeaderLink())) {
                StringBuilder targetBuffer = new StringBuilder();
                FlexibleStringExpander target = FlexibleStringExpander.getInstance(modelFormField.getHeaderLink());
                String fullTarget = target.expandString(context);
                targetBuffer.append(fullTarget);
                String targetType = CommonWidgetModels.Link.DEFAULT_URL_MODE;
                if (UtilValidate.isNotEmpty(targetBuffer.toString()) && targetBuffer.toString().toLowerCase(Locale.getDefault()).startsWith("javascript:")) {
                    targetType = "plain";
                }
                StringWriter sr = new StringWriter();
                makeHyperlinkString(sr, modelFormField.getHeaderLinkStyle(), targetType, targetBuffer.toString(), null, titleText, "", modelFormField, this.request, this.response, context, "");
                String title = sr.toString().replace("\"", "\'");
                sr = new StringWriter();
                sr.append("<@renderHyperlinkTitle ");
                sr.append(" name=\"");
                sr.append(modelFormField.getModelForm().getName());
                sr.append("\" title=\"");
                sr.append(encodeDoubleQuotes(title));
                sr.append("\" />");
                executeMacro(writer, sr.toString());
            } else if (modelFormField.isSortField()) {
                renderSortField(writer, context, modelFormField, titleText);
            } else if (modelFormField.isRowSubmit()) {
                StringWriter sr = new StringWriter();
                sr.append("<@renderHyperlinkTitle ");
                sr.append(" name=\"");
                sr.append(modelFormField.getModelForm().getName());
                sr.append("\" title=\"");
                sr.append(titleText);
                sr.append("\" showSelectAll=\"Y\"/>");
                executeMacro(writer, sr.toString());
            } else {
                sb.append(titleText);
            }
        }
    }
    if (!sb.toString().isEmpty()) {
        // check for required field style on single forms
        if ("single".equals(modelFormField.getModelForm().getType()) && modelFormField.getRequiredField()) {
            String requiredStyle = modelFormField.getRequiredFieldStyle();
            if (UtilValidate.isNotEmpty(requiredStyle)) {
                style = requiredStyle;
            }
        }
        StringWriter sr = new StringWriter();
        sr.append("<@renderFieldTitle ");
        sr.append(" style=\"");
        sr.append(style);
        String displayHelpText = UtilProperties.getPropertyValue("widget", "widget.form.displayhelpText");
        if ("Y".equals(displayHelpText)) {
            Delegator delegator = WidgetWorker.getDelegator(context);
            Locale locale = (Locale) context.get("locale");
            String entityName = modelFormField.getEntityName();
            String fieldName = modelFormField.getFieldName();
            String helpText = UtilHelpText.getEntityFieldDescription(entityName, fieldName, delegator, locale);
            sr.append("\" fieldHelpText=\"");
            sr.append(encodeDoubleQuotes(helpText));
        }
        sr.append("\" title=\"");
        sr.append(sb.toString());
        if (UtilValidate.isNotEmpty(id)) {
            sr.append("\" id=\"");
            sr.append(id);
            sr.append("_title");
            // Render "for"
            sr.append("\" for=\"");
            sr.append(id);
        }
        sr.append("\" />");
        executeMacro(writer, sr.toString());
    }
}

Example 85 with Delegator

use of org.apache.ofbiz.entity.Delegator in project ofbiz-framework by apache.

the class MacroScreenRenderer method renderContentBody.

public void renderContentBody(Appendable writer, Map<String, Object> context, ModelScreenWidget.Content content) throws IOException {
    Locale locale = UtilMisc.ensureLocale(context.get("locale"));
    String mimeTypeId = "text/html";
    String expandedContentId = content.getContentId(context);
    String expandedDataResourceId = content.getDataResourceId(context);
    String renderedContent = null;
    LocalDispatcher dispatcher = (LocalDispatcher) context.get("dispatcher");
    Delegator delegator = (Delegator) context.get("delegator");
    // make a new map for content rendering; so our current map does not get clobbered
    Map<String, Object> contentContext = new HashMap<>();
    contentContext.putAll(context);
    String dataResourceId = (String) contentContext.get("dataResourceId");
    if (Debug.verboseOn()) {
        Debug.logVerbose("expandedContentId:" + expandedContentId, module);
    }
    try {
        if (UtilValidate.isNotEmpty(dataResourceId)) {
            if (WidgetDataResourceWorker.getDataresourceWorker() != null) {
                renderedContent = WidgetDataResourceWorker.getDataresourceWorker().renderDataResourceAsTextExt(delegator, dataResourceId, contentContext, locale, mimeTypeId, false);
            } else {
                Debug.logError("Not rendering content, WidgetDataResourceWorker.dataresourceWorker not found.", module);
            }
        } else if (UtilValidate.isNotEmpty(expandedContentId)) {
            if (WidgetContentWorker.getContentWorker() != null) {
                renderedContent = WidgetContentWorker.getContentWorker().renderContentAsTextExt(dispatcher, expandedContentId, contentContext, locale, mimeTypeId, true);
            } else {
                Debug.logError("Not rendering content, WidgetContentWorker.contentWorker not found.", module);
            }
        } else if (UtilValidate.isNotEmpty(expandedDataResourceId)) {
            if (WidgetDataResourceWorker.getDataresourceWorker() != null) {
                renderedContent = WidgetDataResourceWorker.getDataresourceWorker().renderDataResourceAsTextExt(delegator, expandedDataResourceId, contentContext, locale, mimeTypeId, false);
            } else {
                Debug.logError("Not rendering content, WidgetDataResourceWorker.dataresourceWorker not found.", module);
            }
        }
        if (UtilValidate.isEmpty(renderedContent)) {
            String editRequest = content.getEditRequest(context);
            if (UtilValidate.isNotEmpty(editRequest)) {
                if (WidgetContentWorker.getContentWorker() != null) {
                    WidgetContentWorker.getContentWorker().renderContentAsTextExt(dispatcher, "NOCONTENTFOUND", writer, contentContext, locale, mimeTypeId, true);
                } else {
                    Debug.logError("Not rendering content, WidgetContentWorker.contentWorker not found.", module);
                }
            }
        } else {
            if (content.xmlEscape()) {
                renderedContent = UtilFormatOut.encodeXmlValue(renderedContent);
            }
            writer.append(renderedContent);
        }
    } catch (GeneralException | IOException e) {
        String errMsg = "Error rendering included content with id [" + expandedContentId + "] : " + e.toString();
        Debug.logError(e, errMsg, module);
    }
}