EqptRecipeDiffBatchAction.java

package com.mycim.webapp.actions.diffbatch;

import com.fa.sesa.exception.Assert;
import com.fa.sesa.exception.Errors;
import com.fa.sesa.threadlocal.LocalContext;
import com.mycim.framework.context.spring.SpringContext;
import com.mycim.framework.jdbc.Page;
import com.mycim.framework.utils.MiscUtils;
import com.mycim.framework.utils.lang.StringUtils;
import com.mycim.framework.utils.lang.collections.MapUtils;
import com.mycim.server.ems.service.EmsService;
import com.mycim.server.wip.service.DiffBatchQueryService;
import com.mycim.server.wip.service.DiffBatchService;
import com.mycim.utils.CheckRegexUtils;
import com.mycim.valueobject.MessageIdList;
import com.mycim.valueobject.ObjectList;
import com.mycim.valueobject.wip.EqpRcpDiffBatchSetupInfo;
import com.mycim.webapp.WebUtils;
import com.mycim.webapp.actions.AbstractAction;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * @author finatice.yang
 * @version 6.0.0
 * @date 2021/6/29
 **/
public class EqptRecipeDiffBatchAction extends AbstractAction {

    protected DiffBatchQueryService diffBatchQueryService = SpringContext.getBean(DiffBatchQueryService.class);

    protected DiffBatchService diffBatchService = SpringContext.getBean(DiffBatchService.class);

    protected EmsService emsService = SpringContext.getBean(EmsService.class);

    @Override
    public ActionForward init(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                              HttpServletResponse response){
        return mapping.findForward("batchset");
    }

    public ActionForward eqptDiffHistory(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                                         HttpServletResponse response) {

        String eqptId = WebUtils.getParameterUpperCase("eqptId", request);
        long eqptRrn = getInstanceRrn(eqptId, getNamedSpace(ObjectList.ENTITY_KEY, LocalContext.getFacilityRrn()),
                                      ObjectList.ENTITY_KEY, ObjectList.EQUIPMENT_KEY);

        int thisPage = WebUtils.getThisPage(request);
        int pageSize = WebUtils.getPageSize(request);

        Page page = new Page(thisPage, pageSize);

        Map<String, Object> condition = MapUtils.newHashMap();
        condition.put("eqptId", eqptId);
        condition.put("eqptRrn", eqptRrn);

        page = diffBatchQueryService.getEqpRcpBatchSetupHistory(condition,page);

        request.setAttribute("eqptId", eqptId);
        request.setAttribute("transList", page.getResults());

        request.setAttribute(WebUtils.THIS_PAGE, thisPage);
        request.setAttribute(WebUtils.PAGE_SIZE, pageSize);
        request.setAttribute(WebUtils.MAX_PAGE, page.getTotalPages());
        if (page.isLastPage()) {
            request.setAttribute("isLastPage", "1");
        }
        if (page.isFirstPage()) {
            request.setAttribute("isFirstPage", "1");
        }
        return mapping.findForward("history");
    }

    public void modifyEqpRecipe(Map<String, Object> params) {
        String recipeId = MapUtils.getString(params, "recipeId");
        long recipeRrn = getInstanceRrn(recipeId, LocalContext.getFacilityRrn(), ObjectList.RECIPE_KEY);
        Assert.state(recipeRrn > 0,Errors.create().key(MessageIdList.RECIPE_INVALID_ID).build());

        String productId = MapUtils.getString(params, "productId");
        Assert.state(StringUtils.isNotBlank(productId),
                     Errors.create().key(MessageIdList.PRODUCT_EMPTY_ID).content("Product Id is empty!").build());
        long productRrn = getInstanceRrn(productId, LocalContext.getFacilityRrn(), ObjectList.PRODUCT_KEY);
        Assert.state(productRrn > 0, Errors.create().key(MessageIdList.PRODUCT_VALID_ID).build());

        Integer limit = MapUtils.getInteger(params, "limit");
        Assert.state(Objects.nonNull(limit) && limit.intValue() > 0,
                     Errors.create().key(MessageIdList.WAFER_QTY_UNREASONABLE)
                           .content("Wafer qty limits set unreasonable!").build());

        Long eqptRrn = MapUtils.getLong(params, "eqptRrn");

        EqpRcpDiffBatchSetupInfo batchSetupInfo = new EqpRcpDiffBatchSetupInfo();
        batchSetupInfo.setEqptId(getInstanceId(eqptRrn));
        batchSetupInfo.setEqptRrn(eqptRrn);
        batchSetupInfo.setRecipeId(recipeId);
        batchSetupInfo.setRecipeRrn(recipeRrn);
        batchSetupInfo.setMonitorLimit(MapUtils.getInteger(params, "limit"));
        batchSetupInfo.setMonitorProductId(productId);
        batchSetupInfo.setMonitorProductRrn(productRrn);
        batchSetupInfo.setEdcFlag(CheckRegexUtils.checkFlagOn(MapUtils.getString(params, "edcFlag")));

        diffBatchService.insertOrUpdateEqptRecipeDiffBatchSet(batchSetupInfo);
    }

    public ActionForward deleteEqpRecipe(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                                          HttpServletResponse response) {
        long recipeRrn = WebUtils.getParameterLong("recipeRrn", request);
        long eqptRrn = WebUtils.getParameterLong("eqptRrn", request);

        EqpRcpDiffBatchSetupInfo batchSetupInfo = new EqpRcpDiffBatchSetupInfo();
        batchSetupInfo.setEqptRrn(eqptRrn);
        batchSetupInfo.setRecipeRrn(recipeRrn);
        diffBatchService.deleteEqptRecipeDiffBatchSet(batchSetupInfo);

        return qryEqptSetList(mapping, form, request, response);
    }

    public ActionForward qryEqptSetList(ActionMapping mapping, ActionForm form, HttpServletRequest request,
                                        HttpServletResponse response) {

        String eqptId = WebUtils.getParameterUpperCase("eqptId", request);
        if (StringUtils.isNotBlank(eqptId)) {
            long eqptRrn = getInstanceRrn(eqptId, getNamedSpace(ObjectList.ENTITY_KEY, LocalContext.getFacilityRrn()),
                                          ObjectList.ENTITY_KEY, ObjectList.EQUIPMENT_KEY);
            Assert.isFalse(eqptRrn <= 0, Errors.create().key(MessageIdList.EQUIPMENT_ID_NOT_EXIST).build());

            Map eqptExt = emsService.getEquipmentExtMap(eqptRrn);
            String diffFlag = MapUtils.getString(eqptExt, "diffFlag");
            Assert.isTrue(CheckRegexUtils.checkFlagOn(diffFlag),
                           Errors.create().content("Eqp is not a diff eqp!").build());

            List<EqpRcpDiffBatchSetupInfo> recipeSet = diffBatchQueryService.getEqpRecipeDiffBatchSet(eqptRrn);
            request.setAttribute("recipeList", recipeSet);
            request.setAttribute("eqptDesc", getInstanceDesc(eqptRrn));
            request.setAttribute("eqptId", eqptId);
            request.setAttribute("eqptRrn", eqptRrn);
        }
        return mapping.findForward("batchset");
    }

}