潘钊 / bsth_control · Files

package com.bsth.service.ddexam.impl;

import com.bsth.data.BasicData;
import com.bsth.data.LineConfigData;
import com.bsth.data.schedule.DayOfSchedule;
import com.bsth.data.schedule.thread.ScheduleRefreshThread;
import com.bsth.entity.*;
import com.bsth.entity.realcontrol.LineConfig;
import com.bsth.entity.realcontrol.LineConfigSt;
import com.bsth.entity.realcontrol.ScheduleRealInfo;
import com.bsth.entity.realcontrol.ScheduleRealInfoSt;
import com.bsth.entity.sys.BsthCSysUserRoles;
import com.bsth.entity.sys.RealControAuthority;
import com.bsth.entity.sys.SysUser;
import com.bsth.repository.*;
import com.bsth.repository.realcontrol.LineConfigRepository;
import com.bsth.repository.realcontrol.LineConfigStRepository;
import com.bsth.repository.realcontrol.ScheduleRealInfoRepository;
import com.bsth.repository.realcontrol.ScheduleRealInfoStRepository;
import com.bsth.repository.sys.BsthCSysUserRolesRepository;
import com.bsth.repository.sys.RealControAuthorityRepository;
import com.bsth.repository.sys.SysUserRepository;
import com.bsth.security.util.SecurityUtils;
import com.bsth.service.ddexam.DdexamService;
import com.bsth.util.ConfigUtil;
import org.apache.poi.xssf.usermodel.XSSFCell;
import org.apache.poi.xssf.usermodel.XSSFRow;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLConnection;
import java.text.SimpleDateFormat;
import java.util.*;


@Service
public class DdexamServiceImpl implements DdexamService {

    Logger log = LoggerFactory.getLogger(this.getClass());
    @Autowired
    SysUserRepository sysUserRepository;
    @Autowired
    RealControAuthorityRepository realControAuthorityRepository;
    @Autowired
    BsthCSysUserRolesRepository bsthCSysUserRolesRepository;
    @Autowired
    LineRepository lineRepository;
    @Autowired
    LineStRepository lineStRepository;
    @Autowired
    LineInformationStRepository LineInformationStRepository;
    @Autowired
    LineInformationRepository lineInformationRepository;
    @Autowired
    StationRouteStRepository stationRouteStRepository;
    @Autowired
    StationRouteRepository stationRouteRepository;
    @Autowired
    ScheduleRealInfoStRepository ScheduleRealInfoStRepository;
    @Autowired
    ScheduleRealInfoRepository ScheduleRealInfoRepository;
    @Autowired
    BasicData.BasicDataLoader basicDataLoader;
    @Autowired
    ScheduleRefreshThread scheduleRefreshThread;
    @Autowired
    DayOfSchedule dayOfSchedule;
    @Autowired
    LineConfigStRepository lineConfigStRepository;
    @Autowired
    LineConfigData lineConfigData;
    @Autowired
    ScheduleRealInfoRepository scheduleRealInfoRepository;
    
    @Autowired
    LineConfigRepository lineConfigRepository;
    
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
    SimpleDateFormat sdfhms = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    public List<SysUser> userAll(){
        SysUser loginUser = SecurityUtils.getCurrentUser();
        return  sysUserRepository.findByParentID(String.valueOf(loginUser.getId()));
    }

    @Override
    public int hftime(){
        URLConnection url = null;
        try {
            java.net.URL baseUrl;
            baseUrl = com.bsth.webService.trafficManage.geotool.services.Internal.class.getResource(".");
            url = new java.net.URL(baseUrl,
                    "http://time.tianqi.com/").openConnection();

            url.connect(); //发出连接
            long ld = url.getDate(); //取得网站日期时间
            Date date = new Date(ld); //转换为标准时间对象
          /*  Calendar calendar = Calendar.getInstance();
            calendar.setTime(date);
            calendar.add(Calendar.YEAR, -1);//当前时间减去一年，即一年前的时间  
            //（时间校准网上快了一年，减去一年）*/
            String data = sdfhms.format(date.getTime());
            String[] lk = data.split(" ");
            if(lk.length == 2){
                Runtime.getRuntime().exec(ConfigUtil.get("jp.date") +" " +lk[0]);//Windows 系统
                Runtime.getRuntime().exec(ConfigUtil.get("jp.time") +" " +lk[1]);//Windows 系统
            }
        }  catch (IOException e) {
            e.printStackTrace();
        }
        return 0;
    }

    
    
    @Override
    public int initDate(String date) {
        try {
            Runtime.getRuntime().exec(ConfigUtil.get("jp.time") +" " +date);//Windows 系统
        }catch (Exception e){
            log.error("修改系统时间失败",e);
        }
        return 1;
    }


/*    //考生人初始化 无线程
    @Override
    public Map initializationAll(Integer rs) {
        Long start = System.currentTimeMillis();
        Map m = new HashMap<>();
        try {  //用户当天分配完直接改状态  无二次分配的可能
            List<SysUser> userList = sysUserRepository.findBySusUser(); //已有的用户   不考虑用户角色表  正常情况下创建必分配
            if (userList.size() >= rs) {  //满足考试人数  默认配置都是全的
                for (int i = 0 ; i < rs ; i++ ){   //已rs人数为准
                    SysUser user = userList.get(i);
                    useryType(user);
                    sysUserRepository.changeKsStatus(user.getId()); ////状态  表示今日账户已用
                }

            } else {
                if (userList.size() == 0) { //考试人数 全部重新创建
                    if(usercreateType(rs)){
                        log.info("考试初始化创建成功");
                    }
                } else { //已有的人检查分配线路   不够的创建

                    for (SysUser user : userList) {  //已有的分配班次
                        if (realControAuthorityRepository.findByUserId(user.getId()) == null) {  //检查未分配线路
                        } else { //已分配线路的分配班次
                            System.out.println("分配班次...");
                            sysUserRepository.changeKsStatus(user.getId()); ////状态  表示今日账户已用
                            useryType(user);
                        }
                    }

                    int st = rs - userList.size(); //未创建考试人数
                    //未分配的创建线路并分配
                    if(usercreateType(st)){
                        log.info("考试初始化创建成功");
                    }



                }
            }
        }catch (Exception e){
            log.error("-----考试初始化失败------",e);
            m.put("code","创建失败");
            return m;
        }
        //调用排班初始话功能
        m.put("code","创建成功");
        System.out.println("----------创建时间--------------"+(System.currentTimeMillis() - start));
        dayOfSchedule.lineAll(); //查询所有线路
        basicDataLoader.loadAllData(); //加载所有数据

        lineConfigData.lineAll();
        scheduleRefreshThread.run();
        System.out.println("-------------本次执行时间-----------"+(System.currentTimeMillis() - start));
        return m;

    }
    */
    //考生人初始化  单线程 测试1：执行中途再次执行是否同步 测试2：
    @Override
    @Transactional //事务
    public synchronized Map initializationAll(String name,Long userName,String className) {
        Long start = System.currentTimeMillis();
        Map m = new HashMap<>();
        try {  //用户当天分配完直接改状态  无二次分配的可能
            SysUser loginUser=SecurityUtils.getCurrentUser();
            List<SysUser> userList = sysUserRepository.findBySusUserAll(); //已有的用户   不考虑用户角色表  正常情况下创建必分配
            for (SysUser s :userList){
                if(Long.parseLong(s.getUserName())  == userName ){
                    m.put("code","创建失败 账号重复");
                    return m;
                }
            }
             
            new Thread() {
                public  synchronized  void run() {
                    SysUser user = new SysUser(name,String.valueOf(userName),loginUser,className);
                    if(createUser(user)){
                        log.info("考试初始化创建成功");
                        kk();
                    }
                }
            }.start();
                     
        }catch (Exception e){
            log.error("-----考试初始化失败------",e);
            m.put("code","创建失败");
            return m;
        }
        //调用排班初始话功能
        m.put("code","创建成功");
        System.out.println("-------------本次执行时间-----------"+(System.currentTimeMillis() - start));
        return m;
        
    }


    public Map initializationAll2(Long userName){
        Long start = System.currentTimeMillis();
        Map m = new HashMap<>();

        
        try {  //用户当天分配完直接改状态  无二次分配的可能
            List<SysUser> userList=new ArrayList<>();
            if(userName!=null){
                userList= sysUserRepository.findBySusUser(String.valueOf(userName));
            }else {
                SysUser loginUser = SecurityUtils.getCurrentUser();
                userList= sysUserRepository.findByParentID(String.valueOf(loginUser.getId()));
            }
            if (userList.size() > 0) {
                //已有的人检查分配线路
                List<SysUser> finalUserList = userList;
                if (snt(finalUserList,false)) {
                    kk();
                }
            }
        }catch (Exception e){
            log.error("-----考试初始化失败------",e);
            m.put("code","创建失败");
            return m;
        }
        //调用排班初始话功能
        m.put("code","初始化成功");
        System.out.println("-------------本次执行时间-----------"+(System.currentTimeMillis() - start));
        return m;
        
    }
    /*public void aa(){
        Long start = System.currentTimeMillis();
        Map m = new HashMap<>();
        try {  //用户当天分配完直接改状态  无二次分配的可能
            List<SysUser> userList = sysUserRepository.findBySusUser(); //已有的用户   不考虑用户角色表  正常情况下创建必分配
            if (userList.size() >= rs) {  //满足考试人数  默认配置都是全的
                new Thread() {
                    public  synchronized  void run() {
                        if(snt(rs,userList,0)){
                            log.info("考试初始化创建成功");
                            kk();
                        }
                    }
                }.start();
            } else {
                if (userList.size() == 0) { //考试人数 全部重新创建
                    new Thread() {
                        public  synchronized  void run() {
                            if(usercreateType(rs)){
                                log.info("考试初始化创建成功");
                                kk();
                            }
                        }
                    }.start();

                } else { //已有的人检查分配线路   不够的创建

                    new Thread() {
                        public  synchronized  void run() {
                            if(snt(rs,userList,1)){
                                kk();
                            }
                        }
                    }.start();

                    int st = rs - userList.size(); //未创建考试人数
                    //*    //未分配的创建线路并分配
                    if(usercreateType(st)){ //暂无问题
                        log.info("考试初始化创建成功");
                        kk();
                    }//*
                    new Thread() {
                        public  synchronized  void run() {
                            if(usercreateType(st)){
                                log.info("考试初始化创建成功");
                                kk();
                            }
                        }
                    }.start();

                }
            }
        }catch (Exception e){
            log.error("-----考试初始化失败------",e);
            m.put("code","创建失败");
            return m;
        }
        //调用排班初始话功能
        m.put("code","创建成功");
        System.out.println("-------------本次执行时间-----------"+(System.currentTimeMillis() - start));
        return m;
    }
    */
    public void kk(){
        basicDataLoader.loadAllData(); //加载所有数据
        dayOfSchedule.lineAll(); //查询所有线路
        lineConfigData.lineAll();
        scheduleRefreshThread.run();
    }
    //已创建好的用户分配排班

    public Boolean snt(List<SysUser> userList,boolean type){
        for (int i = 0 ; i < userList.size() ; i++ ){   //已rs人数为准
            SysUser user = userList.get(i);
            if (realControAuthorityRepository.findByUserId(user.getId()) != null) {
                useryType(user,type);
                System.out.println("分配班次...");
                sysUserRepository.changeKsStatus(user.getId()); ////状态  表示今日账户已用
            }
        }
        return true;
    }
    
    //type true:考试 false:练习 考试只初始化A线路排班
    public Boolean useryType(SysUser user,boolean type){
        RealControAuthority hoit = realControAuthorityRepository.findByUserId(user.getId());
        String[] st = hoit.getLineCodeStr().split(",");
        if(!type){
            for (int k = 0 ; k < st.length ; k++){
                Line l = lineRepository.findById(Integer.parseInt(st[k])).get();
                inforealType(l);
            }
        }else {
            if(st.length>0){
                Line l = lineRepository.findById(Integer.parseInt(st[0])).get();
                inforealType(l);
            }
        }
        return true;
    }
    

 
    //添加排班
    public void inforealType(Line line){
        int t  = ScheduleRealInfoRepository.selectCountAll(sdf.format(new Date()),line.getLineCode());
        //鉴于有人员创建账号瞬间就初始化  修改人员状态慢了一步  在此多加一部判断
        if(t  >  0)
            return;
        //用旧线路code查出模板排班表
        List<ScheduleRealInfoSt>  sristList =  ScheduleRealInfoStRepository.queryUserInfo(line.getCoLineCode(),"2021-11-18");//模板固定日期
        List<ScheduleRealInfo>  sriList = new ArrayList<>();
        for(ScheduleRealInfoSt st : sristList){
            ScheduleRealInfo sri = new ScheduleRealInfo();
            BeanUtils.copyProperties(st,sri); //copy
            sri.setScheduleDate(new Date());
            sri.setScheduleDateStr(sdf.format(new Date()));
            sri.setXlBm(line.getLineCode());
            sri.setXlName(line.getName()); 
            sriList.add(sri);
        }
        ScheduleRealInfoRepository.saveAll(sriList);
    }

    public String importExcel(File file, Map map) {
        List<String> textList = new ArrayList<>();
        List<SysUser> userList = new ArrayList<>();

        try{
            InputStream fs = new FileInputStream(file);
            XSSFWorkbook wb = new XSSFWorkbook(fs);
            XSSFSheet sheet = wb.getSheetAt(0);
            // 取得总行数
            int rowNum = sheet.getLastRowNum() + 1;
            // 取得总列数
            int cellNum = sheet.getRow(0).getLastCellNum();
            XSSFRow row = null;
            XSSFCell cell = null;
            for(int i = 1; i < rowNum; i++){
                row = sheet.getRow(i);
                if (row == null){
                    continue;
                }
                String text = "";
                for(int j = 0; j < cellNum; j++){
                    row.getCell(j).setCellType(1);
                    cell = row.getCell(j);
                    if(cell == null){
                        text += ",";
                        continue;
                    }
                    text += String.valueOf(cell) + ",";
                }
                String[] split = (text+";").split(",");
                String str = "";
                for(int j = 0; j < split.length && j < 5; j++){
                    str += split[j];
                }
                if(str.trim().length() == 0)
                    continue;
                textList.add(text + ";");
            }
            for(int i = 0; i < textList.size(); i++) {
                String text = textList.get(i);
                String[] split = text.split(",");
                SysUser user = new SysUser(split[1].trim(),split[0].trim(),SecurityUtils.getCurrentUser(),split[2].trim());
                userList.add(user);
            }
            List<SysUser> users = sysUserRepository.findBySusUserAll();
            Iterator<SysUser> it=userList.iterator();
            while (it.hasNext()){
                SysUser u=it.next();
                for (SysUser user : users) {
                    if(u.getUserName().equals(user.getUserName())){
                        it.remove();
                        continue;
                    }
                }
            }
            boolean flag = true;
            for (SysUser user : userList) {
                if(!createUser(user)){
                    flag=false;
                }
            }
            if(!flag){
                return "文件导入失败";
            }
        }catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return "文件导入失败";
        } finally {
            file.delete();
        }

        return "导入文件成功";

    }


    public synchronized Boolean  createUser(SysUser user){
        sysUserRepository.save(user); //用户存库
        BsthCSysUserRoles userRoles = new BsthCSysUserRoles();
        userRoles.setUsers(user.getId());
        userRoles.setRoles(73); //统一用73考生
        bsthCSysUserRolesRepository.save(userRoles); //权限存库
        List<LineConfigSt> lineConfigList = lineConfigStRepository.findAll(); //线调 线路相关配置信息
        Integer linebumber = lineRepository.findAll().size() + 1; //线路数量 线路code
        String [] mtline = {"A线","B线","C线","D线","E线","F线"}; //对应模板6条线 换成线路name
        List<LineInformationSt> litst = (List<LineInformationSt>) LineInformationStRepository.findAll(); //所有模板线路标准和线路
        if(litst.size() != 6){
            return false;
        }
        //让线路从1开始  部分功能0会异常
        if(linebumber == 0){
            linebumber = 1;
        }

        String lineCodeStr = "";
        for(int j = 0 ; j < litst.size() ; j++){  //6个  <6
            LineSt linest = litst.get(j).getLine(); //旧line
            LineInformationSt Limst = litst.get(j);
            Line line = new Line();
            BeanUtils.copyProperties(linest,line); //copy
            Integer linecodeId = linebumber++ ;
            line.setId(linecodeId);
            line.setLineCode(linecodeId.toString());
            line.setName(mtline[j]+"-"+user.getUserName());
            line.setCoLineCode(linest.getLineCode());
            lineRepository.save(line);  //线路添加
            //----------------线路--------------------------//
            LineInformation lifat = new LineInformation();  //线路标准
            BeanUtils.copyProperties(Limst,lifat);
            lifat.setLine(line);
            lineInformationRepository.save(lifat); //线路标准信息条件
            //-------------------线路标准-----------------------//
            for(LineConfigSt cfgt : lineConfigList){
                if(cfgt.getLine().getLineCode().equals(linest.getLineCode())){
                    LineConfig config = new LineConfig();
                    BeanUtils.copyProperties(cfgt,config); //copy
                    config.setLine(line);
                    lineConfigRepository.save(config);
                }
            }
            //-------------------线调 线路相关配置信息-----------------------//

            List<StationRouteSt> srstList = stationRouteStRepository.findByLine(linest.getLineCode());
            List<StationRoute> srstListAll = new ArrayList<>();
            for(StationRouteSt route : srstList){
                StationRoute srt = new StationRoute();
                BeanUtils.copyProperties(route,srt); //copy
                srt.setLine(line);
                srt.setLineCode(linecodeId.toString());
                srstListAll.add(srt);
            }
            stationRouteRepository.saveAll(srstListAll);//添加站点
            //-------------------站点-----------------------//
            lineCodeStr += linecodeId.toString()+",";  //线调线路
            inforealType(line);
        }
        RealControAuthority raty = new RealControAuthority();
        raty.setUserId(user.getId());
        raty.setLineCodeStr(lineCodeStr);
        raty.setPattern(1); //可用
        realControAuthorityRepository.save(raty);
        //-------------------分配本次线调权限-----------------------//
        return true;
    }

    public synchronized void  clearScheduleRealInfo(SysUser user){
        RealControAuthority hoit = realControAuthorityRepository.findByUserId(user.getId());
        String[] st = hoit.getLineCodeStr().split(",");
        List<String> lines=Arrays.asList(st);
        //bsth_c_s_sp_info_real
        scheduleRealInfoRepository.deleteScheduleRealInfoBylineCodes(lines);
    }

}