diff --git a/src/main/java/com/supwisdom/dlpay/system/bean/AllotBuildingBean.java b/src/main/java/com/supwisdom/dlpay/system/bean/AllotBuildingBean.java
new file mode 100644
index 0000000..819e5f6
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/system/bean/AllotBuildingBean.java
@@ -0,0 +1,56 @@
+package com.supwisdom.dlpay.system.bean;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+@Entity
+public class AllotBuildingBean {
+
+    private String regionid;
+    private String regionname;
+    @Id
+    private String buildingid;
+    private String buildingname;
+
+    public String getRegionid() {
+        return regionid;
+    }
+
+    public void setRegionid(String regionid) {
+        this.regionid = regionid;
+    }
+
+    public String getRegionname() {
+        return regionname;
+    }
+
+    public void setRegionname(String regionnname) {
+        this.regionname = regionnname;
+    }
+
+    public String getBuildingid() {
+        return buildingid;
+    }
+
+    public void setBuildingid(String buildingid) {
+        this.buildingid = buildingid;
+    }
+
+    public String getBuildingname() {
+        return buildingname;
+    }
+
+    public void setBuildingname(String buildingname) {
+        this.buildingname = buildingname;
+    }
+
+    public AllotBuildingBean() {
+    }
+
+    public AllotBuildingBean(String regionid, String regionnname, String buildingid, String buildingname) {
+        this.regionid = regionid;
+        this.regionname = regionnname;
+        this.buildingid = buildingid;
+        this.buildingname = buildingname;
+    }
+}
diff --git a/src/main/java/com/supwisdom/dlpay/system/controller/SystemController.java b/src/main/java/com/supwisdom/dlpay/system/controller/SystemController.java
index 8b932fd..5e80929 100644
--- a/src/main/java/com/supwisdom/dlpay/system/controller/SystemController.java
+++ b/src/main/java/com/supwisdom/dlpay/system/controller/SystemController.java
@@ -1,16 +1,16 @@
 package com.supwisdom.dlpay.system.controller;
 
+import com.google.gson.Gson;
 import com.supwisdom.dlpay.framework.domain.TOperator;
 import com.supwisdom.dlpay.framework.util.DateUtil;
 import com.supwisdom.dlpay.framework.util.StringUtil;
 import com.supwisdom.dlpay.ncmgr.domain.TBuilding;
 import com.supwisdom.dlpay.ncmgr.domain.TNcDevice;
 import com.supwisdom.dlpay.ncmgr.service.NcService;
+import com.supwisdom.dlpay.system.bean.AllotBuildingBean;
 import com.supwisdom.dlpay.system.bean.BuildingBean;
 import com.supwisdom.dlpay.system.bean.RegionBean;
-import com.supwisdom.dlpay.system.domain.DictionaryType;
-import com.supwisdom.dlpay.system.domain.TDictionaryId;
-import com.supwisdom.dlpay.system.domain.TRegion;
+import com.supwisdom.dlpay.system.domain.*;
 import com.supwisdom.dlpay.system.page.Pagination;
 import com.supwisdom.dlpay.system.service.SystemService;
 import com.supwisdom.dlpay.util.RedisUtil;
@@ -571,4 +571,86 @@
         map.put("message", message);
         return map;
     }
+
+    /**
+     * 获取分配楼栋填充数据
+     * @param operid
+     * @param operUser
+     * @return
+     */
+    @ResponseBody
+    @RequestMapping(value = "/getBuildingList")
+    public Map getBuildingList(@RequestParam(value = "operid", required = true) String operid,
+                               @AuthenticationPrincipal TOperator operUser) {
+        Map map = new HashMap();
+        int flag = 0;
+        try {
+            String opertype = operUser.getOpertype();
+            List<AllotBuildingBean> buildinglist = null;
+            List<AllotBuildingBean> buildinglisted = null;
+            if(opertype.equals("L")){
+                flag = 1;
+                map.put("result", "没有分配楼栋权限!");
+            }else if (!StringUtil.isEmpty(opertype) &&(opertype.equals("S")||opertype.equals("P"))){
+                buildinglist = systemService.findSystemAllotBuildingList();
+                buildinglisted = systemService.findBuildingInOper(operid);
+                map.put("result", "楼栋信息查询完成");
+            }else if (!StringUtil.isEmpty(operUser.getRegionid())){
+                buildinglist = systemService.findOperatorAllotBuildingList(operUser.getRegionid());
+                buildinglisted = systemService.findBuildingInOper(operid);
+                map.put("result", "楼栋信息查询完成");
+            }
+            map.put("buildinglist", buildinglist);//  待选楼栋
+            map.put("buildinglisted", buildinglisted);//  已选楼栋
+
+            map.put("flag", flag);
+        } catch (Exception e) {
+            e.printStackTrace();
+            map.put("result", "楼栋信息查询失败");
+            logger.error("楼栋信息查询失败：" + e.getMessage());
+        }
+        return map;
+    }
+
+    /**
+     * 保存操作员楼栋
+     * @param operid
+     * @param buildingArry
+     * @return
+     */
+    @ResponseBody
+    @RequestMapping(value = "/saveOperBuildingBind", method = {RequestMethod.POST})
+    public Map saveOperBuildingBind(@RequestParam(value = "operid", required = true) String operid,
+                                    @RequestBody String[] buildingArry,
+                                    @AuthenticationPrincipal TOperator operUser) {
+        Map map = new HashMap();
+        int okFlag = 0;
+        try {
+            if (buildingArry != null && buildingArry.length > 0) {
+                systemService.deleteOperBuildingByOperid(operid);
+                TOperbuilding operbuilding = null;
+                TOperbuildingId id = null;
+                for (String bean : buildingArry) {
+                    String[] buildings = bean.split("#");
+                    operbuilding = new TOperbuilding();
+                    id = new TOperbuildingId();
+                    id.setOperid(operid);
+                    id.setBuildingid(buildings[1]);
+                    operbuilding.setId(id);
+                    operbuilding.setMemo("");
+                    operbuilding.setAllotoperid(operUser.getOperid());
+                    operbuilding.setUpdtime(DateUtil.getNow());
+                    systemService.saveOperBuilding(operbuilding);
+                }
+                map.put("result", "管理员：" + operid + "，分配楼栋成功");
+            }
+            okFlag = 1;
+        } catch (Exception e) {
+            e.printStackTrace();
+            map.put("result", "管理员：" + operid + "，分配楼栋失败");
+            logger.error("分配设备失败：" + e.getMessage());
+        }
+        map.put("okFlag", okFlag);
+        return map;
+    }
 }
diff --git a/src/main/java/com/supwisdom/dlpay/system/dao/BuildingDao.java b/src/main/java/com/supwisdom/dlpay/system/dao/BuildingDao.java
index ab897e2..19c40e0 100644
--- a/src/main/java/com/supwisdom/dlpay/system/dao/BuildingDao.java
+++ b/src/main/java/com/supwisdom/dlpay/system/dao/BuildingDao.java
@@ -1,6 +1,8 @@
 package com.supwisdom.dlpay.system.dao;
 
 import com.supwisdom.dlpay.ncmgr.domain.TBuilding;
+import com.supwisdom.dlpay.system.bean.AllotBuildingBean;
+import com.supwisdom.dlpay.system.domain.TOperbuilding;
 import com.supwisdom.dlpay.system.page.Pagination;
 
 import java.util.List;
@@ -21,4 +23,14 @@
     public boolean updateBuilding(TBuilding bean);
 
     public boolean updateBuildingFlag(String buildingid);
+
+    public List<AllotBuildingBean> findSystemAllotBuildingList();
+
+    public List<AllotBuildingBean> findOperatorAllotBuildingList(String operRegionid);
+
+    public List<AllotBuildingBean> findBuildingInOper(String operid);
+
+    public boolean deleteOperBuildingByOperid(String operid);
+
+    public boolean saveOperBuilding(TOperbuilding bean);
 }
diff --git a/src/main/java/com/supwisdom/dlpay/system/dao/impl/BuildingDaoImpl.java b/src/main/java/com/supwisdom/dlpay/system/dao/impl/BuildingDaoImpl.java
index 0bebeeb..ded91f9 100644
--- a/src/main/java/com/supwisdom/dlpay/system/dao/impl/BuildingDaoImpl.java
+++ b/src/main/java/com/supwisdom/dlpay/system/dao/impl/BuildingDaoImpl.java
@@ -2,7 +2,9 @@
 
 import com.supwisdom.dlpay.framework.util.StringUtil;
 import com.supwisdom.dlpay.ncmgr.domain.TBuilding;
+import com.supwisdom.dlpay.system.bean.AllotBuildingBean;
 import com.supwisdom.dlpay.system.dao.BuildingDao;
+import com.supwisdom.dlpay.system.domain.TOperbuilding;
 import com.supwisdom.dlpay.system.page.Pagination;
 import org.springframework.stereotype.Repository;
 import org.springframework.transaction.annotation.Transactional;
@@ -135,7 +137,7 @@
             entityManager.persist(bean);
             flag=true;
         }catch (Exception e){
-            e.printStackTrace();
+            throw e;
         }
         return flag;
     }
@@ -162,7 +164,7 @@
             entityManager.merge(bean);
             flag = true;
         } catch (Exception e) {
-            e.printStackTrace();
+            throw  e;
         }
         return flag;
     }
@@ -178,7 +180,73 @@
             query.executeUpdate();
             flag = true;
         }catch (Exception e){
-            e.printStackTrace();
+            throw e;
+        }
+        return flag;
+    }
+
+    @Transactional
+    @Override
+    public List<AllotBuildingBean> findSystemAllotBuildingList() {
+        String sql = "select a.buildingid,a.buildingname,a.regionid,b.regionname from t_building a " +
+                " left join tb_region b on a.regionid=b.regionid ";
+        Query query = entityManager.createNativeQuery(sql, AllotBuildingBean.class);
+        List<AllotBuildingBean> list = query.getResultList();
+        return list;
+    }
+
+    @Transactional
+    @Override
+    public List<AllotBuildingBean> findOperatorAllotBuildingList(String operRegionid) {
+        String sql = "select a.buildingid,a.buildingname,a.regionid,b.regionname from t_building a " +
+                " left join tb_region b on a.regionid=b.regionid " +
+                " where b.regionid in(with recursive tmp as  (select tbr.regionid,tbr.parentid,tbr.regionname from tb_region tbr " +
+                " where regionid= :operRegionid union all  select tbr.regionid,tbr.parentid,tbr.regionname from tb_region tbr inner join tmp t on t.regionid=tbr.parentid  " +
+                "                    ) select regionid from tmp  )";
+        Query query = entityManager.createNativeQuery(sql, AllotBuildingBean.class);
+        query.setParameter("operRegionid", operRegionid);
+        List<AllotBuildingBean> list = query.getResultList();
+        return list;
+    }
+
+    @Transactional
+    @Override
+    public List<AllotBuildingBean> findBuildingInOper(String operid) {
+        String sql = "select a.buildingid,a.buildingname,a.regionid,b.regionname from t_building a " +
+                " left join tb_region b on a.regionid = b.regionid " +
+                " where a.buildingid in " +
+                " (select c.buildingid from t_operbuilding c where operid = ?1)";
+        Query query = entityManager.createNativeQuery(sql, AllotBuildingBean.class);
+        query.setParameter(1, operid);
+        List<AllotBuildingBean> list = query.getResultList();
+        return list;
+    }
+
+    @Transactional
+    @Override
+    public boolean deleteOperBuildingByOperid(String operid) {
+        boolean flag = false;
+        try {
+            String sql = "delete from t_operbuilding where operid = ?1";
+            Query query = entityManager.createNativeQuery(sql);
+            query.setParameter(1, operid);
+            query.executeUpdate();
+            flag = true;
+        }catch (Exception e){
+            throw e;
+        }
+        return flag;
+    }
+
+    @Transactional
+    @Override
+    public boolean saveOperBuilding(TOperbuilding bean) {
+        boolean flag=false;
+        try {
+            entityManager.persist(bean);
+            flag=true;
+        }catch (Exception e){
+            throw e;
         }
         return flag;
     }
diff --git a/src/main/java/com/supwisdom/dlpay/system/domain/TOperbuilding.java b/src/main/java/com/supwisdom/dlpay/system/domain/TOperbuilding.java
new file mode 100644
index 0000000..bc4cecd
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/system/domain/TOperbuilding.java
@@ -0,0 +1,82 @@
+package com.supwisdom.dlpay.system.domain;
+
+import javax.persistence.AttributeOverride;
+import javax.persistence.AttributeOverrides;
+import javax.persistence.Column;
+import javax.persistence.EmbeddedId;
+import javax.persistence.Entity;
+import javax.persistence.Table;
+
+
+@Entity
+@Table(name = "T_OPERBUILDING")
+public class TOperbuilding implements java.io.Serializable {
+
+	// Fields
+
+	private TOperbuildingId id;
+	private String updtime;
+	private String allotoperid;
+	private String memo;
+
+	// Constructors
+
+	/** default constructor */
+	public TOperbuilding() {
+	}
+
+	/** minimal constructor */
+	public TOperbuilding(TOperbuildingId id) {
+		this.id = id;
+	}
+
+	/** full constructor */
+	public TOperbuilding(TOperbuildingId id, String updtime, String allotoperid,
+			String memo) {
+		this.id = id;
+		this.updtime = updtime;
+		this.allotoperid = allotoperid;
+		this.memo = memo;
+	}
+
+	// Property accessors
+	@EmbeddedId
+	@AttributeOverrides({
+			@AttributeOverride(name = "operid", column = @Column(name = "OPERID", nullable = false, length = 32)),
+			@AttributeOverride(name = "buildingid", column = @Column(name = "BUILDINGID", nullable = false, length = 32)) })
+	public TOperbuildingId getId() {
+		return this.id;
+	}
+
+	public void setId(TOperbuildingId id) {
+		this.id = id;
+	}
+
+	@Column(name = "UPDTIME", length = 30)
+	public String getUpdtime() {
+		return this.updtime;
+	}
+
+	public void setUpdtime(String updtime) {
+		this.updtime = updtime;
+	}
+
+	@Column(name = "ALLOTOPERID", length = 32)
+	public String getAllotoperid() {
+		return this.allotoperid;
+	}
+
+	public void setAllotoperid(String allotoperid) {
+		this.allotoperid = allotoperid;
+	}
+
+	@Column(name = "MEMO", length = 255)
+	public String getMemo() {
+		return this.memo;
+	}
+
+	public void setMemo(String memo) {
+		this.memo = memo;
+	}
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/supwisdom/dlpay/system/domain/TOperbuildingId.java b/src/main/java/com/supwisdom/dlpay/system/domain/TOperbuildingId.java
new file mode 100644
index 0000000..0fbdda2
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/system/domain/TOperbuildingId.java
@@ -0,0 +1,52 @@
+package com.supwisdom.dlpay.system.domain;
+
+import javax.persistence.Column;
+import javax.persistence.Embeddable;
+
+/**
+ * TOperdeviceId entity. @author MyEclipse Persistence Tools
+ */
+@Embeddable
+public class TOperbuildingId implements java.io.Serializable {
+
+	// Fields
+
+	private String operid;
+	private String buildingid;
+
+	// Constructors
+
+	/** default constructor */
+	public TOperbuildingId() {
+	}
+
+	/** full constructor */
+	public TOperbuildingId(String operid, String buildingid) {
+		this.operid = operid;
+		this.buildingid = buildingid;
+	}
+
+	// Property accessors
+
+	@Column(name = "OPERID", nullable = false, length = 32)
+	public String getOperid() {
+		return this.operid;
+	}
+
+	public void setOperid(String operid) {
+		this.operid = operid;
+	}
+
+
+	@Column(name = "BUILDINGID", nullable = false, length = 32)
+	public String getBuildingid() {
+		return this.buildingid;
+	}
+
+	public void setBuildingid(String buildingid) {
+		this.buildingid = buildingid;
+	}
+
+
+
+}
\ No newline at end of file
diff --git a/src/main/java/com/supwisdom/dlpay/system/service/SystemService.java b/src/main/java/com/supwisdom/dlpay/system/service/SystemService.java
index 22d43c4..0f1f65f 100644
--- a/src/main/java/com/supwisdom/dlpay/system/service/SystemService.java
+++ b/src/main/java/com/supwisdom/dlpay/system/service/SystemService.java
@@ -2,10 +2,8 @@
 
 
 import com.supwisdom.dlpay.ncmgr.domain.TBuilding;
-import com.supwisdom.dlpay.system.domain.DictionaryType;
-import com.supwisdom.dlpay.system.domain.TDictionary;
-import com.supwisdom.dlpay.system.domain.TDictionaryId;
-import com.supwisdom.dlpay.system.domain.TRegion;
+import com.supwisdom.dlpay.system.bean.AllotBuildingBean;
+import com.supwisdom.dlpay.system.domain.*;
 import com.supwisdom.dlpay.system.page.Pagination;
 
 import java.util.List;
@@ -94,4 +92,18 @@
     //根据id删除楼栋---修改flag为D
     public boolean delBuilding(String buildingid);
 
+    //获取所有要分配的楼栋
+    public List<AllotBuildingBean> findSystemAllotBuildingList();
+
+    //获取操作员权限下要分配的楼栋
+    public List<AllotBuildingBean> findOperatorAllotBuildingList(String operRegionid);
+
+    //获取已经分配过的楼栋
+    public List<AllotBuildingBean> findBuildingInOper(String operid);
+
+    //根据操作员id删除所有分配的楼栋
+    public boolean deleteOperBuildingByOperid(String operid);
+
+    //保存操作员分配的楼栋
+    public boolean saveOperBuilding(TOperbuilding bean);
 }
diff --git a/src/main/java/com/supwisdom/dlpay/system/service/impl/SystemServiceImpl.java b/src/main/java/com/supwisdom/dlpay/system/service/impl/SystemServiceImpl.java
index a571bc6..359c8e1 100644
--- a/src/main/java/com/supwisdom/dlpay/system/service/impl/SystemServiceImpl.java
+++ b/src/main/java/com/supwisdom/dlpay/system/service/impl/SystemServiceImpl.java
@@ -1,14 +1,12 @@
 package com.supwisdom.dlpay.system.service.impl;
 
 import com.supwisdom.dlpay.ncmgr.domain.TBuilding;
+import com.supwisdom.dlpay.system.bean.AllotBuildingBean;
 import com.supwisdom.dlpay.system.dao.BuildingDao;
 import com.supwisdom.dlpay.system.dao.DictionaryDao;
 import com.supwisdom.dlpay.system.dao.OperatorDao;
 import com.supwisdom.dlpay.system.dao.RegionDao;
-import com.supwisdom.dlpay.system.domain.DictionaryType;
-import com.supwisdom.dlpay.system.domain.TDictionary;
-import com.supwisdom.dlpay.system.domain.TDictionaryId;
-import com.supwisdom.dlpay.system.domain.TRegion;
+import com.supwisdom.dlpay.system.domain.*;
 import com.supwisdom.dlpay.system.page.Pagination;
 import com.supwisdom.dlpay.system.service.SystemService;
 import org.springframework.beans.factory.annotation.Autowired;
@@ -171,4 +169,29 @@
         return buildingDao.updateBuildingFlag(buildingid);
     }
 
+    @Override
+    public List<AllotBuildingBean> findSystemAllotBuildingList() {
+        return buildingDao.findSystemAllotBuildingList();
+    }
+
+    @Override
+    public List<AllotBuildingBean> findOperatorAllotBuildingList(String operRegionid) {
+        return buildingDao.findOperatorAllotBuildingList(operRegionid);
+    }
+
+    @Override
+    public List<AllotBuildingBean> findBuildingInOper(String operid) {
+        return buildingDao.findBuildingInOper(operid);
+    }
+
+    @Override
+    public boolean deleteOperBuildingByOperid(String operid) {
+        return buildingDao.deleteOperBuildingByOperid(operid);
+    }
+
+    @Override
+    public boolean saveOperBuilding(TOperbuilding bean) {
+        return buildingDao.saveOperBuilding(bean);
+    }
+
 }
diff --git a/src/main/resources/application.properties b/src/main/resources/application.properties
index d37e1ac..86d2885 100644
--- a/src/main/resources/application.properties
+++ b/src/main/resources/application.properties
@@ -27,6 +27,6 @@
 # user password
 auth.password.bcrypt.length=10
 
-server.servlet.context-path=/
+server.servlet.context-path=/door
 
 
diff --git a/src/main/resources/static/custom/module/admin.js b/src/main/resources/static/custom/module/admin.js
index e6ad642..e15cfdf 100755
--- a/src/main/resources/static/custom/module/admin.js
+++ b/src/main/resources/static/custom/module/admin.js
@@ -1,6 +1,7 @@
 layui.define(['layer'], function (exports) {
     var layer = layui.layer;
     var popupRightIndex, popupCenterIndex, popupCenterParam;
+    var baseUrl = window.location.pathname;
 
     var admin = {
         isRefresh: false,
@@ -228,6 +229,19 @@
                 default:
                     return str;
             }
+        },
+        errorBack: function (err) {
+            layer.closeAll('loading');
+            if (403 == err.status) {
+                layer.msg("无资源权限！", {icon: 2, time: 1500});
+                return;
+            }
+            if (200 == err.status) {
+                layer.msg("请求异常，请刷新页面重新操作", {icon: 2, time: 1500});
+                return;
+            } else {
+                layer.msg("请求服务器失败！", {icon: 2});
+            }
         }
     };
 
@@ -248,7 +262,7 @@
         },
         // 设置主题
         theme: function () {
-            admin.popupRight('home/theme');
+            admin.popupRight(baseUrl+'home/theme');
         },
         // 全屏
         fullScreen: function (e) {
@@ -311,10 +325,10 @@
                     btn: ['确定', '取消']
                 }, function (index, layero) {
                     layer.closeAll('dialog');  //加入这个信息点击确定 会关闭这个消息框
-                    admin.dgo("/dictrefresh", {}, function (data) {
+                    admin.dgo(baseUrl+"dictrefresh", {}, function (data) {
                         if (data.code == 200) {
                             layer.msg("刷新数据字典成功！", {icon: 1, time: 1000});
-                            DictPoolToolkit().initAll("/dictpool");
+                            DictPoolToolkit().initAll(baseUrl+"dictpool");
                         } else if (data.code == 401) {
                             layer.msg(data.msg, {icon: 2, time: 1500}, function () {
                                 location.replace('/login');
diff --git a/src/main/resources/static/custom/module/index.js b/src/main/resources/static/custom/module/index.js
index 992d4d9..df14f67 100755
--- a/src/main/resources/static/custom/module/index.js
+++ b/src/main/resources/static/custom/module/index.js
@@ -2,6 +2,7 @@
     var admin = layui.admin;
     var layer = layui.layer;
     var element = layui.element;
+    var baseUrl = window.location.pathname;
 
     var index = {
         pageTabs: true,  // 是否开启多标签
@@ -14,6 +15,12 @@
                 if ('javascript:;' != menuPath && '' != menuPath) {
                     var key = menuPath.replace(/[?:=&/]/g, '_');
                     $(this).attr('href', '#!' + key);
+                    if (menuPath.startsWith("/")) {
+                        menuPath = baseUrl + menuPath.substring(1);
+                    } else {
+                        menuPath = baseUrl + menuPath;
+                    }
+                    console.log(menuPath);
                     Q.reg(key, function () {
                         index.loadView({
                             menuId: key,
@@ -28,7 +35,7 @@
 
             // 主页
             Q.init({
-                index: 'home_console'
+                index: '_home_console'
             });
             // tab选项卡切换监听
             element.on('tab(admin-pagetabs)', function (data) {
@@ -134,7 +141,7 @@
             // 退出登录点击事件
             $('#btnLogout').click(function () {
                 layer.confirm('确定退出登录？', function () {
-                    location.replace('logout');
+                    location.replace(baseUrl+'logout');
                 });
             });
         }
diff --git a/src/main/resources/templates/doorlist/searchDoorlist.html b/src/main/resources/templates/doorlist/searchDoorlist.html
index 0ded60e..bb02571 100644
--- a/src/main/resources/templates/doorlist/searchDoorlist.html
+++ b/src/main/resources/templates/doorlist/searchDoorlist.html
@@ -334,7 +334,7 @@
             },
         },
         created: function () {
-            var url = "/doorlistMgr/getFillFormList";
+            var url = "[[@{/doorlistMgr/getFillFormList}]]";
             var _self = this;
             $.ajax({
                 type: "get",
@@ -444,7 +444,7 @@
                 endStr = searchDoor.allocatEndDate.Format('yyyyMMdd');
             }
         }
-        var url = "/doorlistMgr/getAllCardList?" + "&allocatStartDate=" + startStr + "&allocatEndDate=" + endStr +
+        var url = "[[@{/doorlistMgr/getAllCardList?}]]" + "&allocatStartDate=" + startStr + "&allocatEndDate=" + endStr +
             "&doorName=" + searchDoor.doorName + "&custName=" + searchDoor.custName
             + "&stuempNo=" + searchDoor.stuempNo + "&factoryId=" + searchDoor.factoryId
             + "&syncStatus=" + searchDoor.syncStatus +
@@ -489,7 +489,7 @@
                 endStr = searchDoor.allocatEndDate.Format('yyyyMMdd');
             }
         }
-        var url = "/doorlistMgr/exportExcel?" + "&allocatStartDate=" + startStr + "&allocatEndDate=" + endStr +
+        var url = "[[@{/doorlistMgr/exportExcel?}]]" + "&allocatStartDate=" + startStr + "&allocatEndDate=" + endStr +
             "&doorName=" + searchDoor.doorName + "&custName=" + searchDoor.custName
             + "&stuempNo=" + searchDoor.stuempNo + "&factoryId=" + searchDoor.factoryId
             + "&syncStatus=" + searchDoor.syncStatus + "&operFlag=" + searchDoor.operFlag
@@ -505,7 +505,7 @@
             layer.msg('请选择要重新下发的名单！',{icon:2,time:1000});
         }else {
             layer.confirm('确定要重新下发这些名单吗？', {icon: 3, title:'请确认',offset:'30%'},function(index){
-                var url = "/doorlistMgr/reSaveDoorCardList.json";
+                var url = "[[@{/doorlistMgr/reSaveDoorCardList}]]";
                 var token=$("meta[name='_csrf_token']").attr("value");
                 $.ajax({
                     type: "POST",
@@ -531,7 +531,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/ncmgr/getRegionBuilding?regionid=" + value),
+            url: encodeURI("[[@{/ncmgr/getRegionBuilding?regionid=}]]" + value),
             success: function (ret) {
                 var bList = [];
                 var rB = ret.reBuilding;
diff --git a/src/main/resources/templates/home/console.html b/src/main/resources/templates/home/console.html
index 027897c..94a54a5 100755
--- a/src/main/resources/templates/home/console.html
+++ b/src/main/resources/templates/home/console.html
@@ -55,7 +55,7 @@
         var element = layui.element;
         var device = layui.device;
 
-        layui.link('/static/custom/css/console.css');
+        layui.link('[[@{/static/custom/css/console.css}]]');
 
         // 渲染轮播
         carousel.render({
diff --git a/src/main/resources/templates/home/password.html b/src/main/resources/templates/home/password.html
index 931eb25..e9e8aee 100755
--- a/src/main/resources/templates/home/password.html
+++ b/src/main/resources/templates/home/password.html
@@ -30,7 +30,7 @@
         // 监听提交
         form.on('submit(submit-psw)', function (data) {
             layer.load(2);
-            $.post('/system/user/updatePsw', data.field, function (data) {
+            $.post('[[@{/system/user/updatePsw}]]', data.field, function (data) {
                 if (data.code == 200) {
                     layer.closeAll('loading');
                     admin.closePopupRight();
diff --git a/src/main/resources/templates/index.html b/src/main/resources/templates/index.html
index 848e8a7..ab98769 100755
--- a/src/main/resources/templates/index.html
+++ b/src/main/resources/templates/index.html
@@ -180,7 +180,7 @@
 
 <script>
     layui.config({
-        base: 'static/custom/module/'
+        base: '[[@{static/custom/module/}]]'
     }).extend({
         formSelects: 'formSelects/formSelects-v4',
         treetable: 'treetable-lay/treetable',
@@ -198,7 +198,7 @@
         index.bindEvent();  // 绑定事件
 
         var dictpool = DictPoolToolkit();
-        dictpool.initAll("/dictpool"); //加载字典
+        dictpool.initAll("[[@{/dictpool}]]"); //加载字典
     });
 </script>
 </body>
diff --git a/src/main/resources/templates/login.html b/src/main/resources/templates/login.html
index 0cef69e..6e00652 100644
--- a/src/main/resources/templates/login.html
+++ b/src/main/resources/templates/login.html
@@ -84,7 +84,7 @@
 <script type="text/javascript"  th:src="@{/static/libs/layui/layui.js}" ></script>
 <script>
     layui.config({
-        base: 'custom/module/'
+        base: '[[@{custom/module}]]/'
     }).use(['form'], function () {
         var $ = layui.jquery;
         var form = layui.form;
@@ -93,7 +93,7 @@
             var field = obj.field;
             layer.load(2);
             $.ajax({
-                url: '/login/form',
+                url: '[[@{/login/form}]]',
                 data: field,
                 type: 'POST',
                 success: function (data) {
diff --git a/src/main/resources/templates/ncmgr/nc_dev.html b/src/main/resources/templates/ncmgr/nc_dev.html
index 8af8ffc..4083bc1 100644
--- a/src/main/resources/templates/ncmgr/nc_dev.html
+++ b/src/main/resources/templates/ncmgr/nc_dev.html
@@ -558,7 +558,7 @@
             $.ajax({
                 type: "get",
                 dataType: "json",
-                url: "/ncmgr/loadDevList",
+                url: "[[@{/ncmgr/loadDevList}]]",
                 success: function (ret) {
                     //console.log(ret);
                     _self.totSize = ret.PageResult.totalCount;
@@ -630,7 +630,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/ncmgr/loadDevList?devname=" + rolename.devname + "&pageNo=" + pageno + "&pageSize=" + pagesize + "&buildingid=" + rolename.buildingid + "&devtype=" + rolename.devtype+"&regionid="+rolename.regionid),
+            url: encodeURI("[[@{/ncmgr/loadDevList?devname=}]]" + rolename.devname + "&pageNo=" + pageno + "&pageSize=" + pagesize + "&buildingid=" + rolename.buildingid + "&devtype=" + rolename.devtype+"&regionid="+rolename.regionid),
             success: function (ret) {
                 _self.totSize = ret.PageResult.totalCount;
                 _self.tableData = ret.PageResult.list;
@@ -645,7 +645,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/ncmgr/loadNcDevForUpdate?deviceid=" + id),
+            url: encodeURI("[[@{/ncmgr/loadNcDevForUpdate?deviceid}]]=" + id),
             success: function (ret) {
                 var dictlist = [];
                 var dict = ret.dicts;
@@ -732,7 +732,7 @@
         var token=$("meta[name='_csrf_token']").attr("value");
         $.ajax({
             type: "post",
-            url: encodeURI("/ncmgr/saveNcDev"),
+            url: encodeURI("[[@{/ncmgr/saveNcDev}]]"),
             dataType: "json",
             contentType: "application/json",
             headers: {
@@ -782,7 +782,7 @@
             $.ajax({
                 type: "get",
                 dataType: "json",
-                url: encodeURI("/ncmgr/deleteNcDev?devid=" + id),
+                url: encodeURI("[[@{/ncmgr/deleteNcDev?devid=}]]" + id),
                 success: function (ret) {
                     //console.log(ret);
                     if (ret.message == undefined) {
@@ -807,7 +807,7 @@
             $.ajax({
                 type: "get",
                 dataType: "json",
-                url:encodeURI("/ncmgr/listClean?devid=" +id),
+                url:encodeURI("[[@{/ncmgr/listClean?devid=}]]" +id),
                 success:function (ret) {
                     if (ret.message == undefined){
                         layer.msg('用户认证已过期，请重新登录',{icon: 2,time:1000});
@@ -829,7 +829,7 @@
             $.ajax({
                 type: "get",
                 dataType: "json",
-                url:encodeURI("/ncmgr/listReload?devid=" +id),
+                url:encodeURI("[[@{/ncmgr/listReload?devid=}]]" +id),
                 success:function (ret) {
                     if (ret.message == undefined){
                         layer.msg('用户认证已过期，请重新登录',{icon: 2,time:1000});
@@ -850,7 +850,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/ncmgr/getRegionBuilding?regionid=" + value),
+            url: encodeURI("[[@{/ncmgr/getRegionBuilding?regionid=}]]" + value),
             success: function (ret) {
                 var bList = [];
                 var rB = ret.reBuilding;
@@ -872,7 +872,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/ncmgr/getRegionBuilding?regionid=" + value),
+            url: encodeURI("[[@{/ncmgr/getRegionBuilding?regionid=}]]" + value),
             success: function (ret) {
                 var bfList = [];
                 var rBf = ret.reBuilding;
diff --git a/src/main/resources/templates/ncmgr/nc_devweek.html b/src/main/resources/templates/ncmgr/nc_devweek.html
index 857c611..54731e1 100644
--- a/src/main/resources/templates/ncmgr/nc_devweek.html
+++ b/src/main/resources/templates/ncmgr/nc_devweek.html
@@ -243,7 +243,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:encodeURI("/ncmgr/loaddevweekList?weekid=0&devname="),
+                url:encodeURI("[[@{/ncmgr/loaddevweekList?weekid=0&devname=}]]"),
                 success:function(ret){
                     //console.log(ret);
                     _self.totSize=ret.PageResult.totalCount;
@@ -273,7 +273,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/ncmgr/loaddevweekList?weekid="+id+"&devname="+devname+"&pageNo="+pageNo+"&pageSize="+pageSize),
+            url:encodeURI("[[@{/ncmgr/loaddevweekList?weekid="+id+"&devname=}]]"+devname+"&pageNo="+pageNo+"&pageSize="+pageSize),
             success:function(ret){
                 _self.totSize=ret.PageResult.totalCount;
                 _self.tableData=ret.PageResult.list;
@@ -288,7 +288,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/ncmgr/deleteNcdevweek?devid="+devid+"&weekid="+weekid,
+                url:"[[@{/ncmgr/deleteNcdevweek?devid=}]]"+devid+"&weekid="+weekid,
                 success:function(ret){
                     if(ret.message == undefined){
                         layer.msg('用户认证已过期，请重新登录', {icon:2,time:1000});
@@ -309,7 +309,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/ncmgr/loadforadddevweek"),
+            url:encodeURI("[[@{/ncmgr/loadforadddevweek}]]"),
             success:function(ret){
                 var weeks = [];
                 var weektimes=ret.weektime;
@@ -351,7 +351,7 @@
         var token=$("meta[name='_csrf_token']").attr("value");
         $.ajax({
             type: "POST",
-            url: encodeURI("/ncmgr/addNcdevweek?weekid="+weekid+"&devids="+devids),
+            url: encodeURI("[[@{/ncmgr/addNcdevweek?weekid=}]]"+weekid+"&devids="+devids),
             dataType: "json",
             contentType: "application/json",
             headers: {
@@ -383,7 +383,7 @@
         var reWeekId=reData;
         $.ajax({
             type:"get",
-            url: encodeURI("/ncmgr/getChosenDev?reWeekId="+reWeekId),
+            url: encodeURI("[[@{/ncmgr/getChosenDev?reWeekId=}]]"+reWeekId),
             dataType:"json",
             success:function(info){
                 var chosenDevList=[];
diff --git a/src/main/resources/templates/ncmgr/nc_time.html b/src/main/resources/templates/ncmgr/nc_time.html
index 422e01c..5a343a4 100644
--- a/src/main/resources/templates/ncmgr/nc_time.html
+++ b/src/main/resources/templates/ncmgr/nc_time.html
@@ -233,7 +233,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:encodeURI("/ncmgr/loadTimeList?timename="),
+                url:encodeURI("[[@{/ncmgr/loadTimeList?timename=}]]"),
                 success:function(ret){
                     //console.log(ret);
                     _self.totSize=ret.PageResult.totalCount;
@@ -257,7 +257,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/ncmgr/loadTimeList?timename="+timename+"&pageNo="+pageNo+"&pageSize="+pageSize),
+            url:encodeURI("[[@{/ncmgr/loadTimeList?timename=}]]"+timename+"&pageNo="+pageNo+"&pageSize="+pageSize),
             success:function(ret){
                 _self.totSize=ret.PageResult.totalCount;
                 _self.tableData=ret.PageResult.list;
@@ -272,7 +272,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/ncmgr/deleteNcTime?timeid="+timeid,
+                url:"[[@{/ncmgr/deleteNcTime?timeid=}]]"+timeid,
                 success:function(ret){
                     if(ret.message == undefined){
                         layer.msg('用户认证已过期，请重新登录', {icon:2,time:1000});
@@ -298,7 +298,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/ncmgr/loadNcTimeForUpdate?timeid="+id),
+            url:encodeURI("[[@{/ncmgr/loadNcTimeForUpdate?timeid=}]]"+id),
             success:function(ret){
                 if (ret.time!=null){
                     //console.log(ret.oper);
@@ -319,10 +319,10 @@
     function saveData(_that,formdata,formName){
         var url = null;
         if(vue.timetitile == "添加时间段"){
-            url = encodeURI("/ncmgr/addNcTime");
+            url = encodeURI("[[@{/ncmgr/addNcTime}]]");
         }
         if(vue.timetitile == "修改时间段"){
-            url = encodeURI("/ncmgr/updateNcTime")
+            url = encodeURI("[[@{/ncmgr/updateNcTime}]]")
         }
         var token=$("meta[name='_csrf_token']").attr("value");
         $.ajax({
diff --git a/src/main/resources/templates/ncmgr/nc_timegrp.html b/src/main/resources/templates/ncmgr/nc_timegrp.html
index 43f42eb..b70e045 100644
--- a/src/main/resources/templates/ncmgr/nc_timegrp.html
+++ b/src/main/resources/templates/ncmgr/nc_timegrp.html
@@ -313,7 +313,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/ncmgr/loadTimegrpList?timegrpname=",
+                url:"[[@{/ncmgr/loadTimegrpList?timegrpname=}]]",
                 success:function(ret){
                     //console.log(ret);
                     _self.totSize=ret.PageResult.totalCount;
@@ -349,7 +349,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/ncmgr/loadTimegrpList?timegrpname="+timegrpname+"&pageNo="+pageno+"&pageSize="+pagesize),
+            url:encodeURI("[[@{/ncmgr/loadTimegrpList?timegrpname=}]]"+timegrpname+"&pageNo="+pageno+"&pageSize="+pagesize),
             success:function(ret){
                 _self.totSize=ret.PageResult.totalCount;
                 _self.tableData=ret.PageResult.list;
@@ -373,7 +373,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/ncmgr/loadNcTimeGrpForUpdate?timegrpid="+id),
+            url:encodeURI("[[@{/ncmgr/loadNcTimeGrpForUpdate?timegrpid=}]]"+id),
             success:function(ret){
                 var timelist = [];
                 var times=ret.timelist;
@@ -397,10 +397,10 @@
     function saveData(_that,formdata,formName) {
         var url;
         if(vue.timegrptitle == "添加时间组"){
-            url = encodeURI("/ncmgr/addNcTimegrp");
+            url = encodeURI("[[@{/ncmgr/addNcTimegrp}]]");
         }
         if(vue.timegrptitle == "修改时间组"){
-            url = encodeURI("/ncmgr/updateNcTimegrp");
+            url = encodeURI("[[@{/ncmgr/updateNcTimegrp}]]");
         }
         var timeid1=formdata.timeid1;
         var timeid2=formdata.timeid2;
@@ -454,7 +454,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/ncmgr/deleteNcTimegrp?timegrpid="+id,
+                url:"[[@{/ncmgr/deleteNcTimegrp?timegrpid=}]]"+id,
                 success:function(ret){
                     //console.log(ret);
                     if(ret.message == undefined){
diff --git a/src/main/resources/templates/ncmgr/nc_weektime.html b/src/main/resources/templates/ncmgr/nc_weektime.html
index 01490cb..4ff6410 100644
--- a/src/main/resources/templates/ncmgr/nc_weektime.html
+++ b/src/main/resources/templates/ncmgr/nc_weektime.html
@@ -332,7 +332,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/ncmgr/loadweektimeList?weektimename=",
+                url:"[[@{/ncmgr/loadweektimeList?weektimename=}]]",
                 success:function(ret){
                     //console.log(ret);
                     _self.totSize=ret.PageResult.totalCount;
@@ -368,7 +368,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/ncmgr/loadweektimeList?weektimename="+weektimename+"&pageNo="+pageno+"&pageSize="+pagesize),
+            url:encodeURI("[[@{/ncmgr/loadweektimeList?weektimename=}]]"+weektimename+"&pageNo="+pageno+"&pageSize="+pagesize),
             success:function(ret){
                 _self.totSize=ret.PageResult.totalCount;
                 _self.tableData=ret.PageResult.list;
@@ -383,7 +383,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/ncmgr/loadNcweektimeForUpdate?weektimeid="+id),
+            url:encodeURI("[[@{/ncmgr/loadNcweektimeForUpdate?weektimeid=}]]"+id),
             success:function(ret){
                 var timelist = [];
                 var times=ret.timegrp;
@@ -407,10 +407,10 @@
     function saveData(_that,formdata,formName) {
         var url;
         if(vue.weektimetitle == "添加时间周"){
-            url = encodeURI("/ncmgr/addNcweektime");
+            url = encodeURI("[[@{/ncmgr/addNcweektime}]]");
         }
         if(vue.weektimetitle == "修改时间周"){
-            url = encodeURI("/ncmgr/updateNcweektime");
+            url = encodeURI("[[@{/ncmgr/updateNcweektime}]]");
         }
         var timeid1=formdata.day1grpid;
         var timeid2=formdata.day2grpid;
@@ -463,7 +463,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/ncmgr/deleteNcweektime?weektimeid="+id,
+                url:"[[@{/ncmgr/deleteNcweektime?weektimeid=}]]"+id,
                 success:function(ret){
                     //console.log(ret);
                     if(ret.message == undefined){
diff --git a/src/main/resources/templates/query/tdoorstream.html b/src/main/resources/templates/query/tdoorstream.html
index e241a30..4b4e74b 100644
--- a/src/main/resources/templates/query/tdoorstream.html
+++ b/src/main/resources/templates/query/tdoorstream.html
@@ -1,6 +1,6 @@
 <div class="layui-card">
     <div class="layui-card-header">
-        <h2 class="header-title">数据中心</h2>
+        <h2 class="header-title">设备流水查询</h2>
         <span class="layui-breadcrumb pull-right">
           <a href="#">数据中心</a>
           <a><cite>设备流水查询</cite></a>
@@ -254,7 +254,7 @@
             $.ajax({
                 type : "get",
                 dataType : "json",
-                url : encodeURI("/query/getSearchFactoryIdList"),
+                url : encodeURI("[[@{/query/getSearchFactoryIdList}]]"),
                 success : function(ret) {
                     var dtllist = [];
                     var dtlStatus = ret.dtlStatus;
@@ -315,7 +315,7 @@
             return;
         }
         //console.log(factoryid+stuempno);
-        var	url =encodeURI( "/query/exportexcel?&startTranDate="+starttransdate+"&endTranDate="
+        var	url =encodeURI( "[[@{/query/exportexcel?&startTranDate=}]]"+starttransdate+"&endTranDate="
             +endtransdate+"&stuempno="+stuempno+"&custname="+custname+"&buildingid="+buildingid+"&regionid="+regionid+"&doorName="+doorname
             +"&streamstatus="+dtlStatus+"&factoryId="+factoryid)
         window.open(url);
@@ -336,7 +336,7 @@
         $.ajax({
             type : "get",
             dataType : "json",
-            url : encodeURI("/query/getSearchDoorStreamList?&startTranDate="+starttransdate+"&endTranDate="+endtransdate+
+            url : encodeURI("[[@{/query/getSearchDoorStreamList?&startTranDate=}]]"+starttransdate+"&endTranDate="+endtransdate+
                 "&stuempno="+stuempno+"&custname="+custname+"&buildingid="+buildingid+"&doorName="+doorname+"&streamstatus="+dtlStatus+
                 "&factoryId="+factoryid +"&pageNo="+pageno+"&pageSize="+pagesize+"&regionid="+regionid),
             success : function(ret) {
@@ -393,7 +393,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/ncmgr/getRegionBuilding?regionid=" + value),
+            url: encodeURI("[[@{/ncmgr/getRegionBuilding?regionid=}]]" + value),
             success: function (ret) {
                 var bList = [];
                 var rB = ret.reBuilding;
diff --git a/src/main/resources/templates/system/building.html b/src/main/resources/templates/system/building.html
index 01bdd0f..6e4d335 100644
--- a/src/main/resources/templates/system/building.html
+++ b/src/main/resources/templates/system/building.html
@@ -247,7 +247,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/system/loadBuildingList",
+                url:"[[@{/system/loadBuildingList}]]",
                 success:function(ret){
                     _self.totSize=ret.pageResult.totalCount;
                     _self.tableData=ret.pageResult.list;
@@ -272,7 +272,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/system/loadBuildingList?regionid="
+            url:encodeURI("[[@{/system/loadBuildingList?regionid=}]]"
                 +regionid+"&buildingname="+buildingname
                 +"&pageNo="+pageno+"&pageSize="+pagesize),
             success:function(ret){
@@ -286,7 +286,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/system/loadBuildingForUpdate?buildingid=" + id),
+            url: encodeURI("[[@{/system/loadBuildingForUpdate?buildingid=}]]" + id),
             success: function (ret) {
                 var regionslist = [];
                 var rl = ret.regionslist;
@@ -312,10 +312,10 @@
     function saveData(_that,formdata,formName) {
         var url = null;
         if(vue.buildingtitile == "添加楼栋"){
-            url = encodeURI("/system/addBuilding");
+            url = encodeURI("[[@{/system/addBuilding}]]");
         }
         if(vue.buildingtitile == "修改楼栋"){
-            url = encodeURI("/system/updateBuilding")
+            url = encodeURI("[[@{/system/updateBuilding}]]")
         }
         var token=$("meta[name='_csrf_token']").attr("value");
         $.ajax({
@@ -347,7 +347,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/system/deleteBuilding?buildingid="+buildingid,
+                url:"[[@{/system/deleteBuilding?buildingid=}]]"+buildingid,
                 success:function(ret){
                     if(ret.message == undefined){
                         layer.msg('用户认证已过期，请重新登录', {icon:2,time:1000});
diff --git a/src/main/resources/templates/system/dictionary.html b/src/main/resources/templates/system/dictionary.html
index 9c77518..22c6740 100644
--- a/src/main/resources/templates/system/dictionary.html
+++ b/src/main/resources/templates/system/dictionary.html
@@ -233,7 +233,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/system/getDictionary",
+                url:"[[@{/system/getDictionary}]]",
                 success:function(ret){
                     _self.totSize=ret.pageResult.totalCount;
                     _self.tableData=ret.pageResult.list;
@@ -247,7 +247,7 @@
         $.ajax({
             type:"get",
             dataType:"json",
-            url:encodeURI("/system/getDictionary?dicttype="
+            url:encodeURI("[[@{/system/getDictionary?dicttype=}]]"
                 +dicttype+"&dictcaption="+dictcaption
                 +"&pageNo="+pageno+"&pageSize="+pagesize),
             success:function(ret){
@@ -264,7 +264,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/system/saveDictionary?&dicttype="+dict.dicttype
+            url: encodeURI("[[@{/system/saveDictionary?&dicttype=}]]"+dict.dicttype
                 +"&dicttypename="+dict.dicttypename+"&dictval="+dict.dictval+"&dictcaption="+dict.dictcaption),
 
             success: function (data) {
@@ -287,7 +287,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/system/updateDictionary?&dicttype="+dict.dicttype
+            url: encodeURI("[[@{/system/updateDictionary?&dicttype=}]]"+dict.dicttype
                 +"&dicttypename="+dict.dicttypename+"&dictval="+dict.dictval+"&dictcaption="+dict.dictcaption
                 +"&oriengaltype="+oriengal[0]+"&oriengalval="+oriengal[1]),
 
@@ -312,7 +312,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/system/saveDictionary?&dicttype="+dict.dicttype
+            url: encodeURI("[[@{/system/saveDictionary?&dicttype=}]]"+dict.dicttype
                 +"&dicttypename="+dict.dicttypename+"&dictval="+dict.dictval+"&dictcaption="+dict.dictcaption),
 
             success: function (data) {
@@ -348,7 +348,7 @@
         $.ajax({
             type : "get",
             dataType : "json",
-            url : encodeURI("/system/getDictionaryType"),
+            url : encodeURI("[[@{/system/getDictionaryType}]]"),
             success : function(ret) {
                 var tlist = [];
                 var ulist=[];
diff --git a/src/main/resources/templates/system/function/form.html b/src/main/resources/templates/system/function/form.html
index 94ef8cc..fa382a5 100755
--- a/src/main/resources/templates/system/function/form.html
+++ b/src/main/resources/templates/system/function/form.html
@@ -51,7 +51,7 @@
                 var msg = "";
                 $.ajax({
                     type: "GET",
-                    url: '/function/checkname',
+                    url: '[[@{/function/checkname}]]',
                     async: false,
                     data: {
                         name: e,
@@ -69,7 +69,7 @@
             }
         });
 
-        var url = '/function/add';
+        var url = '[[@{/function/add}]]';
         // 回显user数据
         var func = admin.getTempData('t_func');
         if (func) {
diff --git a/src/main/resources/templates/system/function/index.html b/src/main/resources/templates/system/function/index.html
index 4071d7d..d2c88d2 100755
--- a/src/main/resources/templates/system/function/index.html
+++ b/src/main/resources/templates/system/function/index.html
@@ -29,7 +29,7 @@
         // 渲染表格
         table.render({
             elem: '#table',
-            url: '/function/list',
+            url: '[[@{/function/list}]]',
             page: true,
             cols: [
                 [
@@ -83,7 +83,7 @@
             admin.putTempData('t_func', data);
             admin.popupCenter({
                 title: title,
-                path: '/function/loadadd',
+                path: '[[@{/function/loadadd}]]',
                 finish: function () {
                     table.reload('table', {});
                 }
@@ -95,7 +95,7 @@
             admin.putTempData('t_func', data);
             admin.popupCenter({
                 title: title,
-                path: '/function/loadsubadd',
+                path: '[[@{/function/loadsubadd}]]',
                 finish: function () {
                     table.reload('table', {});
                 }
@@ -108,7 +108,7 @@
             admin.popupCenter({
                 title: title,
                 area:'70%',
-                path: '/function/loadres?functionid='+functionid
+                path: '[[@{/function/loadres?functionid=}]]'+functionid
             });
         };
         let showAddResModelSub = function (functionid) {
@@ -116,7 +116,7 @@
             admin.putTempData('functionid', functionid);
             admin.popupCenter({
                 title: title,
-                path: '/function/loadresadd',
+                path: '[[@{/function/loadresadd}]]',
                 finish: function () {
                     table.reload('table', {});
                 }
@@ -146,7 +146,7 @@
                 layer.close(i);
                 layer.load(2);
                 let token = $("meta[name='_csrf_token']").attr("value");
-                admin.go('/function/delfunc', {
+                admin.go('[[@{/function/delfunc}]]', {
                     funcid: data.id,
                     _csrf:token
                 }, function (data) {
diff --git a/src/main/resources/templates/system/function/resform.html b/src/main/resources/templates/system/function/resform.html
index 78f7747..4ac8b98 100755
--- a/src/main/resources/templates/system/function/resform.html
+++ b/src/main/resources/templates/system/function/resform.html
@@ -42,7 +42,7 @@
         var form = layui.form;
         form.render('select');
         form.render('radio');
-        var url = '/function/addres';
+        var url = '[[@{/function/addres}]]';
         // 回显user数据
         var func = admin.getTempData('t_res');
         if (func) {
@@ -75,7 +75,7 @@
                         admin.finishPopupCenter();
                     } else if (result.code == 401) {
                         layer.msg(result.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
+                            location.replace('[[@{/login}]]');
                         }, 1000);
                         return;
                     } else {
diff --git a/src/main/resources/templates/system/function/reslist.html b/src/main/resources/templates/system/function/reslist.html
index d95cbfe..54a478f 100755
--- a/src/main/resources/templates/system/function/reslist.html
+++ b/src/main/resources/templates/system/function/reslist.html
@@ -13,7 +13,7 @@
         let func = admin.getTempData('functionid');
         table.render({
             elem: '#restable',
-            url: '/function/reslist?functionid=' + func,
+            url: '[[@{/function/reslist?functionid=}]]' + func,
             cols: [
                 [
                     {field: 'id', title: '资源ID', width: 80, fixed: 'left', sort: true},
@@ -50,7 +50,7 @@
             admin.putTempData('t_data',data);
             admin.popupCenter({
                 title: title,
-                path: '/function/loadresadd',
+                path: '[[@{/function/loadresadd}]]',
                 finish: function () {
                     table.reload('table', {});
                 }
@@ -61,7 +61,7 @@
                 layer.close(i);
                 layer.load(2);
                 let token = $("meta[name='_csrf_token']").attr("value");
-                admin.go('/function/delres', {
+                admin.go('[[@{/function/delres}]]', {
                     resid: data.id,
                     _csrf:token
                 }, function (data) {
diff --git a/src/main/resources/templates/system/function/subform.html b/src/main/resources/templates/system/function/subform.html
index 479452c..f04a15e 100755
--- a/src/main/resources/templates/system/function/subform.html
+++ b/src/main/resources/templates/system/function/subform.html
@@ -54,7 +54,7 @@
         var form = layui.form;
         form.render('select');
         form.render('radio');
-        var url = '/function/add';
+        var url = '[[@{/function/add}]]';
         // 回显user数据
         var func = admin.getTempData('t_func');
         if (func) {
@@ -87,7 +87,7 @@
                         admin.finishPopupCenter();
                     } else if (result.code == 401) {
                         layer.msg(result.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
+                            location.replace('[[@{/login}]]');
                         }, 1000);
                         return;
                     } else {
diff --git a/src/main/resources/templates/system/operator.html b/src/main/resources/templates/system/operator.html
index 2279473..def792d 100644
--- a/src/main/resources/templates/system/operator.html
+++ b/src/main/resources/templates/system/operator.html
@@ -58,6 +58,11 @@
                             width="140">
                     </el-table-column>
                     <el-table-column
+                            prop="opername"
+                            label="操作员名称"
+                            width="140">
+                    </el-table-column>
+                    <el-table-column
                             prop="opertype"
                             label="操作员类别"
                             width="140"
@@ -87,7 +92,7 @@
                             <button type="button" class="btn btn-success btn-xs" title="重置密码" @click="resetPwd(scope.row.operid)">重置</button>
                             <button type="button" class="btn btn-danger btn-xs" title="删除操作员" @click="delOperator(scope.row.operid)">删除</button>
                             <button type="button" class="btn btn-info btn-xs" title="分配楼栋"
-                                    @click="allocationBulding(scope.row.deviceid)" v-if="scope.row.opertype=='L'">分配楼栋
+                                    @click="allotBuilding(scope.row.operid,scope.row.opername)" v-if="scope.row.opertype=='L'">分配楼栋
                             </button>
                         </template>
                     </el-table-column>
@@ -215,6 +220,45 @@
                     <el-button type="primary" @click="saveOperator('operatorDiaForm')">确 定</el-button>
                 </div>
             </el-dialog>
+
+
+            <!--分配楼栋-->
+            <el-dialog :title="buildingTitle" :visible.sync="dlgAllotBuildingVisible" size="mini"top="30px">
+                <el-form ref="operBuildingDiaform" :model="operBuildingDiaform" :rules="rules" label-width="100px" >
+                    <el-form-item label="操作员:" prop="operid">
+                        <el-col  :span="24">
+                            <el-select v-model="operBuildingDiaform.operid">
+                                <el-option
+                                        v-for="operid in operlist"
+                                        :key="operid.value"
+                                        :label="operid.label"
+                                        :value="operid.value"
+                                >
+                                </el-option>
+                            </el-select>
+                        </el-col>
+                    </el-form-item>
+                    <el-form-item label="选择楼栋:" prop="buildings">
+                        <template>
+                            <el-transfer
+                                    v-model="allotbuilding"
+                                    :data="buildingList"
+                                    :target-keys="selectBuildingList"
+                                    :list-style="listStyle"
+                                    :operations="['移除','选择']"
+                                    :titles="['待选楼栋','已选楼栋']"
+                                    filterable
+                                    @on-change="buildingChange">
+                            </el-transfer>
+                        </template>
+                    </el-form-item>
+                </el-form>
+
+                <div slot="footer" class="dialog-footer">
+                    <el-button @click="cancelBuildingOper('operBuildingDiaform')">取 消</el-button>
+                    <el-button type="primary" @click="saveBuildingOper">确 定</el-button>
+                </div>
+            </el-dialog>
         </div>
     </div>
 </div>
@@ -248,22 +292,45 @@
                 email:'',
                 realname:''
             },
+            buildingTitle:'',
+            dlgAllotBuildingVisible:false,
+            allotbuilding:[],
+            buildingList:[],
+            selectBuildingList:[],
+            listStyle: {
+                width: '318px',
+                height: '400px'
+            },
+            operBuildingDiaform:{
+                operid:'',
+                buildingids:[]
+            },
+            operlist:[],
+
             rules:{
                 operid:[
                     {required:true,message:'请输入操作员编号',trigger:'blur'},
                 ],
                 opercode:[
                     {required:true,message:'请输入登陆名',trigger:'blur'},
+                    { min: 2, max: 20, message: '长度在 2 到 20 个字符', trigger: 'blur' }
                 ],
                 opername:[
                     {required:true,message:'请输入操作员名称',trigger:'blur'},
+                    { min: 2, max: 20, message: '长度在 2 到 20 个字符', trigger: 'blur' }
                 ],
                 opertype: [
                     {required: true, message: '请选择操作员类别', trigger: 'blur'}
                 ],
                 roleid: [
                     {required: true, message: '请选择角色', trigger: 'blur'}
-                ]
+                ],
+                tel: [
+                    { min: 11, max: 11, message: '11位数字' }
+                ],
+                realname:[
+                    { min: 2, max: 20, message: '长度在 2 到 20 个字符', trigger: 'blur' }
+                ],
             },
             operatortitile:'添加操作员(默认密码为123456)',
         },
@@ -344,6 +411,53 @@
             },
             resetPwd:function (operid) {
                 resetpwd(operid);
+            },
+            allotBuilding:function (operid,opername) {
+                this.buildingTitle="正在为["+opername+"]分配设备"
+                this.operlist.push({
+                    value: operid,
+                    label: opername
+                })
+                this.operBuildingDiaform.operid = operid
+                getBuildingData(this,operid);
+                this.dlgAllotBuildingVisible=true;
+
+            },
+            buildingChange:function (newTargetKeys) {
+                this.selectBuildingList=newTargetKeys;
+            },
+            cancelBuildingOper:function () {
+                this.allotbuilding=[];
+                this.buildingList=[];
+                this.operlist=[];
+                this.dlgAllotBuildingVisible=false;
+            },
+            saveBuildingOper:function () {
+                var _that = this;
+                var token=$("meta[name='_csrf_token']").attr("value");
+                var operid = this.operBuildingDiaform.operid;
+                alert(operid)
+                $.ajax({
+                    type: "POST",
+                    url: "[[@{/system/saveOperBuildingBind?operid=}]]" + operid,
+                    dataType: "json",
+                    contentType: "application/json",
+                    headers: {
+                        'Accept': 'application/json',
+                        'Content-Type': 'application/json',
+                        'X-CSRF-TOKEN':token,
+                    },
+                    data: JSON.stringify(_that.allotbuilding),
+                    success: function (data) {
+                        if (data.okFlag==1){
+                            _that.dlgAllotBuildingVisible=false;
+                            layer.msg('分配设备成功', {icon: 1,time:2000});
+                            _that.selectBuildingList=[];
+                        }else{
+                            layer.msg(data.result, {icon: 2,time:2000});
+                        }
+                    }
+                });
             }
         },
         created:function(){
@@ -351,7 +465,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:encodeURI("/operator/loadOperatorList"),
+                url:encodeURI("[[@{/operator/loadOperatorList}]]"),
                 success:function(ret){
                     //console.log(ret);
                     _self.totSize=ret.PageResult.totalCount;
@@ -369,7 +483,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/operator/loadOperatorList?operid="+operid+"&realname=" + realname + "&pageNo=" + pageno + "&pageSize=" + pagesize),
+            url: encodeURI("[[@{/operator/loadOperatorList?operid=}]]"+operid+"&realname=" + realname + "&pageNo=" + pageno + "&pageSize=" + pagesize),
             success: function (ret) {
                 _self.totSize = ret.PageResult.totalCount;
                 _self.tableData = ret.PageResult.list;
@@ -385,7 +499,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/operator/deleteOperator?operid="+operid,
+                url:"[[@{/operator/deleteOperator?operid=}]]"+operid,
                 success:function(ret){
                     if(ret.message == undefined){
                         layer.msg('用户认证已过期，请重新登录', {icon:2,time:1000});
@@ -408,7 +522,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/operator/loadOperatorForUpdate?operid=" + id),
+            url: encodeURI("[[@{/operator/loadOperatorForUpdate?operid=}]]" + id),
             success: function (ret) {
                 var opertypelist = [];
                 var opertypes = ret.opertypes;
@@ -463,10 +577,10 @@
     function saveData(_that,formdata,formName){
         var url = null;
         if(vue.operatortitile == "添加操作员(默认密码为123456)"){
-            url = encodeURI("/operator/addOperator");
+            url = encodeURI("[[@{/operator/addOperator}]]");
         }
         if(vue.operatortitile == "修改操作员(默认密码为123456)"){
-            url = encodeURI("/operator/updateOperator")
+            url = encodeURI("[[@{/operator/updateOperator}]]")
         }
         var token=$("meta[name='_csrf_token']").attr("value");
         $.ajax({
@@ -499,7 +613,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/operator/resetpwd?operid="+operid,
+                url:"[[@{/operator/resetpwd?operid=}]]"+operid,
                 success:function(ret){
                     //console.log(ret);
                     if(ret.code == undefined){
@@ -518,6 +632,57 @@
         });
     };
 
+    function getBuildingData(_that,operid) {
+        $.ajax({
+            type:"get",
+            dataType:"json",
+            url:encodeURI("[[@{/system/getBuildingList?operid=}]]"+operid),
+            success:function(ret){
+                if (ret.flag==1){
+                    layer.msg(ret.result, {icon: 2,time:1000});
+                    return;
+                }else{
+                    var srcdata = [];
+                    var trgdata=[];
+                    var buildinglist = ret.buildinglist;
+
+                    for (var i = 0; i < buildinglist.length; i++) {
+                        srcdata.push({
+                            key: buildinglist[i].regionid+'#'+buildinglist[i].buildingid,
+                            label: buildinglist[i].regionname+'->'+buildinglist[i].buildingname,
+
+                        });
+                    }
+                    var buildinglisted = ret.buildinglisted;
+                    for (var i = 0; i < buildinglisted.length; i++) {
+                        trgdata.push(buildinglisted[i].regionid+'#'+buildinglisted[i].buildingid);
+                    }
+
+                    _that.buildingList=srcdata;
+                    _that.allotbuilding=trgdata;
+                }
+            }
+        })
+
+    }
 
 
-</script>
\ No newline at end of file
+
+</script>
+<style lang="scss">
+    .el-checkbox-group.el-transfer-panel__list{
+        height:365px;
+    }
+
+    .el-dialog {
+        width: 900px;
+    }
+    .el-transfer-panel{
+        width:347px;
+    }
+    .el-transfer-panel__body{
+        height:360px;
+        width:345px;
+    }
+
+</style>
\ No newline at end of file
diff --git a/src/main/resources/templates/system/region.html b/src/main/resources/templates/system/region.html
index 1588b6f..523bc38 100644
--- a/src/main/resources/templates/system/region.html
+++ b/src/main/resources/templates/system/region.html
@@ -285,7 +285,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:encodeURI("/system/loadRegionList?regionname="),
+                url:encodeURI("[[@{/system/loadRegionList?regionname=}]]"),
                 success:function(ret){
                     //console.log(ret);
                     _self.totSize=ret.PageResult.totalCount;
@@ -303,7 +303,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/system/loadRegionList?regionname=" + regionname + "&pageNo=" + pageno + "&pageSize=" + pagesize),
+            url: encodeURI("[[@{/system/loadRegionList?regionname=}]]" + regionname + "&pageNo=" + pageno + "&pageSize=" + pagesize),
             success: function (ret) {
                 _self.totSize = ret.PageResult.totalCount;
                 _self.tableData = ret.PageResult.list;
@@ -319,7 +319,7 @@
             $.ajax({
                 type:"get",
                 dataType:"json",
-                url:"/system/deleteRegion?regionid="+regionid,
+                url:"[[@{/system/deleteRegion?regionid=}]]"+regionid,
                 success:function(ret){
                     if(ret.message == undefined){
                         layer.msg('用户认证已过期，请重新登录', {icon:2,time:1000});
@@ -342,7 +342,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/system/loadRegionForUpdate?regionid=" + id),
+            url: encodeURI("[[@{/system/loadRegionForUpdate?regionid=}]]" + id),
             success: function (ret) {
                 var dictlist = [];
                 var parentlist = [];
@@ -391,10 +391,10 @@
     function saveData(_that,formdata,formName){
         var url = null;
         if(vue.regiontitile == "添加区域"){
-            url = encodeURI("/system/addRegion");
+            url = encodeURI("[[@{/system/addRegion}]]");
         }
         if(vue.regiontitile == "修改区域"){
-            url = encodeURI("/system/updateRegion")
+            url = encodeURI("[[@{/system/updateRegion}]]")
         }
         var token=$("meta[name='_csrf_token']").attr("value");
         $.ajax({
@@ -426,7 +426,7 @@
         $.ajax({
             type: "get",
             dataType: "json",
-            url: encodeURI("/system/getFregion?level=" + value),
+            url: encodeURI("[[@{/system/getFregion?level=}]]" + value),
             success: function (ret) {
                 var fList = [];
                 var parentRegion = ret.parentRegion;
diff --git a/src/main/resources/templates/system/role/form.html b/src/main/resources/templates/system/role/form.html
index fcfcbf3..2595cd6 100755
--- a/src/main/resources/templates/system/role/form.html
+++ b/src/main/resources/templates/system/role/form.html
@@ -26,7 +26,7 @@
         var layer = layui.layer;
         var admin = layui.admin;
         var form = layui.form;
-        var url = '/role/add';
+        var url = '[[@{/role/add}]]';
         // 回显user数据
         var func = admin.getTempData('t_func');
         if (func) {
diff --git a/src/main/resources/templates/system/role/func.html b/src/main/resources/templates/system/role/func.html
index 48d1ecc..fff2149 100755
--- a/src/main/resources/templates/system/role/func.html
+++ b/src/main/resources/templates/system/role/func.html
@@ -31,7 +31,7 @@
             };
             $.fn.zTree.init($("#funclist"), menuSetting, nodes);
         }
-        admin.dgo('/role/func', {
+        admin.dgo('[[@{/role/func}]]', {
             roleId: func,
         }, function (data) {
             debugger
@@ -62,7 +62,7 @@
             }
             let idStr = ids.toString();
             let token = $("meta[name='_csrf_token']").attr("value");
-            admin.go('/role/addfunc', {
+            admin.go('[[@{/role/addfunc}]]', {
                 roleId: func,
                 funcs: idStr,
                 _csrf: token,
diff --git a/src/main/resources/templates/system/role/index.html b/src/main/resources/templates/system/role/index.html
index 029e3ef..f92912f 100644
--- a/src/main/resources/templates/system/role/index.html
+++ b/src/main/resources/templates/system/role/index.html
@@ -27,7 +27,7 @@
         // 渲染表格
         table.render({
             elem: '#roletable',
-            url: '/role/list',
+            url: '[[@{/role/list}]]',
             page: true,
             cols: [
                 [
@@ -60,7 +60,7 @@
             admin.putTempData('t_func', data);
             admin.popupCenter({
                 title: title,
-                path: '/role/loadadd',
+                path: '[[@{/role/loadadd}]]',
                 finish: function () {
                     table.reload('roletable', {});
                 }
@@ -72,7 +72,7 @@
             admin.popupCenter({
                 title: title,
                 area:['400px','600px'],
-                path: '/role/loadfunc'
+                path: '[[@{/role/loadfunc}]]'
             });
         };
         // 工具条点击事件
@@ -93,7 +93,7 @@
                 layer.close(i);
                 layer.load(2);
                 let token = $("meta[name='_csrf_token']").attr("value");
-                admin.go('/role/del', {
+                admin.go('[[@{/role/del}]]', {
                     roleid: data.roleId,
                     _csrf: token
                 }, function (data) {
@@ -103,7 +103,7 @@
                         layer.msg(data.msg, {icon: 1});
                     } else if (data.code == 401) {
                         layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
+                            location.replace('[[@{/login}]]');
                         }, 1000);
                         return;
                     } else {
diff --git a/src/main/resources/templates/system/shop/config.html b/src/main/resources/templates/system/shop/config.html
deleted file mode 100644
index 9bc1ccc..0000000
--- a/src/main/resources/templates/system/shop/config.html
+++ /dev/null
@@ -1,285 +0,0 @@
-<div class="layui-card">
-    <div class="layui-card-header">
-        <h2 class="header-title">商户支付能力管理</h2>
-        <span class="layui-breadcrumb pull-right">
-          <a href="#">商户中心</a>
-          <a><cite>商户支付能力管理</cite></a>
-        </span>
-    </div>
-    <div class="layui-card-body">
-        <div class="layui-row">
-            <div class="layui-col-xs5 layui-col-md3">
-                <div class="layui-card">
-                    <div class="layui-card-header">
-                        商户树<span style="font-size: 12px;">（双击结算商户查询）</span>
-                    </div>
-                    <div class="layui-card-body layui-show"
-                         style="background-color: #D7F9F7;max-height: 560px;overflow:auto;">
-                        <ul id="shopacctree" class="ztree"></ul>
-                    </div>
-                </div>
-            </div>
-            <div class="layui-col-xs7 layui-col-md9">
-                <div class="layui-card" style="min-height: 600px;">
-                    <div class="layui-card-body">
-                        <div class="layui-form toolbar">
-                            支付方式：
-                            <select id="search-sourceType">
-                                <option value=""> 全部</option>
-                                <option th:each="pt:${paytypelist}" th:value="${pt.sourceType}"
-                                        th:text="${pt.paydesc}"></option>
-                            </select>&emsp;
-                            <button id="btn-search-shoppaytype" class="layui-btn icon-btn" data-type="search"><i class="layui-icon">&#xe615;</i>搜索
-                            </button>
-                            <button id="btn-add-shoppaytype" class="layui-btn icon-btn" data-type="add"><i class="layui-icon">&#xe654;</i>新
-                                增
-                            </button>
-                            <button id="btn-reset-shoppaytype" class="layui-btn layui-btn-primary" data-type="reset"><i
-                                    class="layui-icon"></i>清 空
-                            </button>
-                        </div>
-                        <table class="layui-table" id="shopPaytypeTable" lay-filter="shopPaytypeTable-filter"></table>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<!-- 表格状态列 -->
-<script type="text/html" id="shop-consumeenable-tpl-state">
-    <input type="checkbox" lay-filter="shop-consumeenable-tpl-state" value="{{d.shopaccno}}" def-sourceType="{{d.paytype}}" lay-skin="switch" lay-text="启用|关闭"
-           {{d.consumeEnable==true?'checked':''}}/>
-</script>
-<script type="text/html" id="shop-anonymousenable-tpl-state">
-    {{# if(d.consumeEnable == true ){ }}
-    <input type="checkbox" lay-filter="shop-anonymousenable-tpl-state" value="{{d.shopaccno}}" def-sourceType="{{d.paytype}}" lay-skin="switch"
-           lay-text="启用|关闭"
-           {{(d.consumeEnable==true && d.anonymousEnable==true)?'checked':''}}/>
-    {{# }else{ }}
-    <input type="checkbox" lay-filter="shop-anonymousenable-tpl-state" value="{{d.shopaccno}}" def-sourceType="{{d.paytype}}" lay-skin="switch"
-           lay-text="启用|关闭"
-           {{(d.consumeEnable==true && d.anonymousEnable==true)?'checked':''}} disabled/>
-    {{# } }}
-</script>
-<script type="text/html" id="shop-reverseenable-tpl-state">
-    <input type="checkbox" lay-filter="shop-reverseenable-tpl-state" value="{{d.shopaccno}}" def-sourceType="{{d.paytype}}" lay-skin="switch" lay-text="启用|关闭"
-           {{d.reverseEnable==true?'checked':''}}/>
-</script>
-
-<script>
-    layui.use(['form', 'table', 'layer', 'admin', 'element'], function () {
-        var form = layui.form;
-        var table = layui.table;
-        var admin = layui.admin;
-        form.render('select');
-        var initTree = function (nodes) {
-            var menuSetting = {
-                view: {
-                    dblClickExpand: false,
-                    showLine: true,
-                    showIcon: true,
-                    selectedMulti: false
-                },
-                data: {
-                    simpleData: {
-                        enable: true
-                    }
-                },
-                callback: {
-                    onDblClick: ondblclick
-                }
-            };
-            $.fn.zTree.init($("#shopacctree"), menuSetting, nodes);
-        }
-        admin.dgo('/shop/shopacctree', {}, function (data) {
-            if (data.code == 200) {
-                initTree(data.data);
-            } else if (data.code == 401) {
-                layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                    location.replace('/login');
-                }, 1000);
-                return;
-            } else {
-                layer.msg(data.msg, {icon: 2, time: 2000});
-            }
-        }, function (ret) {
-            console.log(ret);
-            layer.msg('查询商户树失败了，请稍后再试', {icon: 2});
-        });
-
-        $('#btn-reset-shoppaytype').click(function () {
-            $("#search-sourceType").val("");
-            form.render('select');
-        });
-        $('#btn-search-shoppaytype').click(function(){
-            var ptype = $("#search-sourceType").val();
-            table.reload('shopPaytypeTable', {where: {paytype: ptype, shopaccno:""}, page: {curr: 1}});
-        });
-
-        function ondblclick(event, treeId, treeNode) {
-            if (treeNode.shoptype != 1 || ""==treeNode.shopaccno) {
-                layer.msg("请选择结算商户查询", {icon: 2, time: 1000});
-                return;
-            }
-            var ptype = $("#search-sourceType").val();
-            table.reload('shopPaytypeTable', {where: {paytype: ptype, shopaccno: treeNode.shopaccno}, page: {curr: 1}});
-        }
-
-        // 渲染表格
-        table.render({
-            elem: '#shopPaytypeTable',
-            url: '/shop/shoppaytypelist',
-            page: true,
-            width: 1010,
-            cols: [
-                [
-                    {field: 'shopaccno', title: '商户账号', width: 150, align: 'center', fixed: 'left', sort: true},
-                    {field: 'shopname', title: '商户名称',  align: 'center', fixed: 'left', sort: true},
-                    {field: 'paydesc', title: '支付方式', align: 'center', sort: true},
-                    {
-                        field: 'consumeEnable',
-                        title: '能否消费',
-                        align: 'center',
-                        width: 110,
-                        templet: '#shop-consumeenable-tpl-state',
-                        sort: true
-                    },
-                    {
-                        field: 'anonymousEnable',
-                        title: '匿名消费',
-                        align: 'center',
-                        width: 110,
-                        templet: '#shop-anonymousenable-tpl-state',
-                        sort: true
-                    },
-                    {
-                        field: 'reverseEnable',
-                        title: '能否冲正',
-                        align: 'center',
-                        width: 110,
-                        templet: '#shop-reverseenable-tpl-state',
-                        sort: true
-                    },
-                    {align: 'center', title: '操作', width: 90, fixed: 'right', templet: function (item) {
-                            if (item.paytype != 'balance') {
-                                return '<a class="layui-btn layui-btn-xs" lay-event="config">配置</a>';
-                            }
-                            return '<span style="font-size: 12px;color: #D3D4D3;">无配置</span>';
-                        }
-                    }
-                ]
-            ]
-        });
-
-        // 修改总状态
-        form.on('switch(shop-consumeenable-tpl-state)', function (obj) {
-            var token = $("meta[name='_csrf_token']").attr("value");
-            admin.go('/shop/updatepaytypestat', {
-                shopaccno: obj.elem.value,
-                paytype: $(obj.elem).attr("def-sourceType"),
-                optype: "consume",
-                state: obj.elem.checked ? 'yes' : 'no',
-                _csrf: token
-            }, function (data) {
-                if (data.code == 200) {
-                    layer.msg(data.msg, {icon: 1, time:1000});
-                    table.reload('shopPaytypeTable');
-                } else if (data.code == 401) {
-                    layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                        location.replace('/login');
-                    }, 1000);
-                    return;
-                } else {
-                    layer.msg(data.msg, {icon: 2});
-                    $(obj.elem).prop('checked', !obj.elem.checked);
-                    form.render('checkbox');
-                }
-            },function () {
-                layer.msg('请求失败了，请稍后再试', {icon: 2});
-                $(obj.elem).prop('checked', !obj.elem.checked);
-                form.render('checkbox');
-            });
-        });
-
-        form.on('switch(shop-anonymousenable-tpl-state)', function (obj) {
-            var token = $("meta[name='_csrf_token']").attr("value");
-            updateShopPaytypeState(obj, "anonymous", token);
-        });
-
-        form.on('switch(shop-reverseenable-tpl-state)', function (obj) {
-            var token = $("meta[name='_csrf_token']").attr("value");
-            updateShopPaytypeState(obj, "reverse", token);
-        });
-
-        function updateShopPaytypeState(obj, optype, token) {
-            admin.go('/shop/updatepaytypestat', {
-                shopaccno: obj.elem.value,
-                paytype: $(obj.elem).attr("def-sourceType"),
-                state: obj.elem.checked ? 'yes' : 'no',
-                optype: optype,
-                _csrf: token
-            }, function (data) {
-                if (data.code == 200) {
-                    layer.msg(data.msg, {icon: 1, time: 1000});
-                } else if (data.code == 401) {
-                    layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                        location.replace('/login');
-                    }, 1000);
-                    return;
-                } else {
-                    layer.msg(data.msg, {icon: 2});
-                    $(obj.elem).prop('checked', !obj.elem.checked);
-                    form.render('checkbox');
-                }
-            }, function () {
-                layer.msg('请求失败了，请稍后再试', {icon: 2});
-                $(obj.elem).prop('checked', !obj.elem.checked);
-                form.render('checkbox');
-            });
-        }
-
-        $('#btn-add-shoppaytype').click(function () {
-            var ztree = $.fn.zTree.getZTreeObj("shopacctree");
-            var shopNodes = ztree.getSelectedNodes();
-            if (undefined == shopNodes || null == shopNodes || shopNodes.length < 1) {
-                layer.msg("请先选中左侧的一个结算商户", {icon: 2, time: 1000});
-                return;
-            }
-            var shopNode = shopNodes[0]; //选中商户
-            if(shopNode.shoptype!=1 || ""==shopNode.shopaccno){
-                layer.msg("请选择结算商户！", {icon: 2, time: 1000});
-                return;
-            }
-            admin.putTempData('t_addshoppaytype', {
-                shopaccno:shopNode.shopaccno,
-                shopname: shopNode.name.slice(shopNode.id.length+1)  //23_第一食堂，截取商户名称
-            });
-            admin.popupCenter({
-                title: "新增支付能力",
-                path: '/shop/load4addpaytype',
-                finish: function () {
-                    table.reload('shopPaytypeTable', {
-                        where: {paytype: "", shopaccno: shopNode.shopaccno},
-                        page: {curr: 1}
-                    });
-                }
-            });
-        });
-
-        //监听单元格
-        table.on('tool(shopPaytypeTable-filter)', function (obj) {
-            var data = obj.data;
-            if ('config' == obj.event) {
-                admin.popupCenter({
-                    title: "配置参数【" + data.shopname + "_" + data.paydesc + "】",
-                    path: '/shop/load4paytypepara?shopaccno=' + data.shopaccno + '&paytype=' + data.paytype,
-                    area: '800px',
-                    finish: function () {
-                        table.reload('shopPaytypeTable');
-                    }
-                });
-            }
-        });
-    });
-</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/system/shop/configform.html b/src/main/resources/templates/system/shop/configform.html
deleted file mode 100644
index 9d0bb94..0000000
--- a/src/main/resources/templates/system/shop/configform.html
+++ /dev/null
@@ -1,101 +0,0 @@
-<form id="shop-sourceType-form" lay-filter="shop-sourceType-form" class="layui-form model-form">
-    <div class="layui-form-item">
-        <label class="layui-form-label">商户账号</label>
-        <div class="layui-input-block">
-            <input name="shopaccno" class="layui-input" readonly="readonly" lay-verify="required"/>
-        </div>
-    </div>
-    <div class="layui-form-item">
-        <label class="layui-form-label">商户名称</label>
-        <div class="layui-input-block">
-            <input name="shopname" class="layui-input" readonly="readonly"/>
-        </div>
-    </div>
-    <div class="layui-form-item">
-        <label class="layui-form-label">支付方式</label>
-        <div class="layui-input-block">
-            <select name="paytype" lay-verify="required">
-                <option th:each="pt:${paytypelist}" th:value="${pt.sourceType}"
-                        th:text="${pt.paydesc}"></option>
-            </select>&emsp;
-        </div>
-    </div>
-
-    <div class="layui-form-item">
-        <label class="layui-form-label">能否消费</label>
-        <div class="layui-input-block">
-            <input name="consumeEnable" type="checkbox" lay-skin="switch" lay-text="启用|关闭" value="yes" lay-verify="required" checked/>
-        </div>
-    </div>
-
-    <div class="layui-form-item">
-        <label class="layui-form-label">匿名消费</label>
-        <div class="layui-input-block">
-            <input name="anonymousEnable" type="checkbox" lay-skin="switch" lay-text="启用|关闭" value="yes" lay-verify="required" checked/>
-        </div>
-    </div>
-
-    <div class="layui-form-item">
-        <label class="layui-form-label">能否冲正</label>
-        <div class="layui-input-block">
-            <input name="reverseEnable" type="checkbox" lay-skin="switch" lay-text="启用|关闭" value="yes" lay-verify="required" checked/>
-        </div>
-    </div>
-
-    <div class="layui-form-item model-form-footer">
-        <button class="layui-btn layui-btn-primary" type="button" ew-event="closeDialog">取消</button>
-        <button class="layui-btn" lay-filter="form-submit" lay-submit  id="submitbtn">保存</button>
-    </div>
-</form>
-
-
-<script>
-    layui.use(['layer', 'admin', 'form'], function () {
-        var layer = layui.layer;
-        var admin = layui.admin;
-        var form = layui.form;
-        form.render('checkbox');
-        form.render('select');
-        // 回显数据
-        var shop = admin.getTempData('t_addshoppaytype');
-        if (shop) {
-            form.val('shop-sourceType-form', {
-                shopaccno: shop.shopaccno,
-                shopname: shop.shopname
-            });
-        }
-
-        // 表单提交事件
-        form.on('submit(form-submit)', function (data) {
-            layer.load(2);
-            var vdata = data.field;
-            vdata["_csrf"] = $("meta[name='_csrf_token']").attr("value");
-            $.ajax({
-                type : "POST",
-                dataType : "json",
-                url : '/shop/addshoppaytype',
-                data : vdata,
-                success : function(result) {
-                    layer.closeAll('loading');
-                    if (result.code == 200) {
-                        layer.msg(result.msg, {icon: 1});
-                        admin.finishPopupCenter();
-                    } else if (result.code == 401) {
-                        layer.msg(result.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
-                        }, 1000);
-                        return;
-                    } else {
-                        console.log('err:', result);
-                        layer.msg(result.msg, {icon: 2});
-                    }
-                },
-                error : function() {
-                    layer.closeAll('loading');
-                    layer.msg("请求服务器失败！", {icon: 2});
-                }
-            });
-            return false;
-        });
-    });
-</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/system/shop/configpara.html b/src/main/resources/templates/system/shop/configpara.html
deleted file mode 100644
index a4ff319..0000000
--- a/src/main/resources/templates/system/shop/configpara.html
+++ /dev/null
@@ -1,79 +0,0 @@
-<form id="shop-sourceType-config-form" lay-filter="shop-sourceType-config-form" class="layui-form model-form">
-    <div class="layui-form-item" style="display: none;">
-        <input type="hidden" class="layui-input" id="hid_shopaccno" th:value="${shopaccno}"/>
-        <input type="hidden" class="layui-input" id="hid_paytype" th:value="${paytype}"/>
-    </div>
-
-    <div class="layui-form-item" style="text-align: center;" th:if="${configlist.size()} le 0">
-        无配置项
-    </div>
-
-    <div class="layui-form-item" th:if="${configlist.size()} gt 0" th:each="config:${configlist}">
-        <div class="layui-input-block" style="margin:0;display: inline;float: left;width: 20%;">
-            <label class="layui-form-label" style="float: right;width: 100%;" th:text="${config.configid}">参数名</label>
-        </div>
-        <div class="layui-input-block" style="margin:0;display: inline;float: right;width: 80%;">
-            <input type="text" th:name="${config.configid}" class="layui-input" th:value="${config.configValue}" autocomplete="off"/>
-        </div>
-    </div>
-
-    <div class="layui-form-item model-form-footer">
-        <button class="layui-btn layui-btn-primary" type="button" ew-event="closeDialog">取消</button>
-        <button class="layui-btn" lay-filter="form-submit" lay-submit  id="submitbtn">保存</button>
-    </div>
-</form>
-
-
-<script>
-    layui.use(['layer', 'admin', 'form'], function () {
-        var layer = layui.layer;
-        var admin = layui.admin;
-        var form = layui.form;
-        // 表单提交事件
-        form.on('submit(form-submit)', function (data) {
-            layer.load(2);
-            var vdata = data.field;
-            if(JSON.stringify(vdata)=="{}"){
-                layer.closeAll('loading');
-                admin.closePopupCenter();
-                return; //无配置项，直接关闭
-            }
-            var token = $("meta[name='_csrf_token']").attr("value");
-            vdata["hid_paytype"] = $("#hid_paytype").val();
-            vdata["hid_shopaccno"] = $("#hid_shopaccno").val();
-            console.log('addShopPaytype:', vdata);
-            debugger
-            $.ajax({
-                type : "POST",
-                dataType : "json",
-                url : '/shop/addpaytypepara',
-                headers: {
-                    'Accept': 'application/json',
-                    'Content-Type': 'application/json',
-                    'X-CSRF-TOKEN':token,
-                },
-                data : JSON.stringify(vdata),
-                success : function(result) {
-                    layer.closeAll('loading');
-                    if (result.code == 200) {
-                        layer.msg(result.msg, {icon: 1});
-                        admin.finishPopupCenter();
-                    } else if (result.code == 401) {
-                        layer.msg(result.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
-                        }, 1000);
-                        return;
-                    } else {
-                        console.log('err:' + result.code);
-                        layer.msg(result.msg, {icon: 2});
-                    }
-                },
-                error : function() {
-                    layer.closeAll('loading');
-                    layer.msg("请求服务器失败！", {icon: 2});
-                }
-            });
-            return false;
-        });
-    });
-</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/system/shop/index.html b/src/main/resources/templates/system/shop/index.html
deleted file mode 100644
index 8407b4c..0000000
--- a/src/main/resources/templates/system/shop/index.html
+++ /dev/null
@@ -1,385 +0,0 @@
-<div class="layui-card">
-    <div class="layui-card-header">
-        <h2 class="header-title">商户管理</h2>
-        <span class="layui-breadcrumb pull-right">
-          <a href="#">商户中心</a>
-          <a><cite>商户管理</cite></a>
-        </span>
-    </div>
-    <div class="layui-card-body">
-        <div class="layui-row">
-            <div class="layui-col-xs5 layui-col-md3">
-                <div class="layui-card">
-                    <div class="layui-card-body layui-show"
-                         style="background-color: #D7F9F7;max-height: 560px;overflow:auto;">
-                        <ul id="shoptree" class="ztree"></ul>
-                    </div>
-                </div>
-            </div>
-            <div class="layui-col-xs7 layui-col-md9">
-                <div class="layui-card" style="min-height: 600px;">
-                    <div id="shop-info" class="layui-form toolbar" lay-filter="shop-info-form" style="display: none;">
-                        <div class="layui-card-header">商户基本信息</div>
-                        <div class="layui-card-body">
-                            <div class="layui-form-item">
-                                <div class="layui-inline" style="width: 40%;">
-                                    <label class="layui-form-label">商户号</label>
-                                    <div class="layui-input-inline">
-                                        <input type="text" name="shopid" class="layui-input"
-                                               readonly="readonly"/>
-                                    </div>
-                                </div>
-                                <div class="layui-inline" style="width: 55%;">
-                                    <label class="layui-form-label">商户名</label>
-                                    <div class="layui-input-inline" style="width: 65%;">
-                                        <input type="text" name="shopname" autocomplete="off"
-                                               class="layui-input" maxlength="30" lay-verify="required"/>
-                                    </div>
-                                </div>
-                            </div>
-                            <div class="layui-form-item">
-                                <div class="layui-inline" style="width: 40%;">
-                                    <label class="layui-form-label">上级商户号</label>
-                                    <div class="layui-input-inline">
-                                        <input type="text" name="fshopid" id="fshopid" class="layui-input" autocomplete="off"
-                                               lay-verify="required|number"/>
-                                    </div>
-                                </div>
-                                <div class="layui-inline" style="width: 55%;">
-                                    <label class="layui-form-label">商户账号</label>
-                                    <div class="layui-input-inline" style="width: 65%;">
-                                        <input type="text" name="shopaccno" autocomplete="off"
-                                               class="layui-input" readonly="readonly"/>
-                                    </div>
-                                </div>
-                            </div>
-                            <div class="layui-form-item">
-                                <label class="layui-form-label" style="color: red;">商户类型</label>
-                                <div class="layui-input-inline">
-                                    <select name="shoptype" id="shoptype" lay-filter="shoptype-filter" lay-verify="required">
-                                        <option value="0">商户组</option>
-                                        <option value="1">结算商户</option>
-                                    </select>
-                                </div>
-                                <div class="layui-form-mid layui-word-aux">
-                                    注意：商户组无商户账号，且能创建下级商户。结算商户是叶子商户，会创建商户账号。保存后无法修改！！！
-                                </div>
-                            </div>
-                            <div class="layui-form-item">
-                                <div class="layui-inline" style="width: 40%;">
-                                    <label class="layui-form-label">邮编</label>
-                                    <div class="layui-input-inline">
-                                        <input type="text" name="zipcode" class="layui-input" autocomplete="off" />
-                                    </div>
-                                </div>
-                                <div class="layui-inline" style="width: 55%;">
-                                    <label class="layui-form-label">地址</label>
-                                    <div class="layui-input-inline" style="width: 65%;">
-                                        <input type="text" name="addr" class="layui-input" maxlength="40" autocomplete="off" />
-                                    </div>
-                                </div>
-                            </div>
-                        </div>
-                        <div class="layui-card-header">商户联系人信息</div>
-                        <div class="layui-card-body">
-                            <div class="layui-form-item">
-                                <div class="layui-inline" style="width: 40%;">
-                                    <label class="layui-form-label">姓名</label>
-                                    <div class="layui-input-inline">
-                                        <input type="text" name="contactman" class="layui-input" autocomplete="off"/>
-                                    </div>
-                                </div>
-                                <div class="layui-inline" style="width: 55%;">
-                                    <label class="layui-form-label">手机号</label>
-                                    <div class="layui-input-inline" style="width: 65%;">
-                                        <input type="text" name="mobile" class="layui-input" maxlength="20" autocomplete="off"
-                                               lay-verify="mobile" />
-                                    </div>
-                                </div>
-                            </div>
-                            <div class="layui-form-item">
-                                <div class="layui-inline" style="width: 40%;">
-                                    <label class="layui-form-label">证件类型</label>
-                                    <div class="layui-input-inline">
-                                        <select name="idtype" lay-filter="idtype-filter">
-                                            <option value="1">身份证</option>
-                                            <option value="2">护照</option>
-                                            <option value="3">驾照</option>
-                                            <option value="4">港澳通行证</option>
-                                            <option value="5">学生证</option>
-                                            <option value="9">其他</option>
-                                        </select>
-                                    </div>
-                                </div>
-                                <div class="layui-inline" style="width: 55%;">
-                                    <label class="layui-form-label">证件号</label>
-                                    <div class="layui-input-inline" style="width: 65%;">
-                                        <input type="text" name="idno" class="layui-input" maxlength="20" autocomplete="off"/>
-                                    </div>
-                                </div>
-                            </div>
-                            <div class="layui-form-item">
-                                <div class="layui-inline" style="width: 40%;">
-                                    <label class="layui-form-label">邮箱</label>
-                                    <div class="layui-input-inline">
-                                        <input type="text" name="email" class="layui-input" autocomplete="off" lay-verify="swEmail"/>
-                                    </div>
-                                </div>
-                                <div class="layui-inline" style="width: 55%;">
-                                    <label class="layui-form-label">电话</label>
-                                    <div class="layui-input-inline" style="width: 65%;">
-                                        <input type="text" name="tel" class="layui-input" maxlength="20" autocomplete="off" />
-                                    </div>
-                                </div>
-                            </div>
-                        </div>
-
-                        <div class="layui-form-item" style="padding-bottom: 20px;text-align: center;">
-                            <button class="layui-btn" lay-filter="form-submit-shop-btn" lay-submit id="submitbtn-shop-btn">保存</button>
-                            <button class="layui-btn layui-btn-primary" type="button" id="cancelbtn">取消</button>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        </div>
-    </div>
-</div>
-
-<script>
-    layui.use(['form', 'table', 'layer', 'admin', 'element'], function () {
-        var form = layui.form;
-        var table = layui.table;
-        var admin = layui.admin;
-        form.render('select');
-        form.verify({
-            "mobile": function (e) {
-                if (null != e && e.length > 0 && !(/^1\d{10}$/.test(e))) {
-                    return "请输入正确的手机号";
-                }
-            },
-            "swEmail": function (e) {
-                if (null != e && e.length > 0 && !(/^([a-zA-Z0-9_\.\-])+\@(([a-zA-Z0-9\-])+\.)+([a-zA-Z0-9]{2,4})+$/.test(e))) {
-                    return "邮箱格式不正确";
-                }
-            }
-        });
-
-        var initTree = function (nodes) {
-            var menuSetting = {
-                view: {
-                    dblClickExpand: false,
-                    showLine: true,
-                    showIcon: true,
-                    selectedMulti: false,
-                    addHoverDom: addHoverDom,
-                    removeHoverDom: removeHoverDom
-                },
-                data: {
-                    simpleData: {
-                        enable: true
-                    }
-                },
-                edit: {
-                    enable: true,
-                    showRemoveBtn: true,
-                    removeTitle: "删除商户",
-                    showRenameBtn: false,
-                    drag: {
-                        isCopy: false,
-                        isMove: false
-                    }
-                },
-                callback: {
-                    beforeRemove: beforeRemove,
-                    onDblClick: ondblclick
-                }
-            };
-            $.fn.zTree.init($("#shoptree"), menuSetting, nodes);
-        }
-
-        function beforeRemove(treeId, treeNode) {
-            var zTree = $.fn.zTree.getZTreeObj("shoptree");
-            if (treeNode.isParent) {
-                var childrenNodes = treeNode.children;
-                if (childrenNodes && childrenNodes.length != 0) {
-                    layer.msg("请先删除下级商户", {icon: 2, time: 2000});
-                    return false;
-                }
-            }
-            zTree.selectNode(treeNode);
-            var flag = false;
-            if (confirm("确认删除商户【" + treeNode.name + "】吗？")) {
-                layer.load(2);
-                $.ajax({
-                    type: "POST",
-                    dataType: "json",
-                    url: '/shop/deleteshop',
-                    async: false,  //必须同步
-                    data: {
-                        shopid: treeNode.id,
-                        _csrf: $("meta[name='_csrf_token']").attr("value")
-                    },
-                    success: function (result) {
-                        console.log(result);
-                        layer.closeAll('loading');
-                        if (result.code == 200) {
-                            layer.msg(result.msg, {icon: 1});
-                            flag = true;
-                        } else if (result.code == 401) {
-                            layer.msg(result.msg, {icon: 2, time: 1500}, function () {
-                                location.replace('/login');
-                            }, 1000);
-                        } else {
-                            console.log('err:' + result.code);
-                            layer.msg(result.msg, {icon: 2});
-                        }
-                    },
-                    error: function () {
-                        console.log(ret);
-                        layer.closeAll('loading');
-                        layer.msg("请求服务器失败！", {icon: 2});
-                    }
-                });
-            }
-            return flag;
-        }
-
-        function removeHoverDom(treeId, treeNode) {
-            $("#addBtn_" + treeNode.tId).unbind().remove();
-        }
-
-        $('#cancelbtn').click(function () {
-            $("#shop-info").hide();
-        });
-
-        form.on('submit(form-submit-shop-btn)', function (data) {
-            layer.load(2);
-            var vdata = data.field;
-            vdata["_csrf"] = $("meta[name='_csrf_token']").attr("value");
-            $.ajax({
-                type: "POST",
-                dataType: "json",
-                url: '/shop/saveorupdate',
-                data: vdata,
-                success: function (result) {
-                    layer.closeAll('loading');
-                    debugger
-                    if (result.code == 200) {
-                        var zTree = $.fn.zTree.getZTreeObj("shoptree");
-                        var treeNode = zTree.getNodeByParam("id", '' + result.shop.shopid, null);
-                        if (undefined != treeNode && null != treeNode) {
-                            treeNode.id = ''+result.shop.shopid;
-                            treeNode.pId = '' + result.shop.fshopid;
-                            treeNode.name = '' + result.shop.shopid + '_' + result.shop.shopname;
-                            zTree.updateNode(treeNode); //修改节点
-                        } else {
-                            var ftreeNode = zTree.getNodeByParam("id", '' + result.shop.fshopid, null);
-                            var newNode = {
-                                id: '' + result.shop.shopid,
-                                pId: '' + result.shop.fshopid,
-                                name: '' + result.shop.shopid + '_' + result.shop.shopname,
-                                shoptype: result.shop.shoptype
-                            }
-                            if (result.shop.shoptype == 1) {
-                                newNode["iconSkin"] = "pIcon02";
-                            } else {
-                                newNode["iconSkin"] = "pIcon01";
-                            }
-                            zTree.addNodes(ftreeNode, newNode); //新加树节点
-                        }
-                        layer.msg(result.msg, {icon: 1});
-                        $("#shop-info").hide();
-                    } else if (result.code == 401) {
-                        layer.msg(result.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
-                        }, 1000);
-                        return;
-                    } else {
-                        console.log('err:' + result.code);
-                        layer.msg(result.msg, {icon: 2});
-                    }
-                },
-                error: function () {
-                    layer.closeAll('loading');
-                    layer.msg("请求服务器失败！", {icon: 2});
-                }
-            });
-        });
-
-        function addHoverDom(treeId, treeNode) {
-            if (treeNode.shoptype == 0) {
-                var sObj = $("#" + treeNode.tId + "_span");
-                if (treeNode.editNameFlag || $("#addBtn_" + treeNode.tId).length > 0) return;
-                var addStr = "<span class='button add' id='addBtn_" + treeNode.tId
-                    + "' title='新增下级商户' onfocus='this.blur();'></span>";
-                sObj.after(addStr);
-                var btn = $("#addBtn_" + treeNode.tId);
-                if (btn) btn.bind("click", function () {
-                    form.val("shop-info-form",{
-                        "shopid":"0",
-                        "shopname": "",
-                        "shopaccno":"",
-                        "fshopid":treeNode.id,
-                        "shoptype":"1",
-                        "zipcode":"",
-                        "addr":"",
-                        "contactman":"",
-                        "idtype":"1",
-                        "idno":"",
-                        "mobile":"",
-                        "email":"",
-                        "tel":""
-                    });
-                    $("#fshopid").attr("readonly", "readonly");
-                    $("#shoptype").removeAttr("disabled");
-                    form.render('select');
-                    $("#submitbtn-shop-btn").text("新增");
-                    $("#shop-info").show();
-                    return false;
-                });
-            }
-        }
-
-        function ondblclick(event, treeId, treeNode) {
-            admin.dgo('/shop/getshopinfo', {
-                "shopid": treeNode.id
-            }, function (data) {
-                console.log("getshopinfo返回",data);
-                if (data.code == 200) {
-                    form.val("shop-info-form",data.shop);
-                    $("#fshopid").removeAttr("readonly");
-                    $("#shoptype").attr('disabled', 'disabled');
-                    form.render('select');
-                    $("#submitbtn-shop-btn").text("保存");
-                    $("#shop-info").show();
-                } else if (data.code == 401) {
-                    layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                        location.replace('/login');
-                    }, 1000);
-                    return;
-                } else {
-                    layer.msg(data.msg, {icon: 2, time: 2000});
-                }
-            }, function (ret) {
-                console.log(ret);
-                layer.msg('查询商户失败了，请求服务器异常', {icon: 2});
-            });
-        }
-
-        admin.dgo('/shop/shoptree', {}, function (data) {
-            if (data.code == 200) {
-                initTree(data.data);
-            } else if (data.code == 401) {
-                layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                    location.replace('/login');
-                }, 1000);
-                return;
-            } else {
-                layer.msg(data.msg, {icon: 2, time: 2000});
-            }
-        }, function (ret) {
-            console.log(ret);
-            layer.msg('查询商户树失败了，请稍后再试', {icon: 2});
-        });
-    });
-</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/system/user/account.html b/src/main/resources/templates/system/user/account.html
deleted file mode 100644
index 2475cf9..0000000
--- a/src/main/resources/templates/system/user/account.html
+++ /dev/null
@@ -1,119 +0,0 @@
-<div class="layui-card">
-    <div class="layui-card-header">
-        <h2 class="header-title">账户管理</h2>
-        <span class="layui-breadcrumb pull-right">
-          <a href="#">用户中心</a>
-          <a><cite>账户管理</cite></a>
-        </span>
-    </div>
-    <div class="layui-card-body">
-        <div class="layui-form toolbar">
-            搜索：
-            <input id="search-value-account" class="layui-input search-input" type="text" placeholder="输入用户名称"/>&emsp;
-            <button id="btn-search-account" class="layui-btn icon-btn" data-type="search"><i class="layui-icon">&#xe615;</i>搜索
-            </button>
-        </div>
-        <table class="layui-table" id="accounttable" lay-filter="accounttable"></table>
-    </div>
-</div>
-<script>
-    layui.use(['form', 'table', 'layer', 'admin', 'element'], function () {
-        let form = layui.form;
-        let table = layui.table;
-        let admin = layui.admin;
-        form.render('select');
-        // 渲染表格
-        table.render({
-            elem: '#accounttable',
-            url: '/user/account',
-            page: true,
-            cols: [
-                [
-                    {field: 'accno', title: '账号',fixed: 'left', width: 100},
-                    {field: 'person', title: '名称', width: 80,fixed: 'left', sort: true, templet: function (item) {
-                            if(item.accname!=null){
-                                return item.accname;
-                            }
-                            return item.person.name;
-                    }},
-                    {field: 'status', title: '状态',fixed: 'left',width: 80 , templet: function (item) {
-                            if (item.status == 'normal') {
-                                return '<span class="layui-badge layui-bg-green">正常</span>'
-                            } else if (item.status == 'closed') {
-                                return '<span class="layui-badge">注销</span>'
-                            } else if (item.status == 'locked') {
-                                return '<span class="layui-badge layui-bg-orange">锁定</span>'
-                            }  else {
-                                return '异常'
-                            }
-                        }
-                    },
-                    {field: 'availbal', title: '可用余额', width: 100,fixed: 'left', sort: true},
-                    {field: 'balance', title: '总余额', width: 100,fixed: 'left', sort: true},
-                    {field: 'frozebal', title: '冻结余额', width: 100,fixed: 'left', sort: true},
-                    {field: 'lasttransdate', title: '最后交易日期', width: 120,fixed: 'left', sort: true},
-                    {field: 'opendate', title: '开户日期', width: 100,fixed: 'left', sort: true},
-                    {
-                        field: 'accno', align: 'center', title: '操作', fixed: 'right', templet: function (item) {
-                            if (item.status != 'closed') {
-                                let html = ' <a class="layui-btn  layui-btn-danger layui-btn-xs" lay-event="del"><i class="layui-icon layui-icon-delete"></i>注销</a> ';
-                                return html;
-                            }else {
-                                return '';
-                            }
-                        }
-                    }
-                ]
-            ]
-        });
-        // 搜索按钮点击事件
-        $('#btn-search-account').click(function () {
-            let key = $('#search-value-account').val();
-            table.reload('accounttable', {where: {searchkey: key}, page: {curr: 1}});
-        });
-        // 工具条点击事件
-        table.on('tool(accounttable)', function (obj) {
-            let data = obj.data;
-            let layEvent = obj.event;
-            console.log(data);
-            if (layEvent === 'edit') {
-                showModel(data);
-            } else if (layEvent === 'del') {
-                showDelete(data);
-            }
-        });
-        let showDelete = function (data) {
-            layer.confirm('确定注销账户吗，注销后该用户将无法使用余额？', function (i) {
-                layer.close(i);
-                layer.load(2);
-                let token = $("meta[name='_csrf_token']").attr("value");
-                admin.go('/user/delacc', {
-                    accno: data.accno,
-                    _csrf: token
-                }, function (data) {
-                    console.log(data.code);
-                    layer.closeAll('loading');
-                    if (data.code == 200) {
-                        layer.msg(data.msg, {icon: 1});
-                    } else if (data.code == 401) {
-                        layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
-                        }, 1000);
-                        return;
-                    } else {
-                        layer.msg(data.msg, {icon: 2});
-                    }
-                    table.reload('accounttable', {});
-                }, function (ret) {
-                    console.log(ret);
-                    layer.closeAll('loading');
-                    if(ret.status==403){
-                        layer.msg('没有权限', {icon: 2});
-                    }else{
-                        layer.msg('请求失败了，请稍后再试', {icon: 2});
-                    }
-                });
-            });
-        }
-    });
-</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/system/user/add.html b/src/main/resources/templates/system/user/add.html
deleted file mode 100755
index d2893e6..0000000
--- a/src/main/resources/templates/system/user/add.html
+++ /dev/null
@@ -1,110 +0,0 @@
-<!-- operator表单弹窗 -->
-<form id="user-form" lay-filter="user-form" class="layui-form model-form">
-    <input name="userid" id="userid" type="hidden"/>
-    <div class="layui-form-item">
-        <label class="layui-form-label">姓名*</label>
-        <div class="layui-input-block">
-            <input name="name" placeholder="请输入名称" type="text" class="layui-input" maxlength="100"
-                   lay-verify="required" required/>
-        </div>
-    </div>
-    <div class="layui-form-item">
-        <label class="layui-form-label">性别</label>
-        <div class="layui-input-block">
-            <input type="radio" name="sex" value="male" title="男" checked/>
-            <input type="radio" name="sex" value="female" title="女"/>
-        </div>
-    </div>
-    <div class="layui-form-item">
-        <label class="layui-form-label">证件类型*</label>
-        <div class="layui-input-block">
-            <select name="idtype" id="idtype" lay-verify="required">
-                <option th:each="bean : ${idtypes}" th:value="${bean.idtype}">[[${bean.typename}]]</option>
-            </select>
-        </div>
-    </div>
-    <div class="layui-form-item">
-        <label class="layui-form-label">证件号*</label>
-        <div class="layui-input-block">
-            <input name="idno" placeholder="请输入证件号" type="text" class="layui-input" maxlength="100"
-                   lay-verify="required" required/>
-        </div>
-    </div>
-
-    <div class="layui-form-item">
-        <label class="layui-form-label">手机号*</label>
-        <div class="layui-input-block">
-            <input name="mobile" placeholder="请输入手机号" type="text" class="layui-input" maxlength="11"
-                   lay-verify="required" required/>
-        </div>
-    </div>
-    <div class="layui-form-item">
-        <label class="layui-form-label">邮箱</label>
-        <div class="layui-input-block">
-            <input name="email" placeholder="请输入邮箱" type="text" class="layui-input" maxlength="100" />
-        </div>
-    </div>
-    <div class="layui-form-item">
-        <label class="layui-form-label">地址</label>
-        <div class="layui-input-block">
-            <input name="addr" placeholder="请输入地址" type="text" class="layui-input" maxlength="300" />
-        </div>
-    </div>
-
-    <div class="layui-form-item model-form-footer">
-        <button class="layui-btn layui-btn-primary" type="button" ew-event="closeDialog">取消</button>
-        <button class="layui-btn" lay-filter="user-form-submit" lay-submit  id="submitbtn">保存</button>
-    </div>
-</form>
-
-<script>
-    layui.use(['layer', 'admin', 'form', 'formSelects'], function () {
-        var layer = layui.layer;
-        var admin = layui.admin;
-        var form = layui.form;
-        var url = '/user/add';
-        form.render('radio');
-        form.render('select');
-        // 回显user数据
-        var bean = admin.getTempData('t_bean');
-        if (bean) {
-            form.val('user-form', bean);
-        }
-        // 表单提交事件
-        form.on('submit(user-form-submit)', function (data) {
-            layer.load(2);
-            let token = $("meta[name='_csrf_token']").attr("value");
-            $.ajax({
-                type : "POST",
-                dataType : "json",
-                url : url,
-                headers: {
-                    'Accept': 'application/json',
-                    'Content-Type': 'application/json',
-                    'X-CSRF-TOKEN':token,
-                },
-                data : JSON.stringify(data.field),
-                success : function(result) {
-                    layer.closeAll('loading');
-                    if (result.code == 200) {
-                        layer.msg(result.msg, {icon: 1});
-                        admin.finishPopupCenter();
-                    } else if (result.code == 401) {
-                        layer.msg(result.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
-                        }, 1000);
-                        return;
-                    } else {
-                        console.log('err:' + result.code);
-                        layer.msg(result.msg, {icon: 2});
-                    }
-                },
-                error : function() {
-                    layer.closeAll('loading');
-                    layer.msg("请求服务器失败！", {icon: 2});
-                }
-            });
-            return false;
-        });
-    });
-</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/system/user/bind.html b/src/main/resources/templates/system/user/bind.html
deleted file mode 100755
index dd5561e..0000000
--- a/src/main/resources/templates/system/user/bind.html
+++ /dev/null
@@ -1,76 +0,0 @@
-<div style="padding:20px;">
-    <table class="layui-table" id="userbindtable" lay-filter="userbindtable">
-    </table>
-    <input type="hidden" id="userid" th:value="${userid}">
-</div>
-<script>
-    layui.use(['form', 'table', 'layer', 'admin', 'element'], function () {
-        let form = layui.form;
-        let admin = layui.admin;
-        form.render('select');
-        let table = layui.table;
-        let userid = admin.getTempData('userid');
-        table.render({
-            elem: '#userbindtable',
-            url: '/user/bind?userid=' + userid,
-            cols: [
-                [
-                    {field: 'id', title: '资源ID', width: 80, fixed: 'left', sort: true},
-                    {field: 'name', title: '资源名称', sort: true},
-                    {
-                        field: 'functionId', title: '所属功能', sort: true, align: 'center', templet: function (item) {
-                            return $("#functionname").val();
-                        }
-                    },
-                    {field: 'uri', title: '路径'},
-                    {field: 'code', sort: true, width: 80, title: '代码'},
-                    {
-                        field: 'id', align: 'center', title: '操作',  templet: function (item) {
-                            return '<a class="layui-btn layui-btn-danger layui-btn-xs" lay-event="del"><i class="layui-icon layui-icon-delete"></i>删除</a>'
-                        }
-                    }
-                ]
-            ]
-        });
-        // 工具条点击事件
-        table.on('tool(userbindtable)', function (obj) {
-            let data = obj.data;
-            let layEvent = obj.event;
-            console.log(data);
-            if (layEvent === 'del') {
-                showDelete(data);
-            }
-        });
-
-        let showDelete = function (data) {
-            layer.confirm('确定删除吗？', function (i) {
-                layer.close(i);
-                layer.load(2);
-                let token = $("meta[name='_csrf_token']").attr("value");
-                admin.go('/user/delbind', {
-                    resid: data.id,
-                    _csrf:token
-                }, function (data) {
-                    console.log(data.code);
-                    layer.closeAll('loading');
-                    if (data.code == 200) {
-                        layer.msg(data.msg, {icon: 1});
-                    } else if (data.code == 401) {
-                        layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
-                        }, 1000);
-                        return;
-                    }
-                    else {
-                        layer.msg(data.msg, {icon: 2});
-                    }
-                    table.reload('restable', {});
-                },function(ret){
-                    console.log(ret);
-                    layer.closeAll('loading');
-                    layer.msg('请求失败了，请稍后再试', {icon: 2});
-                });
-            });
-        }
-    });
-</script>
diff --git a/src/main/resources/templates/system/user/index.html b/src/main/resources/templates/system/user/index.html
deleted file mode 100644
index 3a9d6fa..0000000
--- a/src/main/resources/templates/system/user/index.html
+++ /dev/null
@@ -1,154 +0,0 @@
-<div class="layui-card">
-    <div class="layui-card-header">
-        <h2 class="header-title">用户管理</h2>
-        <span class="layui-breadcrumb pull-right">
-          <a href="#">用户中心</a>
-          <a><cite>用户管理</cite></a>
-        </span>
-    </div>
-    <div class="layui-card-body">
-        <div class="layui-form toolbar">
-            搜索：
-            <input id="search-value-user" class="layui-input search-input" type="text" placeholder="输入用户名称"/>&emsp;
-            <button id="btn-search-user" class="layui-btn icon-btn" data-type="search"><i class="layui-icon">&#xe615;</i>搜索
-            </button>
-            <button id="btn-add-user" class="layui-btn icon-btn" data-type="add"><i class="layui-icon"></i>添加用户</button>
-        </div>
-        <table class="layui-table" id="usertable" lay-filter="usertable"></table>
-    </div>
-</div>
-<script>
-    layui.use(['form', 'table', 'layer', 'admin', 'element'], function () {
-        let form = layui.form;
-        let table = layui.table;
-        let admin = layui.admin;
-        form.render('select');
-        // 渲染表格
-        table.render({
-            elem: '#usertable',
-            url: '/user/list',
-            page: true,
-            cols: [
-                [
-                    {field: 'name', title: '名称', width: 80,fixed: 'left', sort: true},
-                    {field: 'sex', title: '性别',fixed: 'left', width: 80, templet: function (item) {
-                            if (item.sex == 'male') {
-                                return '男'
-                            } else if (item.sex == 'female') {
-                                return '女'
-                            } else {
-                                return '男'
-                            }
-                        }
-                    },
-                    {field: 'status', title: '状态',fixed: 'left',width: 80 , templet: function (item) {
-                            if (item.status == 'normal') {
-                                return '<span class="layui-badge layui-bg-green">正常</span>'
-                            } else if (item.status == 'closed') {
-                                return '<span class="layui-badge">注销</span>'
-                            } else if (item.status == 'locked') {
-                                return '<span class="layui-badge layui-bg-orange">锁定</span>'
-                            }  else {
-                                return '异常'
-                            }
-                        }
-                    },
-                    {field: 'idtype', align: 'center',width: 100,  title: '证件类型', fixed: 'left', templet: function (item) {
-                            if (item.idtype == '1') {
-                                return '身份证'
-                            } else if (item.idtype == '2') {
-                                return '护照'
-                            } else if (item.idtype == '3') {
-                                return '驾照'
-                            } else if (item.idtype == '4') {
-                                return '港澳通行证'
-                            } else if (item.idtype == '5') {
-                                return '学工号'
-                            } else {
-                                return '其他'
-                            }
-                        }
-                    },
-                    {field: 'idno', title: '证件号', width: 120,fixed: 'left', sort: true},
-                    {field: 'email', title: '邮箱', width: 100,fixed: 'left', sort: true},
-                    {field: 'mobile', title: '手机', width: 120,fixed: 'left', sort: true},
-                    {field: 'tel', title: '电话', width: 100,fixed: 'left', sort: true},
-                    {field: 'addr', title: '地址', width: 200,fixed: 'left', sort: true},
-                    {field: 'lastsaved', title: '最后修改时间', width: 140,fixed: 'left', sort: true},
-                    {
-                        field: 'userid', align: 'center', title: '操作', fixed: 'right', templet: function (item) {
-                            let html =  ' <a class="layui-btn  layui-btn-xs" lay-event="edit"><i class="layui-icon layui-icon-edit"></i>编辑</a> ';
-                            html +='<a class="layui-btn layui-btn-danger layui-btn-xs" lay-event="del"><i class="layui-icon layui-icon-delete"></i>删除</a>';
-                            /*html +=  '<a class="layui-btn  layui-btn-xs" lay-event="other"><i class="layui-icon layui-icon-link"></i>交易记录</a> ';*/
-                            return html;
-                        }
-                    }
-                ]
-            ]
-        });
-        // 搜索按钮点击事件
-        $('#btn-search-user').click(function () {
-            let key = $('#search-value-user').val();
-            table.reload('usertable', {where: {searchkey: key}, page: {curr: 1}});
-        });
-        $('#btn-add-user').click(function () {
-            showModel();
-        });
-        let showModel = function (data) {
-            let title = data ? '编辑用户' : '添加用户';
-            admin.putTempData('t_bean', data);
-            admin.popupCenter({
-                title: title,
-                path: '/user/loadadd',
-                finish: function () {
-                    table.reload('usertable', {});
-                }
-            });
-        };
-        // 工具条点击事件
-        table.on('tool(usertable)', function (obj) {
-            let data = obj.data;
-            let layEvent = obj.event;
-            if (layEvent === 'edit') {
-                showModel(data);
-            } else if (layEvent === 'other') {
-                showOtherModel(data);
-            } else if (layEvent === 'del') {
-                showDelete(data);
-            }
-        });
-        let showDelete = function (data) {
-            layer.confirm('确定删除该用户吗？', function (i) {
-                layer.close(i);
-                layer.load(2);
-                let token = $("meta[name='_csrf_token']").attr("value");
-                admin.go('/user/del', {
-                    userid: data.userid,
-                    _csrf: token
-                }, function (data) {
-                    console.log(data.code);
-                    layer.closeAll('loading');
-                    if (data.code == 200) {
-                        layer.msg(data.msg, {icon: 1});
-                    } else if (data.code == 401) {
-                        layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
-                        }, 1000);
-                        return;
-                    } else {
-                        layer.msg(data.msg, {icon: 2});
-                    }
-                    table.reload('usertable', {});
-                }, function (ret) {
-                    console.log(ret);
-                    layer.closeAll('loading');
-                    if(ret.status==403){
-                        layer.msg('没有权限', {icon: 2});
-                    }else{
-                        layer.msg('请求失败了，请稍后再试', {icon: 2});
-                    }
-                });
-            });
-        }
-    });
-</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/system/user/point.html b/src/main/resources/templates/system/user/point.html
deleted file mode 100644
index 036815c..0000000
--- a/src/main/resources/templates/system/user/point.html
+++ /dev/null
@@ -1,96 +0,0 @@
-<div class="layui-card">
-    <div class="layui-card-header">
-        <h2 class="header-title">积分管理</h2>
-        <span class="layui-breadcrumb pull-right">
-          <a href="#">用户中心</a>
-          <a><cite>积分管理</cite></a>
-        </span>
-    </div>
-    <div class="layui-card-body">
-        <div class="layui-form toolbar">
-            搜索：
-            <input id="search-value-point" class="layui-input search-input" type="text" placeholder="输入用户名称"/>&emsp;
-            <button id="btn-search-point" class="layui-btn icon-btn" data-type="search"><i class="layui-icon">&#xe615;</i>搜索
-            </button>
-        </div>
-        <table class="layui-table" id="pointtable" lay-filter="pointtable"></table>
-    </div>
-</div>
-<script>
-    layui.use(['form', 'table', 'layer', 'admin', 'element'], function () {
-        let form = layui.form;
-        let table = layui.table;
-        let admin = layui.admin;
-        form.render('select');
-        // 渲染表格
-        table.render({
-            elem: '#pointtable',
-            url: '/user/pointlist',
-            page: true,
-            cols: [
-                [
-                    {field: 'person', title: '名称',fixed: 'left', sort: true, templet: function (item) {
-                            return item.person.name;
-                        }},
-                    {field: 'points', title: '可用积分', fixed: 'left', sort: true},
-                    {field: 'lastsaved', title: '最后修改时间', fixed: 'left', sort: true},
-                    {field: 'accumPoints', title: '累计获得积分', fixed: 'left', sort: true},
-                    {field: 'sumpayPoints', title: '累计消费积分',fixed: 'left', sort: true},
-                    {
-                        field: 'userid', align: 'center', title: '操作', fixed: 'right', templet: function (item) {
-                            let html ='<a class="layui-btn layui-btn-danger layui-btn-xs" lay-event="del"><i class="layui-icon layui-icon-delete"></i>删除</a>';
-                            /*html +=  '<a class="layui-btn  layui-btn-xs" th:lay-href="/user/pointdtl?userid="'+item.userid+'><i class="layui-icon layui-icon-link"></i>交易记录</a> ';*/
-                            return html;
-                        }
-                    }
-                ]
-            ]
-        });
-        // 搜索按钮点击事件
-        $('#btn-search-point').click(function () {
-            let key = $('#search-value-point').val();
-            table.reload('pointtable', {where: {searchkey: key}, page: {curr: 1}});
-        });
-        // 工具条点击事件
-        table.on('tool(pointtable)', function (obj) {
-            let data = obj.data;
-            let layEvent = obj.event;
-            if (layEvent === 'del') {
-                showDelete(data);
-            }
-        });
-        let showDelete = function (data) {
-            layer.confirm('确认删除吗，删除后将无法恢复', function (i) {
-                layer.close(i);
-                layer.load(2);
-                let token = $("meta[name='_csrf_token']").attr("value");
-                admin.go('/user/delpoint', {
-                    userid: data.userid,
-                    _csrf: token
-                }, function (data) {
-                    console.log(data.code);
-                    layer.closeAll('loading');
-                    if (data.code == 200) {
-                        layer.msg(data.msg, {icon: 1});
-                    } else if (data.code == 401) {
-                        layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
-                        }, 1000);
-                        return;
-                    } else {
-                        layer.msg(data.msg, {icon: 2});
-                    }
-                    table.reload('pointtable', {});
-                }, function (ret) {
-                    console.log(ret);
-                    layer.closeAll('loading');
-                    if(ret.status==403){
-                        layer.msg('没有权限', {icon: 2});
-                    }else{
-                        layer.msg('请求失败了，请稍后再试', {icon: 2});
-                    }
-                });
-            });
-        }
-    });
-</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/system/user/pointdtl.html b/src/main/resources/templates/system/user/pointdtl.html
deleted file mode 100644
index 522063b..0000000
--- a/src/main/resources/templates/system/user/pointdtl.html
+++ /dev/null
@@ -1,97 +0,0 @@
-<div class="layui-card">
-    <div class="layui-card-header">
-        <h2 class="header-title">积分交易记录</h2>
-        <span class="layui-breadcrumb pull-right">
-          <a href="#">用户中心</a>
-          <a><cite>积分交易记录</cite></a>
-        </span>
-    </div>
-    <div class="layui-card-body">
-        <div class="layui-form toolbar">
-            搜索：
-            <input id="search-value-point" class="layui-input search-input" type="text" placeholder="输入用户名称"/>&emsp;
-            <button id="btn-search-point" class="layui-btn icon-btn" data-type="search"><i class="layui-icon">&#xe615;</i>搜索
-            </button>
-        </div>
-        <table class="layui-table" id="pointtable" lay-filter="pointtable"></table>
-    </div>
-    <input type="hidden" id="userid" th:value="${userid}">
-</div>
-<script>
-    layui.use(['form', 'table', 'layer', 'admin', 'element'], function () {
-        let form = layui.form;
-        let table = layui.table;
-        let admin = layui.admin;
-        form.render('select');
-        // 渲染表格
-        table.render({
-            elem: '#pointtable',
-            url: '/user/pointlist',
-            page: true,
-            cols: [
-                [
-                    {field: 'person', title: '名称',fixed: 'left', sort: true, templet: function (item) {
-                            return item.person.name;
-                        }},
-                    {field: 'points', title: '可用积分', fixed: 'left', sort: true},
-                    {field: 'lastsaved', title: '最后修改时间', fixed: 'left', sort: true},
-                    {field: 'accumPoints', title: '累计获得积分', fixed: 'left', sort: true},
-                    {field: 'sumpayPoints', title: '累计消费积分',fixed: 'left', sort: true},
-                    {
-                        field: 'userid', align: 'center', title: '操作', fixed: 'right', templet: function (item) {
-                            let html ='<a class="layui-btn layui-btn-danger layui-btn-xs" lay-event="del"><i class="layui-icon layui-icon-delete"></i>删除</a>';
-                            html +=  '<a class="layui-btn  layui-btn-xs" th:lay-href="/user/pointdtl?userid="'+item.userid+'><i class="layui-icon layui-icon-link"></i>交易记录</a> ';
-                            return html;
-                        }
-                    }
-                ]
-            ]
-        });
-        // 搜索按钮点击事件
-        $('#btn-search-point').click(function () {
-            let key = $('#search-value-point').val();
-            table.reload('pointtable', {where: {searchkey: key}, page: {curr: 1}});
-        });
-        // 工具条点击事件
-        table.on('tool(pointtable)', function (obj) {
-            let data = obj.data;
-            let layEvent = obj.event;
-            if (layEvent === 'del') {
-                showDelete(data);
-            }
-        });
-        let showDelete = function (data) {
-            layer.confirm('确认删除吗，删除后将无法恢复', function (i) {
-                layer.close(i);
-                layer.load(2);
-                let token = $("meta[name='_csrf_token']").attr("value");
-                admin.go('/user/delpoint', {
-                    userid: data.userid,
-                    _csrf: token
-                }, function (data) {
-                    console.log(data.code);
-                    layer.closeAll('loading');
-                    if (data.code == 200) {
-                        layer.msg(data.msg, {icon: 1});
-                    } else if (data.code == 401) {
-                        layer.msg(data.msg, {icon: 2, time: 1500}, function () {
-                            location.replace('/login');
-                        }, 1000);
-                        return;
-                    } else {
-                        layer.msg(data.msg, {icon: 2});
-                    }
-                    table.reload('pointtable', {});
-                }, function (ret) {
-                    console.log(ret);
-                    layer.closeAll('loading');
-                    if(ret.status==403){
-                        layer.msg('没有权限', {icon: 2});
-                    }else{
-                        layer.msg('请求失败了，请稍后再试', {icon: 2});
-                    }
-                });
-            });
-        }
-    });
-</script>
\ No newline at end of file
