diff --git a/src/main/java/com/supwisdom/dlpay/conference/api/bean/ConfPeopleApiBean.java b/src/main/java/com/supwisdom/dlpay/conference/api/bean/ConfPeopleApiBean.java
index 04f3b90..e1709a1 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/api/bean/ConfPeopleApiBean.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/api/bean/ConfPeopleApiBean.java
@@ -4,6 +4,8 @@
     private String custname;
     private String attstatus;
     private String atttime;
+    private String deptname;
+    private String custtypename;
 
     public String getCustname() {
         return custname;
@@ -28,4 +30,20 @@
     public void setAtttime(String atttime) {
         this.atttime = atttime;
     }
+
+    public String getDeptname() {
+        return deptname;
+    }
+
+    public void setDeptname(String deptname) {
+        this.deptname = deptname;
+    }
+
+    public String getCusttypename() {
+        return custtypename;
+    }
+
+    public void setCusttypename(String custtypename) {
+        this.custtypename = custtypename;
+    }
 }
diff --git a/src/main/java/com/supwisdom/dlpay/conference/api/bean/ConfPeopleReq.java b/src/main/java/com/supwisdom/dlpay/conference/api/bean/ConfPeopleReq.java
index 2091501..315b4c7 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/api/bean/ConfPeopleReq.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/api/bean/ConfPeopleReq.java
@@ -2,22 +2,13 @@
 
 
 public class ConfPeopleReq {
-    private String devphyid;
-    private String confdate;
+    private Integer confid;
 
-    public String getDevphyid() {
-        return devphyid;
+    public Integer getConfid() {
+        return confid;
     }
 
-    public void setDevphyid(String devphyid) {
-        this.devphyid = devphyid;
-    }
-
-    public String getConfdate() {
-        return confdate;
-    }
-
-    public void setConfdate(String confdate) {
-        this.confdate = confdate;
+    public void setConfid(Integer confid) {
+        this.confid = confid;
     }
 }
diff --git a/src/main/java/com/supwisdom/dlpay/conference/api/controller/ConerenceApiController.java b/src/main/java/com/supwisdom/dlpay/conference/api/controller/ConerenceApiController.java
index 86e1299..17ad02f 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/api/controller/ConerenceApiController.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/api/controller/ConerenceApiController.java
@@ -20,6 +20,7 @@
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.bind.annotation.ResponseBody;
+import org.springframework.web.servlet.ModelAndView;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -27,218 +28,239 @@
 @Controller
 @RequestMapping("/api/conference")
 public class ConerenceApiController {
-  @Autowired
-  private WebInterfaceService webInterfaceService;
-  @Autowired
-  private ConferenceService conferenceService;
-  @Autowired
-  private NcService ncService;
+    @Autowired
+    private WebInterfaceService webInterfaceService;
+    @Autowired
+    private ConferenceService conferenceService;
+    @Autowired
+    private NcService ncService;
 
-  @RequestMapping(value = "/getconference", method = RequestMethod.POST)
-  @ResponseBody
-  public ConferenceResp getConferenceToday(@ModelAttribute ConferenceReq req) {
-    ConferenceResp resp = new ConferenceResp();
-    String confdate=req.getConfdate();
-    if(StringUtil.isEmpty(confdate)){
-      resp.setRetcode(99);
-      resp.setRetmsg("日期为空");
-      return resp;
-    }
-    String devphyid=req.getDevphyid();
-    if(StringUtil.isEmpty(devphyid)){
-      resp.setRetcode(99);
-      resp.setRetmsg("设备物理id为空");
-      return resp;
-    }
-    TNcDevice device=ncService.getDevInfoByDevphyid(devphyid);
-    if(null==device){
-      resp.setRetcode(9);
-      resp.setRetmsg("设备不存在");
-      return resp;
-    }
+    @RequestMapping(value = "/getconference", method = RequestMethod.POST)
+    @ResponseBody
+    public ConferenceResp getConferenceToday(@ModelAttribute ConferenceReq req) {
+        ConferenceResp resp = new ConferenceResp();
+        String confdate = req.getConfdate();
+        if (StringUtil.isEmpty(confdate)) {
+            resp.setRetcode(99);
+            resp.setRetmsg("日期为空");
+            return resp;
+        }
+        String devphyid = req.getDevphyid();
+        if (StringUtil.isEmpty(devphyid)) {
+            resp.setRetcode(99);
+            resp.setRetmsg("设备物理id为空");
+            return resp;
+        }
+        TNcDevice device = ncService.getDevInfoByDevphyid(devphyid);
+        if (null == device) {
+            resp.setRetcode(9);
+            resp.setRetmsg("设备不存在");
+            return resp;
+        }
 
-    List<ConferenceApiBean> conflist=conferenceService.getConferneceForDevice(confdate);
-    resp.setConflist(conflist);
-    resp.setCount(conflist.size());
-    resp.setRetmsg("OK");
-    resp.setRetcode(0);
-    return resp;
-  }
-
-
-  @RequestMapping(value = "/getattrate", method = RequestMethod.POST)
-  @ResponseBody
-  public ConfrateResp getConferenceAttendRate(@ModelAttribute ConfrateReq req) {
-    ConfrateResp resp =new ConfrateResp();
-    Integer confid=req.getConfid();
-    if(null==confid){
-      resp.setRetcode(99);
-      resp.setRetmsg("会议id为空");
-      return resp;
-    }
-
-    TConference conf=conferenceService.getConferenceById(confid);
-    if(null==conf){
-      resp.setRetcode(99);
-      resp.setRetmsg("会议不存在");
-      return resp;
-    }
-    Integer totcnt=0;
-    Integer actualcnt=0;
-    Float rate=0f;
-    if(ConferenceConstant.CONFTYPE_LIST.equals(conf.getConftype())){
-      totcnt=conferenceService.getConfPeopleCount(confid,null);
-      List<String> list=new ArrayList<>();
-      list.add(ConferenceConstant.ATTENDSTATUS_CHECKED);
-      list.add(ConferenceConstant.ATTENDSTATUS_LATE);
-      actualcnt=conferenceService.getConfPeopleCount(confid,list);
-      if(0!=totcnt){
-        rate=actualcnt*100f/totcnt;
-      }
-      resp.setActualcnt(actualcnt);
-      resp.setAttrate(rate);
-      resp.setTotcnt(totcnt);
-    }else{
-      totcnt=conferenceService.getNolistConfPeopleCount(confid);
-      resp.setActualcnt(0);
-      resp.setTotcnt(totcnt);
-    }
-    resp.setRetcode(0);
-    resp.setRetmsg("ok");
-    return  resp;
-  }
-
-
-  @RequestMapping(value = "/getconfpeople", method = RequestMethod.POST)
-  @ResponseBody
-  public ConfPeopleResp getConfPeoples(@ModelAttribute ConfPeopleReq req) {
-    ConfPeopleResp resp=new ConfPeopleResp();
-    String confdate=req.getConfdate();
-    if(StringUtil.isEmpty(confdate)){
-      resp.setRetcode(99);
-      resp.setRetmsg("会议日期为空");
-      return resp;
-    }
-    String devphyid=req.getDevphyid();
-    if(StringUtil.isEmpty(devphyid)){
-      resp.setRetcode(99);
-      resp.setRetmsg("设备物理id为空");
-      return resp;
-    }
-
-    List<ConfPeopleApiBean> lst=conferenceService.getConfPeopleListByDevphyid(devphyid,confdate);
-    resp.setCount(lst.size());
-    resp.setPeoplelist(lst);
-    resp.setRetcode(0);
-    resp.setRetmsg("ok");
-    return resp;
-  }
-
-
-  @RequestMapping(value = "/doattend", method = RequestMethod.POST)
-  @ResponseBody
-  public ApiResponse doAttend(@ModelAttribute ConfAttendReq req) {
-    ApiResponse resp=new ApiResponse();
-    String userid=req.getUserid();
-    Integer confid=req.getConfid();
-    String timestamp=req.getTimestamp();
-    String devphyid=req.getDevphyid();
-    if(StringUtil.isEmpty(userid)||null==confid||StringUtil.isEmpty(timestamp)||StringUtil.isEmpty(devphyid)){
-      resp.setRetcode(99);
-      resp.setRetmsg("参数传递错误");
-      return resp;
-    }
-    TCustomer customer=webInterfaceService.findCustomerById(userid);
-    if(null==customer){
-      resp.setRetcode(99);
-      resp.setRetmsg("客户不存在");
-      return resp;
-    }
-
-    TConference conference=conferenceService.getConferenceById(confid);
-    if(null==conference){
-      resp.setRetcode(99);
-      resp.setRetmsg("会议不存在");
-      return resp;
-    }
-
-    TNcDevice device=conferenceService.getBindedDevice(confid);
-    if(null==device){
-      resp.setRetcode(99);
-      resp.setRetmsg("请在会议绑定的设备上打卡");
-      return resp;
-    }
-
-    String now= DateUtil.getNow("yyyyMMddHHmmss");
-    String downcheck=DateUtil.getNewTime(now,-60*5);
-    String upcheck=DateUtil.getNewTime(now,60*5);
-
-    if (DateUtil.compareDatetime(timestamp, downcheck) < 0||DateUtil.compareDatetime(timestamp, upcheck)>0) {
-      resp.setRetcode(5);
-      resp.setRetmsg("时间误差过大");
-      return resp;
-    }
-
-    String attdate=DateUtil.getNow("yyyyMMdd");
-    String atttime=DateUtil.getNow("HHmm");
-
-    int compareAttend=DateUtil.compareDatetime(atttime,conference.getAttendtime(),"HHmm");
-    int compareStart=DateUtil.compareDatetime(atttime,conference.getStarttime(),"HHmm");
-
-    if(-1==compareAttend){
-      resp.setRetcode(6);
-      resp.setRetmsg("会议签到时间尚未开始，请在签到时间之后再打卡");
-      return resp;
-    }
-    String attstatus;
-    if(-1==compareStart){
-      attstatus= ConferenceConstant.ATTENDSTATUS_CHECKED;
-    }else{
-      attstatus=ConferenceConstant.ATTENDSTATUS_LATE;
-    }
-    if(ConferenceConstant.CONFTYPE_NOLIST.equals(conference.getConftype())){
-      TNolistConfPeople people=new TNolistConfPeople();
-
-      people.setAttstatus(attstatus);
-   //   people.setCardno(dtl.getCardno());
-      people.setConfid(conference.getConfid());
-      people.setCustid(customer.getCustid());
-      people.setAtttime(atttime);
-      people.setCustname(customer.getCustname());
-      people.setAtttype(ConferenceConstant.ATTTYPE_SELF);
-      people.setLastsaved(DateUtil.getNow());
-      conferenceService.saveNolistConfPeople(people);
-    }else{
-      TConfPeople people=conferenceService.getTConfPeopleByConfidAndCustid(conference.getConfid(),customer.getCustid());
-      if(null==people){
-        resp.setRetcode(7);
-        resp.setRetmsg("打卡人员不在会议名单中");
+        List<ConferenceApiBean> conflist = conferenceService.getConferneceForDevice(confdate);
+        resp.setConflist(conflist);
+        resp.setCount(conflist.size());
+        resp.setRetmsg("OK");
+        resp.setRetcode(0);
         return resp;
-      }
-      people.setAttstatus(attstatus);
-      people.setAtttime(atttime);
-      conferenceService.saveConfPeople(people);
     }
-   /* TConfDtl dtl=new TConfDtl();
-    dtl.setUpdateflag(0);
-    dtl.setAttdate();
-    dtl.setAtttime();
-    dtl.setCardno();*/
-  /*  resp.setCount(lst.size());
-    resp.setPeoplelist(lst);
-    resp.setRetcode(0);
-    resp.setRetmsg("ok");*/
-    resp.setRetcode(0);
-    resp.setRetmsg("打卡成功");
-    return resp;
-  }
+
+
+    @RequestMapping(value = "/getattrate", method = RequestMethod.POST)
+    @ResponseBody
+    public ConfrateResp getConferenceAttendRate(@ModelAttribute ConfrateReq req) {
+        ConfrateResp resp = new ConfrateResp();
+        Integer confid = req.getConfid();
+        if (null == confid) {
+            resp.setRetcode(99);
+            resp.setRetmsg("会议id为空");
+            return resp;
+        }
+
+        TConference conf = conferenceService.getConferenceById(confid);
+        if (null == conf) {
+            resp.setRetcode(99);
+            resp.setRetmsg("会议不存在");
+            return resp;
+        }
+        Integer totcnt = 0;
+        Integer actualcnt = 0;
+        Float rate = 0f;
+        if (ConferenceConstant.CONFTYPE_LIST.equals(conf.getConftype())) {
+            totcnt = conferenceService.getConfPeopleCount(confid, null);
+            List<String> list = new ArrayList<>();
+            list.add(ConferenceConstant.ATTENDSTATUS_CHECKED);
+            list.add(ConferenceConstant.ATTENDSTATUS_LATE);
+            actualcnt = conferenceService.getConfPeopleCount(confid, list);
+            if (0 != totcnt) {
+                rate = actualcnt * 100f / totcnt;
+            }
+            resp.setActualcnt(actualcnt);
+            resp.setAttrate(rate);
+            resp.setTotcnt(totcnt);
+        } else {
+            actualcnt = conferenceService.getNolistConfPeopleCount(confid);
+            resp.setActualcnt(actualcnt);
+            resp.setTotcnt(totcnt);
+            resp.setAttrate(rate);
+        }
+        resp.setRetcode(0);
+        resp.setRetmsg("ok");
+        return resp;
+    }
+
+
+    @RequestMapping(value = "/getconfpeople", method = RequestMethod.POST)
+    @ResponseBody
+    public ConfPeopleResp getConfPeoples(@ModelAttribute ConfPeopleReq req) {
+        ConfPeopleResp resp = new ConfPeopleResp();
+        Integer confid = req.getConfid();
+        TConference conference = conferenceService.getConferenceById(confid);
+        if (null == conference) {
+            resp.setRetmsg("");
+        }
+
+        List<ConfPeopleApiBean> lst = conferenceService.getConfPeopleListByConfid(confid, conference.getConftype());
+        resp.setCount(lst.size());
+        resp.setPeoplelist(lst);
+        resp.setRetcode(0);
+        resp.setRetmsg("ok");
+        return resp;
+    }
+
+
+    @RequestMapping(value = "/doattend")
+    @ResponseBody
+    public ModelAndView doAttend(@ModelAttribute ConfAttendReq req) {
+        ModelAndView mov = new ModelAndView();
+        String userid = req.getUserid();
+        Integer confid = req.getConfid();
+        String timestamp = req.getTimestamp();
+        String devphyid = req.getDevphyid();
+        if (null == confid || StringUtil.isEmpty(timestamp) || StringUtil.isEmpty(devphyid)) {
+            mov.addObject("msg", "签到失败");
+            mov.addObject("errorMsg", "参数传递错误");
+            mov.setViewName("apph5/confresult");
+            return mov;
+        }
+
+
+        TConference conference = conferenceService.getConferenceById(confid);
+        if (null == conference) {
+            mov.addObject("msg", "签到失败");
+            mov.addObject("errorMsg", "会议不存在");
+            mov.setViewName("apph5/confresult");
+            return mov;
+        }
+
+        TNcDevice device = conferenceService.getBindedDevice(confid);
+        if (null == device) {
+            mov.addObject("msg", "签到失败");
+            mov.addObject("errorMsg", "请在会议绑定的设备上打卡");
+
+            mov.setViewName("apph5/confresult");
+            return mov;
+        }
+
+        String now = DateUtil.getNow("yyyyMMddHHmmss");
+        String downcheck = DateUtil.getNewTime(now, -60 * 5);
+        String upcheck = DateUtil.getNewTime(now, 60 * 5);
+
+        if (DateUtil.compareDatetime(timestamp, downcheck) < 0 || DateUtil.compareDatetime(timestamp, upcheck) > 0) {
+            mov.addObject("msg", "签到失败");
+            mov.addObject("errorMsg", "时间误差过大");
+            mov.setViewName("apph5/confresult");
+            return mov;
+        }
+
+        if(StringUtil.isEmpty(userid)){
+            mov.addObject("confid",confid);
+            mov.setViewName("apph5/tempattend");
+            return mov;
+        }
+
+        TCustomer customer = webInterfaceService.findCustomerById(userid);
+        if (null == customer) {
+            mov.addObject("msg", "签到失败");
+            mov.addObject("errorMsg", "客户不存在");
+            mov.setViewName("apph5/confresult");
+            return mov;
+        }
+
+        String atttime = DateUtil.getNow("HHmm");
+
+        int compareAttend = DateUtil.compareDatetime(atttime, conference.getAttendtime(), "HHmm");
+        int compareStart = DateUtil.compareDatetime(atttime, conference.getStarttime(), "HHmm");
+
+        if (-1 == compareAttend) {
+            mov.addObject("msg", "签到失败");
+            mov.addObject("errorMsg", "会议签到时间尚未开始，请在签到时间之后再打卡");
+            mov.setViewName("apph5/confresult");
+            return mov;
+        }
+        String attstatus;
+        if (-1 == compareStart) {
+            attstatus = ConferenceConstant.ATTENDSTATUS_CHECKED;
+        } else {
+            attstatus = ConferenceConstant.ATTENDSTATUS_LATE;
+        }
+
+        if (ConferenceConstant.CONFTYPE_NOLIST.equals(conference.getConftype())) {
+            TNolistConfPeople opeople = conferenceService.getNolistConfPeopleByConfidAndCustid(confid, customer.getCustid());
+            if (null != opeople) {
+                mov.addObject("msg", "签到失败");
+                mov.addObject("errorMsg", "请勿重复签到");
+                mov.setViewName("apph5/confresult");
+                return mov;
+            }
+
+            TNolistConfPeople people = new TNolistConfPeople();
+
+            people.setAttstatus(attstatus);
+            //   people.setCardno(dtl.getCardno());
+            people.setConfid(conference.getConfid());
+            people.setCustid(customer.getCustid());
+            people.setAtttime(atttime);
+            people.setCustname(customer.getCustname());
+            people.setAtttype(ConferenceConstant.ATTTYPE_SELF);
+            people.setLastsaved(DateUtil.getNow());
+            conferenceService.saveNolistConfPeople(people);
+        } else {
+            TConfPeople people = conferenceService.getTConfPeopleByConfidAndCustid(conference.getConfid(), customer.getCustid());
+            if (null == people) {
+                mov.addObject("msg", "签到失败");
+                mov.addObject("errorMsg", "打卡人员不在会议名单中");
+                mov.setViewName("apph5/confresult");
+                return mov;
+            }
+            if (!ConferenceConstant.ATTENDSTATUS_CHECKED.equals(people.getAttstatus())) {
+                mov.addObject("msg", "签到失败");
+                mov.addObject("errorMsg", "请勿重复签到");
+                mov.setViewName("apph5/confresult");
+                return mov;
+            }
+
+            if (!ConferenceConstant.ATTENDSTATUS_INSTEAD.equals(people.getAttstatus())) {
+                people.setAttstatus(attstatus);
+            }
+            people.setAtttime(atttime);
+            conferenceService.saveConfPeople(people);
+        }
+
+        mov.addObject("msg", "签到成功");
+        mov.addObject("remarkTitle", "会议概要");
+        mov.addObject("remark", conference.getRemark());
+        mov.setViewName("apph5/confresult");
+        return mov;
+    }
 
     @RequestMapping(value = "/test", method = RequestMethod.POST)
-  @ResponseBody
-  public ApiResponse test() {
-    ApiResponse resp=new ApiResponse();
-    resp.setRetmsg("OK");
-    resp.setRetcode(0);
-    return resp;
-  }
+    @ResponseBody
+    public ApiResponse test() {
+        ApiResponse resp = new ApiResponse();
+        resp.setRetmsg("OK");
+        resp.setRetcode(0);
+        return resp;
+    }
 }
diff --git a/src/main/java/com/supwisdom/dlpay/conference/controller/ConfPeopleController.java b/src/main/java/com/supwisdom/dlpay/conference/controller/ConfPeopleController.java
index 35dc941..484394d 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/controller/ConfPeopleController.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/controller/ConfPeopleController.java
@@ -109,9 +109,7 @@
         try{
             if(!ConferenceConstant.ATTENDSTATUS_INSTEAD.equals(attstatus)){
                 insteadcustid="";
-                remark="";
             }
-
             return conferenceService.updateConfPeople(pid,conftype,insteadcustid,attstatus,remark);
         }catch (Exception e){
             e.printStackTrace();
diff --git a/src/main/java/com/supwisdom/dlpay/conference/controller/ConfReportController.java b/src/main/java/com/supwisdom/dlpay/conference/controller/ConfReportController.java
index de20159..2e18caa 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/controller/ConfReportController.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/controller/ConfReportController.java
@@ -40,9 +40,9 @@
 
     @GetMapping("/confreport/index")
     public String ConferenceView(Model model) {
-      /*  String today = DateUtil.getNow("yyyy-MM-dd");
+        String today = DateUtil.getNow("yyyy-MM-dd");
 
-        model.addAttribute("confDate", today);*/
+        model.addAttribute("confDate", today);
         return "confreport/index";
     }
 
@@ -84,14 +84,7 @@
             @RequestParam(value ="attstatus", required = false) String attstatus,
             @RequestParam(value ="deptcode", required = false) String deptcode) {
         try {
-            List<String> statuslist=new ArrayList<>();
-            if(!StringUtil.isEmpty(attstatus)){
-                statuslist.add(attstatus);
-            }else{
-                statuslist.add(ConferenceConstant.ATTENDSTATUS_CHECKED);
-                statuslist.add(ConferenceConstant.ATTENDSTATUS_LATE);
-            }
-            return conferenceService.getConfPeopleReport(confid,searchkey, statuslist,deptcode);
+            return conferenceService.getConfPeopleReport(confid,searchkey, attstatus,deptcode,"not");
         } catch (Exception e) {
             e.printStackTrace();
             return new PageResult<>(99, "系统查询错误");
@@ -106,14 +99,7 @@
             @RequestParam(value ="attstatus", required = false) String attstatus,
             @RequestParam(value ="deptcode", required = false) String deptcode) {
         try {
-            List<String> statuslist=new ArrayList<>();
-            if(!StringUtil.isEmpty(attstatus)){
-                statuslist.add(attstatus);
-            }else{
-                statuslist.add(ConferenceConstant.ATTENDSTATUS_INSTEAD);
-                statuslist.add(ConferenceConstant.ATTENDSTATUS_UNCHECK);
-            }
-            return conferenceService.getConfPeopleReport(confid, searchkey,statuslist,deptcode);
+            return conferenceService.getConfPeopleReport(confid, searchkey,attstatus,deptcode,"");
         } catch (Exception e) {
             e.printStackTrace();
             return new PageResult<>(99, "系统查询错误");
diff --git a/src/main/java/com/supwisdom/dlpay/conference/controller/ConferenceController.java b/src/main/java/com/supwisdom/dlpay/conference/controller/ConferenceController.java
index c3a32dd..e8bae7a 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/controller/ConferenceController.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/controller/ConferenceController.java
@@ -12,8 +12,12 @@
 import com.supwisdom.dlpay.conference.service.ConferenceService;
 import com.supwisdom.dlpay.conference.util.ConferenceConstant;
 import com.supwisdom.dlpay.conference.util.QRCodeUtil;
+import com.supwisdom.dlpay.customer.bean.CustomerSearchBean;
+import com.supwisdom.dlpay.doorlist.bean.TCustomerImportBean;
+import com.supwisdom.dlpay.doorlist.bean.TCustomerInfo;
 import com.supwisdom.dlpay.framework.domain.TOperator;
 import com.supwisdom.dlpay.framework.util.*;
+import com.supwisdom.dlpay.mainservice.service.WebInterfaceService;
 import com.supwisdom.dlpay.ncmgr.domain.TNcDevice;
 import com.supwisdom.dlpay.ncmgr.service.NcService;
 import com.supwisdom.dlpay.util.WebCheckException;
@@ -40,6 +44,8 @@
     private ConferenceService conferenceService;
     @Autowired
     private NcService ncService;
+    @Autowired
+    private WebInterfaceService webInterfaceService;
 
 
     @GetMapping("/conference/index")
@@ -126,6 +132,7 @@
                                      @RequestParam("endtime") String endtime,
                                      @RequestParam("attendtime") String attendtime,
                                      @RequestParam("deviceid") Integer deviceid,
+                                     @RequestParam("remark") String remark,
                                      //    @RequestParam(value = "file", required = false) MultipartFile file,
                                      @AuthenticationPrincipal UserDetails operUser,
                                      HttpServletRequest request) {
@@ -146,20 +153,8 @@
             if (null == oper || StringUtil.isEmpty(oper.getOperid())) {
                 return JsonResult.error("登录过期，请重新登录");
             }
-           /* String path = request.getSession().getServletContext().getRealPath("upload");
 
-            String fpath = null;
-            if (null != file) {
-                String fileName = file.getOriginalFilename();
-                File targetFile = new File(path, fileName);
-                if (!targetFile.exists()) {
-                    targetFile.mkdirs();
-                }
-                file.transferTo(targetFile);
-                fpath = path + "/" + fileName;
-            }*/
-
-            if (conferenceService.saveNewConference(confname.trim(), DateUtil.unParseToDateFormat(confdate), conftype, DateUtil.unParseToDateFormat(starttime), DateUtil.unParseToDateFormat(endtime), DateUtil.unParseToDateFormat(attendtime), oper,  deviceid)) {
+            if (conferenceService.saveNewConference(confname.trim(), DateUtil.unParseToDateFormat(confdate), conftype, DateUtil.unParseToDateFormat(starttime), DateUtil.unParseToDateFormat(endtime), DateUtil.unParseToDateFormat(attendtime), oper,  deviceid,remark)) {
                 return JsonResult.ok("新增成功");
             } else {
                 return JsonResult.error("新增失败");
@@ -248,9 +243,12 @@
     }
 
     @GetMapping("/conference/loadimport")
-    public String loadimport(@RequestParam("confid") Integer confid, Model model) {
+    public String loadimport(@RequestParam("confid") Integer confid,
+                             @RequestParam("confname") String confname,Model model) {
         model.addAttribute("detailConfid", confid);
-        return "conference/import";
+        model.addAttribute("confName", confname);
+
+        return "conference/confpeoplebind";
     }
 
     @PostMapping("/conference/doimport")
@@ -286,4 +284,47 @@
         }
 
     }
+
+
+    @PostMapping("/conference/addconfpeople")
+    @ResponseBody
+    public JsonResult addConfpeople(@RequestParam("confid") Integer confid,
+                                    @RequestParam("cardnos[]") List<String> cardnos) {
+        try {
+            if (null == confid || StringUtil.isEmpty(cardnos)) {
+                return JsonResult.error("参数传递错误");
+            }
+
+            if (conferenceService.saveConferencePeople(confid, cardnos)) {
+                return JsonResult.ok("人员添加成功");
+            } else {
+                return JsonResult.error("添加失败");
+            }
+        } catch (WebCheckException ex) {
+            return JsonResult.error(ex.getMessage());
+        } catch (Exception e) {
+            e.printStackTrace();
+            return JsonResult.error("系统处理异常").put("exception", e);
+        }
+
+    }
+
+    @RequestMapping("/conference/listpeopleforimport")
+    @ResponseBody
+    public PageResult<TCustomerImportBean> listConfpeople(
+                                                 @RequestParam(value = "custname", required = false) String custname,
+                                                 @RequestParam(value = "deptcode", required = false) String deptcode,
+                                                 @AuthenticationPrincipal TOperator operUser) {
+        try {
+            CustomerSearchBean searchBean = new CustomerSearchBean();
+            searchBean.setCustname(custname);
+            searchBean.setDeptcode(deptcode);
+            PageResult<TCustomerImportBean> bean = webInterfaceService.getCustomerInfo(searchBean);
+            return bean;
+        } catch (Exception e) {
+            e.printStackTrace();
+            return new PageResult<>(99, "系统查询错误");
+        }
+    }
+
 }
\ No newline at end of file
diff --git a/src/main/java/com/supwisdom/dlpay/conference/dao/ConfPeopleDao.java b/src/main/java/com/supwisdom/dlpay/conference/dao/ConfPeopleDao.java
index c3d3f74..c8f127d 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/dao/ConfPeopleDao.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/dao/ConfPeopleDao.java
@@ -21,5 +21,7 @@
 
     int countByConfid(Integer confid);
 
+    int countByConfidAndCustidAndAttstatusNot(Integer confid,String custid,String attstatus);
+
     int countByConfidAndAttstatusIn(Integer confid, List<String> attstatus);
 }
diff --git a/src/main/java/com/supwisdom/dlpay/conference/dao/NolistConfPeopleDao.java b/src/main/java/com/supwisdom/dlpay/conference/dao/NolistConfPeopleDao.java
index 4f8abc1..926a9bd 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/dao/NolistConfPeopleDao.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/dao/NolistConfPeopleDao.java
@@ -10,4 +10,5 @@
 public interface NolistConfPeopleDao extends JpaRepository<TNolistConfPeople, String> {
     int countByConfid(int confid);
 
+    TNolistConfPeople findByConfidAndCustid(Integer confid,String custid);
 }
diff --git a/src/main/java/com/supwisdom/dlpay/conference/service/ConferenceService.java b/src/main/java/com/supwisdom/dlpay/conference/service/ConferenceService.java
index a25b7bc..d08a12a 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/service/ConferenceService.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/service/ConferenceService.java
@@ -48,11 +48,13 @@
 
     @Transactional(rollbackFor = Exception.class)
     boolean saveNewConference(String confname,String confdate, String conftype, String starttime,
-                              String endtime, String attendtime, TOperator oper, Integer deviceid) throws Exception;
+                              String endtime, String attendtime, TOperator oper, Integer deviceid,String remark) throws Exception;
 
     @Transactional(rollbackFor = Exception.class)
     boolean saveConferencePeopleByExcel(Integer confid,String fpath) throws Exception;
 
+    @Transactional(rollbackFor = Exception.class)
+    boolean saveConferencePeople(Integer confid,List<String> cardnos) throws Exception;
 
     @Transactional(rollbackFor = Exception.class, readOnly = true)
     PageResult<TConfPeople> getConferenceDetails(String searchkey, int confid, int pageNo, int pageSize);
@@ -79,12 +81,15 @@
     PageResult<ConfpeopleShowBean> getConfPeoplePage(Integer confid, String attstatus,String atttype, int pageNo, int pageSize);
 
     @Transactional(rollbackFor = Exception.class, readOnly = true)
-    PageResult<ConfpeopleReportBean> getConfPeopleReport(Integer confid, String searchkey,List<String> attstatus, String deptcode);
+    PageResult<ConfpeopleReportBean> getConfPeopleReport(Integer confid, String searchkey,String attstatus, String deptcode,String attflag);
 
     @Transactional(rollbackFor = Exception.class, readOnly = true)
     TConfPeople getTConfPeopleByConfidAndCustid(Integer confid,String custid) ;
 
     @Transactional(rollbackFor = Exception.class, readOnly = true)
+    TNolistConfPeople getNolistConfPeopleByConfidAndCustid(Integer confid,String custid) ;
+
+    @Transactional(rollbackFor = Exception.class, readOnly = true)
     Integer getConfPeopleCount(Integer confid,List<String> status) ;
 
     @Transactional(rollbackFor = Exception.class, readOnly = true)
@@ -93,5 +98,7 @@
     @Transactional(rollbackFor = Exception.class, readOnly = true)
     List<ConfPeopleApiBean> getConfPeopleListByDevphyid(String devphyid, String confdate) ;
 
+    @Transactional(rollbackFor = Exception.class, readOnly = true)
+    List<ConfPeopleApiBean> getConfPeopleListByConfid(Integer confid, String conftype) ;
 
 }
diff --git a/src/main/java/com/supwisdom/dlpay/conference/service/impl/ConferenceServiceImpl.java b/src/main/java/com/supwisdom/dlpay/conference/service/impl/ConferenceServiceImpl.java
index d765a28..fc79f29 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/service/impl/ConferenceServiceImpl.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/service/impl/ConferenceServiceImpl.java
@@ -11,7 +11,6 @@
 import com.supwisdom.dlpay.conference.domain.*;
 import com.supwisdom.dlpay.conference.service.ConferenceService;
 import com.supwisdom.dlpay.conference.util.ConferenceConstant;
-import com.supwisdom.dlpay.doorlist.bean.CustomerListBean;
 import com.supwisdom.dlpay.doorlist.bean.TCustomerInfo;
 import com.supwisdom.dlpay.framework.domain.TOperator;
 import com.supwisdom.dlpay.framework.service.SystemUtilService;
@@ -19,8 +18,6 @@
 import com.supwisdom.dlpay.framework.util.PageResult;
 import com.supwisdom.dlpay.framework.util.StringUtil;
 import com.supwisdom.dlpay.mainservice.dao.CustomerDao;
-import com.supwisdom.dlpay.mainservice.domain.TCard;
-import com.supwisdom.dlpay.mainservice.domain.TCustomer;
 import com.supwisdom.dlpay.mainservice.service.WebInterfaceService;
 import com.supwisdom.dlpay.ncmgr.dao.NcDeviceDao;
 import com.supwisdom.dlpay.ncmgr.domain.TNcDevice;
@@ -36,7 +33,6 @@
 import org.springframework.data.domain.Sort;
 import org.springframework.data.jpa.domain.Specification;
 import org.springframework.stereotype.Service;
-import org.springframework.web.multipart.MultipartFile;
 
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
@@ -256,7 +252,7 @@
     }*/
 
     @Override
-    public boolean saveNewConference(String confname,String confdate, String conftype, String starttime, String endtime,String attendtime, TOperator oper, Integer deviceid) throws Exception {
+    public boolean saveNewConference(String confname,String confdate, String conftype, String starttime, String endtime,String attendtime, TOperator oper, Integer deviceid,String remark) throws Exception {
 
         String errdevname=checkTimeErrorDevice(attendtime,endtime,confdate,deviceid);
         if(!StringUtil.isEmpty(errdevname)){
@@ -276,6 +272,7 @@
         String systime = DateUtil.getNow();
         conf.setCreatetime(systime);
         conf.setLastsaved(systime);
+        conf.setRemark(remark);
         conf = conferenceDao.save(conf);
 
         TConferenceDevbind bind=new TConferenceDevbind();
@@ -323,12 +320,8 @@
                 if(customerlist.size()>0){
                     customer=customerlist.get(0);
                 }
-                if (!StringUtil.isEmpty(cardno)) {
-                    if (null == customer) {
-                        msg += "，市民卡用户不存在";
-                    } else if (!customer.getCustname().equals(name)) {
-                        msg += "，市民卡号与姓名不匹配！";
-                    }
+                if (!customer.getCustname().equals(name)) {
+                    msg += "，市民卡号与姓名不匹配！";
                 }
                 if (!StringUtil.isEmpty(cardno) && successCardnos.contains(cardno)) {
                     msg += "，市民卡号重复！";
@@ -368,6 +361,23 @@
         return true;
     }
 
+    @Override
+    public boolean saveConferencePeople(Integer confid, List<String> cardnos) throws Exception {
+        for (String card :cardnos) {
+            TCustomerInfo customer=new TCustomerInfo();
+            List<TCustomerInfo> customerlist = webInterfaceService.getAllTCustomerList(null,card,null);
+            if(customerlist.size()>0){
+                customer=customerlist.get(0);
+            }else{
+                throw new WebCheckException("客户[" + card + "]不存在");
+            }
+            String atttype=ConferenceConstant.ATTTYPE_SELF;
+            String custid=customer.getCustid();
+            saveNewConfPeople(confid,customer.getCardno(),customer.getCustname(),atttype,custid);
+        }
+        return true;
+    }
+
     private void saveNewConfPeople(Integer confid, String cardno, String name, String atttype, String custid) {
         TConfPeople people = new TConfPeople();
         people.setAttstatus(ConferenceConstant.ATTENDSTATUS_UNCHECK);
@@ -460,6 +470,7 @@
             people.setAttstatus(attstatus);
             people.setRemark(remark);
             nolistConfPeopleDao.save(people);
+
         }else{
             TConfPeople people=confPeopleDao.getOne(pid);
             if(null==people){
@@ -484,6 +495,9 @@
             people.setInsteadcustid(insteadcustid);
             people.setAttstatus(attstatus);
             people.setRemark(remark);
+            if(ConferenceConstant.ATTENDSTATUS_HANDCHECK.equals(attstatus)){
+                people.setAtttime("----");
+            }
             confPeopleDao.save(people);
 
 
@@ -545,7 +559,7 @@
     }
 
     @Override
-    public PageResult<ConfpeopleReportBean> getConfPeopleReport(Integer confid,String searchkey, List<String> attstatus, String deptcode) {
+    public PageResult<ConfpeopleReportBean> getConfPeopleReport(Integer confid,String searchkey, String attstatus, String deptcode,String attflag) {
         TConference conf=conferenceDao.findByConfid(confid);
         if(null==conf){
             return null;
@@ -561,9 +575,9 @@
                 "left join t_customer c on b.custid=c.custid " +
                 "left join tb_dept d on c.deptcode=d.deptcode " +
                 "left join t_customer e on b.insteadcustid=e.custid " +
-                "where b.confid=:confid ");
+                "where b.confid=:confid and b.atttime is "+attflag +" null ");
         if (!StringUtil.isEmpty(attstatus)) {
-            querySql.append(" and b.attstatus in ('"+ StringUtils.join(attstatus.toArray(),"','")+"') ");
+            querySql.append(" and b.attstatus=:attstatus ");
         }
         if(!StringUtil.isEmpty(deptcode)){
             List<String> deptlist=customerDao.getChildDeptlist(deptcode);
@@ -583,6 +597,9 @@
         if(!StringUtil.isEmpty(searchkey)){
             query.setParameter("searchkey", searchkey);
         }
+        if(!StringUtil.isEmpty(attstatus)){
+            query.setParameter("attstatus", attstatus);
+        }
 
         query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.aliasToBean(ConfpeopleReportBean.class));
         List<ConfpeopleReportBean> list = query.getResultList();
@@ -596,6 +613,12 @@
     }
 
     @Override
+    public TNolistConfPeople getNolistConfPeopleByConfidAndCustid(Integer confid, String custid) {
+        return nolistConfPeopleDao.findByConfidAndCustid(confid,custid);
+
+    }
+
+    @Override
     public Integer getConfPeopleCount(Integer confid,List<String> status) {
         if(StringUtil.isEmpty(status)){
             return confPeopleDao.countByConfid( confid);
@@ -631,6 +654,25 @@
         return list;
     }
 
+    @Override
+    public List<ConfPeopleApiBean> getConfPeopleListByConfid(Integer confid, String conftype) {
+        String table="tb_conf_people";
+        if(ConferenceConstant.CONFTYPE_NOLIST.equals(conftype)){
+            table="tb_nolist_confpeople";
+        }
+        StringBuffer querySql=new StringBuffer("select a.custname,a.attstatus,a.atttime,c.deptname,d.custtypename from "+table+" a " +
+                "left join t_customer b on a.custid=b.custid " +
+                "left join tb_dept c on b.deptcode=c.deptcode " +
+                "left join tb_custtype d on b.custtypeid=d.custtypeid "+
+                    "where confid=:confid");
+        Query query = entityManager.createNativeQuery(querySql.toString());
+        query.setParameter("confid",confid);
+        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.aliasToBean(ConfPeopleApiBean.class));
+        List<ConfPeopleApiBean> list = query.getResultList();
+        return list;
+
+    }
+
 
     private String checkConfTimeError(String attendtime, String endtime,String confdate,String cardno) {
         Query query = entityManager.createNativeQuery("select a.confname from tb_conference a,TB_Conf_People b where a.confid=b.confid  " +
diff --git a/src/main/java/com/supwisdom/dlpay/conference/util/ConferenceConstant.java b/src/main/java/com/supwisdom/dlpay/conference/util/ConferenceConstant.java
index d967edf..c12d668 100644
--- a/src/main/java/com/supwisdom/dlpay/conference/util/ConferenceConstant.java
+++ b/src/main/java/com/supwisdom/dlpay/conference/util/ConferenceConstant.java
@@ -18,6 +18,7 @@
     public static final String ATTENDSTATUS_LATE="late";//迟到
     public static final String ATTENDSTATUS_CLOSED="closed";//关闭
     public static final String ATTENDSTATUS_INSTEAD="instead";//代签
+    public static final String ATTENDSTATUS_HANDCHECK="handcheck";//手工签到
 
     public static final String ATTTYPE_SELF="self";
     public static final String ATTTYPE_INSTEAD="instead";
diff --git a/src/main/java/com/supwisdom/dlpay/doorlist/bean/TCustomerImportBean.java b/src/main/java/com/supwisdom/dlpay/doorlist/bean/TCustomerImportBean.java
new file mode 100644
index 0000000..2c915c9
--- /dev/null
+++ b/src/main/java/com/supwisdom/dlpay/doorlist/bean/TCustomerImportBean.java
@@ -0,0 +1,43 @@
+package com.supwisdom.dlpay.doorlist.bean;
+
+import javax.persistence.Entity;
+import javax.persistence.Id;
+
+public class TCustomerImportBean {
+    private String custname;
+    private String cardno;
+    private String deptname;
+    private String custid;
+
+    public String getCustname() {
+        return custname;
+    }
+
+    public void setCustname(String custname) {
+        this.custname = custname;
+    }
+
+    public String getCardno() {
+        return cardno;
+    }
+
+    public void setCardno(String cardno) {
+        this.cardno = cardno;
+    }
+
+    public String getDeptname() {
+        return deptname;
+    }
+
+    public void setDeptname(String deptname) {
+        this.deptname = deptname;
+    }
+
+    public String getCustid() {
+        return custid;
+    }
+
+    public void setCustid(String custid) {
+        this.custid = custid;
+    }
+}
diff --git a/src/main/java/com/supwisdom/dlpay/mainservice/dao/CustomerDao.java b/src/main/java/com/supwisdom/dlpay/mainservice/dao/CustomerDao.java
index 8baff67..da3e237 100644
--- a/src/main/java/com/supwisdom/dlpay/mainservice/dao/CustomerDao.java
+++ b/src/main/java/com/supwisdom/dlpay/mainservice/dao/CustomerDao.java
@@ -2,6 +2,7 @@
 
 import com.supwisdom.dlpay.customer.bean.CustomerSearchBean;
 import com.supwisdom.dlpay.customer.bean.TCustomerExportBean;
+import com.supwisdom.dlpay.doorlist.bean.TCustomerImportBean;
 import com.supwisdom.dlpay.doorlist.bean.TCustomerInfo;
 import com.supwisdom.dlpay.framework.util.PageResult;
 import com.supwisdom.dlpay.mainservice.domain.TCustomer;
@@ -22,6 +23,8 @@
 
     public PageResult<TCustomerInfo> getCustomerInfoPage(CustomerSearchBean param);
 
+    public PageResult<TCustomerImportBean> getCustomerInfo(CustomerSearchBean param);
+
     boolean deleteCustomer(String custid);
 
     List<TCustomerExportBean> getCustomerExportList(String custname,String deptcode);
diff --git a/src/main/java/com/supwisdom/dlpay/mainservice/dao/impl/CustomerDaoImpl.java b/src/main/java/com/supwisdom/dlpay/mainservice/dao/impl/CustomerDaoImpl.java
index c9e0a92..f54c697 100644
--- a/src/main/java/com/supwisdom/dlpay/mainservice/dao/impl/CustomerDaoImpl.java
+++ b/src/main/java/com/supwisdom/dlpay/mainservice/dao/impl/CustomerDaoImpl.java
@@ -2,6 +2,7 @@
 
 import com.supwisdom.dlpay.customer.bean.CustomerSearchBean;
 import com.supwisdom.dlpay.customer.bean.TCustomerExportBean;
+import com.supwisdom.dlpay.doorlist.bean.TCustomerImportBean;
 import com.supwisdom.dlpay.doorlist.bean.TCustomerInfo;
 import com.supwisdom.dlpay.framework.util.PageResult;
 import com.supwisdom.dlpay.framework.util.StringUtil;
@@ -142,6 +143,39 @@
         return new PageResult<>(count.longValue(), list);
     }
 
+    @Transactional
+    @Override
+    public PageResult<TCustomerImportBean> getCustomerInfo(CustomerSearchBean param) {
+
+        String deptcode=param.getDeptcode();
+        List<String> childdplist = getChildDeptlist( deptcode);
+
+        String perName=param.getCustname();
+        String sql = "select a.custid,a.custname,c.deptname,b.cardno from T_Customer a " +
+                "left join t_card b on a.custid = b.custid " +
+                "left join tb_dept c on a.deptcode=c.deptcode" +
+                " where a.status='1' and b.status='normal' and b.transtatus='normal' ";
+
+        if (!StringUtil.isEmpty(perName)){
+            sql += " and a.custname like :perName ";
+        }
+        if (!StringUtil.isEmpty(childdplist)) {
+            sql+=" and a.deptcode in ('"+ StringUtils.join(childdplist.toArray(),"','")+"') ";
+        }
+
+        sql +=" order by b.cardno desc ";
+
+        Query query = entityManager.createNativeQuery(sql);
+        if (!StringUtil.isEmpty(perName)){
+            query.setParameter("perName", "%"+perName+"%");
+        }
+        query.setFirstResult((param.getPageNo() - 1) * param.getPageSize());
+        query.setMaxResults(param.getPageSize()); //分页显示
+        query.unwrap(NativeQueryImpl.class).setResultTransformer(Transformers.aliasToBean(TCustomerImportBean.class));
+        List<TCustomerImportBean> list = query.getResultList();
+        return new PageResult<>( list);
+    }
+
     public List<String> getChildDeptlist( String deptcode) {
         List<String> childdplist=null;
         if (!StringUtil.isEmpty(deptcode)) {
diff --git a/src/main/java/com/supwisdom/dlpay/mainservice/service/WebInterfaceService.java b/src/main/java/com/supwisdom/dlpay/mainservice/service/WebInterfaceService.java
index ca2da77..ad275a0 100644
--- a/src/main/java/com/supwisdom/dlpay/mainservice/service/WebInterfaceService.java
+++ b/src/main/java/com/supwisdom/dlpay/mainservice/service/WebInterfaceService.java
@@ -4,6 +4,7 @@
 import com.supwisdom.dlpay.customer.bean.CustomerSearchBean;
 import com.supwisdom.dlpay.customer.bean.TCustomerExportBean;
 import com.supwisdom.dlpay.doorlist.bean.CustomerListBean;
+import com.supwisdom.dlpay.doorlist.bean.TCustomerImportBean;
 import com.supwisdom.dlpay.doorlist.bean.TCustomerInfo;
 import com.supwisdom.dlpay.framework.util.PageResult;
 import com.supwisdom.dlpay.mainservice.bean.TDoorcardlstInfo;
@@ -148,6 +149,9 @@
     PageResult<TCustomerInfo> getCustomerInfoPage(CustomerSearchBean bean);
 
     @Transactional(propagation = Propagation.REQUIRED,rollbackFor = {Exception.class})
+    PageResult<TCustomerImportBean> getCustomerInfo(CustomerSearchBean bean);
+
+    @Transactional(propagation = Propagation.REQUIRED,rollbackFor = {Exception.class})
     List<TCustomerExportBean> getCustomerExportBean(String custname,String deptcode);
 
 
diff --git a/src/main/java/com/supwisdom/dlpay/mainservice/service/impl/WebInterfaceServiceImpl.java b/src/main/java/com/supwisdom/dlpay/mainservice/service/impl/WebInterfaceServiceImpl.java
index 6b3d10d..ae9edf9 100644
--- a/src/main/java/com/supwisdom/dlpay/mainservice/service/impl/WebInterfaceServiceImpl.java
+++ b/src/main/java/com/supwisdom/dlpay/mainservice/service/impl/WebInterfaceServiceImpl.java
@@ -4,6 +4,7 @@
 import com.supwisdom.dlpay.customer.bean.CustomerSearchBean;
 import com.supwisdom.dlpay.customer.bean.TCustomerExportBean;
 import com.supwisdom.dlpay.doorlist.bean.CustomerListBean;
+import com.supwisdom.dlpay.doorlist.bean.TCustomerImportBean;
 import com.supwisdom.dlpay.doorlist.bean.TCustomerInfo;
 import com.supwisdom.dlpay.framework.util.PageResult;
 import com.supwisdom.dlpay.mainservice.bean.TDoorcardlstInfo;
@@ -224,8 +225,8 @@
             customerTmp.setLastsavedtime(now);
             customerTmp.setAddoperid(operid);
             customerTmp.setRemark(list.getRemarks());
-            customer.setDeptcode(deptcode);
-            customer.setCusttypeid(list.getCusttypeid());
+            customerTmp.setDeptcode(deptcode);
+            customerTmp.setCusttypeid(list.getCusttypeid());
             saveCustomer(customerTmp);
 
             TCard cardTmp = new TCard();
@@ -249,6 +250,11 @@
     }
 
     @Override
+    public PageResult<TCustomerImportBean> getCustomerInfo(CustomerSearchBean bean){
+        return customerDao.getCustomerInfo(bean);
+    }
+
+    @Override
     public List<TCustomerExportBean> getCustomerExportBean(String custname, String deptcode) {
         return customerDao.getCustomerExportList(custname,deptcode);
     }
diff --git a/src/main/resources/templates/apph5/confresult.html b/src/main/resources/templates/apph5/confresult.html
new file mode 100644
index 0000000..fcebbd1
--- /dev/null
+++ b/src/main/resources/templates/apph5/confresult.html
@@ -0,0 +1,91 @@
+<!DOCTYPE html>
+<html xmlns:th="http://www.thymeleaf.org" xmlns:sec="http://www.thymeleaf.org/thymeleaf-extras-springsecurity4">
+<head>
+    <title>首页</title>
+    <!--<meta name="_csrf_header" th:content="${_csrf.headerName}" />
+    <meta name="_csrf_token" th:content="${_csrf.parameterName}" th:value="${_csrf.token}" />-->
+    <meta charset="utf-8"/>
+    <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
+    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
+    <!-- 引入样式 -->
+    <!--<link rel="stylesheet" href="https://unpkg.com/mint-ui/lib/style.css">-->
+    <link rel="stylesheet" href="/static/res/assets/plugins/mintui/style.css" th:href="@{/static/res/assets/plugins/mintui/style.css}">
+    <script type="text/javascript" th:src="@{/static/res/assets/plugins/jquery/jquery.min.js}"></script>
+    <script type="text/javascript" th:src="@{/static/res/assets/plugins/layer/layer.js}"></script>
+    <!-- 先引入 Vue -->
+    <script type="text/javascript" th:src="@{/static/res/assets/plugins/nutui/vue.min.js}"></script>
+    <!-- 引入组件库 -->
+    <script type="text/javascript" th:src="@{/static/res/assets/plugins/mintui/index.js}"></script>
+
+    <!--<script src="https://unpkg.com/vue/dist/vue.js"></script>
+    <script src="https://unpkg.com/mint-ui/lib/index.js"></script>-->
+</head>
+<body>
+<div id="app" >
+    <div class="page-title" style="text-align:center; font-size: 24px;color: #FF8247">签到结果</div><br>
+    <div   style="text-align:center;" th:text="${msg}"></div>
+    <div   style="text-align:center;"  id="errmsg" th:text="${errorMsg}"></div>
+
+    <div style="text-align:center;margin-top:80px;font-size: 20px;color: #ff7148" th:text="${remarkTitle}"></div>
+    <div   style="text-align:center;" th:text="${remark}"></div>
+</div>
+</body>
+
+<script>
+    $(function () {
+  /*      var flag=$("#issuccess").val();
+        console.log(flag);
+        console.log(errmsg);
+        if(flag){
+            $("#msg").html("<p class='mintui-success'>签到成功</p>")
+        }else {
+            $("#msg").html("<p class='mintui-success'>签到失败</p>")
+        }*/
+    });
+/*    var mint_vue = new Vue({
+        el: '#app',
+        data:{
+            devList:[],
+            userId:'',
+            selectDevId:'',
+            devName:'',
+        },
+        methods: {
+            openDoor:function (devId) {
+                //mint_openDoor(devId);
+            },
+            loadListData:function (devName) {
+                //mint_searchByDevName(devName);
+            },
+
+        },
+        watch:{
+            devName:function(newvs,oldvs){
+
+                if(!newvs){
+                    //mint_searchByDevName('');
+                }
+            }
+        },
+        created:function() {
+            var _self = this;
+
+         /!*   var userId = '[[${userId}]]';
+            _self.userId = userId;*!/
+
+
+        }
+    })*/
+
+</script>
+<style>
+    .mint-search{
+        height:50px;
+    }
+
+    .mint-searchbar{
+        padding:1px 1px 1px 1px;
+        box-sizing: border-box
+    }
+</style>
+</html>
diff --git a/src/main/resources/templates/apph5/remoteH5.html b/src/main/resources/templates/apph5/remoteH5.html
index b4a6a57..65fb402 100644
--- a/src/main/resources/templates/apph5/remoteH5.html
+++ b/src/main/resources/templates/apph5/remoteH5.html
@@ -10,7 +10,8 @@
     <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
     <link rel="stylesheet" href="/static/libs/layui/css/layui.css" th:href="@{/static/libs/layui/css/layui.css}"/>
 
-    <link rel="stylesheet" href="/static/res/assets/plugins/element-ui/theme-default/index.css" th:href="@{/static/res/assets/plugins/element-ui/theme-default/index.css}"/>
+    <link rel="stylesheet" href="/static/res/assets/plugins/element-ui/theme-default/index.css"
+          th:href="@{/static/res/assets/plugins/element-ui/theme-default/index.css}"/>
 
     <!--<script type="text/javascript" th:src="@{/static/libs/jquery/jquery-3.2.1.min.js}"></script>-->
     <script type="text/javascript" th:src="@{/static/res/assets/plugins/jquery/jquery.min.js}"></script>
@@ -25,71 +26,75 @@
 
 <body>
 
-        <div id="app">
-            <div class="block" style="background:#ffffff;">
-                <br>
-                <span class="demonstration" style="text-align: center;display:block; font-size: 20px;color: #9932CC">选择要开门的设备</span><br><br>
-                    <!--动态将图片轮播图的容器高度设置成与图片一致-->
-                    <el-carousel trigger="click" :autoplay="false" type="card" :height="bannerHeight + 'px'" @change="indexChange" >
-                        <el-carousel-item v-for="item in devNameList" :key="item">
-                            <h3 class="small" style="text-align:center;">{{ item }}</h3>
-                        </el-carousel-item>
-                    </el-carousel>
-                    <el-button type="success" @click="openDoor" style=" display:block;margin:0 auto;width:100px;height:100px;border-radius:50px;border:solid rgb(100,100,100) 0px; font-size: 20px" >开门</el-button>
-            </div>
+<div id="app">
+    <div class="block" style="background:#ffffff;">
+        <br>
+        <span class="demonstration"
+              style="text-align: center;display:block; font-size: 20px;color: #9932CC">选择要开门的设备</span><br><br>
+        <!--动态将图片轮播图的容器高度设置成与图片一致-->
+        <el-carousel trigger="click" :autoplay="false" type="card" :height="bannerHeight + 'px'" @change="indexChange">
+            <el-carousel-item v-for="item in devNameList" :key="item">
+                <h3 class="small" style="text-align:center;">{{ item }}</h3>
+            </el-carousel-item>
+        </el-carousel>
+        <el-button type="success" @click="openDoor"
+                   style=" display:block;margin:0 auto;width:100px;height:100px;border-radius:50px;border:solid rgb(100,100,100) 0px; font-size: 20px">
+            开门
+        </el-button>
+    </div>
 
-        </div>
+</div>
 
 </body>
 
 <script>
     var app_vue = new Vue({
-        el:'#app',
-        data:{
+        el: '#app',
+        data: {
             devNameList: [],
-            devIdList:[],
-            selectDevName:'',
-            selectDevId:'',
+            devIdList: [],
+            selectDevName: '',
+            selectDevId: '',
             // 图片父容器高度
-            bannerHeight :1000,
+            bannerHeight: 1000,
             // 浏览器宽度
-            screenWidth :0,
-            userId:''
+            screenWidth: 0,
+            userId: ''
         },
 
-        methods:{
+        methods: {
             indexChange: function (pre, next) {
                 var _self = this;
                 var devIdListTmp = _self.devIdList;
-                _self.selectDevId=devIdListTmp[pre];
+                _self.selectDevId = devIdListTmp[pre];
                 // console.log(_self.selectDevId)
 
             },
-            openDoor:function () {
+            openDoor: function () {
                 var devId = app_vue.selectDevId;
                 app_openDoor(devId);
             },
-            setSize:function () {
+            setSize: function () {
                 // 通过浏览器宽度(图片宽度)计算高度
-                this.bannerHeight =  this.screenWidth;
+                this.bannerHeight = this.screenWidth;
             },
         },
-        created:function(){
+        created: function () {
             var _self = this;
             // 首次加载时,需要调用一次
-            _self.screenWidth =  window.innerWidth;
+            _self.screenWidth = window.innerWidth;
             _self.setSize();
 
-            var userId='[[${userId}]]';
+            var userId = '[[${userId}]]';
             _self.userId = userId;
 
             $.ajax({
                 type: "get",
                 dataType: "json",
-                url: "[[@{/app/loadAppDevList?userId=}]]"+userId,
+                url: "[[@{/app/loadAppDevList?userId=}]]" + userId,
                 success: function (ret) {
                     var ut = ret.devList;
-                    if (ut == null){
+                    if (ut == null) {
                         confirm("不具有开门权限");
                     }
                     var names = [];
@@ -99,7 +104,7 @@
                         ids.push(ut[i].deviceid);
                     }
                     _self.devNameList = names;
-                    _self.devIdList= ids;
+                    _self.devIdList = ids;
 
                 }
             })
@@ -110,14 +115,14 @@
     function app_openDoor(devId) {
         var userId = app_vue.userId;
         console.log(userId);
-        layer.confirm('你确定要开启此门吗?',{icon: 3,title: '请确认',offset: '30%'},function (index) {
+        layer.confirm('你确定要开启此门吗?', {icon: 3, title: '请确认', offset: '30%'}, function (index) {
             $.ajax({
                 type: "get",
                 dataType: "json",
-                url:encodeURI("[[@{/app/openDoorById?devId=}]]"+devId+"&userId="+userId),
-                success:function (ret) {
-                    if (ret.message == undefined){
-                        layer.msg('用户认证已过期，请重新登录',{icon: 2,time:1000});
+                url: encodeURI("[[@{/app/openDoorById?devId=}]]" + devId + "&userId=" + userId),
+                success: function (ret) {
+                    if (ret.message == undefined) {
+                        layer.msg('用户认证已过期，请重新登录', {icon: 2, time: 1000});
                         window.location = "[[@{/login}]]";
                         return;
                     }
@@ -133,14 +138,12 @@
     }
 
     // 窗口大小发生改变时,调用一次
-    window.onresize = function(){
-        app_vue.screenWidth =  window.innerWidth;
+    window.onresize = function () {
+        app_vue.screenWidth = window.innerWidth;
         app_vue.setSize();
     }
 
 
-
-
 </script>
 
 <style>
@@ -166,7 +169,7 @@
         background-color: #ffffff;
     }
 
-    .el-carousel__item .Carousel{
+    .el-carousel__item .Carousel {
         border-bottom: 1px solid #f1f4f8;
     }
 </style>
\ No newline at end of file
diff --git a/src/main/resources/templates/apph5/tempattend.html b/src/main/resources/templates/apph5/tempattend.html
new file mode 100644
index 0000000..7ec81d9
--- /dev/null
+++ b/src/main/resources/templates/apph5/tempattend.html
@@ -0,0 +1,171 @@
+<div id="confpeoplebind-form" lay-filter="confpeoplebind-filter" class="layui-form model-form"
+     style="padding: 30px 25px 10px 25px;">
+    <input type="hidden" id="confpeoplebind-confid" th:value="${detailConfid}" />
+    <div class="layui-form-item">
+        <div class="layui-input-inline" style="width: 450px;">
+            <label class="layui-form-label">会议：</label>
+            <div class="layui-input-block">
+                <label class="layui-form-label" th:text="${confName}"></label>
+            </div>
+        </div>
+    </div>
+
+    <div class="layui-form-item">
+        <label class="layui-form-label">人员：</label>
+        <div class="layui-input-block" style="border: 1px solid #ddd;border-radius: 4px;padding: 10px;">
+            <div class="layui-card-body">
+                <div class="layui-form toolbar">
+                    <div class="layui-input-inline">
+                        <input id="search-confpeoplebind-form-deptcode" type="text"
+                               lay-filter="search-confpeoplebind-form-deptcode-filter" autocomplete="off"
+                               class="layui-input"  />
+                    </div>
+                    姓名：
+                    <input id="search-confpeoplebind-form-searchkey" type="text" class="layui-input search-input"
+                           maxlength="20" style="width: 200px;" placeholder="输入人员姓名"/>&emsp;
+                    <button id="btn-search-confpeoplebind-form" class="layui-btn icon-btn"><i
+                            class="layui-icon">&#xe615;</i>搜索
+                    </button>
+                    <button id="btn-reset-confpeoplebind-form" class="layui-btn layui-btn-primary"><i
+                            class="layui-icon"></i>清空
+                    </button>
+
+                    <table class="layui-table" id="confpeoplebind-form-table"
+                           lay-filter="confpeoplebind-form-table-filter"></table>
+                </div>
+            </div>
+        </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="confpeoplebind-form-submit" lay-submit id="submitbtn">保存</button>
+    </div>
+</div>
+
+<style type="text/css" id="confpeoplebind-form-css">
+    .layui-form-item .layui-form-checkbox[lay-skin=primary] {
+        margin-top: 0;
+    }
+</style>
+
+<script>
+    layui.use(['layer', 'table', 'admin', 'form', 'treeSelect'], function () {
+        var layer = layui.layer;
+        var admin = layui.admin;
+        var form = layui.form;
+        var table = layui.table;
+        var treeSelect = layui.treeSelect;
+        var $ = layui.$
+
+        form.render("select");
+        treeSelect.render({
+            elem: '#search-confpeoplebind-form-deptcode',
+            data: '[[@{/customer/depttree}]]',
+            type: 'get',
+            placeholder: '选择部门',
+            search: false,
+            style: {
+                folder: {
+                    enable: false
+                },
+                line: {
+                    enable: true
+                },
+
+            },
+            // 点击回调
+            click: function (d) {
+                var treeNode = d.current;
+                console.log(treeNode);
+                return true;
+            },
+            success: function (d) {
+                console.log(d); // 加载完成后的回调函数
+            }
+        });
+
+        // 渲染表格
+        table.render({
+            elem: '#confpeoplebind-form-table',
+            url: '[[@{/conference/listpeopleforimport}]]',
+            size: 'sm',
+            height: 350,
+            page: false,
+            cols: [
+                [
+                    {type: 'checkbox', style: "#confpeoplebind-form-css", fixed: 'left'},
+                    {field: 'custname', title: '姓名', align: 'center'},
+                    {field: 'cardno', title: '卡号', align: 'center'},
+                    {field: 'deptname', title: '部门', align: 'center'}
+                ]
+            ]
+        });
+
+        // 搜索按钮点击事件
+        $('#btn-search-confpeoplebind-form').click(function () {
+            var deptcode = $("#search-confpeoplebind-form-deptcode").val();
+            var custname = $("#search-confpeoplebind-form-searchkey").val();
+            table.reload('confpeoplebind-form-table', {
+                where: {
+                    deptcode: deptcode,
+                    custname: custname
+                }
+            });
+        });
+
+        $("#btn-reset-confpeoplebind-form").click(function () {
+            $("#search-confpeoplebind-form-deptcode").val("");
+            $("#search-confpeoplebind-form-searchkey").val("");
+            treeSelect.revokeNode('search-confpeoplebind-form-deptcode-filter');
+        });
+
+        form.on('submit(confpeoplebind-form-submit)', function (el) {
+            var confid = $("#confpeoplebind-confid").val();
+            var checkStatus = table.checkStatus('confpeoplebind-form-table');
+            var data = checkStatus.data;
+            var cardnos = [];
+
+            for (var i = 0; i < data.length; i++) {
+                cardnos.push(data[i].cardno);
+            }
+            if (cardnos.length < 1) {
+                layer.msg("请选择用户", {icon: 2, time: 1500});
+                return;
+            }
+            debugger
+            console.log(confid, cardnos);
+            layer.load(2);
+            var token = $("meta[name='_csrf_token']").attr("value");
+            $.ajax({
+                type: "POST",
+                dataType: "json",
+                url: '[[@{/conference/addconfpeople}]]',
+                data: {
+                    "confid": confid,
+                    "cardnos[]": cardnos,
+                    "_csrf": token
+                },
+                success: function (result) {
+                    layer.closeAll('loading');
+                    if (result.code == 200) {
+                        layer.msg(result.msg, {icon: 1});
+                        table.reload('confpeoplebind-form-table'); //刷新表格
+                        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 (err) {
+                    admin.errorBack(err);
+                }
+            });
+        });
+    });
+</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/conference/confform.html b/src/main/resources/templates/conference/confform.html
index 4b404db..3ba5114 100644
--- a/src/main/resources/templates/conference/confform.html
+++ b/src/main/resources/templates/conference/confform.html
@@ -59,6 +59,12 @@
              </select>&emsp;
          </div>
     </div>
+    <div class="layui-form-item">
+        <label class="layui-form-label confinput-label">会议概要</label>
+        <div class="layui-input-block">
+            <textarea name="remark" placeholder="请输入" class="layui-textarea"></textarea>
+        </div>
+    </div>
 
 <!--    <div class="layui-form-item" id="conference-conflist">
         <label class="confinput-label layui-form-label"><span style="color: red">* </span>会议人员</label>
@@ -156,6 +162,7 @@
             formData.append("attendtime", vdata.attendtime);
             formData.append("confdate",vdata.confdate);
             formData.append("deviceid",vdata.deviceid);
+            formData.append("remark",vdata.remark);
           /*  var flag=false;
             var files = $('#form-conference-records').prop('files');
             for (var i = 0; i < files.length; i++) {
diff --git a/src/main/resources/templates/conference/conflist.html b/src/main/resources/templates/conference/conflist.html
index b0c951f..f9b326e 100644
--- a/src/main/resources/templates/conference/conflist.html
+++ b/src/main/resources/templates/conference/conflist.html
@@ -186,7 +186,8 @@
             }else if ('people' == obj.event) {
                 admin.popupCenter({
                     title: "分配人员",
-                    path: '[[@{/conference/loadimport}]]?confid=' + data.confid,
+                    area: '900px',
+                    path: '[[@{/conference/loadimport}]]?confid=' + data.confid+'&confname='+data.confname,
                     finish: function () {
                         table.reload('conferenceTable');
                     }
diff --git a/src/main/resources/templates/conference/confpeoplebind.html b/src/main/resources/templates/conference/confpeoplebind.html
new file mode 100644
index 0000000..7ec81d9
--- /dev/null
+++ b/src/main/resources/templates/conference/confpeoplebind.html
@@ -0,0 +1,171 @@
+<div id="confpeoplebind-form" lay-filter="confpeoplebind-filter" class="layui-form model-form"
+     style="padding: 30px 25px 10px 25px;">
+    <input type="hidden" id="confpeoplebind-confid" th:value="${detailConfid}" />
+    <div class="layui-form-item">
+        <div class="layui-input-inline" style="width: 450px;">
+            <label class="layui-form-label">会议：</label>
+            <div class="layui-input-block">
+                <label class="layui-form-label" th:text="${confName}"></label>
+            </div>
+        </div>
+    </div>
+
+    <div class="layui-form-item">
+        <label class="layui-form-label">人员：</label>
+        <div class="layui-input-block" style="border: 1px solid #ddd;border-radius: 4px;padding: 10px;">
+            <div class="layui-card-body">
+                <div class="layui-form toolbar">
+                    <div class="layui-input-inline">
+                        <input id="search-confpeoplebind-form-deptcode" type="text"
+                               lay-filter="search-confpeoplebind-form-deptcode-filter" autocomplete="off"
+                               class="layui-input"  />
+                    </div>
+                    姓名：
+                    <input id="search-confpeoplebind-form-searchkey" type="text" class="layui-input search-input"
+                           maxlength="20" style="width: 200px;" placeholder="输入人员姓名"/>&emsp;
+                    <button id="btn-search-confpeoplebind-form" class="layui-btn icon-btn"><i
+                            class="layui-icon">&#xe615;</i>搜索
+                    </button>
+                    <button id="btn-reset-confpeoplebind-form" class="layui-btn layui-btn-primary"><i
+                            class="layui-icon"></i>清空
+                    </button>
+
+                    <table class="layui-table" id="confpeoplebind-form-table"
+                           lay-filter="confpeoplebind-form-table-filter"></table>
+                </div>
+            </div>
+        </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="confpeoplebind-form-submit" lay-submit id="submitbtn">保存</button>
+    </div>
+</div>
+
+<style type="text/css" id="confpeoplebind-form-css">
+    .layui-form-item .layui-form-checkbox[lay-skin=primary] {
+        margin-top: 0;
+    }
+</style>
+
+<script>
+    layui.use(['layer', 'table', 'admin', 'form', 'treeSelect'], function () {
+        var layer = layui.layer;
+        var admin = layui.admin;
+        var form = layui.form;
+        var table = layui.table;
+        var treeSelect = layui.treeSelect;
+        var $ = layui.$
+
+        form.render("select");
+        treeSelect.render({
+            elem: '#search-confpeoplebind-form-deptcode',
+            data: '[[@{/customer/depttree}]]',
+            type: 'get',
+            placeholder: '选择部门',
+            search: false,
+            style: {
+                folder: {
+                    enable: false
+                },
+                line: {
+                    enable: true
+                },
+
+            },
+            // 点击回调
+            click: function (d) {
+                var treeNode = d.current;
+                console.log(treeNode);
+                return true;
+            },
+            success: function (d) {
+                console.log(d); // 加载完成后的回调函数
+            }
+        });
+
+        // 渲染表格
+        table.render({
+            elem: '#confpeoplebind-form-table',
+            url: '[[@{/conference/listpeopleforimport}]]',
+            size: 'sm',
+            height: 350,
+            page: false,
+            cols: [
+                [
+                    {type: 'checkbox', style: "#confpeoplebind-form-css", fixed: 'left'},
+                    {field: 'custname', title: '姓名', align: 'center'},
+                    {field: 'cardno', title: '卡号', align: 'center'},
+                    {field: 'deptname', title: '部门', align: 'center'}
+                ]
+            ]
+        });
+
+        // 搜索按钮点击事件
+        $('#btn-search-confpeoplebind-form').click(function () {
+            var deptcode = $("#search-confpeoplebind-form-deptcode").val();
+            var custname = $("#search-confpeoplebind-form-searchkey").val();
+            table.reload('confpeoplebind-form-table', {
+                where: {
+                    deptcode: deptcode,
+                    custname: custname
+                }
+            });
+        });
+
+        $("#btn-reset-confpeoplebind-form").click(function () {
+            $("#search-confpeoplebind-form-deptcode").val("");
+            $("#search-confpeoplebind-form-searchkey").val("");
+            treeSelect.revokeNode('search-confpeoplebind-form-deptcode-filter');
+        });
+
+        form.on('submit(confpeoplebind-form-submit)', function (el) {
+            var confid = $("#confpeoplebind-confid").val();
+            var checkStatus = table.checkStatus('confpeoplebind-form-table');
+            var data = checkStatus.data;
+            var cardnos = [];
+
+            for (var i = 0; i < data.length; i++) {
+                cardnos.push(data[i].cardno);
+            }
+            if (cardnos.length < 1) {
+                layer.msg("请选择用户", {icon: 2, time: 1500});
+                return;
+            }
+            debugger
+            console.log(confid, cardnos);
+            layer.load(2);
+            var token = $("meta[name='_csrf_token']").attr("value");
+            $.ajax({
+                type: "POST",
+                dataType: "json",
+                url: '[[@{/conference/addconfpeople}]]',
+                data: {
+                    "confid": confid,
+                    "cardnos[]": cardnos,
+                    "_csrf": token
+                },
+                success: function (result) {
+                    layer.closeAll('loading');
+                    if (result.code == 200) {
+                        layer.msg(result.msg, {icon: 1});
+                        table.reload('confpeoplebind-form-table'); //刷新表格
+                        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 (err) {
+                    admin.errorBack(err);
+                }
+            });
+        });
+    });
+</script>
\ No newline at end of file
diff --git a/src/main/resources/templates/confpeople/form.html b/src/main/resources/templates/confpeople/form.html
index bffbc79..670123b 100644
--- a/src/main/resources/templates/confpeople/form.html
+++ b/src/main/resources/templates/confpeople/form.html
@@ -2,12 +2,12 @@
     <input name="pid" id="confpeople-pid" type="hidden"/>
     <input name="conftype" id="confpeople-conftype" type="hidden"/>
     <div class="layui-form-item">
-        <label class="layui-form-label">签到状态</label>
+        <label class="layui-form-label" style="width:100px">签到状态</label>
         <div class="layui-input-block">
             <input type="radio" name="attstatus" id="form-confpeople-attstatus-checked"
-                   lay-filter="confpeople-attstatus-filter" value="checked" title="已签到"/>
-            <input type="radio" name="attstatus" id="form-confpeople-attstatus-uncheck"
-                   lay-filter="confpeople-attstatus-filter" value="uncheck" title="未签到"/>
+                   lay-filter="confpeople-attstatus-filter" value="handcheck" title="手工签到"/>
+           <!-- <input type="radio" name="attstatus" id="form-confpeople-attstatus-uncheck"
+                   lay-filter="confpeople-attstatus-filter" value="uncheck" title="未签到"/>-->
             <input type="radio" name="attstatus" id="form-confpeople-attstatus-late"
                    lay-filter="confpeople-attstatus-filter" value="late" title="迟到"/>
             <input type="radio" name="attstatus" id="form-confpeople-attstatus-instead"
diff --git a/src/main/resources/templates/confpeople/index.html b/src/main/resources/templates/confpeople/index.html
index 4221243..fe46124 100644
--- a/src/main/resources/templates/confpeople/index.html
+++ b/src/main/resources/templates/confpeople/index.html
@@ -17,6 +17,7 @@
             <select id="search-confpeople-attstatus">
                 <option value=""> 选择签到状态</option>
                 <option value="checked"> 已签到</option>
+                <option value="handcheck"> 手工签到</option>
                 <option value="uncheck"> 未签到</option>
                 <option value="late"> 迟到</option>
                 <option value="instead"> 被代签</option>
@@ -63,13 +64,23 @@
                     {field: 'custname', title: '客户姓名', align: 'center'},
                     {field: 'cardno', title: '卡号', align: 'center'},
                     {field: 'deptname', title: '所属部门', align: 'center'},
-                    {field: 'attendtime', title: '签到时间', align: 'center'},
+                    {
+                        field: 'atttime', title: '签到时间', align: 'center',templet: function (d) {
+                            var atttime=d.atttime;
+                            if(null!=atttime){
+                                return atttime.substring(0,2)+':'+atttime.substring(2,4);
+                            }
+                           return '';
+                        }
+                    },
                     {
                         field: 'attstatus', title: '状态', align: 'center', sort: true, templet: function (d) {
                             if ('uncheck' == d.attstatus) {
                                 return '<span class="layui-badge layui-bg-orange">未签到</span>'
                             } else if ('checked' == d.attstatus) {
                                 return '<span class="layui-badge layui-bg-green">已签到</span>';
+                            } else if ('handcheck' == d.attstatus) {
+                                return '<span class="layui-badge layui-bg-green">手工签到</span>';
                             } else if ('late' == d.attstatus) {
                                 return '<span class="layui-badge layui-bg-cyan">迟到</span>';
                             } else if ('instead' == d.attstatus) {
diff --git a/src/main/resources/templates/confreport/detail.html b/src/main/resources/templates/confreport/detail.html
index 4073e27..1bb129e 100644
--- a/src/main/resources/templates/confreport/detail.html
+++ b/src/main/resources/templates/confreport/detail.html
@@ -146,7 +146,11 @@
                                     return '<span class="layui-badge layui-bg-orange">未签到</span>'
                                 } else if ('checked' == d.attstatus) {
                                     return '<span class="layui-badge layui-bg-green">已签到</span>';
-                                } else if ('late' == d.attstatus) {
+                                }  else if ('handcheck' == d.attstatus) {
+                                    return '<span class="layui-badge layui-bg-green">手工签到</span>';
+                                }  else if ('closed' == d.attstatus) {
+                                    return '<span class="layui-badge layui-bg-gray">关闭</span>';
+                                }else if ('late' == d.attstatus) {
                                     return '<span class="layui-badge layui-bg-gray">迟到</span>';
                                 } else if ('instead' == d.attstatus) {
                                     return '<span class="layui-badge">被代签</span>';
@@ -190,7 +194,11 @@
                                     return '<span class="layui-badge layui-bg-orange">未签到</span>'
                                 } else if ('checked' == d.attstatus) {
                                     return '<span class="layui-badge layui-bg-green">已签到</span>';
-                                } else if ('late' == d.attstatus) {
+                                }  else if ('handcheck' == d.attstatus) {
+                                    return '<span class="layui-badge layui-bg-green">手工签到</span>';
+                                }  else if ('closed' == d.attstatus) {
+                                    return '<span class="layui-badge layui-bg-gray">关闭</span>';
+                                }else if ('late' == d.attstatus) {
                                     return '<span class="layui-badge layui-bg-gray">迟到</span>';
                                 } else if ('instead' == d.attstatus) {
                                     return '<span class="layui-badge">被代签</span>';
diff --git a/src/main/resources/templates/confreport/index.html b/src/main/resources/templates/confreport/index.html
index 396ace6..7717bdb 100644
--- a/src/main/resources/templates/confreport/index.html
+++ b/src/main/resources/templates/confreport/index.html
@@ -10,7 +10,7 @@
         <div class="layui-form toolbar">
             <div class="layui-form-item">
                 <div class="layui-inline">
-                    <label class="layui-form-label">会议类型：</label>
+                    <label class="layui-form-label" style="width:120px">会议类型：</label>
                     <div class="layui-input-inline">
                         <select id="search-confreport-conftype">
                             <option value=""> 选择会议类型</option>
@@ -20,7 +20,7 @@
                     </div>
                 </div>
                 <div class="layui-inline">
-                    <label class="layui-form-label">会议名称：</label>
+                    <label class="layui-form-label" style="width:120px">会议名称：</label>
                     <div class="layui-input-inline">
                         <input id="search-confreport-confname" class="layui-input search-input" maxlength="20"
                                type="text"
@@ -28,7 +28,7 @@
                     </div>
                 </div>
                 <div class="layui-inline">
-                    <label class="layui-form-label">会议日期：</label>
+                    <label class="layui-form-label" style="width:120px">会议日期：</label>
                     <div class="layui-input-inline">
                         <input type="text" name="confdate" class="layui-input" th:value="${confDate}"
                                id="search-confreport-confdate" placeholder="yyyy-MM-dd">
@@ -146,8 +146,9 @@
     });
 </script>
 
+<!--
 <style>
     .layui-form-label{
         width:120px;
     }
-</style>
\ No newline at end of file
+</style>-->
diff --git a/src/main/resources/templates/ncmgr/nc_dev.html b/src/main/resources/templates/ncmgr/nc_dev.html
index 20d89e1..56eb374 100644
--- a/src/main/resources/templates/ncmgr/nc_dev.html
+++ b/src/main/resources/templates/ncmgr/nc_dev.html
@@ -676,6 +676,10 @@
 
                         });
                     }
+                    dictlist.push({
+                        value: 'H',
+                        label: "会议平板"
+                    });
                     dev_vue.devtypes = dictlist;
                     dev_vue.regions = uows;
                     dev_vue.buildings = rows;
@@ -783,6 +787,10 @@
 
                     });
                 }
+                dictlist.push({
+                    value: 'H',
+                    label: "会议平板"
+                });
                 var devUseType = [];
                 var useTypes = ret.devUseType;
                 for (var i = 0; i < useTypes.length; i++) {
@@ -792,6 +800,10 @@
 
                     });
                 }
+                devUseType.push({
+                    value: 'HY',
+                    label: "会议签到"
+                });
                 var devlist = [];
                 var dev = ret.devices;
                 for (var i = 0; i < dev.length; i++) {
