设备增删改查以及关联与解绑终端

ebc-sea-platform/src/main/java/com/ai/ipu/server/controller/DeviceManageController.java

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
import java.util.Map;
/**
 * 终端管理
 */
    }
    /**
     * 关联用户
     * 关联用户的用户列表信息查询
     */
    @ResponseBody
    @RequestMapping("/associatUser")
    public JMap associatUser(JMap params) throws Exception {
        boolean flag=false;
        if(params.getInt("MAP_TAG_ID")!=0){
            //flag=  userManageService.associatTerminal(params);
        }
    @RequestMapping("/queryAssociatUserInfo")
    public JMap queryAssociatUserInfo(JMap params) throws Exception {
        List<Map<String, Object>> userList=  deviceManageService.queryAssociatUserInfo(params);
        JMap result = new JsonMap();
        result.put("result", flag);
        result.put("result", userList);
        return result;
    }
    /**
     * 关联用户的船舶列表信息查询
     */
    @ResponseBody
    @RequestMapping("/queryAssociatBoatInfo")
    public JMap queryAssociatBoatInfo(JMap params) throws Exception {
        List<Map<String, Object>> boatList=  deviceManageService.queryAssociatBoatInfo(params);
        JMap result = new JsonMap();
        result.put("result", boatList);
        return result;
    }
    /**
     * 关联用户的保存功能
     */
    @ResponseBody
    @RequestMapping("/associatUserSave")
    public JMap associatUserSave(JMap params) throws Exception {
        int num=deviceManageService.associatUserSave(params);
        JMap result = new JsonMap();
        result.put("result", num);
        return result;
    }
    /**
     * 关联船舶的保存功能
     */
    @ResponseBody
    @RequestMapping("/associatBoatSave")
    public JMap associatBoatSave(JMap params) throws Exception {
        int num=deviceManageService.associatBoatSave(params);
        JMap result = new JsonMap();
        result.put("result", num);
        return result;
    }
    /**
     * 解绑用户
     */

ebc-sea-platform/src/main/java/com/ai/ipu/server/controller/EquipmentManageController.java

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.List;
import java.util.Map;
/**
 * 设备管理
 */
    @ResponseBody
    @RequestMapping("/queryEquipmentInfo")
    public JMap queryEquipmentInfo(JMap params) throws Exception {
        PageInfo equipmentList=  equipmentManageService.queryEquipmentInfo(params);
        JMap result = new JsonMap();
        result.put("result", equipmentList);
        //取值判断如果有当前id则为修改，否则为新增
        JMap params1 = params.getJMap("params");
        try{
            if(params1.getInt("MAP_TAG_ID")!=0){
            if(params1.getInt("FACILITY_ID")!=0){
                num= equipmentManageService.modifyEquipmentInfo(params1);
            }else{
                num= equipmentManageService.addEquipmentInfo(params1);
    @ResponseBody
    @RequestMapping("/deleteEquipmentInfo")
    public JMap deleteEquipmentInfo(JMap params) throws Exception {
        //取值判断如果有当前id则为修改，否则为新增
        JMap params1 = params.getJMap("params");
        boolean flag=false;
        if(params.getInt("MAP_TAG_ID")!=0){
            flag=  equipmentManageService.deleteEquipmentInfo(params);
        if(params1.getInt("FACILITY_ID")!=0){
            flag=  equipmentManageService.deleteEquipmentInfo(params1);
        }
        JMap result = new JsonMap();
        result.put("result", flag);
     */
    @ResponseBody
    @RequestMapping("/deleteEquipmentsInfo")
    public JMap deleteEquipmentsInfo(JMap params) throws Exception {
    public JMap deleteEquipmentsInfo(List<Map<String,Object>> paramsList) throws Exception {
        boolean flag=false;
        if(params.getInt("MAP_TAG_ID")!=0){
            flag=  equipmentManageService.deleteEquipmentsInfo(params);
        if(!paramsList.isEmpty()){
            flag=  equipmentManageService.deleteEquipmentsInfo(paramsList);
        }
        JMap result = new JsonMap();
        result.put("result", flag);

ebc-sea-platform/src/main/java/com/ai/ipu/server/dao/impl/DeviceManageDaoImpl.java

import com.ai.ipu.data.JMap;
import com.ai.ipu.data.impl.JsonList;
import com.ai.ipu.data.impl.JsonMap;
import com.ai.ipu.database.dao.IpuDaoManager;
import com.ai.ipu.server.dao.interfaces.DeviceManageDao;
import com.ai.ipu.sql.mgmt.ISqlMgmtDao;
import com.ai.ipu.sql.mgmt.SqlMgmtDaoFactory;
public class DeviceManageDaoImpl implements DeviceManageDao {
    private String connName = "ebc";
    private String userAndDevicetableName = "LR_PARTY_TERMINAL"; //人员和终端关联表
    private String equipmentTableName = "LR_FACILITY"; //设施表
    @Override
    public PageInfo queryDeviceInfo(JMap params) throws Exception {
        JMap params1 = params.getJMap("params");
        PageHelper.startPage(params1.getInt("pageNum"),params1.getInt("pageSize"));
        ISqlMgmtDao dao = SqlMgmtDaoFactory.createFileSqlMgmtDao(connName);
        List<Map<String, Object>> mapTagList= dao.executeSelect("ipu.DeviceManageDao", "queryDeviceInfo", params1);
        List<Map<String, Object>> mapTagXyList= dao.executeSelect("ipu.DeviceManageDao", "queryDeviceXyInfo", params1);
        //将后台拼接成级联属性
        mapTagList.forEach((mapTag)->{
            ArrayList<Object> arrayList = new ArrayList<>();
            mapTagXyList.forEach((mapTagXy)->{
                if(mapTag.get("MAP_TAG_ID")==mapTagXy.get("MAP_TAG_ID")){
                    arrayList.add(mapTagXy);
                    System.out.println(arrayList.toString());
                }
            });
            mapTag.put("EBC_MAP_TAG_XY",arrayList);
        });
        PageInfo pageInfo = new PageInfo(mapTagList);
        return pageInfo;
    public List<Map<String, Object>> queryAssociatBoatInfo(JMap params) throws Exception {
        HashMap<String, Object> paramMap = new HashMap<>();
        paramMap.put("FACILITY_NAME","船舶");
        CommonTableDao dao = IpuDaoManager.takeDao(CommonTableDao.class, connName);
        List<Map<String, Object>> boatList = dao.selectByCond(equipmentTableName, paramMap);
        return boatList;
    }
    @Override
    public int modifyDeviceInfo (JMap params) throws Exception {
        deleteDeviceXyInfo(params);
        //将新数据插入
        int num = addDeviceInfo(params);
        return num;
    public List<Map<String, Object>> queryAssociatUser () throws Exception  {
        HashMap<String, Object> paramMap = new HashMap<>();
        CommonTableDao dao = IpuDaoManager.takeDao(CommonTableDao.class, connName);
        List<Map<String, Object>> userAndDeviceList = dao.selectByCond(userAndDevicetableName, paramMap);
        return userAndDeviceList;
    }
    @Override
    public int addDeviceInfo(JMap params) throws Exception {
        Object mapTagContent = params.get("MAP_TAG_CONTENT");
        String mapTagContentStr = JSONObject.toJSONString(mapTagContent);
        params.put("MAP_TAG_CONTENT",mapTagContentStr);
        ISqlMgmtDao dao = SqlMgmtDaoFactory.createFileSqlMgmtDao(connName);
        int num = dao.executeInsert("ipu.DeviceManageDao", "addDeviceInfo", params);
        if(num>0){
            JMap paramsMap=new JsonMap();
            JList paramsList=new JsonList();
            JList paramsJList = params.getJList("EBC_MAP_TAG_XY");
            paramsJList.forEach(s->{
                HashMap hashMap = JSON.parseObject(JSONObject.toJSONString(s), HashMap.class);
                hashMap.put("MAP_TAG_ID",params.getInt("MAP_TAG_ID"));
                paramsList.add(hashMap);
            });
            paramsMap.put("paramsList",paramsList);
            int i = dao.executeInsert("ipu.DeviceManageDao", "addDevicexyInfo", paramsMap);
        }
        return num;
    public int associatUserSave(JMap params) throws Exception {
        HashMap<String, Object> paramMap = new HashMap<>();
        //参数
        CommonTableDao dao = IpuDaoManager.takeDao(CommonTableDao.class, connName);
        int i = dao.insert(userAndDevicetableName, paramMap);
        return i;
    }
    @Override
    public boolean deleteDeviceXyInfo(JMap params) throws Exception {
        ISqlMgmtDao dao = SqlMgmtDaoFactory.createFileSqlMgmtDao(connName);
        //先删除子表在删除父表
        dao.executeDelete( "ipu.DeviceManageDao", "deleteDeviceXyInfo", params);
        int num = dao.executeDelete("ipu.DeviceManageDao", "deleteDeviceInfo", params);
        if(num>0){
            return true;
        }
        return false;
    public int associatBoatSave(JMap params) throws Exception {
        HashMap<String, Object> paramMap = new HashMap<>();
        //参数
        CommonTableDao dao = IpuDaoManager.takeDao(CommonTableDao.class, connName);
        int i = dao.update(equipmentTableName, paramMap);
        return i;
    }
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/dao/impl/EquipmentManageDaoImpl.java

import com.ai.ipu.data.JMap;
import com.ai.ipu.data.impl.JsonList;
import com.ai.ipu.data.impl.JsonMap;
import com.ai.ipu.database.dao.IpuDaoManager;
import com.ai.ipu.server.dao.interfaces.EquipmentManageDao;
import com.ai.ipu.sql.mgmt.ISqlMgmtDao;
import com.ai.ipu.sql.mgmt.SqlMgmtDaoFactory;
public class EquipmentManageDaoImpl implements EquipmentManageDao {
    private String connName = "ebc";
    private String equipmentTableName = "LR_FACILITY"; //设施表
    @Override
    public PageInfo queryEquipmentInfo(JMap params) throws Exception {
        JMap params1 = params.getJMap("params");
        PageHelper.startPage(params1.getInt("pageNum"),params1.getInt("pageSize"));
        ISqlMgmtDao dao = SqlMgmtDaoFactory.createFileSqlMgmtDao(connName);
        List<Map<String, Object>> mapTagList= dao.executeSelect("ipu.EquipmentManageDao", "queryEquipmentInfo", params1);
        List<Map<String, Object>> mapTagXyList= dao.executeSelect("ipu.EquipmentManageDao", "queryEquipmentXyInfo", params1);
        //将后台拼接成级联属性
        mapTagList.forEach((mapTag)->{
            ArrayList<Object> arrayList = new ArrayList<>();
            mapTagXyList.forEach((mapTagXy)->{
                if(mapTag.get("MAP_TAG_ID")==mapTagXy.get("MAP_TAG_ID")){
                    arrayList.add(mapTagXy);
                    System.out.println(arrayList.toString());
                }
            });
            mapTag.put("EBC_MAP_TAG_XY",arrayList);
        });
        PageInfo pageInfo = new PageInfo(mapTagList);
        List<Map<String, Object>> equipmentList= dao.executeSelect("ipu.EquipmentManageDao", "queryEquipmentInfo", params1);
        PageInfo pageInfo = new PageInfo(equipmentList);
        return pageInfo;
    }
    @Override
    public int modifyEquipmentInfo (JMap params) throws Exception {
        deleteEquipmentXyInfo(params);
        //将新数据插入
        int num = addEquipmentInfo(params);
        return num;
        CommonTableDao dao = IpuDaoManager.takeDao(CommonTableDao.class, connName);
        int i = dao.update(equipmentTableName, params);
        return i;
    }
    @Override
    public int addEquipmentInfo(JMap params) throws Exception {
        Object mapTagContent = params.get("MAP_TAG_CONTENT");
        String mapTagContentStr = JSONObject.toJSONString(mapTagContent);
        params.put("MAP_TAG_CONTENT",mapTagContentStr);
        ISqlMgmtDao dao = SqlMgmtDaoFactory.createFileSqlMgmtDao(connName);
        int num = dao.executeInsert("ipu.EquipmentManageDao", "addEquipmentInfo", params);
        if(num>0){
            JMap paramsMap=new JsonMap();
            JList paramsList=new JsonList();
            JList paramsJList = params.getJList("EBC_MAP_TAG_XY");
            paramsJList.forEach(s->{
                HashMap hashMap = JSON.parseObject(JSONObject.toJSONString(s), HashMap.class);
                hashMap.put("MAP_TAG_ID",params.getInt("MAP_TAG_ID"));
                paramsList.add(hashMap);
            });
            paramsMap.put("paramsList",paramsList);
            int i = dao.executeInsert("ipu.EquipmentManageDao", "addEquipmentxyInfo", paramsMap);
        }
        return num;
        CommonTableDao dao = IpuDaoManager.takeDao(CommonTableDao.class, connName);
        int i = dao.insert(equipmentTableName, params);
        return i;
    }
    @Override
    public boolean deleteEquipmentXyInfo(JMap params) throws Exception {
        ISqlMgmtDao dao = SqlMgmtDaoFactory.createFileSqlMgmtDao(connName);
        //先删除子表在删除父表
        dao.executeDelete( "ipu.EquipmentManageDao", "deleteEquipmentXyInfo", params);
        int num = dao.executeDelete("ipu.EquipmentManageDao", "deleteEquipmentInfo", params);
    public boolean deleteEquipmentInfo(JMap params) throws Exception {
        CommonTableDao dao = IpuDaoManager.takeDao(CommonTableDao.class, connName);
        int num = dao.delete(equipmentTableName, params);
        if(num>0){
            return true;
        }
        return false;
    }
    @Override
    public boolean deleteEquipmentsInfo(List<Map<String, Object>> paramsList) {
        return false;
    }
    @Override
    public boolean importEquipmentInfo(List<Map<String, Object>> paramsList) {
        return false;
    }
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/dao/interfaces/DeviceManageDao.java

import com.ai.ipu.data.JMap;
import com.github.pagehelper.PageInfo;
import java.util.List;
import java.util.Map;
public interface DeviceManageDao {
    PageInfo queryDeviceInfo(JMap params) throws Exception;
    List<Map<String, Object>> queryAssociatBoatInfo(JMap params) throws Exception;
    int modifyDeviceInfo(JMap params) throws Exception;
    List<Map<String, Object>> queryAssociatUser() throws Exception ;
    int addDeviceInfo(JMap params) throws Exception;
    int associatUserSave(JMap params) throws Exception ;
    boolean deleteDeviceXyInfo(JMap params) throws Exception;
    int associatBoatSave(JMap params) throws Exception ;
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/dao/interfaces/EquipmentManageDao.java

import com.ai.ipu.data.JMap;
import com.github.pagehelper.PageInfo;
import java.util.List;
import java.util.Map;
public interface EquipmentManageDao {
    PageInfo queryEquipmentInfo(JMap params) throws Exception;
    int addEquipmentInfo(JMap params) throws Exception;
    boolean deleteEquipmentXyInfo(JMap params) throws Exception;
    boolean deleteEquipmentInfo(JMap params) throws Exception;
    boolean deleteEquipmentsInfo(List<Map<String, Object>> paramsList);
    boolean importEquipmentInfo(List<Map<String, Object>> paramsList);
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/model/UserEnums.java

package com.ai.ipu.server.model;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Map;
import org.springframework.util.ReflectionUtils;
public enum UserEnums {
    oneUser(1, "张三", "1111", "搜救", "经理"),
    twoUser(2, "李四", "2222", "搜救", "员工"),
    threeUser(3, "王五", "3333", "搜救", "员工"),
    fiveUser(4, "赵六", "4444", "搜救", "员工"),
    sixUser(5, "田七", "5555", "搜救", "员工");
    public int id; //id
    public String userName;//姓名
    public String employeeNo;//员工编号
    public String department;//部门
    public String duty;//职务
    UserEnums() {
    }
    UserEnums(int id, String userName, String employeeNo, String department, String duty) {
        this.id = id;
        this.userName = userName;
        this.employeeNo = employeeNo;
        this.department = department;
        this.duty = duty;
    }
    public int getId() {
        return id;
    }
    public String getUserName() {
        return userName;
    }
    public String getEmployeeNo() {
        return employeeNo;
    }
    public String getDepartment() {
        return department;
    }
    public String getDuty() {
        return duty;
    }
    /**
     * 根据id返回枚举值
     * @param id
     * @return
     */
    public static UserEnums   getEumByid(int id){
        for(UserEnums userEnum: UserEnums.values()) {
            if(userEnum.getId()==id) {
                return userEnum;
            }
        }
        return null;
    }
    /**
     * 根据序号获取枚举数组中的值，序号必须从0开始
     * @param id
     * @return
     * @throws IllegalAccessException
     * @throws IllegalArgumentException
     * @throws InvocationTargetException
     * @throws InstantiationException
     */
    public static <T> List<T> getEumByKey(int id) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, InstantiationException {
        List<String> enumList=getEumValueList();
        List<T> enumList1=new ArrayList<T>();
        for(UserEnums testEnums: UserEnums.values()) {
            if(testEnums.getId()==id) {
                Class<?> clazz=testEnums.getClass();
                // 获取所有常量
                Object object = clazz.getEnumConstants()[id];
                Field[]  filedFields=clazz.getFields();
                for (Field field : filedFields) {
                    field.setAccessible(true);
                    Object sssObject=field.get(object);
                    if(enumList.contains(field.getName())) {
                        continue;
                    }else {
                        if(sssObject!=null)
                            enumList1.add((T) sssObject);
                    }
                }
                return enumList1;
            }
        }
        return null;
    }
    /**
     * 获取枚举值常量列表
     * @param
     * @return
     */
    public static List<String>  getEumValueList() {
        List<String> list=new ArrayList<String>();
        for(Object object:UserEnums.values()) {
            list.add(object.toString());
        }
        return list;
    }
    /**
     * 传入方法名称  values是值 ，field是 字段mingcheng
     * @param <T>
     * @param enumType
     * @param value
     * @param field
     * @return
     * @throws Exception
     */
    public static <T extends Enum<T>> T getEnumOnValue(Class<T> enumType, String value, String field) throws Exception {
        for (Object obj : enumType.getEnumConstants()) {
            Method m = obj.getClass().getDeclaredMethod("values", null);
            Object[] results = (Object[]) m.invoke(obj, null);
            for (Object result : results) {
                Field codeField = result.getClass().getDeclaredField(field);
                ReflectionUtils.makeAccessible(codeField);
                String fileValue = String.valueOf(ReflectionUtils.getField(codeField, result));
                if (fileValue.equals(value)) {
                    return (T) result;
                }
            }
        }
        return null;
    }
    /**
     * 获取所有的用户放到list里
     *
     * @return
     * @throws Exception
     */
    public static List<Map<String,Object>> getUserList(){
        ArrayList<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
        for(UserEnums userEnum : UserEnums .values()){
            Map<String,Object> userMap = new HashMap<String,Object>();
            userMap.put("id",userEnum.getId());
            userMap.put("userName",userEnum.getUserName());
            userMap.put("employeeNo",userEnum.getEmployeeNo());
            userMap.put("department",userEnum.getDepartment());
            userMap.put("duty",userEnum.getDuty());
            list.add(userMap);
        }
        return list;
    }
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/service/impl/DeviceManageServiceImpl.java

import com.ai.ipu.data.JMap;
import com.ai.ipu.server.dao.interfaces.DeviceManageDao;
import com.ai.ipu.server.model.UserEnums;
import com.ai.ipu.server.service.interfaces.DeviceManageService;
import com.github.pagehelper.PageInfo;
import org.slf4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
@Service
public class DeviceManageServiceImpl implements DeviceManageService  {
    @Override
    public PageInfo queryDeviceInfo(JMap params) throws Exception {
        return deviceManageDao.queryDeviceInfo(params);
        return null;
    }
    @Override
    public int modifyDeviceInfo(JMap params) throws Exception{
        //將原來数据删除，然后在从新插入
        return deviceManageDao.modifyDeviceInfo(params);
        return 0;
    }
    @Override
    public int addDeviceInfo(JMap params) throws Exception{
        return deviceManageDao.addDeviceInfo(params);
        return 0;
    }
    @Override
    public boolean deleteDeviceXyInfo(JMap params) throws Exception{
        return deviceManageDao.deleteDeviceXyInfo(params);
        return true;
    }
    @Override
    public List<Map<String, Object>> queryAssociatUserInfo(JMap params) throws Exception{
        //调用uspa接口获取人员信息 暂时用枚举
        List<Map<String, Object>> userList = UserEnums.getUserList();
        //查询关联表，如果已关联人员剔除
        List<Map<String, Object>> userAndDeviceList=  deviceManageDao.queryAssociatUser();
        Iterator<Map<String, Object>> iterator = userList.iterator();
        while (iterator.hasNext()){
            Map<String, Object> next = iterator.next();
            for (Map<String, Object> userAndDevice : userAndDeviceList) {
                if (userAndDevice.get("PARTY_NAME").equals(next.get("userName"))) {
                    iterator.remove();
                    break;
                }
            }
        }
        return userList;
    }
    @Override
    public List<Map<String, Object>> queryAssociatBoatInfo(JMap params) throws Exception {
        return deviceManageDao.queryAssociatBoatInfo(params);
    }
    @Override
    public int associatUserSave(JMap params) throws Exception {
        return deviceManageDao.associatUserSave(params);
    }
    @Override
    public int associatBoatSave(JMap params) throws Exception {
        return deviceManageDao.associatBoatSave(params);
    }
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/service/impl/EquipmentManageServiceImpl.java

import org.springframework.stereotype.Service;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
@Service
    @Override
    public PageInfo queryEquipmentInfo(JMap params) throws Exception {
        PageInfo pageInfo = new PageInfo();
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return pageInfo;
        return equipmentManageDao.queryEquipmentInfo(params);
    }
    @Override
    public int modifyEquipmentInfo(JMap params) throws Exception{
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return 1;
        return equipmentManageDao.modifyEquipmentInfo(params);
    }
    @Override
    public int addEquipmentInfo(JMap params) throws Exception{
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return 1;
        return equipmentManageDao.addEquipmentInfo(params);
    }
    @Override
    public boolean deleteEquipmentInfo(JMap params) throws Exception{
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return true;
        return equipmentManageDao.deleteEquipmentInfo(params);
    }
    @Override
    public boolean deleteEquipmentsInfo(JMap params) throws Exception {
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return false;
    public boolean deleteEquipmentsInfo(List<Map<String,Object>> paramsList) throws Exception {
        return equipmentManageDao.deleteEquipmentsInfo(paramsList);
    }
    @Override
    public boolean importEquipmentInfo(JMap params) throws Exception {
        //拼接接口地址
        String IOT_URL=UrlAddress.IOT_URL+"device";
        Map map = HttpURLConnectionUtil.iotCallMothod(params, IOT_URL);
        return false;
    public boolean importEquipmentInfo(List<Map<String,Object>> paramsList) throws Exception {
        return equipmentManageDao.importEquipmentInfo(paramsList);
    }

ebc-sea-platform/src/main/java/com/ai/ipu/server/service/interfaces/DeviceManageService.java

import com.ai.ipu.data.JMap;
import com.github.pagehelper.PageInfo;
import java.util.List;
import java.util.Map;
public interface DeviceManageService {
    PageInfo queryDeviceInfo(JMap params) throws Exception;
    int addDeviceInfo(JMap params) throws Exception;
    boolean deleteDeviceXyInfo(JMap params) throws Exception;
    List<Map<String, Object>> queryAssociatUserInfo(JMap params) throws Exception;
    List<Map<String, Object>> queryAssociatBoatInfo(JMap params) throws Exception;
    int associatUserSave(JMap params) throws Exception;
    int associatBoatSave(JMap params) throws Exception;
}

ebc-sea-platform/src/main/java/com/ai/ipu/server/service/interfaces/EquipmentManageService.java

import com.ai.ipu.data.JMap;
import com.github.pagehelper.PageInfo;
import java.util.List;
import java.util.Map;
public interface EquipmentManageService {
    PageInfo queryEquipmentInfo(JMap params) throws Exception;
    boolean deleteEquipmentInfo(JMap params) throws Exception;
    boolean deleteEquipmentsInfo(JMap params) throws Exception;
    boolean deleteEquipmentsInfo(List<Map<String,Object>> paramsList) throws Exception;
    boolean importEquipmentInfo(JMap params) throws Exception;
    boolean importEquipmentInfo(List<Map<String,Object>> paramsList) throws Exception;
}

ebc-sea-platform/src/main/resources/dev/ipu-mybatis-config.xml

		<environment id="ebc">
			<transactionManager type="JDBC" />
			<dataSource type="com.ai.ipu.database.datasource.DruidDataSourceFactory">
				<property name="jdbcUrl" value="jdbc:mysql://121.42.183.206:3307/ebc" />
				<property name="username" value="ipu" />
				<property name="password" value="ipumysql" />
				<property name="jdbcUrl" value="jdbc:mysql://10.19.90.34:3307/ebc" />
				<property name="username" value="ebc" />
				<property name="password" value="ebc@123" />
			</dataSource>
		</environment>
	</environments>

ebc-sea-platform/src/main/resources/sql/ipu/EquipmentManageDao.xml

<?xml version="1.0" encoding="UTF-8"?>
<sqls>
	<sql name="queryEquipmentInfo">
		<![CDATA[
		<select id="queryEquipmentInfo" resultType="java.util.Map" >
	        SELECT
				FACILITY_ID,
				FACILITY_TYPE,
				FACILITY_CODE,
				FACILITY_NAME,
				LONGITUDE,
				LATITUDE,
				DEVICE_ID
			FROM
				LR_FACILITY
	        <where>
	        	<if test="FACILITY_CODE!=null">
               		 and FACILITY_CODE like concat(concat("%",#{FACILITY_CODE}),"%")
            	</if>
            	<if test="FACILITY_NAME!=null">
               		 and FACILITY_NAME like concat(concat("%",#{FACILITY_NAME}),"%")
            	</if>
	        </where>
		</select>
		]]>
	</sql>
	<sql name="queryMapTagXyInfo">
		<![CDATA[
		<select id="queryMapTagXyInfo" resultType="java.util.Map" >
	        SELECT
				MAP_TAG_ID,
				MAP_TAG_XY_ID,
				XY_NAME,
				LATITUDE,
				LONGITUDE
			FROM
				ebc_map_tag_xy
		</select>
		]]>
	</sql>
	<sql name="addMapTagInfo">
		<![CDATA[
		<insert id="addMapTagInfo" resultType="java.util.Map" useGeneratedKeys="true" keyProperty="MAP_TAG_ID">
		   INSERT INTO  ebc_map_tag(
			MAP_TAG_NAME,MAP_TAG_TYPE,MAP_TAG_CONTENT,CREATE_DATE
			)VALUES (
			  #{MAP_TAG_NAME},
			  #{MAP_TAG_TYPE},
			  #{MAP_TAG_CONTENT},
			  #{CREATE_DATE}
			)
			</insert>
			]]>
	</sql>
	<sql name="addMapTagxyInfo">
		<![CDATA[<insert id="addMapTagxyInfo">
			INSERT INTO ebc_map_tag_xy
			(MAP_TAG_ID,XY_NAME,LONGITUDE,LATITUDE)
			VALUES
			<foreach collection ="paramsList" item="itemParams" index= "index" separator =",">
			(#{itemParams.MAP_TAG_ID},#{itemParams.XY_NAME},#{itemParams.LONGITUDE},#{itemParams.LATITUDE})
			</foreach>
		</insert>
		]]>
	</sql>
	<sql name="deleteMapTagXyInfo">
		<![CDATA[
			<delete id="deleteMapTagXyInfo">
				delete FROM ebc_map_tag_xy where MAP_TAG_ID=#{MAP_TAG_ID}
			</delete>
		]]>
	</sql>
	<sql name="deleteMapTagInfo">
		<![CDATA[
			<delete id="deleteMapTagInfo">
				delete FROM ebc_map_tag where MAP_TAG_ID=#{MAP_TAG_ID}
			</delete>
		]]>
	</sql>
</sqls>