* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

* http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing,

* software distributed under the License is distributed on an

* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

* KIND, either express or implied.  See the License for the

* specific language governing permissions and limitations

* under the License.

*******************************************************************************/

* Services for Production Run maintenance

*

*/

    public static final String module = ProductionRunServices.class.getName();

    public static final String resource = "ManufacturingUiLabels";

    private static BigDecimal ZERO = BigDecimal.ZERO;

    private static BigDecimal ONE = BigDecimal.ONE;

    private static int decimals = -1;

    private static int rounding = -1;

    static {

        decimals = UtilNumber.getBigDecimalScale("order.decimals");

        rounding = UtilNumber.getBigDecimalRoundingMode("order.rounding");

        // set zero to the proper scale

        ZERO = ZERO.setScale(decimals);

        ONE = ONE.setScale(decimals);

    }

    /**

     * Cancels a ProductionRun.

     * @param ctx The DispatchContext that this service is operating in.

     * @param context Map containing the input parameters.

     * @return Map with the result of the service, the output parameters.

     */

    public static Map cancelProductionRun(DispatchContext ctx, Map context) {

        Map result = new HashMap();

        Delegator delegator = ctx.getDelegator();

        LocalDispatcher dispatcher = ctx.getDispatcher();

        Locale locale = (Locale) context.get("locale");

        GenericValue userLogin = (GenericValue) context.get("userLogin");

        String productionRunId = (String) context.get("productionRunId");

        ProductionRun productionRun = new ProductionRun(productionRunId, delegator, dispatcher);

        if (!productionRun.exist()) {

            return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ManufacturingProductionRunNotExists", locale));

        }

        String currentStatusId = productionRun.getGenericValue().getString("currentStatusId");

        // PRUN_CREATED, PRUN_DOC_PRINTED --> PRUN_CANCELLED

        if (currentStatusId.equals("PRUN_CREATED") || currentStatusId.equals("PRUN_DOC_PRINTED") || currentStatusId.equals("PRUN_SCHEDULED")) {

            try {

                // First of all, make sure that there aren't production runs that depend on this one.

                List mandatoryWorkEfforts = new ArrayList();

                ProductionRunHelper.getLinkedProductionRuns(delegator, dispatcher, productionRunId, mandatoryWorkEfforts);

                for (int i = 1; i < mandatoryWorkEfforts.size(); i++) {

                    GenericValue mandatoryWorkEffort = ((ProductionRun)mandatoryWorkEfforts.get(i)).getGenericValue();

                    if (!(mandatoryWorkEffort.getString("currentStatusId").equals("PRUN_CANCELLED"))) {

                        return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ManufacturingProductionRunStatusNotChangedMandatoryProductionRunFound", locale));

                    }

                }

                Map serviceContext = new HashMap();

                // change the production run (header) status to PRUN_CANCELLED

                serviceContext.put("workEffortId", productionRunId);

                serviceContext.put("currentStatusId", "PRUN_CANCELLED");

                serviceContext.put("userLogin", userLogin);

                Map resultService = null;

                resultService = dispatcher.runSync("updateWorkEffort", serviceContext);

                // Cancel the product promised

                List products = delegator.findByAnd("WorkEffortGoodStandard", UtilMisc.toMap("workEffortId", productionRunId, "workEffortGoodStdTypeId", "PRUN_PROD_DELIV", "statusId", "WEGS_CREATED"));

                if (!UtilValidate.isEmpty(products)) {

                    Iterator productsIt = products.iterator();

                    while (productsIt.hasNext()) {

                        GenericValue product = (GenericValue)productsIt.next();

                        product.set("statusId", "WEGS_CANCELLED");

                        product.store();

                    }

                }

                // change the tasks status to PRUN_CANCELLED

                List tasks = productionRun.getProductionRunRoutingTasks();

                GenericValue oneTask = null;

                String taskId = null;

                for (int i = 0; i < tasks.size(); i++) {

                    oneTask = (GenericValue)tasks.get(i);

                    taskId = oneTask.getString("workEffortId");

                    serviceContext.clear();

                    serviceContext.put("workEffortId", taskId);

                    serviceContext.put("currentStatusId", "PRUN_CANCELLED");

                    serviceContext.put("userLogin", userLogin);

                    resultService = dispatcher.runSync("updateWorkEffort", serviceContext);

                    // cancel all the components

                    List components = delegator.findByAnd("WorkEffortGoodStandard", UtilMisc.toMap("workEffortId", taskId, "workEffortGoodStdTypeId", "PRUNT_PROD_NEEDED", "statusId", "WEGS_CREATED"));

                    if (!UtilValidate.isEmpty(components)) {

                        Iterator componentsIt = components.iterator();

                        while (componentsIt.hasNext()) {

                            GenericValue component = (GenericValue)componentsIt.next();

                            component.set("statusId", "WEGS_CANCELLED");

                            component.store();

                        }

                    }

                }

            } catch (Exception e) {

                Debug.logError(e, "Problem calling the updateWorkEffort service", module);

                return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ManufacturingProductionRunStatusNotChanged", locale));

            }

            result.put(ModelService.SUCCESS_MESSAGE, UtilProperties.getMessage(resource, "ManufacturingProductionRunStatusChanged",UtilMisc.toMap("newStatusId", "PRUN_DOC_PRINTED"), locale));

            return result;

        }

        return ServiceUtil.returnError("Cannot cancel productionRun, not in a valid status");

    }

    /**

     * Creates a Production Run.

     *  <li> check if routing - product link exist

     *  <li> check if product have a Bill Of Material

     *  <li> check if routing have routingTask

     *  <li> create the workEffort for ProductionRun

     *  <li> create the WorkEffortGoodStandard for link between ProductionRun and the product it will produce

     *  <li> for each valid routingTask of the routing create a workeffort-task

     *  <li> for the first routingTask, create for all the valid productIdTo with no associateRoutingTask  a WorkEffortGoodStandard

     *  <li> for each valid routingTask of the routing and valid productIdTo associate with this RoutingTask create a WorkEffortGoodStandard

     * @param ctx The DispatchContext that this service is operating in.

     * @param context Map containing the input parameters, productId, routingId, pRQuantity, startDate, workEffortName, description

     * @return Map with the result of the service, the output parameters.

     */

    public static Map createProductionRun(DispatchContext ctx, Map context) {

        Map result = new HashMap();

        Delegator delegator = ctx.getDelegator();

        LocalDispatcher dispatcher = ctx.getDispatcher();

        Locale locale = (Locale) context.get("locale");

        GenericValue userLogin = (GenericValue) context.get("userLogin");

        /* TODO: security management  and finishing cleaning (ex copy from PartyServices.java)

        if (!security.hasEntityPermission(secEntity, secOperation, userLogin)) {

            result.put(ModelService.RESPONSE_MESSAGE, ModelService.RESPOND_ERROR);

            result.put(ModelService.ERROR_MESSAGE, "You do not have permission to perform this operation for this party");

            return partyId;

        }

         */

        // Mandatory input fields

        String productId = (String) context.get("productId");

        Timestamp  startDate =  (Timestamp) context.get("startDate");

        BigDecimal pRQuantity = (BigDecimal) context.get("pRQuantity");

        String facilityId = (String) context.get("facilityId");

        // Optional input fields

        String workEffortId = (String) context.get("routingId");

        String workEffortName = (String) context.get("workEffortName");

        String description = (String) context.get("description");

        GenericValue routing = null;

        GenericValue product = null;

        List workEffortProducts = null;

        List productBoms = null;

        List routingTaskAssocs = null;

        try {

            // Find the product

            product = delegator.findByPrimaryKey("Product", UtilMisc.toMap("productId", productId));

            if (product == null) {

                return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ManufacturingProductNotExist", locale));

            }

        } catch (GenericEntityException e) {

            Debug.logWarning(e.getMessage(), module);

            return ServiceUtil.returnError(e.getMessage());

        }

        // -------------------

        // Routing and routing tasks

        // -------------------

        // Select the product's routing

        try {

            Map routingInMap = UtilMisc.toMap("productId", productId, "applicableDate", startDate, "userLogin", userLogin);

            if (workEffortId != null) {

                routingInMap.put("workEffortId", workEffortId);

            }

            Map routingOutMap = dispatcher.runSync("getProductRouting", routingInMap);

            routing = (GenericValue)routingOutMap.get("routing");

            routingTaskAssocs = (List)routingOutMap.get("tasks");

        } catch (GenericServiceException gse) {

            Debug.logWarning(gse.getMessage(), module);

        }

        if (routing == null) {

            return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ManufacturingProductRoutingNotExist", locale));

        }

        if (UtilValidate.isEmpty(routingTaskAssocs)) {

            return ServiceUtil.returnError(UtilProperties.getMessage(resource, "ManufacturingRoutingHasNoRoutingTask", locale));

        }

        // -------------------

        // Components

        // -------------------

        // The components are retrieved using the getManufacturingComponents service

        // (that performs a bom breakdown and if needed runs the configurator).

        List components = null;

        Map serviceContext = new HashMap();

        serviceContext.put("productId", productId); // the product that we want to manufacture

        serviceContext.put("quantity", pRQuantity); // the quantity that we want to manufacture

        serviceContext.put("userLogin", userLogin);

        Map resultService = null;

        try {

            resultService = dispatcher.runSync("getManufacturingComponents", serviceContext);

            components = (List)resultService.get("components"); // a list of objects representing the product's components

        } catch (GenericServiceException e) {

            Debug.logError(e, "Problem calling the getManufacturingComponents service", module);

            return ServiceUtil.returnError(e.getMessage());

        }

        // ProductionRun header creation,

        if (workEffortName == null) {

            String prdName = UtilValidate.isNotEmpty(product.getString("productName"))? product.getString("productName"): product.getString("productId");

            String wefName = UtilValidate.isNotEmpty(routing.getString("workEffortName"))? routing.getString("workEffortName"): routing.getString("workEffortId");

            workEffortName =  prdName + "-" + wefName;

        }

        serviceContext.clear();

        serviceContext.put("workEffortTypeId", "PROD_ORDER_HEADER");

        serviceContext.put("workEffortPurposeTypeId", "WEPT_PRODUCTION_RUN");

        serviceContext.put("currentStatusId", "PRUN_CREATED");

        serviceContext.put("workEffortName", workEffortName);

        serviceContext.put("description",description);

        serviceContext.put("facilityId", facilityId);

        serviceContext.put("estimatedStartDate",startDate);

        serviceContext.put("quantityToProduce", pRQuantity);

        serviceContext.put("userLogin", userLogin);

        try {

            resultService = dispatcher.runSync("createWorkEffort", serviceContext);

        } catch (GenericServiceException e) {

            Debug.logError(e, "Problem calling the createWorkEffort service", module);

            return ServiceUtil.returnError(e.getMessage());

        }

        String productionRunId = (String) resultService.get("workEffortId");

        if (Debug.infoOn()) {

            Debug.logInfo("ProductionRun created: " + productionRunId, module);

        }

        // ProductionRun,  product will be produce creation = WorkEffortGoodStandard for the productId

        serviceContext.clear();

        serviceContext.put("workEffortId", productionRunId);

        serviceContext.put("productId", productId);

        serviceContext.put("workEffortGoodStdTypeId", "PRUN_PROD_DELIV");

        serviceContext.put("statusId", "WEGS_CREATED");

        serviceContext.put("estimatedQuantity", pRQuantity);

        serviceContext.put("fromDate", startDate);

        serviceContext.put("userLogin", userLogin);

        try {

            resultService = dispatcher.runSync("createWorkEffortGoodStandard", serviceContext);

        } catch (GenericServiceException e) {

            Debug.logError(e, "Problem calling the createWorkEffortGoodStandard service", module);

            return ServiceUtil.returnError(e.getMessage());

        }

        // Multi creation (like clone) ProductionRunTask and GoodAssoc

        Iterator  rt = routingTaskAssocs.iterator();

        boolean first = true;

        while (rt.hasNext()) {

            GenericValue routingTaskAssoc = (GenericValue) rt.next();

            if (EntityUtil.isValueActive(routingTaskAssoc, startDate)) {

                GenericValue routingTask = null;

                try {

                    routingTask = routingTaskAssoc.getRelatedOne("ToWorkEffort");

                } catch (GenericEntityException e) {

                    Debug.logError(e.getMessage(),  module);

                }

                // Calculate the estimatedCompletionDate

                long totalTime = ProductionRun.getEstimatedTaskTime(routingTask, pRQuantity, dispatcher);

                Timestamp endDate = TechDataServices.addForward(TechDataServices.getTechDataCalendar(routingTask),startDate, totalTime);

                serviceContext.clear();

                serviceContext.put("priority", routingTaskAssoc.get("sequenceNum"));

                serviceContext.put("workEffortPurposeTypeId", routingTask.get("workEffortPurposeTypeId"));

                serviceContext.put("workEffortName",routingTask.get("workEffortName"));

                serviceContext.put("description",routingTask.get("description"));