#

Junjie

6 天以前 1ae2f3acafa9d036dfe4f14f8dcc5c4b5815c46a

 src/main/java/com/zy/asrs/utils/Utils.java

@@ -1,27 +1,19 @@
package com.zy.asrs.utils;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.core.common.Arith;
import com.core.common.Cools;
import com.zy.core.properties.SlaveProperties;
import com.core.common.SpringUtils;
import com.zy.common.utils.RedisUtil;
import com.zy.core.enums.RedisKeyType;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.HashMap;

/**
 * Created by vincent on 2020/8/27
 */
public class Utils {

    public static final List<Integer> FIRST_GROUP_ROW_LIST = new ArrayList<Integer>() {{
        add(2);add(3);add(4);add(5);add(6);add(7);add(8);add(9);add(10);
        add(11);add(12);add(13);add(14);add(15);add(16);add(17);
    }};
    public static final List<Integer> SECOND_GROUP_ROW_LIST = new ArrayList<Integer>() {{
        add(18);add(19);add(20);
        add(21);add(22);add(23);add(24);add(25);add(26);add(27);add(28);add(29);add(30);
    }};

    private static final String LOC_NO_FLAG = "-";
    private static final DecimalFormat fmt = new DecimalFormat("##0.00");

    public static float scale(Float f){
@@ -45,151 +37,13 @@
        }
    }

    public static Integer getGroupRow(String locNo, Boolean pakin){
        int row = getRow(locNo);
        return getGroupRow(row, pakin);
    }

    public static Integer getGroupRow(Integer row, Boolean pakin) {
        if (pakin) {
            if (FIRST_GROUP_ROW_LIST.contains(row)) {
                return 17;
            } else if (SECOND_GROUP_ROW_LIST.contains(row)) {
                return 18;
            } else {
                return 0;
            }
        } else {
            if (FIRST_GROUP_ROW_LIST.contains(row)) {
                return 2;
            } else if (SECOND_GROUP_ROW_LIST.contains(row)) {
                return 30;
            } else {
                return 0;
            }
        }
    }




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






    /**
     * 判断是否为深库位
     */
    public static boolean isDeepLoc(SlaveProperties slaveProperties, String locNo){
        if (slaveProperties.isDoubleDeep()) {
            int row = getRow(locNo);
            return slaveProperties.getDoubleLocs().contains(row);
        } else {
            return false;
        }
    }

    /**
     * 判断是否为深库位
     */
    public static boolean isDeepLoc(SlaveProperties slaveProperties, Integer row){
        if (slaveProperties.isDoubleDeep()) {
            return slaveProperties.getDoubleLocs().contains(row);
        } else {
            return false;
        }
    }

    /**
     * 判断是否为浅库位
     */
    public static boolean isShallowLoc(SlaveProperties slaveProperties, String locNo){
        if (slaveProperties.isDoubleDeep()) {
            int row = getRow(locNo);
            return !slaveProperties.getDoubleLocs().contains(row);
        } else {
            return false;
        }
    }

    /**
     * 判断是否为浅库位
     */
    public static boolean isShallowLoc(SlaveProperties slaveProperties, Integer row){
        if (slaveProperties.isDoubleDeep()) {
            return !slaveProperties.getDoubleLocs().contains(row);
        } else {
            return false;
        }
    }

    /**
     * 获取 深库位对应的浅库位号
     */
    public static String getShallowLoc(SlaveProperties slaveProperties, String deepLoc) {
        int row = getRow(deepLoc);
        int remainder = (int) Arith.remainder(row, slaveProperties.getGroupCount());
        int shallowRow = remainder == 1 ? (row + 1) : (row - 1);
        return zerofill(String.valueOf(shallowRow), 2) + deepLoc.substring(2);
    }

    public static void main(String[] args) {
        SlaveProperties slaveProperties = new SlaveProperties();
        slaveProperties.setDoubleDeep(true);
        slaveProperties.setGroupCount(2);
        System.out.println(getShallowLoc(slaveProperties, "3200101"));
    }

    /**
     * 获取 深库位排对应的浅库位排
     */
    public static Integer getShallowRow(SlaveProperties slaveProperties, Integer deepRow) {
        int remainder = (int) Arith.remainder(deepRow, slaveProperties.getGroupCount());
        return remainder == 1 ? (deepRow + 1) : (deepRow - 1);
    }

    /**
     * 获取 浅库位对应的深库位号
     */
    public static String getDeepLoc(SlaveProperties slaveProperties, String shallowLoc) {
        int row = getRow(shallowLoc);
        int remainder = (int) Arith.remainder(row, slaveProperties.getGroupCount());
        int targetRow;
        if (remainder == 2) {
            targetRow = row - 1;
        } else if (remainder == 1) {
            targetRow = row + 1;
        } else {
            throw new RuntimeException(shallowLoc + "不是浅库位，系统繁忙");
        }
        return zerofill(String.valueOf(targetRow), 2) + shallowLoc.substring(2);
    }

    /**
     * 获取 浅库位排对应的深库位排
     */
    public static Integer getDeepRow(SlaveProperties slaveProperties, Integer shallowRow) {
        int remainder = (int) Arith.remainder(shallowRow, slaveProperties.getGroupCount());
        int targetRow;
        if (remainder == 2) {
            targetRow = shallowRow - 1;
        } else if (remainder == 1) {
            targetRow = shallowRow + 1;
        } else {
            throw new RuntimeException(shallowRow + "不是浅库位排，系统繁忙");
        }
        return targetRow;
    }

    /**
     * 通过库位号获取 排
     */
    public static int getRow(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(0, 2));
            String[] split = locNo.split(LOC_NO_FLAG);
            return Integer.parseInt(split[0]);
        }
        throw new RuntimeException("库位解析异常");
    }
@@ -199,7 +53,8 @@
     */
    public static int getBay(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(2, 5));
            String[] split = locNo.split(LOC_NO_FLAG);
            return Integer.parseInt(split[1]);
        }
        throw new RuntimeException("库位解析异常");
    }
@@ -209,39 +64,52 @@
     */
    public static int getLev(String locNo) {
        if (!Cools.isEmpty(locNo)) {
            return Integer.parseInt(locNo.substring(5, 7));
            String[] split = locNo.split(LOC_NO_FLAG);
            return Integer.parseInt(split[2]);
        }
        throw new RuntimeException("库位解析异常");
    }

    /**
     * 通过排列层拼接出库位号
     */
    public static String append(int row, int bay, int lev) {
        return zerofill(String.valueOf(row), 2) + zerofill(String.valueOf(bay), 3) + zerofill(String.valueOf(lev), 2);
    }


    /**
     * 当检索到双深库位的浅库位时，如果深库位无货，则放入对应的深库位
     */
    public static void toDeepIfEmptyByShallow(String shallowLoc) {
        int row = getRow(shallowLoc);
        int remainder = (int) Arith.remainder(row, 4);
        int targetRow = 0;
        if (remainder == 2) {
            targetRow = row - 1;
        } else if (remainder == 3) {
            targetRow = row + 1;
        } else {
            throw new RuntimeException(shallowLoc + "不是浅库位，系统繁忙");
        }
        String targetLoc = zerofill(String.valueOf(targetRow), 2) + shallowLoc.substring(2);

    }

    public static String getLocNo(Number row, Number bay, Number lev) {
        return zerofill(String.valueOf(row), 2) + zerofill(String.valueOf(bay), 3) + zerofill(String.valueOf(lev), 2);
        return row + LOC_NO_FLAG + bay + LOC_NO_FLAG + lev;
    }

    public static boolean isJSON(String value) {
        try {
            JSONObject jsonData = JSON.parseObject(value);
            if (jsonData == null) {
                return false;
            }
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    //获取设备日志采集时间
    public static int getDeviceLogCollectTime() {
        int defaultTime = 200;
        try {
            RedisUtil redisUtil = SpringUtils.getBean(RedisUtil.class);
            if (redisUtil == null) {
                return defaultTime;
            }

            Object object = redisUtil.get(RedisKeyType.SYSTEM_CONFIG_MAP.key);
            if (object == null) {
                return defaultTime;
            }

            HashMap<String, String> systemConfigMap = (HashMap<String, String>) object;
            String deviceLogCollectTime = systemConfigMap.get("deviceLogCollectTime");
            if(deviceLogCollectTime == null){
                return defaultTime;
            }

            return Integer.parseInt(deviceLogCollectTime);
        }catch (Exception e){
            e.printStackTrace();
        }
        return defaultTime;
    }
}