service 迁入sys

ssj-sys/pom.xml

@@ -16,11 +16,17 @@
     </properties>
 
 	<dependencies>
-	
-   	    <dependency>
-			<groupId>com.ssj</groupId>
-    		<artifactId>ssj-kmt-exercise-service-impl</artifactId>
-		</dependency>
+
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-kmt-exercise-service</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-aijia-service</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
         <dependency>
             <groupId>com.ssj</groupId>
             <artifactId>ssj-sys-service</artifactId>
@@ -29,7 +35,28 @@
 
         <dependency>
             <groupId>com.ssj</groupId>
-            <artifactId>ssj-common-config</artifactId>
+            <artifactId>ssj-dao</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+
+
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-mybatis-service-impl</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-rabbitmq</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+
+
+
+
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-baidu-aipface</artifactId>
             <version>0.0.1-SNAPSHOT</version>
         </dependency>
         <dependency>
@@ -39,6 +66,51 @@
         </dependency>
         <dependency>
             <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-weixin-pay</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-aliyun-sms</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-alipay</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-easemob</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-xunfei</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-jiguang</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-cmb</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-config</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
+            <artifactId>ssj-common-file</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.ssj</groupId>
             <artifactId>ssj-common-excel</artifactId>
             <version>0.0.1-SNAPSHOT</version>
         </dependency>
@@ -59,6 +131,43 @@
 <!--        </dependency>-->
 	</dependencies>
 
+    <!-- Package as an executable jar -->
+    <build>
+        <!-- 产生的构件的文件名，默认值是${artifactId}-${version}。 -->
+        <finalName>${project.artifactId}</finalName>
+        <resources>
+            <resource>
+                <directory>src/main/resources/</directory>
+                <filtering>true</filtering>
+                <includes>
+                    <include>**/*.properties</include>
+                </includes>
+            </resource>
+            <resource>
+                <directory>src/main/resources</directory>
+                <includes>
+                    <include>**.*</include>
+                    <include>**/*.*</include><!-- i18n能读取到 -->
+                    <include>**/*/*.*</include>
+                </includes>
+            </resource>
+        </resources>
+
+
+        <plugins>
+
+            <plugin>
+                <artifactId>maven-resources-plugin</artifactId>
+                <configuration>
+                    <encoding>utf-8</encoding>
+                    <useDefaultDelimiters>true</useDefaultDelimiters>
+                </configuration>
+            </plugin>
+
+        </plugins>
+
+    </build>
+
     <profiles>
         <profile>
             <id>test</id>

ssj-sys/src/main/java/com/ssj/framework/log/service/impl/RequestApiLogServiceImpl.java

@@ -0,0 +1,130 @@
+package com.ssj.framework.log.service.impl;
+
+
+import java.text.SimpleDateFormat;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import java.util.List;
+import java.util.Map;
+import java.util.SimpleTimeZone;
+import java.util.regex.Pattern;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.mongodb.core.query.Criteria;
+import org.springframework.data.mongodb.core.query.Query;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.expression.ParseException;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.dao.log.dao.RequestApiLogDao;
+import com.ssj.framework.basic.utils.StringUtils;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.log.domain.RequestApiLog;
+import com.ssj.framework.log.service.RequestApiLogService;
+import com.ssj.framework.weixin.util.DateUtil;
+
+
+/**
+ * 
+ * 类名称：RequestApiLogServiceImpl<br>
+ * 类描述：请求接口日志服务接口实现<br>
+ * @version v1.0
+ *
+ */
+@Service(version = "1.0")
+@Transactional
+public class RequestApiLogServiceImpl extends BaseServiceImpl<RequestApiLog, String> implements RequestApiLogService {
+
+    @Autowired
+    private RequestApiLogDao requestApiLogDao;
+    
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Override
+    public PagingAndSortingRepository<RequestApiLog, String> getDao() {
+        return requestApiLogDao;
+    }
+    
+    
+    @Override
+    public Page<RequestApiLog> findMongoDBPage(Map<String,Object> params,Pageable pageable) {
+    	 PageImpl<RequestApiLog> page=new PageImpl<RequestApiLog>(new ArrayList<RequestApiLog>());
+    	 Criteria criteria = new Criteria();
+         if (params.containsKey("methodName") && params.get("methodName")!=null && StringUtils.isNotEmpty(params.get("methodName").toString())) {
+             Pattern pattern = Pattern.compile("^.*" + params.get("methodName").toString() + ".*$", Pattern.CASE_INSENSITIVE);
+             criteria = criteria
+            		 .orOperator(
+            				 Criteria.where("apiUrl").regex(pattern),
+            				 Criteria.where("apiName").regex(pattern),
+            				 Criteria.where("methodName").regex(pattern)
+            		 );
+         }
+         if (params.containsKey("userId") && params.get("userId")!=null && StringUtils.isNotEmpty(params.get("userId").toString())) {
+        	 Pattern pattern = Pattern.compile("^.*" + params.get("userId").toString() + ".*$", Pattern.CASE_INSENSITIVE);
+             criteria = criteria
+            		 .orOperator(
+            				 Criteria.where("accessToken").regex(pattern), 
+            				 Criteria.where("userId").regex(pattern)
+            		 );
+         }
+         if (params.containsKey("postBody") && params.get("postBody")!=null && StringUtils.isNotEmpty(params.get("postBody").toString())) {
+        	 Pattern pattern = Pattern.compile("^.*" + params.get("postBody").toString() + ".*$", Pattern.CASE_INSENSITIVE);
+             criteria = criteria
+            		 .orOperator(
+            				 Criteria.where("postBody").regex(pattern),
+            				 Criteria.where("requestMap").regex(pattern)
+            		 ); 
+         }
+         if (params.containsKey("ipAddress") && params.get("ipAddress")!=null && StringUtils.isNotEmpty(params.get("ipAddress").toString())) {
+        	 Pattern pattern = Pattern.compile("^.*" + params.get("ipAddress").toString() + ".*$", Pattern.CASE_INSENSITIVE);
+             criteria = criteria
+            		 .orOperator(
+            				 Criteria.where("ipAddress").regex(pattern)
+            		 ); 
+         }
+
+         criteria = criteria.andOperator(
+        		 Criteria.where("requestDate").lte(DateUtil.dateToISODate(params.get("endTime").toString())),
+        		 Criteria.where("requestDate").gte(DateUtil.dateToISODate(params.get("startTime").toString())));
+         
+         Query query = new Query(criteria).skip((pageable.getPageNumber()- 1) * pageable.getPageSize()).limit(pageable.getPageSize());
+         query.with(new Sort(Sort.Direction.DESC, "requestDate"));
+         List<RequestApiLog> list= mongoTemplate.find(query, RequestApiLog.class);
+         long total = mongoTemplate.count(query, RequestApiLog.class);// 数据总数量
+         page=new PageImpl<RequestApiLog>(list, pageable, total);
+         return page;
+    }
+    
+
+    @Override
+    public Page<RequestApiLog> findPage(Pageable pageable) {
+        return requestApiLogDao.findAll(pageable);
+    }
+
+    @Override
+    public ResponseEntity deleteLogs(int days) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        long sum = requestApiLogDao.countByAll();
+        int removeCount =  requestApiLogDao.deleteLogs(days);
+        responseEntity.success("日志总数"+ sum + "，清除日志条数"+removeCount);
+        return responseEntity;
+    }
+
+
+	@Override
+	public RequestApiLog getMongoDBById(String id) {
+		return mongoTemplate.findById(id, RequestApiLog.class);
+	}
+	
+
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/common/service/impl/AppCommonServiceImpl.java

@@ -0,0 +1,390 @@
+package com.ssj.service.conch.common.service.impl;
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import com.ssj.push.util.jiguang.MessagePushUtils;
+import com.ssj.service.sys.homework.service.HomeworkPictureService;
+import com.ssj.service.sys.homework.service.HomeworkService;
+import com.ssj.service.sys.homework.service.NoHomeworkRecordService;
+import com.ssj.service.weixin.sales.service.LibVipServiceService;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.alibaba.fastjson.JSON;
+import com.ssj.bean.conch.conch.domain.ConchDerver;
+import com.ssj.bean.sys.push.domain.SconXinge;
+import com.ssj.bean.sys.schoolmatecircle.domain.SSJUserMessage;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.conch.push.util.PushConstants;
+import com.ssj.framework.basic.config.bean.Config;
+import com.ssj.framework.basic.config.service.ConfigService;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.framework.core.util.Constant;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.core.util.SystemResourceLocator;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.service.conch.common.dto.OnlineMessagesDto;
+import com.ssj.service.conch.common.request.EasemobAPNsRequest;
+import com.ssj.service.conch.common.request.OnlineSendMessageRequest;
+import com.ssj.service.conch.common.service.AppCommonService;
+import com.ssj.service.conch.conch.service.ConchDerverService;
+import com.ssj.service.conch.student.dto.UserFriendDto;
+import com.ssj.service.sys.push.service.SconPushMessageService;
+import com.ssj.service.sys.push.service.SconXingeService;
+import com.ssj.service.sys.push.service.task.XingePushThreadTask;
+import com.ssj.service.sys.schoolmatecircle.service.SSJUserFriendService;
+import com.ssj.service.sys.schoolmatecircle.service.SSJUserMessageService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import com.ssj.service.weixin.user.service.UserService;
+import com.ssj.sys.util.face.FaceReq;
+import com.ssj.taskthread.ThreadPool;
+@Service(version = "1.0")
+@Transactional
+public class AppCommonServiceImpl implements AppCommonService{
+	
+	@Autowired
+	private UserService userService;
+	@Autowired
+	private SconXingeService sconXingeService;
+	@Autowired
+	private SconPushMessageService sconPushMessageService;
+	@Autowired
+	private SSJUserFriendService userFriendService;
+	@Autowired
+    private TokenManager tokenManager;
+	@Autowired
+    private SSJUserMessageService userMessageService;
+	@Autowired
+	private ILibVipService vipService;
+	@Autowired
+	private ConfigService configService;
+	@Autowired
+	private ConchDerverService conchDerverService;
+	@Autowired
+	private LibVipServiceService libVipServiceService;
+
+	@Override
+	public void easemobAPNsPush(EasemobAPNsRequest request) {
+		//通过环信id查找用户信鸽token信息，推送语音通话通知
+		User user = userService.findByEasemobName(request.getEasemobName());
+		if(user != null) {
+	        //判断用户的token是否失效，如果失效则不推送
+	        String token = tokenManager.getToken(user.getId(),"APP");
+	        if(token != null) {
+	        	//给家长推送绑定提示消息
+		        SconXinge sconXinge = sconXingeService.findByPushUserIdAndPlatformType(user.getId(), request.getPlatformType());
+		        if(sconXinge != null) {
+		        	//判断当前环境是开发还是生产 当前系统环境,1:生产环境 2:测试环境
+		        	String sysEnv = (String) SystemResourceLocator.getValue("SYS_ENV");
+		            //不推安卓设备
+		        	ThreadPool.getInstance().addTask(new XingePushThreadTask("私塾家", request.getContent(), null, sconXinge.getIosToken(), request.getPlatformType(),null,"ring_called_30.caf",null,Integer.valueOf(sysEnv),0));
+			        sconPushMessageService.savePushMessage(user.getId(), Constant.PARENT_PLATFORM_TYPE, null, request.getContent(), PushConstants.MESSAGE_TYPE_XINGE);
+		        }
+	        }
+		}
+	}
+
+	@Override
+	@Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public ResponseEntity findFriends(String userId) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		//查询好友列表
+		List<UserFriendDto> dtoList = userFriendService.findFriends(userId);
+    	Map<String, Object> data = new HashMap<String,Object>();
+    	//设置是否是即时通讯
+    	data.put("isRealTime", 0);
+    	data.put("friendList", dtoList);
+        responseEntity.success(data,"成功");
+		return responseEntity;
+	}
+	
+	@Override
+	public ResponseEntity onlineSendMessage(String userId, OnlineSendMessageRequest request) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		//判断是否是好友关系，非好友关系不能发送消息
+		//判断是否已经添加过好友
+		String parentName = null;
+		boolean flag = userFriendService.validateIsFriend(userId, request.getReceiveUserId());
+		if(!flag) {
+			//判断是否是家长
+			parentName = vipService.validateIsParent(userId, request.getReceiveUserId());
+			if(StringUtils.isBlank(parentName)) {
+				responseEntity.failure("你还不是他(她)朋友,请添加好友后才能聊天");
+				return responseEntity;
+			}
+		}
+		
+		//在线发送消息
+		SSJUserMessage lastUserMessage = userMessageService.findLastOnlineMessage(userId,request.getReceiveUserId());
+		//判断和上次聊天的间隔时间是否超过5分钟，如果超过5分钟插入时间标识
+		Date currentTime = new Date();
+		if(lastUserMessage != null ) {
+			Date lastTime = DateHelper.getAddHour(lastUserMessage.getCreateTime(), 0, 5);
+			if(DateUtil.compareDate(lastTime, currentTime) && !lastUserMessage.getType().equals("TIME")) {
+				SSJUserMessage userMessage = new SSJUserMessage();
+				userMessage.setSendUserId(userId);
+				userMessage.setReceiveUserId(request.getReceiveUserId());
+				userMessage.setCreateTime(currentTime);
+				userMessage.setType("TIME");
+				userMessage.setContent(DateUtil.format_yyyyMMddHHmmss(currentTime));
+				userMessage.setIsRead(1);
+				userMessage.setTimeMillis(String.valueOf(System.currentTimeMillis()));
+				userMessageService.save(userMessage);
+			}
+		}
+		//记录聊天消息
+		SSJUserMessage userMessage = new SSJUserMessage();
+		userMessage.setSendUserId(userId);
+		userMessage.setReceiveUserId(request.getReceiveUserId());
+		userMessage.setType(request.getType());
+		userMessage.setContent(request.getContent());
+		userMessage.setFileKey(request.getFileKey());
+		userMessage.setDuration(request.getDuration());
+		userMessage.setCreateTime(currentTime);
+		userMessage.setTimeMillis(String.valueOf(System.currentTimeMillis()));
+		userMessage = userMessageService.save(userMessage);
+		//信鸽推送聊天消息到接收人端
+		Map<String, Object> custom = new HashMap<String, Object>();
+		custom.put("type", "ONLINE_MESSAGE");
+		custom.put("time", currentTime);
+        custom.put("badge",0);
+		Map<String, Object> map2 = new HashMap<String, Object>();
+		User user = userService.getById(userId);
+		String photo = user.getPhoto();
+		map2.put("userId", userId);
+		if(StringUtils.isNotBlank(parentName)) {
+			//家长用户名
+			map2.put("userName", parentName);
+		}else {
+			//发送者用户名
+			map2.put("userName", user.getUserName());
+		}
+		map2.put("userImg", photo);
+		map2.put("type", request.getType());
+		map2.put("content", request.getContent());
+		map2.put("fileKey", request.getFileKey());
+		map2.put("duration", request.getDuration());
+		map2.put("createTime", currentTime);
+		map2.put("timeMillis", userMessage.getTimeMillis());
+		ConchDerver conchDerver = conchDerverService.findByUserId(userId);
+		if(conchDerver != null){
+			map2.put("derver", conchDerver.getDerver());
+		}else {
+			map2.put("derver", null);
+		}
+		map2.put("easemobName", user.getEasemobName());
+		custom.put("data", map2);
+
+		//如果给家长端发送消息设置角标数量
+        if(StringUtils.isNotBlank(parentName)) {
+            String badge = tokenManager.getString("APP_BADGE_"+request.getReceiveUserId());
+            if(StringUtils.isBlank(badge)) {
+                tokenManager.setString("APP_BADGE_"+request.getReceiveUserId(), "1", 300 * 24 * 3600);
+                custom.put("badge",1);
+            }else {
+                int badgeNum = Integer.valueOf(badge)+1;
+                custom.put("badge",badgeNum);
+                tokenManager.setString("APP_BADGE_"+request.getReceiveUserId(), String.valueOf(badgeNum), 300 * 24 * 3600);
+            }
+        }
+		sconXingeService.asynPushOnlineMessageThreadTask(request.getReceiveUserId(), custom);
+		
+		//返回发送的消息实体
+		OnlineMessagesDto dto = new OnlineMessagesDto();
+		dto.setUserId(userId);
+		dto.setUserImg(photo);
+		dto.setType(request.getType());
+		dto.setContent(request.getContent());
+		dto.setFileKey(request.getFileKey());
+		dto.setDuration(request.getDuration());
+		dto.setCreateTime(currentTime);
+		dto.setTimeMillis(userMessage.getTimeMillis());
+		
+		responseEntity.success(dto,"成功");
+		return responseEntity;
+	}
+
+	@Override
+	@Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public ResponseEntity onlineMessages(Map<String, Object> params,Pageable pageable) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		
+		//查询好友聊天记录消息列表
+        //因连表查询很慢，所以用户头像信息提前查
+        User sendUser = userService.getById((String)params.get("sendUserId"));
+        User receiveUser = userService.getById((String)params.get("receiveUserId"));
+        //查询聊天消息
+		Page<Map<String, Object>> page = userMessageService.findOnlineMessages(params, pageable);
+		List<OnlineMessagesDto> dtoList = new ArrayList<OnlineMessagesDto>();
+		for (Map<String, Object> map : page.getContent()) {
+			OnlineMessagesDto dto = new OnlineMessagesDto();
+			dto.setUserId((String)map.get("send_user_id"));
+			if(dto.getUserId().equals(sendUser.getId())) {
+                dto.setUserImg(sendUser.getPhoto());
+            }else if(dto.getUserId().equals(receiveUser.getId())){
+                dto.setUserImg(receiveUser.getPhoto());
+            }
+			dto.setType((String)map.get("type"));
+			dto.setContent((String)map.get("content"));
+			dto.setFileKey((String)map.get("file_key"));
+			dto.setDuration((String)map.get("duration"));
+			dto.setCreateTime((Date)map.get("create_time"));
+			if(map.get("time_millis") != null) {
+				dto.setTimeMillis(map.get("time_millis").toString());
+			}
+			dtoList.add(dto);
+		}
+		Map<String, Object> data = new HashMap<String,Object>();
+        data.put("pages", page.getTotalElements());
+        data.put("pageSize", pageable.getPageSize());
+        data.put("pageNo", pageable.getPageNumber()+1);
+		data.put("list", dtoList);
+		responseEntity.success(data,"成功");
+		return responseEntity;
+	}
+
+	@Override
+	@Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public ResponseEntity onlineNoReadMessageSum(String userId) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		//查询用户聊天所有好友未读消息总数
+		int count = userMessageService.countByReceiveUserId(userId);
+		Map<String, Object> data = new HashMap<String,Object>();
+    	data.put("unreadSum", count);
+        responseEntity.success(data,"成功");
+		return responseEntity;
+	}
+
+	@Override
+	public void setMessagesRead(String userId, String receiveUserId) {
+		//设置聊天消息已读
+		userMessageService.updateMessageHaveRead(userId,receiveUserId);
+	}
+
+	@Override
+	public void syncRefreshGrade() {
+		//同步更新年级
+		//上学期日期
+		String firstSemesterDate = configService.findByParamCode("FIRST_SEMESTER_DATE");
+		//下学期日期
+		String secondSemesterDate = configService.findByParamCode("SECOND_SEMESTER_DATE");
+		
+		//判断当天时间日期是否和上学期相同
+		String semesterDate = DateHelper.format(new Date(), "MM月dd日");
+		
+		if(semesterDate.equals(firstSemesterDate)) {
+			//如果是上学期 那么需要更新tb_lib_vip表学生的年级升学信息，及需要更改tb_sys_config_semester为上学期
+			vipService.updateGradeByGrade("高三", "高二");
+			vipService.updateGradeByGrade("高二", "高一");
+			vipService.updateGradeByGrade("高一", "九年级");
+			vipService.updateGradeByGrade("九年级", "八年级");
+			vipService.updateGradeByGrade("八年级", "七年级");
+			vipService.updateGradeByGrade("七年级", "六年级");
+			vipService.updateGradeByGrade("六年级", "五年级");
+			vipService.updateGradeByGrade("五年级", "四年级");
+			vipService.updateGradeByGrade("四年级", "三年级");
+			vipService.updateGradeByGrade("三年级", "二年级");
+			vipService.updateGradeByGrade("二年级", "一年级");
+			vipService.updateGradeByGrade("一年级", "学前");
+			Config config = configService.findConfigByParamCode("semester");
+			config.setParamVal("1");
+			configService.save(config);
+		}else if(semesterDate.equals(secondSemesterDate)) {
+			//如果是下学期 需要更改tb_sys_config_semester为下学期
+			Config config = configService.findConfigByParamCode("semester");
+			config.setParamVal("2");
+			configService.save(config);
+		}
+	}
+
+	@Override
+	public void pushAllBySystemMessage(String type, String title) {
+		Map<String, Object> custom = new HashMap<String, Object>();
+		custom.put("type", "SYSTEM_MESSAGE");
+		custom.put("time", new Date());
+		Map<String, Object> map2 = new HashMap<String, Object>();
+		map2.put("title", title);
+		custom.put("data", map2);
+		//系统消息推送所有设备
+		//推送所有安卓端
+		//推送所有ios端
+		String sysEnv = (String) SystemResourceLocator.getValue("SYS_ENV");
+        String content = JSON.toJSONString(custom);
+		switch (Integer.parseInt(type)) {
+		case 0:
+			//所有端
+			//信鸽各端定义 2:家长端 3:学生端 4:老师端 5:校长端
+			//家长端
+			MessagePushUtils.pushAllByAndroid("私塾家", content, 2, "message");
+			MessagePushUtils.pushAllByIosAPNS(title, 2, null, custom, Integer.valueOf(sysEnv));
+			
+			//学生端
+			MessagePushUtils.pushAllByAndroid("私塾家", content, 3, "message");
+			MessagePushUtils.pushAllByIosAPNS(title, 3, null, custom, Integer.valueOf(sysEnv));
+			
+			//老师端
+			MessagePushUtils.pushAllByAndroid("私塾家", content, 4, "message");
+			MessagePushUtils.pushAllByIosAPNS(title, 4, null, custom, Integer.valueOf(sysEnv));
+			
+			//校长端
+			MessagePushUtils.pushAllByAndroid("私塾家", content, 5, "message");
+			MessagePushUtils.pushAllByIosAPNS(title, 5, null, custom, Integer.valueOf(sysEnv));
+			break;
+		case 1:
+			//学生端
+			MessagePushUtils.pushAllByAndroid("私塾家", content, 3, "message");
+			MessagePushUtils.pushAllByIosAPNS(title, 3, null, custom, Integer.valueOf(sysEnv));
+			break;
+		case 2:
+			//家长端
+			MessagePushUtils.pushAllByAndroid("私塾家", content, 2, "message");
+			MessagePushUtils.pushAllByIosAPNS(title, 2, null, custom, Integer.valueOf(sysEnv));
+			break;
+		case 3:
+			//老师端
+			MessagePushUtils.pushAllByAndroid("私塾家", content, 4, "message");
+			MessagePushUtils.pushAllByIosAPNS(title, 4, null, custom, Integer.valueOf(sysEnv));
+			break;
+		case 4:
+			//校长端
+			MessagePushUtils.pushAllByAndroid("私塾家", content, 5, "message");
+			MessagePushUtils.pushAllByIosAPNS(title, 5, null, custom, Integer.valueOf(sysEnv));
+			break;
+		default:
+			break;
+		}
+	}
+
+	@Override
+	public String discernPictureByAI(String fileKey) {
+		//调用AI接口识别图片内容
+        return FaceReq.discernPicture(fileKey, new HashMap<String, String>());
+	}
+
+	@Override
+	public ResponseEntity getChildService(String vipId) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		Map<String, Object> data = new HashMap<>();
+		//获取小孩服务集合
+		List<Integer> zybServiceList = libVipServiceService.getChildServiceList(vipId);
+		data.put("zybServiceList", zybServiceList);
+		if(CollectionUtils.isNotEmpty(zybServiceList)) {
+			data.put("isZybService", 1);
+		}else {
+			data.put("isZybService", 0);
+		}
+		responseEntity.success(data, "成功");
+		return responseEntity;
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/common/service/impl/ConchCommonServiceImpl.java

@@ -0,0 +1,912 @@
+package com.ssj.service.conch.common.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.alibaba.fastjson.JSON;
+import com.ssj.bean.conch.conch.domain.ConchDerver;
+import com.ssj.bean.conch.conch.domain.ConchDerverUseRecord;
+import com.ssj.bean.conch.conch.domain.SconPadInfo;
+import com.ssj.bean.sys.fx.domain.Merchant;
+import com.ssj.bean.sys.give.GiveRecord;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.bean.weixin.libmy.domain.LibVipBind;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.bean.weixin.push.domain.SendTemplateShort;
+import com.ssj.bean.weixin.sales.domain.LibVipService;
+import com.ssj.bean.weixin.user.domain.QrCode;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.conch.push.util.PushConstants;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.framework.core.util.*;
+import com.ssj.framework.idworker.IdWorker;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.service.conch.common.service.ConchCommonService;
+import com.ssj.service.conch.conch.service.ConchDerverService;
+import com.ssj.service.conch.conch.service.ConchDerverUseRecordService;
+import com.ssj.service.conch.conch.service.SconPadInfoService;
+import com.ssj.service.conch.parents.request.version4.SwipeQrCodeReq;
+import com.ssj.service.conch.parents.v1.dto.SwipeQrCodeV1Dto;
+import com.ssj.service.conch.parents.v1.request.SwipeQrCodeV1Req;
+import com.ssj.service.conch.student.dto.SwipeLoginDto;
+import com.ssj.service.conch.student.request.SwipeQrCodeRequest;
+import com.ssj.service.sys.easemob.service.EasemobService;
+import com.ssj.service.sys.fx.service.DeviceService;
+import com.ssj.service.sys.give.GiveRecordService;
+import com.ssj.service.sys.push.service.SconXingeService;
+import com.ssj.service.weixin.library.service.IBookManagerService;
+import com.ssj.service.weixin.library.service.ILibJoinService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import com.ssj.service.weixin.library.service.LibVipBindService;
+import com.ssj.service.weixin.push.service.PushTemplateService;
+import com.ssj.service.weixin.sales.service.LibVipServiceService;
+import com.ssj.service.weixin.user.service.QrCodeService;
+import com.ssj.service.weixin.user.service.UserService;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+@Service(version="1.0")
+@Transactional
+public class ConchCommonServiceImpl implements ConchCommonService{
+	
+	protected Logger	logger   = LoggerFactory.getLogger(this.getClass());
+	
+	@Autowired
+    private TokenManager tokenManager;
+	@Autowired
+	private ILibVipService vipService;
+	@Autowired
+	private UserService userService;
+	@Autowired
+	private ILibJoinService joinService;
+	@Autowired
+	private LibVipServiceService  libVipServiceService;
+	@Autowired
+	private ConchDerverService conchDerverService;
+	@Autowired
+	private QrCodeService qrCodeService;
+	@Autowired
+	private IBookManagerService managerService;
+	@Autowired
+	private LibVipBindService libVipBindService;
+	 @Autowired
+	private PushTemplateService  pushTemplateService;
+	 @Autowired
+	private SconXingeService sconXingeService;
+	@Autowired
+	private EasemobService easemobService;
+
+
+
+	@Autowired
+	private GiveRecordService giveRecordService;
+	@Autowired
+	private ConchDerverUseRecordService conchDerverUseRecordService;
+
+	@Autowired
+	private DeviceService deviceService;
+
+	@Autowired
+	private SconPadInfoService sconPadInfoService;
+
+	@Override
+	public ResponseEntity swipeQrCode(String userId,SwipeQrCodeReq req) {
+		//通过传入的二维码内容判断
+		//如果是扫描绑定贝壳的二维码
+		ConchDerver  conchDerver = conchDerverService.findByQrCode(req.getQrCode());
+		if(conchDerver != null) {
+			//如果家长小孩绑定过贝壳则提示该小孩已绑定贝壳
+			if(StringUtils.isBlank(req.getVipId())) {
+				return swipeBindDerverService(conchDerver.getDerver(),userId,req.getLongitude(), req.getLatitude());
+			}
+			LibVip libVip = vipService.getById(req.getVipId());
+			if(libVip == null ) {
+				return swipeBindDerverService(conchDerver.getDerver(),userId,req.getLongitude(), req.getLatitude());
+			}
+			if(StringUtils.isNotBlank(libVip.getDerver())) {
+				return new ResponseEntity().failure("您已绑定过小塾相机,无需再绑定");
+			}
+			return this.bindDerver(req.getVipId(), req.getLongitude(), req.getLatitude(), conchDerver.getDerver());
+		}
+		//如果是家长端扫描绑定校长二维码
+		if(req.getQrCode().contains("http://weixin.qq.com/q")||req.getQrCode().contains("https://weixin.qq.com/q")) {
+			//绑定校长业务
+			return this.swipeBindMaster(userId, req.getQrCode());
+		}
+		ResponseEntity responseEntity = new ResponseEntity();
+		responseEntity.failure("二维码识别错误");
+		return responseEntity;
+	}
+	
+	
+	/**
+	 * @param derver
+	 * @param userId
+	 * @param longitude
+	 * @param latitude
+	 * @return
+	
+	 * 方法说明:家长app 没有小孩的情况下扫描绑定小塾,后台添加贝壳服务并生成孩子信息到tb_lib_vip表
+	
+	 * 创立日期:2018年8月21日 上午10:36:04
+	 * 创建人:yangcan
+	
+	 */
+	private ResponseEntity swipeBindDerverService(String derver, String userId,String longitude, String latitude) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		ConchDerver  conchDerver = conchDerverService.findByDerver(derver);
+		if(conchDerver !=null){
+			String derVipId = conchDerver.getVipId();
+			if(derVipId!=null){
+				responseEntity.failure("设备已被其他用户绑定");
+				return responseEntity;
+			}else{
+				User user =	userService.getById(userId);
+				LibVip  libVip= new LibVip();
+				Date date = new Date();
+				libVip.setImgUrl(user.getPhoto());
+				libVip.setChildName(user.getName());
+				libVip.setActivateTime(date);
+				libVip.setCreateTime(date);
+				libVip.setStat("1");//生成的会员卡设置为有效状态 1--有效 2--无效',
+				libVip.setLevel(1);
+				libVip.setUserId(userId);
+				libVip.setBanben(2);
+				libVip.setDerver(derver);
+				vipService.save(libVip);
+				
+				//推送贝壳消息，创建用户
+				String derUserId = libVip.getChildUserId();
+				if(StringUtils.isBlank(derUserId)){
+					User childUserInfo = new User();
+					childUserInfo.setId(IdWorker.generateId());
+					childUserInfo.setEasemobName(userService.createUniqueEasemobName());
+					//创建小孩环信账号
+					easemobService.createUserSingle(childUserInfo.getEasemobName(), null);
+					//添加家长和小孩的好友关系
+					easemobService.addFriendSingle(user.getEasemobName(), childUserInfo.getEasemobName());
+					childUserInfo.setPassword("123456");
+					//需要创建小塾的账号密码
+					childUserInfo.setPwdSalt(PasswordUtil.generateSalt());
+					childUserInfo.setPassword(PasswordUtil.initPassword(childUserInfo.getPassword(), childUserInfo.getPwdSalt()));
+					childUserInfo.setCreateTime(new Date());
+					userService.save(childUserInfo);
+					libVip.setChildUserId(childUserInfo.getId());
+				}else {
+					User childUserInfo = userService.getById(derUserId);
+					if(StringUtils.isBlank(childUserInfo.getEasemobName())) {
+						childUserInfo.setEasemobName(userService.createUniqueEasemobName());
+						userService.save(childUserInfo);
+						//创建小孩环信账号
+						easemobService.createUserSingle(childUserInfo.getEasemobName(), null);
+						User parentUserInfo = userService.getById(libVip.getUserId());
+						//添加家长和小孩的好友关系
+						easemobService.addFriendSingle(parentUserInfo.getEasemobName(), childUserInfo.getEasemobName());
+					}
+				}
+				conchDerver.setUserId(libVip.getChildUserId());
+				conchDerver.setVipId(libVip.getId());
+				conchDerver.setUpdatedDate(new Date());
+				logger.info("恭喜您绑定成功");
+				
+				int isService = conchDerver.getIsService();
+				if(isService==0){
+					conchDerver.setIsService(1);
+					giveBindConchZybService(libVip.getId());
+				}
+				vipService.save(libVip);
+				conchDerverService.save(conchDerver);
+				tokenManager.set("DERVER_"+derver, conchDerver,1);
+			
+				//推送家长提示贝壳绑定成功
+				//推送绑定成功消息给小塾
+				Map<String,Object> map = new HashMap<String,Object>();
+				map.put("type", "BIND");
+				map.put("time", new Date());
+				map.put("data", "{}");
+				String content = JSON.toJSONString(map);
+				//信鸽推送
+		        sconXingeService.asynPushThreadTask(derver,null,1,content,PushConstants.PUSH_OTHER);
+				responseEntity.success("小塾相机绑定成功");
+				return responseEntity;
+			}
+		}else{
+			responseEntity.failure("小塾相机不存在");
+			return responseEntity;
+		}
+	}
+	
+	
+	/**
+	 * @param vipId
+	 * @param longitude
+	 * @param latitude
+	 * @param derver
+	 * @return
+	
+	 * 方法说明:家长app扫描小孩绑定小塾
+	
+	 * 创立日期:2018年8月10日 下午1:35:59
+	 * 创建人:yangcan
+	
+	 */
+	@Override
+	public ResponseEntity bindDerver(String vipId, String longitude, String latitude, String derver) {
+		return this.bindDerver(vipId, longitude, latitude, derver, null);
+	}
+
+	@Override
+	public ResponseEntity bindDerver(String vipId, String longitude, String latitude, String derver, String userId) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		ConchDerver conchDerver = conchDerverService.findByDerver(derver);
+		if (conchDerver != null) {
+			//此小塾为试用的
+			/*if (conchDerver.getUseType() == 2 && StringUtil.isNotBlank(userId)) {
+				if (this.conchTryServiceOperate(responseEntity, userId, derver, conchDerver.getUseDays())) {
+					return responseEntity;
+				}
+			}*/
+
+			/*//试用小塾给对应的设置的试用服务时长（新业务）
+			if (conchDerver.getUseType() == 2) {
+				this.giveBindConchZybServiceV1(vipId, conchDerver.getUseDays());
+			} else if (conchDerver.getUseType() == 3) {
+				//永久的小塾，每绑定一次送10年
+				//libVipServiceService.saveLibVipServiceV2("S003", "C004", vipId, new Date(), 120, "zyb");
+			}*/
+			//给对应服务
+			//this.giveBindConchZybServiceV2(vipId, conchDerver.getUseDays(), conchDerver.getUseType());
+			String derVipId = conchDerver.getVipId();
+			if (StringUtils.isNotBlank(derVipId)) {
+				if (derVipId.equals(vipId)) {
+					responseEntity.failure("您已绑定过小塾相机,无需再绑定");
+					return responseEntity;
+				} else {
+					responseEntity.failure("小塾相机已被其他用户绑定");
+					return responseEntity;
+				}
+			} else {
+				LibVip libVip = vipService.getById(vipId);
+				libVip.setActivateTime(new Date());
+				libVip.setDerver(derver);
+
+				//推送贝壳消息，创建用户
+				String derUserId = libVip.getChildUserId();
+				if (StringUtils.isBlank(derUserId)) {
+					User childUserInfo = new User();
+					childUserInfo.setId(IdWorker.generateId());
+					childUserInfo.setEasemobName(userService.createUniqueEasemobName());
+					//创建小孩环信账号
+					easemobService.createUserSingle(childUserInfo.getEasemobName(), null);
+					User parentUserInfo = userService.getById(libVip.getUserId());
+					//添加家长和小孩的好友关系
+					easemobService.addFriendSingle(parentUserInfo.getEasemobName(), childUserInfo.getEasemobName());
+
+					childUserInfo.setPassword("123456");
+					//需要创建小塾的账号密码
+					childUserInfo.setPwdSalt(PasswordUtil.generateSalt());
+					childUserInfo.setPassword(PasswordUtil.initPassword(childUserInfo.getPassword(), childUserInfo.getPwdSalt()));
+					childUserInfo.setCreateTime(new Date());
+					userService.save(childUserInfo);
+					libVip.setChildUserId(childUserInfo.getId());
+				} else {
+					User childUserInfo = userService.getById(derUserId);
+					if (StringUtils.isBlank(childUserInfo.getEasemobName())) {
+						childUserInfo.setEasemobName(userService.createUniqueEasemobName());
+						userService.save(childUserInfo);
+						//创建小孩环信账号
+						easemobService.createUserSingle(childUserInfo.getEasemobName(), null);
+						User parentUserInfo = userService.getById(libVip.getUserId());
+						//添加家长和小孩的好友关系
+						easemobService.addFriendSingle(parentUserInfo.getEasemobName(), childUserInfo.getEasemobName());
+					}
+				}
+				//存入redis ,小程序扫描公众号会推送消息,公众号直接返回 不提示
+
+				//tokenManager.setString("sharingschool" + derver, "1", 5);
+
+				conchDerver.setUserId(libVip.getChildUserId());
+				conchDerver.setVipId(vipId);
+				conchDerver.setUpdatedDate(new Date());
+				logger.info("恭喜您绑定小塾相机成功");
+
+				int isService = conchDerver.getIsService();
+				if (isService == 0) {
+
+					conchDerver.setIsService(1);
+					//无作业吧服务，或作业吧服务已过期，赠送作业吧服务2个月
+					giveBindConchZybService(libVip.getId());
+				}
+
+				//是否串区
+				Merchant merchant=deviceService.checkIsRage(conchDerver.getImei(),conchDerver.getLongitude(),conchDerver.getLatitude(),longitude,latitude);
+				if(StringUtil.isBlank(libVip.getPosCode())&&merchant!=null){
+					libVip.setPosCode(merchant.getPosCode());
+				}
+
+				vipService.save(libVip);
+				conchDerverService.save(conchDerver);
+				tokenManager.set("DERVER_"+derver, conchDerver,1);
+			
+				//推送绑定成功消息给小塾
+				Map<String,Object> map = new HashMap<String,Object>();
+				map.put("type", "BIND");
+				map.put("time", new Date());
+				map.put("data", "{}");
+				String content = JSON.toJSONString(map);
+				//信鸽推送
+		        sconXingeService.asynPushThreadTask(derver,null,1,content,PushConstants.PUSH_OTHER);
+
+				this.giveBindConchZybServiceV3(vipId, conchDerver);
+				responseEntity.success("小塾相机绑定成功");
+				return responseEntity;
+			}
+		} else {
+			responseEntity.failure("小塾相机不存在");
+			return responseEntity;
+		}
+	}
+	
+	private ResponseEntity swipeBindMaster(String userId,String qrCodeUrl) {
+		ResponseEntity responseEntity = new ResponseEntity();
+        try {
+			QrCode qrCode =qrCodeService.findByUrl(qrCodeUrl);
+			if(qrCode!=null && !"conch".equals(qrCode.getParentId())){
+				String newUserId = qrCode.getObjectId();
+				TbLibManager isMaster = managerService.findByUserId(newUserId, 6);//证明是校长
+				if(isMaster!=null){
+					LibVipBind libVipBind = libVipBindService.findByUserId(userId);
+					if(libVipBind!=null){
+						String masterId  =libVipBind.getMasterId();
+						if(!newUserId.equals(masterId)){
+							responseEntity.failure(ResponseConstant.CODE_000, "您已经绑定了校长，您不能绑定其他校长");
+							return responseEntity;
+						}
+					}
+					
+					
+					List<LibVip> list =  new ArrayList<LibVip>();
+					list.addAll(vipService.getByUserId(userId));
+					User parentsuser=	userService.getById(userId);
+					//没有会员卡就生成一张会员卡
+					if(list.size()==0){
+						LibVip  libVip= new LibVip();
+						Date date = new  Date();
+						libVip.setImgUrl(parentsuser.getPhoto());
+						libVip.setChildName(parentsuser.getName());
+						libVip.setActivateTime(date);
+						libVip.setCreateTime(date);
+						libVip.setStat("1");//生成的会员卡设置为有效状态 1--有效 2--无效',
+						libVip.setLevel(1);
+						libVip.setUserId(userId);
+						vipService.save(libVip);
+						list.add(libVip);
+					}
+					
+					if(list!=null && list.size()>0){
+						//全部插入绑定
+						for (LibVip libVip : list) {
+							libVipBindService.vipBindByMasterId(libVip.getId(), newUserId, null,libVip.getUserId());
+						}
+						
+					Map<String,String> data =new HashMap<String, String>();
+					User masteruser = userService.getById(newUserId);
+				
+					//String contentMessage = "尊敬的"+isMaster.getName()+"校长您好！您已与"+user.getName()+"绑定成功，请提醒您的家长完善资料！";
+					   String masterUserName = masteruser.getName()!=null&&masteruser.getName().trim().length()>0&&!"null".equals(masteruser.getName())?masteruser.getName():"";
+					   String parentsUserName = parentsuser.getName()!=null&&parentsuser.getName().trim().length()>0&&!"null".equals(parentsuser.getName())?parentsuser.getName():"";
+					   String contentMessage ="亲爱的用户您好，您与"+parentsUserName+"已成功完成关系绑定，私塾家线上服务将为您带来亲切的教学体验！";
+					  
+    					data.put("first", contentMessage+"\n");
+    					data.put("keyword1","绑定成功");
+    					data.put("keyword2", DateHelper.format(new Date(),"yyyy-MM-dd HH:mm"));
+    					String template_id = "OPENTM412814251";
+    					SendTemplateShort sendTemplateShort=new SendTemplateShort(masteruser.getAccount(),template_id,null,data);
+    					pushTemplateService.saveAndSendPushWxTemplate(sendTemplateShort);
+    					Map<String,String> data1 =new HashMap<String, String>();
+    					//String parentscontentMessage = "亲爱的"+user.getName()+"家长您好，您已与"+isMaster.getName()+"校长绑定成功，校长将全程为您孩子的课程保驾护航！";
+    					 String parentscontentMessage ="亲爱的用户您好，您与"+masterUserName+"已成功完成关系绑定，私塾家线上服务将为您带来亲切的教学体验！";
+    					data1.put("first", parentscontentMessage+"\n");
+    					data1.put("keyword1","绑定成功");
+    					data1.put("keyword2", DateHelper.format(new Date(),"yyyy-MM-dd HH:mm"));
+    					sendTemplateShort=new SendTemplateShort(parentsuser.getAccount(),template_id,null,data1);
+    					pushTemplateService.saveAndSendPushWxTemplate(sendTemplateShort);
+    					
+    					//给校长推送绑定提示消息
+    					//sconXingeService.asynPushThreadTask(newUserId,5,contentMessage);
+    					//给家长推送绑定提示消息
+    			        sconXingeService.asynPushThreadTask(userId,null,2,parentscontentMessage,PushConstants.PUSH_OTHER);
+					}
+					//插入绑定关系
+					responseEntity.success("校长绑定成功");
+				}else{
+					//不是，那么就不插入
+					responseEntity.failure(ResponseConstant.CODE_000, "只能绑定校长");
+				}
+			}else{
+				responseEntity.failure(ResponseConstant.CODE_000, "二维码不存在");
+			}
+        } catch (Exception e){
+            logger.error(e.getMessage());
+            responseEntity.failure(ResponseConstant.CODE_500, "查询异常");
+        }
+        return responseEntity;
+	}
+	
+	@Override
+	public ResponseEntity swipeQrCode(SwipeQrCodeRequest request) {
+		//我的小孩名片内容格式 https://xt.sharingschool.com/weixin/libVip/bindingLibVip_"+vipId+".html
+		String vipId = request.getQrCode().replace((String) SystemResourceLocator.getValue("sys_url")+"/weixin/libVip/bindingLibVip_", "").replace(".html", "");
+		
+		LibVip libVip = vipService.getById(vipId);
+		if(libVip != null) {
+			if(StringUtils.isBlank(libVip.getDerver())) {
+				//如果学生没有购买小塾相机也可以使用学生端
+				if(StringUtils.isBlank(libVip.getChildUserId())) {
+					return swipeParentLogin(libVip,request.getPlatform(),request.getXingeToken());
+				}else {
+					return swipeLogin(libVip.getChildUserId(),libVip,request.getPlatform(),request.getXingeToken());
+				}
+			}
+			ConchDerver conchDerver = conchDerverService.findByDerver(libVip.getDerver());
+			if(StringUtils.isBlank(conchDerver.getUserId())) {
+				return new ResponseEntity().failure("该小塾相机暂未绑定");
+			}
+			return swipeLogin(conchDerver.getUserId(),libVip,request.getPlatform(),request.getXingeToken());
+		}
+		
+		//如果是扫描绑定贝壳的二维码
+		ConchDerver  conchDerver = conchDerverService.findByQrCode(request.getQrCode());
+		if(conchDerver != null) {
+			if(StringUtils.isBlank(conchDerver.getUserId())) {
+				return new ResponseEntity().failure("该小塾相机暂未绑定");
+			}
+			libVip = vipService.getById(conchDerver.getVipId());
+			return swipeLogin(conchDerver.getUserId(),libVip,request.getPlatform(),request.getXingeToken());
+		}
+		ResponseEntity responseEntity = new ResponseEntity();
+		responseEntity.failure("二维码识别错误");
+		return responseEntity;
+	}
+	
+	
+//	private ResponseEntity swipeLogin(LibVip libVip,String platform,String xingeToken) {
+//		ResponseEntity responseEntity = new ResponseEntity();
+//		User user = userService.getById(userId);
+//		if(user == null) {
+//			responseEntity.failure("用户不存在");
+//		}else {
+//			//保存信鸽token
+//			sconXingeService.saveOrUpdate(userId, xingeToken, platform,3);
+//			SwipeLoginDto dto = new SwipeLoginDto();
+//			//生成学生登录token
+//			dto.setAccessToken(tokenManager.createToken(CodecUtil.createUUID(),userId));
+//			dto.setVipId(libVip.getId());
+//			dto.setUserName(libVip.getChildName());
+//			dto.setImgUrl(libVip.getImgUrl());
+//			dto.setEasemobName(user.getEasemobName());
+//			responseEntity.success(dto, "登录成功!");
+//		}
+//		return responseEntity; 
+//	}
+	
+	/**
+	 * @param libVip
+	 * @param platform
+	 * @param xingeToken
+	 * @return
+	
+	 * 方法说明:学生没有贝壳号,学生扫描家长端登录
+	
+	 * 创立日期:2018年10月30日 下午3:53:30
+	 * 创建人:yangcan
+	
+	 */
+	private  ResponseEntity swipeParentLogin(LibVip libVip,String platform,String xingeToken) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		//生成一个学生账号
+		User childUserInfo = new User();
+		childUserInfo.setId(IdWorker.generateId());
+		childUserInfo.setEasemobName(userService.createUniqueEasemobName());
+		//创建小孩环信账号
+		easemobService.createUserSingle(childUserInfo.getEasemobName(), null);
+		User parentUserInfo = userService.getById(libVip.getUserId());
+		//添加家长和小孩的好友关系
+		easemobService.addFriendSingle(parentUserInfo.getEasemobName(), childUserInfo.getEasemobName());
+		
+		childUserInfo.setPassword("123456");
+		//需要创建小塾的账号密码
+		childUserInfo.setPwdSalt(PasswordUtil.generateSalt());
+		childUserInfo.setPassword(PasswordUtil.initPassword(childUserInfo.getPassword(), childUserInfo.getPwdSalt()));
+		childUserInfo.setCreateTime(new Date());
+		userService.save(childUserInfo);
+		libVip.setChildUserId(childUserInfo.getId());
+		vipService.save(libVip);
+		
+		//保存信鸽token
+		sconXingeService.saveOrUpdate(childUserInfo.getId(), xingeToken, platform,3);
+		SwipeLoginDto dto = new SwipeLoginDto();
+		//生成学生登录token
+		dto.setAccessToken(tokenManager.createToken(CodecUtil.createUUID(),childUserInfo.getId(),"APP"));
+		dto.setVipId(libVip.getId());
+		dto.setUserName(libVip.getChildName());
+		dto.setImgUrl(libVip.getImgUrl());
+		dto.setEasemobName(childUserInfo.getEasemobName());
+		responseEntity.success(dto, "登录成功!");
+		return responseEntity;
+	}
+	
+	
+	
+	
+	@Override
+	public  ResponseEntity swipeLogin(String userId,LibVip libVip,String platform,String xingeToken) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		User user = userService.getById(userId);
+		if(user == null) {
+			responseEntity.failure("用户不存在");
+		}else {
+			//保存信鸽token
+			sconXingeService.saveOrUpdate(userId, xingeToken, platform,3);
+			SwipeLoginDto dto = new SwipeLoginDto();
+			//生成学生登录token
+			dto.setAccessToken(tokenManager.createToken(CodecUtil.createUUID(),userId,"APP"));
+			dto.setVipId(libVip.getId());
+			dto.setUserName(libVip.getChildName());
+			dto.setImgUrl(libVip.getImgUrl());
+			dto.setEasemobName(user.getEasemobName());
+			responseEntity.success(dto, "登录成功!");
+		}
+		return responseEntity;
+	}
+
+
+	@Override
+	public ResponseEntity swipeQrCodeV1(String userId, SwipeQrCodeV1Req req) {
+		//通过传入的二维码内容判断
+		//如果是扫描绑定贝壳的二维码
+		ResponseEntity responseEntity = new ResponseEntity();
+		ConchDerver  conchDerver = conchDerverService.findByQrCode(req.getQrCode());
+		if(conchDerver != null) {
+			//如果家长小孩绑定过贝壳则提示该小孩已绑定贝壳
+			if(StringUtils.isBlank(req.getVipId())) {
+				SwipeQrCodeV1Dto dto = new SwipeQrCodeV1Dto();
+				dto.setType(1);
+				dto.setDerver(conchDerver.getDerver());
+				//随机从4张头像中选择一个
+				int num = new Random().nextInt(4) + 1;
+				dto.setImgUrl("/childImg/"+num+".png");
+				responseEntity.success(dto, "成功");
+				return responseEntity;
+			}
+			LibVip libVip = vipService.getById(req.getVipId());
+			if(libVip == null ) {
+				return responseEntity.failure("查询小孩信息失败");
+			}
+			if(StringUtils.isNotBlank(libVip.getDerver())) {
+				return responseEntity.failure("您已绑定过小塾相机,无需再绑定");
+			}
+			return this.bindDerver(req.getVipId(), req.getLongitude(), req.getLatitude(), conchDerver.getDerver());
+		}
+		//如果是家长端扫描绑定校长二维码
+		if(req.getQrCode().contains("http://weixin.qq.com/q")||req.getQrCode().contains("https://weixin.qq.com/q")) {
+			//绑定校长业务
+			responseEntity = this.swipeBindMaster(userId, req.getQrCode());
+			if(responseEntity.getCode().equals(ResponseConstant.CODE_999)) {
+				SwipeQrCodeV1Dto dto = new SwipeQrCodeV1Dto();
+				dto.setType(2);
+				responseEntity.success(dto, "成功");
+			}
+			return responseEntity;
+		}
+		responseEntity.failure("二维码识别错误");
+		return responseEntity;
+	}
+
+	@Override
+	@Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public ResponseEntity newSwipeQrCodeV1(String userId, SwipeQrCodeV1Req req) {
+		//通过传入的二维码内容判断
+		//如果是扫描绑定贝壳的二维码
+		ResponseEntity responseEntity = new ResponseEntity();
+		ConchDerver  conchDerver = conchDerverService.findByQrCode(req.getQrCode());
+		if(conchDerver != null) {
+			tokenManager.setString("sharingschool" + conchDerver.getDerver(), "1", 5);
+			if(StringUtils.isNotBlank(conchDerver.getVipId())) {
+				return responseEntity.failure("小塾相机已被其他用户绑定");
+			}
+			SwipeQrCodeV1Dto dto = new SwipeQrCodeV1Dto();
+			dto.setType(1);
+			dto.setDerver(conchDerver.getDerver());
+			//随机从4张头像中选择一个
+			int num = new Random().nextInt(4) + 1;
+			dto.setImgUrl("/childImg/"+num+".png");
+			responseEntity.success(dto, "成功");
+			return responseEntity;
+		}
+		//如果是家长端扫描绑定校长二维码
+		if(req.getQrCode().contains("http://weixin.qq.com/q")||req.getQrCode().contains("https://weixin.qq.com/q")) {
+			//绑定校长业务
+			QrCode qrCode =qrCodeService.findByUrl(req.getQrCode());
+			if(qrCode!=null && !"conch".equals(qrCode.getParentId())){
+				String newUserId = qrCode.getObjectId();
+				TbLibManager isMaster = managerService.findByUserId(newUserId, 6);//证明是校长
+				if(isMaster!=null){
+					SwipeQrCodeV1Dto dto = new SwipeQrCodeV1Dto();
+					dto.setType(2);
+					dto.setMasterId(newUserId);
+					responseEntity.success(dto, "成功");
+				}else{
+					responseEntity.failure(ResponseConstant.CODE_000, "只能绑定校长");
+				}
+			}else{
+				responseEntity.failure(ResponseConstant.CODE_000, "二维码不存在");
+			}
+	        return responseEntity;
+		}
+		//如果是家长端扫作业吧会员卡的二维码
+        if (req.getQrCode().contains("/weixin/libVip/bindingLibVip")) {
+            SwipeQrCodeV1Dto dto = new SwipeQrCodeV1Dto();
+            dto.setType(3);
+            String str = req.getQrCode();
+            dto.setVipId(str.substring(str.indexOf("_") + 1, str.indexOf(".html")));
+            LibVip libVip = vipService.getById(dto.getVipId());
+            if (libVip == null) {
+                responseEntity.failure(ResponseConstant.CODE_000, "该会员不存在");
+            } else if (StringUtils.isNotBlank(libVip.getUserId())) {
+                responseEntity.failure(ResponseConstant.CODE_000, "该会员卡已被绑定");
+            } else {
+                responseEntity.success(dto, "成功");
+            }
+            return responseEntity;
+        }
+		//如果是家长端扫小塾学伴PAD的二维码，如果已经存在该设备，则返回家长下所有孩子
+		if (req.getQrCode().contains("PAD-") || req.getQrCode().contains("pad-")) {
+			SwipeQrCodeV1Dto dto = new SwipeQrCodeV1Dto();
+			dto.setType(4);
+			String str = req.getQrCode();
+			String padCode = str.substring(str.indexOf("-") + 1);
+			SconPadInfo sconPadInfo = sconPadInfoService.findTopByPadCode(padCode);
+			if (sconPadInfo == null) {
+				responseEntity.failure("该设备码不存在");
+			} else {
+				List<LibVip> vipList = vipService.getByUserId(userId);
+				if (vipList.size() > 0) {
+					List<SwipeQrCodeV1Dto.ChildInfo> childList = new ArrayList<>();
+					for (LibVip libVip : vipList) {
+						SwipeQrCodeV1Dto.ChildInfo childDto = dto.new ChildInfo();
+						childDto.setVipId(libVip.getId());
+						childDto.setChildName(libVip.getChildName());
+						childDto.setImgUrl(libVip.getImgUrl());
+						childList.add(childDto);
+					}
+					dto.setList(childList);
+					responseEntity.success(dto, "成功");
+				}else{
+					responseEntity.failure("该家长无小孩，请先绑定小孩");
+				}
+			}
+			return responseEntity;
+		}
+		responseEntity.failure("二维码识别错误");
+		return responseEntity;
+	}
+
+	/**
+	 * 此方法暂时注释，赠送改为用兑换码兑换
+	 * @param vipId
+	 */
+	@Override
+	public void giveBindConchZybService(String vipId) {
+		//绑定赠送作业吧服务2个月
+		/*String sendZybFlag = PropertiesUtil.getValue("sendZybFlag");
+		if ("1".equals(sendZybFlag)) {
+			//赠送记录
+			GiveRecord record = giveRecordService.findByVipId(vipId);
+			if (record == null) {
+				record = new GiveRecord();
+				record.setVipId(vipId);
+				record.setQuantity(2);
+				record.setSpecies("S003");
+				record.setType("C004");
+				record.setCreateTime(new Date());
+				giveRecordService.save(record);
+				libVipServiceService.saveLibVipServiceV2("S003", "C004", vipId, new Date(), 2, "zyb");
+			}
+		}*/
+	}
+
+	@Override
+	public void giveBindConchZybServiceV1(String vipId, int days) {
+		//赠送记录
+		GiveRecord record = giveRecordService.findByVipId(vipId);
+		if (record == null) {
+			record = new GiveRecord();
+			record.setVipId(vipId);
+			record.setQuantity(days);
+			record.setSpecies("S003");
+			record.setType("C022");
+			record.setCreateTime(new Date());
+			giveRecordService.save(record);
+			libVipServiceService.saveLibVipServiceV4("S003", "C022", vipId, new Date(), null, days, record.getId());
+		}
+	}
+
+	@Override
+	public void giveBindConchZybServiceV2(String vipId, int days, int useType) {
+		Date beginTime = new Date();
+		switch (useType) {
+			case 1:
+				this.removeGiveService(vipId);
+				break;
+			case 2:
+				this.removeGiveService(vipId);
+				//试用小塾，每个孩子只送一次服务
+				GiveRecord record = giveRecordService.findByVipId(vipId);
+				if (record == null) {
+					record = new GiveRecord();
+					record.setVipId(vipId);
+					record.setQuantity(days);
+					record.setSpecies("S003");
+					record.setType("C022");
+					record.setCreateTime(new Date());
+					giveRecordService.save(record);
+					libVipServiceService.saveLibVipServiceV4("S003", "C022", vipId, new Date(), null, days, record.getId());
+				}
+				break;
+			case 3:
+				//永久小塾，赠送100年服务
+				LibVipService libVipService = libVipServiceService.findTopByVipIdAndSpeciesOrderByEndTimeDesc(vipId, "S003");
+				if (libVipService != null) {
+					String endTimeString = "2119-01-01";
+					String endTimeCompare = DateUtil.format_yyyyMMdd(libVipService.getEndTime());
+					//服务只赠送一次
+					if (endTimeString.compareTo(endTimeCompare) < 0) {
+						return;
+					}
+					if (DateHelper.compareTwoDate(beginTime, libVipService.getEndTime())) {
+						beginTime = libVipService.getEndTime();
+					}
+				}
+				//结束时间
+				Date endTime = DateHelper.getYearDate(beginTime, 100);
+				if (libVipService == null) {
+					libVipService = new LibVipService();
+					libVipService.setSpecies("S003");
+					libVipService.setType("C006");
+					libVipService.setStartTime(new Date());
+					libVipService.setVipId(vipId);
+					libVipService.setCreateTime(new Date());
+				}
+				libVipService.setEndTime(endTime);
+				libVipService.setStat(1);
+				libVipService.setIsJia(0);
+				libVipService.setOrderDetailsId("zyb");
+				libVipServiceService.save(libVipService);
+				break;
+			default:
+				break;
+		}
+	}
+
+	@Override
+	public void giveBindConchZybServiceV3(String vipId, ConchDerver conchDerver) {
+		int useType = conchDerver.getUseType();
+		Date now = new Date();
+		switch (useType) {
+			case 2:
+				//试用小塾，每个孩子只送一次服务,赠送半个月
+				//试用服务改为赠送1个月 --修订于2019-11-8 by Mount
+				GiveRecord record = giveRecordService.findByVipId(vipId);
+				if (record == null) {
+					//作业批改服务（作业吧服务）
+					String species = "S003";
+					//月卡
+					String type = "C004";
+					//数量
+					int number = 1;
+					record = new GiveRecord();
+					record.setVipId(vipId);
+					record.setSpecies(species);
+					record.setType(type);
+					record.setQuantity(number);
+					record.setGiveWay(1);
+					record.setCreateTime(now);
+					giveRecordService.save(record);
+					libVipServiceService.saveLibVipServiceV4("S003", "C022", vipId, now, null, number, record.getId());
+
+				}
+				break;
+			case 3:
+				if(conchDerver.getIsGiveInvalid() == 0){
+					//记录赠送记录
+					GiveRecord newRecord = new GiveRecord();
+					newRecord.setVipId(vipId);
+					newRecord.setQuantity(2);
+					newRecord.setSpecies("S003");
+					newRecord.setType("C004");
+					newRecord.setGiveWay(2);
+					newRecord.setCreateTime(now);
+					giveRecordService.save(newRecord);
+					//阶段服务版⼩塾（绑定则赠送2个月服务，只会送一次，类似于优惠券）
+					libVipServiceService.saveLibVipServiceV4("S003", "C004", vipId, now, null, 2, newRecord.getId());
+					logger.info("小塾" + conchDerver.getDerver() + "变为正常的小塾");
+					//使用完,记录已赠送过服务
+					conchDerver.setIsGiveInvalid(1);
+					conchDerverService.save(conchDerver);
+
+				}
+				break;
+			default:
+				break;
+		}
+	}
+
+	/**
+	 * 移除已经赠送过的永久服务
+	 * @param vipId
+	 */
+	private void removeGiveService(String vipId) {
+		String endTimeString = "2119-01-01";
+		LibVipService libVipService = libVipServiceService.findTopByVipIdAndSpeciesOrderByEndTimeDesc(vipId, "S003");
+		if (libVipService != null) {
+			Date endTime = libVipService.getEndTime();
+			String endTimeCompare = DateUtil.format_yyyyMMdd(endTime);
+			//证明有赠送过服务，需要移除
+			if (endTimeString.compareTo(endTimeCompare) < 0) {
+				//向前推100年
+				endTime = DateHelper.getYearDate(endTime, -100);
+				libVipService.setEndTime(endTime);
+				libVipServiceService.save(libVipService);
+			}
+		}
+	}
+
+	@Override
+	public boolean conchTryServiceOperate(ResponseEntity responseEntity, String userId, String derver, int useDays) {
+		//用户试用小塾记录
+		ConchDerverUseRecord useRecord = conchDerverUseRecordService.findByUserIdAndDerver(userId, derver);
+		Date now = new Date();
+		if (useRecord != null) {
+			//检验是否在有效试用期内
+			if (!DateHelper.compareTwoDate(now, useRecord.getEndTime())) {
+				responseEntity.failure("此小塾相机试用已到期，不能再次绑定");
+				return true;
+			}
+		} else {
+			useRecord = new ConchDerverUseRecord();
+			useRecord.setUserId(userId);
+			useRecord.setCreateTime(now);
+			useRecord.setDerver(derver);
+			useRecord.setEndTime(DateUtil.getDateAfter(now, useDays));
+			conchDerverUseRecordService.save(useRecord);
+		}
+		return false;
+	}
+
+	@Override
+    public void unbindTryDerver() {
+        //所有今天失效的记录
+        List<ConchDerverUseRecord> list = conchDerverUseRecordService.findOneDayInvalidRecord(new Date());
+        for (ConchDerverUseRecord useRecord : list) {
+            //是否需要解绑
+            boolean needUnbind = false;
+            //需要检验该用户下小孩是否还绑定该试用小塾，有可能已经提前解绑，小塾已给新用户试用
+            //查找家长所有小孩
+            List<LibVip> vipList = vipService.getByUserId(useRecord.getUserId());
+            for (LibVip libVip : vipList) {
+                if (useRecord.getDerver().equals(libVip.getDerver())) {
+                    needUnbind = true;
+                    break;
+                }
+            }
+            if (needUnbind) {
+                conchDerverService.untyingParents(useRecord.getDerver());
+            }
+        }
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/conch/service/impl/ConchDerverUseRecordServiceImpl.java

@@ -0,0 +1,47 @@
+package com.ssj.service.conch.conch.service.impl;
+
+import java.util.Date;
+import java.util.List;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.conch.conch.domain.ConchDerverUseRecord;
+import com.ssj.dao.conch.conch.dao.ConchDerverUseRecordDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.service.conch.conch.service.ConchDerverUseRecordService;
+
+/**
+ * @author Mount Liu
+ * @date 2019/7/30
+ */
+@Service(version = "1.0")
+@Transactional
+public class ConchDerverUseRecordServiceImpl extends BaseServiceImpl<ConchDerverUseRecord, String> implements ConchDerverUseRecordService {
+
+    protected Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @Autowired
+    private ConchDerverUseRecordDao dao;
+
+    @Override
+    public PagingAndSortingRepository<ConchDerverUseRecord, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public ConchDerverUseRecord findByUserIdAndDerver(String userId, String derver) {
+        return dao.findByUserIdAndDerver(userId, derver);
+    }
+
+    @Override
+    public List<ConchDerverUseRecord> findOneDayInvalidRecord(Date oneDay) {
+        return dao.findByEndTime(DateUtil.format_yyyyMMdd(DateUtil.getDateAfter(oneDay, -1)));
+    }
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/conch/service/impl/ConchPadServiceImpl.java

@@ -0,0 +1,900 @@
+package com.ssj.service.conch.conch.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.alibaba.fastjson.JSON;
+import com.ssj.bean.conch.conch.domain.ConchDerver;
+import com.ssj.bean.conch.conch.domain.SconPadInfo;
+import com.ssj.bean.conch.conch.domain.SmarttimePicture;
+import com.ssj.bean.conch.conch.dto.BriefHomeworkPictureDto;
+import com.ssj.bean.conch.conch.dto.HomeworkRecordDto;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseBookCourse;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestion;
+import com.ssj.bean.kmt.kmt.domain.KmtHomeworkWrongQuestion;
+import com.ssj.bean.sys.homework.domain.Homework;
+import com.ssj.bean.sys.homework.domain.HomeworkPicture;
+import com.ssj.bean.sys.imlibuser.TbClassStudent;
+import com.ssj.bean.sys.push.domain.SconXinge;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.bean.weixin.sales.domain.LibVipService;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.bean.weixin.zyb.domain.ZuoybStudentPush;
+import com.ssj.conch.push.util.PushConstants;
+import com.ssj.dao.sys.homework.dao.HomeworkQueryDao;
+import com.ssj.dao.weixin.zuoyb.dao.ZuoybStudentPushDao;
+import com.ssj.framework.core.persistence.DynamicSpecifications;
+import com.ssj.framework.core.persistence.SearchFilter;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.framework.core.util.CodecUtil;
+import com.ssj.framework.core.util.PasswordUtil;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.core.util.SystemResourceLocator;
+import com.ssj.framework.idworker.IdWorker;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.service.conch.conch.dto.HomeworkPictureCommentPadDTO;
+import com.ssj.service.conch.conch.paddto.*;
+import com.ssj.service.conch.conch.padrequest.PadPhoneLoginRequest;
+import com.ssj.service.conch.conch.padrequest.PadUploadHomeworkRequest;
+import com.ssj.service.conch.conch.padrequest.PadUploadPictureRequest;
+import com.ssj.service.conch.conch.padrequest.PadVipIdRequest;
+import com.ssj.service.conch.conch.service.*;
+import com.ssj.service.conch.conch.vo.BookHomeworkWrongQuestionPadVO;
+import com.ssj.service.conch.conch.vo.ExerciseWrongQuestionVO;
+import com.ssj.service.conch.conch.vo.HomeworkFeedbackPadVO;
+import com.ssj.service.conch.conch.vo.WrongQuestionPeriodVO;
+import com.ssj.service.conch.parents.request.version4.SwipePadLoginReq;
+import com.ssj.service.conch.student.dto.RelateKnowledgeDto;
+import com.ssj.service.kmt.enums.HomeworkWrongQuestionTypeEnum;
+import com.ssj.service.kmt.service.KmtExerciseBookCourseService;
+import com.ssj.service.kmt.service.KmtExerciseQuestionService;
+import com.ssj.service.kmt.service.KmtHomeworkWrongQuestionService;
+import com.ssj.service.sys.easemob.service.EasemobService;
+import com.ssj.service.sys.homework.service.HomeworkPictureService;
+import com.ssj.service.sys.homework.service.HomeworkService;
+import com.ssj.service.sys.imlibuser.service.TbClassStudentService;
+import com.ssj.service.sys.parentrole.service.SSJParentRoleService;
+import com.ssj.service.sys.problem.service.ProblemPictureService;
+import com.ssj.service.sys.push.service.SconXingeService;
+import com.ssj.service.sys.schoolmatecircle.service.SSJUserMessageService;
+import com.ssj.service.sys.smarttime.service.SmarttimeService;
+import com.ssj.service.sys.template.CommentTemplateMapperService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import com.ssj.service.weixin.sales.service.LibVipServiceService;
+import com.ssj.service.weixin.user.service.UserService;
+import com.ssj.sys.util.xunfei.XunFeiTTSUtils;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import static java.util.stream.Collectors.groupingBy;
+
+
+/**
+ * @author yangcan
+ * 类描述:小塾学伴PAD业务接口实现
+ * 创建时间:2019/11/6 16:51
+ */
+@Service(version="1.0")
+@Transactional
+public class ConchPadServiceImpl implements ConchPadService {
+	protected Logger	logger   = LoggerFactory.getLogger(this.getClass());
+
+	@Autowired
+	private TokenManager tokenManager;
+
+	@Autowired
+	private UserService userService;
+
+	@Autowired
+	private ILibVipService vipService;
+
+	@Autowired
+	private SSJUserMessageService userMessageService;
+
+    @Autowired
+    private ConchDerverService conchDerverService;
+    @Autowired
+    private HomeworkService homeworkService;
+    @Autowired
+    private HomeworkPictureService homeworkPictureService;
+    @Autowired
+	private ZuoybStudentPushDao studentPushDao;
+    @Autowired
+	private CommentTemplateMapperService commentTemplateMapperService;
+    @Autowired
+	private KmtHomeworkWrongQuestionService kmtHomeworkWrongQuestionService;
+    @Autowired
+	private KmtExerciseQuestionService kmtExerciseQuestionService;
+    @Autowired
+	private KmtExerciseBookCourseService kmtExerciseBookCourseService;
+    @Autowired
+	private HomeworkQueryDao homeworkQueryDao;
+    @Autowired
+    private SconPadInfoService sconPadInfoService;
+    @Autowired
+	private SmarttimeService smarttimeService;
+    @Autowired
+	private ProblemPictureService problemPictureService;
+    @Autowired
+    private SconXingeService sconXingeService;
+    @Autowired
+	private LibVipServiceService libVipServiceService;
+	@Autowired
+	private SSJParentRoleService parentRoleService;
+	@Autowired
+	private TbClassStudentService tbClassStudentService;
+	@Autowired
+	private EasemobService easemobService;
+
+	@Autowired
+	private IntegralDetailService integralDetailService;
+
+	@Autowired
+	private HomeworkRankingService rankingService;
+
+	/**
+	 * 小塾学伴家长手机号登录，通过家长tb_user信息查询tb_lib_vip表小孩信息，返回小孩信息
+	 * @param request
+	 * @return
+	 */
+	@Override
+	public ResponseEntity phoneLogin(PadPhoneLoginRequest request,int type) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		//检验验证码是否正确
+		String code = "";
+		//判断是否是测试环境，如果是测试环境则跳过验证码校验
+        String sysEnv = (String) SystemResourceLocator.getValue("SYS_ENV");
+        if("2".equals(sysEnv) || "13767960482".equals(request.getPhone())) {
+            //开发环境
+            code = request.getVerificationCode();
+        }else {
+            code = tokenManager.getString(request.getPhone());
+        }
+		if (StringUtils.isBlank(code)) {
+			responseEntity.failure("该验证码已经失效，请重新获取");
+			return responseEntity;
+		}
+		if (code.equals(request.getVerificationCode())) {
+			//通过手机号查找user表是否用户绑定该手机，如果没有则需要注册一条用户信息
+			User user = userService.findByMobile(request.getPhone());
+			if (user == null) {
+				responseEntity.failure("用户不存在，请下载小塾学伴家长端APP登录");
+				return 	responseEntity;
+			}
+			//查询小孩信息
+			List<PadPhoneLoginDto> dtoList = new ArrayList<PadPhoneLoginDto>();
+			List<LibVip> viplist = vipService.getByUserId(user.getId());
+			for (LibVip vip : viplist) {
+				PadPhoneLoginDto dto = new PadPhoneLoginDto();
+				dto.setVipId(vip.getId());
+				dto.setUserName(vip.getChildName());
+				dto.setUserId(vip.getChildUserId());
+				dto.setGrade(vip.getGrade());
+				dto.setImgUrl(vip.getImgUrl());
+				dto.setQrCodeImg(vip.getQrcodeUrl());
+				User childUser = userService.getById(vip.getChildUserId());
+				dto.setEasemobName(childUser.getEasemobName());
+				//如果token没有失效则续用,解决一个家长多个小孩在不同pad登录挤掉另一个小孩的情况
+                if(type == 6) {
+                    String accessToken = tokenManager.getToken(childUser.getId(),"IPAD");
+                    if(StringUtils.isBlank(accessToken)) {
+                        accessToken = tokenManager.createToken(CodecUtil.createUUID(),childUser.getId(),365 * 24 * 3600,"IPAD");
+                    }
+                    //清除小塾学伴app端token
+                    String accessTokenApp = tokenManager.getToken(user.getId(),"APP");
+                    tokenManager.removeToken(accessTokenApp,"APP");
+                    dto.setAccessToken(accessToken);
+                }else if(type == 3) {
+                    String accessToken = tokenManager.getToken(childUser.getId(),"APP");
+                    if(StringUtils.isBlank(accessToken)) {
+                        accessToken = tokenManager.createToken(CodecUtil.createUUID(),childUser.getId(),365 * 24 * 3600,"APP");
+                    }
+                    //清除小塾学伴ipad端token
+                    String accessTokenIpad = tokenManager.getToken(user.getId(),"IPAD");
+                    tokenManager.removeToken(accessTokenIpad,"IPAD");
+                    dto.setAccessToken(accessToken);
+                }
+				dtoList.add(dto);
+			}
+			Map<String, Object> data = new HashMap<String, Object>();
+			data.put("list", dtoList);
+			responseEntity.success(data, "成功");
+		} else {
+			responseEntity.failure("验证码不正确，请重新输入");
+		}
+		return responseEntity;
+	}
+
+    @Override
+    public ResponseEntity newPhoneLogin(PadPhoneLoginRequest request) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        //检验验证码是否正确
+        String code = "";
+        //判断是否是测试环境，如果是测试环境则跳过验证码校验
+        String sysEnv = (String) SystemResourceLocator.getValue("SYS_ENV");
+        if("2".equals(sysEnv) || "13767960482".equals(request.getPhone())) {
+            //开发环境
+            code = request.getVerificationCode();
+        }else {
+            code = tokenManager.getString(request.getPhone());
+        }
+        if (StringUtils.isBlank(code)) {
+            responseEntity.failure("该验证码已经失效，请重新获取");
+            return responseEntity;
+        }
+        if (code.equals(request.getVerificationCode())) {
+            //通过手机号查找user表是否用户绑定该手机，如果没有则需要注册一条用户信息
+            User user = userService.findByMobile(request.getPhone());
+            if (user == null) {
+                responseEntity.failure("用户不存在，请下载小塾学伴家长APP登录");
+                return 	responseEntity;
+            }
+            //查询小孩信息
+            List<PadNewPhoneLoginDto> dtoList = new ArrayList<PadNewPhoneLoginDto>();
+            List<LibVip> viplist = vipService.getByUserId(user.getId());
+            for (LibVip vip : viplist) {
+                PadNewPhoneLoginDto dto = new PadNewPhoneLoginDto();
+                dto.setVipId(vip.getId());
+                dto.setUserName(vip.getChildName());
+                if(StringUtils.isBlank(vip.getChildUserId())) {
+					//推送贝壳消息，创建用户
+					User childUserInfo = new User();
+					childUserInfo.setId(IdWorker.generateId());
+					childUserInfo.setName(vip.getChildName());
+					childUserInfo.setUserName(vip.getChildName());
+					if (StringUtils.isNotBlank(vip.getSex())) {
+						childUserInfo.setSex(Integer.valueOf(vip.getSex()));
+					}
+					childUserInfo.setPhoto(getRandomChildImg(vip.getImgUrl()));
+					childUserInfo.setEasemobName(userService.createUniqueEasemobName());
+					//创建小孩环信账号
+					easemobService.createUserSingle(childUserInfo.getEasemobName(), null);
+					//添加和家长端好友关系
+					//添加家长和小孩的好友关系
+					if(StringUtils.isBlank(user.getEasemobName())) {
+						user.setEasemobName(userService.createUniqueEasemobName());
+						//创建家长环信账号
+						easemobService.createUserSingle(user.getEasemobName(), null);
+						userService.save(user);
+					}
+					logger.info("parentUserInfo.getEasemobName()="+user.getEasemobName());
+					logger.info("childUserInfo.getEasemobName()="+childUserInfo.getEasemobName());
+					easemobService.addFriendSingle(user.getEasemobName(), childUserInfo.getEasemobName());
+
+					childUserInfo.setPassword("123456");
+					//需要创建小塾的账号密码
+					childUserInfo.setPwdSalt(PasswordUtil.generateSalt());
+					childUserInfo.setPassword(PasswordUtil.initPassword(childUserInfo.getPassword(), childUserInfo.getPwdSalt()));
+					childUserInfo.setCreateTime(new Date());
+					userService.save(childUserInfo);
+					vip.setChildUserId(childUserInfo.getId());
+					vipService.save(vip);
+				}
+                dto.setUserId(vip.getChildUserId());
+                dto.setGrade(vip.getGrade());
+                dto.setImgUrl(vip.getImgUrl());
+                dtoList.add(dto);
+            }
+            Map<String, Object> data = new HashMap<String, Object>();
+            data.put("list", dtoList);
+            responseEntity.success(data, "成功");
+            tokenManager.clearPasswordWrongRecord(request.getPhone());
+        } else {
+			int wrongCount = tokenManager.recordPasswordWrong(request.getPhone(), "CONCH_PAD");
+			if (wrongCount >= 5) {
+				responseEntity.failure("验证码不正确，您的账号已被锁定，请30分钟后重试");
+			} else if (wrongCount >= 2) {
+				responseEntity.failure(String.format("您再输错%s次账号将会锁定", 5 - wrongCount));
+			} else {
+				responseEntity.failure("验证码不正确，请重新输入");
+			}
+        }
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity getChildInfo(PadVipIdRequest request,int type) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        LibVip vip = vipService.getById(request.getVipId());
+        if (vip == null) {
+            return responseEntity.failure("小孩不存在，请下载小塾学伴家长APP登录添加小孩");
+        }
+        PadPhoneLoginDto dto = new PadPhoneLoginDto();
+        dto.setVipId(vip.getId());
+        dto.setUserName(vip.getChildName());
+        dto.setUserId(vip.getChildUserId());
+        dto.setGrade(vip.getGrade());
+        dto.setImgUrl(vip.getImgUrl());
+        dto.setQrCodeImg(vip.getQrcodeUrl());
+        User childUser = userService.getById(vip.getChildUserId());
+        dto.setEasemobName(childUser.getEasemobName());
+        if (type == 6) {
+			//如果token没有失效则续用,解决一个家长多个小孩在不同pad登录挤掉另一个小孩的情况
+//            String accessToken = tokenManager.getToken(childUser.getId(), "IPAD");
+//            if (StringUtils.isBlank(accessToken)) {
+//                accessToken = tokenManager.createToken(CodecUtil.createUUID(), childUser.getId(), 365 * 24 * 3600, "IPAD");
+//            }
+			String accessToken = tokenManager.createToken(CodecUtil.createUUID(), childUser.getId(), 365 * 24 * 3600, "IPAD");
+            //清除小塾学伴app端token
+            String accessTokenApp = tokenManager.getToken(childUser.getId(), "APP");
+            tokenManager.removeToken(accessTokenApp, "APP");
+            dto.setAccessToken(accessToken);
+        } else if (type == 3) {
+//            String accessToken = tokenManager.getToken(childUser.getId(), "APP");
+//            if (StringUtils.isBlank(accessToken)) {
+//                accessToken = tokenManager.createToken(CodecUtil.createUUID(), childUser.getId(), 365 * 24 * 3600, "APP");
+//            }
+			String accessToken = tokenManager.createToken(CodecUtil.createUUID(), childUser.getId(), 365 * 24 * 3600, "APP");
+            //清除小塾学伴ipad端token
+            String accessTokenIpad = tokenManager.getToken(childUser.getId(), "IPAD");
+            tokenManager.removeToken(accessTokenIpad, "IPAD");
+            dto.setAccessToken(accessToken);
+        }
+        responseEntity.success(dto, "成功");
+        return responseEntity;
+    }
+
+    /**
+	 * 通过小孩userId查询tb_lib_vip表获取相关学生信息
+	 *
+	 * @param userId
+	 * @return
+	 */
+	@Override
+	public ResponseEntity personalCenter(String userId,int type) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		LibVip vip = vipService.findByChildUserId(userId);
+		if(vip == null) {
+			responseEntity.failure("用户不存在，请联系系统管理员");
+			return 	responseEntity;
+		}
+		PadPersonalCenterDto dto = new PadPersonalCenterDto();
+		dto.setUserName(vip.getChildName());
+		dto.setImgUrl(vip.getImgUrl());
+		dto.setGrade(vip.getGrade());
+		dto.setSchool(vip.getSchool());
+		//查询是否接收消息推送
+        SconPadInfo sconPadInfo = sconPadInfoService.findTopByVipIdAndType(vip.getId(),type);
+        if(sconPadInfo == null) {
+            dto.setIsRemind(1);
+        }else {
+            dto.setIsRemind(sconPadInfo.getIsRemind());
+        }
+        //积分
+        dto.setIntegralCount(rankingService.searchIntegralByVipId(vip.getId()));
+		responseEntity.success(dto,"成功");
+		return responseEntity;
+	}
+
+	/**
+	 * 通过小孩userId查询tb_lib_vip表获取相关学生信息,
+	 * 通过小孩userId查询ssj_user_message表查询未读消息总数
+	 * @param userId
+	 * @return
+	 */
+	@Override
+	public ResponseEntity home(String userId) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		LibVip vip = vipService.findByChildUserId(userId);
+		if(vip == null) {
+			responseEntity.failure("用户不存在，请联系系统管理员");
+			return 	responseEntity;
+		}
+		PadHomeDto dto = new PadHomeDto();
+		dto.setUserName(vip.getChildName());
+		dto.setImgUrl(vip.getImgUrl());
+		dto.setGrade(vip.getGrade());
+		//查询聊天未读消息总数
+		int count = userMessageService.countByReceiveUserId(userId);
+		dto.setUnreadSum(count);
+        SconXinge sconXinge = sconXingeService.findByPushUserIdAndPlatformType(vip.getUserId(), 2);
+		if(sconXinge != null) {
+			dto.setEyeCareTime(String.valueOf(sconXinge.getEyeCareTime()));
+		}
+		//查询今天是否签到
+		dto.setWhetherSignIn(integralDetailService.findTodaySignData(vip.getId()));
+		dto.setIsBind(StringUtils.isEmpty(vip.getLibId())?2:1);
+		responseEntity.success(dto,"成功");
+		return responseEntity;
+	}
+
+	@Override
+	public ResponseEntity newHome(String userId) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		LibVip vip = vipService.findByChildUserId(userId);
+		if(vip == null) {
+			responseEntity.failure("用户不存在，请联系系统管理员");
+			return 	responseEntity;
+		}
+		PadNewHomeDto dto = new PadNewHomeDto();
+		dto.setUserName(vip.getChildName());
+		dto.setImgUrl(vip.getImgUrl());
+		dto.setGrade(vip.getGrade());
+		String vipId=vip.getId();
+		//查询聊天未读消息总数
+		int count = userMessageService.countByReceiveUserId(userId);
+		int homeworkSum=homeworkPictureService.countTodayByVipId(vipId);
+		int problemSum=problemPictureService.countProblemSum(vipId);
+		dto.setUnreadSum(count);
+		dto.setHomeworkSum(homeworkSum);
+		dto.setProblemSum(problemSum);
+        SconXinge sconXinge = sconXingeService.findByPushUserIdAndPlatformType(vip.getUserId(), 2);
+        if(sconXinge != null) {
+			dto.setEyeCareTime(String.valueOf(sconXinge.getEyeCareTime()));
+		}
+		//查询今天是否签到
+		dto.setWhetherSignIn(integralDetailService.findTodaySignData(vipId));
+		dto.setIsBind(StringUtils.isEmpty(vip.getLibId())?2:1);
+		responseEntity.success(dto,"成功");
+		return responseEntity;
+	}
+
+    @Override
+    public ResponseEntity setIsRemind(String userId, int isRemind, int type) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        SconPadInfo sconPadInfo = sconPadInfoService.findTopByUserIdAndType(userId,type);
+        if(sconPadInfo != null) {
+            sconPadInfo.setIsRemind(isRemind);
+            sconPadInfoService.save(sconPadInfo);
+        }
+        responseEntity.success();
+        return responseEntity;
+    }
+    /**
+	 * 小塾学伴扫一扫添加好友
+	 * 二维码内容为tb_lib_vip_qrcode_url然后查询tb_lib_vip小孩信息
+	 * @param qrCode
+	 * @return
+	 */
+	@Override
+	public ResponseEntity swipeQrCode(String qrCode) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		//如果是家长端扫作业吧会员卡的二维码
+		if (qrCode.contains("/weixin/libVip/bindingLibVip")) {
+			String vipId = qrCode.substring(qrCode.indexOf("_") + 1, qrCode.indexOf(".html"));
+			LibVip vip = vipService.getById(vipId);
+			if(vip == null) {
+				responseEntity.failure("二维码不存在");
+				return 	responseEntity;
+			}
+			Map<String, Object> data = new HashMap<String, Object>();
+			data.put("friendUserId", vip.getChildUserId());
+			data.put("imgUrl", vip.getImgUrl());
+			data.put("friendUserName", vip.getChildName());
+			responseEntity.success(data, "成功");
+			return responseEntity;
+		}else {
+			responseEntity.failure("二维码不存在");
+			return 	responseEntity;
+		}
+	}
+
+    /**
+     * 查询scon_homework, scon_homework_picture
+     * @param vipId
+     * @param type 1历史记录， 0 今日作业
+     * @return
+     */
+    @Override
+    public List<HomeworkRecordDto> findHomeworkRecord(String vipId, int type) {
+        List<HomeworkRecordDto> result = null;
+        LibVip vip = vipService.getById(vipId);
+        Date now = new Date();
+        if (type > 0){
+            result = conchDerverService.findHistoryHomeworkRecord(vip, DateUtil.addDays(now, -5), DateUtil.addDays(now, -1));
+        } else {
+            result = conchDerverService.findTodayHomeworkRecord(vip, now);
+        }
+        return result;
+    }
+
+	@Override
+	public List<HomeworkRecordDto> findHomeworkRecordByVipId(String vipId) {
+    	LibVip vip = vipService.getById(vipId);
+		return conchDerverService.findHomeworkRecordByVip(vip);
+	}
+
+	@Override
+    public Map<String, Object> startHomework(String vipId, String courseName, Long currentTime) {
+        LibVip vip = vipService.getById(vipId);
+        return conchDerverService.startHomeworkByVipId(vip, courseName, currentTime);
+    }
+
+    @Override
+    public Map<String, Object> endHomework(String vipId, String courseName, Long endTime, Long usedTime) {
+        LibVip vip = vipService.getById(vipId);
+        return  conchDerverService.endHomeworkByVipId(vip, courseName, endTime, usedTime);
+    }
+
+    @Override
+    public Map<String, Object> uploadHomeworkPicture(PadUploadPictureRequest request) throws Exception{
+        LibVip vip = vipService.getById(request.getVipId());
+        return conchDerverService.upload(vip, null, request.getFileKeys(), request.getUploadType(),
+                request.getDerverFileId(), System.currentTimeMillis(), request.getCourseName());
+    }
+
+    @Override
+    public ResponseEntity noNetworkUploadHomeworkPicture(PadUploadHomeworkRequest request) throws Exception {
+        LibVip libVip = vipService.getById(request.getVipId());
+        return conchDerverService.noNetworkUploadHomeworkByVipId(libVip, request.getCourseName(), request.getDerverFileId(), request.getFileKeys(), request.getStartTime(), request.getEndTime());
+    }
+
+	@Override
+	public void deleteHomework(String vipId, String courseName, long usedTime) {
+    	Homework homework = homeworkService.findDateSubjectHomework(vipId, courseName, new Date());
+    	if (homework != null){
+			long count = homeworkPictureService.countByHomeworkId(homework.getId());
+			if(count == 0) {
+				logger.warn("删除了作业计时", homework);
+				homeworkService.delete(homework);
+			}else {
+				//因为计时没有拍照所以去掉无用计时时间
+				long workUsedTime = usedTime%60000 == 0 ? usedTime/60000 : (usedTime/60000)+1;
+				homework.setUsedTime(homework.getUsedTime()-workUsedTime);
+				homeworkService.save(homework);
+			}
+		}
+	}
+
+    @Override
+    public HomeworkFeedbackPadVO homeworkFeedbackDetails(String homeworkId, int type) {
+		List<HomeworkPicture> pictures = homeworkPictureService.findDerverPictureByWorkId(homeworkId);
+		Homework homework = homeworkService.getById(homeworkId);
+		HomeworkFeedbackPadVO homeworkFeedbackPadVO = new HomeworkFeedbackPadVO();
+		if (CollectionUtils.isNotEmpty(pictures) && homework != null){
+			Integer isFeedback = type == 1 ? 1 : type == 0 ? homeworkService.isCorrected(homeworkId) : 0;
+			StringBuilder videoText = new StringBuilder();
+			homeworkFeedbackPadVO.setIsFeedback(isFeedback);
+			homeworkFeedbackPadVO.setHomeworkId(homeworkId);
+			homeworkFeedbackPadVO.setSubject(homework.getSubject());
+
+			//作业简报
+			ZuoybStudentPush studentPush = studentPushDao.findByHomeworkId(homeworkId);
+			if (studentPush == null) {
+				logger.info("查询作业反馈详情时，未查询到作业简报");
+			} else {
+				homeworkFeedbackPadVO.setBrief(studentPush.getSuggest());
+				if (StringUtils.isNotBlank(studentPush.getImg())){
+					String[] imgs = studentPush.getImg().split(",");
+					for (int i = 0; i < imgs.length; i++){
+						BriefHomeworkPictureDto homeworkPictureDto = new BriefHomeworkPictureDto();
+						homeworkPictureDto.setHomeworkPictureId(homeworkId + "_" + i);
+						homeworkPictureDto.setHomeworkPictureUrl(imgs[i]);
+						homeworkPictureDto.setType(5);
+						homeworkFeedbackPadVO.addHomeworkPicture(homeworkPictureDto);
+					}
+				}
+			}
+
+			//作业原图批注列表
+			List<HomeworkPictureCommentPadDTO> homeworkCommentList = new ArrayList<>();
+			pictures.forEach(homeworkPicture -> {
+				//原图
+				if (homeworkPicture.getIsMark() != 4){
+					BriefHomeworkPictureDto homeworkPictureDto = new BriefHomeworkPictureDto();
+					homeworkPictureDto.setHomeworkPictureId(homeworkPicture.getId());
+					homeworkPictureDto.setHomeworkPictureUrl(homeworkPicture.getFileKey());
+					if (homeworkPicture.getIsMark() > 0){
+						homeworkPictureDto.setType(homeworkPicture.getIsMark());
+					} else if (homeworkPicture.getIsFeedback() == 0 && homework.getCorrectTime() != null) {
+						homeworkPictureDto.setType(2);
+					}
+					homeworkFeedbackPadVO.addHomeworkPicture(homeworkPictureDto);
+				}
+
+
+				//标注图片
+				if (StringUtils.isNotBlank(homeworkPicture.getCorrectedPictureUrl())) {
+					HomeworkPictureCommentPadDTO homeworkPictureCommentPadDTO = new HomeworkPictureCommentPadDTO();
+					homeworkPictureCommentPadDTO.setHomeworkCommentUrl(homeworkPicture.getCorrectedPictureUrl());
+					homeworkPictureCommentPadDTO.setIsComposition(homeworkPicture.getIsComposition());
+					if (homeworkPicture.getIsComposition() == 1) {
+                        //有作文，查询作文评语
+                        homeworkPictureCommentPadDTO.setCompositionCommentModuleList(commentTemplateMapperService.getCompositionCommentModuleDTOList(homeworkPicture.getId()));
+					}
+					if(StringUtils.isNotBlank(homeworkPicture.getHomeworkComment())){
+						homeworkPictureCommentPadDTO.setHomeworkComment(homeworkPicture.getHomeworkComment());
+					}
+					homeworkCommentList.add(homeworkPictureCommentPadDTO);
+				}
+			});
+			homeworkFeedbackPadVO.setHomeworkCommentList(homeworkCommentList);
+
+			//错题列表
+			List<KmtHomeworkWrongQuestion> kmtHomeworkWrongQuestionList = kmtHomeworkWrongQuestionService.findByHomeworkId(homework.getId());
+			if (CollectionUtils.isNotEmpty(kmtHomeworkWrongQuestionList)) {
+				List<KmtHomeworkWrongQuestion> wrongQuestionList = kmtHomeworkWrongQuestionList.stream()
+						.filter(it -> Objects.equals(it.getType(), HomeworkWrongQuestionTypeEnum.WrongAnswer.getCode()))
+						.collect(Collectors.toList());
+				if (CollectionUtils.isNotEmpty(wrongQuestionList)) {//有错题
+					//查询出所有错题
+					videoText.append("今日错题");
+					Set<String> wrongQuestionIdSet = wrongQuestionList.stream().map(KmtHomeworkWrongQuestion::getQuestionId).collect(Collectors.toSet());
+					List<KmtExerciseQuestion> kmtExerciseQuestionList = kmtExerciseQuestionService.findByIdIn(new ArrayList<>(wrongQuestionIdSet));
+
+					//错题根据教辅分组
+					Map<String, List<KmtExerciseQuestion>> kmtExerciseQuestionMapGroupByBook = kmtExerciseQuestionList.stream()
+							.collect(groupingBy(KmtExerciseQuestion::getBookId));
+					List<BookHomeworkWrongQuestionPadVO> bookHomeworkWrongQuestionVoList = new ArrayList<>();
+					kmtExerciseQuestionMapGroupByBook.forEach((bookId, questionListGroupByBook) -> {
+						BookHomeworkWrongQuestionPadVO bookHomeworkWrongQuestionPadVO = new BookHomeworkWrongQuestionPadVO();
+						List<WrongQuestionPeriodVO> wrongQuestionPeriodVoList = new ArrayList<>();
+
+						//根据教辅分组后，再根据课时分组
+						Map<String, List<KmtExerciseQuestion>> kmtExerciseQuestionMapGroupByPeriod = questionListGroupByBook.stream()
+								.collect(groupingBy(KmtExerciseQuestion::getBookCourseId));
+						kmtExerciseQuestionMapGroupByPeriod.forEach((periodId, questionListGroupByPeriod) -> {
+							WrongQuestionPeriodVO wrongQuestionPeriodVO = new WrongQuestionPeriodVO();
+
+							//排序
+							questionListGroupByPeriod.sort((o1, o2) -> {
+								Integer num1 = o1.getNum();
+								if (num1 == null) {
+									return -1;
+								}
+								Integer num2 = o2.getNum();
+								if (num2 == null) {
+									return 1;
+								}
+								return num1.compareTo(num2);
+							});
+
+							KmtExerciseBookCourse kmtExerciseBookCourse = kmtExerciseBookCourseService.getById(periodId);
+							bookHomeworkWrongQuestionPadVO.setBookName(kmtExerciseBookCourse.getBookName());
+							videoText.append(kmtExerciseBookCourse.getBookName()).append(" ");
+							videoText.append(kmtExerciseBookCourse.getUnit()).append(" ");
+							wrongQuestionPeriodVO.setUnit(kmtExerciseBookCourse.getUnit());
+							wrongQuestionPeriodVO.setPeriod(kmtExerciseBookCourse.getPeriod());
+							videoText.append(kmtExerciseBookCourse.getPeriod()).append(" ");
+							wrongQuestionPeriodVoList.add(wrongQuestionPeriodVO);
+
+
+							List<ExerciseWrongQuestionVO> questionList = new ArrayList<>();
+							questionListGroupByPeriod.forEach(kmtExerciseQuestion -> {
+								ExerciseWrongQuestionVO exerciseWrongQuestionVO = new ExerciseWrongQuestionVO();
+								exerciseWrongQuestionVO.setBigQuestionIndex(kmtExerciseQuestion.getBigQuestionIndex());
+								videoText.append("第").append(kmtExerciseQuestion.getBigQuestionIndex()).append("大题").append(" ");
+								String smallQuestionName = kmtExerciseQuestion.getSmallQuestionName();
+								if (Objects.equals("(0)", smallQuestionName)) {
+									smallQuestionName = "0";
+								}
+								exerciseWrongQuestionVO.setSmallQuestionIndex(smallQuestionName);
+								if (smallQuestionName.compareTo("0") > 0){
+									videoText.append("第").append(smallQuestionName).append("小题").append(" ");
+								}
+								KmtHomeworkWrongQuestion kmtHomeworkWrongQuestion = wrongQuestionList.stream().filter(it -> Objects.equals(it.getQuestionId(), kmtExerciseQuestion.getId())).findFirst().get();
+								exerciseWrongQuestionVO.setSpaceIndex(kmtHomeworkWrongQuestion.getSpaceIndex());
+								if (StringUtils.isNotBlank(kmtHomeworkWrongQuestion.getSpaceIndex())){
+									videoText.append("第").append(kmtHomeworkWrongQuestion.getSpaceIndex()).append("小空").append(" ");
+								}
+								questionList.add(exerciseWrongQuestionVO);
+							});
+							wrongQuestionPeriodVO.setQuestionList(questionList);
+						});
+						bookHomeworkWrongQuestionPadVO.setWrongQuestionPeriodList(wrongQuestionPeriodVoList);
+						bookHomeworkWrongQuestionPadVO.setWrongQuestionPeriodList(wrongQuestionPeriodVoList);
+						bookHomeworkWrongQuestionVoList.add(bookHomeworkWrongQuestionPadVO);
+					});
+					homeworkFeedbackPadVO.setWrongQuestionList(bookHomeworkWrongQuestionVoList);
+				}
+			}
+
+			//错题知识点
+			List<Map<String, Object>> howDetailsMapList = homeworkQueryDao.findDetailsByHomeworkId(homework.getId());
+			if (CollectionUtils.isNotEmpty(howDetailsMapList)) {
+				List<RelateKnowledgeDto> relateKnowledgeDtoList = new ArrayList<>();
+				howDetailsMapList.forEach(howDetailsMap -> {
+					String module = String.valueOf(howDetailsMap.get("module"));
+					Optional<RelateKnowledgeDto> optional = relateKnowledgeDtoList.stream().filter(it -> Objects.equals(it.getModule(), module)).findFirst();
+					String alias = String.valueOf(howDetailsMap.get("alias"));
+					if (optional.isPresent()) {
+						RelateKnowledgeDto relateKnowledgeDto = optional.get();
+						List<String> details = relateKnowledgeDto.getDetails();
+						if (details.contains(alias)) {
+							return;
+						}
+						details.add(alias);
+					} else {
+						RelateKnowledgeDto relateKnowledgeDto = new RelateKnowledgeDto();
+						relateKnowledgeDto.setModule(module);
+						List<String> tempAliasList = new ArrayList<>();
+						tempAliasList.add(alias);
+						relateKnowledgeDto.setDetails(tempAliasList);
+						relateKnowledgeDtoList.add(relateKnowledgeDto);
+					}
+				});
+				homeworkFeedbackPadVO.setKnowledgeList(relateKnowledgeDtoList);
+			}
+			Set<String> knowHowDetailsAlias = howDetailsMapList.stream().map(it -> String.valueOf(it.get("alias"))).collect(Collectors.toSet());
+			if (CollectionUtils.isNotEmpty(knowHowDetailsAlias)){
+				videoText.append("错题涉及知识点");
+				int i = 1;
+				for (String know : knowHowDetailsAlias){
+					videoText.append(i).append(" ").append(know).append(" ");
+					i++;
+				}
+			}
+			if (homeworkFeedbackPadVO.getIsFeedback()  == 1 && StringUtils.isNotBlank(videoText)){
+				if (videoText.toString().equals(homework.getConchVideoText())){
+					homeworkFeedbackPadVO.setConchVideoPath(homework.getConchVideoPath());
+				} else {
+					logger.info("反馈内容不同，需要重新生成语音,homework={}", homework);
+					try {
+						String videoPath = XunFeiTTSUtils.textToVoice(videoText.toString(), homework.getVipId());
+						homeworkFeedbackPadVO.setConchVideoPath(videoPath);
+						homework.setConchVideoText(videoText.toString());
+						homework.setConchVideoPath(videoPath);
+						homeworkService.save(homework);
+					} catch (Exception e){
+						logger.error("讯飞转语音异常", e);
+					}
+				}
+			}
+		}
+
+		return homeworkFeedbackPadVO;
+    }
+
+    /**
+     * 手机号登录后绑定小孩和设备关系,通过padcode查询scon_pad_info表，然后绑定vip_id,user_id
+     * @param request
+     * @param type 平台类型:(6:小塾学伴pad端  3:小塾学伴学生app端)
+     * @return
+     */
+    @Override
+    public ResponseEntity bindPad(SwipePadLoginReq request, int type) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        SconPadInfo sconPadInfo = sconPadInfoService.findTopByPadCode(request.getPadCode());
+        if(sconPadInfo==null){
+            responseEntity.failure("PAD设备码不存在");
+        }else{
+            LibVip libVip = vipService.getById(request.getVipId());
+            if(libVip==null){
+                responseEntity.failure("不存在该小孩");
+            }else{
+                //清除小孩之前扫描登录的设备信息
+                SconPadInfo oldSconPadInfo =  sconPadInfoService.findTopByVipId(request.getVipId());
+                if(oldSconPadInfo != null) {
+                    oldSconPadInfo.setVipId(null);
+                    oldSconPadInfo.setUserId(null);
+                    sconPadInfoService.save(oldSconPadInfo);
+                }
+                sconPadInfo.setVipId(libVip.getId());
+                sconPadInfo.setUserId(libVip.getChildUserId());
+                sconPadInfo.setType(type);
+                sconPadInfoService.save(sconPadInfo);
+                responseEntity.success("成功");
+            }
+        }
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity getLoginStatus(String padCode, int type) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>();
+        SconPadInfo sconPadInfo = sconPadInfoService.findTopByPadCode(padCode);
+        if(sconPadInfo != null && StringUtils.isNotBlank(sconPadInfo.getUserId())) {
+            if(sconPadInfo.getType() == 6) {
+                String accessToken = tokenManager.getToken(sconPadInfo.getUserId(),"IPAD");
+                data.put("accessToken",accessToken);
+            }else if(sconPadInfo.getType() == 3) {
+                String accessToken = tokenManager.getToken(sconPadInfo.getUserId(),"APP");
+                data.put("accessToken",accessToken);
+            }
+            LibVip libVip = vipService.getById(sconPadInfo.getVipId());
+            User user = userService.getById(libVip.getChildUserId());
+            data.put("vipId", libVip.getId());
+            data.put("userName", libVip.getChildName());
+            data.put("grade", libVip.getGrade());
+            data.put("userId", user.getId());
+            data.put("imgUrl", libVip.getImgUrl());
+            data.put("qrCodeImg", libVip.getQrcodeUrl());
+            data.put("easemobName", user.getEasemobName());
+        }
+        responseEntity.success(data, "成功");
+        return responseEntity;
+    }
+
+    @Override
+	public ResponseEntity findSmartTimeList(String vipId, Pageable pageable){
+    	ResponseEntity responseEntity =new ResponseEntity();
+    	Map<String,Object> params=new HashMap<>();
+    	params.put("LIKE_vipId",vipId);
+    	List<Map<String,Object>> list=new ArrayList<>();
+		Map<String,Object> data=new HashMap<>();
+		Map<String, SearchFilter> filters = SearchFilter.parse(params);
+		Specification<SmarttimePicture> specification = DynamicSpecifications.bySearchFilter(filters.values(), SmarttimePicture.class);
+		Page<SmarttimePicture> page= smarttimeService.findAll(specification,pageable);
+		page.forEach(it->{
+			HashMap<String,Object> hashMap=new HashMap<>();
+			String fileKey=Optional.ofNullable(it.getFileKey()).orElse("");
+			hashMap.put("fileKey",fileKey);
+			list.add(hashMap);
+		});
+		data.put("pages",page.getTotalElements());
+		data.put("pageNo",pageable.getPageNumber());
+		data.put("pageSize",pageable.getPageSize());
+		data.put("list",list);
+    	return responseEntity.success(data,"查看学生相册成功");
+	}
+	@Override
+	public ResponseEntity cancelStudentPadRole(String userId){
+		ResponseEntity responseEntity=new ResponseEntity();
+		//如果该小孩有绑定小塾则解绑该小塾
+		LibVip libVip = vipService.findByChildUserId(userId);
+		ConchDerver conchDerver = conchDerverService.findByDerver(libVip.getId());
+		if(conchDerver != null){
+			if(StringUtils.isNotBlank(conchDerver.getVipId())){
+				logger.info("贝壳开始解绑设备号核对成功");
+				logger.info(JSON.toJSONString(conchDerver));
+				conchDerverService.updateByDerver(conchDerver.getDerver());
+				libVipServiceService.updateVipServiceByVipId(libVip.getId());//服务改为无效
+				//推送解绑消息
+				//推送解绑绑定成功消息给小塾
+				Map<String,Object> map = new HashMap<String,Object>();
+				map.put("type", "BIND");
+				map.put("time", new Date());
+				map.put("data", "{}");
+				String content = JSON.toJSONString(map);
+				sconXingeService.asynPushThreadTask(conchDerver.getDerver(), null, 1,content, PushConstants.PUSH_OTHER);
+				//清除贝壳accessToken
+				String token = tokenManager.getToken(conchDerver.getUserId(),"IPAD");
+				if(token!=null){
+					tokenManager.removeToken(token,"IPAD");
+				}
+				//清除贝壳设备信息缓存
+				tokenManager.delString("DERVER_"+conchDerver.getDerver());
+				//解绑小塾derver设置为空
+				libVip.setDerver(null);
+			}
+		}
+		//如果有作业吧服务则清除绑定馆信息
+		LibVipService service = libVipServiceService.findTopByVipIdAndSpeciesOrderByEndTimeDesc(libVip.getId(), "S003");
+		if(service!=null){
+			service.setLibId("");
+			libVipServiceService.save(service);
+		}
+		//将删除的小孩的未读消息置为已读
+		userMessageService.updateMessageHaveRead(libVip.getUserId(),libVip.getChildUserId());
+		//设置order_user字段为家长userId，如果需要恢复小孩信息时则替换回来
+		libVip.setOrderUser(libVip.getUserId());
+		//设置家长userId为空
+		libVip.setUserId(null);
+		//将图书馆也解绑
+		libVip.setLibId(null);
+		vipService.save(libVip);
+		//清楚unionid相关缓存
+		User user = userService.getById(userId);
+		String unionid = user.getUnionid();
+		tokenManager.batchDel("*" + unionid + "*");
+		//清楚各端token缓存
+		tokenManager.delToken(userId);
+		//解绑关联该小孩的副家长账号
+		parentRoleService.deleteByVipId(libVip.getId());
+		//失效小孩与馆绑定关系(目前只能绑定一个馆)
+		List<TbClassStudent> studentBindList = tbClassStudentService.findByVipId(libVip.getId());
+		studentBindList.stream().forEach(tbLibImStudent -> tbLibImStudent.setStatus(0));
+		tbClassStudentService.save(studentBindList);
+		return responseEntity.success("成功");
+
+	}
+
+	private String getRandomChildImg(String imgUrl) {
+		if(StringUtils.isBlank(imgUrl)) {
+			//随机从4张头像中选择一个
+			int num = new Random().nextInt(4) + 1;
+			return "/childImg/"+num+".png";
+		}
+		return imgUrl;
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/conch/service/impl/ConchSystemDerverServiceImpl.java

@@ -0,0 +1,173 @@
+package com.ssj.service.conch.conch.service.impl;
+
+
+
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.conch.conch.domain.ConchDerver;
+import com.ssj.bean.conch.conch.domain.ConchSystemDerver;
+import com.ssj.dao.conch.conch.dao.ConchSystemDerverDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.idworker.IdWorker;
+import com.ssj.service.conch.conch.request.ConchSystemDerverReq;
+import com.ssj.service.conch.conch.service.ConchDerverService;
+import com.ssj.service.conch.conch.service.ConchSystemDerverService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+@Service(version="1.0")
+@Transactional
+public class ConchSystemDerverServiceImpl extends BaseServiceImpl<ConchSystemDerver, String> implements ConchSystemDerverService {
+    @Autowired
+    private ConchSystemDerverDao dao;
+    @Autowired
+    private ConchDerverService conchDerverService;
+
+    @Autowired
+    private TokenManager tokenManager;
+
+    private String DERVER ="system_";
+
+    @Override
+    public PagingAndSortingRepository<ConchSystemDerver, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public ResponseEntity findByImeiAndSimcardAndSimNumbeer(ConchSystemDerverReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        try {
+            String imei = req.getImei();
+            String simcard = req.getSimcard();
+            String oldDerver = req.getOldDerver();
+            String key=imei+simcard+oldDerver;
+            ConchSystemDerver  conchSystemDerver= tokenManager.get(DERVER+key, ConchSystemDerver.class);
+            if(conchSystemDerver!=null){
+                Map<String, Object> data = new HashMap<String,Object>(4);
+                data.put("derver", conchSystemDerver.getDerver());
+                data.put("oldDerver", conchSystemDerver.getOldDerver());
+                data.put("imei", conchSystemDerver.getImei());
+                data.put("simcard", conchSystemDerver.getSimcard());
+                responseEntity.success(data,"成功");
+                return responseEntity;
+            }
+            Long lo =tokenManager.setnx(key,"1");
+            if(lo==0){
+                Thread.sleep(3000);
+            }
+              conchSystemDerver= tokenManager.get(DERVER+key, ConchSystemDerver.class);
+            if(conchSystemDerver!=null){
+                Map<String, Object> data = new HashMap<String,Object>(4);
+                data.put("derver", conchSystemDerver.getDerver());
+                data.put("oldDerver", conchSystemDerver.getOldDerver());
+                data.put("imei", conchSystemDerver.getImei());
+                data.put("simcard", conchSystemDerver.getSimcard());
+                responseEntity.success(data,"成功");
+                tokenManager.delString(key);
+                return responseEntity;
+            }
+
+
+
+            Date date =new Date();
+            if(imei.startsWith("353")){
+                conchSystemDerver= dao.findByOldDerver(oldDerver);
+                if(conchSystemDerver ==null){
+                    conchSystemDerver = dao.findBySimcard(simcard);
+                    if(conchSystemDerver==null){
+                        ConchDerver conchDerver = conchDerverService.findByDerver(oldDerver);
+                        String derver ="";
+                        if(conchDerver ==null ){
+                            //系统生成，唯一，支持高并发
+
+                            derver = IdWorker.generateId();
+                        }else{
+                            derver = conchDerver.getDerver();
+                        }
+                        conchSystemDerver = new  ConchSystemDerver(derver, oldDerver,  simcard, imei);
+                    }
+                }
+
+                conchSystemDerver.setCreatedDate(date);
+                conchSystemDerver.setUpdatedDate(date);
+                conchSystemDerver.setNum(conchSystemDerver.getNum()+1);
+                this.save(conchSystemDerver);
+            }else if(imei.startsWith("867")){
+                conchSystemDerver= dao.findByOldDerver(oldDerver);
+                if(conchSystemDerver==null){
+                    //通过imei 去查询 有重复imei
+                    List<ConchSystemDerver>  list =  dao.findByImei(imei);
+
+
+                    if(list !=null && list.size()>0){
+                        int size =list.size();
+                        if(size>1){
+                            for (ConchSystemDerver conchSystem : list  ) {
+                                if(simcard.equals(conchSystem.getSimcard())){
+                                    conchSystemDerver =conchSystem;
+                                    break;
+                                }
+                            }
+                            if(conchSystemDerver==null){ conchSystemDerver =list.get(0);}
+
+                        }else{
+                            conchSystemDerver =list.get(0);
+                        }
+                        if("400-800-5430".equals(conchSystemDerver.getSimcard())){
+                            conchSystemDerver.setSimcard(simcard);
+                        }
+
+                    }else{
+
+                        ConchDerver conchDerver = conchDerverService.findByDerver(oldDerver);
+                        String derver ="";
+                        if(conchDerver ==null ){
+                            derver = IdWorker.generateId();
+                        }else{
+                            derver = conchDerver.getDerver();
+                        }
+                        conchSystemDerver = new  ConchSystemDerver(derver, oldDerver,  simcard, imei);
+                    }
+                }
+                conchSystemDerver.setCreatedDate(date);
+                conchSystemDerver.setUpdatedDate(date);
+                conchSystemDerver.setNum(conchSystemDerver.getNum()+1);
+                this.save(conchSystemDerver);
+            }else{
+                conchSystemDerver = dao.findByImeiAndSimcard(imei,simcard);
+                if(conchSystemDerver==null){
+                    conchSystemDerver = new  ConchSystemDerver( IdWorker.generateId(), oldDerver,  simcard, imei);
+                }
+                conchSystemDerver.setCreatedDate(date);
+                conchSystemDerver.setUpdatedDate(date);
+                conchSystemDerver.setNum(conchSystemDerver.getNum()+1);
+                this.save(conchSystemDerver);
+            }
+            tokenManager.delString(key);
+            tokenManager.set(DERVER+key, conchSystemDerver,3600);
+
+            Map<String, Object> data = new HashMap<String,Object>(4);
+            data.put("derver", conchSystemDerver.getDerver());
+            data.put("oldDerver", conchSystemDerver.getOldDerver());
+            data.put("imei", conchSystemDerver.getImei());
+            data.put("simcard", conchSystemDerver.getSimcard());
+
+            responseEntity.success(data,"成功");
+        }catch (Exception e){
+            e.printStackTrace();
+        }
+
+        return responseEntity;
+    }
+
+    public static void main(String[] args) {
+        String imei ="867983040020728";
+        System.out.println(imei.startsWith("867"));
+        System.out.println(imei.startsWith("353"));
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/conch/service/impl/HomeworkRankingServiceImpl.java

@@ -0,0 +1,333 @@
+package com.ssj.service.conch.conch.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.conch.conch.domain.HomeworkRanking;
+import com.ssj.bean.conch.conch.domain.IntegralDetail;
+import com.ssj.bean.kmt.kmt.domain.KmtHomeworkWrongQuestion;
+import com.ssj.bean.sys.homework.domain.Homework;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.dao.conch.conch.dao.HomeworkRankingDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.framework.core.util.Constant;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.service.conch.conch.dto.HomeworkRankingDto;
+import com.ssj.service.conch.conch.dto.RankDTO;
+import com.ssj.service.conch.conch.service.HomeworkRankingService;
+import com.ssj.service.conch.conch.service.IntegralDetailService;
+import com.ssj.service.kmt.service.KmtHomeworkWrongQuestionService;
+import com.ssj.service.mapper.HomeworkMapper;
+import com.ssj.service.sys.homework.service.HomeworkService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageRequest;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.time.LocalDate;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+/**
+ * @author yrf
+ * @date 2019/4/26 10:59
+ */
+@Service(version = "1.0")
+@Transactional
+public class HomeworkRankingServiceImpl extends BaseServiceImpl<HomeworkRanking, String> implements HomeworkRankingService {
+
+    @Autowired
+    private HomeworkRankingDao homeworkRankingDao;
+    @Autowired
+    private HomeworkMapper homeworkMapper;
+
+    @Autowired
+    private HomeworkService homeworkService;
+    @Autowired
+    private KmtHomeworkWrongQuestionService kmtHomeworkWrongQuestionService;
+    @Autowired
+    private TokenManager tokenManager;
+    @Autowired
+    private IntegralDetailService integralDetailService;
+    @Autowired
+    private ILibVipService vipService;
+
+    @Override
+    public PagingAndSortingRepository<HomeworkRanking, String> getDao() {
+        return homeworkRankingDao;
+    }
+
+    @Override
+    public int computeAndSaveIntegralByHomeworkUseTime(String vipId, String homeworkId, Long usedTime,String subject) {
+        if (usedTime == null) {
+            //未计时
+            return 0;
+        }
+        //小于5分钟或大于等于50分钟记0分
+        int integral = 0;
+        if (5 < usedTime && usedTime <= 50) {
+            if (usedTime <= 20) {
+                integral = 3;
+            } else if (usedTime <= 30) {
+                integral = 2;
+            } else {
+                integral = 1;
+            }
+        }
+        return this.saveRankIntegral(vipId, integral,1,subject);
+    }
+
+    @Override
+    public void computeAndSaveIntegralByHomeworkCorrectRate(String vipId, double homeworkCorrectRate, String subject) {
+        int integral = 0;
+        if (homeworkCorrectRate >= 0.9) {
+            integral = 5;
+        } else if (homeworkCorrectRate >= 0.8) {
+            integral = 3;
+        } else if (homeworkCorrectRate >= 0.7) {
+            integral = 2;
+        } else if (homeworkCorrectRate >= 0.5) {
+            integral = 1;
+        }
+
+        if (integral > 0) {
+            this.saveRankIntegral(vipId, integral, 2, subject);
+        }
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public RankDTO findByDerver(String derver) {
+        if (StringUtils.isBlank(derver)) {
+            return null;
+        }
+
+        List<Object []> tempResult = homeworkRankingDao.findByDerver(derver);
+        if (tempResult.size() > 0) {
+            RankDTO rankDTO = new RankDTO();
+            rankDTO.setUserName(String.valueOf(tempResult.get(0)[0]));
+            rankDTO.setImgUrl(String.valueOf(tempResult.get(0)[1]));
+            rankDTO.setRankingNum((Integer) tempResult.get(0)[2]);
+            rankDTO.setIndex(Double.valueOf(tempResult.get(0)[3].toString()).intValue());
+            rankDTO.setDerver(String.valueOf(tempResult.get(0)[4]));
+            rankDTO.setVipId(String.valueOf(tempResult.get(0)[5]));
+            return rankDTO;
+        }
+
+        return null;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public List<RankDTO> findPrevious50() {
+        List<Object[]> tempResult = homeworkRankingDao.findPrevious50();
+        List<RankDTO> rankDTOList = new LinkedList<>();
+        tempResult.forEach(it -> {
+            RankDTO rankDTO = new RankDTO();
+            rankDTO.setUserName(String.valueOf(it[0]));
+            rankDTO.setImgUrl(String.valueOf(it[1]));
+            rankDTO.setRankingNum((Integer) Optional.ofNullable(it[2]).orElse(0));
+            rankDTO.setIndex(Double.valueOf(it[3].toString()).intValue());
+            rankDTO.setDerver(String.valueOf(it[4]));
+            rankDTO.setVipId(String.valueOf(it[5]));
+            rankDTOList.add(rankDTO);
+        });
+        return rankDTOList;
+    }
+
+    @Override
+    public int computeCorrectionIntegral() {
+        int pageNo = 1;
+        int pageSize = 500;
+        int [] count = {0};
+        boolean hasNextPage = true;
+
+        LocalDate yesterday = LocalDate.now().minusDays(1);
+        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd");
+        String beginTimeStr = formatter.format(yesterday) + " 00:00:00";
+        String endTimeStr = formatter.format(yesterday) + " 23:59:59";
+
+        int totalQuestionCount;
+        int rightQuestionCount = 0;
+        double correctRate;
+        do {
+            // 查询前一天所有的作业计时记录，为每个学生计算小塾积分
+            Page<Homework> page = homeworkService.findByCreateTimeBetween(beginTimeStr, endTimeStr, new PageRequest(pageNo - 1, pageSize));
+            List<Homework> homeworkList = page.getContent();
+            if (CollectionUtils.isNotEmpty(homeworkList)) {
+                for (Homework homework : homeworkList) {
+                    // 查询练习册所有题目（包括错题和做对的题目），获取题目id
+                    List<KmtHomeworkWrongQuestion> kmtHomeworkQuestionList = kmtHomeworkWrongQuestionService.findByHomeworkId(homework.getId());
+                    totalQuestionCount = kmtHomeworkQuestionList.size();
+
+                    if (totalQuestionCount > 0) {
+                        for (KmtHomeworkWrongQuestion kmtHomeworkWrongQuestion : kmtHomeworkQuestionList) {
+                            if (Objects.equals(2, kmtHomeworkWrongQuestion.getType())) {
+                                rightQuestionCount ++;
+                            }
+                        }
+
+                        correctRate = rightQuestionCount * 1.0 / totalQuestionCount;
+
+                        // 计算对应学生小塾积分
+                        this.computeAndSaveIntegralByHomeworkCorrectRate(homework.getVipId(), correctRate, homework.getSubject());
+                        count[0] ++;
+                    }
+
+                    rightQuestionCount = 0;
+                }
+            }
+
+            if (pageNo >= page.getTotalPages()) {
+                //已没有下一页
+                hasNextPage = false;
+            } else {
+                pageNo ++;
+            }
+        } while (hasNextPage);
+
+        return count[0];
+    }
+
+    @Override
+    public RankDTO findByVipId(String vipId) {
+        return homeworkMapper.findByVipId(vipId);
+    }
+
+    @Override
+    public ResponseEntity findHomeworkRankingByVipId(String vipId) {
+        RankDTO ownRank = this.findByVipId(vipId);
+
+        return this.getRankingList(ownRank);
+    }
+
+    @Override
+    public ResponseEntity findHomeworkRankingByDerver(String derver) {
+        RankDTO ownRank = this.findByDerver(derver);
+
+        return this.getRankingList(ownRank);
+    }
+
+    private ResponseEntity getRankingList(RankDTO ownRank) {
+        //如果自己在50名以内，则更新列表中自己的数据
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        List<RankDTO> rankDTOList = tokenManager.getList(Constant.PREVIOUS50_HOMEWORK_RANK, RankDTO.class);
+        if (CollectionUtils.isEmpty(rankDTOList)) {
+            rankDTOList = this.findPrevious50();
+            tokenManager.set(Constant.PREVIOUS50_HOMEWORK_RANK, rankDTOList);
+        }
+        boolean needSort = false;
+        boolean inTheList = false;
+        if (ownRank != null) {
+            for (RankDTO rankDTO : rankDTOList) {
+                if (Objects.equals(rankDTO.getVipId(), ownRank.getVipId())) {
+                    inTheList = true;
+
+                    if (!Objects.equals(ownRank.getRankingNum(), rankDTO.getRankingNum())) {
+                        rankDTO.setRankingNum(ownRank.getRankingNum());
+                        needSort = true;
+                        break;
+                    }
+                }
+            }
+        }
+        if (ownRank != null && !inTheList) {
+            RankDTO lastOne = rankDTOList.get(rankDTOList.size() - 1);
+            if (ownRank.getRankingNum() > lastOne.getRankingNum()) {
+                rankDTOList.remove(lastOne);
+                rankDTOList.add(ownRank);
+                needSort = true;
+            }
+        }
+        if (needSort) {
+            rankDTOList.sort(Comparator.comparingInt(RankDTO::getRankingNum).reversed());
+        }
+
+        Map<String, Object> resultMap = new HashMap<>();
+
+        HomeworkRankingDto dto = null;
+        if (ownRank != null) {
+            dto = new HomeworkRankingDto();
+            dto.setUserName(ownRank.getUserName());
+            dto.setImgUrl(ownRank.getImgUrl());
+            dto.setRankingNum(ownRank.getRankingNum());
+            dto.setIndex(ownRank.getIndex());
+        }
+
+        List<HomeworkRankingDto> dtoList = new ArrayList<>();
+        for (RankDTO rankDTO : rankDTOList) {
+            HomeworkRankingDto dto1 = new HomeworkRankingDto();
+            dto1.setUserName(rankDTO.getUserName());
+            dto1.setImgUrl(rankDTO.getImgUrl());
+            dto1.setRankingNum(rankDTO.getRankingNum());
+            dto1.setIndex(rankDTO.getIndex());
+            dtoList.add(dto1);
+        }
+        resultMap.put("ownRank", dto);
+        resultMap.put("rankList", dtoList);
+        responseEntity.success(resultMap, "查询成功");
+        return responseEntity;
+    }
+
+    @Override
+    public int saveRankIntegral(String vipId, int integral,int operType,String details) {
+        LibVip vip =vipService.getById(vipId);
+        //没绑定校区的不加积分
+        if(vip==null){
+            return 0;
+        }
+        //积分夺宝跟兑换以及积分失效 不用限制是否绑定校区
+        if(operType<9 || operType>11){
+            if(StringUtils.isEmpty(vip.getLibId())){
+                return 0;
+            }
+        }
+        HomeworkRanking homeworkRanking = homeworkRankingDao.findByVipId(vipId);
+        if (homeworkRanking == null) {
+            homeworkRanking = new HomeworkRanking();
+            homeworkRanking.setVipId(vipId);
+            homeworkRanking.setRankingNum(integral);
+            Date now = new Date();
+            homeworkRanking.setUpdateTime(now);
+            homeworkRanking.setCreateTime(now);
+        } else {
+            if (integral == 0) {
+                return 0;
+            }
+
+            Integer currentRankingNum = homeworkRanking.getRankingNum();
+            if (currentRankingNum == null) {
+                currentRankingNum = 0;
+            }
+            homeworkRanking.setRankingNum(currentRankingNum + integral);
+            homeworkRanking.setUpdateTime(new Date());
+        }
+        homeworkRankingDao.save(homeworkRanking);
+
+        //记录明细
+        if (integral == 0) {
+            return 0;
+        }
+        IntegralDetail integralDetail = new IntegralDetail(operType,details);
+        integralDetail.setVipId(vipId);
+        integralDetail.setCreateTime(new Date());
+        integralDetail.setIntegral(Math.abs(integral));
+        integralDetailService.save(integralDetail);
+        return integral;
+    }
+
+    @Override
+    public int searchIntegralByVipId(String vipId) {
+        HomeworkRanking ranking = homeworkRankingDao.findByVipId(vipId);
+        if(ranking==null){
+            return 0;
+        }
+       return  ranking.getRankingNum();
+    }
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/conch/service/impl/IntegralDetailServiceImpl.java

@@ -0,0 +1,196 @@
+package com.ssj.service.conch.conch.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.alibaba.fastjson.JSON;
+import com.alibaba.fastjson.JSONObject;
+import com.ssj.bean.award.dto.VipIntegralDto;
+import com.ssj.bean.conch.conch.domain.IntegralDetail;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.dao.conch.conch.dao.IntegralDetailDao;
+import com.ssj.dao.sys.award.dao.AwardQueryDao;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.framework.core.util.RedisUtil;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.weixin.util.Collections3;
+import com.ssj.service.conch.conch.service.HomeworkRankingService;
+import com.ssj.service.conch.conch.service.IntegralDetailService;
+import com.ssj.service.conch.conch.vo.SignVO;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+/**
+ * @author sh
+ * @className IntegralDetailServiceImpl
+ * @description 积分明细
+ * @date 2020/6/2
+ */
+@Service(version = "1.0")
+@Transactional
+public class IntegralDetailServiceImpl extends BaseServiceImpl<IntegralDetail,String> implements IntegralDetailService {
+
+    @Autowired
+    private IntegralDetailDao dao;
+
+    @Autowired
+    private TokenManager tokenManager;
+    @Autowired
+    private HomeworkRankingService rankingService;
+    @Autowired
+    private AwardQueryDao queryDao;
+    @Autowired
+    private RedisUtil redisUtil;
+    @Autowired
+    private ILibVipService vipService;
+
+
+    @Override
+    public PagingAndSortingRepository<IntegralDetail, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public int findTodaySignData(String vipId) {
+        int count = dao.findTodaySignData(vipId);
+        return count==0?2:1;
+    }
+
+    @Override
+    public ResponseEntity signToday(String vipId) throws Exception{
+        ResponseEntity responseEntity = new ResponseEntity();
+        //查询今天是否有签到
+        //没签到，进行签到操作
+        //查询连续签到天数
+        String signData = tokenManager.getString("sign_"+vipId);
+        int continueDays = 1;
+        String today = DateHelper.getUserDate("yyyy-MM-dd");
+        Boolean isSign = false;
+        if(StringUtils.isEmpty(signData)){
+            SignVO vo = new SignVO(today,1);
+            tokenManager.set("sign_"+vipId,vo);
+            isSign = true;
+        }else{
+            JSONObject json = JSONObject.parseObject(signData);
+            SignVO vo = JSON.toJavaObject(json,SignVO.class);
+            String signDate = vo.getSignDate();
+            int signDays = vo.getDays();
+            int days = DateHelper.daysOfTwo(DateHelper.parseDate(signDate,"yyyy-MM-dd"),new Date());
+            //今天已经签到
+            if(days == 0){
+                continueDays = signDays;
+            }else{
+                if(days==1){
+                    if(signDays>29){
+                        continueDays = signDays%30 +1;
+                    }else{
+                        continueDays = signDays+1;
+                    }
+                }
+                isSign = true;
+                SignVO vo2 = new SignVO(today,continueDays);
+                tokenManager.set("sign_"+vipId,vo2);
+            }
+        }
+        if(isSign){
+            rankingService.saveRankIntegral(vipId,getIntegral(continueDays),3,"");
+        }
+
+        Map<String,Object> data = new HashMap<>();
+        data.put("signDays",continueDays);
+        data.put("list",initSignData(continueDays));
+        return responseEntity.success(data,"累计打卡"+continueDays+"天，积分+"+getIntegral(continueDays));
+    }
+
+    @Override
+    public int findThisWeekShare(String vipId, String beginTime,String subject) {
+        return dao.findThisWeekShare(vipId,beginTime,subject);
+    }
+
+    @Override
+    public int findThisMonthShare(String vipId, String month) {
+
+        return dao.findThisMonthShare(vipId, month);
+    }
+    @Override
+    public int findPrizeShare(String vipId, String detailCategory) {
+        return dao.findPrizeShare(vipId,detailCategory);
+    }
+
+    @Override
+    public Page<VipIntegralDto> userIntegralList(Map<String, Object> params, Pageable pageable) {
+        return queryDao.userIntegralList(params,pageable);
+    }
+
+    @Override
+    public int clearTowMonthIntegral() {
+        Set<String> strings =  redisUtil.keys("invalid_*");
+        if(Collections3.isNotEmpty(strings)){
+            for(String str:strings){
+                String vipId = str.replace("invalid_","");
+                //查询vip是否有绑定校区
+                LibVip vip = vipService.getById(vipId);
+                if(vip==null){
+                    continue;
+                }
+                //有绑定校区则不处理，删除key
+                if(StringUtils.isNotEmpty(vip.getLibId())){
+                    tokenManager.delString(str);
+                    continue;
+                }
+                //无绑定校区且超达到或超过60天则清0
+                String invalidValue = tokenManager.getString(str);
+                if(towMillisDays(invalidValue)>=60){
+                    int total = rankingService.searchIntegralByVipId(vipId);
+                    rankingService.saveRankIntegral(vipId,-total,11,"");
+                }
+            }
+        }
+        return 0;
+    }
+
+    private int towMillisDays(String minMillis){
+        int days = Integer.parseInt(minMillis) - (int)System.currentTimeMillis() / (1000*3600*24);
+        return days;
+
+    }
+
+    private int getIntegral(int continueDays){
+
+        if(continueDays%7==0){
+            return 5;
+        }
+        if(continueDays%30==0){
+            return 15;
+        }
+        return 1;
+    }
+
+    private List<Map<String,Integer>> initSignData(int continueDays){
+        List<Map<String,Integer>> list = new ArrayList<>();
+        int count = 31;
+        for (int i = 1; i < count; i++) {
+            Map<String,Integer> map = new HashMap<>(2);
+            map.put("whetherSignIn",2);
+            map.put("integral",1);
+            if(i<=continueDays){
+                map.put("whetherSignIn",1);
+            }
+            if(i%7==0){
+                map.put("integral",5);
+            }
+            if(i%30==0){
+                map.put("integral",15);
+            }
+            list.add(map);
+        }
+        return list;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/conch/service/impl/SconOtaManagerServiceImpl.java

@@ -0,0 +1,111 @@
+package com.ssj.service.conch.conch.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.conch.conch.domain.SconOtaManager;
+import com.ssj.dao.conch.conch.dao.SconOtaManagerDao;
+import com.ssj.framework.basic.config.bean.Config;
+import com.ssj.framework.basic.config.dao.ConfigDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.persistence.DynamicSpecifications;
+import com.ssj.framework.core.persistence.SearchFilter;
+import com.ssj.framework.core.util.ResponseConstant;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.core.util.SystemResourceLocator;
+import com.ssj.service.conch.conch.request.AddOtaVersionReq;
+import com.ssj.service.conch.conch.request.AddSconOtaManagerRequest;
+import com.ssj.service.conch.conch.request.OtaVersionReq;
+import com.ssj.service.conch.conch.request.UpdateSconOtaManagerRequest;
+import com.ssj.service.conch.conch.service.SconOtaManagerService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author yangcan
+ * 类描述: ota系统管理
+ * 创建时间:2019/6/28 13:23
+ */
+@Service(version="1.0")
+@Transactional
+public class SconOtaManagerServiceImpl extends BaseServiceImpl<SconOtaManager, String> implements SconOtaManagerService {
+
+	private   Logger logger = LoggerFactory.getLogger(this.getClass());
+
+	@Autowired
+	private SconOtaManagerDao sconOtaManagerDao;
+
+	@Override
+	public PagingAndSortingRepository<SconOtaManager, String> getDao() {
+		return sconOtaManagerDao;
+	}
+
+	@Override
+	public SconOtaManager findByCurrentVersion(String currentVersion) {
+		return sconOtaManagerDao.findByCurrentVersion(currentVersion);
+	}
+
+	@Override
+	public ResponseEntity getOtaVersion(OtaVersionReq request) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		//查询ota版本信息
+		SconOtaManager sconOtaManager = sconOtaManagerDao.findByCurrentVersion(request.getCurrentVersion());
+		if(sconOtaManager == null) {
+			responseEntity.failure("未查询到需要升级的ota版本信息");
+			return responseEntity;
+		}
+		Map<String, Object> resultMap = new HashMap<>();
+		resultMap.put("updatePackName", sconOtaManager.getUpdatePackName());
+		resultMap.put("currentVersion", sconOtaManager.getCurrentVersion());
+		resultMap.put("updateVersion", sconOtaManager.getUpdateVersion());
+		String sysEnv = (String) SystemResourceLocator.getValue("SYS_ENV");
+		if("1".equals(sysEnv)) {
+			//正式环境
+			resultMap.put("fileKey","https://img.sharingschool.com"+sconOtaManager.getFileKey());
+		}else {
+			//测试环境
+			resultMap.put("fileKey","https://xt.sharingschool.com/upload"+sconOtaManager.getFileKey());
+		}
+		resultMap.put("content", sconOtaManager.getContent());
+		resultMap.put("isTest", sconOtaManager.getIsTest());
+		resultMap.put("testImei", sconOtaManager.getTestImei());
+		resultMap.put("isUsing", sconOtaManager.getIsUsing());
+		resultMap.put("createTime", sconOtaManager.getCreateTime());
+		resultMap.put("packName",sconOtaManager.getFileKey().substring(14));
+		resultMap.put("md5",sconOtaManager.getMd5());
+		String testImei = sconOtaManager.getTestImei();
+		int isTest=sconOtaManager.getIsTest();
+		if(1==isTest){
+			if(!this.isContains(testImei,request.getImei())){
+				responseEntity.failure("imei号错误");
+				return  responseEntity;
+			}
+		}
+		responseEntity.success(resultMap, "成功");
+		return responseEntity;
+	}
+
+	@Override
+	public Page<SconOtaManager> findByPage(Map<String, Object> params, Pageable sp) {
+		Map<String, SearchFilter> filters = SearchFilter.parse(params);
+		Specification<SconOtaManager> specification = DynamicSpecifications.bySearchFilter(filters.values(), SconOtaManager.class);
+		return sconOtaManagerDao.findAll(specification,sp);
+	}
+
+	private boolean isContains(String str,String str1){
+		String  sr[] =str.split(",");
+		List<String>list=Arrays.asList(sr).stream().filter(string->!string.isEmpty()).collect(Collectors.toList());
+		if(list.contains(str1)){
+			return true;
+		}else {
+			return false;
+		}
+	}
+}

ssj-sys/src/main/java/com/ssj/service/conch/conch/service/impl/SconPadInfoServiceImpl.java

@@ -0,0 +1,92 @@
+package com.ssj.service.conch.conch.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.conch.conch.domain.SconPadInfo;
+import com.ssj.bean.sys.push.domain.SconXinge;
+import com.ssj.conch.push.util.PushConstants;
+import com.ssj.dao.conch.conch.dao.SconPadInfoDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.service.conch.conch.padrequest.PadInitInfoRequest;
+import com.ssj.service.conch.conch.service.SconPadInfoService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Date;
+import java.util.List;
+
+/**
+ * @author yangcan
+ * 类描述:小塾学伴pad 服务实现
+ * 创建时间:2019/11/7 10:32
+ */
+@Service(version="1.0")
+@Transactional
+public class SconPadInfoServiceImpl extends BaseServiceImpl<SconPadInfo, String> implements SconPadInfoService {
+	
+	protected Logger	logger   = LoggerFactory.getLogger(this.getClass());
+	
+	@Autowired
+    private TokenManager tokenManager;
+	@Autowired
+    private SconPadInfoDao sconPadInfoDao;
+
+	@Override
+	public PagingAndSortingRepository<SconPadInfo, String> getDao() {
+		return sconPadInfoDao;
+	}
+
+	/**
+	 * 初始化上传信鸽token信息,插入scon_pad_info表
+	 * @param request
+	 */
+	@Override
+	public void initInfo(PadInitInfoRequest request, int type) {
+        //初始化上传信鸽token信息
+        SconPadInfo sconPadInfo = sconPadInfoDao.findTopByPadCodeAndPlatform(request.getPadCode(),request.getPlatform());
+        if(sconPadInfo == null) {
+            //新增初始化上传信鸽token信息
+            sconPadInfo = new SconPadInfo();
+        }
+        sconPadInfo.setPadCode(request.getPadCode());
+        sconPadInfo.setPlatform(request.getPlatform());
+        sconPadInfo.setXingeToken(request.getXingeToken());
+        sconPadInfo.setType(type);
+        sconPadInfo.setCreateTime(new Date());
+        this.save(sconPadInfo);
+	}
+
+	@Override
+	public List<SconPadInfo> findByVipId(String vipId) {
+		return sconPadInfoDao.findByVipId(vipId);
+	}
+
+	@Override
+	public SconPadInfo findTopByVipId(String vipId) {
+		return sconPadInfoDao.findTopByVipId(vipId);
+	}
+
+    @Override
+    public SconPadInfo findTopByVipIdAndType(String vipId, int type) {
+        return sconPadInfoDao.findTopByVipIdAndType(vipId,type);
+    }
+
+    @Override
+    public SconPadInfo findTopByUserIdAndType(String userId, int type) {
+        return sconPadInfoDao.findTopByUserIdAndType(userId,type);
+    }
+
+    @Override
+	public List<SconPadInfo> findByUserId(String userId) {
+		return sconPadInfoDao.findByUserId(userId);
+	}
+
+	@Override
+	public SconPadInfo findTopByPadCode(String padCode) {
+		return sconPadInfoDao.findTopByPadCode(padCode);
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/curator/service/impl/v1/TbLibBindAuditServiceImpl.java

@@ -0,0 +1,40 @@
+package com.ssj.service.conch.curator.service.impl.v1;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.curator.TbLibBindAudit;
+import com.ssj.dao.conch.curator.dao.TbLibBindAuditDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.conch.curator.service.v1.TbLibBindAuditService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Service(version = "1.0")
+@Transactional
+public class TbLibBindAuditServiceImpl extends BaseServiceImpl<TbLibBindAudit, String> implements TbLibBindAuditService {
+
+    @Autowired
+    private TbLibBindAuditDao dao;
+
+    @Override
+    public PagingAndSortingRepository<TbLibBindAudit, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public TbLibBindAudit findByVipIdAndStatusNot(String vipId, int status) {
+        return dao.findByVipIdAndStatusNot(vipId,status);
+    }
+
+    @Override
+    public TbLibBindAudit findByVipIdAndStatus(String vipId, int status) {
+        return dao.findByVipIdAndStatus(vipId,status);
+    }
+
+    @Override
+    public List<TbLibBindAudit> findByLibIdAndStatus(String libId, int status) {
+        return dao.findByLibIdAndStatus(libId,status);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/curator/service/impl/v1/VacationLimitServiceImpl.java

@@ -0,0 +1,174 @@
+package com.ssj.service.conch.curator.service.impl.v1;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.curator.TbVacationLimit;
+import com.ssj.dao.conch.curator.dao.IVacationLimitDao;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.service.conch.curator.service.v1.IVacationLimitService;
+import com.ssj.service.conch.parents.v1.dto.VacationDto;
+import com.ssj.service.conch.parents.v1.request.VacationSaveReq;
+import com.ssj.service.weixin.sales.service.LibVipServiceService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+@Service(version = "1.0")
+@Transactional
+public class VacationLimitServiceImpl extends BaseServiceImpl<TbVacationLimit, String> implements IVacationLimitService {
+
+    @Autowired
+    private IVacationLimitDao dao;
+
+    @Autowired
+    private LibVipServiceService vipServiceService;
+
+    @Override
+    public PagingAndSortingRepository<TbVacationLimit, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public List<TbVacationLimit> findValidVocationLimit(Date beginTime, Date endTime, String libId) {
+        return dao.findValidVocationLimit(beginTime, endTime, libId);
+    }
+
+    @Override
+    public ResponseEntity vacationList(String libId, int type) {
+        Map<String,Object> data = new HashMap<>();
+        String year = DateHelper.getNextYear(type);
+        List<TbVacationLimit> list = dao.findLibVacationData(libId,year);
+        if(list.isEmpty()){
+            //初始化数据
+            list = new ArrayList<>();
+            for(int i=1;i<5;i++){
+                TbVacationLimit vacation = new TbVacationLimit();
+                vacation.setLibId(libId);
+                vacation.setType(i);
+                vacation.setLimitYear(year);
+                vacation.setLimitMsg(i==1?"开始时间不能超过1月2月":i==2?"日期不超过7天,开始时间不能超过4月、5月":i==3?"开始时间不能超过7月、8月":"日期不超过7天，开始时间不能超过9月、10月");
+                vacation.setSetState(1);
+                vacation = this.save(vacation);
+                list.add(vacation);
+            }
+        }
+        List<VacationDto> dtoList = new ArrayList<>();
+        list.forEach(t->{
+            VacationDto dto = new VacationDto();
+            BeanUtils.copyProperties(t,dto);
+            Date now = new Date();
+            if(t.getStartDate()==null){
+                dto.setIsEffect(2);
+                dto.setStartDate("");
+                dto.setEndDate("");
+            }else{
+                if(DateHelper.compareTwoDate(t.getStartDate(),now) || (DateHelper.compareTwoDate(t.getEndDate(),now) && DateHelper.compareTwoDate(now,t.getEndDate()) )){
+                    dto.setIsEffect(1);
+                }else {
+                    dto.setIsEffect(2);
+                }
+                dto.setStartDate(DateHelper.format(t.getStartDate(),"yyyy-MM-dd"));
+                dto.setEndDate(DateHelper.format(t.getEndDate(),"yyyy-MM-dd"));
+            }
+            dtoList.add(dto);
+        });
+
+
+        data.put("list",dtoList);
+        ResponseEntity responseEntity = new ResponseEntity();
+        responseEntity.success(data,"获取数据成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity vacationSetSave(VacationSaveReq req,String userId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        try{
+            TbVacationLimit vacation = this.getById(req.getId());
+            String year = vacation.getLimitYear();
+            //原有的假日设置
+            TbVacationLimit oldVacation = new TbVacationLimit();
+            BeanUtils.copyProperties(vacation, oldVacation);
+            if(req.getSetState()==2) {   //开启
+                //校验数据有效性
+                String startDate = req.getStartDate();
+                String endDate = req.getEndDate();
+                if(startDate.compareTo(DateHelper.format(new Date(),"yyyy-MM-dd"))<0){
+
+                    responseEntity.failure("000","假期开始时间不能早于今天");
+                    return  responseEntity;
+                }
+                if(vacation.getType()==1){ //寒假开始时间不能超过1月2月
+                    String limitStartDate = year+"-01"+"-01";
+                    String limitEndDate = year+"-03"+"-01";
+                    if(startDate.compareTo(limitStartDate)<0 || startDate.compareTo(limitEndDate)>0 || endDate.compareTo(limitStartDate)<0 || endDate.compareTo(limitEndDate)>0){
+                        responseEntity.failure("000","寒假时间不能超过1月2月");
+                        return  responseEntity;
+                    }
+                }else if(vacation.getType()==2){ //五一 日期不超过7天,开始时间不能超过4月、5月
+                    String limitStartDate = year+"-04"+"-01";
+                    String limitEndDate = year+"-06"+"-01";
+                    if(startDate.compareTo(limitStartDate)<0 || startDate.compareTo(limitEndDate)>0 || endDate.compareTo(limitStartDate)<0 || endDate.compareTo(limitEndDate)>0){
+                        responseEntity.failure("000","五一时间不能超过4月、5月");
+                        return  responseEntity;
+                    }
+                    if(DateHelper.daysBetween(DateHelper.parseDate(endDate,"yyyy-MM-dd"),DateHelper.parseDate(startDate,"yyyy-MM-dd"))>7){
+                        responseEntity.failure("000","五一假期不能超过7天");
+                        return  responseEntity;
+                    }
+                }else if(vacation.getType()==3){
+                    String limitStartDate = year+"-07"+"-01";
+                    String limitEndDate = year+"-09"+"-01";
+                    if(startDate.compareTo(limitStartDate)<0 || startDate.compareTo(limitEndDate)>0 || endDate.compareTo(limitStartDate)<0 || endDate.compareTo(limitEndDate)>0){
+                        responseEntity.failure("000","暑假时间不能超过7月8月");
+                        return  responseEntity;
+                    }
+                }else if(vacation.getType()==4){
+                    String limitStartDate = year+"-09"+"-01";
+                    String limitEndDate = year+"-11"+"-01";
+                    if(startDate.compareTo(limitStartDate)<0 || startDate.compareTo(limitEndDate)>0 || endDate.compareTo(limitStartDate)<0 || endDate.compareTo(limitEndDate)>0){
+                        responseEntity.failure("000","国庆时间不能超过9月10月");
+                        return  responseEntity;
+                    }
+                    if(DateHelper.daysBetween(DateHelper.parseDate(endDate,"yyyy-MM-dd"),DateHelper.parseDate(startDate,"yyyy-MM-dd"))>7){
+                        responseEntity.failure("000","国庆假期不能超过7天");
+                        return  responseEntity;
+                    }
+                }else{
+                    responseEntity.failure("000","超出系统定义！");
+                    return  responseEntity;
+                }
+            }
+
+            if(vacation.getStartDate()!=null){
+                if(DateHelper.compareTwoDate(vacation.getStartDate(),new Date())){
+                    responseEntity.failure("000","设置已生效，不能修改！");
+                    return  responseEntity;
+                }
+            }
+
+            //处理保存数据
+            //if(req.getSetState()==2){  //开启
+                vacation.setStartDate(DateHelper.parseDate(req.getStartDate(),"yyyy-MM-dd"));
+                vacation.setEndDate(DateHelper.parseDate(req.getEndDate(),"yyyy-MM-dd"));
+            //}
+            vacation.setUpdateTime(new Date());
+            vacation.setUserId(userId);
+            vacation.setSetState(req.getSetState());
+            vacation = this.save(vacation);
+
+            //处理有效服务数据延长或缩短
+            vipServiceService.setLibService(vacation, oldVacation);
+
+            responseEntity.success("保存数据成功");
+        }catch (Exception e){
+            e.printStackTrace();
+            responseEntity.failure("500","保存处理数据出现异常！");
+        }
+        return responseEntity;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/game/service/impl/GameAnswerRecordServiceImpl.java

@@ -0,0 +1,28 @@
+package com.ssj.service.conch.game.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.game.domain.GameAnswerRecord;
+import com.ssj.dao.sys.game.dao.GameAnswerRecordDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.conch.game.service.GameAnswerRecordService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author Mount Liu
+ * @date 2018/2/20
+ */
+@Service(version="1.0")
+@Transactional
+public class GameAnswerRecordServiceImpl extends BaseServiceImpl<GameAnswerRecord, String> implements GameAnswerRecordService {
+
+    @Autowired
+    private GameAnswerRecordDao gameAnswerRecordDao;
+
+
+    @Override
+    public PagingAndSortingRepository<GameAnswerRecord, String> getDao() {
+        return gameAnswerRecordDao;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/game/service/impl/GameQuestionOptionServiceImpl.java

@@ -0,0 +1,29 @@
+package com.ssj.service.conch.game.service.impl;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.game.domain.GameQuestionOption;
+import com.ssj.dao.sys.game.dao.GameQuestionOptionDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.conch.game.service.GameQuestionOptionService;
+
+/**
+ * @author Mount Liu
+ * @date 2018/2/19
+ */
+@Service(version="1.0")
+@Transactional
+public class GameQuestionOptionServiceImpl extends BaseServiceImpl<GameQuestionOption, String> implements GameQuestionOptionService {
+
+    @Autowired
+    private GameQuestionOptionDao dao;
+
+    @Override
+    public PagingAndSortingRepository<GameQuestionOption, String> getDao() {
+        return dao;
+    }
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/game/service/impl/GameQuestionServiceImpl.java

@@ -0,0 +1,44 @@
+package com.ssj.service.conch.game.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.game.domain.GameQuestion;
+import com.ssj.dao.sys.game.dao.GameQuestionDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.persistence.DynamicSpecifications;
+import com.ssj.framework.core.persistence.SearchFilter;
+import com.ssj.service.conch.game.service.GameQuestionService;
+
+import java.util.Map;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author Mount Liu
+ * @date 2018/2/19
+ */
+@Service(version="1.0")
+@Transactional
+public class GameQuestionServiceImpl extends BaseServiceImpl<GameQuestion, String> implements GameQuestionService {
+
+    @Autowired
+    private GameQuestionDao dao;
+
+    @Override
+    public PagingAndSortingRepository<GameQuestion, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public Page<GameQuestion> findByPage(Map<String, Object> params, Pageable sp) {
+        Map<String, SearchFilter> filters = SearchFilter.parse(params);
+        Specification<GameQuestion> specification = DynamicSpecifications.bySearchFilter(filters.values(), GameQuestion.class);
+        return dao.findAll(specification, sp);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/game/service/impl/GameRecordServiceImpl.java

@@ -0,0 +1,43 @@
+package com.ssj.service.conch.game.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.game.domain.GameRecord;
+import com.ssj.dao.sys.game.dao.GameRecordDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.conch.game.service.GameRecordService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author Mount Liu
+ * @date 2018/2/19
+ */
+@Service(version="1.0")
+@Transactional
+public class GameRecordServiceImpl extends BaseServiceImpl<GameRecord, String> implements GameRecordService {
+
+    @Autowired
+    private GameRecordDao dao;
+
+    @Override
+    public PagingAndSortingRepository<GameRecord, String> getDao() {
+        return dao;
+    }
+
+
+    @Override
+    public void deleteByUserId(String userId) {
+        dao.deleteRecordsByUserId(userId);
+    }
+
+    @Override
+    public GameRecord findByUserIdAndLevel(String userId, int level) {
+        return dao.findByUserIdAndLevel(userId, level);
+    }
+
+    @Override
+    public GameRecord findByUserIdAndGameRespondentIdAndLevel(String userId, String gameRespondentId, Integer level) {
+        return dao.findByUserIdAndGameRespondentIdAndLevel(userId, gameRespondentId, level);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/game/service/impl/GameRespondentServiceImpl.java

@@ -0,0 +1,28 @@
+package com.ssj.service.conch.game.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.game.domain.GameRespondent;
+import com.ssj.dao.sys.game.dao.GameRespondentDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.conch.game.service.GameRespondentService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author yrf
+ * @date 2020/4/22 14:19
+ */
+@Service(version="1.0")
+@Transactional
+public class GameRespondentServiceImpl extends BaseServiceImpl<GameRespondent, String> implements GameRespondentService {
+
+    @Autowired
+    private GameRespondentDao gameRespondentDao;
+
+
+    @Override
+    public PagingAndSortingRepository<GameRespondent, String> getDao() {
+        return gameRespondentDao;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/game/service/impl/GameServiceImpl.java

@@ -0,0 +1,249 @@
+package com.ssj.service.conch.game.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.game.domain.GameQuestion;
+import com.ssj.bean.sys.game.domain.GameQuestionOption;
+import com.ssj.bean.sys.game.domain.GameRecord;
+import com.ssj.bean.sys.game.domain.Ranklist;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.dao.sys.game.dao.GameQuestionDao;
+import com.ssj.dao.sys.game.dao.GameQuestionOptionDao;
+import com.ssj.dao.sys.game.dao.GameRecordDao;
+import com.ssj.dao.sys.game.dao.RanklistDao;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.service.conch.game.dto.QuestionDto;
+import com.ssj.service.conch.game.dto.RanklistDto;
+import com.ssj.service.conch.game.request.RanklistReq;
+import com.ssj.service.conch.game.request.SavePersonInfoReq;
+import com.ssj.service.conch.game.request.SaveV1Req;
+import com.ssj.service.conch.game.service.GameRecordService;
+import com.ssj.service.conch.game.service.GameService;
+import com.ssj.service.conch.game.service.RanklistService;
+import com.ssj.service.weixin.user.service.UserService;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+/**
+ * @author Mount Liu
+ * @date 2018/2/20
+ */
+@Service(version="1.0")
+@Transactional
+public class GameServiceImpl implements GameService {
+
+    @Autowired
+    private RanklistDao ranklistDao;
+
+    @Autowired
+    private RanklistService ranklistService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private GameRecordDao gameRecordDao;
+
+    @Autowired
+    private GameRecordService gameRecordService;
+
+    @Autowired
+    private GameQuestionDao gameQuestionDao;
+
+    @Autowired
+    private GameQuestionOptionDao gameQuestionOptionDao;
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public ResponseEntity rankingList(RanklistReq req, Pageable pageable) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>();
+        Map<String, Object> params = new HashMap<>(16);
+        List<RanklistDto> list = new ArrayList<>();
+        if (StringUtils.isNotBlank(req.getMaxCreateTime())) {
+            params.put("LTE_createTime", req.getMaxCreateTime());
+        }
+        Page<Ranklist> page = ranklistService.findByPage(params, pageable);
+        for (Ranklist ranklist : page.getContent()) {
+            RanklistDto dto = new RanklistDto();
+            dto.setName(ranklist.getName());
+            dto.setPhoto(ranklist.getPhoto());
+            dto.setScore(ranklist.getScore());
+            dto.setSex(ranklist.getSex());
+            list.add(dto);
+        }
+        data.put("pages", page.getTotalElements());
+        data.put("pageSize", req.getPageSize());
+        data.put("pageNo", req.getPageNo());
+        data.put("list", list);
+        responseEntity.success(data, "成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity saveResult(String userId, SaveV1Req req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        //插入新记录
+        GameRecord record = new GameRecord();
+        Ranklist ranklist = ranklistDao.findByUserId(userId);
+        record.setScore(req.getScore());
+        record.setSpaceImagination(req.getSpaceImagination());
+//        record.setSpatialAbility(req.getSpatialAbility());
+//        record.setTextSearch(req.getTextSearch());
+//        record.setMemory(req.getMemory());
+//        record.setObservationAbility(req.getObservationAbility());
+        record.setGraphicReasoning(req.getGraphicReasoning());
+        record.setAttention(req.getAttention());
+        record.setAppraisal(req.getAppraisal());
+        record.setLevel(req.getLevel());
+        //更新总分
+        double totalScore = req.getScore() + ranklist.getScore();
+        ranklist.setScore(totalScore);
+        ranklist.setLevel(req.getLevel());
+        ranklistService.save(ranklist);
+        gameRecordService.save(record);
+        responseEntity.success("成功");
+        return responseEntity;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public ResponseEntity homepageInfo(String userId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> map = new HashMap<>(16);
+        Ranklist ranklist = ranklistDao.findByUserId(userId);
+        if (ranklist != null) {
+            map.put("name", ranklist.getName());
+            map.put("photo", ranklist.getPhoto());
+            List<GameRecord> records = gameRecordDao.findByUserId(userId);
+            //1:第一次测试，2：已经测过，没有结束，3已经测过，已经结束
+            switch (records.size()) {
+                case 0:
+                    map.put("type", 1);
+                    break;
+                case 5:
+                    map.put("type", 3);
+                    break;
+                default:
+                    map.put("type", 2);
+                    break;
+            }
+        } else {
+            //第一次授权后新增数据
+            User user = userService.getById(userId);
+            Ranklist newRanklist = new Ranklist();
+            newRanklist.setUserId(userId);
+            newRanklist.setName(user.getName());
+            newRanklist.setPhoto(user.getPhoto());
+            newRanklist.setCreateTime(new Date());
+            ranklistService.save(newRanklist);
+            map.put("name", user.getName());
+            map.put("photo", user.getPhoto());
+            map.put("type", 1);
+        }
+        responseEntity.success(map,"成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity savePersonInfo(String userId, SavePersonInfoReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Ranklist ranklist = ranklistDao.findByUserId(userId);
+        if (ranklist != null) {
+            ranklist.setSex(req.getSex());
+            ranklist.setAgeGroup(req.getAgeGroup());
+            ranklistService.save(ranklist);
+            responseEntity.success("成功");
+        } else {
+            responseEntity.failure("用户数据不存在，请联系管理员！");
+        }
+        return responseEntity;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public ResponseEntity findResult(String userId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> map = new HashMap<>(16);
+        List<GameRecord> ranklist = gameRecordDao.findByUserId(userId);
+        if (ranklist != null && ranklist.size() > 0) {
+            double totalScore = 0.0;
+            for (GameRecord record : ranklist) {
+                totalScore += record.getScore();
+            }
+            map.put("score", ranklist.get(0).getScore());
+            map.put("totalScore", totalScore);
+            map.put("spaceImagination", ranklist.get(0).getSpaceImagination());
+//            map.put("spatialAbility", ranklist.get(0).getSpatialAbility());
+//            map.put("textSearch", ranklist.get(0).getTextSearch());
+//            map.put("memory", ranklist.get(0).getMemory());
+//            map.put("observationAbility", ranklist.get(0).getObservationAbility());
+            map.put("graphicReasoning", ranklist.get(0).getGraphicReasoning());
+            map.put("attention", ranklist.get(0).getAttention());
+            map.put("appraisal", ranklist.get(0).getAppraisal());
+            if (ranklist.size() == 5) {
+                map.put("isEnd", 1);
+            } else {
+                map.put("isEnd", 0);
+            }
+        }
+        responseEntity.success(map,"成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity findQuestion(String userId, int selection) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        //题目列表
+        List<QuestionDto.Question> questionList = new ArrayList();
+        //选项列表
+        List<QuestionDto.Question.Option> optionList = new ArrayList();
+        Ranklist ranklist = ranklistDao.findByUserId(userId);
+        QuestionDto dto = new QuestionDto();
+        dto.setAgeGroup(ranklist.getAgeGroup());
+        dto.setSex(ranklist.getSex());
+        //1：重新开始；2：接着测试（或挑战下一关）
+        if (selection == 1) {
+            //软删除用户游戏记录
+            gameRecordDao.deleteRecordsByUserId(userId);
+            //清空分数
+            ranklistDao.updateScore(0.0, userId);
+            dto.setLevel(1);
+        } else {
+            dto.setLevel(ranklist.getLevel() + 1);
+        }
+        //查询当前关卡所有题目，按照升序排列
+        List<GameQuestion> questions = gameQuestionDao.findByLevelOrderByNumberAsc(dto.getLevel());
+        for (GameQuestion question : questions) {
+            QuestionDto.Question qusDto = dto.new Question();
+            qusDto.setTitle(question.getTitle());
+            if (StringUtils.isNotBlank(question.getPicture())) {
+                qusDto.setPicture(Arrays.asList(question.getPicture().split(",")));
+            }
+            qusDto.setContent(question.getContent());
+            qusDto.setAnswerId(question.getAnswerId());
+            qusDto.setAnswer(question.getAnswer());
+            qusDto.setType(question.getType());
+            List<GameQuestionOption> options = gameQuestionOptionDao.findByQuestionId(question.getId());
+            if (options != null && options.size() > 0) {
+                for (GameQuestionOption option : options) {
+                    QuestionDto.Question.Option optDto = qusDto.new Option();
+                    optDto.setId(optDto.getId());
+                    optDto.setContent(option.getContent());
+                    optionList.add(optDto);
+                }
+            }
+            qusDto.setOptions(optionList);
+            questionList.add(qusDto);
+        }
+        dto.setList(questionList);
+        responseEntity.success(dto,"成功");
+        return responseEntity;
+    }
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/game/service/impl/GameV2ServiceImpl.java

@@ -0,0 +1,296 @@
+package com.ssj.service.conch.game.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.ssj.bean.sys.game.domain.GameAnswerRecord;
+import com.ssj.bean.sys.game.domain.GameRecord;
+import com.ssj.bean.sys.game.domain.GameRespondent;
+import com.ssj.bean.sys.game.domain.Ranklist;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.dao.sys.game.dao.GameRecordDao;
+import com.ssj.dao.sys.game.dao.RanklistDao;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.service.conch.game.dto.HistoryDto;
+import com.ssj.service.conch.game.dto.RanklistDto;
+import com.ssj.service.conch.game.request.*;
+import com.ssj.service.conch.game.service.*;
+import com.ssj.service.mapper.GameMapper;
+import com.ssj.service.weixin.user.service.UserService;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+/**
+ * @author Mount Liu
+ * @date 2018/2/20
+ */
+@Service(version="1.0")
+@Transactional
+public class GameV2ServiceImpl implements GameV2Service {
+
+    @Autowired
+    private RanklistDao ranklistDao;
+    @Autowired
+    private RanklistService ranklistService;
+    @Autowired
+    private UserService userService;
+    @Autowired
+    private GameRecordDao gameRecordDao;
+    @Autowired
+    private GameRecordService gameRecordService;
+    @Autowired
+    private GameMapper gameMapper;
+    @Autowired
+    private GameAnswerRecordService gameAnswerRecordService;
+    @Autowired
+    private GameRespondentService gameRespondentService;
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public ResponseEntity rankingList(RanklistReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>();
+        Page<RanklistDto> page = new Page<>(req.getPageNo(), req.getPageSize());
+        page = gameMapper.findPage(page, req.getMaxCreateTime());
+        data.put("pages", page.getPages());
+        data.put("pageSize", req.getPageSize());
+        data.put("pageNo", req.getPageNo());
+        data.put("list", page.getRecords());
+        return responseEntity.success(data, "查询成功");
+    }
+
+    @Override
+    public ResponseEntity saveResult(String userId, SaveV2Req req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        GameRecord record = gameRecordService.findByUserIdAndLevel(userId, req.getLevel());
+        if (record == null) {
+            record = new GameRecord();
+            record.setCreateTime(new Date());
+        }
+
+        record.setUserId(userId);
+        record.setScore(req.getScore());
+        record.setSpaceImagination(req.getSpaceImagination());
+        record.setExecutionFunctionality(req.getExecutionFunctionality());
+        record.setVisualSearch(req.getVisualSearch());
+        record.setWorkingMemory(req.getWorkingMemory());
+        record.setAttention(req.getAttention());
+        record.setRelevantMemory(req.getRelevantMemory());
+        record.setMentalRotation(req.getMentalRotation());
+        record.setGraphicReasoning(req.getGraphicReasoning());
+        record.setAppraisal(req.getAppraisal());
+        record.setLevel(req.getLevel());
+        record.setIsDelete(0);
+        gameRecordService.save(record);
+
+        //更新总分
+        Ranklist ranklist = ranklistDao.findByUserId(userId);
+        ranklist.setScore(req.getScore());
+        ranklist.setLevel(req.getLevel());
+        ranklistService.save(ranklist);
+
+        return responseEntity.success("保存成功");
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public ResponseEntity homepageInfo(String userId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> map = new HashMap<>(16);
+        Ranklist ranklist = ranklistDao.findByUserId(userId);
+        if (ranklist != null) {
+            map.put("name", ranklist.getName());
+            map.put("photo", ranklist.getPhoto());
+            map.put("level", ranklist.getLevel());
+            map.put("ageGroup", ranklist.getAgeGroup());
+        } else {
+            //第一次授权后新增数据
+            User user = userService.getById(userId);
+            if (user == null) {
+                return responseEntity.failure("用户不存在");
+            }
+            Ranklist newRanklist = new Ranklist();
+            newRanklist.setUserId(userId);
+            newRanklist.setName(user.getName());
+            newRanklist.setPhoto(user.getPhoto());
+            newRanklist.setCreateTime(new Date());
+            ranklistService.save(newRanklist);
+            map.put("name", user.getName());
+            map.put("photo", user.getPhoto());
+            map.put("level", -1);
+            map.put("ageGroup", -1);
+        }
+        return responseEntity.success(map, "成功");
+    }
+
+    @Override
+    public ResponseEntity savePersonInfo(String userId, SavePersonInfoReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Ranklist ranklist = ranklistDao.findByUserId(userId);
+        if (ranklist != null) {
+            ranklist.setSex(req.getSex());
+            ranklist.setAgeGroup(req.getAgeGroup());
+            ranklistService.save(ranklist);
+            return responseEntity.success("成功");
+        } else {
+            return responseEntity.failure("用户数据不存在，请联系管理员！");
+        }
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public ResponseEntity findResult(String userId, TestResultReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        GameRecord gameRecord;
+        if (StringUtils.isBlank(req.getGameRecordId())) {
+            gameRecord = gameRecordDao.findNewest(userId);
+        } else {
+            gameRecord = gameRecordService.getById(req.getGameRecordId());
+        }
+
+        if (gameRecord == null) {
+            return responseEntity.failure("您还未开始测试");
+        }
+
+        Map<String, Object> resultMap = new HashMap<>();
+        Ranklist ranklist = ranklistService.findByUserId(userId);
+        resultMap.put("appraisal", gameRecord.getAppraisal());
+        resultMap.put("score", gameRecord.getScore());
+        resultMap.put("level", gameRecord.getLevel());
+        resultMap.put("totalScore", ranklist.getScore());
+        resultMap.put("spaceImagination", gameRecord.getSpaceImagination());
+        resultMap.put("executionFunctionality", gameRecord.getExecutionFunctionality());
+        resultMap.put("visualSearch", gameRecord.getVisualSearch());
+        resultMap.put("workingMemory", gameRecord.getWorkingMemory());
+        resultMap.put("attention", gameRecord.getAttention());
+        resultMap.put("relevantMemory", gameRecord.getRelevantMemory());
+        resultMap.put("mentalRotation", gameRecord.getMentalRotation());
+        resultMap.put("graphicReasoning", gameRecord.getGraphicReasoning());
+
+        return responseEntity.success(resultMap, "成功");
+    }
+
+    @Override
+    public ResponseEntity reset(String userId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        Ranklist ranklist = ranklistService.findByUserId(userId);
+
+        if (ranklist == null) {
+            return responseEntity.failure("您还未开始测试");
+        }
+
+        //清除测试总分和当前关卡
+        ranklist.setScore(0.0);
+        ranklist.setLevel(0);
+        ranklistService.save(ranklist);
+
+        //清除所有关卡的测试记录
+        gameRecordService.deleteByUserId(userId);
+
+        return responseEntity.success("重置成功");
+    }
+
+    @Override
+    public ResponseEntity saveResultV2(String userId, SaveV2Req req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        //更新测试结果
+        Ranklist ranklist = ranklistDao.findByUserId(userId);
+        if (ranklist == null) {
+            return responseEntity.failure("失败");
+        }
+        if (Objects.equals(0, req.getLevel()) && ranklist.getLevel() > -1) {
+            // 已完成练习关卡
+            return responseEntity.success("成功");
+        }
+
+        if (0 == req.getLevel()) {
+            // 练习关卡结果保存
+            ranklist.setLevel(0);
+        } else {
+            // 正常测试结果保存
+//            GameRecord record = gameRecordService.findByUserIdAndLevel(userId, req.getLevel());
+            GameRecord record = gameRecordService.findByUserIdAndGameRespondentIdAndLevel(userId,
+                    req.getGameRespondentId(), req.getLevel());
+            if (record == null) {
+                record = new GameRecord();
+                record.setCreateTime(new Date());
+            }
+
+            // 测试记录
+            record.setUserId(userId);
+            record.setGameRespondentId(req.getGameRespondentId());
+            record.setScore(req.getScore());
+            record.setSpaceImagination(req.getSpaceImagination());
+            record.setExecutionFunctionality(req.getExecutionFunctionality());
+            record.setVisualSearch(req.getVisualSearch());
+            record.setWorkingMemory(req.getWorkingMemory());
+            record.setAttention(req.getAttention());
+            record.setRelevantMemory(req.getRelevantMemory());
+            record.setMentalRotation(req.getMentalRotation());
+            record.setGraphicReasoning(req.getGraphicReasoning());
+            record.setAppraisal(req.getAppraisal());
+            record.setLevel(req.getLevel());
+            record.setIsDelete(0);
+            gameRecordService.save(record);
+
+            // 排行榜记录
+            ranklist.setScore(req.getScore());
+            ranklist.setLevel(req.getLevel());
+        }
+        ranklistService.save(ranklist);
+
+        return responseEntity.success("保存成功");
+    }
+
+    @Override
+    public ResponseEntity answerInfoSave(String userId, AnswerInfoSaveReq req) {
+        GameAnswerRecord gameAnswerRecord = new GameAnswerRecord();
+        BeanUtils.copyProperties(req, gameAnswerRecord);
+        gameAnswerRecord.setUserId(userId);
+        gameAnswerRecord.setCreateTime(new Date());
+        gameAnswerRecordService.save(gameAnswerRecord);
+        return new ResponseEntity().success("保存成功");
+    }
+
+    @Override
+    public ResponseEntity saveRespondentInfo(String userId, SaveRespondentInfoReq req) {
+        GameRespondent gameRespondent = new GameRespondent();
+        BeanUtils.copyProperties(req, gameRespondent);
+        gameRespondent.setUserId(userId);
+        gameRespondent.setCreateTime(new Date());
+        gameRespondent = gameRespondentService.save(gameRespondent);
+        return new ResponseEntity().success(Collections.singletonMap("gameRespondentId", gameRespondent.getId()), "成功");
+    }
+
+    @Override
+    public ResponseEntity findHistory(String userId, RanklistReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        try {
+            DateUtil.parse_yyyyMMddHHmmss(req.getMaxCreateTime());
+        } catch (Exception e) {
+            return responseEntity.failure("时间格式不正确");
+        }
+
+        IPage<HistoryDto> page = new Page<>(req.getPageNo(), req.getPageSize());
+        gameMapper.findHistory(page, userId, req);
+
+        Map<String, Object> resultMap = new HashMap<>();
+        resultMap.put("pageNo", page.getCurrent());
+        resultMap.put("pageSize", page.getSize());
+        resultMap.put("pages", page.getPages());
+        resultMap.put("list", page.getRecords());
+
+        return responseEntity.success(resultMap, "成功");
+    }
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/game/service/impl/RanklistServiceImpl.java

@@ -0,0 +1,107 @@
+package com.ssj.service.conch.game.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.game.domain.Ranklist;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.dao.sys.game.dao.RanklistDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.persistence.DynamicSpecifications;
+import com.ssj.framework.core.persistence.SearchFilter;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.service.conch.game.dto.RanklistDto;
+import com.ssj.service.conch.game.request.RanklistReq;
+import com.ssj.service.conch.game.service.RanklistService;
+import com.ssj.service.weixin.user.service.UserService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+/**
+ * @author Mount Liu
+ * @date 2018/1/22
+ */
+@Service(version="1.0")
+@Transactional
+public class RanklistServiceImpl extends BaseServiceImpl<Ranklist, String> implements RanklistService {
+
+    @Autowired
+    private RanklistDao dao;
+
+    @Autowired
+    private UserService userService;
+
+    @Override
+    public PagingAndSortingRepository<Ranklist, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public Page<Ranklist> findByPage(Map<String, Object> params, Pageable sp) {
+        Map<String, SearchFilter> filters = SearchFilter.parse(params);
+        Specification<Ranklist> specification = DynamicSpecifications.bySearchFilter(filters.values(), Ranklist.class);
+        return dao.findAll(specification, sp);
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public ResponseEntity rankingList(RanklistReq req, Pageable pageable) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>();
+        Map<String, Object> params = new HashMap<>(16);
+        List<RanklistDto> list = new ArrayList<>();
+        if (StringUtil.isNotBlank(req.getMaxCreateTime())) {
+            params.put("LTE_createTime", req.getMaxCreateTime());
+        }
+        Page<Ranklist> page = this.findByPage(params, pageable);
+        for (Ranklist ranklist :page.getContent()){
+            RanklistDto  dto = new RanklistDto();
+            dto.setName(ranklist.getName());
+            dto.setPhoto(ranklist.getPhoto());
+            dto.setScore(ranklist.getScore());
+            list.add(dto);
+        }
+        data.put("pages", page.getTotalElements());
+        data.put("pageSize", req.getPageSize());
+        data.put("pageNo", req.getPageNo());
+        data.put("list", list);
+        responseEntity.success(data, "成功");
+        return responseEntity;
+    }
+
+    /**
+     *
+     * @param userId
+     * @param score
+     * @return
+     */
+    @Override
+    public ResponseEntity saveResult(String userId, double score){
+        ResponseEntity responseEntity = new ResponseEntity();
+        Ranklist ranklist = dao.findByUserId(userId);
+        if (ranklist == null) {
+            User user = userService.getById(userId);
+            Ranklist newRanklist = new Ranklist();
+            newRanklist.setUserId(userId);
+            newRanklist.setName(user.getName());
+            newRanklist.setPhoto(user.getPhoto());
+            newRanklist.setScore(score);
+            newRanklist.setCreateTime(new Date());
+            this.save(newRanklist);
+        }
+        responseEntity.success("成功");
+        return responseEntity;
+    }
+
+    @Override
+    public Ranklist findByUserId(String userId) {
+        return dao.findByUserId(userId);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/opentest/RecordQuestionServiceImpl.java

@@ -0,0 +1,797 @@
+package com.ssj.service.conch.opentest;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.conch.conch.dto.OpenTestDto;
+import com.ssj.bean.mybatis.KnowledgeMBDto;
+import com.ssj.bean.sys.opentest.OpenTestQuestion;
+import com.ssj.bean.sys.opentest.OpenTestUnit;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.bean.weixin.zyb.domain.ZuoybKnowHowDetailsSort;
+import com.ssj.dao.sys.opentest.OpenTestQuestionDao;
+import com.ssj.dao.sys.opentest.OpenTestUnitDao;
+import com.ssj.dao.weixin.zuoyb.dao.ZuoybKnowHowDetailsSortDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.service.conch.opentest.dto.Condition1Dto;
+import com.ssj.service.conch.opentest.dto.KnowledgeDto;
+import com.ssj.service.conch.opentest.request.*;
+import com.ssj.service.mapper.RecordQuestionMapper;
+import com.ssj.service.sys.opentest.OpenTestQuestionService;
+import com.ssj.service.sys.opentest.OpenTestUnitService;
+import com.ssj.service.weixin.library.service.IBookManagerService;
+import com.ssj.service.weixin.user.service.UserService;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author yanghuan
+ * @title: RecordQuestionServiceImpl
+ * @projectName ssj
+ * @description: TODO
+ * @date 2020/5/15 10:05
+ */
+@Service(version = "1.0")
+@Transactional
+public class RecordQuestionServiceImpl extends BaseServiceImpl<OpenTestQuestion, String> implements RecordQuestionService {
+
+    private Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @Autowired
+    private TokenManager tokenManager;
+
+    @Autowired
+    private OpenTestQuestionDao dao;
+
+    @Autowired
+    private RecordQuestionMapper recordQuestionMapper;
+    @Autowired
+    private UserService userService;
+    @Autowired
+    private IBookManagerService bookManagerService;
+    @Autowired
+    private OpenTestQuestionService OpenTestQuestionService;
+
+    @Autowired
+    private OpenTestUnitService openTestUnitService;
+
+    @Autowired
+    private OpenTestQuestionService openTestQuestionService;
+
+    @Autowired
+    private OpenTestUnitDao openTestUnitDao;
+
+    @Autowired
+    private ZuoybKnowHowDetailsSortDao zuoybKnowHowDetailsSortDao;
+
+    @Override
+    public PagingAndSortingRepository<OpenTestQuestion, String> getDao() {
+        return dao;
+    }
+    @Override
+    public ResponseEntity addOrEditQuestion(QuestionReuqest req){
+        ResponseEntity responseEntity = new ResponseEntity();
+        OpenTestQuestion openTestQuestion;
+        List<OpenTestQuestion> questionList = openTestQuestionService.findQuestionList(req.getSubject(), req.getGrade(), req.getVersion(), req.getUnit(), 1, req.getType(), req.getSemester());
+        if (questionList.size() > 0) {
+            return responseEntity.failure("此筛选已有题目发布成功，添加失败");
+        }
+        if (StringUtils.isNotBlank(req.getQuestionId())) {
+            openTestQuestion = OpenTestQuestionService.getById(req.getQuestionId());
+            if (null != openTestQuestion) {
+                if (!Objects.equals(req.getType(), openTestQuestion.getType())) {
+                    return responseEntity.failure("不能更改类型，添加失败");
+                }
+                 //修改,判断年级，科目，版本是否变化
+                 if(Objects.equals(req.getGrade(),openTestQuestion.getGrade())&&Objects.equals(req.getSubject(),openTestQuestion.getSubject())&&
+                 Objects.equals(req.getVersion(),openTestQuestion.getVersion())&&Objects.equals(req.getUnit(),openTestQuestion.getUnit())
+                         &&Objects.equals(req.getSemester(),openTestQuestion.getSemester())
+                 ){
+                     //年级科目版本单元都没有任何变化,再判断是大题还是小题
+                     //大题
+                     if(0==openTestQuestion.getQuestionNum()){
+                         //大题变小题
+                         if(CollectionUtils.isNotEmpty(req.getOptionList())){
+                             //根据sortNo，定位他的题目顺序，后面的题再顺延
+                             int sortNo=openTestQuestion.getSortNo();
+                             int sort=sortNo+1;
+                             OpenTestQuestion question = null;
+                             //单元测评
+                             if (req.getType() == 2) {
+                                 question = dao.findQuestion(req.getSubject(), req.getGrade(), req.getVersion(), req.getUnit(), req.getType(), sort, req.getSemester());
+                             } else {
+                                 question = dao.findQuestion(req.getSubject(), req.getGrade(), req.getVersion(), req.getType(), sort, req.getSemester());
+                             }
+                             if(null==question){
+                                 openTestQuestion.setQuestionNum(1);
+                             }else {
+                                 openTestQuestion.setQuestionNum(question.getQuestionNum()-1);
+                             }
+                             //后面的题号都得顺延，
+                             recordQuestionMapper.updateQuestionNum(openTestQuestion, -1);
+                             openTestQuestion.setQuestionNum(question.getQuestionNum());
+                         }
+                         List<String> list=new ArrayList<>();
+                         for(QuestionReuqest.Options options:req.getOptionList()){
+                             String option=options.getOption();
+                             String content=options.getValue();
+                             int isAnswer=options.getIsAnswer();
+                             String answer=option+"."+content;
+                             if(1==isAnswer){
+                                 openTestQuestion.setOptionAnswer(option);
+                             }
+                             list.add(answer);
+                         }
+
+                         String  optionContent=list.stream().collect(Collectors.joining("#S"));
+                         openTestQuestion.setOptionContent(optionContent);
+                         //大题变大题不用管
+                     }else {
+                         //小题
+                         //小题变小题
+                         if(CollectionUtils.isNotEmpty(req.getOptionList())){
+                             List<String> list=new ArrayList<>();
+                             for(QuestionReuqest.Options options:req.getOptionList()){
+                                 String option=options.getOption();
+                                 String content=options.getValue();
+                                 int isAnswer=options.getIsAnswer();
+                                 String answer=option+"."+content;
+                                 if(1==isAnswer){
+                                     openTestQuestion.setOptionAnswer(option);
+                                 }
+                                 list.add(answer);
+                             }
+
+                             String  optionContent=list.stream().collect(Collectors.joining("#S"));
+                             openTestQuestion.setOptionContent(optionContent);
+                         }else {
+                             openTestQuestion.setOptionContent(null);
+                             openTestQuestion.setOptionAnswer(null);
+                             //后面的题号都得顺延，
+                             recordQuestionMapper.updateQuestionNum(openTestQuestion, 1);
+                             //小题变大题
+                             openTestQuestion.setQuestionNum(0);
+                         }
+
+                     }
+                     openTestQuestion.setQuestion(req.getQuestion());
+                     //改了单元科目等的
+                 }else {
+                     if(0!=openTestQuestion.getQuestionNum()){
+                            //小题改为大小题的
+                             recordQuestionMapper.updateQuestionNum(openTestQuestion, 1);
+                             this.getOpenTestQuestion(openTestQuestion,req);
+                             if(CollectionUtils.isEmpty(req.getOptionList())){
+                                 openTestQuestion.setOptionContent(null);
+                                 openTestQuestion.setOptionAnswer(null);
+                             }
+                     }else {
+                         //大题改为大小题的
+                         this.getOpenTestQuestion(openTestQuestion,req);
+                     }
+                 }
+             }
+             openTestQuestion.setModule(req.getModule());
+             openTestQuestion.setModuleType(req.getModuleType());
+        }else {
+            //新增
+            openTestQuestion=new OpenTestQuestion();
+            this.getOpenTestQuestion(openTestQuestion,req);
+        }
+        OpenTestQuestionService.save(openTestQuestion);
+        return responseEntity.success("成功");
+    }
+
+    //题目重新赋值
+    private OpenTestQuestion getOpenTestQuestion(OpenTestQuestion openTestQuestion,QuestionReuqest req){
+        //查该单元排序最大的编号
+        OpenTestQuestion testQuestion = null;
+        if (req.getType() == 2) {
+            //单元测评
+            testQuestion = dao.findQuestion(req.getSubject(), req.getGrade(), req.getVersion(), req.getUnit(), req.getType(), req.getSemester());
+        } else {
+            testQuestion = dao.findQuestion(req.getSubject(), req.getGrade(), req.getVersion(), req.getType(), req.getSemester());
+        }
+
+        if(null==testQuestion){
+            openTestQuestion.setSortNo(0);
+        }else {
+            openTestQuestion.setSortNo(testQuestion.getSortNo()+1);
+        }
+        openTestQuestion.setQuestion(req.getQuestion());
+        //判断插入时题号顺序
+        OpenTestQuestion question=null;
+        if (req.getType() == 2) {
+            question = dao.findQuestionOrderByQuestionNum(req.getSubject(), req.getGrade(), req.getVersion(), req.getUnit(), req.getType(), req.getSemester());
+        } else {
+            question = dao.findQuestionOrderByQuestionNum(req.getSubject(), req.getGrade(), req.getVersion(), req.getType(), req.getSemester());
+        }
+        if(CollectionUtils.isNotEmpty(req.getOptionList())){
+            if(null==question){
+                openTestQuestion.setQuestionNum(1);
+            }else {
+                openTestQuestion.setQuestionNum(question.getQuestionNum()+1);
+            }
+            //将选项插入到数据库
+            List<String> list=new ArrayList<>();
+            for(QuestionReuqest.Options options:req.getOptionList()){
+                String option=options.getOption();
+                String content=options.getValue();
+                int isAnswer=options.getIsAnswer();
+                String answer=option+"."+content;
+                if(1==isAnswer){
+                    openTestQuestion.setOptionAnswer(option);
+                }
+                list.add(answer);
+            }
+            String  optionContent=list.stream().collect(Collectors.joining("#S"));
+            openTestQuestion.setOptionContent(optionContent);
+        }else {
+            openTestQuestion.setQuestionNum(0);
+        }
+        openTestQuestion.setSubject(req.getSubject());
+        openTestQuestion.setGrade(req.getGrade());
+        openTestQuestion.setVersion(req.getVersion());
+        openTestQuestion.setModule(req.getModule());
+        openTestQuestion.setModuleType(req.getModuleType());
+        openTestQuestion.setUnit(req.getUnit());
+        openTestQuestion.setType(req.getType());
+        openTestQuestion.setSemester(req.getSemester());
+        openTestQuestion.setCreateTime(new Date());
+        return openTestQuestion;
+    }
+
+    @Override
+    public ResponseEntity login(LoginReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        // 校验账号密码
+        User user = userService.getUserByPassword(req.getLoginName(), req.getPassword());
+        if (user == null) {
+            return responseEntity.failure("账号或密码不正确");
+        }
+
+        // 校验录题权限
+        TbLibManager libManager = bookManagerService.findByUserIdAndType(user.getId(), 19);
+        if (libManager == null) {
+            return responseEntity.failure("您还没有录题权限");
+        }
+        
+        String token = tokenManager.getToken(user.getId(), "RECORD_QUESTION");
+        if (StringUtil.isBlank(token)) {
+            // 生成访问令牌
+            token = tokenManager.createToken(null, user.getId(), "RECORD_QUESTION");
+        }
+
+        return responseEntity.success(Collections.singletonMap("accessToken", token), "登录成功");
+    }
+
+    @Override
+    public ResponseEntity deleteQuestion(DeleteReq req) {
+        OpenTestQuestion openTestQuestion = this.getById(req.getQuestionId());
+
+        if (openTestQuestion.getUpdateVersion() > -1) {
+            // 删除自身
+            recordQuestionMapper.deleteQuestion(req.getQuestionId());
+
+            // 题号前移步长
+            int step = 1;
+
+            // 最新设计题目之间没有关联性（父子）
+//            List<OpenTestQuestion> childQuestionList = recordQuestionMapper.findAllChild(req.getQuestionId());
+//            if (CollectionUtils.isNotEmpty(childQuestionList)) {
+//                // 删除自己的孩子
+//                recordQuestionMapper.deleteChild(req.getQuestionId());
+//
+//                step = childQuestionList.size();
+//                openTestQuestion = childQuestionList.get(0);
+//            }
+
+            if (openTestQuestion.getQuestionNum() != null && openTestQuestion.getQuestionNum() > 0) {
+                // 更新影响到的题目的题号
+                recordQuestionMapper.updateQuestionNum(openTestQuestion, step);
+            }
+
+            //失效相关单元
+            List<OpenTestUnit> unitList = openTestUnitService.findUnit(openTestQuestion.getGrade(), openTestQuestion.getSubject(), openTestQuestion.getVersion(), openTestQuestion.getUnit(), openTestQuestion.getSemester(), openTestQuestion.getType());
+            if (CollectionUtils.isNotEmpty(unitList)) {
+                unitList.forEach(e -> {
+                    e.setIsValid(0);
+                });
+                openTestUnitService.save(unitList);
+                tokenManager.delString("/api/recordQuestionSys/getConditionInfo/valid");
+                //tokenManager.delString("/api/xiaoshuTest/getConditionInfo");
+            }
+        }
+
+        return new ResponseEntity().success("删除成功");
+    }
+
+    @Override
+    public ResponseEntity findQuestionList(QuestionUnitRequest req){
+        ResponseEntity responseEntity=new ResponseEntity();
+        List<OpenTestDto> list=new ArrayList<>();
+        Map<String,Object> data=new HashMap<>(16);
+        List<OpenTestQuestion> questionList = openTestQuestionService.findQuestionList(req.getSubject(), req.getGrade(), req.getVersion(), req.getUnit(), req.getType(), req.getType1(), req.getSemester());
+       if(CollectionUtils.isNotEmpty(questionList)){
+           questionList.forEach(a->{
+               OpenTestDto dto=new OpenTestDto();
+               if(null!=a.getQuestionNum()){
+                   dto.setQuestionNo(a.getQuestionNum());
+               }
+               dto.setQuestionId(a.getId());
+               dto.setQuestion(a.getQuestion());
+               dto.setModule(a.getModule());
+               dto.setAnswer(a.getOptionAnswer());
+               dto.setModuleType(a.getModuleType());
+               String answerContent=a.getOptionContent();
+               List<OpenTestDto.Contents> optionList = new ArrayList<>();
+               if (StringUtil.isNotBlank(answerContent)) {
+                   String optionAnswer=a.getOptionAnswer();
+                   //将选项分离出来
+                   String[] options = answerContent.split("#S");
+                   String value = "";
+                   for (int i = 0; i < options.length; i++) {
+                       OpenTestDto.Contents contents = dto.new Contents();
+                       String s = options[i];
+                       //这里是文字选项
+                       switch (i) {
+                           case 0:
+                               value = s.substring(s.indexOf("A.") + 2);
+                               contents.setOption("A");
+                               if(Objects.equals(optionAnswer,"A")){
+                                   contents.setIsAnswer(1);
+                               }else {
+                                   contents.setIsAnswer(0);
+                               }
+                               break;
+                           case 1:
+                               value = s.substring(s.indexOf("B.") + 2);
+                               contents.setOption("B");
+                               if(Objects.equals(optionAnswer,"B")){
+                                   contents.setIsAnswer(1);
+                               }else {
+                                   contents.setIsAnswer(0);
+                               }
+                               break;
+                           case 2:
+                               value = s.substring(s.indexOf("C.") + 2);
+                               contents.setOption("C");
+                               if(Objects.equals(optionAnswer,"C")){
+                                   contents.setIsAnswer(1);
+                               }else {
+                                   contents.setIsAnswer(0);
+                               }
+                               break;
+                           case 3:
+                               value = s.substring(s.indexOf("D.") + 2);
+                               contents.setOption("D");
+                               if(Objects.equals(optionAnswer,"D")){
+                                   contents.setIsAnswer(1);
+                               }else {
+                                   contents.setIsAnswer(0);
+                               }
+                               break;
+                           case 4:
+                               value = s.substring(s.indexOf("E.") + 2);
+                               contents.setOption("E");
+                               if(Objects.equals(optionAnswer,"E")){
+                                   contents.setIsAnswer(1);
+                               }else {
+                                   contents.setIsAnswer(0);
+                               }
+                               break;
+                           case 5:
+                               value = s.substring(s.indexOf("F.") + 2);
+                               contents.setOption("F");
+                               if(Objects.equals(optionAnswer,"F")){
+                                   contents.setIsAnswer(1);
+                               }else {
+                                   contents.setIsAnswer(0);
+                               }
+                               break;
+                           case 6:
+                               value = s.substring(s.indexOf("G.") + 2);
+                               contents.setOption("G");
+                               if(Objects.equals(optionAnswer,"G")){
+                                   contents.setIsAnswer(1);
+                               }else {
+                                   contents.setIsAnswer(0);
+                               }
+                               break;
+                           case 7:
+                               value = s.substring(s.indexOf("H.") + 2);
+                               contents.setOption("H");
+                               if(Objects.equals(optionAnswer,"H")){
+                                   contents.setIsAnswer(1);
+                               }else {
+                                   contents.setIsAnswer(0);
+                               }
+                               break;
+                           default:
+                               break;
+                       }
+                       contents.setValue(value);
+                       optionList.add(contents);
+                   }
+                   dto.setOptionList(optionList);
+               }
+               list.add(dto);
+           });
+       }
+        data.put("list",list);
+        responseEntity.success(data,"成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity getConditionInfo(boolean isAll, int platform) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data;
+        List<Map<String, Object>> mapList = new ArrayList<>();
+        if (isAll) {
+            data = tokenManager.get("/api/recordQuestionSys/getConditionInfo/all", Map.class);
+        } else {
+            data = tokenManager.get("/api/recordQuestionSys/getConditionInfo/valid", Map.class);
+        }
+        if (data == null) {
+            data = new HashMap<>(16);
+        } else {
+            return responseEntity.success(data, "成功");
+        }
+        //测评小程序包含学前的，录题系统不包含
+        if (platform == 0) {
+            mapList.add(this.getCondition(isAll, 1));
+        }
+        mapList.add(this.getCondition(isAll, 2));
+        mapList.add(this.getCondition(isAll, 3));
+        //期中测评筛选
+        data.put("list", mapList);
+        if (isAll) {
+            tokenManager.set("/api/recordQuestionSys/getConditionInfo/all", data);
+        } else {
+            tokenManager.set("/api/recordQuestionSys/getConditionInfo/valid", data);
+        }
+        return responseEntity.success(data, "成功");
+    }
+
+    /**
+     * 获取单元测评的筛选条件
+     * @param isAll
+     * @return
+     */
+    private Map<String, Object> getCondition(boolean isAll, int type) {
+        List<OpenTestUnit> list = openTestUnitService.findUnit(isAll, type);
+        List<Condition1Dto> dtoList = new ArrayList<>();
+        Map<String, Condition1Dto> conditionMap = new LinkedHashMap<>(16);
+        for (int i = 0; i < list.size(); i++) {
+            OpenTestUnit entity = list.get(i);
+            String key = entity.getGrade();
+            if (i > 0) {
+                if (list.get(i).getGrade().equals(list.get(i - 1).getGrade())) {
+                    Condition1Dto dto = conditionMap.get(key);
+                    conditionMap.put(key, this.getNewCondition(dto, entity, type));
+                } else {
+                    conditionMap.put(key, this.getNewCondition(entity, type));
+                }
+            } else {
+                conditionMap.put(key, this.getNewCondition(entity, type));
+            }
+        }
+        for (Condition1Dto dto : conditionMap.values()) {
+            dtoList.add(dto);
+        }
+        Map<String, Object> unitMap = new HashMap<>(16);
+        String value = "";
+        if (type == 1) {
+            value = "学前";
+        } else if (type == 2) {
+            value = "单元";
+        } else if (type == 3) {
+            value = "期中";
+        }
+        unitMap.put("type", type);
+        unitMap.put("value", value);
+        unitMap.put("gradeList", dtoList);
+        return unitMap;
+    }
+
+    /**
+     * 生成一个全新的对象
+     * @param entity
+     * @return
+     */
+    private Condition1Dto getNewCondition(OpenTestUnit entity, int type) {
+        Condition1Dto dto = new Condition1Dto();
+        dto.setGrade(entity.getGrade());
+        List<Condition1Dto.Subject> subjectList = new ArrayList<>();
+        //年级下设置科目
+        Condition1Dto.Subject subjectDto = dto.new Subject();
+        subjectDto.setSubject(entity.getSubject());
+        //科目下设置类型：只有语文有专题和同步，其余科目都只有同步
+        List<Condition1Dto.Subject.Type> typeList = new ArrayList<>();
+        if ("语文".equals(entity.getSubject())) {
+            Condition1Dto.Subject.Type type1Dto = subjectDto.new Type();
+            type1Dto.setType("同步");
+            Condition1Dto.Subject.Type type2Dto = subjectDto.new Type();
+            type2Dto.setType("专题");
+            typeList.add(type1Dto);
+            typeList.add(type2Dto);
+        } else {
+            Condition1Dto.Subject.Type type1Dto = subjectDto.new Type();
+            type1Dto.setType("同步");
+            typeList.add(type1Dto);
+        }
+        subjectDto.setTypeList(typeList);
+        //科目下设置版本
+        List<Condition1Dto.Subject.Version> versionList = new ArrayList<>();
+        Condition1Dto.Subject.Version versionDto = subjectDto.new Version();
+        versionDto.setVersion(entity.getVersionName());
+        //版本下设置学期
+        List<Condition1Dto.Subject.Version.Semester> semesterList = new ArrayList<>();
+        Condition1Dto.Subject.Version.Semester semesterDto = versionDto.new Semester();
+        semesterDto.setSemester(entity.getSemester() == 1 ? "第一学期" : "第二学期");
+
+        List<Condition1Dto.Subject.Version.Semester.Unit> unitList = new ArrayList<>();
+        //单元测评
+        if (type == 2) {
+            //学期下设置单元
+            Condition1Dto.Subject.Version.Semester.Unit unitDto = semesterDto.new Unit();
+            unitDto.setUnit(entity.getUnit());
+            unitList.add(unitDto);
+        }
+
+        semesterDto.setUnitList(unitList);
+        semesterList.add(semesterDto);
+
+        versionDto.setSemesterList(semesterList);
+        versionList.add(versionDto);
+        subjectDto.setVersionList(versionList);
+        //添加科目实例
+        subjectList.add(subjectDto);
+        dto.setSubjectList(subjectList);
+        return dto;
+    }
+
+    /**
+     * 在旧对象上添加
+     * @param dto
+     * @param entity
+     * @return
+     */
+    private Condition1Dto getNewCondition(Condition1Dto dto, OpenTestUnit entity, int type) {
+        List<Condition1Dto.Subject> subjectList = dto.getSubjectList();
+        boolean addSubject = true;
+        boolean addVersion = true;
+        boolean addSemester = true;
+        Condition1Dto.Subject subjectDto;
+        //年级下设置科目,如果科目一样则不再添加新科目
+        if (subjectList.get(subjectList.size() - 1).getSubject().equals(entity.getSubject())) {
+            subjectDto = subjectList.get(subjectList.size() - 1);
+            addSubject = false;
+        } else {
+            subjectDto = dto.new Subject();
+            subjectDto.setVersionList(new ArrayList<>());
+            subjectDto.setSubject(entity.getSubject());
+        }
+        //科目下设置类型：只有语文有专题和同步，其余科目都只有同步
+        List<Condition1Dto.Subject.Type> typeList = new ArrayList<>();
+        if("语文".equals(entity.getSubject())){
+            Condition1Dto.Subject.Type type1Dto = subjectDto.new Type();
+            type1Dto.setType("同步");
+            Condition1Dto.Subject.Type type2Dto = subjectDto.new Type();
+            type2Dto.setType("专题");
+            typeList.add(type1Dto);
+            typeList.add(type2Dto);
+        }else{
+            Condition1Dto.Subject.Type type1Dto = subjectDto.new Type();
+            type1Dto.setType("同步");
+            typeList.add(type1Dto);
+        }
+        subjectDto.setTypeList(typeList);
+        //科目下设置版本
+        List<Condition1Dto.Subject.Version> versionList = subjectDto.getVersionList();
+        Condition1Dto.Subject.Version versionDto;
+
+        //版本一样则不再添加版本
+        if (versionList.size() > 0 && versionList.get(versionList.size() - 1).getVersion().equals(entity.getVersionName())) {
+            versionDto = subjectDto.getVersionList().get(versionList.size() - 1);
+            addVersion = false;
+        } else {
+            versionDto = subjectDto.new Version();
+            versionDto.setVersion(entity.getVersionName());
+            versionDto.setSemesterList(new ArrayList<>());
+        }
+        //版本下设置学期
+        List<Condition1Dto.Subject.Version.Semester> semesterList = versionDto.getSemesterList();
+        Condition1Dto.Subject.Version.Semester semesterDto;
+        //学期一样则不再添加学期
+        if (semesterList.size() > 0 && semesterList.get(semesterList.size() - 1).getSemester().equals(entity.getSemester() == 1 ? "第一学期" : "第二学期")) {
+            semesterDto = versionDto.getSemesterList().get(semesterList.size() - 1);
+            addSemester = false;
+        } else {
+            semesterDto = versionDto.new Semester();
+            semesterDto.setSemester(entity.getSemester() == 1 ? "第一学期" : "第二学期");
+            semesterDto.setUnitList(new ArrayList<>());
+        }
+
+        if (type == 2) {
+            //版本下设置单元
+            List<Condition1Dto.Subject.Version.Semester.Unit> unitList = semesterDto.getUnitList();
+            Condition1Dto.Subject.Version.Semester.Unit unitDto = semesterDto.new Unit();
+            unitDto.setUnit(entity.getUnit());
+            unitList.add(unitDto);
+            semesterDto.setUnitList(unitList);
+        }
+
+        //无学期则添加新的
+        if (addSemester) {
+            semesterList.add(semesterDto);
+            versionDto.setSemesterList(semesterList);
+        }
+        //无版本则添加新的
+        if (addVersion) {
+            versionList.add(versionDto);
+            subjectDto.setVersionList(versionList);
+        }
+        //无科目则填加新的
+        if(addSubject){
+            subjectList.add(subjectDto);
+            dto.setSubjectList(subjectList);
+        }
+        return dto;
+    }
+
+    @Override
+    public ResponseEntity getKnowledge(GetKnowledgeReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        List<KnowledgeDto> dtoList = new ArrayList<>();
+        Map<String, Object> data = new HashMap<>(16);
+        Map<String, Object> params = new HashMap<>(16);
+        List<KnowledgeMBDto> knowledgeDtoList;
+        if ("同步".equals(req.getType())) {
+            List<OpenTestUnit> list = openTestUnitService.findUnit(req.getGrade(), req.getSubject(), req.getVersion(), req.getUnit(), req.getSemester(), req.getType1());
+            if (CollectionUtils.isNotEmpty(list)) {
+                List<String> howIds = new ArrayList<>();
+                list.forEach(e -> {
+                    //非单元测评
+                    if (req.getType1() != 2) {
+                        if(StringUtil.isNotBlank(e.getHowId())){
+                            if (StringUtil.isNotBlank(e.getHowId())) {
+                                howIds.addAll(Arrays.asList(e.getHowId().split(",")));
+                            }
+                        }
+                    } else {
+                        howIds.add(e.getHowId());
+                    }
+                });
+                params.put("subject", req.getSubject());
+                params.put("grade", req.getGrade());
+                params.put("semester", req.getUnit().contains("第一学期") ? 1 : 2);
+                params.put("version", list.get(0).getVersionType());
+                params.put("howIds", howIds);
+                knowledgeDtoList = recordQuestionMapper.findKnowledgeList(params);
+                knowledgeDtoList.forEach(e -> {
+                    KnowledgeDto dto = new KnowledgeDto();
+                    dto.setName(e.getName());
+                    dto.setKnowledgeList(new ArrayList<>());
+                    dtoList.add(dto);
+                });
+            }
+        } else {
+            params.put("grade", req.getGrade());
+            params.put("semester", req.getUnit().contains("第一学期") ? 1 : 2);
+            //专题知识点显示所有
+            knowledgeDtoList = recordQuestionMapper.findZtKnowledgeList(params);
+            Map<String, KnowledgeDto> knowledgeDtoMap = new LinkedHashMap();
+            for (int i = 0; i < knowledgeDtoList.size(); i++) {
+                KnowledgeMBDto entity = knowledgeDtoList.get(i);
+                String key = entity.getModule();
+                if (i > 0) {
+                    //去重科目
+                    if (entity.getModule().equals(knowledgeDtoList.get(i - 1).getModule())) {
+                        KnowledgeDto dto = knowledgeDtoMap.get(key);
+                        List<KnowledgeDto.Knowledge> knowledgeList = dto.getKnowledgeList();
+                        KnowledgeDto.Knowledge knowledge = dto.new Knowledge();
+                        knowledge.setName(entity.getName());
+                        knowledgeList.add(knowledge);
+                        dto.setKnowledgeList(knowledgeList);
+                        knowledgeDtoMap.put(key, dto);
+                    } else {
+                        KnowledgeDto dto = new KnowledgeDto();
+                        dto.setName(entity.getModule());
+                        KnowledgeDto.Knowledge knowledge = dto.new Knowledge();
+                        knowledge.setName(entity.getName());
+                        List<KnowledgeDto.Knowledge> knowledgeList = new ArrayList<>();
+                        knowledgeList.add(knowledge);
+                        dto.setKnowledgeList(knowledgeList);
+                        knowledgeDtoMap.put(key, dto);
+                    }
+                } else {
+                    KnowledgeDto dto = new KnowledgeDto();
+                    dto.setName(entity.getModule());
+                    KnowledgeDto.Knowledge knowledge = dto.new Knowledge();
+                    knowledge.setName(entity.getName());
+                    List<KnowledgeDto.Knowledge> knowledgeList = new ArrayList<>();
+                    knowledgeList.add(knowledge);
+                    dto.setKnowledgeList(knowledgeList);
+                    knowledgeDtoMap.put(key, dto);
+                }
+            }
+            for (KnowledgeDto dto : knowledgeDtoMap.values()) {
+                dtoList.add(dto);
+            }
+        }
+        data.put("list", dtoList);
+        return responseEntity.success(data, "成功");
+    }
+
+    @Override
+    public ResponseEntity publishQuestion(PublishReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        List<OpenTestQuestion> questionList = openTestQuestionService.findQuestionList(req.getSubject(), req.getGrade(), req.getVersion(), req.getUnit(), 0, req.getType(), req.getSemester());
+        if (CollectionUtils.isNotEmpty(questionList)) {
+            questionList.forEach(e -> {
+                e.setUpdateVersion(1);
+            });
+            openTestQuestionService.save(questionList);
+        }
+        //发布完相应显示对应单元
+        List<OpenTestUnit> unitList = openTestUnitService.findUnit(req.getGrade(), req.getSubject(), req.getVersion(), req.getUnit(), req.getSemester(), req.getType(), 0);
+        if (CollectionUtils.isNotEmpty(unitList)) {
+            unitList.forEach(e -> {
+                e.setIsValid(1);
+            });
+            openTestUnitService.save(unitList);
+            tokenManager.delString("/api/recordQuestionSys/getConditionInfo/valid");
+            //tokenManager.delString("/api/xiaoshuTest/getConditionInfo");
+        }
+        return responseEntity.success("发布成功");
+    }
+
+    @Override
+    public void updateHowId() {
+        //单元测评
+        List<OpenTestUnit> list = openTestUnitDao.findByHowIdIsNullAndType(2);
+        for (OpenTestUnit unit : list) {
+            ZuoybKnowHowDetailsSort zuoybKnowHowDetailsSort = zuoybKnowHowDetailsSortDao.findKnowHow(unit.getGrade(), unit.getSubject(), unit.getVersionType(), unit.getSemester(), unit.getKmtUnit());
+            if(zuoybKnowHowDetailsSort!=null){
+                unit.setHowId(zuoybKnowHowDetailsSort.getHowId());
+                openTestUnitService.save(unit);
+            }
+        }
+        //期中测评
+        List<OpenTestUnit> list1 = openTestUnitDao.findByHowIdIsNullAndType(3);
+        for (OpenTestUnit unit : list1) {
+            String[] units = unit.getUnit().split("#S");
+            String howIds = "";
+            for (String s : units) {
+                List<OpenTestUnit> list2 = openTestUnitDao.findUnitRegexp(unit.getGrade(), unit.getSubject(), unit.getVersionName(), s, unit.getSemester(), 2);
+                for (OpenTestUnit e : list2) {
+                    if (StringUtil.isNotBlank(e.getHowId())) {
+                        if (StringUtil.isBlank(howIds)) {
+                            howIds = e.getHowId();
+                        } else {
+                            howIds += "," + e.getHowId();
+                        }
+                    }
+                }
+                if (StringUtil.isNotBlank(howIds)) {
+                    unit.setHowId(howIds);
+                    openTestUnitService.save(unit);
+                }
+            }
+        }
+    }
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/teacher/service/impl/ApplyTeacherServiceImpl.java

@@ -0,0 +1,174 @@
+package com.ssj.service.conch.teacher.service.impl;
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.transaction.annotation.Transactional;
+
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.teacher.domain.ApplyTeacher;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.dao.sys.teacher.dao.IApplyTeacherDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.persistence.DynamicSpecifications;
+import com.ssj.framework.core.persistence.SearchFilter;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.service.conch.teacher.request.oneonly.ApplyTeacherReq;
+import com.ssj.service.conch.teacher.request.oneonly.TeacherImgVO;
+import com.ssj.service.conch.teacher.service.IApplyTeachService;
+import com.ssj.service.weixin.library.service.IBookManagerService;
+import com.ssj.service.weixin.user.service.UserService;
+
+@Service(version ="1.0")
+@Transactional
+public class ApplyTeacherServiceImpl extends BaseServiceImpl<ApplyTeacher, String> implements IApplyTeachService {
+
+	@Autowired
+	private IApplyTeacherDao dao;
+	
+	@Autowired
+    private TokenManager tokenManager;
+	
+	@Autowired
+	private IBookManagerService managerService;
+	
+	@Autowired
+	private UserService userService;
+	
+	@Override
+	public PagingAndSortingRepository<ApplyTeacher, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public ResponseEntity applyTeacher(ApplyTeacherReq request, String accessToken) {
+		ResponseEntity response = new ResponseEntity();
+		//查询是否有数据
+		String userId = tokenManager.getUserId(accessToken);
+		User user = userService.getById(userId);
+		ApplyTeacher teacher = dao.findTeacherByUserId(userId);
+
+		//将科目列表拼成分号隔开的字符串
+		StringBuilder subjects = new StringBuilder();
+		if (request.getSubjects() != null){
+			request.getSubjects().forEach((subject) -> {
+				if (subject.getActive() == 2){
+					subjects.append(subject.getName()).append(";");
+				}
+			});
+		}
+		//如果有科目,删除最后一个分号
+		if (subjects.length() > 0){
+			subjects.deleteCharAt(subjects.length() - 1);
+		}
+
+		if(teacher == null){ //新增
+			teacher = new ApplyTeacher();
+			teacher.setHeadPicUrl(request.getHeadPicUrl()==null?user.getPhoto():request.getHeadPicUrl());
+			teacher.setRealName(request.getRealName());
+			teacher.setSex(request.getSex());
+			teacher.setSubject(subjects.toString());
+			List<TeacherImgVO> imgList = request.getTeacherImgList();
+			List<String> list1 = new ArrayList<String>();
+			List<String> list2 = new ArrayList<String>();
+			for(TeacherImgVO vo:imgList){
+				if(vo.getType() == 1){
+					list1.add(vo.getFileKey());
+				}else{
+					list2.add(vo.getFileKey());
+				}
+			}
+			teacher.setTeacherImg(StringUtils.join(list2, ",")); //正反面
+			teacher.setTitleImg(StringUtils.join(list1, ",")); //资格证
+			teacher.setCreateTime(new Date());
+			teacher.setConcatPhone(request.getConcatPhone());
+			teacher.setSchoolAge(request.getSchoolAge());
+			teacher.setPersonalLabel(StringUtils.join(request.getPersonalLabel().toArray(), ","));
+			teacher.setPersonalInfo(request.getPersonalInfo());
+			teacher.setSuccessfulCase(request.getSuccessfulCase());
+			teacher.setTeachPoint(request.getTeachPoint());
+			teacher.setUserId(user.getId());
+			teacher.setAuditState("1");
+			this.save(teacher);
+		}else{ //修改 联系方式、教龄时间、个人标签、个人简介、教学特征、成功案例。
+			//如果是审核通过的数据，同步更新tb_lib_manager 表的教师信息
+			if(teacher.getAuditState().equals("3")){ //审核不通过
+				teacher = new ApplyTeacher();
+				teacher.setHeadPicUrl(request.getHeadPicUrl()==null?user.getPhoto():request.getHeadPicUrl());
+				teacher.setRealName(request.getRealName());
+				teacher.setSex(request.getSex());
+				teacher.setSubject(subjects.toString());
+				List<TeacherImgVO> imgList = request.getTeacherImgList();
+				List<String> list1 = new ArrayList<String>();
+				List<String> list2 = new ArrayList<String>();
+				for(TeacherImgVO vo:imgList){
+					if(vo.getType() == 1){
+						list1.add(vo.getFileKey());
+					}else{
+						list2.add(vo.getFileKey());
+					}
+				}
+				teacher.setTeacherImg(StringUtils.join(list2, ",")); //正反面
+				teacher.setTitleImg(StringUtils.join(list1, ",")); //资格证
+				teacher.setCreateTime(new Date());
+				teacher.setConcatPhone(request.getConcatPhone());
+				teacher.setSchoolAge(request.getSchoolAge());
+				teacher.setPersonalLabel(StringUtils.join(request.getPersonalLabel().toArray(), ","));
+				teacher.setPersonalInfo(request.getPersonalInfo());
+				teacher.setSuccessfulCase(request.getSuccessfulCase());
+				teacher.setTeachPoint(request.getTeachPoint());
+				teacher.setUserId(user.getId());
+				teacher.setAuditState("1");
+				this.save(teacher);
+			}else{
+				teacher.setHeadPicUrl(request.getHeadPicUrl()==null?user.getPhoto():request.getHeadPicUrl());
+				teacher.setConcatPhone(request.getConcatPhone());
+				teacher.setSchoolAge(request.getSchoolAge());
+				teacher.setPersonalLabel(StringUtils.join(request.getPersonalLabel().toArray(), ","));
+				teacher.setPersonalInfo(request.getPersonalInfo());
+				teacher.setSuccessfulCase(request.getSuccessfulCase());
+				teacher.setTeachPoint(request.getTeachPoint());
+				teacher.setUpdateTime(new Date());
+				this.save(teacher);
+				TbLibManager manager = managerService.findByUserId(userId, 7);
+				if(manager !=null){
+					manager.setTelephone(request.getConcatPhone());
+					manager.setSchoolAge(request.getSchoolAge());
+					manager.settPhoto(request.getHeadPicUrl()==null?user.getPhoto():request.getHeadPicUrl());
+					manager.setPersonalInfo(teacher.getPersonalInfo());
+					manager.setPersonalLabel(teacher.getPersonalLabel());
+					manager.setSuccessfulCase(teacher.getSuccessfulCase());
+					manager.setTeachPoint(teacher.getTeachPoint());
+					manager.setSchoolAge(teacher.getSchoolAge());
+					managerService.save(manager);
+				}
+			}	
+		}
+		response.success();
+		return response;
+	}
+
+	@Override
+	public ApplyTeacher findInfoByUserId(String userId) {
+		
+		return dao.findTeacherByUserId(userId);
+	}
+
+	@Override
+	public Page<ApplyTeacher> findByPage(Map<String, Object> params, Pageable initPage) {
+		 Map<String, SearchFilter> filters = SearchFilter.parse(params);
+			Specification<ApplyTeacher> specification = DynamicSpecifications.bySearchFilter(filters.values(), ApplyTeacher.class);    
+			return  dao.findAll(specification, initPage);
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/teacher/service/impl/TeacherOrgServiceImpl.java

@@ -0,0 +1,938 @@
+package com.ssj.service.conch.teacher.service.impl;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+import com.ssj.framework.core.util.PropertiesUtil;
+import com.ssj.service.conch.teacher.dto.NewMyInfoDto;
+import com.ssj.service.mapper.LibManagerMapper;
+import com.ssj.service.weixin.library.dto.SubjectMyInfoDto;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestionKnow;
+import com.ssj.bean.kmt.kmt.domain.KmtHomeworkWrongQuestion;
+import com.ssj.bean.sys.homework.domain.Homework;
+import com.ssj.bean.sys.homework.domain.HomeworkHowDetail;
+import com.ssj.bean.sys.homework.domain.HomeworkPicture;
+import com.ssj.bean.sys.organization.domain.OrgTeacher;
+import com.ssj.bean.sys.problem.domain.ProblemPicture;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.bean.weixin.libmy.domain.LibVipBind;
+import com.ssj.bean.weixin.libmy.domain.TbLibJoin;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.bean.weixin.libmy.domain.TbLibManagerAudit;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.bean.weixin.zyb.domain.ZuoybKnowHowDetails;
+import com.ssj.bean.weixin.zyb.domain.ZuoybKnowHowDetailsSort;
+import com.ssj.dao.sys.problem.dao.ProblemPictureDao;
+import com.ssj.dao.sys.problem.dao.ProblemPictureQueryDao;
+import com.ssj.dao.weixin.library.dao.LibManagerAuditDao;
+import com.ssj.dao.weixin.library.dao.LibVipBindDao;
+import com.ssj.dao.weixin.library.dao.LibVipDao;
+import com.ssj.dao.weixin.zuoyb.dao.ZuoybQueryDao;
+
+import com.ssj.framework.core.security.exception.CommonException;
+import com.ssj.framework.core.util.Constant;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.service.conch.teacher.dto.KownHowDto;
+import com.ssj.service.conch.teacher.dto.MyInfoDto;
+import com.ssj.service.conch.teacher.request.teacherorg.AnsweredProblemReq;
+import com.ssj.service.conch.teacher.request.teacherorg.CorrectRequest;
+import com.ssj.service.conch.teacher.request.teacherorg.CorrectedPictureUrlRequest;
+import com.ssj.service.conch.teacher.request.teacherorg.HomeworkReportReq;
+import com.ssj.service.conch.teacher.request.teacherorg.HomeworkTaskReq;
+import com.ssj.service.conch.teacher.request.teacherorg.KnowListReq;
+import com.ssj.service.conch.teacher.request.teacherorg.OrganizationListReq;
+import com.ssj.service.conch.common.request.PageReq;
+import com.ssj.service.conch.teacher.request.teacherorg.SaveAnswerReq;
+import com.ssj.service.conch.teacher.request.teacherorg.SaveInfoReq;
+import com.ssj.service.conch.teacher.request.teacherorg.SwipeBindingReq;
+import com.ssj.service.conch.teacher.service.TeacherOrgService;
+import com.ssj.service.conch.teacher.service.TeacherService;
+import com.ssj.service.kmt.dto.ExerciseBookDto;
+import com.ssj.service.kmt.dto.ExerciseQuestionAnswer4CorrectDTO;
+import com.ssj.service.kmt.enums.HomeworkWrongQuestionTypeEnum;
+import com.ssj.service.kmt.request.AnswerSearchRequest;
+import com.ssj.service.kmt.request.ExerciseConditionRequest;
+import com.ssj.service.kmt.request.WrongQuestionRequest;
+import com.ssj.service.kmt.service.KmtCorrectHomeworkService;
+import com.ssj.service.kmt.service.KmtExerciseBookCourseService;
+import com.ssj.service.kmt.service.KmtExerciseQuestionKnowService;
+import com.ssj.service.kmt.service.KmtExerciseQuestionService;
+import com.ssj.service.kmt.service.KmtHomeworkWrongQuestionService;
+import com.ssj.service.sys.homework.service.HomeworkHowDetailsService;
+import com.ssj.service.sys.homework.service.HomeworkPictureService;
+import com.ssj.service.sys.homework.service.HomeworkService;
+import com.ssj.service.sys.organization.service.OrgTeacherService;
+import com.ssj.service.sys.problem.service.IBanbenDetailService;
+import com.ssj.service.sys.problem.service.ProblemPictureService;
+import com.ssj.service.weixin.library.service.IBookManagerService;
+import com.ssj.service.weixin.library.service.ILibJoinService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import com.ssj.service.weixin.library.service.LibManagerAuditService;
+import com.ssj.service.weixin.library.service.LibVipBindService;
+import com.ssj.service.weixin.user.service.UserService;
+import com.ssj.service.weixin.zuoyb.service.ZuoybKnowHowDetailsService;
+import com.ssj.service.weixin.zuoyb.service.ZuoybKnowHowDetailsSortService;
+
+/**
+ * @author Mount Liu
+ * @version 2019/2/28
+ */
+@Service(version="1.0")
+@Transactional
+public class TeacherOrgServiceImpl implements TeacherOrgService {
+
+    private   Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @Autowired
+    private LibManagerAuditService libManagerAuditService;
+
+    @Autowired
+    private LibManagerAuditDao libManagerAuditDao;
+
+    @Autowired
+    private IBookManagerService iBookManagerService;
+
+    @Autowired
+    private OrgTeacherService orgTeacherService;
+
+    @Autowired
+    private LibVipBindDao libVipBindDao;
+
+    @Autowired
+    private LibVipBindService libVipBindService;
+
+    @Autowired
+    private ProblemPictureService problemPictureService;
+
+    @Autowired
+    private ProblemPictureDao problemPictureDao;
+
+    @Autowired
+    private ProblemPictureQueryDao problemPictureQueryDao;
+
+    @Autowired
+    private ZuoybQueryDao zuoybQueryDao;
+
+    @Autowired
+    private ILibVipService libVipService;
+
+    @Autowired
+    private ZuoybKnowHowDetailsService zuoybKnowHowDetailsService;
+
+    @Autowired
+    private LibVipDao libVipDao;
+
+    @Autowired
+    private UserService userService;
+    @Autowired
+    private HomeworkPictureService homeworkPictureService;
+    @Autowired
+    private HomeworkService homeworkService;
+    @Autowired
+    private TeacherService teacherService;
+    @Autowired
+    private KmtCorrectHomeworkService kmtCorrectHomeworkService;
+    @Autowired
+    private KmtExerciseBookCourseService kmtExerciseBookCourseService;
+    @Autowired
+    private KmtExerciseQuestionService kmtExerciseQuestionService;
+    @Autowired
+    private KmtHomeworkWrongQuestionService kmtHomeworkWrongQuestionService;
+    @Autowired
+    private HomeworkHowDetailsService homeworkHowDetailsService;
+    @Autowired
+    private KmtExerciseQuestionKnowService kmtExerciseQuestionKnowService;
+
+
+    @Autowired
+    private IBanbenDetailService banbenDetailService;
+
+    @Autowired
+    private ZuoybKnowHowDetailsSortService zuoybKnowHowDetailsSortService;
+    @Autowired
+    private IBookManagerService bookManagerService;
+
+    @Autowired
+    private ILibJoinService libJoinService;
+
+    @Autowired
+    private LibManagerMapper libManagerMapper;
+
+    @Override
+    public ResponseEntity saveInfo(String userId, SaveInfoReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        //机构信息
+        OrgTeacher orgTeacher = orgTeacherService.getById(req.getOrgId());
+        TbLibManager tbLibManager = iBookManagerService.findAllByUserIdAndType(userId, 10);
+        if (tbLibManager == null) {
+            tbLibManager = new TbLibManager();
+            tbLibManager.setState(2);
+            tbLibManager.setType(10);
+            tbLibManager.setCreateTime(new Date());
+            tbLibManager.setUserId(userId);
+            /*tbLibManager.setName(req.getName());
+            tbLibManager.setSex(req.getSex());
+            tbLibManager.setTelephone(req.getTelephone());
+            tbLibManager.setCourseName(req.getCourse());
+            tbLibManager.setAddress(orgTeacher.getAddress());
+            tbLibManager.setOrgId(req.getOrgId());
+            tbLibManager.setOrgName(orgTeacher.getName());
+            tbLibManager.setCertification(req.getCertification());
+            tbLibManager.setIdFace(req.getIdFace());
+            tbLibManager.setIdCon(req.getIdCon());
+            User user = userService.getById(userId);
+            tbLibManager.settPhoto(user.getPhoto());*/
+            //更新头像，使用用户选择的头像或者用户微信头像
+            if (StringUtil.isBlank(req.getPhoto())) {
+                User user = userService.getById(userId);
+                tbLibManager.settPhoto(user.getPhoto());
+            } else {
+                tbLibManager.settPhoto(req.getPhoto());
+            }
+            iBookManagerService.save(tbLibManager);
+        } else {
+            //更新头像
+            if (StringUtil.isNotBlank(req.getPhoto())) {
+                tbLibManager.settPhoto(req.getPhoto());
+                iBookManagerService.save(tbLibManager);
+            }
+        }
+        TbLibManagerAudit tbLibManagerAudit = new TbLibManagerAudit();
+        tbLibManagerAudit.setLibManagerId(tbLibManager.getId());
+        tbLibManagerAudit.setName(req.getName());
+        tbLibManagerAudit.setSex(req.getSex());
+        tbLibManagerAudit.setTelephone(req.getTelephone());
+        tbLibManagerAudit.setSubject(req.getCourse());
+        //机构老师为10，同tb_lib_manager.type
+        tbLibManagerAudit.setType(10);
+        //状态：审核中
+        tbLibManagerAudit.setStatus(3);
+        tbLibManagerAudit.setCreateTime(new Date());
+        tbLibManagerAudit.setLon(orgTeacher.getLon());
+        tbLibManagerAudit.setLat(orgTeacher.getLat());
+        tbLibManagerAudit.setAddress(orgTeacher.getAddress());
+        tbLibManagerAudit.setOrgId(orgTeacher.getId());
+        tbLibManagerAudit.setOrgName(orgTeacher.getName());
+        tbLibManagerAudit.setCertification(req.getCertification());
+        tbLibManagerAudit.setIdFace(req.getIdFace());
+        tbLibManagerAudit.setIdCon(req.getIdCon());
+        tbLibManagerAudit.setUserId(userId);
+        //保存审批老师信息
+        libManagerAuditService.save(tbLibManagerAudit);
+        responseEntity.success("保存成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity getMyInfo(String userId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        MyInfoDto dto = new MyInfoDto();
+        //查询该机构老师数据，包含无效的
+        TbLibManager teacher = iBookManagerService.findAllByUserIdAndType(userId, 10);
+        if (teacher == null) {
+            teacher = new TbLibManager();
+            teacher.setUserId(userId);
+            teacher.setType(10);
+            teacher.setState(2);
+            teacher.setCreateTime(new Date());
+            User user = userService.getById(userId);
+            teacher.settPhoto(user.getPhoto());
+            iBookManagerService.save(teacher);
+        }else{
+            //没有头像自动更新头像
+            if(StringUtil.isBlank(teacher.gettPhoto())){
+                User user = userService.getById(userId);
+                teacher.settPhoto(user.getPhoto());
+                iBookManagerService.save(teacher);
+            }
+        }
+        //审批记录信息
+        List<TbLibManagerAudit> auditList = libManagerAuditDao.findByLibManagerIdOrderByCreateTimeDesc(teacher.getId());
+        //isFirst=1的情况：1.没有审批记录；2.审批记录是“审批拒绝”和“审核中”（所有审批记录都是被拒绝；审批记录有且只有一条为“审核中”）
+        int isFirst = 0;
+        int approveStatus = 0;
+        int i = 0;
+        //最新的一条审批记录
+        TbLibManagerAudit topAudit = null;
+        if (CollectionUtils.isNotEmpty(auditList)) {
+            for (TbLibManagerAudit audit : auditList) {
+                if (audit.getStatus() == 1) {
+                    i++;
+                }
+            }
+            //第2种情况
+            if (i == 0) {
+                isFirst = 1;
+            }
+            topAudit = auditList.get(0);
+            approveStatus = topAudit.getStatus();
+        } else {
+            //第1种情况
+            isFirst = 1;
+        }
+        //第一次注册，返回提交的资料
+        if (isFirst == 1 && topAudit != null) {
+            dto.setName(topAudit.getName());
+            dto.setSex(topAudit.getSex());
+            dto.setTelephone(topAudit.getTelephone());
+            dto.setOrgId(topAudit.getOrgId());
+            dto.setOrganization(topAudit.getOrgName());
+            dto.setCourse(topAudit.getSubject());
+            dto.setStudentCount(0);
+            dto.setCertification(topAudit.getCertification());
+            dto.setIdFace(topAudit.getIdFace());
+            dto.setIdCon(topAudit.getIdCon());
+        }else{
+            dto.setName(teacher.getName());
+            dto.setSex(teacher.getSex() == null ? 0 : teacher.getSex());
+            dto.setTelephone(teacher.getTelephone());
+            dto.setOrgId(teacher.getOrgId());
+            dto.setOrganization(teacher.getOrgName());
+            dto.setCourse(teacher.getCourseName());
+            dto.setStudentCount(libVipBindDao.countByTeacherIdAndVipIdIsNotNull(teacher.getUserId()));
+            dto.setCertification(teacher.getCertification());
+            dto.setIdFace(teacher.getIdFace());
+            dto.setIdCon(teacher.getIdCon());
+        }
+        dto.setPhoto(teacher.gettPhoto());
+        dto.setApproveStatus(approveStatus);
+        dto.setIsFirst(isFirst);
+        responseEntity.success(dto, "成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity getMyInfoV1(String userId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        MyInfoDto dto = new MyInfoDto();
+        //查询该机构老师数据
+        TbLibManager teacher = iBookManagerService.findAllByUserIdAndTypeAndState(userId, 10, 1);
+        if (teacher == null) {
+            return responseEntity.failure("无此身份");
+        } else {
+            //没有头像自动更新头像
+            if (StringUtil.isBlank(teacher.gettPhoto())) {
+                User user = userService.getById(userId);
+                teacher.settPhoto(user.getPhoto());
+                iBookManagerService.save(teacher);
+            }
+        }
+        dto.setName(teacher.getName());
+        dto.setSex(teacher.getSex() == null ? 0 : teacher.getSex());
+        dto.setTelephone(teacher.getTelephone());
+        TbLibJoin libJoin = libJoinService.getById(teacher.getLibId());
+        dto.setOrgId(teacher.getLibId());
+        dto.setOrganization(libJoin != null ? libJoin.getLeagueName() : null);
+        dto.setCourse(teacher.getCourseName());
+        //dto.setStudentCount(libVipBindDao.countByTeacherIdAndVipIdIsNotNull(teacher.getUserId()));
+        dto.setCertification(teacher.getCertification());
+        dto.setIdFace(teacher.getIdFace());
+        dto.setIdCon(teacher.getIdCon());
+        dto.setPhoto(teacher.gettPhoto());
+        dto.setApproveStatus(1);
+        dto.setIsFirst(0);
+        responseEntity.success(dto, "成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity newGetMyInfo(String userId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        NewMyInfoDto dto = new NewMyInfoDto();
+        List<SubjectMyInfoDto> dtoList = libManagerMapper.findSubjectMyInfo(userId, Constant.ORG_TEACHER_TYPE);
+        if(CollectionUtils.isEmpty(dtoList)) {
+            return responseEntity.failure("无此身份");
+        }
+        SubjectMyInfoDto subjectDto = dtoList.get(0);
+        dto.setName(subjectDto.getName());
+        dto.setPhoto(subjectDto.getPhoto());
+        dto.setTelephone(subjectDto.getTelephone());
+
+        StringBuffer sb = new StringBuffer();
+        Set<String> set = new LinkedHashSet<>();
+        for (SubjectMyInfoDto subjectMyInfoDto:dtoList) {
+            if(StringUtils.isNotBlank(subjectMyInfoDto.getCourseName())) {
+                List<String> subList = Arrays.asList(subjectMyInfoDto.getCourseName().split(","));
+                if(CollectionUtils.isNotEmpty(subList)) {
+                    for (String str:subList) {
+                        set.add(str);
+                    }
+                }
+            }
+            sb.append(subjectMyInfoDto.getLeagueName()).append(",");
+        }
+        dto.setLeagueName(sb.substring(0,sb.length()-1));
+        //科目汇总
+        String course = set.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(","));
+        dto.setCourse(course);
+        responseEntity.success(dto, "成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity unAnsweredProblemList(String userId, Pageable pageable, PageReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>(16);
+        //查找难题列表
+        Map<String, Object> searchParams = new HashMap<>();
+        searchParams.put("type", 0);
+        searchParams.put("teacherId", userId);
+        searchParams.put("maxCreateTime", req.getMaxCreateTime());
+        searchParams.put("vipId","no_need");
+        List<Map<String, Object>> list = new ArrayList<>();
+        Page<Map<String, Object>> page = problemPictureQueryDao.findProblemListOfParent(searchParams, pageable);
+        if (page.getSize() > 0) {
+            for (Map<String, Object> pageMap : page.getContent()) {
+                Map<String, Object> map = new HashMap<>();
+                map.put("vipId", pageMap.get("vip_id"));
+                map.put("photo", pageMap.get("img_url"));
+                map.put("name", pageMap.get("child_name"));
+                map.put("problemId", pageMap.get("id"));
+                map.put("fileKey", pageMap.get("file_key"));
+                map.put("createTime", pageMap.get("create_time"));
+                list.add(map);
+            }
+        }
+        data.put("pages", page.getSize());
+        data.put("pageNo", req.getPageNo());
+        data.put("pageSize", req.getPageSize());
+        data.put("list", list);
+        responseEntity.success(data, "成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity answeredProblemList(String userId, Pageable pageable, AnsweredProblemReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>(16);
+        //查找难题列表
+        Map<String, Object> searchParams = new HashMap<>(16);
+        searchParams.put("type", 1);
+        searchParams.put("teacherId", userId);
+        searchParams.put("maxCreateTime", req.getMaxCreateTime());
+        Date now = new Date();
+        searchParams.put("feedbackStartTime", DateUtil.format_yyyyMMdd(DateUtil.addDays(now, -7)));
+        searchParams.put("feedbackEndTime", DateUtil.format_yyyyMMdd(DateUtil.addDays(now, 1)));
+        if(StringUtil.isNotBlank(req.getVipId())){
+            searchParams.put("vipId", req.getVipId());
+        }else{
+            searchParams.put("vipId","no_need");
+        }
+        List<Map<String, Object>> list = new ArrayList<>();
+        Page<Map<String, Object>> page = problemPictureQueryDao.findProblemListOfParent(searchParams, pageable);
+        if (page.getSize() > 0) {
+            for (Map<String, Object> pageMap : page.getContent()) {
+                Map<String, Object> map = new HashMap<>();
+                map.put("photo", pageMap.get("img_url"));
+                map.put("name", pageMap.get("child_name"));
+                map.put("problemId", pageMap.get("id"));
+                map.put("fileKey", pageMap.get("file_key"));
+                map.put("createTime", pageMap.get("feedback_time"));
+                list.add(map);
+            }
+        }
+        data.put("pages", page.getSize());
+        data.put("pageNo", req.getPageNo());
+        data.put("pageSize", req.getPageSize());
+        data.put("list", list);
+        responseEntity.success(data, "成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity saveAnswer(SaveAnswerReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        problemPictureService.feedbackToProblem(req);
+        responseEntity.success("成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity knowList(KnowListReq req, Pageable pageable) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>(16);
+        List<KownHowDto> list = new ArrayList<>();
+        Map<String, Object> searchParams = new HashMap<>(16);
+        if (StringUtil.isNotBlank(req.getValue())) {
+            //模糊查询知识点
+            searchParams.put("LIKE_name", req.getValue());
+            Page<Map<String, Object>> pages = zuoybQueryDao.findKnowHowDetailByPage(searchParams, pageable);
+            //单元id对应的知识点LIST
+            Map<String, List<Map<String, Object>>> knowMap = new HashMap<>(16);
+            //单元id关联单元名称
+            Map<String, Object> idToNameMap = new HashMap<>(16);
+            for (Map<String, Object> knowDetail : pages.getContent()) {
+                String key = (String) knowDetail.get("how_id");
+                List<Map<String, Object>> knowDetailMapList;
+                Map<String, Object> knowDetailMap = new HashMap<>(16);
+                knowDetailMap.put("knowHowDetailsId", knowDetail.get("id"));
+                knowDetailMap.put("knowHowDetailsName", knowDetail.get("name"));
+                if (knowMap.get(key) != null) {
+                    knowDetailMapList = knowMap.get(key);
+                } else {
+                    knowDetailMapList = new ArrayList<>();
+                }
+                knowDetailMapList.add(knowDetailMap);
+                knowMap.put(key, knowDetailMapList);
+                idToNameMap.put((String) knowDetail.get("how_id"), knowDetail.get("how_name"));
+            }
+            for (String key : knowMap.keySet()) {
+                List<Map<String, Object>> knowHowList = knowMap.get(key);
+                KownHowDto dto = new KownHowDto();
+                dto.setKnowHowId(key);
+                dto.setKnowHowName((String) idToNameMap.get(key));
+                List<KownHowDto.KnowHowDetail> knowHowDetailDtoList = new ArrayList<>();
+                if (knowHowList != null && knowHowList.size() > 0) {
+                    for (Map<String, Object> knowHow : knowHowList) {
+                        KownHowDto.KnowHowDetail knowHowDetailDto = dto.new KnowHowDetail();
+                        knowHowDetailDto.setKnowHowDetailsId((String) knowHow.get("knowHowDetailsId"));
+                        knowHowDetailDto.setKnowHowDetailsName((String) knowHow.get("knowHowDetailsName"));
+                        knowHowDetailDtoList.add(knowHowDetailDto);
+                    }
+                }
+                dto.setKnowHowDetailList(knowHowDetailDtoList);
+                list.add(dto);
+            }
+            data.put("pages", pages.getTotalElements());
+        } else {
+            //查找单元列表
+            ProblemPicture problem = problemPictureService.getById(req.getProblemId());
+            LibVip libVip = libVipService.getById(req.getVipId());
+            searchParams.put("courseName", problem.getSubject());
+            searchParams.put("grade", libVip.getGrade());
+            searchParams.put("semester", Integer.parseInt( PropertiesUtil.getValue("semester")));
+            searchParams.put("banben", libVip.getBanben());
+            Page<Map<String, Object>> pages = zuoybQueryDao.findKnowHowByPage(searchParams, pageable);
+            for (Map<String, Object> know : pages.getContent()) {
+                KownHowDto dto = new KownHowDto();
+                dto.setKnowHowId((String) know.get("id"));
+                dto.setKnowHowName((String) know.get("name"));
+                List<ZuoybKnowHowDetails> kowDetailList = zuoybKnowHowDetailsService.findByHowId(dto.getKnowHowId());
+                List<KownHowDto.KnowHowDetail> knowHowDetailDtoList = new ArrayList<>();
+                if (kowDetailList != null && kowDetailList.size() > 0) {
+                    for (ZuoybKnowHowDetails knowHowDetail : kowDetailList) {
+                        KownHowDto.KnowHowDetail knowHowDetailDto = dto.new KnowHowDetail();
+                        knowHowDetailDto.setKnowHowDetailsId(knowHowDetail.getId());
+                        knowHowDetailDto.setKnowHowDetailsName(knowHowDetail.getName());
+                        knowHowDetailDtoList.add(knowHowDetailDto);
+                    }
+                }
+                dto.setKnowHowDetailList(knowHowDetailDtoList);
+                list.add(dto);
+            }
+            data.put("pages", pages.getTotalElements());
+        }
+        data.put("pageNo", req.getPageNo());
+        data.put("pageSize", req.getPageSize());
+        data.put("list", list);
+        responseEntity.success(data, "成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity knowListNew(KnowListReq req, Pageable pageable) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>(16);
+        List<KownHowDto> list = new ArrayList<>();
+        Map<String, Object> searchParams = new HashMap<>(16);
+        ProblemPicture problem = problemPictureService.getById(req.getProblemId());
+        LibVip libVip = libVipService.getById(req.getVipId());
+        String courseName = problem.getSubject();
+        String grade = libVip.getGrade();
+        int semester = Integer.parseInt( PropertiesUtil.getValue("semester"));
+        //获取版本
+        int banben = banbenDetailService.findBanben(problem.getSubject(), libVip.getSchool(), libVip.getGrade());
+        if (StringUtil.isNotBlank(req.getValue())) {
+            //模糊查询知识点
+            searchParams.put("LIKE_name", req.getValue());
+            searchParams.put("banben", banben);
+            Page<Map<String, Object>> pages = zuoybQueryDao.findKnowHowDetailByPage(searchParams, pageable);
+            //单元id对应的知识点LIST
+            Map<String, List<Map<String, Object>>> knowMap = new HashMap<>(16);
+            //单元id关联单元名称
+            Map<String, Object> idToNameMap = new HashMap<>(16);
+            for (Map<String, Object> knowDetail : pages.getContent()) {
+                String key = (String) knowDetail.get("how_id");
+                List<Map<String, Object>> knowDetailMapList;
+                Map<String, Object> knowDetailMap = new HashMap<>(16);
+                knowDetailMap.put("knowHowDetailsId", knowDetail.get("how_details_id"));
+                knowDetailMap.put("knowHowDetailsName", knowDetail.get("alias"));
+                if (knowMap.get(key) != null) {
+                    knowDetailMapList = knowMap.get(key);
+
+                } else {
+                    knowDetailMapList = new ArrayList<>();
+                }
+                knowDetailMapList.add(knowDetailMap);
+                knowMap.put(key, knowDetailMapList);
+                idToNameMap.put((String) knowDetail.get("how_id"), knowDetail.get("how_name"));
+            }
+            for (String key : knowMap.keySet()) {
+                List<Map<String, Object>> knowHowList = knowMap.get(key);
+                KownHowDto dto = new KownHowDto();
+                dto.setKnowHowId(key);
+                dto.setKnowHowName((String) idToNameMap.get(key));
+                List<KownHowDto.KnowHowDetail> knowHowDetailDtoList = new ArrayList<>();
+                if (knowHowList != null && knowHowList.size() > 0) {
+                    for (Map<String, Object> knowHow : knowHowList) {
+                        KownHowDto.KnowHowDetail knowHowDetailDto = dto.new KnowHowDetail();
+                        knowHowDetailDto.setKnowHowDetailsId((String) knowHow.get("knowHowDetailsId"));
+                        knowHowDetailDto.setKnowHowDetailsName((String) knowHow.get("knowHowDetailsName"));
+                        knowHowDetailDtoList.add(knowHowDetailDto);
+                    }
+                }
+                dto.setKnowHowDetailList(knowHowDetailDtoList);
+                list.add(dto);
+            }
+            data.put("pages", pages.getTotalElements());
+        } else {
+            //查找单元列表
+            searchParams.put("EQ_courseName", courseName);
+            searchParams.put("EQ_grade", grade);
+            searchParams.put("EQ_semester", semester);
+            searchParams.put("EQ_type", banben);
+            //查询条件为单元
+            searchParams.put("EQ_stat", 1);
+            Page<ZuoybKnowHowDetailsSort> pages = zuoybKnowHowDetailsSortService.findByPage(searchParams, pageable);
+            for (ZuoybKnowHowDetailsSort know : pages.getContent()) {
+                KownHowDto dto = new KownHowDto();
+                dto.setKnowHowId(know.getHowId());
+                dto.setKnowHowName(know.getAlias());
+                List<ZuoybKnowHowDetailsSort> kowDetailList = zuoybKnowHowDetailsSortService.findByCourseNameAndGradeAndSemesterAndTypeAndStatAndHowId(courseName, grade, semester, banben, 2, dto.getKnowHowId());
+                List<KownHowDto.KnowHowDetail> knowHowDetailDtoList = new ArrayList<>();
+                if (kowDetailList != null && kowDetailList.size() > 0) {
+                    for (ZuoybKnowHowDetailsSort knowHowDetail : kowDetailList) {
+                        KownHowDto.KnowHowDetail knowHowDetailDto = dto.new KnowHowDetail();
+                        knowHowDetailDto.setKnowHowDetailsId(knowHowDetail.getHowDetailsId());
+                        knowHowDetailDto.setKnowHowDetailsName(knowHowDetail.getAlias());
+                        knowHowDetailDtoList.add(knowHowDetailDto);
+                    }
+                }
+                dto.setKnowHowDetailList(knowHowDetailDtoList);
+                list.add(dto);
+            }
+            data.put("pages", pages.getTotalElements());
+        }
+        data.put("pageNo", req.getPageNo());
+        data.put("pageSize", req.getPageSize());
+        data.put("list", list);
+        responseEntity.success(data, "成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity bindStudentList(String userId, Pageable pageable, PageReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>(16);
+        List<Map<String, Object>> list = new ArrayList<>();
+        Map<String, Object> searchParams = new HashMap<>(16);
+        searchParams.put("teacherId", userId);
+        Page<Map<String, Object>> pages = libVipDao.findVipByOrgTeacherId(searchParams, pageable);
+        for (Map<String, Object> student : pages.getContent()) {
+            Map<String, Object> map = new HashMap<>(16);
+            map.put("vipId", student.get("id"));
+            map.put("photo", student.get("img_url"));
+            map.put("name", student.get("child_name"));
+            map.put("school", student.get("school"));
+            map.put("grade", student.get("grade"));
+            list.add(map);
+        }
+        data.put("pages", pages.getTotalElements());
+        data.put("pageNo", req.getPageNo());
+        data.put("pageSize", req.getPageSize());
+        data.put("list", list);
+        responseEntity.success(data, "成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity homeworkTask(HomeworkTaskReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity homeworkReport(HomeworkReportReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity getOrganizationList(OrganizationListReq req, Pageable pageable) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        Map<String, Object> data = new HashMap<>(16);
+        List<Map<String, Object>> list = new ArrayList<>();
+        Map<String, Object> searchParams = new HashMap<>(16);
+        if (StringUtils.isNoneBlank(req.getMaxCreateTime())) {
+            searchParams.put("LTE_createTime", req.getMaxCreateTime());
+        }
+        searchParams.put("LIKE_name", req.getName());
+        Page<OrgTeacher> pages = orgTeacherService.findByPage(searchParams, pageable);
+        for (OrgTeacher org : pages.getContent()) {
+            Map<String, Object> map = new HashMap<>(16);
+            map.put("orgId", org.getId());
+            map.put("name", org.getName());
+            list.add(map);
+        }
+        data.put("pages", pages.getTotalElements());
+        data.put("pageNo", req.getPageNo());
+        data.put("pageSize", req.getPageSize());
+        data.put("list", list);
+        responseEntity.success(data,"成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity swipeBinding(String userId, SwipeBindingReq req) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        //格式为：studentBindOrgTeacher?vipId=123456&subject=YUWEN
+        String qrCode = req.getQrCode();
+        int status = 0;
+        String vipId = "";
+        String subject = "";
+        if (StringUtil.isNotBlank(qrCode)) {
+            if (!qrCode.contains("studentBindOrgTeacher")) {
+                status = 1;
+            }
+            try{
+                vipId = qrCode.substring(qrCode.indexOf("vipId=") + 6, qrCode.indexOf("&"));
+                subject = qrCode.substring(qrCode.indexOf("subject=") + 8);
+            }catch (Exception e){
+                status = 1;
+            }
+            if (StringUtil.isBlank(vipId) || StringUtil.isBlank(subject)) {
+                status = 1;
+            }
+            subject = Constant.getSubjectFromRequest(subject);
+        } else {
+            status = 1;
+        }
+        if (status > 0) {
+            responseEntity.failure("不能识别该二维码");
+            return responseEntity;
+        }
+        TbLibManager teacher = iBookManagerService.findByUserId(userId, 10);
+        if(!teacher.getCourseName().contains(subject)){
+            responseEntity.failure("您无权限绑定该科目学生");
+            return responseEntity;
+        }
+        LibVipBind libVipBind = libVipBindService.findByVipIdAndSubject(vipId,subject);
+        if (libVipBind!=null){
+            if(StringUtil.isBlank(libVipBind.getTeacherId())){
+                libVipBind.setTeacherId(userId);
+                libVipBindService.save(libVipBind);
+            }else if(userId.equals(libVipBind.getTeacherId())){
+                responseEntity.failure("该学生已经被您绑定了");
+                return responseEntity;
+            }else{
+                responseEntity.failure("该学生已经被其他老师绑定了");
+                return responseEntity;
+            }
+        }else{
+            libVipBind = new LibVipBind();
+            libVipBind.setSubject(subject);
+            libVipBind.setCreateTime(new Date());
+            libVipBind.setVipId(vipId);
+            libVipBind.setTeacherId(userId);
+            libVipBindService.save(libVipBind);
+        }
+        //未解答难题小孩和老师绑定（只绑定老师注册科目）
+        List<ProblemPicture> list = problemPictureDao.findUnansweredAndNoTeacherByVipIdAndSubject(vipId,subject);
+        for (ProblemPicture problemPicture : list) {
+            problemPicture.setTeacherId(userId);
+            problemPictureService.save(problemPicture);
+        }
+        responseEntity.success("成功");
+        return responseEntity;
+    }
+
+    @Override
+    public ResponseEntity rectifyCourseName(String homeworkPictureId, String courseName) {
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        HomeworkPicture homeworkPicture = homeworkPictureService.getById(homeworkPictureId);
+        if (courseName.equals(homeworkPicture.getSubject()) || homeworkPicture.getIsFeedback() == 1){
+            return responseEntity.failure("当前学科与目标科目相同或者该作业已批改");
+        }
+
+        String teacherId = teacherService.getHomeworkTeacherId(homeworkPicture.getVipId(), courseName);
+        Homework hw = homeworkService.findByTodaySubjectHomework(homeworkPicture.getVipId(), courseName);
+        if (hw == null){
+            hw = new Homework();
+            hw.setSubject(courseName);
+            hw.setParentId(homeworkPicture.getParentId());
+            hw.setDerver(homeworkPicture.getDerver());
+            hw.setVipId(homeworkPicture.getVipId());
+            hw.setStartTime(homeworkPicture.getCreateTime());
+            hw.setCreateTime(homeworkPicture.getCreateTime());
+            LibVip libVip = libVipService.getById(homeworkPicture.getVipId());
+            hw.setGrade(libVip.getGrade());
+            hw = homeworkService.save(hw);
+        }
+        homeworkPicture.setHomeworkId(hw.getId());
+        homeworkPicture.setAllotTime(new Date());
+        homeworkPicture.setTeacherId(teacherId);
+        homeworkPicture.setSubject(courseName);
+        homeworkPicture = homeworkPictureService.save(homeworkPicture);//修改科目
+
+        if (StringUtils.isNotBlank(teacherId)) {
+            //更新新科目批改老师的批改作业图片数量和实时权重
+            bookManagerService.updateCorrectHomeworkNum(homeworkPicture.getVipId(), teacherId, 1);
+        }
+
+        //推送线上老师
+        homeworkPictureService.pushOnlineTeacher(homeworkPicture);
+
+        return responseEntity.success("操作成功");
+    }
+
+    @Override
+    public ResponseEntity sendVagueImgRemind(String homeworkPictureId) {
+        return homeworkPictureService.vagueHomeworkPicture(homeworkPictureId,null,homeworkPictureId);
+    }
+
+    @Override
+    public ResponseEntity homeworkToSmarttimePicture(String homeworkPictureId) {
+        return kmtCorrectHomeworkService.homeworkPicture2SmartTimePicture(homeworkPictureId);
+    }
+
+    @Override
+    public ResponseEntity getAnswerFilterCondition(String homeworkId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        Map<String, Object> homeworkInfoMap = homeworkService.findHomeworkInfoById(homeworkId);
+
+        if (homeworkInfoMap == null) {
+            return responseEntity.failure("未查询到对应作业信息");
+        }
+
+        int semester = Integer.parseInt( PropertiesUtil.getValue("semester"));
+        ExerciseConditionRequest request = new ExerciseConditionRequest();
+        request.setGrade(String.valueOf(homeworkInfoMap.get("grade")));
+        request.setSemester(semester);
+        request.setSubject(String.valueOf(homeworkInfoMap.get("subject")));
+//        request.setVersionType(Integer.valueOf(String.valueOf(homeworkInfoMap.get("banben"))));
+
+        //userId只用于加工审核那里查询待加工待审核的练习册，此处无用
+        List<ExerciseBookDto> list = kmtExerciseBookCourseService.getExerciseCondition(request, null);
+        Map<String, Object> data = new HashMap<>();
+        data.put("books", list);
+
+        return responseEntity.success(data, "查询成功");
+    }
+
+    @Override
+    public List<ExerciseQuestionAnswer4CorrectDTO> findAnswerList(AnswerSearchRequest request) {
+        return kmtExerciseQuestionService.findByExerciseBookCourseIdV2(request);
+    }
+
+    @Override
+    public void correct(CorrectRequest request, String teacherId) {
+        String homeworkId = request.getHomeworkId();
+        Homework homework = homeworkService.getById(homeworkId);
+
+        if (homework == null) {
+            throw new CommonException("作业不存在");
+        }
+
+        Date now = new Date();
+
+        //把之前的答错、答对题目信息改为删除失效状态
+        List<String> homeworkPictureIdList = request.getHomeworkPictureIdList();
+        List<KmtHomeworkWrongQuestion> oldKmtHomeworkWrongQuestionList = kmtHomeworkWrongQuestionService.findByHomeworkPictureIdIn(homeworkPictureIdList);
+        if (CollectionUtils.isNotEmpty(oldKmtHomeworkWrongQuestionList)) {
+            oldKmtHomeworkWrongQuestionList.forEach(kmtHomeworkWrongQuestion -> {
+                kmtHomeworkWrongQuestion.setIsDelete(true);
+                kmtHomeworkWrongQuestion.setUpdateTime(now);
+            });
+            kmtHomeworkWrongQuestionService.save(oldKmtHomeworkWrongQuestionList);
+        }
+
+        //删除之前批改添加的错题知识点记录
+        homeworkHowDetailsService.deleteByHomeworkPictureIdIn(homeworkPictureIdList);
+
+        if (request.getWrongHowDetailIds() != null && request.getWrongHowDetailIds().size() > 0){
+            //有自己勾选的知识点，则直接保存知识点
+            Integer knowledgeVersion = request.getKnowledgeVersion();
+            List<HomeworkHowDetail> list = new ArrayList<>();
+            request.getWrongHowDetailIds().forEach(detailId -> {
+                HomeworkHowDetail homeworkHowDetail = homeworkHowDetailsService.createHomeworkHowDetail(now, homeworkId, detailId, knowledgeVersion);
+                list.add(homeworkHowDetail);
+            });
+            homeworkHowDetailsService.save(list);
+        } else {
+            List<WrongQuestionRequest> wrongQuestionList = request.getWrongQuestionList();
+            if (CollectionUtils.isNotEmpty(wrongQuestionList)) {//有错题
+                wrongQuestionList.forEach(wrongQuestion -> {
+                    //生成错题记录
+                    KmtHomeworkWrongQuestion kmtHomeworkWrongQuestion = kmtHomeworkWrongQuestionService.createKmtHomeworkWrongQuestion(homework, now, wrongQuestion.getQuestionId(), HomeworkWrongQuestionTypeEnum.WrongAnswer.getCode());
+                    kmtHomeworkWrongQuestion = kmtHomeworkWrongQuestionService.save(kmtHomeworkWrongQuestion);
+
+                    List<String> knowledgeIdList = wrongQuestion.getKnowledgeIdList();
+                    if (CollectionUtils.isNotEmpty(knowledgeIdList)) {//教师手动选择了知识点
+                        for (String knowledgeId : knowledgeIdList) {
+                            HomeworkHowDetail homeworkHowDetail = homeworkHowDetailsService.createHomeworkHowDetail(now, kmtHomeworkWrongQuestion, knowledgeId);
+                            homeworkHowDetailsService.save(homeworkHowDetail);
+                        }
+                    } else {//未选择，则默认选择此题目下所有知识点
+                        List<KmtExerciseQuestionKnow> kmtExerciseQuestionKnowList = kmtExerciseQuestionKnowService.findByQuestionId(kmtHomeworkWrongQuestion.getQuestionId());
+                        for (KmtExerciseQuestionKnow kmtExerciseQuestionKnow : kmtExerciseQuestionKnowList) {
+                            HomeworkHowDetail homeworkHowDetail = homeworkHowDetailsService.createHomeworkHowDetail(now, kmtHomeworkWrongQuestion, kmtExerciseQuestionKnow.getHowDetailsId());
+                            homeworkHowDetailsService.save(homeworkHowDetail);
+                        }
+                    }
+                });
+            }
+
+            //答对的题
+            List<String> rightQuestionIdList = request.getRightQuestionIdList();
+            if (CollectionUtils.isNotEmpty(rightQuestionIdList)) {
+                rightQuestionIdList.forEach(rightQuestionId -> {
+                    //生成答对的题目记录
+                    KmtHomeworkWrongQuestion kmtHomeworkWrongQuestion = kmtHomeworkWrongQuestionService.createKmtHomeworkWrongQuestion(homework, now, rightQuestionId, HomeworkWrongQuestionTypeEnum.Right.getCode());
+                    kmtHomeworkWrongQuestionService.save(kmtHomeworkWrongQuestion);
+                });
+            }
+        }
+
+        //更新作业图片记录信息
+        List<HomeworkPicture> homeworkPictureList = homeworkPictureService.findByIdInAndIsDelete(homeworkPictureIdList, 0);
+        List<CorrectedPictureUrlRequest> correctedPictureUrlRequestList = request.getCorrectedPictureUrlList();
+        List<HomeworkPicture> homeworkPictureListNeedUpdate = new ArrayList<>();
+        homeworkPictureList.forEach(homeworkPicture -> {
+            if (!Objects.equals(1, homeworkPicture.getIsMark()) && !Objects.equals(3, homeworkPicture.getIsMark())) {
+                homeworkPicture.setIsFeedback(1);//更新为已批改状态
+
+                //如果有批注则需要更新批注字段
+                Optional<CorrectedPictureUrlRequest> optional = correctedPictureUrlRequestList.stream().filter(it -> Objects.equals(it.getHomeworkPictureId(), homeworkPicture.getId())).findFirst();
+                if (optional.isPresent()) {
+                    CorrectedPictureUrlRequest correctedPictureUrlRequest = optional.get();
+                    homeworkPicture.setCorrectedPictureUrl(correctedPictureUrlRequest.getCorrectedPictureUrl());
+                }
+
+                homeworkPictureListNeedUpdate.add(homeworkPicture);
+            }
+        });
+        homeworkPictureService.save(homeworkPictureListNeedUpdate);
+
+        //更新学科作业记录信息
+        homework.setCorrectionTime(homeworkService.stopCorrectTiming(homeworkId));
+        homeworkService.save(homework);
+
+        //推送相关通知信息
+        homeworkPictureService.confirmPushTodayFinishHomework(homework.getId(),homework.getDerver(),homework.getVipId(), homework.getSubject(), homework.getCreateTime(),homework.getCorrectTime());
+    }
+
+}

ssj-sys/src/main/java/com/ssj/service/conch/teacher/service/impl/TeacherOrgV2ServiceImpl.java

@@ -0,0 +1,364 @@
+package com.ssj.service.conch.teacher.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.alibaba.fastjson.JSON;
+import com.ssj.bean.conch.conch.dto.ProblemDetailDto;
+import com.ssj.bean.sys.feedback.domain.Feedback;
+import com.ssj.bean.sys.feedback.domain.SconPhotoFeedbackDetail;
+import com.ssj.bean.sys.feedback.domain.SconVoiceFeedbackDetail;
+import com.ssj.bean.sys.imlibuser.TbClass;
+import com.ssj.bean.sys.picturepredeal.domain.ProblemSimilarPredeal;
+import com.ssj.bean.sys.problem.domain.ProblemPicture;
+import com.ssj.bean.sys.problem.dto.ProblemPictureListDto;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.framework.core.util.Constant;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.mapper.libraryteacher.LibraryTeacherMapper;
+import com.ssj.service.conch.conch.service.ConchDerverService;
+import com.ssj.service.conch.teacher.library.dto.KnowledgeDTO;
+import com.ssj.service.conch.teacher.library.dto.StudentDTOV2;
+import com.ssj.service.conch.teacher.library.dto.TypicalWrongQuestionDTO;
+import com.ssj.service.conch.teacher.library.dto.WrongQuestionDetailDTO;
+import com.ssj.service.conch.teacher.library.request.ClassIdReq;
+import com.ssj.service.conch.teacher.library.request.QuestionDetailReq;
+import com.ssj.service.conch.teacher.request.teacherorg.AnsweredProblemReq;
+import com.ssj.service.conch.teacher.request.teacherorg.ClassIdPageRequest;
+import com.ssj.service.conch.teacher.service.TeacherOrgV2Service;
+import com.ssj.service.conch.teacher.v2.dto.ClassDto;
+import com.ssj.service.conch.teacher.v2.dto.ClassStudentDto;
+import com.ssj.service.conch.teacher.v2.dto.NewClassDto;
+import com.ssj.service.mapper.LibManagerMapper;
+import com.ssj.service.sys.feedback.service.FeedbackService;
+import com.ssj.service.sys.feedback.service.SconPhotoFeedbackDetailService;
+import com.ssj.service.sys.feedback.service.SconVoiceFeedbackDetailService;
+import com.ssj.service.sys.imlibuser.service.TbClassService;
+import com.ssj.service.sys.picturepredeal.service.ProblemSimilarPreDealService;
+import com.ssj.service.sys.problem.service.ProblemPictureService;
+import com.ssj.service.weixin.library.service.IBookManagerService;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.util.*;
+
+/**
+ * @author yangcan
+ * 类描述:学科老师端接口实现类V2
+ * 创建时间:2019/10/31 15:46
+ */
+@Service(version="1.0")
+@Transactional
+public class TeacherOrgV2ServiceImpl implements TeacherOrgV2Service {
+
+    private Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @Autowired
+    private TbClassService tbClassService;
+
+    @Autowired
+    private LibraryTeacherMapper libraryTeacherMapper;
+    @Autowired
+    private IBookManagerService iBookManagerService;
+    @Autowired
+    private ProblemPictureService problemPictureService;
+
+    @Autowired
+    private ProblemSimilarPreDealService problemSimilarPreDealService;
+
+    @Autowired
+    private ConchDerverService conchDerverService;
+    @Autowired
+    private LibManagerMapper libManagerMapper;
+
+    @Autowired
+    private FeedbackService feedbackService;
+
+    @Autowired
+    private SconPhotoFeedbackDetailService sconPhotoFeedbackDetailService;
+
+    @Autowired
+    private SconVoiceFeedbackDetailService sconVoiceFeedbackDetailService;
+
+    @Override
+    public ResponseEntity homeworkCount(ClassIdReq req, String teacherId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        String lastDateStr = DateUtil.format_yyyyMMdd(DateUtil.getDateAfter(new Date(), -1));
+        String beginDateTimeStr = lastDateStr + " 00:00:00";
+        String endDateTimeStr = lastDateStr + " 23:59:59";
+
+        TbClass tbClass = tbClassService.getById(req.getClassId());
+        if (tbClass == null || tbClass.getStatus() == 0) {
+            return responseEntity.failure("班级不存在");
+        }
+        List<TbLibManager> tbLibManagerList = iBookManagerService.findManagerList(tbClass.getLibId(), teacherId,
+                Constant.ORG_TEACHER_TYPE);
+        if (tbLibManagerList.isEmpty()) {
+            return responseEntity.failure("您还不是学科老师");
+        }
+        String courseNameStr = tbLibManagerList.get(0).getCourseName();
+        if (StringUtils.isBlank(courseNameStr)) {
+            return responseEntity.failure("老师科目资料错误");
+        }
+        List<String> subjectList = Arrays.asList(courseNameStr.split(","));
+        if (StringUtils.isNotBlank(req.getSubject())) {
+            if (!subjectList.contains(req.getSubject())) {
+                return responseEntity.failure("您未负责此科目");
+            } else {
+                subjectList = Collections.singletonList(req.getSubject());
+            }
+        }
+
+        //计算正确率
+        Map<String, Object> homeworkCountDataMap = libraryTeacherMapper.countHomeworkDataByClass(req.getClassId(), subjectList, beginDateTimeStr, endDateTimeStr);
+        int accuracyRate;
+        int totalNum = Integer.parseInt(Optional.ofNullable(homeworkCountDataMap.get("totalCount")).orElse("0").toString());
+        if (totalNum > 0) {
+            int wrongNum = Integer.parseInt(Optional.ofNullable(homeworkCountDataMap.get("wrongCount")).orElse("0").toString());
+            accuracyRate = new BigDecimal((totalNum - wrongNum) * 100.0 / totalNum).intValue();
+        } else {
+            return responseEntity.success((Map<String, Object>) null, "查询成功");
+        }
+
+        //查询班级学生总数和昨天提交作业的学生数
+        int totalStudentNum = libraryTeacherMapper.countAllByClassId(req.getClassId());
+        int submitStudentNum = 0;
+        if (totalStudentNum > 0) {
+            submitStudentNum = libraryTeacherMapper.countSubmittedStudentNum(req.getClassId(), subjectList, beginDateTimeStr, endDateTimeStr, false);
+        }
+
+        //查询典型错题
+        List<String> homeworkIdList = libraryTeacherMapper.findHomeworkIdYesterdayByClass(req.getClassId(), subjectList, beginDateTimeStr, endDateTimeStr);
+        List<TypicalWrongQuestionDTO> typicalWrongQuestionDTOList = new ArrayList<>();
+        if (CollectionUtils.isNotEmpty(homeworkIdList)) {
+            typicalWrongQuestionDTOList = libraryTeacherMapper.findTypicalWrongQuestionListStep1(homeworkIdList);
+            int submittedAndCorrectedStudentNum = libraryTeacherMapper.countSubmittedStudentNum(req.getClassId(), subjectList, beginDateTimeStr, endDateTimeStr, true);
+            Map<String, Object> typicalWrongQuestionListStep2;
+            for (TypicalWrongQuestionDTO typicalWrongQuestionDTO : typicalWrongQuestionDTOList) {
+                typicalWrongQuestionListStep2 = libraryTeacherMapper.findTypicalWrongQuestionListStep2(typicalWrongQuestionDTO.getQuestionId());
+                if (typicalWrongQuestionListStep2 != null) {
+                    typicalWrongQuestionDTO.setBookName(Optional.ofNullable(typicalWrongQuestionListStep2.get("book_name")).map(Object::toString).orElse(""));
+                    typicalWrongQuestionDTO.setUnit(Optional.ofNullable(typicalWrongQuestionListStep2.get("unit")).map(Object::toString).orElse(""));
+                    typicalWrongQuestionDTO.setPeriod(Optional.ofNullable(typicalWrongQuestionListStep2.get("period")).map(Object::toString).orElse(""));
+                    typicalWrongQuestionDTO.setBigIndex(Optional.ofNullable(typicalWrongQuestionListStep2.get("bigIndex")).map(Object::toString).orElse(""));
+                    typicalWrongQuestionDTO.setSmallIndex(Optional.ofNullable(typicalWrongQuestionListStep2.get("smallIndex")).map(Object::toString).orElse(""));
+                }
+                typicalWrongQuestionDTO.setErrorRate(typicalWrongQuestionDTO.getStudentCount() * 100 / (submittedAndCorrectedStudentNum == 0 ? 1 : submittedAndCorrectedStudentNum));
+
+                //计算难度系数
+                double difficultyDegree = 0.0;
+//                Map<String, Object> homeworkCountInGradeMap = libraryTeacherMapper.countHomeworkDataByGrade(typicalWrongQuestionDTO.getQuestionId(), tbClass.getGrade(), beginDateTimeStr, endDateTimeStr);
+//                if (homeworkCountInGradeMap != null) {
+//                    int rightCount = Integer.parseInt(Optional.ofNullable(homeworkCountInGradeMap.get("rightCount")).orElse("0").toString());
+//                    int totalCount = Integer.parseInt(Optional.ofNullable(homeworkCountInGradeMap.get("totalCount")).orElse("0").toString());
+//                    if (totalCount > 0) {
+//                        difficultyDegree = new BigDecimal(1.0 * rightCount / totalCount).setScale(1, BigDecimal.ROUND_DOWN).doubleValue();
+//                    }
+//                }
+                typicalWrongQuestionDTO.setDifficultyDegree(difficultyDegree);
+
+                //查询关联知识点
+                List<KnowledgeDTO> knowledgeDTOList = libraryTeacherMapper.findDependentKnowledge(typicalWrongQuestionDTO.getQuestionId());
+                typicalWrongQuestionDTO.setKnowledgeList(knowledgeDTOList);
+            }
+        }
+        typicalWrongQuestionDTOList.sort((o1, o2) -> o2.getErrorRate() - o1.getErrorRate());
+
+        Map<String, Object> resultMap = new HashMap<>();
+        resultMap.put("accuracyRate", accuracyRate);
+        resultMap.put("totalStudentNum", totalStudentNum);
+        resultMap.put("submitStudentNum", submitStudentNum);
+        resultMap.put("wrongQuestionList", typicalWrongQuestionDTOList);
+
+        return responseEntity.success(resultMap, "查询成功");
+    }
+
+    @Override
+    public ResponseEntity findSubmittedStudentList(ClassIdReq req, String teacherId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        TbClass tbClass = tbClassService.getById(req.getClassId());
+        if (tbClass == null || tbClass.getStatus() == 0) {
+            return responseEntity.failure("班级不存在");
+        }
+        List<TbLibManager> tbLibManagerList = iBookManagerService.findManagerList(tbClass.getLibId(), teacherId,
+                Constant.ORG_TEACHER_TYPE);
+        if (tbLibManagerList.isEmpty()) {
+            return responseEntity.failure("您还不是学科老师");
+        }
+        String courseNameStr = tbLibManagerList.get(0).getCourseName();
+        if (StringUtils.isBlank(courseNameStr)) {
+            return responseEntity.failure("老师科目资料错误");
+        }
+        List<String> subjectList = Arrays.asList(courseNameStr.split(","));
+        if (StringUtils.isNotBlank(req.getSubject())) {
+            if (!subjectList.contains(req.getSubject())) {
+                return responseEntity.failure("您未负责此科目");
+            } else {
+                subjectList = Collections.singletonList(req.getSubject());
+            }
+        }
+
+        String lastDateStr = DateUtil.format_yyyyMMdd(DateUtil.getDateAfter(new Date(), -1));
+        String beginDateTimeStr = lastDateStr + " 00:00:00";
+        String endDateTimeStr = lastDateStr + " 23:59:59";
+
+        List<StudentDTOV2> studentDTOV2List = libraryTeacherMapper.findSubmittedStudentList(req.getClassId(), subjectList, beginDateTimeStr, endDateTimeStr);
+        return responseEntity.success(Collections.singletonMap("list", studentDTOV2List), "查询成功");
+    }
+
+    @Override
+    public ResponseEntity findWrongQuestionDetail(QuestionDetailReq req) {
+        String lastDateStr = DateUtil.format_yyyyMMdd(DateUtil.getDateAfter(new Date(), -1));
+        String beginDateTimeStr = lastDateStr + " 00:00:00";
+        String endDateTimeStr = lastDateStr + " 23:59:59";
+        List<WrongQuestionDetailDTO> wrongQuestionDetailDTOList = libraryTeacherMapper.findWrongQuestionDetail(req.getClassId(), req.getQuestionId(), beginDateTimeStr, endDateTimeStr);
+        return new ResponseEntity().success(Collections.singletonMap("list", wrongQuestionDetailDTOList), "查询成功");
+    }
+
+    @Override
+    public ResponseEntity classList(String userId) {
+        List<ClassDto> classDtoList = libraryTeacherMapper.findClassList(userId);
+        Map<String,Object> data=new HashMap<>();
+        data.put("list",classDtoList);
+        return new ResponseEntity().success(data,"查询成功");
+    }
+
+    @Override
+    public ResponseEntity newClassList(String userId) {
+        List<NewClassDto> classDtoList = libraryTeacherMapper.findNewClassList(userId);
+        Map<String,Object> data = new HashMap<>();
+        data.put("list",classDtoList);
+        return new ResponseEntity().success(data,"查询成功");
+    }
+
+    @Override
+    public ResponseEntity studentList(String classId) {
+        List<ClassStudentDto> studentDtoList = libraryTeacherMapper.findStudentList(classId);
+        Map<String,Object> data=new HashMap<>();
+        data.put("list",studentDtoList);
+        return new ResponseEntity().success(data,"查询成功");
+    }
+
+    @Override
+    public Map<String, Object> studentProblemPictureList(AnsweredProblemReq req, String teacherId) {
+        Map<String, Object> data = new HashMap<>();
+        data.put("pageNo", req.getPageNo());
+        data.put("pageSize", req.getPageSize());
+        data.put("pages", 0);
+        data.put("maxCreateTime", req.getMaxCreateTime());
+        data.put("list", new ArrayList<>());
+        TbLibManager teacher = iBookManagerService.findAllByUserIdAndTypeAndState(teacherId, 10, 1);
+        if (teacher != null){
+            req.setSubject(teacher.getCourseName());
+            data = problemPictureService.findProblemPictureList(req);
+            this.changeTeacherAppResolutionStatus(data);
+        }
+        return data;
+    }
+
+    @Override
+    public Map<String, Object> findProblemPictureList(ClassIdPageRequest req, String teacherId) {
+        Map<String, Object> data = new HashMap<>();
+        data.put("pageNo", req.getPageNo());
+        data.put("pageSize", req.getPageSize());
+        data.put("pages", 0);
+        data.put("maxCreateTime", req.getMaxCreateTime());
+        List<TbLibManager> libManagerList=iBookManagerService.findAllByUserIdAndTypeAndStatus(teacherId,10);
+        List<ProblemPictureListDto> list=new ArrayList<>();
+        if(CollectionUtils.isNotEmpty(libManagerList)){
+            libManagerList.forEach(it->{
+                list.addAll(problemPictureService.findProblemPictureList(req,it.getCourseName(),it.getLibId()));
+            });
+            data.put("list", list);
+            this.changeTeacherAppResolutionStatus(data);
+        }
+        return data;
+    }
+
+    /**
+     * 改变老师端的状态返回，与其他端不一致
+     * @param data
+     */
+    private void changeTeacherAppResolutionStatus (Map<String, Object> data){
+        List<ProblemPictureListDto> temp = (List<ProblemPictureListDto>)data.get("list");
+        for (ProblemPictureListDto dto : temp){
+            if (dto.getTaskStatus() == 1 && dto.getDealFlag() == 0) {
+                dto.setResolutionStatus(2);
+            } else {
+                dto.setResolutionStatus(dto.getTaskStatus());
+            }
+        }
+        data.put("list", temp);
+    }
+
+    @Override
+    public ProblemDetailDto getProblemFeedbackData(String problemPictureId) {
+        ProblemPicture problemPicture = problemPictureService.getById(problemPictureId);
+        com.ssj.bean.conch.conch.dto.ProblemDetailDto result = new com.ssj.bean.conch.conch.dto.ProblemDetailDto();
+        if (problemPicture != null){
+            ProblemSimilarPredeal predeal = problemSimilarPreDealService.findPreDealByProblemPictureId(problemPictureId);
+            if (predeal == null){
+                result = conchDerverService.getProblemFeedbackData(problemPicture, null, false);
+                result.setResolutionStatus(2);
+            } else {
+                boolean showExerciseQuestion = predeal.getDealFlag() == 3 ? true : false;
+                result = conchDerverService.getProblemFeedbackData(problemPicture, JSON.parseArray(predeal.getQuestionIds(), String.class), showExerciseQuestion);
+                if (predeal.getTaskStatus() == 1 && predeal.getDealFlag() == 0){
+                    result.setResolutionStatus(1);
+                } else {
+                    result.setResolutionStatus(predeal.getTaskStatus());
+                }
+            }
+            //新加语音和图片的
+            Feedback feedback = feedbackService.findByBizId(problemPictureId);
+            if (feedback != null) {
+                // 获取老师反馈的图片信息
+                List<SconPhotoFeedbackDetail> photoList = sconPhotoFeedbackDetailService.findByFeedbackIdOrderByNumAsc(feedback.getId());
+                List<Map<String, String>> fileKeys = new ArrayList<>();
+                photoList.forEach(e -> {
+                    Map<String, String> imageMap = new HashMap<>();
+                    imageMap.put("imagekey", e.getFileKey());
+                    fileKeys.add(imageMap);
+                });
+                result.setFileKeys(fileKeys);
+                //查找语音列表
+                List<SconVoiceFeedbackDetail> voiceList = sconVoiceFeedbackDetailService.findByFeedbackIdOrderByNumAsc(feedback.getId());
+                List<Map<String, String>> voiceListMap = new ArrayList<>();
+                if (CollectionUtils.isNotEmpty(voiceList)) {
+                    for (SconVoiceFeedbackDetail voice : voiceList) {
+                        Map<String, String> voiceMap = new HashMap<>();
+                        voiceMap.put("voiceKey", voice.getFileKey());
+                        voiceMap.put("duration", voice.getDuration());
+                        voiceListMap.add(voiceMap);
+                    }
+                }
+                result.setVoiceKeyList(voiceListMap);
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public ResponseEntity findSubjectList(ClassIdReq req, String teacherId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+
+        TbLibManager orgTeacher = libManagerMapper.findOrgTeacher(teacherId, req.getClassId());
+        if (orgTeacher == null) {
+            return responseEntity.failure("您还不是此班级的学科老师");
+        }
+
+        String subjectStr = orgTeacher.getCourseName();
+        if (StringUtils.isBlank(subjectStr)) {
+            responseEntity.success(Collections.singletonMap("subjectList", Collections.emptyList()), "查询成功");
+        } else {
+            responseEntity.success(Collections.singletonMap("subjectList", Arrays.asList(subjectStr.split(","))), "查询成功");
+        }
+
+        return responseEntity;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/conch/teacher/service/impl/TzybHomeworkServiceImpl.java

@@ -0,0 +1,713 @@
+package com.ssj.service.conch.teacher.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.alibaba.fastjson.JSON;
+import com.ssj.bean.sys.homework.domain.Homework;
+import com.ssj.bean.sys.homework.domain.HomeworkPicture;
+import com.ssj.bean.sys.homework.domain.NoHomeworkRecord;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.bean.weixin.sales.domain.LibVipService;
+import com.ssj.bean.weixin.zyb.domain.ZuoybStudentPush;
+import com.ssj.conch.constant.CourseConstant;
+import com.ssj.conch.push.util.PushConstants;
+import com.ssj.enums.XinGePushBusinessTypeEnum;
+import com.ssj.enums.XinGePushMessageTypeEnum;
+import com.ssj.framework.basic.utils.StringUtils;
+import com.ssj.framework.core.util.Constant;
+import com.ssj.framework.files.service.FileInfoService;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.framework.weixin.util.WxUtil;
+import com.ssj.service.conch.teacher.dto.*;
+import com.ssj.service.conch.teacher.request.zyb.HomeworkDataSaveRequest;
+import com.ssj.service.conch.teacher.request.zyb.SubjectImageSubmitRequest;
+import com.ssj.service.conch.teacher.service.ITzybService;
+import com.ssj.service.conch.teacher.service.TeacherService;
+import com.ssj.service.conch.teacher.service.TzybHomeworkService;
+import com.ssj.service.sys.homework.service.HomeworkPictureService;
+import com.ssj.service.sys.homework.service.HomeworkService;
+import com.ssj.service.sys.homework.service.NoHomeworkRecordService;
+import com.ssj.service.sys.picturepredeal.service.PicturePreDealService;
+import com.ssj.service.sys.push.service.SconXingeService;
+import com.ssj.service.weixin.library.service.IBookManagerService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import com.ssj.service.weixin.sales.service.LibVipServiceService;
+import com.ssj.service.weixin.user.service.UserService;
+import com.ssj.service.weixin.zuoyb.service.ZuoybDayService;
+import com.ssj.service.weixin.zuoyb.service.ZuoybStudentPushSerivce;
+import com.ssj.service.weixin.zuoyb.service.ZuoybStudentWorkService;
+import org.apache.commons.collections.CollectionUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @author chchen
+ * @date 2018/9/21 13:27
+ */
+@Service(version ="1.0")
+@Transactional
+public class TzybHomeworkServiceImpl implements TzybHomeworkService {
+
+    private   Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @Autowired
+    private ZuoybStudentPushSerivce zuoybStudentPushSerivce;
+
+    @Autowired
+    private HomeworkPictureService homeworkPictureService;
+
+    @Autowired
+    private HomeworkService homeworkService;
+
+    @Autowired
+    private ILibVipService libVipService;
+
+    @Autowired
+    private LibVipServiceService libVipServiceService;
+
+    @Autowired
+    private IBookManagerService bookManagerService;
+
+    @Autowired
+    private ITzybService tzybService;
+
+    @Autowired
+    private ILibVipService vipService;
+
+    @Autowired
+    private UserService userService;
+
+    @Autowired
+    private SconXingeService sconXingeService;
+
+    @Autowired
+    private ZuoybDayService zuoybDayService;
+
+    @Autowired
+    private ZuoybStudentWorkService zuoybStudentWorkService;
+    
+    @Autowired
+    private TeacherService teacherService;
+    
+    @Autowired
+	private FileInfoService fileInfoService;
+    
+    @Autowired
+    private PicturePreDealService picturePreDealService;
+    @Autowired
+    private NoHomeworkRecordService noHomeworkRecordService;
+    @Autowired
+    private IBookManagerService managerService;
+
+    /**
+     * 把作业数据中的总体部分抽象出来，放入到实体中返回
+     * @param list
+     * @return
+     */
+    private TotalitySituationAdapter convertTotalityData (List<LearningStateDto> list){
+        TotalitySituationAdapter result = new TotalitySituationAdapter();
+        if (list != null){
+            result.setLearningStateScore(list);
+        }
+        return result;
+    }
+
+    /**
+     * 把各科数据整合放入实体列表中返回
+     * @param list 各科数据
+     * @return
+     */
+    private List<SubjectHomeworkDto> convertSubjectData (List<SubjectParamDto> list){
+        List<SubjectHomeworkDto> result = new ArrayList<>();
+
+        for (String key : CourseConstant.subjectList){
+            SubjectHomeworkDto temp = new SubjectHomeworkDto();
+            temp.setSubject(key);
+            result.add(temp);
+        }
+
+        if (list != null) {
+            for (SubjectParamDto sct : list){
+                for (SubjectHomeworkDto shd : result){
+                    if (shd.getSubject().equals(sct.getSubject())){
+                        shd.setCostTime(sct.getCostTime());
+                        shd.setType(sct.getType());
+                        shd.setBeginTime(sct.getBeginTime());
+                    }
+                }
+            }
+        }
+
+        if (list != null){
+            for (SubjectParamDto obj : list){
+                for (SubjectHomeworkDto shd : result){
+                    if (shd.getSubject().equals(obj.getSubject())){
+                        //状态
+                        int workState = obj.getFinishState();
+                        shd.setState(workState);
+
+                        //部分完成需要装配未完成内容
+                        List<LabelStateDto> unfinishArray = obj.getUnfinishedList();
+                        if(workState == 2 && unfinishArray != null && unfinishArray.size() > 0){
+                            for (LabelStateDto obj1 : unfinishArray){
+                                if (obj1.getActive()  == 1){
+                                    shd.addUnfinished(obj1.getName());
+                                }
+                            }
+                        }
+
+                        //不是无作业要装配图片
+                        if (workState != 1 && obj.getHomeworkPictureList() != null && obj.getHomeworkPictureList().size() > 0){
+                            for (HomeworkPictureDto obj1 : obj.getHomeworkPictureList()){
+                                HomeworkPictureDto hp = new HomeworkPictureDto();
+                                hp.setPid(obj1.getPid());
+                                hp.setImage(obj1.getImage());
+                                shd.addHomeworkPicture(hp);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> saveHomeworkSituation(String userId, HomeworkDataSaveRequest request) {
+        Map<String, Object> result = new HashMap<>();
+        TotalitySituationAdapter adapter = this.convertTotalityData(request.getLearningState());
+        ZuoybStudentPush push = this.saveTotalitySituation(request.getPushId(), request.getHomeworkPicture(),
+                request.getSuggestion(), adapter, userId);
+        if (push == null){
+            logger.error("没有push记录是有问题的访问");
+            result.put("isSuccess", false);
+            result.put("msg", "没有push");
+            return result;
+        }
+        LibVip student = libVipService.getById(push.getVipId());
+
+        LibVipService  libvipService = libVipServiceService.getVipIdZXService5days(student, push.getLibId());
+        if(libvipService == null){
+            result.put("isSuccess", false);
+            result.put("msg", "作业吧服务已失效");
+            logger.warn("{}学生的作业吧服务已失效", student.getChildName());
+            return result;
+        }
+
+        //各科情况保存
+        List<SubjectHomeworkDto> list = this.convertSubjectData(request.getSubjectDataList());
+
+        for (SubjectHomeworkDto sh : list){
+            //如果未开始计时，并且没有选择全部完成，部分完成，无作业，并且图片列表为空的，直接过滤
+            if (sh.getType() == 0 && sh.getState() == 0 && CollectionUtils.isEmpty(sh.getHomeworkPictureList())){
+                continue;
+            }
+            if (sh.getState() == 3 || sh.getState() == 4){
+                //无作业
+                NoHomeworkRecord noHomeworkRecord = new NoHomeworkRecord();
+                noHomeworkRecord.setCourseName(sh.getSubject());
+                noHomeworkRecord.setCreateTime(new Date());
+                //设置在馆老师端
+                noHomeworkRecord.setDeviceType(1);
+                noHomeworkRecord.setVipId(student.getId());
+                //设置无作业
+                noHomeworkRecord.setType(sh.getState());
+                noHomeworkRecord.setGrade(student.getGrade());
+                noHomeworkRecordService.save(noHomeworkRecord);
+            } else {
+                Homework hw = homeworkService.findByTodaySubjectHomework(push.getVipId(), sh.getSubject());
+                if (hw == null){
+                    hw = new Homework();
+                    Date date = new Date();
+                    hw.setCreateTime(date);
+                    hw.setStartTime(date);
+                    hw.setParentId(student.getUserId());
+                    hw.setDerver(student.getDerver());
+                    hw.setVipId(student.getId());
+                    hw.setSubject(sh.getSubject());
+                }
+
+                if (sh.getType() == 1){
+                    hw.setEndTime(null);
+                }
+                if (hw.getEndTime() == null) {
+                    if (sh.getBeginTime() == null || sh.getBeginTime() <= 0) {
+                        hw.setEndTime(hw.getStartTime());
+                    } else {
+                        hw.setStartTime(new Date(sh.getBeginTime()));
+                        hw.setEndTime(new Date(sh.getBeginTime() + sh.getCostTime() * 60 * 1000));
+                    }
+                } else if ((hw.getUsedTime() == null || hw.getUsedTime() <= 0) && (sh.getBeginTime() != null && sh.getBeginTime() > 0)){
+                    hw.setStartTime(new Date(sh.getBeginTime()));
+                    hw.setEndTime(new Date(sh.getBeginTime() + sh.getCostTime() * 60 * 1000));
+                }
+                hw.setWorkingType(sh.getType());
+                if (sh.getCostTime() > 0){
+                    hw.setUsedTime((long)sh.getCostTime());
+                }
+                hw.setHomeworkType(1);
+                hw.setPushId(push.getId());
+                hw.setGrade(student.getGrade());
+                hw.setWorkType(sh.getState());
+                hw.setUnFinishedContent(sh.unfinish2String());
+                homeworkService.save(hw);
+            }
+        }
+        result.put("isSuccess", true);
+        return result;
+    }
+    
+    @Override
+	public Map<String, Object> saveStudentHomeworkFeedback(String userId, HomeworkDataSaveRequest request) {
+    	Map<String, Object> result = new HashMap<>();
+        TotalitySituationAdapter adapter = this.convertTotalityData(request.getLearningState());
+        ZuoybStudentPush push = this.saveTotalitySituation(request.getPushId(), request.getHomeworkPicture(),
+                request.getSuggestion(), adapter, userId);
+        if (push == null){
+            logger.error("没有push记录是有问题的访问");
+            result.put("isSuccess", false);
+            result.put("msg", "没有push");
+            return result;
+        }
+        LibVip student = libVipService.getById(push.getVipId());
+
+        LibVipService  libvipService = libVipServiceService.getVipIdZXService5days(student, push.getLibId());
+        if(libvipService == null){
+            result.put("isSuccess", false);
+            result.put("msg", "作业吧服务已失效");
+            logger.warn("{}学生的作业吧服务已失效", student.getChildName());
+            return result;
+        }
+
+        //各科情况保存
+        List<SubjectHomeworkDto> list = this.convertSubjectData(request.getSubjectDataList());
+        logger.info("各科转化后的数据={}", JSON.toJSONString(list));
+        
+        for (SubjectHomeworkDto sh : list){
+            //查询当天该科目的作业计时记录
+            Homework hw = homeworkService.findByTodaySubjectHomework(push.getVipId(), sh.getSubject());
+            if(hw != null) {
+            	//如果有计时没有拍照则删除计时记录
+            	long count = homeworkPictureService.countByHomeworkId(hw.getId());
+            	if(count == 0) {
+            		homeworkService.delete(hw);
+            	}else {
+            		if (sh.getType() == 1){
+                        hw.setEndTime(null);
+                    }
+                    if (hw.getEndTime() == null) {
+                        if (sh.getBeginTime() == null || sh.getBeginTime() <= 0) {
+                            hw.setEndTime(hw.getStartTime());
+                        } else {
+                            hw.setStartTime(new Date(sh.getBeginTime()));
+                            hw.setEndTime(new Date(sh.getBeginTime() + sh.getCostTime() * 60 * 1000));
+                        }
+                    } else if ((hw.getUsedTime() == null || hw.getUsedTime() <= 0) && (sh.getBeginTime() != null && sh.getBeginTime() > 0)){
+                        hw.setStartTime(new Date(sh.getBeginTime()));
+                        hw.setEndTime(new Date(sh.getBeginTime() + sh.getCostTime() * 60 * 1000));
+                    }
+                    hw.setWorkingType(sh.getType());
+                    if (sh.getCostTime() > 0){
+                        hw.setUsedTime((long)sh.getCostTime());
+                    }
+                    hw.setHomeworkType(1);
+                    hw.setPushId(push.getId());
+                    hw.setGrade(student.getGrade());
+                    hw.setWorkType(sh.getState());
+                    hw.setUnFinishedContent(sh.unfinish2String());
+                    homeworkService.save(hw);
+            	}
+            }
+        }
+        result.put("isSuccess", true);
+        return result;
+	}
+
+    @Override
+    public ZuoybStudentPush saveTotalitySituation(String pushId, List<String> picture, String suggest, TotalitySituationAdapter totality, String userId) {
+        ZuoybStudentPush push = null;
+        if (StringUtils.isNotBlank(pushId)){
+            push = zuoybStudentPushSerivce.getById(pushId);
+        } else {
+            push = new ZuoybStudentPush();
+        }
+        if(CollectionUtils.isNotEmpty(picture)) {
+            if(StringUtils.isBlank(push.getImg())) {
+                //作业登记图片多张用逗号隔开
+                String imgList = picture.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(","));
+                push.setImg(imgList);
+            }else {
+                //作业登记只能新增不能删除
+                String[] imgStr = push.getImg().split(",");
+                List<String> imgList = new ArrayList<>();
+                for (int i = 0; i < imgStr.length; i++) {
+                    imgList.add(imgStr[i]);
+                }
+                for (String str : picture) {
+                    if(!imgList.contains(str)) {
+                        imgList.add(str);
+                    }
+                }
+                //作业登记图片多张用逗号隔开
+                String imgs = imgList.stream().filter(string ->!string.isEmpty()).collect(Collectors.joining(","));
+                push.setImg(imgs);
+            }
+        }
+        push.setTeacherId(userId);
+        push.setSuggest(suggest);
+        push.setSubhtml(suggest);
+        push.setWorkingSpeed(totality.getSpeedScore());
+        push.setWorkingActivity(totality.getActiveScore());
+        push.setWorkingAutomaticity(totality.getAutomaticScore());
+        push.setWorkingConcentration(totality.getConcernScore());
+        push = zuoybStudentPushSerivce.save(push);
+        return push;
+    }
+
+
+    @Override
+    public HomeworkDataDto getHomeworkData(String studentId, String date, String userId) {
+        if (StringUtils.isEmpty(date)){
+            date = DateUtil.getCurrentDateString();
+        }
+
+        LibVip student = vipService.getById(studentId);
+        HomeworkDataDto hd = new HomeworkDataDto();
+        if (student == null) {
+            logger.error("查询不到学生的信息, id={}", studentId);
+            return hd;
+        }
+
+//        ZuoybStudentPush push = zuoybStudentPushSerivce.findByVipIdToDay(studentId);
+        ZuoybStudentPush push = this.createTodayPush(studentId, userId);
+
+
+
+
+        //总体信息
+        hd.setPushId(push.getId());
+        List<String> homeworkCheckInList = new ArrayList<String>();
+        if(StringUtils.isNotBlank(push.getImg())) {
+        	homeworkCheckInList = Arrays.asList(push.getImg().toString().split(","));
+        }
+        hd.setHomeworkPicture(homeworkCheckInList);
+        hd.setSuggestion(push.getSuggest());
+        hd.initLearningState();
+        for (LearningStateDto item : hd.getLearningState()){
+            if ("作业速度".equals(item.getName()) && push.getWorkingSpeed() != null && push.getWorkingSpeed() > 0){
+                item.setScore(push.getWorkingSpeed());
+            }
+
+            if ("自律性".equals(item.getName()) && push.getWorkingAutomaticity() != null && push.getWorkingAutomaticity() > 0){
+                item.setScore(push.getWorkingAutomaticity());
+            }
+
+            if ("积极性".equals(item.getName()) && push.getWorkingActivity() != null && push.getWorkingActivity() > 0){
+                item.setScore(push.getWorkingActivity());
+            }
+
+            if ("专注度".equals(item.getName()) && push.getWorkingConcentration() != null && push.getWorkingConcentration() > 0){
+                item.setScore(push.getWorkingConcentration());
+            }
+        }
+
+        //学生信息
+
+        StudentInfo si = new StudentInfo();
+        si.setStudentId(studentId);
+        si.setName(student.getChildName());
+        si.setGrade(student.getGrade());
+        si.setSchool(student.getSchool());
+        si.setImage(student.getImgUrl());
+        if (StringUtils.isNotEmpty(student.getTagsCharacter())){
+            for (String label : student.getTagsCharacter().split(";")){
+                si.addLabel(label);
+            }
+        }
+        if (StringUtils.isNotEmpty(student.getTagsHabit())){
+            for (String label : student.getTagsHabit().split(";")){
+                si.addLabel(label);
+            }
+        }
+        hd.setChildInfo(si);
+
+        //用时数组
+        List<Homework> hwList = homeworkService.queryDateHomework(studentId, DateUtil.parse_yyyyMMdd(date));
+        for (String key : CourseConstant.getSubjectList(student.getGrade())){
+            SubjectParamDto spd = new SubjectParamDto();
+            spd.setSubject(key);
+            spd.initUnfinishOption();
+            hd.addSubjectData(spd);
+        }
+        List<String> homeworkIds = new ArrayList<>();
+        for (Homework hw : hwList){
+            for (SubjectParamDto spd : hd.getSubjectDataList()){
+                if (spd.getSubject().equals(hw.getSubject())){
+                    spd.setCostTime(hw.getUsedTime() == null ? 0 : hw.getUsedTime().intValue());
+                    spd.setBeginTime(hw.getStartTime().getTime());
+                    //设置计时状态,有计时状态并且作业是老师端计时的
+                    if (hw.getWorkingType() != null && hw.getHomeworkType() != null && hw.getHomeworkType() == 1){
+                        spd.setType(hw.getWorkingType());
+                    }
+                    //设置完成的状态
+                    if (hw.getWorkType() != null && hw.getWorkType() > 0){
+                        spd.setFinishState(hw.getWorkType());
+                    }
+
+                    //设置未完成内容
+                    if (hw.getWorkType() != null && hw.getWorkType() == 2
+                            && StringUtils.isNotEmpty(hw.getUnFinishedContent())){
+                        String[] ai = hw.getUnFinishedContent().split(",");
+                        for (String key : ai){
+                            for (LabelStateDto ls : spd.getUnfinishedList()){
+                                if (ls.getName().equals(key)){
+                                    ls.setActive(1);
+                                    break;
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            homeworkIds.add(hw.getId());
+        }
+        if (homeworkIds.size() > 0){
+            List<HomeworkPicture> homeworkPictureList = homeworkPictureService.findHomeworkPictureByHomeworkIds(homeworkIds);
+            if (homeworkPictureList != null){
+                for (SubjectParamDto spd : hd.getSubjectDataList()){
+                    for(HomeworkPicture hp : homeworkPictureList){
+                        if (spd.getSubject().equals(hp.getSubject())){
+                            HomeworkPictureDto hpd = new HomeworkPictureDto();
+                            hpd.setPid(hp.getId());
+                            hpd.setImage(hp.getFileKey());
+                            if (hp.getIsMark() > 0){
+                                hpd.setIsCorrected(hp.getIsMark());
+                                if (hp.getIsMark() == 1){
+                                    hpd.setIsCorrected(4);
+                                }
+                            }
+                            if (hp.getIsFeedback() == 1 ){
+                                hpd.setIsCorrected(1);
+                            }
+                            spd.addHomeworkPicture(hpd);
+                        }
+                    }
+                }
+            }
+        }
+
+        return hd;
+    }
+
+    @Override
+    @Transactional
+    public ZuoybStudentPush createTodayPush (String vipId, String userId){
+        ZuoybStudentPush push = zuoybStudentPushSerivce.findByVipIdToDay(vipId);
+        if (push == null){
+            TbLibManager teacher = bookManagerService.findByUserId(userId, Constant.TEACHER_TYPE);
+            if (teacher != null){
+                push = new ZuoybStudentPush();
+                push.setVipId(vipId);
+                push.setLibId(teacher.getLibId());
+                push.setTeacherId(userId);
+                push.setPushTime(new Date());
+                //设置编辑中状态
+                push.setType(1);
+                //写死courseHour
+                push.setCourseHour("A");
+                push = zuoybStudentPushSerivce.save(push);
+            } else {
+                logger.error("查询不到老师，teacherId={}", userId);
+            }
+        }
+        return push;
+    }
+
+    @Override
+    public boolean deleteOnePicture(String pid) {
+        boolean result = false;
+        if (StringUtils.isNotEmpty(pid)){
+            HomeworkPicture hp = homeworkPictureService.getById(pid);
+            if (hp != null){
+                if ((hp.getLocking() == null || hp.getLocking() == 0) && hp.getIsFeedback() != 1){
+                	if(StringUtils.isNotBlank(hp.getTeacherId())) {
+                		//如果有分配老师则将老师的待批改累计数-1
+                    	bookManagerService.updateCorrectHomeworkNum(hp.getVipId(), hp.getTeacherId(), -1);
+                	}
+                	//如果是最后一张图片
+                	//删除作业图片文件资源
+                    fileInfoService.deleteByFilePath(hp.getFileKey());
+                    homeworkPictureService.delete(pid);
+                    result = true;
+                } else {
+                    result = false;
+                    logger.warn("作业图片已被锁住，pid={}", pid);
+                }
+            } else {
+                result = false;
+                logger.error("查询不到作业图片， pid={}", pid);
+            }
+        } else {
+            result = false;
+            logger.warn("删除作业图片时图片id不能为空");
+        }
+        return result;
+    }
+
+
+
+    @Override
+    public boolean submitReport(String pushId) {
+        boolean result = false;
+        ZuoybStudentPush  push  = zuoybStudentPushSerivce.getById(pushId);
+        if (push != null){
+            result = true;
+            boolean needPush = false;
+            List<String> homeworkIdList = homeworkService.findIdPictureNotUpload(push.getVipId());
+            if (CollectionUtils.isEmpty(homeworkIdList)) {
+                //没有还未上传图片的作业，需判断是否已批改完成
+                List<Map<String, Object>> list = tzybService.findFeddBackInfo(push.getVipId());
+                if (list != null && list.size() > 0) {
+                    //在线老师未批改完成
+                    push.setType(3);
+                } else {
+                    //在线老师已批改完成
+                    needPush = true;
+                }
+            }
+            if (needPush) {
+                //在线老师已批改完成，在馆老师需要带推送
+                push.setType(2);
+                try{
+                    LibVip vip= vipService.getById(push.getVipId());
+                    //保存学习历史
+                    zuoybDayService.saveToday(vip.getId(), 1);
+                    //推送给家长公众号消息
+                    tzybService.sendTemplateTeacher(userService.getAccount(vip.getUserId()), vip.getChildName(), push.getVipId(), WxUtil.map.get("jzdAppId"));
+
+                    //推送家长
+                    String contentMessage =  "尊敬的"+vip.getChildName()+"家长，您孩子今日的作业反馈报告已生成";
+                    sconXingeService.asynPushThreadTask(vip.getUserId(), null, 2, contentMessage, PushConstants.PUSH_HOMEWORK);
+
+                    //推送馆长
+//                    if (org.apache.commons.lang3.StringUtils.isNotBlank(push.getLibId())){
+//                        zuoybStudentWorkService.sendHomeworkReport2LibManager(push.getLibId(),  vip.getChildName(),  push.getId(),WxUtil.map.get("lsdAppId"));
+//                    }
+                } catch (Exception e){
+                    logger.error("推送异常", e);
+                }
+            }
+            zuoybStudentPushSerivce.save(push);
+        } else {
+            logger.error("查询不到push记录，pushId={}", pushId);
+        }
+        return result;
+    }
+
+    @Override
+    public Map<String, Object> saveSubjectHomework(SubjectImageSubmitRequest request, String userId) {
+        Map<String, Object> result = new HashMap<>();
+        TbLibManager teacher = bookManagerService.findByUserId(userId, Constant.TEACHER_TYPE);
+        LibVip student = libVipService.getById(request.getStudentId());
+        LibVipService  libvipService = libVipServiceService.getVipIdZXService5days(student, teacher.getLibId());
+        if(libvipService == null){
+            result.put("isSuccess", false);
+            result.put("msg", "作业吧服务已失效");
+            logger.warn("{}学生的作业吧服务已失效", student.getChildName());
+            return result;
+        }
+
+        //作业记录
+        ZuoybStudentPush push = this.createTodayPush(student.getId(), userId);
+        Homework homework = homeworkService.findByTodaySubjectHomework(request.getStudentId(), request.getSubject());
+        Date nowDateTime = new Date();
+        if (homework == null){
+            homework = new Homework();
+            Date date = nowDateTime;
+            homework.setCreateTime(date);
+            homework.setStartTime(date);
+            homework.setEndTime(date);
+            homework.setParentId(student.getUserId());
+            homework.setDerver(student.getDerver());
+            homework.setVipId(student.getId());
+            homework.setSubject(request.getSubject());
+            homework.setGrade(student.getGrade());
+            homework.setUsedTime(0L);
+            //作业吧
+            homework.setHomeworkType(1);
+            homework.setGrade(student.getGrade());
+        }
+
+        //如果有记录的话，设置一下pushId
+        if (push != null){
+            homework.setPushId(push.getId());
+        }
+        homework = homeworkService.save(homework);
+
+        String onlineTeacherId = teacherService.getHomeworkTeacherId(request.getStudentId(), request.getSubject());
+        List<HomeworkPictureDto> list = new ArrayList<>();
+        HomeworkPictureDto hpd = null;
+        for (String img : request.getImages()){
+            HomeworkPicture pic = new HomeworkPicture();
+            pic.setCreateTime(nowDateTime);
+            //获取的homework有数据的话，添加homeworkId到picture表
+            pic.setHomeworkId(homework.getId());
+            pic.setDerver(student.getDerver());
+            pic.setFileKey(img);
+            pic.setAllotTime(nowDateTime);
+            pic.setTeacherId(onlineTeacherId);
+            pic.setZybWorkStat(2);
+            pic.setIsFeedback(0);
+            pic.setSubject(request.getSubject());
+            pic.setVipId(request.getStudentId());
+            pic = homeworkPictureService.save(pic);
+            picturePreDealService.asyncPostRequest2AI(pic);
+
+            hpd = new HomeworkPictureDto();
+            hpd.setPid(pic.getId());
+            hpd.setImage(pic.getFileKey());
+            if (pic.getIsMark() > 0){
+                hpd.setIsCorrected(pic.getIsMark());
+                if (pic.getIsMark() == 1){
+                    hpd.setIsCorrected(4);
+                }
+            }
+            if (pic.getIsFeedback() == 1 ){
+                hpd.setIsCorrected(1);
+            }
+            list.add(hpd);
+        }
+
+        if (StringUtils.isNotEmpty(onlineTeacherId)){
+            //更新选定批改老师的实时权重和批改图片总数
+            managerService.updateCorrectHomeworkNum(request.getStudentId(), onlineTeacherId, request.getImages().size());
+
+            //给线上批改的老师推送消息
+            homeworkPictureService.sendMsg4SubmitWork(request.getStudentId(), onlineTeacherId);
+
+            //推送在线老师
+            homeworkPictureService.sendTempMsg2OnlineTeacher(onlineTeacherId, student.getChildName(), nowDateTime, request.getSubject());
+
+            List<TbLibManager> libManagerList = managerService.findByUserIdAndTypeIn(onlineTeacherId, new int[]{8, 11});
+            if (CollectionUtils.isNotEmpty(libManagerList)) {
+                TbLibManager correctTeacher = libManagerList.get(0);
+                String content = "尊敬的" + correctTeacher.getName() + "老师，您负责的" + student.getChildName() + "学生，已经于" + DateUtil.dateTimeToString(nowDateTime) + "时间完成" + request.getSubject() + "作业，请您尽快完成作业批改！";
+                this.sconXingeService.asynPushThreadTask(onlineTeacherId, 4, XinGePushMessageTypeEnum.Message.getCode(), XinGePushBusinessTypeEnum.HomeworkCorrectNotice.getCode(), "作业批改提醒", content, "APP_TEACHER", PushConstants.PUSH_OTHER);
+            }
+        }
+
+
+        result.put("isSuccess",  true);
+        result.put("msg", "成功");
+        result.put("data", list);
+        return result;
+    }
+	
+}
+

ssj-sys/src/main/java/com/ssj/service/conch/teacher/task/QuestionRecommendRecordSaveTask.java

@@ -0,0 +1,36 @@
+package com.ssj.service.conch.teacher.task;
+
+import com.alibaba.fastjson.JSON;
+import com.ssj.bean.kmt.kmt.domain.QuestionRecommendRecord;
+import com.ssj.service.kmt.service.QuestionRecommendRecordService;
+import com.ssj.taskthread.Task;
+
+/**
+ * @author yrf
+ * @description
+ * @time 2020/3/17 13:18
+ */
+public class QuestionRecommendRecordSaveTask extends Task {
+
+    private QuestionRecommendRecord questionRecommendRecord;
+    private QuestionRecommendRecordService questionRecommendRecordService;
+
+    public QuestionRecommendRecordSaveTask(QuestionRecommendRecord questionRecommendRecord,
+                                           QuestionRecommendRecordService questionRecommendRecordService) {
+
+        super();
+        this.questionRecommendRecord = questionRecommendRecord;
+        this.questionRecommendRecordService = questionRecommendRecordService;
+    }
+
+    @Override
+    public void run() {
+        try {
+            questionRecommendRecordService.save(questionRecommendRecord);
+        } catch (Exception e) {
+            logger.error("questionRecommendRecord={}", JSON.toJSONString(questionRecommendRecord));
+            logger.error("异步保存推荐题目记录异常", e);
+        }
+    }
+
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CSDetailFileServiceImpl.java

@@ -0,0 +1,25 @@
+package com.ssj.service.course.service.impl;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseSeriesDetailFile;
+import com.ssj.dao.course.dao.ICSDetalFileDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.course.service.ICSDetailFileService;
+
+@Service(version="1.0")
+public class CSDetailFileServiceImpl extends BaseServiceImpl<CourseSeriesDetailFile, String>
+		implements ICSDetailFileService {
+
+	@Autowired
+	private ICSDetalFileDao dao;
+	
+	@Override
+	public PagingAndSortingRepository<CourseSeriesDetailFile, String> getDao() {
+		
+		return dao;
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CSDetailServiceImpl.java

@@ -0,0 +1,79 @@
+package com.ssj.service.course.service.impl;
+
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseSeriesDetail;
+import com.ssj.dao.course.dao.CourseQueryDao;
+import com.ssj.dao.course.dao.ICSDetailDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.persistence.DynamicSpecifications;
+import com.ssj.framework.core.persistence.SearchFilter;
+import com.ssj.service.course.service.ICSDetailService;
+
+@Service(version="1.0")
+@Transactional
+public class CSDetailServiceImpl extends BaseServiceImpl<CourseSeriesDetail, String> implements ICSDetailService {
+
+	@Autowired
+	private ICSDetailDao dao;
+	
+	@Autowired
+	private  CourseQueryDao  courseQueryDao;
+	
+	@Override
+	public PagingAndSortingRepository<CourseSeriesDetail, String> getDao() {
+		return dao;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Page<CourseSeriesDetail> findByPage(Map<String, Object> params, Pageable initPage) {
+		Map<String, SearchFilter> filters = SearchFilter.parse(params);
+		Specification<CourseSeriesDetail> specification = DynamicSpecifications.bySearchFilter(filters.values(), CourseSeriesDetail.class);    
+		return  dao.findAll(specification, initPage);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<CourseSeriesDetail> findBySeriesId(String seriesId) {
+		return dao.findBySeriesId(seriesId);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Integer findBySeriesIdCount(String seriesId) {
+		return dao.findBySeriesIdCount(seriesId);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> findSeriesDetailsByUserId(String seriesId,
+			String userId,String vipId, String libId) {
+		return courseQueryDao.findSeriesDetailsByUserId(seriesId, userId,vipId, libId);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesDetail getCourseSeriesDetailByCourseIndex(
+			String seriesId, Integer courseIndex) {
+		return dao.getCourseSeriesDetailByCourseIndex(seriesId, courseIndex);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<CourseSeriesDetail> findBySeriesIdAndAfterIndex(String seriesId, Integer courseIndex) {
+	
+		return dao.findBySeriesIdAndAfterIndex(seriesId,courseIndex);
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CSServiceImpl.java

@@ -0,0 +1,566 @@
+package com.ssj.service.course.service.impl;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Reference;
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseDetailFeedbackLib;
+import com.ssj.bean.course.domain.CourseSeries;
+import com.ssj.bean.course.domain.CourseSeriesDetail;
+import com.ssj.bean.course.domain.CourseSeriesJoin;
+import com.ssj.bean.course.domain.CourseSeriesSetting;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.bean.weixin.push.domain.Miniprogram;
+import com.ssj.bean.weixin.push.domain.SendTemplateShort;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.dao.course.dao.CourseQueryDao;
+import com.ssj.dao.course.dao.ICSDao;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.persistence.DynamicSpecifications;
+import com.ssj.framework.core.persistence.SearchFilter;
+import com.ssj.framework.weixin.util.WxUtil;
+import com.ssj.service.course.req.CourseChangeReq;
+import com.ssj.service.course.res.ChangeLessonDetailRes;
+import com.ssj.service.course.res.ChangeLessonRes;
+import com.ssj.service.course.res.CourseLessonRes;
+import com.ssj.service.course.service.CourseSeriesJoinService;
+import com.ssj.service.course.service.CourseSeriesOrderService;
+import com.ssj.service.course.service.CourseSeriesSettingService;
+import com.ssj.service.course.service.ICSDetailService;
+import com.ssj.service.course.service.ICSService;
+import com.ssj.service.course.service.ICouseLibFeedbackService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import com.ssj.service.weixin.push.service.PushTemplateService;
+import com.ssj.service.weixin.user.service.UserService;
+
+@Service(version="1.0")
+@Transactional
+public class CSServiceImpl extends BaseServiceImpl<CourseSeries, String> implements ICSService {
+
+	@Autowired
+	private ICSDao dao;
+	@Autowired
+	private CourseQueryDao courseQueryDao;
+	@Autowired
+	private CourseSeriesOrderService courseSeriesOrderService;
+
+	@Autowired
+	private ICSDetailService csDetailService;
+
+	@Autowired
+	private ICouseLibFeedbackService courseLibFeedbackService;
+
+	@Autowired
+	private CourseSeriesJoinService joinService;
+
+	@Autowired
+	private CourseSeriesSettingService settingService;
+
+	@Autowired
+	private UserService userService;
+
+	@Autowired
+	private ILibVipService vipService;
+
+	 @Autowired
+	private PushTemplateService pushTemplateService;
+
+	@Override
+	public PagingAndSortingRepository<CourseSeries, String> getDao() {
+
+		return dao;
+	}
+
+	private static List<String> colors=new ArrayList<String>();
+
+	static{
+		colors.add("#FF80A8");
+		colors.add("#00B7FF");
+		colors.add("#3A95FF");
+		colors.add("#FFBE0F");
+		colors.add("#FF6464");
+		colors.add("#FF80A8");
+		colors.add("#00B7FF");
+		colors.add("#3A95FF");
+		colors.add("#FFBE0F");
+		colors.add("#FF6464");
+	}
+
+
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> getCourseAll() {
+		List<Map<String, Object>> list =new ArrayList<Map<String,Object>>();
+		Map<String, Object> map1 =new HashMap<String, Object>();
+		map1.put("course_hot_lable", "1");
+		map1.put("list", this.getCourseAll(1, 1));
+		Map<String, Object> map2 =new HashMap<String, Object>();
+		map2.put("course_hot_lable", "2");
+		map2.put("list", this.getCourseAll(2, 1));
+		Map<String, Object> map3 =new HashMap<String, Object>();
+		map3.put("course_hot_lable", "3");
+		map3.put("list", this.getCourseAll(3, 2));
+		list.add(map1);
+		list.add(map2);
+		list.add(map3);
+		return list;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Page<CourseSeries> findByPage(Map<String, Object> params, Pageable initPage) {
+		Map<String, SearchFilter> filters = SearchFilter.parse(params);
+		Specification<CourseSeries> specification = DynamicSpecifications.bySearchFilter(filters.values(), CourseSeries.class);
+		return  dao.findAll(specification, initPage);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> getCourseAll(int courseTypeLabel,int offset) {
+		return courseQueryDao.getCourseAll(courseTypeLabel,offset);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> getManageJoin(String userId) {
+		return courseQueryDao.getManageJoin(userId);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> getTeacherCourseInfo(String libId, String userId,int type) {
+
+		return courseQueryDao.getTeacherCourseInfo(libId,userId,type);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<CourseSeries> findByBuy(String libId) {
+		List<CourseSeries> list = courseQueryDao.findByBuy(libId);
+		for (CourseSeries courseSeries : list) {
+			String rate =dao.getDurationByLibIdAndCourseSeriesId(libId, courseSeries.getId());
+			courseSeries.setInterruptRate(rate!=null ? rate :"0");
+			courseSeries.setStudentNumber(courseSeriesOrderService.getCurrentStudentSize(libId,  courseSeries.getId()));
+		}
+		return list;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Map<String, Object> getThisCourseInfo(Map<String, Object> search) {
+		String format="yyyy-MM-dd";
+		Map<String, Object> reqMap=courseQueryDao.getThisCourseInfo(search);
+
+		/**
+		 * 计算出
+		 * next_course
+		 * studyed_course
+		 * course_index
+		 *
+		 * course_details_id
+		 * course_unit
+		 */
+		if(reqMap!=null && reqMap.get("course_series_id")!=null){
+			Integer courseIndex=1;
+			String nextCourse="无";
+			Integer studyedCourse=0;
+			String courseDetailsId="";
+			String courseUnit="";
+			Integer isSend=0;
+			String feedbackId="";
+
+			String courseDate="";
+			if(reqMap.get("course_date")!=null){
+				courseDate=reqMap.get("course_date").toString();
+			}
+			String[] courseDateArrays=courseDate.split(",");
+			//courseIndex=courseDateArrays.length;//默认值为最大
+			Date curDate=DateHelper.parseDate(DateHelper.format(new Date(), format), format);
+			for (int i = 0; i < courseDateArrays.length; i++) {
+				if(DateHelper.parseDate(courseDateArrays[i], format).compareTo(curDate) == 0){
+					courseIndex = i+1;
+				}
+				if(DateHelper.parseDate(courseDateArrays[i], format).compareTo(curDate)>0){
+					nextCourse=courseDateArrays[i];
+					//courseIndex=i+1;
+					if(i>0){
+						if(DateHelper.parseDate(courseDateArrays[i-1], format).compareTo(curDate)==0){
+							studyedCourse=i-1;
+						}else{
+							studyedCourse=i;
+						}
+					}
+					break;
+				}
+			}
+			CourseSeriesDetail courseSeriesDetail=csDetailService.getCourseSeriesDetailByCourseIndex((String)reqMap.get("course_series_id"), courseIndex);
+			if(courseSeriesDetail!=null){
+				courseDetailsId=courseSeriesDetail.getId();
+				courseUnit=courseSeriesDetail.getCourseUnit();
+
+				String libId=search.get("libId").toString();
+				CourseDetailFeedbackLib courseDetailFeedbackLib=courseLibFeedbackService.getCourseDetailFeedbackLibByTeacherId(libId,courseDetailsId);
+
+				if(courseDetailFeedbackLib!=null){
+					isSend=1;
+					feedbackId=courseDetailFeedbackLib.getId();
+				}
+			}
+			reqMap.put("studyed_course", studyedCourse);
+			reqMap.put("course_details_id", courseDetailsId);
+			reqMap.put("next_course", nextCourse);
+			reqMap.put("course_unit", courseUnit);
+			reqMap.put("is_send", isSend);
+			reqMap.put("feedback_id", feedbackId);
+		}
+		return reqMap;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> getCourseStudentList(Map<String, Object> search) {
+
+		return courseQueryDao.getCourseStudentList(search);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Map<String, Object> getFeedBackInfo(String courseDetailId, String vipId,String libId) {
+
+		return courseQueryDao.getFeedBackInfo(courseDetailId,vipId,libId);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public String getLatestTime(int type) {
+		return dao.getLatestTime(type);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Double getAvg(int type) {
+		return dao.getAvg(type);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Long getCountVip(int type) {
+		return dao.getCountVip(type);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Long getfinAll(int type) {
+		return dao.getfinAll(type);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Map<String, Object> getFeedBackInfoById(String id) {
+
+		return courseQueryDao.getFeedBackInfoById(id);
+	}
+
+
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public String getCourseSeriesByColor() {
+		String reqColor="#FF6464";
+		List<String> list= courseQueryDao.getCourseSeriesByColor();
+		for (String color : colors) {
+			if(!list.contains(color)){
+				reqColor=color;
+				break;
+			}
+		}
+		return reqColor;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> getCourseStudentListV2(Map<String, Object> search) {
+
+		return courseQueryDao.getCourseStudentListV2(search);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<CourseLessonRes> findOrderCourseList(String libId,String userId) {
+		List<Map<String, Object>> list = courseQueryDao.findOrderCourseList(libId,userId);
+		List<CourseLessonRes> resList = new ArrayList<CourseLessonRes>();
+		if(list !=null && list.size()>0){
+			for (Map<String, Object> map : list) {
+				CourseLessonRes res = new CourseLessonRes();
+				res.setCourseCover(map.get("cover_url")==null?"":map.get("cover_url").toString());
+				res.setCourseName(map.get("course_name")==null?"":map.get("course_name").toString());
+				res.setCourseSeriesId(map.get("id").toString());
+				res.setLessonCount(Integer.parseInt(map.get("lesson_count").toString()));
+				res.setStudentCount(Integer.parseInt(map.get("student_count")==null?"0":map.get("student_count").toString()));
+				res.setNextCourseTime(map.get("next_course_time")==null?"":map.get("next_course_time").toString());
+				resList.add(res);
+			}
+		}
+		return resList;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Map<String, Object> studentManagerList(String libId, String courseSeriesId) {
+		Map<String, Object> map = new HashMap<>();
+		CourseSeries series = this.getById(courseSeriesId);
+		map.put("courseSeriesId", courseSeriesId);
+		map.put("courseName", series.getCourseName());
+		map.put("courseCover", series.getCoverUrl());
+		List<Map<String, Object>> list = courseQueryDao.studentManagerList(libId,courseSeriesId);
+		map.put("studentCount", list.size());
+		List<Map<String, Object>> list2 = new ArrayList<Map<String, Object>>();
+		if(list != null && list.size()>0){
+			for (Map<String, Object> map2 : list) {
+				Map<String, Object> map3 = new HashMap<>();
+				map3.put("vipId", map2.get("id"));
+				map3.put("childName", map2.get("child_name"));
+				map3.put("headImg", map2.get("img_url"));
+				list2.add(map3);
+			}
+
+		}
+		map.put("list", list2);
+
+		return map;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Map<String, Object> bkManagerList(String libId, String courseSeriesId) {
+		Map<String, Object> map = new HashMap<>();
+		CourseSeries series = this.getById(courseSeriesId);
+		map.put("courseSeriesId", courseSeriesId);
+		map.put("courseName", series.getCourseName());
+		map.put("courseCover", series.getCoverUrl());
+		map.put("sugStudent", series.getClassPnum());
+		map.put("sugStudentGrade", series.getCourseTarget());
+		//查询一个学生
+		CourseSeriesJoin join = joinService.findOneDataByAny(libId,courseSeriesId);
+		List<Map<String, Object>> list = courseQueryDao.findDetailBySeriesId(libId,courseSeriesId,join.getVipId());
+		map.put("courseCount", list.size());
+		List<Map<String, Object>> list2 = new ArrayList<Map<String, Object>>();
+		if(list != null && list.size()>0){
+			for (Map<String, Object> map2 : list) {
+				Map<String, Object> map3 = new HashMap<>();
+				map3.put("detailId", map2.get("id"));
+				map3.put("detailName", map2.get("course_unit"));
+				map3.put("courseDuration", map2.get("course_duration"));
+				map3.put("lastUsedTime",map2.get("begin_time")==null?"":map2.get("begin_time").toString().substring(0, 19) );
+				map3.put("courseContent", map2.get("course_content").toString().replaceAll("\r","").replaceAll("\n", ""));
+				list2.add(map3);
+			}
+
+		}
+		map.put("list", list2);
+
+		return map;
+	}
+
+	@Override
+	public void confirmChange(CourseChangeReq req) {
+
+
+		//查找详情实体
+		CourseSeriesDetail detail = csDetailService.getById(req.getCourseDetailId());
+		//找到一条老师设置
+		CourseSeriesSetting  setting = settingService.fingByCourseSeriesIdAndLibIdLimit(detail.getSeriesId(), req.getLibId());
+		List<String> weeks =Arrays.asList(setting.getWeeks().split(","));
+		StringBuffer  stringbuff =new StringBuffer();
+		String dates = setting.getCourseDate();
+		List<String> dateList = Arrays.asList(dates.split(","));
+		Date openTime = DateHelper.parseDate(req.getNewTime(), "yyyy-MM-dd");
+		Date newDate = DateHelper.parseDate(req.getNewTime(), "yyyy-MM-dd");
+		Date oldDate = DateHelper.parseDate(req.getOldTime(), "yyyy-MM-dd");
+		Date searchDate = newDate;
+		if(newDate.before(oldDate)){
+			searchDate = newDate;
+		}else{
+			searchDate = oldDate;
+		}
+		//找到一个学生
+		CourseSeriesJoin join = joinService.findOneDataByDetail(req.getLibId(),req.getCourseDetailId());
+		//查出学生的所有上课时间
+		List<CourseSeriesJoin> list = joinService.findbyLibAndVip(req.getLibId(),detail.getSeriesId(),join.getVipId(),join.getNum(),searchDate);
+		list.add(0,join);
+		//找出离新调课时间最近的一堂课的实体
+		CourseSeriesJoin join2 = joinService.findOneDataByDetailAndTime(req.getLibId(),detail.getSeriesId(),searchDate);
+		if(req.getIsPostpone()!=null && req.getIsPostpone()==2){ //以后的课程按照开课设置顺延
+
+			//List<CourseSeriesDetail> list =csDetailService.findBySeriesIdAndAfterIndex(detail.getSeriesId(), detail.getCourseIndex());
+			String courseDates =  dates.split(req.getOldTime())[0];
+
+			int day = DateHelper.getday(openTime)-1	;//周四
+			// 计算今天是周几，  看是否有提交的 周几上课
+			Integer few =-1;
+			if(few==-1){
+				for (int j = 0; j < weeks.size(); j++) {
+					few=	Integer.parseInt(weeks.get(j))-day>=0?j:-1;
+					if(few>-1){
+						break;
+					}
+				}
+			}
+			if(few ==-1)few =0;
+			Integer we =Integer.parseInt(weeks.get(few));//第一个
+			Integer oldwe =day;
+
+			stringbuff.append(courseDates);
+			int num = join2==null?1:join2.getNum();
+			int i =0;
+			for (CourseSeriesJoin join1:list) {
+				if(i>0 || (we.equals(oldwe))){
+					if(weeks.size()==1){
+						if(i==0){
+							openTime=DateHelper.getNextDay(openTime,(we-oldwe>0?we-oldwe:we-oldwe+7));
+						}else{
+							openTime=DateHelper.getNextDay(openTime,(we+7-oldwe));
+						}
+
+					}else{
+						openTime=DateHelper.getNextDay(openTime, we >=oldwe ? (we-oldwe) :(we+7-oldwe));
+					}
+					//openTime=DateHelper.getNextDay(openTime, we >=oldwe ? (we-oldwe) :(we+7-oldwe));
+				}
+
+				stringbuff.append(DateHelper.format(openTime,"yyyy-MM-dd"));;
+				if(i<list.size()-1){
+					stringbuff.append(",");
+				}
+				num++;
+				joinService.updateJoinDate(join1.getCourseDetailsId(),  req.getLibId(), num, openTime);
+				if(i>0 || (we.equals(oldwe))){
+					oldwe =we;
+					few ++;
+					few=few %weeks.size();
+					we =Integer.parseInt(weeks.get(few));
+				}
+
+				i++;
+			}
+
+
+		}else{ //不顺延
+
+			//查一条开课设置
+			//int courseIndex = detail.getCourseIndex()-1;
+			boolean ischange = true;
+			for (int j = 0; j < dateList.size(); j++) {
+				if(req.getOldTime().equals(dateList.get(j)) && ischange){
+					stringbuff.append(req.getNewTime());
+					ischange=false;
+				}else{
+					stringbuff.append(dateList.get(j));
+				}
+				if(j<dateList.size()-1){
+					stringbuff.append(",");
+				}else{
+					openTime = DateHelper.parseDate(dateList.get(j), "yyyy-MM-dd");
+				}
+			}
+			int num = join2==null?0:join2.getNum();
+			for (CourseSeriesJoin join1:list) {
+				//join1.setNum(num);
+				//joinService.save(join1);
+				num++;
+				if(join1.getCourseDetailsId().equals(req.getCourseDetailId())){
+					//更新记录
+					joinService.updateDetailsData(req.getCourseDetailId(),req.getNewTime(),req.getLibId(),num);
+				}else{
+					joinService.updateJoinDate2(join1.getCourseDetailsId(),  req.getLibId(), num);
+				}
+
+
+			}
+		}
+
+		if(openTime.before(newDate)){
+			openTime = newDate;
+		}
+		//更改开课设置表
+		String courseDate = stringbuff.toString();
+		List<String> courseList = Arrays.asList(courseDate.split(","));
+		Collections.sort(courseList);
+		settingService.updateSettingOneDay(req.getLibId(),StringUtils.join(courseList, ","),detail.getSeriesId(),openTime);
+		if(req.getIsCall()!=null && req.getIsCall()==2){ //调整上课时间通知家长
+			//获取到joinList
+			List<CourseSeriesJoin> joinList = joinService.findbyLibJoinList(detail.getId(),req.getLibId());
+			for (CourseSeriesJoin courseSeriesJoin : joinList) {
+				String id = "OPENTM410945628";
+				//尊敬的家长，您好，您所报读的xx课，原本计划上课时间为xxx，已调整为xxx时间，请您留意。
+				User user = userService.getById(courseSeriesJoin.getUserId());
+				LibVip vip = vipService.getById(courseSeriesJoin.getVipId());
+				String first = "尊敬的家长，您好，您孩子"+vip.getChildName()+"所报读的" + detail.getCourseUnit() + "原本计划上课时间为"+req.getOldTime()+"已调整为"+req.getNewTime()+"时间，请您留意。";
+				Map<String, String> data = new HashMap<String, String>();
+				data.put("first", first);
+				data.put("keyword1", "临时调课");
+				data.put("keyword2", req.getOldTime());
+				data.put("keyword3", req.getNewTime());
+				data.put("remark", "请您留意。");
+				Miniprogram m = this.getMiniprogram(WxUtil.map.get("courseAppId"), "pages/index/index");
+				SendTemplateShort sendTemplateShort = new SendTemplateShort(user.getAccount(), id, null, data, m);
+				pushTemplateService.saveAndSendPushWxTemplate(sendTemplateShort);
+			}
+		}
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<ChangeLessonRes> changeLessonList(String libId, String courseSeriesId) {
+		List<ChangeLessonRes> list = new ArrayList<ChangeLessonRes>();
+
+		//查询一个学生
+		CourseSeriesJoin join = joinService.findOneDataByAny(libId,courseSeriesId);
+		//查询这个课程有多少学生
+		int studentCount = joinService.findStudentCount(libId,courseSeriesId);
+		CourseSeries series = this.getById(courseSeriesId);
+		ChangeLessonRes res = new ChangeLessonRes();
+		res.setCourseSeriesId(series.getId());
+		res.setCourseName(series.getCourseName());
+		res.setCourseCover(series.getCoverUrl());
+
+		List<Map<String, Object>> qlist = courseQueryDao.getDateDetailList(libId,courseSeriesId,join.getVipId());
+		List<ChangeLessonDetailRes> dlist = new ArrayList<ChangeLessonDetailRes>();
+		for (Map<String, Object> map : qlist) {
+			ChangeLessonDetailRes dres = new ChangeLessonDetailRes();
+			dres.setCourseDetailId(map.get("id")==null?"":map.get("id").toString());
+			dres.setOpenTime(map.get("begin_time")==null?"":map.get("begin_time").toString());
+			dres.setStartTime(map.get("open_time")==null?"":map.get("open_time").toString());
+			dres.setDetailName(map.get("course_unit")==null?"":map.get("course_unit").toString());
+			dres.setStudentCount(studentCount);
+			dres.setState(map.get("begin_time")==null || "".equals(map.get("begin_time"))?3:map.get("feedback_id")==null?1:2);
+			dres.setFeedbackId(map.get("feedback_id")==null?"":map.get("feedback_id").toString());
+			dlist.add(dres);
+		}
+		res.setList(dlist);
+		list.add(res);
+		return list;
+	}
+
+	private Miniprogram getMiniprogram (String appId, String path){
+		Miniprogram miniprogram =new  Miniprogram();
+		miniprogram.setAppid(appId);
+		miniprogram.setPagepath(path);
+		return miniprogram;
+	}
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CourseFeedbackFileServiceImpl.java

@@ -0,0 +1,71 @@
+package com.ssj.service.course.service.impl;
+
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseFeedbackFile;
+import com.ssj.dao.course.dao.CourseQueryDao;
+import com.ssj.dao.course.dao.IFeedbackFileDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.course.service.ICourseFeedbackFileService;
+
+@Service(version="1.0")
+@Transactional
+public class CourseFeedbackFileServiceImpl extends BaseServiceImpl<CourseFeedbackFile, String> implements ICourseFeedbackFileService {
+
+	@Autowired
+	private IFeedbackFileDao dao;
+	@Autowired
+	private CourseQueryDao courseQueryDao;
+	
+	@Override
+	public PagingAndSortingRepository<CourseFeedbackFile, String> getDao() {
+		
+		return dao;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseFeedbackFile findOneData(String libId, String courseDetailId) {
+		
+		return dao.findOneData(libId,courseDetailId);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<String> getRedFlowList3(String libId, String vipId, String courseDetailId) {
+		
+		return dao.getRedFlowList3(libId,vipId,courseDetailId);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Integer getRedFlowCount(String libId, String vipId, String courseDetailsId, Date openTime) {
+	
+		return dao.getRedFlowCount(libId,vipId,courseDetailsId,openTime);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<String> getImgList(String libId, String backId, String courseDetailsId, Date openTime) {
+		
+		return dao.getImgList(libId,backId,courseDetailsId,openTime);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> getNextFile(String courseSeriesId, int num,
+			String fileType) {
+		return courseQueryDao.getNextFile(courseSeriesId, num-3,num+3, fileType);
+	}
+
+	
+
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CourseLearnServiceImpl.java

@@ -0,0 +1,41 @@
+package com.ssj.service.course.service.impl;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseLearn;
+import com.ssj.dao.course.dao.CourseLearnDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.course.service.CourseLearnService;
+
+
+
+/** 
+ * @author  wuwen 
+ * @version 2018年12月12日11:21:45
+ * 类说明 
+ */
+@Transactional
+@Service(version="1.0")
+public class CourseLearnServiceImpl extends BaseServiceImpl<CourseLearn, String> implements CourseLearnService {
+
+	@Autowired
+	private CourseLearnDao  dao;
+	
+	@Override
+	public PagingAndSortingRepository<CourseLearn, String> getDao() {
+		return dao;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseLearn findCourseLearnByFlowId(String courseName, String vipId) {
+		return dao.findCourseLearnByFlowId(courseName, vipId);
+	}
+	
+	
+	
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CourseLibFeedbackServiceImpl.java

@@ -0,0 +1,198 @@
+package com.ssj.service.course.service.impl;
+
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Reference;
+import com.alibaba.dubbo.config.annotation.Service;
+import com.alibaba.fastjson.JSON;
+import com.ssj.bean.course.domain.CourseDetailFeedbackLib;
+import com.ssj.bean.course.domain.CourseFeedbackFile;
+import com.ssj.bean.course.domain.CourseSeries;
+import com.ssj.bean.course.domain.CourseSeriesDetail;
+import com.ssj.bean.course.domain.CourseSeriesDetailFeedback;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.bean.weixin.push.domain.Miniprogram;
+import com.ssj.bean.weixin.push.domain.SendTemplateShort;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.dao.course.dao.ICourseLibFeedbackDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.framework.weixin.util.WxUtil;
+import com.ssj.service.course.req.TeacherFeedbackReqV2;
+import com.ssj.service.course.service.CourseSeriesDetailFeedbackService;
+import com.ssj.service.course.service.CourseSeriesJoinService;
+import com.ssj.service.course.service.ICSDetailService;
+import com.ssj.service.course.service.ICSService;
+import com.ssj.service.course.service.ICourseFeedbackFileService;
+import com.ssj.service.course.service.ICouseLibFeedbackService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import com.ssj.service.weixin.push.service.PushTemplateService;
+import com.ssj.service.weixin.user.service.UserService;
+
+@Transactional
+@Service(version="1.0")
+public class CourseLibFeedbackServiceImpl extends BaseServiceImpl<CourseDetailFeedbackLib, String> implements ICouseLibFeedbackService {
+
+	@Autowired
+	private ICourseLibFeedbackDao dao;
+	
+	@Autowired
+	private ILibVipService vipService;
+	 @Autowired
+	private PushTemplateService  pushTemplateService;
+	@Autowired
+	private CourseSeriesJoinService joinService;
+	@Autowired
+	private UserService userService;
+	
+	@Autowired
+	private ICSDetailService csDetailService;
+	@Autowired
+	private ICSService csService;
+	
+	@Autowired
+	private ICourseFeedbackFileService backFileService;
+	
+	@Autowired
+	private ICSService courseService;
+	
+	@Autowired
+	private CourseSeriesDetailFeedbackService feedbackService;
+	
+	@Override
+	public PagingAndSortingRepository<CourseDetailFeedbackLib, String> getDao() {
+		
+		return dao;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseDetailFeedbackLib findTodayVOByAnyParams(String courseDetailId, String libId) {
+		return dao.findTodayVOByAnyParams(courseDetailId,libId);
+	}
+
+	@Override
+	public void courseFeedbackSendV2(TeacherFeedbackReqV2 req,String userId) {
+		
+		//LibVip vip = vipService.getById(req.getVipId());
+		CourseDetailFeedbackLib back = dao.findTodayVOByAnyParams(req.getCourseDetailId(),req.getLibId());
+		int isSend = 0;
+		if(back != null){ 
+			if(back.getIsSend()==1){
+				isSend = 1;
+			}
+		}else{
+			back=new CourseDetailFeedbackLib();
+		}
+		CourseSeriesDetail courseDetail = csDetailService.getById(req.getCourseDetailId());
+		CourseSeries courseSeries = csService.getById(courseDetail.getSeriesId());
+		back.setUserId(userId);
+		back.setCourseContent(JSON.toJSONString(req.getCourseContentList()));//后续看怎么处理用；隔开
+		back.setCourseSeriesId(req.getCourseSeriesId());
+		back.setCourseTask(req.getClassTask());
+		back.setCreateTime(new Date());
+		back.setIsSend(1);
+		back.setLibId(req.getLibId());
+		back.setOpenTime(new Date());
+		back.setTodayLine(JSON.toJSONString(req.getInfoList()));
+		back.setCourseDetailsId(req.getCourseDetailId());
+		back.setTeacherSay(req.getSaying());
+		this.save(back);
+		
+		
+		//课程信息
+		Map<String, Object> studentsearch = new HashMap<String, Object>();
+		studentsearch.put("userId", userId);
+		studentsearch.put("courseSeriesId", req.getCourseSeriesId());
+		studentsearch.put("libId", req.getLibId());
+		//查找课程学生列表
+		studentsearch.put("courseDetailId", req.getCourseDetailId());
+		List<Map<String, Object>> studentMaplist = courseService.getCourseStudentListV2(studentsearch);
+		List<CourseSeriesDetailFeedback> cFeedbackList=new ArrayList<CourseSeriesDetailFeedback>();
+		CourseSeriesDetailFeedback cFeedback=null;
+		for (Map<String, Object> map : studentMaplist) {
+			String vipId=map.get("vip_id").toString();
+			String vUserId=map.get("user_id").toString();
+			
+			cFeedback=new CourseSeriesDetailFeedback();
+			cFeedback.setIsSend(1);
+			cFeedback.setLibId(req.getLibId());
+			cFeedback.setUserId(vUserId);
+			cFeedback.setVipId(vipId);
+			cFeedback.setSaying(req.getSaying());
+			cFeedback.setCreateTime(new Date());
+			cFeedback.setCourseDetailsId(req.getCourseDetailId());
+			cFeedback.setCourseSeriesId(courseDetail.getSeriesId());
+			cFeedback.setLibFeedbackId(back.getId());
+			cFeedback.setActiveScore((double)0);
+			cFeedback.setFocusScore((double)0);
+			cFeedbackList.add(cFeedback);
+		}
+		
+		if(cFeedbackList.size()>0){
+			feedbackService.save(cFeedbackList);
+		}
+		
+		
+		List<String> imgList = req.getImgList();
+		if(imgList !=null && imgList.size()>0){
+			for (String string : imgList) {
+				CourseFeedbackFile file = new CourseFeedbackFile();
+				file.setCreateTime(new Date());
+				file.setLibId(req.getLibId());
+				file.setImgurl(string);
+				file.setCourseDetailsId(req.getCourseDetailId());
+				file.setVipId(back.getId()); //如果是小红花vipId就是学生id，如果是课堂风采vipId就是反馈id
+				backFileService.save(file);
+			}
+		}
+		
+		if(isSend == 0){
+			//查询学生列表
+			Map<String, Object> search = new HashMap<String, Object>();
+			search.put("libId", req.getLibId());
+			search.put("courseDetailId", req.getCourseDetailId());
+			List<Map<String, Object>> studentlist = csService.getCourseStudentList(search);
+			for (Map<String, Object> map : studentlist) {
+				String vipId = map.get("vip_id").toString();
+				LibVip vip = vipService.getById(vipId);
+				//发送报告
+				User user = userService.getById(vip.getUserId());
+				
+				String parentContentMessage = "亲爱的"+ vip.getChildName()+"家长您好！老师已完成本节课的课后反馈，请及时查收，以便跟进孩子学习情况!";
+				Map<String, String> data = new HashMap<String, String>();
+				data.put("first", parentContentMessage+"\n");
+				data.put("keyword1", courseSeries.getCourseName()+courseDetail.getCourseUnit());
+				data.put("keyword2", DateUtil.dateToString(new Date()));
+				String template_id = "OPENTM408875752";
+				Miniprogram miniprogram = new Miniprogram();
+				miniprogram.setAppid(WxUtil.map.get("courseAppId"));
+				miniprogram.setPagepath("pages/feedback_report/feedback_report?type=11&feedbackId="+back.getId()+"&vipId="+vipId);
+				SendTemplateShort sendTemplateShort = new SendTemplateShort(user.getAccount(), template_id, null,
+						data, miniprogram);
+				pushTemplateService.saveAndSendPushWxTemplate(sendTemplateShort);
+				
+				//讲join表的状态更新为已反馈
+				joinService.updateStateSend(back.getCourseDetailsId(),vipId,back.getLibId());
+			}
+			
+		}
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseDetailFeedbackLib getCourseDetailFeedbackLibByTeacherId(
+			String libId, String courseDetailsId) {
+		return dao.getCourseDetailFeedbackLibByTeacherId(libId, courseDetailsId);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CourseReadHisService.java

@@ -0,0 +1,36 @@
+package com.ssj.service.course.service.impl;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseReadHis;
+import com.ssj.dao.course.dao.ICourseReadHisDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.course.service.ICourseReadHisService;
+
+@Transactional
+@Service(version="1.0")
+public class CourseReadHisService extends BaseServiceImpl<CourseReadHis, String> implements ICourseReadHisService {
+
+	@Autowired
+	private ICourseReadHisDao dao;
+	
+	@Override
+	public PagingAndSortingRepository<CourseReadHis, String> getDao() {
+		
+		return dao;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseReadHis findOneData(String userId, String libId, String courseDetailId, String onlineType, int state) {
+		
+		return dao.findOneData(userId,libId,courseDetailId,onlineType,state);
+	}
+
+	
+
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CourseScanHisServiceImpl.java

@@ -0,0 +1,49 @@
+package com.ssj.service.course.service.impl;
+
+import java.util.Date;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseScanHis;
+import com.ssj.dao.course.dao.ICourseScanDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.course.service.ICourseScanHisService;
+
+@Service(version="1.0")
+public class CourseScanHisServiceImpl extends BaseServiceImpl<CourseScanHis, String> implements ICourseScanHisService {
+
+	@Autowired
+	private ICourseScanDao dao;
+	
+	@Override
+	public PagingAndSortingRepository<CourseScanHis, String> getDao() {
+		
+		return dao;
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseScanHis getSessionHis(String sessionId) {
+		
+		return dao.getSessionHis(sessionId,1);
+	}
+
+	@Override
+	public void saveCourseScanHis(String sessionId, String userId) {
+		CourseScanHis  his=dao.getSessionHis(sessionId);
+		if(his ==null){
+			his =new CourseScanHis();
+			his.setSessionId(sessionId);
+		}
+		his.setState(1);
+		his.setUserId(userId);
+		his.setCreateTime(new Date());
+		this.save(his);
+	}
+
+	
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CourseSeriesDetailFeedbackServiceImpl.java

@@ -0,0 +1,240 @@
+package com.ssj.service.course.service.impl;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Reference;
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseSeries;
+import com.ssj.bean.course.domain.CourseSeriesDetail;
+import com.ssj.bean.course.domain.CourseSeriesDetailFeedback;
+import com.ssj.bean.course.domain.CourseSeriesDetailFile;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.bean.weixin.push.domain.Miniprogram;
+import com.ssj.bean.weixin.push.domain.SendTemplateShort;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.dao.course.dao.CourseQueryDao;
+import com.ssj.dao.course.dao.CourseSeriesDetailFeedbackDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.framework.weixin.util.WxUtil;
+import com.ssj.service.course.req.TeacherFeedbackReq;
+import com.ssj.service.course.service.CourseSeriesDetailFeedbackService;
+import com.ssj.service.course.service.CourseSeriesJoinService;
+import com.ssj.service.course.service.ICSDetailService;
+import com.ssj.service.course.service.ICSService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import com.ssj.service.weixin.push.service.PushTemplateService;
+import com.ssj.service.weixin.user.service.UserService;
+
+
+/** 
+ * @author  ZhangCaibao 
+ * @version 2018年10月19日 上午10:01:20 
+ * 类说明 
+ */
+@Transactional
+@Service(version="1.0")
+public class CourseSeriesDetailFeedbackServiceImpl  extends BaseServiceImpl<CourseSeriesDetailFeedback, String> implements  CourseSeriesDetailFeedbackService{
+	@Autowired
+	private  CourseSeriesDetailFeedbackDao  dao;
+	@Autowired
+	private  CourseQueryDao  courseQueryDao;
+	@Autowired
+	private ILibVipService vipService;
+	 @Autowired
+	private PushTemplateService  pushTemplateService;
+	@Autowired
+	private UserService userService;
+	
+	@Autowired
+	private ICSDetailService csDetailService;
+	@Autowired
+	private ICSService csService;
+	
+	@Autowired
+	private CourseSeriesJoinService joinService;
+	
+	
+	@Override
+	public PagingAndSortingRepository<CourseSeriesDetailFeedback, String> getDao() {
+		return dao;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> getCourseFeedback(String courseSeriesId) {
+		return courseQueryDao.getCourseFeedback(courseSeriesId);
+	}
+	
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> getCourseFeedback(String courseSeriesId,String libId) {
+		return courseQueryDao.getCourseFeedback(courseSeriesId,libId);
+	}
+    
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Map<String, Object> getCourseScore(String courseSeriesId) {
+		Map<String, Object> map = new HashMap<String, Object>();
+		List<Object[]>   list = dao.getCourseScore(courseSeriesId);
+		Object score =0;
+		Object total =0;
+		if(list != null && !list.isEmpty()){
+			Object[] tempObj = list.get(0);
+			score = (Object)tempObj[0];
+			total = (Object)tempObj[1];
+		}
+		map.put("score", score);
+		map.put("total", total);
+		return map;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Map<String, Object> getCourseScore(String courseSeriesId,String libId) {
+		Map<String, Object> map = new HashMap<String, Object>();
+		List<Object[]>   list = dao.getCourseScore(courseSeriesId,libId);
+		Object score =0;
+		Object total =0;
+		if(list != null && !list.isEmpty()){
+			Object[] tempObj = list.get(0);
+			score = (Object)tempObj[0];
+			total = (Object)tempObj[1];
+		}
+		map.put("score", score);
+		map.put("total", total);
+		return map;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesDetailFeedback getFeedbackByDetailsId(
+			String courseDetailsId) {
+		return dao.getFeedbackByDetailsId(courseDetailsId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesDetailFeedback findyDetailIdAndVipId(String courseDetailId, String vipId) {
+		
+		return dao.findyDetailIdAndVipId(courseDetailId,vipId);
+	}
+	@Override
+	public void courseFeedbackSend(TeacherFeedbackReq req) {
+		LibVip vip = vipService.getById(req.getVipId());
+		CourseSeriesDetailFeedback back = this.findyDetailIdAndVipId(req.getCourseDetailId(),req.getVipId());
+		if(req.getSendType()==2){
+			
+			if(back == null){
+				new CourseSeriesDetailFeedback();
+			}
+			back.setActiveScore(req.getActiveScore());
+			back.setUserId(vip.getUserId());
+			back.setVipId(req.getVipId());
+			back.setCourseDetailsId(req.getCourseDetailId());
+			back.setCourseSeriesId(req.getCourseSeriesId());
+			back.setFocusScore(req.getFocusScore());
+			back.setActiveScore(req.getActiveScore());
+			back.setIsSend(1);
+			back.setSaying(req.getSaying());
+			back.setLibId(req.getLibId());
+			back.setCreateTime(new Date());
+			this.save(back);
+		}else{
+			
+			back.setIsSend(1);
+			this.save(back);
+			
+		}
+		//发送报告
+		User user = userService.getById(vip.getUserId());
+		CourseSeriesDetail courseDetail = csDetailService.getById(back.getCourseDetailsId());
+		CourseSeries courseSeries = csService.getById(courseDetail.getSeriesId());
+		String parentContentMessage = "亲爱的"+ vip.getChildName()+"家长您好！老师已完成本节课的课后反馈，请及时查收，以便跟进孩子学习情况!";
+		Map<String, String> data = new HashMap<String, String>();
+		data.put("first", parentContentMessage+"\n");
+		data.put("keyword1", courseSeries.getCourseName()+courseDetail.getCourseUnit());
+		data.put("keyword2", DateUtil.dateToString(new Date()));
+		String template_id = "OPENTM408875752";
+		Miniprogram miniprogram = new Miniprogram();
+		miniprogram.setAppid(WxUtil.map.get("courseAppId"));
+		miniprogram.setPagepath("pages/feedback_report/feedback_report?type=11&feedbackId="+back.getId());
+		SendTemplateShort sendTemplateShort = new SendTemplateShort(user.getAccount(), template_id, null,
+				data, miniprogram);
+		pushTemplateService.saveAndSendPushWxTemplate(sendTemplateShort);
+		
+		//讲join表的状态更新为已反馈
+		joinService.updateStateSend(back.getCourseDetailsId(),back.getVipId(),back.getLibId());
+	}
+	@Override
+	public Map<String, Object> courseFeedbackPre(TeacherFeedbackReq req) {
+		LibVip vip = vipService.getById(req.getVipId());
+		//先查询是否有数据
+		CourseSeriesDetailFeedback back = this.findyDetailIdAndVipId(req.getCourseDetailId(),req.getVipId());
+		if(back == null){
+			back = new CourseSeriesDetailFeedback();
+		}
+		back.setActiveScore(req.getActiveScore());
+		back.setUserId(vip.getUserId());
+		back.setVipId(req.getVipId());
+		back.setCourseDetailsId(req.getCourseDetailId());
+		back.setCourseSeriesId(req.getCourseSeriesId());
+		back.setFocusScore(req.getFocusScore());
+		back.setActiveScore(req.getActiveScore());
+		back.setIsSend(0);
+		back.setSaying(req.getSaying());
+		back.setLibId(req.getLibId());
+		back.setCreateTime(new Date());
+		this.save(back);
+		
+		Map<String, Object> feedBackInfo =  new HashMap<String, Object>();
+		feedBackInfo.put("lib_id", req.getLibId());
+		feedBackInfo.put("vip_id", req.getVipId());
+		feedBackInfo.put("child_name", vip.getChildName());
+		feedBackInfo.put("img_url", vip.getImgUrl());
+		feedBackInfo.put("active_score", req.getActiveScore());
+		feedBackInfo.put("saying", req.getSaying());
+		feedBackInfo.put("focus_score", req.getFocusScore());
+		feedBackInfo.put("course_details_id", req.getCourseDetailId());
+		feedBackInfo.put("is_send", 0);
+		feedBackInfo.put("is_save", back.getId());
+		
+		feedBackInfo.put("feedback_id", back.getId());
+		feedBackInfo.put("is_evaluate", "0");
+		feedBackInfo.put("course_time", DateUtil.dateToString(new Date()));
+		CourseSeriesDetail detail = csDetailService.getById(req.getCourseDetailId());
+		feedBackInfo.put("course_content", detail.getCourseContent()==null?new ArrayList<String>():Arrays.asList(detail.getCourseContent().replaceAll("\r","").replaceAll("\n", "").split("；")));
+		feedBackInfo.put("contentImgList", new ArrayList<String>());
+		//feedBackInfo.put("redFlowerList", backFileService.getRedFlowList3(req.getLibId(),req.getVipId(),req.getCourseDetailId()));
+		feedBackInfo.put("redFlowerList", new ArrayList<String>());
+		 //CourseSeriesDetail detail = csDetailService.getById(req.getCourseDetailId());
+		 //查找附件
+		 List<CourseSeriesDetailFile> fileList = detail.getFileList();
+		 List<Map<String, Object>> mp4List = new ArrayList<Map<String, Object>>(); 
+		 for (CourseSeriesDetailFile courseSeriesDetailFile : fileList) {
+			 if(courseSeriesDetailFile.getFileType().equalsIgnoreCase("mp4")){
+				 Map<String, Object> map2 = new HashMap<String, Object>();
+				 map2.put("coverUrl", courseSeriesDetailFile.getCoverUrl());
+				 map2.put("fileUrl", courseSeriesDetailFile.getFileUrl());
+				 mp4List.add(map2);
+			 }
+			
+			 
+		}
+		feedBackInfo.put("mp4List", mp4List);
+		Map<String, Object> data = new HashMap<String, Object>();
+		data.put("feedBackInfo", feedBackInfo);
+		return data;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesDetailFeedback findyDetailIdAndLibFeedbackId(
+			String libFeedbackId, String vipId) {
+		return dao.findyDetailIdAndLibFeedbackId(libFeedbackId, vipId);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CourseSeriesJoinServiceImpl.java

@@ -0,0 +1,440 @@
+package com.ssj.service.course.service.impl;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseSeriesDetail;
+import com.ssj.bean.course.domain.CourseSeriesDetailFeedback;
+import com.ssj.bean.course.domain.CourseSeriesJoin;
+import com.ssj.bean.course.domain.CourseSeriesSetting;
+import com.ssj.bean.weixin.libmy.domain.LibVip;
+import com.ssj.bean.weixin.libmy.domain.TbLibJoin;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.dao.course.dao.CourseQueryDao;
+import com.ssj.dao.course.dao.CourseSeriesJoinDao;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.course.req.CourseSeriesAddReq;
+import com.ssj.service.course.req.CourseSeriesAddVip;
+import com.ssj.service.course.res.CourseSeriesCalendarRes;
+import com.ssj.service.course.res.CourseSeriesRes;
+import com.ssj.service.course.res.CourseSeriesTimeRes;
+import com.ssj.service.course.service.CourseSeriesDetailFeedbackService;
+import com.ssj.service.course.service.CourseSeriesJoinService;
+import com.ssj.service.course.service.CourseSeriesSettingService;
+import com.ssj.service.course.service.ICSDetailService;
+import com.ssj.service.weixin.library.service.ILibJoinService;
+import com.ssj.service.weixin.library.service.ILibVipService;
+import com.ssj.service.weixin.user.service.UserService;
+
+/**
+ * @author  ZhangCaibao
+ * @version 2018年10月18日 下午3:24:57
+ * 类说明
+ */
+@Transactional
+@Service(version="1.0")
+public class CourseSeriesJoinServiceImpl extends BaseServiceImpl<CourseSeriesJoin, String> implements CourseSeriesJoinService {
+	@Autowired
+	private  CourseSeriesJoinDao  dao;
+	@Autowired
+	private  CourseQueryDao  queryDao;
+	@Autowired
+	private  ICSDetailService  cSDetailService;
+	@Autowired
+	private  CourseSeriesSettingService  courseSeriesSettingService;
+	@Autowired
+	private ILibJoinService  joinService;
+	@Autowired
+	private UserService userService;
+	@Autowired
+	private  CourseSeriesDetailFeedbackService  courseSeriesDetailFeedbackService;
+	@Autowired
+	private ILibVipService vipService;
+	@Override
+	public PagingAndSortingRepository<CourseSeriesJoin, String> getDao() {
+		return dao;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public int findCourseSeriesJoinBycourseDetailsIdAndLibId(
+			String courseDetailsId, String libId, String vipId) {
+		return dao.findCourseSeriesJoinBycourseDetailsIdAndLibId(courseDetailsId, libId, vipId);
+	}
+	@Override
+	public void saveCousreSeriesJoin(CourseSeriesAddReq req,String userId) {
+		List<String> vipIds  = req.getVipIds();
+
+		List<CourseSeriesDetail> list =cSDetailService.findBySeriesId(req.getCourseSeriesId());
+		CourseSeriesSetting courseSeriesSetting =courseSeriesSettingService.fingByCourseSeriesIdAndLibIdLimit(req.getCourseSeriesId(), req.getLibId());
+		//int days =courseSeriesSetting.getDays();
+		String[] weeks=courseSeriesSetting.getWeeks().split(",");
+		List<String> resultList = new ArrayList<>(weeks.length);
+		Collections.addAll(resultList,weeks);
+		Collections.sort(resultList);
+
+
+
+		for (String vipId : vipIds) {
+			Date openTime = courseSeriesSetting.getOpenTime();
+			int day = DateHelper.getday(openTime)-1	;//周四
+			// 计算今天是周几，  看是否有提交的 周几上课
+			Integer few =-1;
+			if(few==-1){
+				for (int j = 0; j < resultList.size(); j++) {
+					few=	Integer.parseInt(resultList.get(j))-day>=0?j:-1;
+					if(few>-1){
+						break;
+					}
+				}
+			}
+			if(few==-1)few=0;
+			Integer we =Integer.parseInt(resultList.get(few));//第一个
+			Integer oldwe =day;
+
+			int type =dao.findCourseSeriesJoinBycourseDetailsIdAndLibId(req.getCourseSeriesId(), req.getLibId(), vipId);
+			if(type == 0){
+				List<CourseSeriesJoin> joinList =new ArrayList<CourseSeriesJoin>();
+				for (int i = 0; i < list.size(); i++) {
+					CourseSeriesJoin join = new  CourseSeriesJoin();
+					join.setCourseSeriesId(req.getCourseSeriesId());
+					join.setCreateTime(new Date());
+					join.setLibId(req.getLibId());
+					join.setUserId(userId);
+					openTime=DateHelper.getNextDay(openTime, we >=oldwe ? (we-oldwe) :(we+7-oldwe));
+					join.setOpenTime(openTime);
+					join.setVipId(vipId);
+					join.setCourseDetailsId(list.get(i).getId());
+					join.setState(0);
+					join.setNum(list.get(i).getCourseIndex());
+					joinList.add(join);
+					oldwe =we;
+					few ++;
+					few=few %resultList.size();
+					we =Integer.parseInt(resultList.get(few));
+				}
+				this.save(joinList);
+
+			}
+		}
+
+	}
+	@Override
+	public void saveCousreSeriesJoin(CourseSeriesAddVip req,String userId) {
+
+		LibVip  libVip= new LibVip();
+		libVip.setCreateTime(new Date());
+		libVip.setStat("1");//生成的会员卡设置为有效状态 1--有效 2--无效',
+		libVip.setLevel(1);
+		libVip.setUserId(userId);
+		User user=userService.getById(userId);
+		TbLibJoin libjoin = joinService.getById(req.getLibId());
+		libVip.setBanben(libjoin !=null ? (libjoin.getLeagueCode()!=null &&libjoin.getLeagueCode().startsWith("SZ")?2:1):1);
+		libVip.setImgUrl(user!=null?user.getPhoto():null);
+		libVip.setActivateTime(new Date());
+		libVip.setChildName(req.getChildName());libVip.setParentName(req.getParentName());
+		libVip.setPhone(req.getPhone());libVip.setGrade(req.getGrade());libVip.setSchool(req.getSchool());
+		vipService.save(libVip);
+		String vipId =libVip.getId();
+		List<CourseSeriesDetail> list =cSDetailService.findBySeriesId(req.getCourseSeriesId());
+		CourseSeriesSetting courseSeriesSetting =courseSeriesSettingService.fingByCourseSeriesIdAndLibIdLimit(req.getCourseSeriesId(), req.getLibId());
+		String[] weeks=courseSeriesSetting.getWeeks().split(",");
+		List<String> resultList = new ArrayList<>(weeks.length);
+		Collections.addAll(resultList,weeks);
+		Collections.sort(resultList);
+
+		Date openTime = courseSeriesSetting.getOpenTime();
+		int day = DateHelper.getday(openTime)-1	;//周四
+		// 计算今天是周几，  看是否有提交的 周几上课
+		Integer few =-1;
+		if(few==-1){
+			for (int j = 0; j < resultList.size(); j++) {
+				few=	Integer.parseInt(resultList.get(j))-day>=0?j:-1;
+				if(few>-1){
+					break;
+				}
+			}
+		}
+		if(few==-1)few=0;
+		Integer we =Integer.parseInt(resultList.get(few));//第一个
+		Integer oldwe =day;
+
+		List<CourseSeriesJoin> joinList =new ArrayList<CourseSeriesJoin>();
+		for (int i = 0; i < list.size(); i++) {
+			CourseSeriesJoin join = new  CourseSeriesJoin();
+			join.setCourseSeriesId(req.getCourseSeriesId());
+			join.setCreateTime(new Date());
+			join.setLibId(req.getLibId());
+			join.setUserId(userId);
+			openTime=DateHelper.getNextDay(openTime, we >=oldwe ? (we-oldwe) :(we+7-oldwe));
+			join.setOpenTime(openTime);
+			join.setVipId(vipId);
+			join.setCourseDetailsId(list.get(i).getId());
+			join.setState(0);
+			join.setNum(list.get(i).getCourseIndex());
+			joinList.add(join);
+			oldwe =we;
+			few ++;
+			few=few %resultList.size();
+			we =Integer.parseInt(resultList.get(few));
+		}
+		this.save(joinList);
+
+
+
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesCalendarRes findCourseSeriesJoinByUserId(String userId,String vipId,String id,String libId) {
+		CourseSeriesCalendarRes res=new CourseSeriesCalendarRes();
+		List<CourseSeriesTimeRes> courseSeriesTimes=new ArrayList<CourseSeriesTimeRes>();
+		List<CourseSeriesRes> courseSeriesList=new ArrayList<CourseSeriesRes>();
+
+		List<Map<String,Object>> courseSeriesJoinMaps=queryDao.findCourseSeriesJoinByUserId(userId,vipId,id,libId);
+		for (Map<String, Object> map : courseSeriesJoinMaps) {
+			CourseSeriesTimeRes time=new CourseSeriesTimeRes();
+			String openTime=(map.get("open_time").toString());
+			String[] openTimes=openTime.split(",");
+			time.setId(map.get("course_series_id").toString());
+			time.setLibId(map.get("lib_id").toString());
+			time.setColor(map.get("color")!=null ? map.get("color").toString() : "#FF80A8");
+			time.setOpenTimes(Arrays.asList(openTimes));
+			courseSeriesTimes.add(time);
+		}
+
+		List<Map<String,Object>> courseSeriesMaps= queryDao.findCourseSeriesByUserId(userId,vipId);
+		if(StringUtils.isNotEmpty(id) && StringUtils.isNotEmpty(libId)){
+			for (Map<String, Object> map : courseSeriesMaps) {
+				String cld=map.get("lib_id").toString();
+				String cd=map.get("id").toString();
+				if(id.equals(cd) && libId.equals(cld)){
+					CourseSeriesRes courseSeries=new CourseSeriesRes();
+					courseSeries.setLibId(map.get("lib_id").toString());
+					courseSeries.setId(map.get("id").toString());
+					courseSeries.setCoverUrl(map.get("cover_url")!=null?map.get("cover_url").toString():"");
+					courseSeries.setClassPnum(map.get("class_pnum")!=null?map.get("class_pnum").toString():"");
+					courseSeries.setCourseName( map.get("course_name")!=null?map.get("course_name").toString():"");
+					courseSeries.setCoursePlan( map.get("course_plan")!=null?map.get("course_plan").toString():"");
+					courseSeries.setCourseSummary( map.get("course_summary")!=null?map.get("course_summary").toString():"");
+					courseSeries.setCourseTarget( map.get("course_target")!=null?map.get("course_target").toString():"");
+					courseSeries.setTeacherName( map.get("name")!=null?map.get("name").toString():"");
+
+
+					List<Map<String,Object>> details =cSDetailService.findSeriesDetailsByUserId(courseSeries.getId(),userId,vipId, cld);
+					List<Map<String, Object>> detailMaps=new ArrayList<Map<String,Object>>();
+					for (Map<String,Object> courseSeriesDetail : details) {
+						Map<String, Object> tMap=new HashMap<String, Object>();
+						tMap.put("id", courseSeriesDetail.get("id").toString());
+						tMap.put("seriesId", courseSeriesDetail.get("series_id")!=null ? courseSeriesDetail.get("series_id").toString() :"");
+						tMap.put("courseUnit", courseSeriesDetail.get("course_unit")!=null ? courseSeriesDetail.get("course_unit").toString() :"");
+						tMap.put("courseContent", courseSeriesDetail.get("course_content")!=null ?
+								courseSeriesDetail.get("course_content").toString().replaceAll("\r","").replaceAll("\n", "").split("；") :"");
+						tMap.put("courseModel", courseSeriesDetail.get("course_model")!=null ? courseSeriesDetail.get("course_model").toString() :"");
+						tMap.put("courseDuration", courseSeriesDetail.get("course_duration")!=null ?courseSeriesDetail.get("course_duration").toString():"");
+						tMap.put("courseNum", courseSeriesDetail.get("course_num")!=null ? courseSeriesDetail.get("course_num").toString() :"");
+						tMap.put("courseIndex", courseSeriesDetail.get("course_index")!=null ? courseSeriesDetail.get("course_index").toString():"");
+						tMap.put("openTime",courseSeriesDetail.get("open_time")!=null?  courseSeriesDetail.get("open_time").toString() :"");
+						detailMaps.add(tMap);
+					}
+					courseSeries.setDetails(detailMaps);
+					courseSeriesList.add(courseSeries);
+				}
+			}
+		}else{
+			for (Map<String, Object> map : courseSeriesMaps) {
+				CourseSeriesRes courseSeries=new CourseSeriesRes();
+				String cld=map.get("lib_id").toString();
+				courseSeries.setLibId(map.get("lib_id").toString());
+				courseSeries.setId(map.get("id").toString());
+				courseSeries.setCoverUrl(map.get("cover_url")!=null?map.get("cover_url").toString():"");
+				courseSeries.setClassPnum(map.get("class_pnum")!=null?map.get("class_pnum").toString():"");
+				courseSeries.setCourseName( map.get("course_name")!=null?map.get("course_name").toString():"");
+				courseSeries.setCoursePlan( map.get("course_plan")!=null?map.get("course_plan").toString():"");
+				courseSeries.setCourseSummary( map.get("course_summary")!=null?map.get("course_summary").toString():"");
+				courseSeries.setCourseTarget( map.get("course_target")!=null?map.get("course_target").toString():"");
+				courseSeries.setTeacherName( map.get("name")!=null?map.get("name").toString():"");
+
+				List<Map<String,Object>> details =cSDetailService.findSeriesDetailsByUserId(courseSeries.getId(),userId,vipId,  cld);
+				List<Map<String, Object>> detailMaps=new ArrayList<Map<String,Object>>();
+				for (Map<String,Object> courseSeriesDetail : details) {
+					Map<String, Object> tMap=new HashMap<String, Object>();
+					tMap.put("id", courseSeriesDetail.get("id").toString());
+					tMap.put("seriesId", courseSeriesDetail.get("series_id")!=null ? courseSeriesDetail.get("series_id").toString() :"");
+					tMap.put("courseUnit", courseSeriesDetail.get("course_unit")!=null ? courseSeriesDetail.get("course_unit").toString() :"");
+					tMap.put("courseContent", courseSeriesDetail.get("course_content")!=null ?
+							courseSeriesDetail.get("course_content").toString().replaceAll("\r","").replaceAll("\n", "").split("；") :"");
+					tMap.put("courseModel", courseSeriesDetail.get("course_model")!=null ? courseSeriesDetail.get("course_model").toString() :"");
+					tMap.put("courseDuration", courseSeriesDetail.get("course_duration")!=null ?courseSeriesDetail.get("course_duration").toString():"");
+					tMap.put("courseNum", courseSeriesDetail.get("course_num")!=null ? courseSeriesDetail.get("course_num").toString() :"");
+					tMap.put("courseIndex", courseSeriesDetail.get("course_index")!=null ? courseSeriesDetail.get("course_index").toString():"");
+					tMap.put("openTime",courseSeriesDetail.get("open_time")!=null?  courseSeriesDetail.get("open_time").toString() :"");
+					detailMaps.add(tMap);
+				}
+				courseSeries.setDetails(detailMaps);
+				courseSeriesList.add(courseSeries);
+			}
+		}
+
+		res.setCourseSeriesDetails(courseSeriesList);
+		res.setCourseSeriesTimes(courseSeriesTimes);
+		return res;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> findCourseSeriesFeedbackByUserId(String userId,String vipId) {
+		return queryDao.findCourseSeriesFeedbackByUserId(userId,vipId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Page<Map<String, Object>> findFeedbackPageByUserId(Map<String, Object> searchParams, Pageable pageable) {
+		Page<Map<String, Object>> page=queryDao.findFeedbackPageByUserId(searchParams, pageable);
+		List<Map<String,Object>> list=page.getContent();
+		for (Map<String, Object> map : list) {
+			Integer state=(Integer) map.get("state");
+			String courseDetailsId=map.get("course_details_id").toString();
+			String vipId=map.get("vip_id").toString();
+			if(2==state){//已反馈，去查反馈数据
+				CourseSeriesDetailFeedback feedback=courseSeriesDetailFeedbackService.findyDetailIdAndVipId(courseDetailsId,vipId);
+				if(feedback==null){
+					feedback=new CourseSeriesDetailFeedback();
+				}
+				Map<String,Object> feedbackMap=new LinkedHashMap<String, Object>();
+				feedbackMap.put("id", feedback.getLibFeedbackId());
+				feedbackMap.put("activeScore", feedback.getActiveScore());
+				feedbackMap.put("courseDetailsId", feedback.getCourseDetailsId());
+				feedbackMap.put("courseSeriesId", feedback.getCourseSeriesId());
+				feedbackMap.put("createTime", feedback.getCreateTime());
+				feedbackMap.put("evaluate", feedback.getEvaluate());
+				feedbackMap.put("isSend", feedback.getIsSend());
+				feedbackMap.put("libId", feedback.getLibId());
+				feedbackMap.put("pleasedScore", feedback.getPleasedScore());
+				feedbackMap.put("saying", feedback.getSaying());
+				feedbackMap.put("userId", feedback.getUserId());
+				feedbackMap.put("vipId", feedback.getVipId());
+				map.put("feedback", feedbackMap);
+			}else{
+				map.put("feedback", new CourseSeriesDetailFeedback());
+			}
+		}
+		return page;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> findVipIsBuy(String userId,String courseDetailsId,String libId) {
+		return queryDao.findVipIsBuy(userId, courseDetailsId, libId);
+	}
+	@Override
+	public void updateBeginTime(String libId, String courseDetailId) {
+		dao.updateBeginTime(libId,courseDetailId);
+	}
+	@Override
+	public void courseUpdateTime(String courseDetailId, String libId) {
+
+		dao.courseUpdateTime(courseDetailId,libId);
+	}
+	@Override
+	public void updateStateSend(String courseDetailsId, String vipId, String libId) {
+
+		dao.updateStateSend(courseDetailsId,vipId,libId);
+	}
+	@Override
+	public void updateJoinDate(String courseDetailsId, String libId,int num ,Date date) {
+		dao.updateJoinDate(courseDetailsId, libId, num, date);
+	}
+
+	@Override
+	public void updateJoinDate2(String courseDetailsId, String libId, int num) {
+		dao.updateJoinDate2(courseDetailsId,libId,num);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> findCourseRecordList(String userId,String vipId) {
+		return queryDao.findCourseRecordList(userId, vipId);
+	}
+	@Override
+	public void saveOrUpdateJoinDate(String courseDetailsId, String libId,
+									 int num, Date date,List<String> vipIds,String courseSeriesId) {
+		for (String vipId : vipIds) {
+			CourseSeriesJoin seriesjoin=dao.findBycourseDetailsIdAndLibIdAndNum(courseDetailsId, libId,vipId);
+			if(seriesjoin==null){
+				seriesjoin  =new CourseSeriesJoin();
+				seriesjoin.setCourseDetailsId(courseDetailsId);
+				seriesjoin.setLibId(libId);
+				seriesjoin.setVipId(vipId);
+				seriesjoin.setState(0);
+			}
+			seriesjoin.setCourseSeriesId(courseSeriesId);
+			seriesjoin.setCreateTime(new Date());
+			seriesjoin.setNum(num);
+			seriesjoin.setOpenTime(date);
+			this.save(seriesjoin);
+		}
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<String> findByVipIdAndCourseSeriesIdAndLibId(String libId,String courseSeriesId){
+		return dao.findByVipIdAndCourseSeriesIdAndLibId(libId, courseSeriesId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public void delByAnyReq(String libId, String courseSeriesId, String vipId) {
+		dao.delByAnyReq(libId,courseSeriesId,vipId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesJoin findOneDataByAny(String libId, String courseSeriesId) {
+
+		return dao.findOneDataByAny(libId,courseSeriesId);
+	}
+	@Override
+	public void updateDetailsData(String courseDetailId, String newTime,String libId,int num) {
+		dao.updateDetailsData(courseDetailId,newTime,libId,num);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public int findStudentCount(String libId, String courseSeriesId) {
+
+		return dao.findStudentCount(libId,courseSeriesId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<CourseSeriesJoin> findbyLibJoinList(String seriesId, String libId) {
+
+		return dao.findbyLibJoinList(libId,seriesId);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<CourseSeriesJoin> findbyLibAndVip(String libId, String seriesId, String vipId, int num, Date openTime) {
+		return dao.findbyLibAndVip(libId,seriesId,vipId,num,openTime);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesJoin findOneDataByDetail(String libId, String detailId) {
+		return dao.findOneDataByDetail(libId,detailId);
+	}
+
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesJoin findOneDataByDetailAndTime(String libId, String detailId, Date openTime) {
+		return dao.findOneDataByDetailAndTime(libId,detailId,openTime);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CourseSeriesOrderServiceImpl.java

@@ -0,0 +1,75 @@
+package com.ssj.service.course.service.impl;
+
+import java.util.List;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseSeriesOrder;
+import com.ssj.dao.course.dao.CourseSeriesOrderDao;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.course.service.CourseSeriesOrderService;
+
+/** 
+ * @author  ZhangCaibao 
+ * @version 2018年10月18日 下午3:31:44 
+ * 类说明 
+ */
+@Transactional
+@Service(version="1.0")
+public class CourseSeriesOrderServiceImpl  extends BaseServiceImpl<CourseSeriesOrder, String> implements  CourseSeriesOrderService{
+    
+	@Autowired
+	private  CourseSeriesOrderDao  dao;
+	@Override
+	public PagingAndSortingRepository<CourseSeriesOrder, String> getDao() {
+		return dao;
+	}
+	@Override
+	public void saveOrder(CourseSeriesOrder courseSeriesOrder) {
+		int orderNo	=dao.findCourseSeriesByOrderNo(courseSeriesOrder.getOrderNo());
+		if(orderNo ==0){
+			courseSeriesOrder.setStartTime(courseSeriesOrder.getCreateTime());
+			courseSeriesOrder.setEndTime(DateHelper.getMonthDate(courseSeriesOrder.getStartTime(), 12));
+			courseSeriesOrder.setStat(1);
+			this.save(courseSeriesOrder);
+		}
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public int findCourseSeriesBylibId(String libId, String courseSeriesId) {
+		return dao.findCourseSeriesBylibId(libId, courseSeriesId)!=null?1:0;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesOrder findCourseSeriesService(String libId,
+			String courseSeriesId) {
+		return dao.findCourseSeriesBylibId(libId, courseSeriesId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<CourseSeriesOrder> findByLibId(String libId) {
+		return dao.findByLibId(libId);
+	}
+	@Override
+	public int getCurrentCourserSize(String libId) {
+		return dao.getCurrentCourserSize(libId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public int getCurrentStudentSize(String libId) {
+		Integer size =dao.getCurrentStudentSize(libId);
+		return size!=null?size:0;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public int getCurrentStudentSize(String libId, String courseSeriesId) {
+		Integer size =dao.getCurrentStudentSize(libId, courseSeriesId);
+		return size!=null?size:0;
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/course/service/impl/CourseSeriesSettingServiceImpl.java

@@ -0,0 +1,211 @@
+package com.ssj.service.course.service.impl;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.course.domain.CourseSeriesDetail;
+import com.ssj.bean.course.domain.CourseSeriesSetting;
+import com.ssj.dao.course.dao.CourseSeriesSettingDao;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.service.course.req.CourseSettingSave;
+import com.ssj.service.course.res.CourseSeriesSettingRes;
+import com.ssj.service.course.service.CourseSeriesJoinService;
+import com.ssj.service.course.service.CourseSeriesSettingService;
+import com.ssj.service.course.service.ICSDetailService;
+
+/** 
+ * @author  ZhangCaibao 
+ * @version 2018年10月18日 下午3:35:15 
+ * 类说明 
+ */
+@Transactional
+@Service(version="1.0")
+public class CourseSeriesSettingServiceImpl  extends BaseServiceImpl<CourseSeriesSetting, String> implements  CourseSeriesSettingService {
+    @Autowired
+	private CourseSeriesSettingDao  dao;
+    @Autowired
+    private CourseSeriesJoinService  courseSeriesJoinService;
+	@Autowired
+	private  ICSDetailService  cSDetailService;
+	@Override
+	public PagingAndSortingRepository<CourseSeriesSetting, String> getDao() {
+		return dao;
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<CourseSeriesSetting> fingByCourseSeriesIdAndLibId(
+			String courseSeriesId, String libId) {
+		return dao.fingByCourseSeriesIdAndLibId(courseSeriesId, libId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesSettingRes findSettingByLibId(String courseSeriesId,
+			String libId) {
+		CourseSeriesSettingRes res = new  CourseSeriesSettingRes();
+		List<CourseSeriesSetting> list =this.fingByCourseSeriesIdAndLibId(courseSeriesId, libId);
+		 List<String> urlList = new ArrayList<>();
+	        list.forEach(entity -> {
+	            if(StringUtil.isNotBlank(entity.getTeacherId())){
+	                urlList.add(entity.getTeacherId());
+	            }
+	            res.setCourseSeriesId(courseSeriesId);
+	            res.setDays(entity.getDays());
+	            res.setLibId(libId);
+	            res.setStartDate(DateHelper.format(entity.getOpenTime(), "yyyy-MM-dd"));
+	            res.setPrice(entity.getPrice());
+	            if(StringUtil.isNotBlank(entity.getWeeks())){
+	            	res.setWeeks(entity.getWeeks().split(","));
+	            }
+	        });
+	        res.setTeacherIds(urlList);
+		return res;
+	}
+	@Override
+	public void saveCousreSeriesSetting(CourseSettingSave req) {
+		dao.deleteByByCourseSeriesIdAndLibId(req.getCourseSeriesId(), req.getLibId());
+		List<String> teacherIds  = req.getTeacherIds();
+		Date openTime = DateHelper.parseDate(req.getStartDate(), "yyyy-MM-dd");
+		Date startTime = openTime;
+		
+		List<CourseSeriesDetail> list =cSDetailService.findBySeriesId(req.getCourseSeriesId());
+		List<String> weeks =req.getWeeks();
+		Collections.sort(weeks);
+		
+		int day = DateHelper.getday(openTime)-1	;//周四
+		// 计算今天是周几，  看是否有提交的 周几上课 
+		Integer few =-1;
+    	if(few==-1){
+    		for (int j = 0; j < weeks.size(); j++) {
+    			 few=	Integer.parseInt(weeks.get(j))-day>=0?j:-1;
+    			 if(few>-1){
+    				 break;
+    			 }
+    		}
+    	}
+    	if(few ==-1)few =0;
+    	Integer we =Integer.parseInt(weeks.get(few));//第一个
+    	Integer oldwe =day;
+		
+		StringBuffer  stringbuff =new StringBuffer();
+		for (int i = 0; i < list.size(); i++) {
+			if(weeks.size()==1){
+				if(i==0){
+					openTime=DateHelper.getNextDay(openTime,(we-oldwe>0?we-oldwe:we-oldwe+7));
+				}else{
+					openTime=DateHelper.getNextDay(openTime,(we+7-oldwe));
+				}
+
+			}else{
+				openTime=DateHelper.getNextDay(openTime, we >=oldwe ? (we-oldwe) :(we+7-oldwe));
+			}
+			stringbuff.append(DateHelper.format(openTime,"yyyy-MM-dd"));
+			if(i<list.size()-1){
+				stringbuff.append(",");
+			}
+			courseSeriesJoinService.updateJoinDate(list.get(i).getId(),  req.getLibId(), list.get(i).getCourseIndex(), openTime);
+			oldwe =we;
+			few ++;
+			few=few %weeks.size();
+			we =Integer.parseInt(weeks.get(few));
+		}
+		
+		for (String string : teacherIds) {
+			CourseSeriesSetting  setting = new  CourseSeriesSetting();
+			setting.setCourseSeriesId(req.getCourseSeriesId());
+			setting.setLibId(req.getLibId());
+			setting.setDays(req.getDays());
+			setting.setOpenTime(startTime);
+			setting.setPrice(req.getPrice());
+			setting.setTeacherId(string);
+			setting.setEndTime(openTime);
+			setting.setWeeks(String.join(",",weeks));
+			setting.setCourseSize(list.size());
+			setting.setCourseDate(stringbuff.toString());
+			this.save(setting);
+			
+		}
+		//修改课程最后时间以及课程数
+	}
+	
+	
+	
+	@Override
+	public void saveCousreSeriesSetting() {
+		List<CourseSeriesSetting> listse =this.findAll();
+		for (CourseSeriesSetting req : listse) {
+			Date openTime = req.getOpenTime();
+			List<CourseSeriesDetail> list =cSDetailService.findBySeriesId(req.getCourseSeriesId());
+			if(StringUtil.isEmpty(req.getWeeks())){
+				continue;
+			}
+			List<String> weeks =Arrays.asList(req.getWeeks().split(","));
+			Collections.sort(weeks);
+			
+			int day = DateHelper.getday(openTime)-1	;//周四
+			// 计算今天是周几，  看是否有提交的 周几上课 
+			Integer few =-1;
+			if(few==-1){
+				for (int j = 0; j < weeks.size(); j++) {
+					few=	Integer.parseInt(weeks.get(j))-day>=0?j:-1;
+					if(few>-1){
+						break;
+					}
+				}
+			}
+			if(few ==-1)few =0;
+			Integer we =Integer.parseInt(weeks.get(few));//第一个
+			Integer oldwe =day;
+			List<String> vipIds=courseSeriesJoinService.findByVipIdAndCourseSeriesIdAndLibId(req.getLibId(), req.getCourseSeriesId());
+			StringBuffer  stringbuff =new StringBuffer();
+			for (int i = 0; i < list.size(); i++) {
+				openTime=DateHelper.getNextDay(openTime, we >=oldwe ? (we-oldwe) :(we+7-oldwe));
+				stringbuff.append(DateHelper.format(openTime,"yyyy-MM-dd"));
+				if(i<list.size()-1){
+					stringbuff.append(",");
+				}
+				courseSeriesJoinService.saveOrUpdateJoinDate(list.get(i).getId(),  req.getLibId(), list.get(i).getCourseIndex(), openTime,vipIds,req.getCourseSeriesId());
+				oldwe =we;
+				few ++;
+				few=few %weeks.size();
+				we =Integer.parseInt(weeks.get(few));
+			}
+			
+		}
+		//修改课程最后时间以及课程数
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesSetting fingByCourseSeriesIdAndLibIdLimit(
+			String courseSeriesId, String libId) {
+		return dao.fingByCourseSeriesIdAndLibIdLimit(courseSeriesId, libId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public CourseSeriesSetting findSetByUserIdAndLibId(String userId, String courseSeriesId, String libId) {
+		
+		return dao.findSetByUserIdAndLibId(userId,courseSeriesId,libId);
+	}
+	@Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public int findTeacherHasLesson(String timesNow, String libId, String userId) {
+		
+		return dao.findTeacherHasLesson(timesNow,libId,userId);
+	}
+	@Override
+	public void updateSettingOneDay(String libId, String newTime, String seriesId,Date openTime) {
+		dao.updateSettingOneDay(libId,newTime,seriesId,openTime);
+	}
+
+
+}

ssj-sys/src/main/java/com/ssj/service/es/EsDataRecodeServiceImpl.java

@@ -0,0 +1,181 @@
+package com.ssj.service.es;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+import com.ssj.bean.es.domain.EsDataRecode;
+import com.ssj.dao.es.dao.IEsDataRecodeDao;
+import com.ssj.es.service.base.BaseElasticService;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.util.ResponseConstant;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.mapper.load.data.LoadDataMapper;
+import com.ssj.service.es.service.IEsDataRecodeService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.lang.reflect.Method;
+import java.util.*;
+
+/**
+ * @author sh
+ * @className EsDataRecodeServiceImpl
+ * @description TODO
+ * @date 2020/4/29
+ */
+@Service(version = "1.0")
+@Transactional
+public class EsDataRecodeServiceImpl  extends BaseServiceImpl<EsDataRecode,String> implements IEsDataRecodeService{
+
+    @Autowired
+    private IEsDataRecodeDao dao;
+    @Autowired
+    private BaseElasticService baseElasticService;
+
+    @Autowired
+    private LoadDataMapper loadDataMapper;
+
+    @Override
+    public PagingAndSortingRepository<EsDataRecode, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public  <T> ResponseEntity findIsLoadEs(String beginDate,String loadDate, String indexName, String apiName, List<T> list) {
+
+        ResponseEntity responseEntity = new ResponseEntity();
+        try{
+            //判断时间字符串格式是否正确
+            Date date = DateHelper.parseDate(loadDate,"yyyy-MM-dd");
+            Date date2 = DateHelper.parseDate(beginDate,"yyyy-MM-dd");
+            loadDate= DateHelper.format(date,"yyyy-MM-dd");
+            beginDate= DateHelper.format(date2,"yyyy-MM-dd");
+        }catch (Exception e){
+            responseEntity.failure("000","传入日期格式错误，格式要求yyyy-MM-dd");
+            return  responseEntity;
+        }
+
+        String thisMonth = DateHelper.format(new Date(),"yyyy-MM-dd");
+        //判断时间是否合法
+        if(loadDate.compareTo(thisMonth)>=0 && beginDate.compareTo(thisMonth) >=0){
+            responseEntity.failure("000","传入时间错误，应小于本月！");
+            return  responseEntity;
+        }
+
+        //判断索引名称是否符合要求
+        String pattern = "^[a-z0-9_-]+$";
+        if(!indexName.matches(pattern)){
+            responseEntity.failure("000","传入索引名称不合法，小写字母和字母组合");
+            return  responseEntity;
+        }
+
+        EsDataRecode recode = dao.getLastDataByIndex(indexName);
+        boolean b = false;
+        if(recode == null ){
+            b = true;
+        }else{
+            if(beginDate.compareTo(recode.getLoadDate())==0 && loadDate.compareTo(recode.getLoadDate())>0){
+                b = true;
+            }
+        }
+        if(b){
+            try{
+                baseElasticService.insertBatchES(indexName,list);
+                recode = new EsDataRecode();
+                recode.setApiName(apiName);
+                recode.setCreateTime(new Date());
+                recode.setEsIndexName(indexName);
+                recode.setLoadDate(loadDate);
+                recode.setState(1);
+                this.save(recode);
+                responseEntity.success("数据加载成功！");
+            }catch (Exception e){
+                responseEntity.failure("000","保存es数据出现异常，请重试！");
+                return  responseEntity;
+            }
+
+        }else{
+            Map<String,Object> data = new HashMap<>(2);
+            data.put("lastLoadDate",recode.getLoadDate());
+            responseEntity.failure(ResponseConstant.CODE_004,"时间区间不正确",data);
+        }
+        return  responseEntity;
+    }
+
+    @Override
+    public <T> ResponseEntity loadDataToEs(String beginDate, String loadDate, String indexName, String apiName, Class<T> clazz, String methodName,int count) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        try{
+            //判断时间字符串格式是否正确
+            Date date = DateHelper.parseDate(loadDate,"yyyy-MM-dd");
+            Date date2 = DateHelper.parseDate(beginDate,"yyyy-MM-dd");
+            loadDate= DateHelper.format(date,"yyyy-MM-dd");
+            beginDate= DateHelper.format(date2,"yyyy-MM-dd");
+        }catch (Exception e){
+            responseEntity.failure("000","传入日期格式错误，格式要求yyyy-MM-dd");
+            return  responseEntity;
+        }
+
+        String thisMonth = DateHelper.format(new Date(),"yyyy-MM-dd");
+        //判断时间是否合法
+        if(loadDate.compareTo(thisMonth)>=0 && beginDate.compareTo(thisMonth) >=0){
+            responseEntity.failure("000","传入时间错误，应小于本月！");
+            return  responseEntity;
+        }
+
+        //判断索引名称是否符合要求
+        String pattern = "^[a-z0-9_-]+$";
+        if(!indexName.matches(pattern)){
+            responseEntity.failure("000","传入索引名称不合法，小写字母和字母组合");
+            return  responseEntity;
+        }
+
+        EsDataRecode recode = dao.getLastDataByIndex(indexName);
+        if(recode != null ){
+            if(loadDate.compareTo(beginDate)<=0){
+                responseEntity.failure("000","结束时间要大于开始时间");
+                return  responseEntity;
+            }
+            if(recode.getLoadDate().compareTo(loadDate)>=0){
+                responseEntity.success("请求数据已经之前已经预加载完成！");
+                return  responseEntity;
+            }
+            //将开始时间赋值为上次加载成功时间
+            beginDate = recode.getLoadDate();
+        }
+
+        try{
+            Method method = loadDataMapper.getClass().getMethod(methodName,Class.forName("com.baomidou.mybatisplus.extension.plugins.pagination.Page"),Class.forName("java.lang.String"),Class.forName("java.lang.String"));
+            Page page = new Page<>(1, count);
+            Object object =  method.invoke(loadDataMapper,page,beginDate,loadDate);
+            List<T> list = castList(object,clazz);
+            baseElasticService.insertBatchES(indexName,list);
+            recode = new EsDataRecode();
+            recode.setApiName(apiName);
+            recode.setCreateTime(new Date());
+            recode.setEsIndexName(indexName);
+            recode.setLoadDate(loadDate);
+            recode.setState(1);
+            this.save(recode);
+            responseEntity.success("数据加载成功！");
+        }catch (Exception e){
+            e.printStackTrace();
+            responseEntity.failure("000","保存es数据出现异常，请重试！");
+            return  responseEntity;
+        }
+        return  responseEntity;
+    }
+
+
+    public static <T> List<T> castList(Object obj, Class<T> clazz) {
+        List<T> result = new ArrayList<T>();
+        if (obj instanceof List<?>) {
+            for (Object o : (List<?>) obj) {
+                result.add(clazz.cast(o));
+            }
+            return result;
+        }
+        return null;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/correctsys/HomeworkCorrectCountServiceImpl.java

@@ -0,0 +1,30 @@
+package com.ssj.service.kmt.correctsys;
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.homework.domain.HomeworkCorrectCount;
+import com.ssj.dao.kmt.correctsys.HomeworkCorrectCountDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.correctsys.service.HomeworkCorrectCountService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author yanghuan
+ * @title: HomeworkCorrectCountServiceImpl
+ * @projectName ssj
+ * @description: TODO
+ * @date 2020/6/5 13:35
+ */
+@Service(version = "1.0")
+@Transactional
+public class HomeworkCorrectCountServiceImpl extends BaseServiceImpl<HomeworkCorrectCount,String> implements HomeworkCorrectCountService {
+
+    @Autowired
+    private HomeworkCorrectCountDao dao;
+
+
+    @Override
+    public PagingAndSortingRepository<HomeworkCorrectCount, String> getDao() {
+        return dao;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtAiRecordServiceImpl.java

@@ -0,0 +1,42 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtAiRecord;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtAiRecordDao;
+import com.ssj.dao.kmt.kmt.dao.KmtQueryDao;
+import com.ssj.service.kmt.service.KmtAiRecordService;
+
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+
+	
+@Transactional
+@Service(version ="1.0")
+public class KmtAiRecordServiceImpl extends BaseServiceImpl<KmtAiRecord, String> implements KmtAiRecordService {
+	
+	@Autowired
+	private KmtAiRecordDao dao;
+	
+	@Autowired
+	private KmtQueryDao queryDao;
+
+	@Override
+	public PagingAndSortingRepository<KmtAiRecord, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	@Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<String> findKmtAiRecordByFileName() {
+		return queryDao.findKmtAiRecordByFileName();
+	}
+
+	
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtArrangeAllotServiceImpl.java

@@ -0,0 +1,671 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.arrange.dto.*;
+import com.ssj.bean.kmt.arrange.vo.DutyRequestVO;
+import com.ssj.bean.kmt.arrange.vo.DutySysRequestVO;
+import com.ssj.bean.kmt.kmt.domain.KmtArrangeAllot;
+import com.ssj.bean.kmt.kmt.domain.KmtArrangeDetail;
+import com.ssj.bean.weixin.libmy.domain.TbLibLoginInfo;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.dao.kmt.kmt.dao.KmtArrangeAllotDao;
+import com.ssj.dao.kmt.kmt.dao.KmtArrangeTemplateDao;
+import com.ssj.dao.kmt.kmt.dao.TeacherArrangeQueryDao;
+import com.ssj.dao.sys.homework.dao.HomeworkDao;
+import com.ssj.dao.weixin.library.dao.IBookManagerDao;
+import com.ssj.dao.weixin.library.dao.ILibVipDao;
+import com.ssj.dao.weixin.library.dao.TbLibLoginInfoDao;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.util.MapGetterTool;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.service.kmt.arrange.service.KmtArrangeAllotService;
+import com.ssj.service.kmt.arrange.service.KmtArrangeDetailService;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.text.SimpleDateFormat;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+
+import static java.math.BigDecimal.ROUND_HALF_DOWN;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtArrangeAllotServiceImpl extends BaseServiceImpl<KmtArrangeAllot, String> implements KmtArrangeAllotService {
+
+	@Autowired
+	private KmtArrangeAllotDao dao;
+
+	@Autowired
+	private TeacherArrangeQueryDao queryDao;
+	private ResponseEntity responseEntity;
+
+	@Autowired
+	private  HomeworkDao homeworkDao;
+
+	@Autowired
+	private ILibVipDao libVipDao;
+
+	@Autowired
+	private KmtArrangeTemplateDao kmtArrangeTemplateDao;
+
+	@Autowired
+	private KmtArrangeDetailService kmtArrangeDetailService;
+
+	@Autowired
+	private TbLibLoginInfoDao tbLibLoginInfoDao;
+
+	@Autowired
+	private IBookManagerDao managerDao;
+
+	@Override
+	public PagingAndSortingRepository<KmtArrangeAllot, String> getDao() {
+		return dao;
+	}
+
+
+	@Override
+	public TeacherArrangeVO teacherMonthDutyList(String teacherUserId) {
+		TeacherArrangeVO vo = new TeacherArrangeVO();
+		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM");
+		Date date = new Date();
+		Calendar ca = Calendar.getInstance();
+		ca.setTime(date);
+		String thisMonth = sdf.format(date);
+		int days = ca.get(Calendar.DAY_OF_MONTH);
+		int lastDay = ca.getActualMaximum(Calendar.DAY_OF_MONTH);
+		if (days > 24 && days<lastDay) { //将显示下个月排班
+			vo.setIsShowNext(1);
+			//查询下个月老师有多少排班
+			vo.setNextDutyCount(dao.findMonthDutyCount(teacherUserId, getPreMonth()));
+		} else {
+			vo.setIsShowNext(0);
+			vo.setNextDutyCount(0);
+		}
+		List<Map<String, Object>> list = queryDao.findTeacheDutyList(teacherUserId,thisMonth);
+
+		vo.setMonth(thisMonth.substring(thisMonth.length()-2));
+		vo.setYear(thisMonth.substring(0,thisMonth.length()-3));
+		//记录出勤 计算出勤率
+		int i= 0; //有效出勤数
+		int j = 0 ; //总出勤
+		Map<String, Object> dayMap = new HashMap<String, Object>();
+		List<DutyTimeVO> timeVoList = new ArrayList<DutyTimeVO>();
+		TeacherArrangeDayVO dayVO = new TeacherArrangeDayVO();
+		List<TeacherArrangeDayVO> dayList = new ArrayList<TeacherArrangeDayVO>();
+		if (list != null && list.size() > 0) {
+			int x = 0;
+			for (Map<String, Object> map : list) {
+				int dayCompare = DateHelper.format(new Date(),"yyyy-MM-dd").compareTo(map.get("arrange_date").toString());
+				if(map.get("attend_type")!=null && dayCompare>0){ //null则是没有选择时段
+					if(map.get("attend_type").toString().equals("1")){ //有效出勤
+						i++;
+					}
+					j++;
+				}
+				if(dayVO.getDay()!=null){
+					if(!dayVO.getDay().equals(map.get("arrange_date").toString().substring(map.get("arrange_date").toString().length()-2))){ //
+						dayVO.setTimeVoList(timeVoList);
+						dayList.add(dayVO);
+						timeVoList=new ArrayList<DutyTimeVO>();
+						dayVO = new TeacherArrangeDayVO();
+					}
+				}
+				if(dayCompare<=0){
+					dayVO.setIsOutDate(0);
+				}else{
+					dayVO.setIsOutDate(1);
+				}
+				dayVO.setIsOpen(Integer.parseInt(map.get("is_open").toString()));
+				dayVO.setDay(map.get("arrange_date").toString().substring(map.get("arrange_date").toString().length()-2));
+				DutyTimeVO timeVO = new DutyTimeVO();
+				timeVO.setId(map.get("id").toString());
+				timeVO.setEndInterval(map.get("end_interval").toString());
+				timeVO.setStartInterval(map.get("start_interval").toString());
+				//先判断是否饱和
+				if(dayCompare>0){
+					//先判断是否缺勤
+					if(map.get("attend_type")==null){
+						timeVO.setTimeState(1);
+					}else{
+						if(map.get("attend_type").toString().equals("0")){
+							timeVO.setTimeState(4);
+						}else{
+							timeVO.setTimeState(2);
+						}
+					}
+				}else{
+					if(map.get("attend_type")==null){
+						timeVO.setTimeState(1);
+					}else{
+						timeVO.setTimeState(2);
+					}
+				}
+
+				timeVoList.add(timeVO);
+				x++;
+				if(list.size()==x){
+					dayVO.setTimeVoList(timeVoList);
+					dayList.add(dayVO);
+				}
+			}
+		}
+		vo.setDayList(dayList);
+		if(j==0 || i==0){
+			vo.setDutyRate("0");
+		}else{
+			DecimalFormat df = new DecimalFormat("#0.00");
+			vo.setDutyRate(df.format(new BigDecimal(i).divide(new BigDecimal(j),10,ROUND_HALF_DOWN).multiply(new BigDecimal(100))));
+		}
+		return vo;
+	}
+
+	@Override
+	public TeacherNextArrangeVO teacherNextMonthDutyList(String teacherUserId) {
+		TeacherNextArrangeVO vo = new TeacherNextArrangeVO();
+		String thisMonth = getPreMonth();
+
+		List<Map<String, Object>> list = queryDao.findTeacheDutyList(teacherUserId,thisMonth);
+		vo.setMonth(thisMonth.substring(thisMonth.length()-2));
+		vo.setYear(thisMonth.substring(0,thisMonth.length()-3));
+		vo.setNextDutyCount(dao.findCountByTeacherId(thisMonth,teacherUserId));
+		Map<String, Object> dayMap = new HashMap<String, Object>();
+		List<DutyTimeVO> timeVoList = new ArrayList<DutyTimeVO>();
+		TeacherArrangeDayVO dayVO = new TeacherArrangeDayVO();
+		List<TeacherArrangeDayVO> dayList = new ArrayList<TeacherArrangeDayVO>();
+		if (list != null && list.size() > 0) {
+			int x = 0;
+			for (Map<String, Object> map : list) {
+				if(dayVO.getDay()!=null){
+					if(!dayVO.getDay().equals(map.get("arrange_date").toString().substring(map.get("arrange_date").toString().length()-2))){
+						dayVO.setTimeVoList(timeVoList);
+						dayList.add(dayVO);
+						timeVoList=new ArrayList<DutyTimeVO>();
+						dayVO = new TeacherArrangeDayVO();
+					}
+				}
+				dayVO.setIsOpen(Integer.parseInt(map.get("is_open").toString()));
+				dayVO.setDay(map.get("arrange_date").toString().substring(map.get("arrange_date").toString().length()-2));
+				DutyTimeVO timeVO = new DutyTimeVO();
+				timeVO.setId(map.get("id").toString());
+				timeVO.setEndInterval(map.get("end_interval").toString());
+				timeVO.setStartInterval(map.get("start_interval").toString());
+				//先判断是否饱和
+				if(map.get("attend_type")==null){
+					if(Integer.parseInt(map.get("max_num").toString())<=Integer.parseInt(map.get("have_num").toString())){
+						timeVO.setTimeState(3);
+					}else {
+						timeVO.setTimeState(1);
+					}
+				}else{
+					timeVO.setTimeState(2);
+				}
+				timeVoList.add(timeVO);
+
+				x++;
+				if(list.size()==x){
+					dayVO.setTimeVoList(timeVoList);
+					dayList.add(dayVO);
+				}
+			}
+			vo.setDayList(dayList);
+		}
+		return vo;
+	}
+
+	@Override
+	public ResponseEntity saveTeacherDuty(DutyRequestVO requestVO, String teacherUserId) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		Date date = new Date();
+		Calendar ca = Calendar.getInstance();
+		ca.setTime(date);
+		int days = ca.get(Calendar.DAY_OF_MONTH);
+		int lastDay = ca.getActualMaximum(Calendar.DAY_OF_MONTH);
+
+		if (days > 24 && days< lastDay) { //时间段
+			ca.add(Calendar.MONTH,1);
+			SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM");
+			String preMonth = dft.format(ca.getTime());
+			List<String> resultList= new ArrayList<>();
+			if(requestVO.getIds().length>0){
+				resultList = new ArrayList<>(Arrays.asList(requestVO.getIds()));
+				//判断是否超过饱和人数
+				List<Map<String,Object>> list = queryDao.findIsOver(resultList,teacherUserId);
+				if(list!=null && list.size()>0) {
+					StringBuffer sb = new StringBuffer();
+					for (Map<String, Object> map : list) {
+						sb.append(map.get("arrange_date")).append(" ").append(map.get("time_interval")).append(" ");
+					}
+					sb.append("排班人数已经饱和");
+					responseEntity.failure(sb.toString());
+					return responseEntity;
+				}
+			}
+			//先减去当前老师的对应的时段饱和数
+			//dao.updateArrangeDetailHaveNum(-1,preMonth,teacherUserId);
+
+			//查询老师保存前所有的arrange_detail_id id
+			List<String> beforeDelList = dao.findTeacherDetailList(preMonth,teacherUserId);
+			//删除原来保存的数据
+			dao.delOldAllotData(preMonth,teacherUserId);
+			//保存新数据
+
+			//dao.insertNewAllotData(resultList,teacherUserId,preMonth);
+			/**
+			 * @Query(nativeQuery = true,value = "insert into kmt_arrange_allot(id,arrange_detail_id,teacher_id,arrange_date,attend_type,status,create_time)\n" +
+			 *             "SELECT UUID(),a.id,?2,a.arrange_date,0,1,NOW()\n" +
+			 *             "from kmt_arrange_detail a\n" +
+			 *             "INNER JOIN tb_lib_manager b on a.`subject` = b.course_name and a.type=b.type and b.user_id=?2\n" +
+			 *             "where a.id in (?1) and DATE_FORMAT(a.arrange_date,'%Y-%m') = ?3")
+			 */
+			if(resultList!=null && resultList.size()>0){
+				List<KmtArrangeAllot> allotList = new ArrayList<>();
+				for(String str:resultList){
+					KmtArrangeAllot allot = new KmtArrangeAllot();
+					KmtArrangeDetail detail = kmtArrangeDetailService.getById(str);
+					allot.setStatus(1);
+					allot.setAttendType(0);
+					allot.setArrangeDate(detail.getArrangeDate());
+					allot.setTeacherId(teacherUserId);
+					allot.setArrangeDetailId(str);
+					allot.setCreateTime(new Date());
+					//allot.set
+					allotList.add(allot);
+				}
+				this.save(allotList);
+			}
+
+			//再加上当前老师对应的时段饱和数
+			//dao.updateArrangeDetailHaveNum(1,preMonth,teacherUserId);
+
+			//将之前删除的数据与新的数据对比 都存在的id，不处理，新增的has_num+1，删除的-1
+			if(!resultList.isEmpty() && !beforeDelList.isEmpty()){
+				for(int i=beforeDelList.size()-1;i>=0;i--){
+					boolean isDel = false;
+					String delStr = beforeDelList.get(i);
+					for (int j=resultList.size()-1;j>=0;j--){
+						String addStr = resultList.get(j);
+						if(delStr.equals(addStr)){
+							isDel=true;
+							resultList.remove(addStr);
+							break;
+						}
+					}
+					if(isDel){
+						beforeDelList.remove(delStr);
+					}
+				}
+			}
+			List<KmtArrangeDetail> list = new ArrayList<>();
+			if(!beforeDelList.isEmpty()){
+				//have_num -1
+				for(String str:beforeDelList){
+					KmtArrangeDetail details = kmtArrangeDetailService.getById(str);
+					details.setHaveNum(details.getHaveNum()-1);
+					list.add(details);
+				}
+			}
+
+			if(!resultList.isEmpty()){
+				//have_num +1
+				for(String str:resultList){
+					KmtArrangeDetail details = kmtArrangeDetailService.getById(str);
+					details.setHaveNum(details.getHaveNum()+1);
+					list.add(details);
+				}
+			}
+			if(!list.isEmpty()){
+				kmtArrangeDetailService.save(list);
+			}
+			//更新所有has_num
+			//dao.updateDetailData(preMonth);
+			responseEntity.success("保存成功");
+
+		}else{
+			responseEntity.failure(000,"不在数据保存时间内，无法保存！");
+		}
+		return responseEntity;
+	}
+
+	@Override
+	public List<DutyTemplate> dutyTemplateList(String teacherUserId) {
+		String preMonth = getPreMonth();
+		List<DutyTemplate> list = new ArrayList<DutyTemplate>();
+		List<Map<String,Object>> maplist = queryDao.findTemplateList(preMonth);
+		for (Map<String,Object> map:maplist){
+			DutyTemplate template = new DutyTemplate();
+			template.setDay(map.get("arrange_date").toString());
+			template.setIsOpen(map.get("is_open").toString());
+			list.add(template);
+		}
+		return list;
+	}
+
+	@Override
+	public void saveSysTeacherDuty(DutySysRequestVO vo1) {
+		Date date = new Date();
+		Calendar ca = Calendar.getInstance();
+		ca.setTime(date);
+		int days = ca.get(Calendar.DAY_OF_MONTH);
+		int lastDay = ca.getActualMaximum(Calendar.DAY_OF_MONTH);
+		if (days > 0 && days<=24) { //时间段
+			List<String> strList = Arrays.asList(vo1.getDays());
+			dao.updateTemplateisClose(getPreMonth());
+			for (String str : strList) {
+				//更新
+				dao.updateTemplateisOpen(str);
+			}
+		}
+	}
+
+	/**
+	 * 描述:获取下一个月.
+	 *
+	 * @return
+	 */
+	public static String getPreMonth() {
+		Date date = new Date();
+		Calendar cal = Calendar.getInstance();
+		cal.setTime(date);
+		cal.add(cal.MONTH, 1);
+		SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM");
+		String preMonth = dft.format(cal.getTime());
+		return preMonth;
+
+	}
+
+	//获取传入月份天数的map list
+	public List<Map<String,Object>> getMonthDayList(Date date){
+		List<Map<String,Object>> mapList = new ArrayList<Map<String,Object>>();
+		//获取第一天
+		Calendar cal = Calendar.getInstance();
+		//设置年份
+		cal.setTime(date);
+		//获取某月最小天数
+		int lastDay = cal.getActualMaximum(Calendar.DATE);
+
+		SimpleDateFormat dft = new SimpleDateFormat("yyyy-MM");
+		String preMonth = dft.format(cal.getTime());
+		for(int i=1;i<=lastDay;i++){
+			Map<String,Object> map = new HashMap<String,Object>();
+			if(String.valueOf(i).length()==1){
+				map.put(preMonth+"-0"+String.valueOf(i),i);
+			}else{
+				map.put(preMonth+"-"+String.valueOf(i),i);
+			}
+			mapList.add(map);
+		}
+		return mapList;
+	}
+
+	public static String getMonthFirstDay(Date date){
+		Calendar cal = Calendar.getInstance();
+		//设置年份
+		cal.setTime(date);
+		//获取某月最小天数
+		int firstDay = cal.getMinimum(Calendar.DATE);
+		//设置日历中月份的最小天数
+		cal.set(Calendar.DAY_OF_MONTH,firstDay);
+		//格式化日期
+		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+		return sdf.format(cal.getTime());
+	}
+
+	public static String getMonthLasttDay(Date date){
+		Calendar cal = Calendar.getInstance();
+		//设置年份
+		cal.setTime(date);
+		//获取某月最小天数
+		int lastDay = cal.getActualMaximum(Calendar.DATE);
+		//设置日历中月份的最小天数
+		cal.set(Calendar.DAY_OF_MONTH,lastDay);
+		//格式化日期
+		SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
+		return sdf.format(cal.getTime());
+	}
+	@Override
+	public KmtArrangeAllot getKmtArrangeAllotByTeacher(String arrangeDetailId,String teacherId) {
+		return dao.getKmtArrangeAllotByTeacher(arrangeDetailId, teacherId);
+	}
+
+
+	@Override
+	public void updateKmtArrangeAllotToStatus(String arrangeDetailId,String teacherId, Integer status) {
+		dao.updateKmtArrangeAllotToStatus(arrangeDetailId, teacherId, status);
+	}
+
+
+	//统计月活跃数，定时任务的时候先调用再更新
+	@Override
+	public Integer countArrangeActiveNum(){
+		Integer activeCount=libVipDao.findActiveNumByActivateTime();//近 7 天激活用户
+		Integer useCount=homeworkDao.findUserCountByCreateTime();//近 7 天使用过作业批改服务的用户
+		Integer repetiveCount=homeworkDao.findRepetiveCount();//重复的
+		Integer monthActiveCount=activeCount+useCount-repetiveCount;//月活跃数
+		return monthActiveCount;
+	}
+
+
+	@Override
+	public Integer countKmtArrangeAllotByArrangeDetailId(String arrangeDetailId) {
+		return dao.countKmtArrangeAllotByArrangeDetailId(arrangeDetailId);
+	}
+
+
+	@Override
+	public List<String> findKmtArrangeAllotByArrangeDetailId(String arrangeDetailId) {
+		return dao.findKmtArrangeAllotByArrangeDetailId(arrangeDetailId);
+	}
+
+
+	@Override
+	public void updateAttendType(String date) throws Exception{
+		//遍历所有的老师
+		List<TbLibManager> teacherList=managerDao.findAllTeacher();
+		for(TbLibManager tbLibManager:teacherList){
+			String userId=tbLibManager.getUserId();
+			int type=tbLibManager.getType();
+			Map<String, Object> map = new HashMap<>();
+			map.put("userId",userId);
+			map.put("type", type);
+			map.put("date", date);
+			List<Map<String, Object>> list = queryDao.findAShouldtendanTime(map);
+			try {
+				if (list.size() > 0) {
+					for (Map<String, Object> map1 : list) {
+						MapGetterTool mapGetterTool = new MapGetterTool(map1);
+						String beginTime = date + " " + mapGetterTool.getString("start_interval") + ":00";
+						LocalDateTime begin = LocalDateTime.parse(beginTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+						String beforeTime = begin.plusMinutes(10).toString().replaceAll("T", " ");
+						String endTime = date + " " + mapGetterTool.getString("end_interval") + ":00";
+						LocalDateTime end = LocalDateTime.parse(endTime, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
+						String afterTime = end.plusMinutes(-5).toString().replaceAll("T", " ");
+						String id = mapGetterTool.getString("id");
+						//先判断10:10分的状态是在线还是离线
+						List<TbLibLoginInfo> minuteList=tbLibLoginInfoDao.findListByTime(userId,type,beforeTime,beforeTime,date);
+						if(minuteList.size()!=0){
+							//判断10点的状态是在线还是离线
+							List<TbLibLoginInfo>  minuteList1=tbLibLoginInfoDao.findListByTime(userId,type,beginTime,beginTime,date);
+							List<TbLibLoginInfo> list0;
+							if(minuteList1.size()!=0){
+								//在线不顺延
+								list0=tbLibLoginInfoDao.findCount(userId,type,beginTime,endTime,date);
+							}else {
+								//不在线顺延,获取第一条记录
+								TbLibLoginInfo tb1=tbLibLoginInfoDao.findByTheFirstTime(userId,type,beginTime,date);
+								 beginTime=DateHelper.getStandTime(tb1.getLoginTime());
+								 endTime=this.getTwoHoursAfter(beginTime);
+								list0=tbLibLoginInfoDao.findCount(userId,type,beginTime,endTime,date);
+							}
+							   if(list0.size()>3){
+							   	continue;
+							   }else {
+							   	if(0==list0.size()){
+							   		//肯定出勤了
+									dao.updateKmtArrangeAllotByID(id,date);
+								}else if(1==list0.size()){
+							   		//退出过一次
+								  String logout=DateHelper.getStandTime(list0.get(0).getLogoutTime());
+								  if(logout.equals(endTime)){
+								  	//临界点下线算出勤
+									  dao.updateKmtArrangeAllotByID(id,date);
+								  }else {
+									  String out=this.getFiveMinutesAfter(logout);
+									  List<TbLibLoginInfo> list1 = tbLibLoginInfoDao.findAllList(userId, type, logout,endTime,date);
+									  if(list1.size()!=0){
+										  String intime = DateHelper.getStandTime(list1.get(0).getLoginTime());
+										  String otime  =DateHelper.getDateTime(list1.get(0).getLogoutTime());
+										  if(out.compareTo(intime)>=0){
+											  dao.updateKmtArrangeAllotByID(id,date);
+										  }else {
+											  continue;
+										  }
+									  }
+								  }
+
+								}else if(list0.size()==2){
+									//退出过2次
+									String intime = DateHelper.getStandTime(list0.get(1).getLoginTime());
+									String outime1  =DateHelper.getDateTime(list0.get(0).getLogoutTime());
+									String outime2 =DateHelper.getDateTime(list0.get(1).getLogoutTime());
+									String out1 = this.getFiveMinutesAfter(outime1);
+									String out2 = this.getFiveMinutesAfter(outime2);
+									if(outime2.equals(endTime)){
+										//临界点下线算出勤
+										dao.updateKmtArrangeAllotByID(id,date);
+									}else {
+										//判断下一次登录的时间
+										List<TbLibLoginInfo> list1 = tbLibLoginInfoDao.findAllList(userId, type, outime2,endTime,date);
+										if(list1.size()!=0){
+											String intime1 = DateHelper.getStandTime(list1.get(0).getLoginTime());
+											if(out1.compareTo(intime)>=0&&out2.compareTo(intime1)>=0){
+												dao.updateKmtArrangeAllotByID(id,date);
+											}else {
+												continue;
+											}
+										}
+									}
+
+
+								}else {
+									//退出过3次
+									String otime1  =DateHelper.getDateTime(list0.get(0).getLogoutTime());
+									String otime2  =DateHelper.getDateTime(list0.get(1).getLogoutTime());
+									String otime3  =DateHelper.getDateTime(list0.get(2).getLogoutTime());
+									String out1 = this.getFiveMinutesAfter(otime1);
+									String out2 = this.getFiveMinutesAfter(otime2);
+									String out3 = this.getFiveMinutesAfter(otime3);
+									String lotime1=DateHelper.getDateTime(list0.get(1).getLoginTime());
+									String lotime2=DateHelper.getDateTime(list0.get(2).getLoginTime());
+									if(otime3.equals(endTime)){
+										//临界点下线算出勤
+										dao.updateKmtArrangeAllotByID(id,date);
+									}else {
+										//判断下一次登录的时间
+										List<TbLibLoginInfo> list1 = tbLibLoginInfoDao.findAllList(userId, type, otime3,endTime,date);
+										if(list1.size()!=0){
+											String intime1 = DateHelper.getStandTime(list1.get(0).getLoginTime());
+											if(out1.compareTo(lotime1)>=0&&out2.compareTo(lotime2)>=0&&out3.compareTo(intime1)>=0){
+												dao.updateKmtArrangeAllotByID(id,date);
+											}else {
+												continue;
+											}
+										}
+									}
+
+								}
+
+							   }
+
+						}
+
+
+					}
+
+				}
+			} catch (Exception e) {
+				e.printStackTrace();
+			}
+
+		}
+
+	}
+
+	private  String  getFiveMinutesAfter(String time) throws Exception{
+		Date date2= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time);
+		Calendar cal=Calendar.getInstance();
+		cal.setTime(date2);
+		cal.add(Calendar.MINUTE,5);
+		Date date3=cal.getTime();
+		String out1  =new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date3);
+		return out1;
+
+	}
+
+
+	private  String getTwoHoursAfter(String time) throws Exception{
+		Date date2= new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse(time);
+		Calendar cal=Calendar.getInstance();
+		cal.setTime(date2);
+		cal.add(Calendar.HOUR_OF_DAY,2);
+		Date date3=cal.getTime();
+		String date1=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date3);
+		return date1;
+	}
+
+
+
+	@Override
+	public boolean findTeacherArrange(Date createTime, String teacherId) {
+		int time = Integer.valueOf(DateHelper.format(createTime, "HH"));
+		String startInterval;
+		String endInterval;
+		if(10 <= time && time < 12) {
+			//如果在10-12点之间
+			startInterval = "10:00";
+			endInterval = "12:00";
+		}else if(15 <= time && time < 17) {
+			startInterval = "15:00";
+			endInterval = "17:00";
+		}else if(17 <= time && time < 19) {
+			startInterval = "17:00";
+			endInterval = "19:00";
+		}else if(19 <= time && time < 21) {
+			startInterval = "19:00";
+			endInterval = "21:00";
+		}else {
+			//都不在排班时间段则加权重
+			return false;
+		}
+		String userId = dao.findTeacherArrange(startInterval,endInterval,teacherId);
+		if(StringUtils.isNotBlank(userId)) {
+			return true;
+		}
+		return false;
+	}
+
+
+	@Override
+	public void clearArrangeAllotByTeacherId(String teacherId) {
+		List<KmtArrangeAllot> kmtArrangeAllot=dao.findKmtArrangeAllotByNextCurTime(teacherId);
+		for (KmtArrangeAllot ka : kmtArrangeAllot) {
+			ka.setStatus(0);
+			KmtArrangeDetail kmtArrangeDetail=kmtArrangeDetailService.getById(ka.getArrangeDetailId());
+			if (kmtArrangeDetail != null && kmtArrangeDetail.getHaveNum() > 0) {
+				kmtArrangeDetail.setHaveNum(kmtArrangeDetail.getHaveNum() - 1);
+				kmtArrangeDetailService.save(kmtArrangeDetail);
+			}
+		}
+		this.save(kmtArrangeAllot);
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtArrangeDetailServiceImpl.java

@@ -0,0 +1,432 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.alibaba.fastjson.JSONObject;
+import com.ssj.bean.kmt.kmt.domain.KmtArrangeAllot;
+import com.ssj.bean.kmt.kmt.domain.KmtArrangeDetail;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.dao.kmt.kmt.dao.KmtArrangeDetailDao;
+import com.ssj.dao.kmt.kmt.dao.KmtArrangeQueryDao;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.util.RedisUtil;
+import com.ssj.service.kmt.arrange.dto.*;
+import com.ssj.service.kmt.arrange.service.KmtArrangeAllotService;
+import com.ssj.service.kmt.arrange.service.KmtArrangeDetailService;
+import com.ssj.service.weixin.library.service.IBookManagerService;
+import org.apache.commons.lang3.ObjectUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigDecimal;
+import java.text.DecimalFormat;
+import java.util.*;
+
+import static java.math.BigDecimal.ROUND_HALF_DOWN;
+
+
+	
+@Transactional
+@Service(version ="1.0")
+public class KmtArrangeDetailServiceImpl extends BaseServiceImpl<KmtArrangeDetail, String> implements KmtArrangeDetailService {
+	
+	protected Logger logger = LoggerFactory.getLogger(this.getClass());
+	
+	@Autowired
+	private KmtArrangeDetailDao dao;
+	
+	@Autowired
+	private KmtArrangeQueryDao queryDao;
+	
+	@Autowired
+	private IBookManagerService managerService;
+	
+	@Autowired
+	private KmtArrangeAllotService kmtArrangeAllotService;
+	
+	@Autowired
+	private RedisUtil redisUtil;
+	
+	
+	
+	@Override
+	public PagingAndSortingRepository<KmtArrangeDetail, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public List<KmtArrangeDetail> findKmtArrangeDetailByCurMonth(String type,String subject) {
+		return dao.findKmtArrangeDetailByCurMonth(type, subject);
+	}
+
+	@Override
+	public List<KmtArrangeDetail> findKmtArrangeDetailByMonth(String month,String type, String subject) {
+		if(StringUtils.isNotEmpty(month)){
+			return dao.findKmtArrangeDetailByMonth(month,type, subject);
+		}else{
+			return dao.findKmtArrangeDetailByCurMonth(type, subject);
+		}
+	}
+
+
+	@Override
+	public ArrangeCalendarDto findCalendarList(String month,String type, String subject) {
+		Calendar calendar = Calendar.getInstance();
+		calendar.setTime(new Date());
+		ArrangeCalendarDto arrangeCalendarDto=new ArrangeCalendarDto();
+		arrangeCalendarDto.setSubject(subject);
+		arrangeCalendarDto.setType(type);
+		arrangeCalendarDto.setIsNextMonth(calendar.get(Calendar.DAY_OF_MONTH)>=25?1:0);
+
+		List<KmtArrangeDetail> kmtArrangeDetails=null;
+		if(StringUtils.isNotEmpty(month)){
+			kmtArrangeDetails=this.findKmtArrangeDetailByMonth(month+"-01",type,subject);
+			Date date=DateHelper.parseDate(month, "yyyy-MM");
+			Calendar cal=Calendar.getInstance();  
+		    cal.setTime(date); 
+			arrangeCalendarDto.setMonth(cal.get(Calendar.MONTH)+1);
+		}else{
+			kmtArrangeDetails=this.findKmtArrangeDetailByCurMonth(type,subject);
+			arrangeCalendarDto.setMonth(Calendar.getInstance().get(Calendar.MONTH)+1);
+		}
+		for (KmtArrangeDetail kmtArrangeDetail : kmtArrangeDetails) {
+			arrangeCalendarDto.addArrangeDetailDto(kmtArrangeDetail);
+		}
+		return arrangeCalendarDto;
+	}
+	
+	
+	@Override
+	public ArrangeTeacherDto findHaveTeacherList(String parentTeacherId,String id, String teacherName) {
+		DecimalFormat df = new DecimalFormat("#0.00");
+		ArrangeTeacherDto arrangeTeacherDto=new ArrangeTeacherDto();
+		KmtArrangeDetail kmtArrangeDetail=this.getById(id);
+		Map<String,String> dutyRatioMap=new LinkedHashMap<String, String>();
+		if(kmtArrangeDetail!=null){
+			ArrangeIntervalDto arrangeDetail=new ArrangeIntervalDto();
+			arrangeDetail.setId(id);
+			arrangeDetail.setArrangeDate(DateHelper.format(kmtArrangeDetail.getArrangeDate(), "yyyy-MM-dd"));
+			arrangeDetail.setStartInterval(kmtArrangeDetail.getStartInterval());
+			arrangeDetail.setEndInterval(kmtArrangeDetail.getEndInterval());
+			arrangeDetail.setIsOpen(kmtArrangeDetail.getIsOpen());
+			arrangeDetail.setMaxNum(kmtArrangeDetail.getMaxNum());
+			arrangeDetail.setMiniNum(kmtArrangeDetail.getMiniNum());
+			arrangeDetail.setHaveNum(kmtArrangeDetail.getHaveNum());
+			if(DateHelper.dateQualsByMonth(kmtArrangeDetail.getArrangeDate(),new Date())
+					|| DateHelper.isLastDayOfMonth(DateHelper.theMonthFirstDate(kmtArrangeDetail.getArrangeDate()),new Date())){
+				arrangeDetail.setIsAdd(1);
+			}else{
+				arrangeDetail.setIsAdd(0);
+			}
+			arrangeTeacherDto.setArrangeDetail(arrangeDetail);
+			
+			List<Map<String,Object>> mapList=queryDao.findHaveTeacherList(parentTeacherId, id, teacherName);
+			for (Map<String, Object> map : mapList) {
+				ArrangeTeacherDetailDto arrangeTeacherDetailDto=new ArrangeTeacherDetailDto();
+				arrangeTeacherDetailDto.setTeacherId(ObjectUtils.defaultIfNull(map.getOrDefault("teacher_id", ""), "").toString());
+				arrangeTeacherDetailDto.setTeacherName(ObjectUtils.defaultIfNull(map.getOrDefault("name", ""), "").toString());
+				arrangeTeacherDetailDto.setPhoto(ObjectUtils.defaultIfNull(map.getOrDefault("t_photo", ""), "").toString());
+				arrangeTeacherDetailDto.setHaveCount(Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("fullcount", "0"), "0").toString()));
+				arrangeTeacherDetailDto.setSubject(kmtArrangeDetail.getSubject());
+				arrangeTeacherDetailDto.setAttendanceRatio(
+						Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("count", "0"), "0").toString()) >0
+						? df.format(new BigDecimal(Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("attend_sum", "0"), "0").toString()))
+						    .divide(new BigDecimal(Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("count", "0"), "0").toString())),10,ROUND_HALF_DOWN).multiply(new BigDecimal(100)))
+						: "0.00");
+				if(StringUtils.isNotEmpty(parentTeacherId)){
+					arrangeTeacherDetailDto.setIsEdit(
+							(ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString())
+							.equals(parentTeacherId) 
+							? ((DateHelper.dateQualsByMonth(kmtArrangeDetail.getArrangeDate(),new Date())
+									|| DateHelper.isLastDayOfMonth(DateHelper.theMonthFirstDate(kmtArrangeDetail.getArrangeDate()),new Date()))) ? 1 : 0 : 0);
+				}else{
+					//判断是否为当月，或上一个月的最后一天，其它时段不能移除
+					if(DateHelper.dateQualsByMonth(kmtArrangeDetail.getArrangeDate(),new Date())
+							|| DateHelper.isLastDayOfMonth(DateHelper.theMonthFirstDate(kmtArrangeDetail.getArrangeDate()),new Date())){
+							arrangeTeacherDetailDto.setIsEdit(1);
+					}else{
+						arrangeTeacherDetailDto.setIsEdit(0);
+					}
+				}
+				
+				//实时小组在岗率：实时排班时长达到 30 个时段的人数／小组总人数
+				if(dutyRatioMap.containsKey((ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString()))){
+					arrangeTeacherDetailDto.setDutyRatio(dutyRatioMap.get((ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString())));
+				}else{
+					List<Map<String, Object>> GTList=queryDao.findGTTeacherByMonthList(ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString(), new Date());
+					if(GTList!=null && GTList.size()>0){
+						List<TbLibManager> list= managerService.findByParentId(ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString());
+						if(list!=null && list.size()>0){
+							arrangeTeacherDetailDto.setDutyRatio(df.format(new BigDecimal(GTList.size())
+							.divide(new BigDecimal(list.size()),10,ROUND_HALF_DOWN).multiply(new BigDecimal(100))));
+							dutyRatioMap.put(ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString(), arrangeTeacherDetailDto.getDutyRatio());
+						}
+					}
+				}
+				arrangeTeacherDto.getList().add(arrangeTeacherDetailDto);
+			}
+		}
+		return arrangeTeacherDto;
+	}
+	
+
+
+	@Override
+	public ArrangeTeacherDto findNoHaveTeacherList(String parentTeacherId,String id, String teacherName) {
+		DecimalFormat df = new DecimalFormat("#0.00");
+		ArrangeTeacherDto arrangeTeacherDto=new ArrangeTeacherDto();
+		KmtArrangeDetail kmtArrangeDetail=this.getById(id);
+		Map<String,String> dutyRatioMap=new LinkedHashMap<String, String>();
+		if(kmtArrangeDetail!=null){
+			ArrangeIntervalDto arrangeDetail=new ArrangeIntervalDto();
+			arrangeDetail.setId(id);
+			arrangeDetail.setArrangeDate(DateHelper.format(kmtArrangeDetail.getArrangeDate(), "yyyy-MM-dd"));
+			arrangeDetail.setStartInterval(kmtArrangeDetail.getStartInterval());
+			arrangeDetail.setEndInterval(kmtArrangeDetail.getEndInterval());
+			arrangeDetail.setIsOpen(kmtArrangeDetail.getIsOpen());
+			arrangeDetail.setMaxNum(kmtArrangeDetail.getMaxNum());
+			arrangeDetail.setMiniNum(kmtArrangeDetail.getMiniNum());
+			arrangeDetail.setHaveNum(kmtArrangeDetail.getHaveNum());
+			arrangeTeacherDto.setArrangeDetail(arrangeDetail);
+			
+			String subject=kmtArrangeDetail.getSubject();
+			Integer type=kmtArrangeDetail.getType();
+			List<String> noAddTeacherIds=new ArrayList<String>();
+
+			//查出小组的所有老师，type and subject
+			List<String> tbLibManagers=managerService.findByParentIdAndTypeAndCourseName(parentTeacherId,type,subject,teacherName);
+			//查出这个时段已经添加的老师Id
+			List<String> kmtArrangeAllots=kmtArrangeAllotService.findKmtArrangeAllotByArrangeDetailId(id);
+			for (String teacherId : tbLibManagers) {
+				if(!kmtArrangeAllots.contains(teacherId)){
+					noAddTeacherIds.add(teacherId);
+				}
+			}
+			if(noAddTeacherIds.size()>0){
+				List<Map<String,Object>> mapList=queryDao.findNoHaveTeacherList(noAddTeacherIds, DateHelper.parseDate(arrangeDetail.getArrangeDate(), "yyyy-MM-dd"));
+				for (Map<String, Object> map : mapList) {
+					ArrangeTeacherDetailDto arrangeTeacherDetailDto=new ArrangeTeacherDetailDto();
+					arrangeTeacherDetailDto.setTeacherId(ObjectUtils.defaultIfNull(map.getOrDefault("teacher_id", ""), "").toString());
+					arrangeTeacherDetailDto.setTeacherName(ObjectUtils.defaultIfNull(map.getOrDefault("name", ""), "").toString());
+					arrangeTeacherDetailDto.setPhoto(ObjectUtils.defaultIfNull(map.getOrDefault("t_photo", ""), "").toString());
+					arrangeTeacherDetailDto.setHaveCount(Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("fullcount", "0"), "0").toString()));
+					arrangeTeacherDetailDto.setSubject(kmtArrangeDetail.getSubject());
+					arrangeTeacherDetailDto.setAttendanceRatio(
+							Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("count", "0"), "0").toString())>0 
+								? df.format(new BigDecimal(Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("attend_sum", "0"), "0").toString()))
+								    .divide(new BigDecimal(Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("count", "0"), "0").toString())),10,ROUND_HALF_DOWN).multiply(new BigDecimal(100)))
+							: "0.00");
+					
+					//实时小组在岗率：实时排班时长达到 30 个时段的人数／小组总人数
+					if(dutyRatioMap.containsKey((ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString()))){
+						arrangeTeacherDetailDto.setDutyRatio(dutyRatioMap.get((ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString())));
+					}else{
+						List<Map<String, Object>> GTList=queryDao.findGTTeacherByMonthList(ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString(), new Date());
+						if(GTList!=null && GTList.size()>0){
+							List<TbLibManager> list= managerService.findByParentId(ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString());
+							if(list!=null && list.size()>0){
+								arrangeTeacherDetailDto.setDutyRatio(
+										df.format(new BigDecimal(GTList.size())
+										.divide(new BigDecimal(list.size()),10,ROUND_HALF_DOWN).multiply(new BigDecimal(100))));
+								dutyRatioMap.put(ObjectUtils.defaultIfNull(map.getOrDefault("parent_id", ""), "").toString(), arrangeTeacherDetailDto.getDutyRatio());
+							}
+						}
+					}
+					arrangeTeacherDto.getList().add(arrangeTeacherDetailDto);
+				}
+			}
+		}	
+		return arrangeTeacherDto;
+	}
+
+
+	@Override
+	public boolean deleteArrangeByTeacher(String id, String teacherId) {
+		try {
+			synchronized(this){
+				kmtArrangeAllotService.updateKmtArrangeAllotToStatus(id, teacherId, 0);
+				Integer count=kmtArrangeAllotService.countKmtArrangeAllotByArrangeDetailId(id);
+				dao.updateKmtArrangeDetailToHaveNum(id, count);
+			}
+		} catch (Exception e) {
+			return false;
+		}
+		return true;
+	}
+
+
+	/**
+	 * reqCode
+	 * 1：成功
+	 * 2：必须提前于排班时段前 4 个小时进行
+	 * 3：此时段添加老师量已超出饱和量
+	 * 4：此时段数据不存在
+	 * 500：异常
+	 * 
+	 */
+	@Override
+	public Integer addArrangeByTeacher(String id, List<String> teacherIds) {
+		Integer reqCode=1;
+		try {
+			synchronized(this){
+				List<KmtArrangeAllot> kmtArrangeAllots=new ArrayList<KmtArrangeAllot>();
+				KmtArrangeDetail kmtArrangeDetail=this.getById(id);
+				if(kmtArrangeDetail!=null){
+					
+					String kmtDetailDate=DateHelper.format(kmtArrangeDetail.getArrangeDate(), "yyyy-MM-dd")+" "+kmtArrangeDetail.getStartInterval();
+					Long s = (DateHelper.parseDate(kmtDetailDate, "yyyy-MM-dd HH:mm").getTime()-System.currentTimeMillis()) / (1000 * 60);
+					if(240 >=s){
+						logger.error("{}：排班必须提前于排班时段前 4 个小时进行",kmtArrangeDetail.getId());
+						reqCode=2;
+						return reqCode;
+					}
+//					if(kmtArrangeDetail.getMaxNum()<(kmtArrangeDetail.getHaveNum()+teacherIds.size())){
+//						logger.error("{}：此时段添加老师量已超出饱和量",kmtArrangeDetail.getId());
+//						reqCode=3;
+//						return reqCode;
+//					}
+					for (String teacherId : teacherIds) {
+						KmtArrangeAllot kmtArrangeAllot=new KmtArrangeAllot();
+						kmtArrangeAllot.setArrangeDate(kmtArrangeDetail.getArrangeDate());
+						kmtArrangeAllot.setArrangeDetailId(id);
+						kmtArrangeAllot.setStatus(1);
+						kmtArrangeAllot.setAttendType(0);
+						kmtArrangeAllot.setCreateTime(new Date());
+						kmtArrangeAllot.setTeacherId(teacherId);
+						kmtArrangeAllots.add(kmtArrangeAllot);
+					}
+					kmtArrangeAllotService.save(kmtArrangeAllots);
+					Integer count=kmtArrangeAllotService.countKmtArrangeAllotByArrangeDetailId(id);
+					dao.updateKmtArrangeDetailToHaveNum(id, count);
+				}else{
+					reqCode=4;
+				}
+			}
+		} catch (Exception e) {
+			logger.error("addArrangeByTeacher添加老师异常:{}",e.getMessage());
+			reqCode=500;
+		}
+		return reqCode;
+	}
+
+
+	@Override
+	public ArrangeTeamTeacherDto findTeamTeacherList(String parentTeacherId,String type,String id,String teacherName,Pageable pageable) {
+		ArrangeTeamTeacherDto arrangeTeamTeacherDto=new ArrangeTeamTeacherDto();
+		arrangeTeamTeacherDto.setDutyRatio("0.00");
+		
+		DecimalFormat df = new DecimalFormat("#0.00");
+		String arrangeDate=null;
+		String tempId=null;
+		if(StringUtils.isNotEmpty(id)){
+			KmtArrangeDetail kmtArrangeDetail=this.getById(id);
+			if(kmtArrangeDetail!=null){
+				arrangeDate=DateHelper.format(kmtArrangeDetail.getArrangeDate(),"yyyy-MM-dd");
+				tempId=kmtArrangeDetail.getArrangeTemplateId();
+			}
+		}
+		Page<Map<String, Object>> page=queryDao.findTeamTeacherList(parentTeacherId, type, tempId, arrangeDate, teacherName, pageable);
+		List<Map<String, Object>> mapList=page.getContent();
+		for (Map<String, Object> map : mapList) {
+			ArrangeTeacherDetailDto arrangeTeacherDetailDto=new ArrangeTeacherDetailDto();
+			arrangeTeacherDetailDto.setTeacherId(ObjectUtils.defaultIfNull(map.getOrDefault("teacher_id", ""), "").toString());
+			arrangeTeacherDetailDto.setTeacherName(ObjectUtils.defaultIfNull(map.getOrDefault("name", ""), "").toString());
+			arrangeTeacherDetailDto.setPhoto(ObjectUtils.defaultIfNull(map.getOrDefault("t_photo", ""), "").toString());
+			arrangeTeacherDetailDto.setHaveCount(Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("fullcount", "0"), "0").toString()));
+			arrangeTeacherDetailDto.setSubject(ObjectUtils.defaultIfNull(map.getOrDefault("course_name", ""), "").toString());
+			arrangeTeacherDetailDto.setDutyRatio("0.00");
+			arrangeTeacherDetailDto.setAttendanceRatio(
+					Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("count", "0"), "0").toString())>0 
+					? df.format(new BigDecimal(Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("attend_sum", "0"), "0").toString()))
+						.divide(new BigDecimal(Integer.parseInt(ObjectUtils.defaultIfNull(map.getOrDefault("count", "0"), "0").toString())),10,ROUND_HALF_DOWN).multiply(new BigDecimal(100)))
+					: "0.00");
+			
+			arrangeTeamTeacherDto.getList().add(arrangeTeacherDetailDto);
+		}
+		arrangeTeamTeacherDto.setTotalElements(page.getTotalElements());
+		arrangeTeamTeacherDto.setTotalPages(page.getTotalPages());
+		
+		//实时小组在岗率：实时排班时长达到 30 个时段的人数／小组总人数
+		List<Map<String, Object>> GTList=queryDao.findGTTeacherByMonthList(parentTeacherId, new Date());
+		if(GTList!=null && GTList.size()>0){
+			List<TbLibManager> list= managerService.findByParentId(parentTeacherId);
+			if(list!=null && list.size()>0){
+				arrangeTeamTeacherDto.setDutyRatio(
+						df.format(new BigDecimal(GTList.size())
+						.divide(new BigDecimal(list.size()),10,ROUND_HALF_DOWN).multiply(new BigDecimal(100)))
+						);
+			}
+		}
+		return arrangeTeamTeacherDto;
+	}
+	
+
+	
+	@Override
+	public List<KmtArrangeDetail> findKmtArrangeDetailByMonth(String month) {
+		return dao.findKmtArrangeDetailByMonth(month);
+	}
+
+	@Override
+	public void pushKmtArrangeDetailByMiniNum() {
+		boolean isPush=false;
+		List<KmtArrangeDetail> kmtArrangeDetails=this.findKmtArrangeDetailByMonth(DateHelper.format(new Date(), "yyyy-MM-dd"));
+		for (KmtArrangeDetail kmtArrangeDetail : kmtArrangeDetails) {
+			if(kmtArrangeDetail.getHaveNum()<kmtArrangeDetail.getMiniNum()){
+				isPush=true;
+				break;
+			}
+		}
+		//发送提醒给校区管理员
+		//发送提醒给超级管理员
+		if(isPush){
+			
+		}
+	}
+
+	
+	@Override
+	public void initKmtArrangeDetailByRedis(String month) {
+		List<KmtArrangeDetail> kmtArrangeDetails=this.findKmtArrangeDetailByMonth(month);
+		for (KmtArrangeDetail kmtArrangeDetail : kmtArrangeDetails) {
+			redisUtil.set(kmtArrangeDetail.getId(), JSONObject.toJSONString(kmtArrangeDetail));
+		}
+	}
+
+
+	@Override
+	public boolean updateKmtArrangeDetailByRedisKey(String id, int haveNum) {
+		synchronized(this){
+			if(redisUtil.exists(id)){
+				String jsonObj=redisUtil.get(id);
+				KmtArrangeDetail kmtArrangeDetail=JSONObject.parseObject(jsonObj, KmtArrangeDetail.class);
+				if(kmtArrangeDetail!=null){
+					if(kmtArrangeDetail.getMaxNum()>=kmtArrangeDetail.getHaveNum()+haveNum){
+						kmtArrangeDetail.setHaveNum(kmtArrangeDetail.getHaveNum()+haveNum);
+						redisUtil.set(kmtArrangeDetail.getId(), JSONObject.toJSONString(kmtArrangeDetail));
+						return true;
+					}
+				}
+			}else{
+				KmtArrangeDetail kmtArrangeDetail=this.getById(id);
+				if(kmtArrangeDetail!=null){
+					if(kmtArrangeDetail.getMaxNum()>=kmtArrangeDetail.getHaveNum()+haveNum){
+						kmtArrangeDetail.setHaveNum(kmtArrangeDetail.getHaveNum()+haveNum);
+						redisUtil.set(kmtArrangeDetail.getId(), JSONObject.toJSONString(kmtArrangeDetail));
+						return true;
+					}
+				}
+			}
+		}
+		return false;
+	}
+
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtArrangeTemplateServiceImpl.java

@@ -0,0 +1,326 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+
+import java.util.ArrayList;
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtArrangeDetail;
+import com.ssj.bean.kmt.kmt.domain.KmtArrangeTemplate;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.bean.weixin.push.domain.SendTemplateShort;
+import com.ssj.dao.kmt.kmt.dao.KmtArrangeQueryDao;
+import com.ssj.dao.kmt.kmt.dao.KmtArrangeTemplateDao;
+import com.ssj.framework.basic.utils.DateHelper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.util.Constant;
+import com.ssj.service.kmt.arrange.dto.ArrangeCalendarDto;
+import com.ssj.service.kmt.arrange.dto.ArrangeDetailDto;
+import com.ssj.service.kmt.arrange.dto.ArrangeIntervalDto;
+import com.ssj.service.kmt.arrange.dto.CurCalendarDto;
+import com.ssj.service.kmt.arrange.dto.CurCalendarIntervalDto;
+import com.ssj.service.kmt.arrange.service.KmtArrangeAllotService;
+import com.ssj.service.kmt.arrange.service.KmtArrangeDetailService;
+import com.ssj.service.kmt.arrange.service.KmtArrangeTemplateService;
+import com.ssj.service.weixin.library.service.IBookManagerService;
+import com.ssj.service.weixin.push.service.PushTemplateService;
+
+
+	
+@Transactional
+@Service(version ="1.0")
+public class KmtArrangeTemplateServiceImpl extends BaseServiceImpl<KmtArrangeTemplate, String> implements KmtArrangeTemplateService {
+	
+	protected Logger logger = LoggerFactory.getLogger(this.getClass());
+	
+	@Autowired
+	private KmtArrangeTemplateDao dao;
+	
+	@Autowired
+	private KmtArrangeQueryDao queryDao;
+	
+	@Autowired
+	private KmtArrangeDetailService kmtArrangeDetailService;
+	
+	@Autowired
+	private KmtArrangeAllotService kmtArrangeAllotService;
+	
+	@Autowired
+	private PushTemplateService pushTemplateService;
+	
+	@Autowired
+	private IBookManagerService bookManagerService;
+	
+	
+	
+	@Override
+	public PagingAndSortingRepository<KmtArrangeTemplate, String> getDao() {
+		return dao;
+	}
+
+
+	@Override
+	public void generateKmtArrangeDetailByNextMonth() {
+		List<String[]> calendarList=DateHelper.nextCalendarList();
+		String[] subjects={"语文","数学","英语"};
+		Integer[] types={Constant.KMT_122_TEACHER_TYPE,Constant.KNOW_MATCH_TYPE};
+		
+		List<KmtArrangeTemplate> arrangeTemplateList=dao.findKmtArrangeTemplateList();
+		List<KmtArrangeDetail> kmtArrangeDetails=new ArrayList<KmtArrangeDetail>();
+		KmtArrangeDetail kmtArrangeDetail=null;
+		for (String subject : subjects) {
+			for (Integer type : types) {
+				for (String[] dates : calendarList) {
+					for (KmtArrangeTemplate kmtArrangeTemplate : arrangeTemplateList) {
+						kmtArrangeDetail=new KmtArrangeDetail();
+						kmtArrangeDetail.setArrangeDate(DateHelper.parseDate(dates[0],"yyyy-MM-dd"));
+						kmtArrangeDetail.setWeek(Integer.valueOf(dates[1]));
+						kmtArrangeDetail.setArrangeTemplateId(kmtArrangeTemplate.getId());
+						kmtArrangeDetail.setStartInterval(kmtArrangeTemplate.getStartInterval());
+						kmtArrangeDetail.setEndInterval(kmtArrangeTemplate.getEndInterval());
+						kmtArrangeDetail.setIsOpen(1);
+						kmtArrangeDetail.setMaxNum(0);
+						kmtArrangeDetail.setMiniNum(0);
+						kmtArrangeDetail.setHaveNum(0);
+						kmtArrangeDetail.setStatus(1);
+						kmtArrangeDetail.setSubject(subject);
+						kmtArrangeDetail.setType(type);
+						kmtArrangeDetail.setCreateTime(new Date());
+						kmtArrangeDetails.add(kmtArrangeDetail);
+					}
+				}
+			}
+		}
+		kmtArrangeDetailService.save(kmtArrangeDetails);
+	}
+
+	@Override
+	public void updateKmtArrangeDetailByNextMonth() {   
+		//月活泼数量
+		Integer activeNum=kmtArrangeAllotService.countArrangeActiveNum();
+		  
+		List<KmtArrangeTemplate> arrangeTemplateList=dao.findKmtArrangeTemplateList();
+		List<KmtArrangeDetail> kmtArrangeDetails=kmtArrangeDetailService.findKmtArrangeDetailByMonth(DateHelper.format(DateHelper.nextMonthFirstDate(), "yyyy-MM-dd"));
+		if(kmtArrangeDetails==null || kmtArrangeDetails.size()<=0){
+			//没有的话，再生成下一个月的数据
+			generateKmtArrangeDetailByNextMonth();
+			kmtArrangeDetails=kmtArrangeDetailService.findKmtArrangeDetailByMonth(DateHelper.format(DateHelper.nextMonthFirstDate(), "yyyy-MM-dd"));
+		}
+		for (KmtArrangeTemplate kmtArrangeTemplate : arrangeTemplateList) {
+			
+			//如果系统中配置的activeNum数为null或小于0,就使用系统中生成的月活泼数量，要不就使用手动配置的月活泼数量
+			if(kmtArrangeTemplate.getActiveNum()==null || kmtArrangeTemplate.getActiveNum()<0){
+				kmtArrangeTemplate.setActiveNum(activeNum);
+				kmtArrangeTemplate.setUpdateTime(new Date());
+				this.save(kmtArrangeTemplate);
+			}
+			
+			for (KmtArrangeDetail kmtArrangeDetail : kmtArrangeDetails) {
+				if(kmtArrangeTemplate.getId().equals(kmtArrangeDetail.getArrangeTemplateId())){
+					if(kmtArrangeDetail.getWeek()<=5){//周中
+						if(kmtArrangeDetail.getType()==Constant.KMT_122_TEACHER_TYPE){//批改人数 
+							kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getAverageNum() * 1.5));
+							kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getAverageNum()));
+						}else if(kmtArrangeDetail.getType()==Constant.KNOW_MATCH_TYPE){//知识点匹配人数
+							if(kmtArrangeDetail.getSubject().equals("语文")){
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 5));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() / 5 ));
+							}else if(kmtArrangeDetail.getSubject().equals("数学")){
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 10));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() / 10));
+							}else if(kmtArrangeDetail.getSubject().equals("英语")){
+								Integer eActiveNum=(int)Math.ceil(kmtArrangeTemplate.getActiveNum() * 0.8) ;
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * eActiveNum / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 5));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * eActiveNum / kmtArrangeTemplate.getKnowAverageNum() / 5));
+							}
+						}
+					}else{//周末
+						if(kmtArrangeDetail.getType()==Constant.KMT_122_TEACHER_TYPE){//批改人数 
+							kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getAverageNum() * 1.5));
+							kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getAverageNum()));
+						}else if(kmtArrangeDetail.getType()==Constant.KNOW_MATCH_TYPE){//知识点匹配人数
+							if(kmtArrangeDetail.getSubject().equals("语文")){
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 5));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() / 5));
+							}else if(kmtArrangeDetail.getSubject().equals("数学")){
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 10));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() / 10));
+							}else if(kmtArrangeDetail.getSubject().equals("英语")){
+								Integer eActiveNum=(int)Math.ceil(kmtArrangeTemplate.getActiveNum() * 0.8) ;
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * eActiveNum / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 5));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * eActiveNum / kmtArrangeTemplate.getKnowAverageNum() / 5));
+							}
+						}
+					}
+				}
+				kmtArrangeDetail.setUpdateTime(new Date());
+			}
+		}
+		kmtArrangeDetailService.save(kmtArrangeDetails);
+		//this.updateKmtArrangeTemplateByActiveNum(activeNum);
+	}
+
+
+	@Override
+	public void updateKmtArrangeTemplateByActiveNum(int activeNum) {
+		dao.updateKmtArrangeTemplateByActiveNum(activeNum);
+	}
+
+
+	@Override
+	public List<CurCalendarDto> findArrangeTemplateIntervalList() {
+		List<CurCalendarDto> list=new ArrayList<CurCalendarDto>();
+		ArrangeCalendarDto arrangeCalendarDto=kmtArrangeDetailService.findCalendarList(null, "8", "语文");
+		List<ArrangeDetailDto> arrangeDetailDtos=arrangeCalendarDto.getList();
+		for (ArrangeDetailDto arrangeDetailDto : arrangeDetailDtos) {
+			CurCalendarDto curCalendarDto=new CurCalendarDto();
+			curCalendarDto.setArrangeDate(arrangeDetailDto.getArrangeDate());
+			curCalendarDto.setIsOpen(arrangeDetailDto.getIsOpen());
+			curCalendarDto.setWeek(arrangeDetailDto.getWeek());
+			
+			List<ArrangeIntervalDto> ArrangeIntervalDtos=arrangeDetailDto.getIntervalList();
+			for (ArrangeIntervalDto arrangeIntervalDto : ArrangeIntervalDtos) {
+				CurCalendarIntervalDto curCalendarIntervalDto=new CurCalendarIntervalDto();
+				curCalendarIntervalDto.setId(arrangeIntervalDto.getId());
+				curCalendarIntervalDto.setArrangeDate(arrangeIntervalDto.getArrangeDate());
+				curCalendarIntervalDto.setStartInterval(arrangeIntervalDto.getStartInterval());
+				curCalendarIntervalDto.setEndInterval(arrangeIntervalDto.getEndInterval());
+				Date aDate=DateHelper.parseDate(arrangeIntervalDto.getArrangeDate()+" "+arrangeIntervalDto.getEndInterval(), "yyyy-MM-dd HH:mm");
+				if(aDate.getTime()<=new Date().getTime()){
+					curCalendarIntervalDto.setIsEnd(1);
+				}else{
+					curCalendarIntervalDto.setIsEnd(0);
+				}
+				curCalendarDto.getIntervalList().add(curCalendarIntervalDto);
+			}
+			list.add(curCalendarDto);
+		}
+		return list;
+	}
+	
+	
+	@Override
+	public KmtArrangeTemplate getKmtArrangeDetailByCurTime() {
+		return dao.getKmtArrangeDetailByCurTime();
+	}
+	
+
+
+	@Override
+	public void pushArrangeTemplateByUserList() {
+		
+		KmtArrangeTemplate kmtArrangeTemplate=this.getKmtArrangeDetailByCurTime();
+		if(kmtArrangeTemplate!=null){
+			List<Map<String, Object>> teacherUsers=queryDao.findKmtArrangeAllotByArrangeTemplateIdList(kmtArrangeTemplate.getId());
+		
+			String template_id_short="OPENTM413234390";
+			Map<String, String> data = new HashMap<String, String>();
+			data.put("first", "根据您的作业批改排班时间，距离开始批改作业还有10分钟，请及时上线。");
+            
+			for (Map<String, Object> map : teacherUsers) {
+				try {
+					data.put("keyword2", map.get("arrange_date")+" "+map.get("start_interval"));
+					TbLibManager tbLibManager=null;
+					List<TbLibManager> tbLibManagers= bookManagerService.findByUserIdAndTypeIn(map.get("teacher_id").toString(), new int[]{Constant.KMT_122_TEACHER_TYPE,Constant.KNOW_MATCH_TYPE});
+					if(tbLibManagers!=null && tbLibManagers.size()>0){
+						tbLibManagers.get(0);
+						
+						for (TbLibManager tm : tbLibManagers) {
+							if(tm.getType()==Integer.parseInt(map.get("type").toString())){
+								tbLibManager=tm;
+								break;
+							}
+						}	
+					}
+					
+					if(map.containsKey("wx_account")){
+						data.put("keyword1", tbLibManager!=null ? tbLibManager.getName() : "");
+						SendTemplateShort sendTemplateShort = new SendTemplateShort(map.get("wx_account").toString(), template_id_short, null, data);
+						pushTemplateService.saveAndSendPushWxTemplate(sendTemplateShort);
+					}
+					
+				} catch (Exception e) {
+					logger.error("距离开始批改作业还有10分钟推送异常{}...",e.getMessage());
+				}
+			}
+		}
+		
+	}
+
+
+	@Override
+	public void updateKmtArrangeDetailByNextMonth(Integer activeNum) {
+		if(activeNum==null || activeNum<=0){
+			logger.error("活泼数量不能为空");
+			return;
+		}
+		List<KmtArrangeTemplate> arrangeTemplateList=dao.findKmtArrangeTemplateList();
+		List<KmtArrangeDetail> kmtArrangeDetails=kmtArrangeDetailService.findKmtArrangeDetailByMonth(DateHelper.format(DateHelper.nextMonthFirstDate(), "yyyy-MM-dd"));
+		if(kmtArrangeDetails==null || kmtArrangeDetails.size()<=0){
+			//没有的话，再生成下一个月份的数据
+			generateKmtArrangeDetailByNextMonth();
+			kmtArrangeDetails=kmtArrangeDetailService.findKmtArrangeDetailByMonth(DateHelper.format(DateHelper.nextMonthFirstDate(), "yyyy-MM-dd"));
+		}
+		for (KmtArrangeTemplate kmtArrangeTemplate : arrangeTemplateList) {
+			kmtArrangeTemplate.setActiveNum(activeNum);
+			for (KmtArrangeDetail kmtArrangeDetail : kmtArrangeDetails) {
+				if(kmtArrangeTemplate.getId().equals(kmtArrangeDetail.getArrangeTemplateId())){
+					if(kmtArrangeDetail.getWeek()<=5){//周中
+						if(kmtArrangeDetail.getType()==Constant.KMT_122_TEACHER_TYPE){//批改人数 
+							kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getAverageNum() * 1.5));
+							kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getAverageNum()));
+						}else if(kmtArrangeDetail.getType()==Constant.KNOW_MATCH_TYPE){//知识点匹配人数
+							if(kmtArrangeDetail.getSubject().equals("语文")){
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 5));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() / 5 ));
+							}else if(kmtArrangeDetail.getSubject().equals("数学")){
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 10));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() / 10));
+							}else if(kmtArrangeDetail.getSubject().equals("英语")){
+								Integer eActiveNum=(int)Math.ceil(kmtArrangeTemplate.getActiveNum() * 0.8) ;
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * eActiveNum / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 5));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWorkRatio() * eActiveNum / kmtArrangeTemplate.getKnowAverageNum() / 5));
+							}
+						}
+					}else{//周末
+						if(kmtArrangeDetail.getType()==Constant.KMT_122_TEACHER_TYPE){//批改人数 
+							kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getAverageNum() * 1.5));
+							kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getAverageNum()));
+						}else if(kmtArrangeDetail.getType()==Constant.KNOW_MATCH_TYPE){//知识点匹配人数
+							if(kmtArrangeDetail.getSubject().equals("语文")){
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 5));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() / 5));
+							}else if(kmtArrangeDetail.getSubject().equals("数学")){
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 10));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * kmtArrangeTemplate.getActiveNum() / kmtArrangeTemplate.getKnowAverageNum() / 10));
+							}else if(kmtArrangeDetail.getSubject().equals("英语")){
+								Integer eActiveNum=(int)Math.ceil(kmtArrangeTemplate.getActiveNum() * 0.8) ;
+								kmtArrangeDetail.setMaxNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * eActiveNum / kmtArrangeTemplate.getKnowAverageNum() * 1.5 / 5));
+								kmtArrangeDetail.setMiniNum((int)Math.ceil(kmtArrangeTemplate.getKnowWeekendRatio() * eActiveNum / kmtArrangeTemplate.getKnowAverageNum() / 5));
+							}
+						}
+					}
+				}
+				kmtArrangeDetail.setUpdateTime(new Date());
+			}
+		}
+		kmtArrangeDetailService.save(kmtArrangeDetails);
+		this.updateKmtArrangeTemplateByActiveNum(activeNum);
+	}
+
+
+	
+
+}
+	
+

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtConchQueryServiceImpl.java

@@ -0,0 +1,82 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import java.util.*;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.sys.homework.domain.HomeworkPicture;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.dao.kmt.kmt.dao.KmtConchQueryDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.dto.SubjectStudentDto;
+import com.ssj.service.kmt.service.KmtConchQueryService;
+import com.ssj.service.kmt.service.ZybWrongQuestionReasonService;
+import com.ssj.service.sys.problem.service.ProblemPictureService;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtConchQueryServiceImpl extends BaseServiceImpl<HomeworkPicture, String> implements KmtConchQueryService {
+	private   Logger logger = LoggerFactory.getLogger(this.getClass());
+
+	@Autowired
+	private KmtConchQueryDao dao;
+
+	@Autowired
+	private ZybWrongQuestionReasonService wrongReasonService;
+
+	@Autowired
+	private ProblemPictureService problemPictureService;
+	
+	@Override
+	public PagingAndSortingRepository<HomeworkPicture, String> getDao() {
+		return null;
+	}
+	
+	@Override
+	@Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<SubjectStudentDto> findHomeworkPictureByList(String teacherId) {
+		List<SubjectStudentDto> result = new ArrayList<SubjectStudentDto>();
+		int hour = DateUtil.getHour(new Date());
+		List<Map<String, Object>> list = null;
+		if (hour < 14) {
+			list = dao.findHomeworkPictureByList(teacherId, DateUtil.format_yyyyMMdd(DateUtil.addDays(new Date(), -1)));
+		} else {
+			list =  dao.findHomeworkPictureByList(teacherId, DateUtil.format_yyyyMMdd(DateUtil.getTodatDate()));
+		}
+		if (list != null && list.size() > 0){
+			result = problemPictureService.parseToFrontFormat(list);
+		}
+
+		return result;
+	}
+
+	public List<String> getVipId  (List<Map<String, Object>> list){
+		List<String> result = new ArrayList<String>();
+		for (Map<String, Object> map : list){
+			if (!result.contains(map.get("vip_id") + "")){
+				result.add(map.get("vip_id") + "");
+			}
+		}
+		return result;
+	}
+
+	@Override
+	@Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public List<Map<String, Object>> findStudentWorkImgByList(String studentWorkId) {
+		return dao.findStudentWorkImgByList(studentWorkId);
+	}
+
+	@Override
+	@Transactional(propagation = Propagation.NOT_SUPPORTED)
+	public Map<String, Object> findWrongReason() {
+		Map<String, Object> data = new HashMap<String, Object>();
+		data.put("list", wrongReasonService.findAll());
+		return data;
+	}
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtCourseKnowAreaServiceImpl.java

@@ -0,0 +1,26 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtCourseKnowArea;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtCourseKnowAreaDao;
+import com.ssj.service.kmt.service.KmtCourseKnowAreaService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+
+	
+@Transactional
+@Service(version ="1.0")
+public class KmtCourseKnowAreaServiceImpl extends BaseServiceImpl<KmtCourseKnowArea, String> implements KmtCourseKnowAreaService {
+	
+	@Autowired
+	private KmtCourseKnowAreaDao dao;
+
+	@Override
+	public PagingAndSortingRepository<KmtCourseKnowArea, String> getDao() {
+		return dao;
+	}
+	
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtCourseKnowDetailServiceImpl.java

@@ -0,0 +1,31 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtCourseKnowDetail;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtCourseKnowDetailDao;
+import com.ssj.service.kmt.service.KmtCourseKnowDetailService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+import java.util.List;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtCourseKnowDetailServiceImpl extends BaseServiceImpl<KmtCourseKnowDetail, String> implements KmtCourseKnowDetailService {
+	
+	@Autowired
+	private KmtCourseKnowDetailDao dao;
+
+	@Override
+	public PagingAndSortingRepository<KmtCourseKnowDetail, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public List<KmtCourseKnowDetail> findByCourseKnowId(String courseKnowId) {
+		return dao.findByCourseKnowId(courseKnowId);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtCourseKnowKdDetailServiceImpl.java

@@ -0,0 +1,31 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtCourseKnowKdDetail;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtCourseKnowKdDetailDao;
+import com.ssj.service.kmt.service.KmtCourseKnowKdDetailService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+import java.util.List;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtCourseKnowKdDetailServiceImpl extends BaseServiceImpl<KmtCourseKnowKdDetail, String> implements KmtCourseKnowKdDetailService {
+	
+	@Autowired
+	private KmtCourseKnowKdDetailDao dao;
+
+	@Override
+	public PagingAndSortingRepository<KmtCourseKnowKdDetail, String> getDao() {
+		return dao;
+	}
+
+
+	@Override
+	public List<KmtCourseKnowKdDetail> findByCourseKnowId(String courseKnowId) {
+		return dao.findByCourseKnowId(courseKnowId);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtCourseKnowTemplateServiceImpl.java

@@ -0,0 +1,25 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtCourseKnowTemplate;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtCourseKnowTemplateDao;
+import com.ssj.service.kmt.service.KmtCourseKnowTemplateService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+@Service(version ="1.0")
+public class KmtCourseKnowTemplateServiceImpl extends BaseServiceImpl<KmtCourseKnowTemplate, String> implements KmtCourseKnowTemplateService {
+    @Autowired
+    private KmtCourseKnowTemplateDao dao;
+
+    @Override
+    public PagingAndSortingRepository<KmtCourseKnowTemplate, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public KmtCourseKnowTemplate findByCourseKnowId(String courseKnowId) {
+        return dao.findByCourseKnowId(courseKnowId);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtCourseQuestionDetailServiceImpl.java

@@ -0,0 +1,121 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtCourseQuestionDetail;
+import com.ssj.framework.basic.utils.StringUtils;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtCourseQuestionDetailDao;
+import com.ssj.dao.kmt.kmt.dao.KmtQueryDao;
+import com.ssj.service.kmt.service.KmtCourseQuestionDetailService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtCourseQuestionDetailServiceImpl  extends BaseServiceImpl<KmtCourseQuestionDetail, String> implements KmtCourseQuestionDetailService {
+	
+	@Autowired
+	private KmtCourseQuestionDetailDao dao;
+	
+	@Autowired
+	private KmtQueryDao queryDao;
+	
+
+	@Override
+	public PagingAndSortingRepository<KmtCourseQuestionDetail, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public KmtCourseQuestionDetail findCourseQuestionDetail(
+			String courseKnowId, Integer mark) {
+		return dao.findCourseQuestionDetail(courseKnowId, mark);
+	}
+	
+	@Override
+	public List<Map<String,Object>> findFeedbackRatioMap(String courseKnowId) {
+		return queryDao.findFeedbackRatioMap(courseKnowId);
+	}
+
+	@Override
+	public Integer findHowDetailsIdByAllCount(String zuoybKnowHowDetailId, String vipId,String courseKnowId) {
+		return queryDao.findHowDetailsIdByAllCount(zuoybKnowHowDetailId,vipId,courseKnowId);
+	}
+
+	@Override
+	public Integer findHowDetailsIdByWrongCount(String zuoybKnowHowDetailId,String vipId,String courseId) {
+		return queryDao.findHowDetailsIdByWrongCount(zuoybKnowHowDetailId, vipId,courseId);
+	}
+
+	@Override
+	public List<Map<String, Object>> findFeedbackWrongRatioMap(String courseId) {
+		return queryDao.findFeedbackWrongRatioMap(courseId);
+	}
+
+	@Override
+	public Integer countFeedBackNum() {
+		return queryDao.countFeedBackNum();
+	}
+
+	@Override
+	public List<Map<String, Object>> findFeedbackRatioVipMap() {
+		return queryDao.findFeedbackRatioVipMap();
+	}
+
+	@Override
+	public List<Map<String, Object>> get121KnowModuleData(String vipId, String subject, String beginTime, String endTime) {
+		return queryDao.get121KnowModuleData(vipId, subject, beginTime, endTime);
+	}
+
+	@Override
+	public List<Map<String, Object>> get121SkillData(String vipId, String subject, String beginTime, String endTime) {
+		List<Map<String, Object>> list = queryDao.get121SkillData(vipId, subject, beginTime, endTime);
+		Map<String, Integer> tempMap = new HashMap<>();
+		List<Map<String, Object>> result = new ArrayList<>();
+		String temp = null;
+		Integer tempInt  = null;
+		if (list != null){
+			for (Map<String, Object> map : list){
+				temp = map.get("module") + "";
+				//获取技能的值
+				if (StringUtils.isNotEmpty(temp)){
+					String[] skills = temp.split(";");
+					for (String skill : skills){
+						tempInt = tempMap.get(skill);
+						if (tempInt != null && tempInt > 0){
+							tempMap.put(skill, tempInt.intValue() + 1);
+						} else {
+							tempMap.put(skill, 1);
+						}
+					}
+				}
+			}
+			//把map转成list
+			Map<String, Object> item = null;
+			for (String key : tempMap.keySet()){
+				item = new HashMap<>();
+				item.put("module", key);
+				item.put("count", tempMap.get(key));
+				result.add(item);
+			}
+		}
+		return result;
+	}
+
+	@Override
+	public List<Map<String, Object>> findCourseKnowIdMap(String courseKnowId) {
+		return queryDao.findCourseKnowIdMap(courseKnowId);
+	}
+
+	@Override
+	public List<KmtCourseQuestionDetail> findByCourseKnowId(String courseKnowId) {
+		return dao.findByCourseKnowIdOrderByMark(courseKnowId);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtCourseRecordServiceImpl.java

@@ -0,0 +1,33 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtCourseRecord;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtCourseRecordDao;
+import com.ssj.service.kmt.service.KmtCourseRecordService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtCourseRecordServiceImpl extends BaseServiceImpl<KmtCourseRecord, String> implements KmtCourseRecordService {
+
+	@Autowired
+	private KmtCourseRecordDao dao;
+	
+	@Override
+	public PagingAndSortingRepository<KmtCourseRecord, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	@Transactional
+	public KmtCourseRecord findKmtCourseRecord(String courseKnowId) {
+		return dao.findKmtCourseRecord(courseKnowId);
+	}
+
+	
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtCourseServiceImpl.java

@@ -0,0 +1,488 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Reference;
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtCourse;
+import com.ssj.bean.kmt.kmt.domain.KmtCourseKnowTemplate;
+
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.util.PropertiesUtil;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.core.util.SystemResourceLocator;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.bean.kmt.kmt.dto.CourseHandoutTemplate;
+import com.ssj.bean.kmt.kmt.dto.LessonGroupDTO;
+import com.ssj.dao.kmt.kmt.dao.KmtCourseDao;
+import com.ssj.dao.kmt.kmt.dao.KmtCourseKnowTemplateDao;
+import com.ssj.dao.kmt.kmt.dao.KmtQueryDao;
+import com.ssj.service.kmt.service.KmtCourseService;
+import com.ssj.service.kmt.service.KmtQuestionService;
+import com.ssj.service.weixin.push.service.PushTemplateService;
+import org.apache.commons.lang3.StringUtils;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.ui.Model;
+
+import org.springframework.transaction.annotation.Transactional;
+import java.util.*;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtCourseServiceImpl extends BaseServiceImpl<KmtCourse, String> implements KmtCourseService {
+
+	private final Logger logger = LoggerFactory.getLogger(KmtCourseServiceImpl.class);
+
+	@Autowired
+	private KmtCourseDao dao;
+	
+	@Autowired
+	private KmtQueryDao queryDao;
+
+	@Autowired
+	private KmtCourseKnowTemplateDao kmtCourseKnowTemplateDao;
+
+
+	 @Autowired
+	private PushTemplateService pushTemplateService;
+	
+
+
+    @Autowired
+    private KmtQuestionService kmtQuestionService;
+    
+
+
+
+	@Override
+	public PagingAndSortingRepository<KmtCourse, String> getDao() {
+		return dao;
+	}
+
+
+	@Override
+	public List<Map<String,Object>> findCourseByList(String teacherId) {
+		return queryDao.findCourseByList(teacherId);
+	}
+
+
+	@Override
+	public List<List<Map<String, Object>>>  findHowByCourseNameByName(String libId,
+			String courseName, String grade, String semester, String type,String name) {
+		List<List<Map<String, Object>>> reqs=new ArrayList<List<Map<String,Object>>>();
+		Map<String, List<Map<String, Object>>> reqMaps=new LinkedHashMap<String, List<Map<String,Object>>>();
+		List<Map<String, Object>> howMap=queryDao.findHowByCourseNameByName(libId, courseName, grade, semester, type, name);
+		for (Map<String, Object> map : howMap) {
+			if(reqMaps.containsKey(map.get("how_id").toString())){
+				reqMaps.get(map.get("how_id").toString()).add(map);
+			}else{
+				List<Map<String, Object>> list=new ArrayList<Map<String,Object>>();
+				list.add(map);
+				reqMaps.put(map.get("how_id").toString(), list);
+			}
+		}
+		for (Map<String, Object> map : howMap) {
+			if(reqMaps.containsKey(map.get("how_id").toString())){
+				reqs.add(reqMaps.get(map.get("how_id").toString()));
+				reqMaps.remove(map.get("how_id").toString());
+			}
+			
+		}
+		return reqs;
+	}
+	
+	@Override
+	public List<List<Map<String, Object>>>  findHowByCourseNameByHowName(String libId,
+			String courseName, String grade, String semester, String type,String name) {
+		List<List<Map<String, Object>>> reqs=new ArrayList<List<Map<String,Object>>>();
+		Map<String, List<Map<String, Object>>> reqMaps=new LinkedHashMap<String, List<Map<String,Object>>>();
+		List<Map<String, Object>> howMap=queryDao.findHowByCourseNameByHowName(libId, courseName, grade, semester, type, name);
+		for (Map<String, Object> map : howMap) {
+			if(reqMaps.containsKey(map.get("how_id").toString())){
+				reqMaps.get(map.get("how_id").toString()).add(map);
+			}else{
+				List<Map<String, Object>> list=new ArrayList<Map<String,Object>>();
+				list.add(map);
+				reqMaps.put(map.get("how_id").toString(), list);
+			}
+		}
+		for (Map<String, Object> map : howMap) {
+			if(reqMaps.containsKey(map.get("how_id").toString())){
+				reqs.add(reqMaps.get(map.get("how_id").toString()));
+				reqMaps.remove(map.get("how_id").toString());
+			}
+			
+		}
+		return reqs;
+	}
+
+
+	@Override
+	public KmtCourse findCourseByKnowId(String courseKnowId) {
+		return dao.findCourseByKnowId(courseKnowId);
+	}
+
+
+	@Override
+	public KmtCourse findFaceCourseByTime(String teacherId, String courseTime,
+			String startTime) {
+		return dao.findFaceCourseByTime(teacherId, courseTime, startTime);
+	}
+
+
+	@Override
+	public KmtCourse findFaceCourseByTime(String teacherId) {
+		return dao.findFaceCourseByTime(teacherId);
+	}
+
+	@Override
+	public List<Map<String, Object>> getTeachCount(String[] teacherIds) {
+		if (teacherIds == null || teacherIds.length  == 0) return null;
+		return queryDao.getTeachCount(teacherIds, 4); //4表示已上课的
+	}
+
+	@Override
+	public List<Map<String, Object>> getTeachStudentCount(String[] teacherIds) {
+		if (teacherIds == null || teacherIds.length  == 0) return null;
+		return queryDao.getTeachStudentCount(teacherIds);
+	}
+
+	@Override
+	public int countDistinctByTeacherId(String teacherId) {
+		return dao.countDistinctByTeacherId(teacherId);
+	}
+
+	@Override
+	public String getMyTeacherId(String vipId) {
+		return dao.getMyTeacherId(vipId);
+	}
+
+	@Override
+	public String getMyTeacherId(String vipId, String date) {
+		return dao.getMyTeacherId(vipId, date);
+	}
+
+	@Override
+	public List<String> findNoTimeTeacher(String date) {
+		//算这个课次的结束时间
+		Calendar cal = Calendar.getInstance();
+		cal.setTime(DateUtil.stringToDate(date));
+		cal.add(Calendar.HOUR, 2);
+
+		String[] splitDate = date.split(" "); // 为了取日期
+		String[] timeArray = splitDate[1].split(":");  //为了取开始时间而分割，笑脸
+		String beginTime = timeArray[0] + ":" + timeArray[1];
+		String endTime = cal.get(Calendar.HOUR) + ":" + cal.get(Calendar.MINUTE);
+		return findNoTimeTeacher(splitDate[0], beginTime, endTime);
+	}
+	@Override
+	public List<String> findNoTimeTeacher (String beginTime, String endTime, String date){
+		return dao.getNoTimeTeacherList(date, beginTime, endTime);
+	}
+	@Override
+	public List<String> findNoTimeTeacherByWeek (String beginTime, String endTime, int[] weeks){
+		return dao.getNoTimeTeacherListByWeek(weeks, beginTime, endTime);
+	}
+	@Override
+	public List<String> findNoTimeTeacherByWeek (String beginTime, String endTime, int[] weeks, List<String> teacherId){
+		return dao.getNoTimeTeacherListByWeek(weeks, beginTime, endTime, teacherId);
+	}
+	@Override
+	public boolean isHasTime  (String beginTime, String endTime, String date, String teacherId){
+		boolean result = true;
+		List<String> teacherList = dao.getNoTimeTeacherList(date, beginTime, endTime, teacherId);
+		if (teacherList != null && teacherList.size() > 0){
+			result = false;
+		}
+		return result;
+	}
+
+
+	@Override
+	public List<KmtCourse> findByTeacherId(String teacherId) {
+		return dao.findByTeacherId(teacherId);
+	}
+	
+	
+	@Override
+	public List<Map<String,Object>> findStudentByList(String teacherId,String name,String grade) {
+		return queryDao.findStudentByList(teacherId,name,grade);
+	}
+
+	@Override
+	public List<Map<String, Object>> findSimpleStudentByList(String teacherId, String name, String grade) {
+		return queryDao.findSimpleStudentByList(teacherId, name, grade);
+	}
+
+	@Override
+	public List<Map<String, Object>> findLibVipByList(String name) {
+		return queryDao.findLibVipByList(name);
+	}
+	
+
+	@Override
+	public List<KmtCourse> findByLessionServiceId(String sid) {
+		return dao.findByLessonServiceIdOrderByCourseTimeAscStartTimeAscIsFinishDesc(sid);
+	}
+
+	@Override
+	public List<KmtCourse> findByLessionServiceIdIn(String[] ids) {
+		return dao.findByLessonServiceIdInAndNum(ids, 1);
+	}
+
+	@Override
+	public List<KmtCourse> findKmtCourseByTeacherAndDate (String teacherId, String date) {
+		return dao.findByTeacherIdAndAndCourseTimeAndState(teacherId, date, 1);
+	}
+	@Override
+	public List<Map<String, Object>> findTimeAndWeek (String vipId){
+		return queryDao.findTimeAndWeekByVipId(vipId);
+	}
+	@Override
+	public List<KmtCourse> findCourseByVipId (String vipId){
+		return dao.findCourse4ChangeTeacher(vipId);
+	}
+
+
+	@Override
+	public void confirmLesson(KmtCourse course) {
+		dao.confirmLesson(course.getLessonServiceId());
+	}
+
+	@Override
+	public boolean validateTeacherCourse(String teacherId, String startTime, String endTime, String courseTime) {
+		//检验时间是否有冲突
+		int count = dao.validateTeacherCourse(teacherId, startTime, endTime, courseTime);
+		return count == 0;
+	}
+
+	@Override
+	public List<KmtCourse> findByVipIdAndLessonServiceIdAndPlanStatusLessThan(String vipId, String lessonServiceId,int planStatus) {
+		return dao.findByVipIdAndLessonServiceIdAndPlanStatusLessThanOrderByCourseTime(vipId, lessonServiceId, planStatus);
+	}
+
+	@Override
+	public List<String> findTeachersByLessonServiceId(String lessonServiceId) {
+		return dao.findTeachersByLessonServiceId(lessonServiceId);
+	}
+
+	@Override
+	public int countByCurrentMonthFinishLesson(String lessonServiceId, String monthBeginTime, String monthEndTime) {
+		return dao.countByCurrentMonthFinishLesson(lessonServiceId, monthBeginTime, monthEndTime);
+	}
+
+	@Override
+	public int countIsFinishCourse(String teacherId){
+		return dao.countByTeacherIdAndIsFinish(teacherId, 1);
+	}
+
+	@Override
+	public List<String> findByVipIdAndDate(String vipId, String date, Integer isGroup) {
+		return dao.findByVipIdAndDate(vipId, date, isGroup);
+	}
+
+
+	@Override
+	public List<KmtCourse> findByLessonServiceId(String lessonServiceId) {
+		return dao.findByLessonServiceId(lessonServiceId);
+	}
+
+
+	@Override
+	public List<KmtCourse> findFinishCourseByVipIdAndTimes(String vipId, String startTime, String endTime) {
+		return dao.findFinishCourseByVipIdAndTimes(vipId, startTime, endTime);
+	}
+
+    @Override
+    public ResponseEntity howList(String courseName, String grade, String name, String semester, String queryKdlist, String topic) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        List<List<Map<String, Object>>> howList = new ArrayList<>();
+        Map<String, Object> map =new HashMap<>(16);
+        if(StringUtils.isEmpty(semester)){
+
+            semester= PropertiesUtil.getValue("semester");
+        }
+        if ("同步".equals(topic)) {
+            //"同步"知识点
+            howList = findHowByCourseNameByName("SSJ", courseName, grade, semester, "2", name);
+        } else if ("专题".equals(topic)) {
+            //"专题"知识点
+        	howList = findHowByCourseNameByHowName("SSJ", courseName, grade, semester, "2", name);
+        }
+        map.put("howList", howList);
+        if(StringUtils.isNotEmpty(queryKdlist)){
+            map.put("kbList", kmtQuestionService.findKBByList("SSJ", courseName, grade, semester,"2"));
+        }
+        responseEntity.success(map,"查询成功");
+        return responseEntity;
+    }
+
+	@Override
+	public List<CourseHandoutTemplate> findCourseHandoutTemplateList(String teacherId, String courseName, String courseHandoutTemplateName) {
+		return queryDao.findCourseHandoutTemplateList(teacherId, courseName, courseHandoutTemplateName);
+	}
+
+    @Override
+    public ResponseEntity applyTemplate(String groupCourseId, String courseKnowTemplateId) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		List<KmtCourse> kmtCourseList = dao.findByGroupCourseId(groupCourseId);
+		if (kmtCourseList == null || kmtCourseList.isEmpty()) {
+			logger.warn("一对多备课选择已有模板时，未查询到对应课程，groupCourseId=" + groupCourseId);
+			responseEntity.failure("没有此课程");
+			return responseEntity;
+		}
+		KmtCourseKnowTemplate courseKnowTemplate = kmtCourseKnowTemplateDao.findOne(courseKnowTemplateId);
+		if (courseKnowTemplate == null) {
+			logger.warn("一对多备课选择已有模板时，发现对应模板为空，courseKnowTemplateId=" + courseKnowTemplateId);
+			responseEntity.failure("没有此模板");
+			return responseEntity;
+		}
+
+		kmtCourseList.forEach(kmtCourse -> {
+			kmtCourse.setCourseKnowId(courseKnowTemplate.getCourseKnowId());
+			dao.save(kmtCourse);
+		});
+
+		responseEntity.success("应用成功");
+
+		return responseEntity;
+	}
+
+	@Override
+	public List<KmtCourse> findByGroupCourseId(String groupCourseId) {
+		return dao.findByGroupCourseId(groupCourseId);
+	}
+
+	@Override
+	public List<KmtCourse> findCourseListByLessonGroupIdAndPlanStatus(String lessonGroupId, List<Integer> planStatusList) {
+		return dao.findCourseListByLessonGroupId(lessonGroupId, planStatusList);
+	}
+
+	@Override
+	public List<LessonGroupDTO> findLessonGroupList(String teacherId, String courseTime) {
+		List<LessonGroupDTO> lessonGroupList = queryDao.findLessonGroupList(teacherId, courseTime);
+		lessonGroupList.sort((lessonGroup1, lessonGroup2) -> {
+			Date date1 = DateUtil.parse_yyyyMMddHHmm(courseTime + " " + lessonGroup1.getStartTime());
+			Date date2 = DateUtil.parse_yyyyMMddHHmm(courseTime + " " + lessonGroup2.getStartTime());
+			return date1.compareTo(date2);
+		});
+		return lessonGroupList;
+	}
+
+	@Override
+	public String findLessonGroupDetail(Model model, String lessonGroupId, String groupCourseId, String teacherId) {
+		/**
+		LessonGroup lessonGroup = lessonGroupService.getById(lessonGroupId);
+		if (!Objects.equals(teacherId, lessonGroup.getTeacherId())) {
+			logger.warn("只能查询自己授课的课程");
+			return "/error/500";
+		}
+
+		Calendar calendar = Calendar.getInstance();
+		calendar.setTime(new Date());
+		calendar.add(Calendar.HOUR_OF_DAY, -12);
+		Date time = calendar.getTime();
+		String timeStr = DateUtil.format_yyyyMMddHHmmss(time);
+
+		KmtCourse kmtCourse = dao.findOneByGroupCourseIdAndLessonGroupId(groupCourseId, lessonGroupId, timeStr);
+
+		List<Map<String, Object>> studentList = queryDao.findLessonGroupStudentList(groupCourseId, timeStr);
+
+		LessonGroupDetailDTO lessonGroupDetailDTO = new LessonGroupDetailDTO();
+		lessonGroupDetailDTO.setLessonGroupId(lessonGroupId);
+		lessonGroupDetailDTO.setGroupName(lessonGroup.getGroupName());
+		lessonGroupDetailDTO.setGroupCourseId(groupCourseId);
+		lessonGroupDetailDTO.setCourseName(lessonGroup.getCourseName());
+		lessonGroupDetailDTO.setCourseKnowId(kmtCourse.getCourseKnowId());
+		lessonGroupDetailDTO.setCourseTime(kmtCourse.getCourseTime());
+		lessonGroupDetailDTO.setStartTime(kmtCourse.getStartTime());
+		lessonGroupDetailDTO.setStudentList(studentList);
+
+        model.addAttribute("lessonGroupDetailDTO", lessonGroupDetailDTO);
+		 **/
+        return "kmt/course/ExamSprint";
+	}
+
+	@Override
+	public ResponseEntity modifyLessonGroupName(String lessonGroupId, String newName, String teacherId) {
+		ResponseEntity responseEntity = new ResponseEntity();
+		/**
+
+		LessonGroup lessonGroup = lessonGroupService.getById(lessonGroupId);
+		if (!Objects.equals(teacherId, lessonGroup.getTeacherId())) {
+			responseEntity.failure("只能修改自己授课的课程");
+			return responseEntity;
+		}
+
+		lessonGroup.setGroupName(newName);
+		lessonGroupService.save(lessonGroup);
+	**/
+		responseEntity.success("修改成功");
+		return responseEntity;
+	}
+
+	@Override
+	public List<Date> findLessonGroupDateList(String teacherId) {
+		Calendar calendar = Calendar.getInstance();
+		calendar.setTime(new Date());
+		calendar.add(Calendar.HOUR_OF_DAY, -12);
+		Date time = calendar.getTime();
+		String timeStr = DateUtil.format_yyyyMMddHHmmss(time);
+
+		return dao.findLessonGroupDateList(teacherId, timeStr);
+	}
+
+	@Override
+	public List<KmtCourse> findFaceCourseByGroupIdAndChildNameAndFlowId(String lessonGroupId, String childName,String flowId) {
+		if(StringUtils.isBlank(flowId)) {
+			return dao.findFaceCourseByGroupIdAndChildName(lessonGroupId, childName);
+		}
+		return dao.findFaceCourseByGroupIdAndChildNameAndFlowId(lessonGroupId,flowId);
+	}
+
+	@Override
+	public List<Map<String, Object>> finishHandout(String lessonGroupId) {
+		return queryDao.finishHandout(lessonGroupId);
+	}
+
+
+	@Override
+	public List<Map<String, Object>> findAllTeacherPraise () {
+		return queryDao.findAllTeacherPraise();
+	}
+
+	@Override
+	public List<KmtCourse> findAllUnPraiseCourse() {
+		return dao.findByIsFinishAndParentJudgeLeverIsNull(1);
+	}
+
+
+	@Override
+	public KmtCourse findByLessonGroupIdAndVipId(String lessonGroupId, String vipId) {
+		return dao.findByLessonGroupIdAndVipId(lessonGroupId, vipId);
+	}
+
+
+	@Override
+	public boolean validateGroupCourseKnow(String lessonGroupId, int currentCount) {
+		int count = dao.validateGroupCourseKnow(lessonGroupId, currentCount);
+		if(count == 0) {
+			//没有生成讲义
+			return true;
+		}
+		//有生成讲义
+		return false;
+	}
+
+    @Override
+    public Integer countCourseSumByLessonGroupId(String lessonGroupId) {
+        return dao.countCourseSumByLessonGroupId(lessonGroupId);
+    }
+
+
+	@Override
+	public KmtCourse findCourseRandomStudent(String lessonGroupId) {
+		return dao.findCourseRandomStudent(lessonGroupId);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtCourseTemplateServiceImpl.java

@@ -0,0 +1,62 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import java.util.List;
+
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtCourseTemplate;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtCourseTemplateDao;
+import com.ssj.service.kmt.service.KmtCourseTemplateService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtCourseTemplateServiceImpl extends BaseServiceImpl<KmtCourseTemplate, String> implements KmtCourseTemplateService {
+
+	@Autowired
+	private KmtCourseTemplateDao dao;
+
+	@Override
+	public PagingAndSortingRepository<KmtCourseTemplate, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public List<KmtCourseTemplate> findTemplateByList(String teacherId,String type) {
+		return dao.findTemplateByList(teacherId,type);
+	}
+
+	@Override
+	public List<String> findHasTimeTeacherByCourseTime(String[] teacherIds, int week, String courseTime) {
+		return dao.findTeacherCourseTime(week, courseTime, teacherIds);
+	}
+
+	@Override
+	public List<String> findHasTimeTeacherByWeek(String[] teacherIds, int[] weeks, String courseTime) {
+		return dao.findTeacherByWeek(weeks, courseTime, teacherIds);
+	}
+
+	public KmtCourseTemplate findTemplateByTeacherId  (String teacherId, String courseTime) {
+		return dao.findByTeacherIdAndState(teacherId, courseTime, 1);
+	}
+
+
+	public List<KmtCourseTemplate> findByTeacherIdAndWeek (String teacherId, int week){
+		return dao.findByTeacherAndWeek(teacherId, week);
+	}
+
+	@Override
+	public KmtCourseTemplate findTemplateByAnyThing(String teacherId, int type, String val) {
+		
+		return dao.findTemplateByAnyThing(teacherId,type,val);
+	}
+
+	@Override
+	public void setTeacherDataState(String teacherId, int type) {
+		dao.setTeacherDataState(teacherId,type);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExampaperAreaServiceImpl.java

@@ -0,0 +1,115 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExampaperArea;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.persistence.DynamicSpecifications;
+import com.ssj.framework.core.persistence.SearchFilter;
+import com.ssj.framework.core.solr.util.SolrQueryUtils;
+import com.ssj.dao.kmt.kmt.dao.IKmtExampaperAreaDao;
+import com.ssj.service.kmt.service.IKmtExampaperAreaService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtExampaperAreaServiceImpl extends BaseServiceImpl<KmtExampaperArea, String>
+		implements IKmtExampaperAreaService {
+
+	@Autowired
+	private IKmtExampaperAreaDao dao;
+	
+	@Override
+	public PagingAndSortingRepository<KmtExampaperArea, String> getDao() {
+		
+		return dao;
+	}
+	@Override
+	public Page<KmtExampaperArea> findByPage(Map<String, Object> params, Pageable sp) {
+		 Map<String, SearchFilter> filters = SearchFilter.parse(params);
+			Specification<KmtExampaperArea> specification = DynamicSpecifications.bySearchFilter(filters.values(), KmtExampaperArea.class);
+			return  dao.findAll(specification, sp);
+	}
+	@Override
+	public List<KmtExampaperArea> findByCourseNameAndGrad(String courseName,
+			String grad) {
+		return dao.findByCourseNameAndGrad(courseName, grad);
+	}
+	@Override
+	public KmtExampaperArea findBeanByAnyThings(String year, String city, String area, String school, Integer semester,
+			Integer type, String subject, String grade,String addStr) {
+		
+		return dao.findBeanByAnyThings( year,  city,  area,  school, semester,type,  subject,  grade,addStr);
+	}
+	@Override
+	public KmtExampaperArea findBeanByAnyThings(String year, String city, String area, String school, Integer semester,
+			Integer type, String subject, String grade,String addStr, String id) {
+		return dao.findBeanByAnyThings( year,  city,  area,  school, semester,type,  subject,  grade,addStr,id);
+	}
+	@Override
+	public KmtExampaperArea findByCourseNameAndGradAndArea(String year,
+			String area, String semester, Integer type, String subject,
+			String grade) {
+		List<KmtExampaperArea> list =dao.findByCourseNameAndGradAndArea(year, area, semester, type, subject, grade);
+		 int pageSize=1;
+		 int listcount =list.size();
+		 if(listcount==0){
+			 return null;
+		 }
+		 if(list.size()<=pageSize){
+			 return list.get(0);
+		 }
+		 int count = SolrQueryUtils.getRandom(listcount);
+		return list.get(count);
+	}
+	@Override
+	public KmtExampaperArea findByCourseNameAndGradAndArea(String year,
+			String area, String semester, Integer type, String subject,
+			String grade, List<String> ids) {
+		List<KmtExampaperArea> list = new ArrayList<KmtExampaperArea>();
+		if(ids!=null&&ids.size()>0){
+			list.addAll(dao.findByCourseNameAndGradAndArea(year, area, semester, type, subject, grade,ids));
+		}else{
+			list.addAll(dao.findByCourseNameAndGradAndArea(year, area, semester, type, subject, grade));
+		}
+		 int pageSize=1;
+		 int listcount =list.size();
+		 if(listcount==0){
+			 return null;
+		 }
+		 if(list.size()<=pageSize){
+			 return list.get(0);
+		 }
+		 int count = SolrQueryUtils.getRandom(listcount);
+		return list.get(count);
+	}
+	@Override
+	public KmtExampaperArea findByCourseNameAndGradAndArea(String year,
+			String area, String semester, Integer type, String subject,
+			String grade, String areaId) {
+		 List<KmtExampaperArea> list =dao.findByCourseNameAndGradAndArea(year, area, semester, type, subject, grade,areaId);
+		 int pageSize=1;
+		 int listcount =list.size();
+		 if(listcount==0){
+			 return null;
+		 }
+		 if(list.size()<=pageSize){
+			 return list.get(0);
+		 }
+		int count = SolrQueryUtils.getRandom(listcount);
+		return list.get(count);
+	}
+
+	@Override
+	public KmtExampaperArea findAreaByQuestionId(String questionId) {
+		return dao.findByQuestionId(questionId);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExampaperDetailServiceImpl.java

@@ -0,0 +1,137 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExampaperDetail;
+import com.ssj.bean.kmt.kmtsys.model.TreeDataModel;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.persistence.DynamicSpecifications;
+import com.ssj.framework.core.persistence.SearchFilter;
+import com.ssj.dao.kmt.kmt.dao.KmtExampaperDetailDao;
+import com.ssj.service.kmt.service.KmtExampaperDetailService;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.jpa.domain.Specification;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtExampaperDetailServiceImpl extends BaseServiceImpl<KmtExampaperDetail, String>
+		implements KmtExampaperDetailService {
+
+	@Autowired
+	private KmtExampaperDetailDao dao;
+	
+	@Override
+	public PagingAndSortingRepository<KmtExampaperDetail, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public List<KmtExampaperDetail> findKmtExampaperDetails(String areaId) {
+		return dao.findKmtExampaperDetails(areaId);
+	}
+
+	@Override
+	public List<KmtExampaperDetail> getPidAndCodes(String pid,String areaId) {
+		return dao.getPidAndCodes(pid,areaId);
+	}
+
+	@Override
+	public Page<KmtExampaperDetail> findByPage(Map<String, Object> params,
+			Pageable sp) {
+		 Map<String, SearchFilter> filters = SearchFilter.parse(params);
+			Specification<KmtExampaperDetail> specification = DynamicSpecifications.bySearchFilter(filters.values(), KmtExampaperDetail.class);
+			return  dao.findAll(specification, sp);
+	}
+
+	@Override
+	public Integer updateSortNo(String id, int sortNo) {
+		return dao.updateSortNo(id, sortNo);
+	}
+
+	@Override
+	public void changeSubCount(String id, boolean increase) {
+		KmtExampaperDetail org = this.getById(id);
+		if(org!=null){
+			 int subCount = org.getSubCount();
+			 if(increase){
+				 subCount ++;
+			 }else{
+				 subCount --;
+			 }
+			 org.setSubCount(subCount);
+			 this.save(org);
+		}
+		
+	}
+
+	@Override
+	public List<KmtExampaperDetail> findKmtExampaperDetailsByQuId(String areaId, String quId) {
+		return dao.findKmtExampaperDetailsByQuId(areaId,quId);
+	}
+
+	@Override
+	public List<TreeDataModel> findTreeDataModels(String areaId) {
+		List<TreeDataModel> treeDataModels=new ArrayList<TreeDataModel>();
+		TreeDataModel treeDataModel=null;
+		List<KmtExampaperDetail> kmtExampaperDetails= dao.findKmtExampaperDetails(areaId);
+		if(kmtExampaperDetails!=null){
+			for (KmtExampaperDetail kmtExampaperDetail : kmtExampaperDetails) {
+				if(StringUtils.isEmpty(kmtExampaperDetail.getpId()) 
+						|| "-1".equals(kmtExampaperDetail.getpId())){//组装出第一级
+					treeDataModel=new TreeDataModel();
+					treeDataModel.setAreaId(kmtExampaperDetail.getAreaId());
+					treeDataModel.setId(kmtExampaperDetail.getId());
+					treeDataModel.setName(kmtExampaperDetail.getName());
+					treeDataModel.setCode(kmtExampaperDetail.getCode());
+					treeDataModel.setOpen(true);
+					treeDataModel.setQuestionId(kmtExampaperDetail.getQuestionId());
+					treeDataModel.setKmtQuestion(kmtExampaperDetail.getKmtQuestion());
+					treeDataModel.setChildren(new ArrayList<TreeDataModel>());
+					treeDataModels.add(treeDataModel);
+				}
+			}
+			for (KmtExampaperDetail kmtExampaperDetail : kmtExampaperDetails) {
+				if(StringUtils.isNotEmpty(kmtExampaperDetail.getpId())){
+					runTree(treeDataModels,kmtExampaperDetail);
+				}
+			}
+		}
+		return treeDataModels;
+	}
+
+	
+	private void  runTree(List<TreeDataModel> treeDataModels,KmtExampaperDetail kmtExampaperDetail){
+		TreeDataModel model=null;
+		for (TreeDataModel treeDataModel : treeDataModels) {
+			if(treeDataModel.getId().equals(kmtExampaperDetail.getpId())){
+				model=new TreeDataModel();
+				model.setAreaId(kmtExampaperDetail.getAreaId());
+				model.setId(kmtExampaperDetail.getId());
+				model.setName(kmtExampaperDetail.getName());
+				model.setCode(kmtExampaperDetail.getCode());
+				model.setOpen(true);
+				model.setQuestionId(kmtExampaperDetail.getQuestionId());
+				model.setKmtQuestion(kmtExampaperDetail.getKmtQuestion());
+				model.setChildren(new ArrayList<TreeDataModel>());
+				treeDataModel.getChildren().add(model);
+			}else{
+				runTree(treeDataModel.getChildren(),kmtExampaperDetail);
+			}
+		}
+	}
+	
+	
+	
+	
+	
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExampaperServiceImpl.java

@@ -0,0 +1,38 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExampaper;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtExampaperDao;
+import com.ssj.service.kmt.service.KmtExampaperService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+import java.util.List;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtExampaperServiceImpl extends BaseServiceImpl<KmtExampaper, String> implements KmtExampaperService {
+
+	@Autowired
+	private KmtExampaperDao dao;
+
+	@Override
+	public PagingAndSortingRepository<KmtExampaper, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public List<KmtExampaper> findByQuIdList(String quId) {
+		return dao.findByQuIdList(quId);
+	}
+
+	@Override
+	public void deleteByQuestionId(String quId) {
+		 dao.deleteByQuestionId(quId);
+	}
+	
+	
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseBookCourseServiceImpl.java

@@ -0,0 +1,220 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseBookCourse;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseBookCourseDao;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseQueryDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.util.Constant;
+import com.ssj.service.conch.parents.v1.dto.BookDTO;
+import com.ssj.service.kmt.constant.KnowledgeVersion;
+import com.ssj.service.kmt.dto.ExerciseBookBaseDto;
+import com.ssj.service.kmt.dto.ExerciseBookCourseDTO;
+import com.ssj.service.kmt.dto.ExerciseBookDto;
+import com.ssj.service.kmt.request.ExerciseConditionRequest;
+import com.ssj.service.kmt.request.QuestionDistributeRequest;
+import com.ssj.service.kmt.service.KmtExerciseBookCourseService;
+import com.ssj.service.mapper.KmtExerciseMapper;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtExerciseBookCourseServiceImpl extends BaseServiceImpl<KmtExerciseBookCourse, String> implements KmtExerciseBookCourseService {
+
+    @Autowired
+    private KmtExerciseBookCourseDao dao;
+
+    @Autowired
+    private KmtExerciseQueryDao queryDao;
+
+    @Autowired
+    private KnowledgeVersion knowledgeVersion;
+    @Autowired
+    private KmtExerciseMapper kmtExerciseMapper;
+
+    @Override
+    public PagingAndSortingRepository<KmtExerciseBookCourse, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public List<ExerciseBookDto> getExerciseCondition(ExerciseConditionRequest request, String userId) {
+        List<KmtExerciseBookCourse> list = null;
+        if (request.getDealType() == 1){
+            if (StringUtils.isBlank(request.getGrade())){
+                //待加工页面没有科目年级，只判断年级
+                list = dao.findHandBooksByStatusAndUserId(userId, Constant.MAX_ROWS_COUNT);
+            } else {
+                list = dao.findUnHandlingBook(request.getSubject(), request.getGrade(), request.getVersionType(), request.getSemester(), Constant.MAX_ROWS_COUNT);
+            }
+        } else if (request.getDealType() == 2){
+            if (StringUtils.isBlank(request.getGrade())){
+                //待审核页面没有科目年级，只判断年级
+                list = dao.findAudeBooksByStatusAndUserId(userId, Constant.MAX_ROWS_COUNT);
+            } else {
+                list = dao.findUnAuditingBook(request.getSubject(), request.getGrade(), request.getVersionType(), request.getSemester(), Constant.MAX_ROWS_COUNT);
+            }
+        } else if (request.getDealType() == 4) {
+            list = kmtExerciseMapper.findUnAnalysisBookCourse(userId, Constant.MAX_ROWS_COUNT);
+        } else {
+            list = queryDao.getAllBookCourse(request.getSubject(), request.getGrade(),
+                    request.getSemester(), request.getVersionType());
+        }
+        List<ExerciseBookDto> result = new ArrayList<>();
+        if (list != null) {
+            result = this.findBookList(list);
+        }
+        return result;
+    }
+
+    @Override
+    public List<ExerciseBookCourseDTO> getBookExerciseList(QuestionDistributeRequest request) {
+        return queryDao.getBookExerciseList(request);
+    }
+
+
+    /**
+     *  循环插入练习册到结构列表中
+     * @param list
+     * @return
+     */
+    private List<ExerciseBookDto> findBookList (List<KmtExerciseBookCourse> list){
+        List<ExerciseBookDto> result = new ArrayList<>();
+        if (list != null) {
+            ExerciseBookDto book = null;
+            for (KmtExerciseBookCourse course : list) {
+                book = this.isBookExist(result, course.getBookId());
+                if (book == null){
+                    String bookName = course.getBookName();
+                    book = new ExerciseBookDto(course.getBookId(), bookName);
+                    if (StringUtils.isNotBlank(course.getGrade())){
+                        //如果有年级-科目等信息，组装一个描述信息 年级-上下册-版本-科目
+                        book.setSemester(course.getSemester() == 0 ? 1 : course.getSemester());
+                        book.setGrade(course.getGrade());
+                        book.setSubject(course.getCourseName());
+                        String versionStr = null;
+                        if (StringUtils.isNotBlank(course.getCourseName())){
+                            versionStr = knowledgeVersion.getVersionNameBySubjectAndVersionNum(course.getCourseName(), course.getVersion());
+                            bookName += '(' + versionStr.substring(0, 1) + ')';
+                            book.setName(bookName);
+                        }
+                        ExerciseBookBaseDto version = new ExerciseBookBaseDto(course.getVersion().toString(), versionStr);
+                        book.setVersion(version);
+                    }
+                    result.add(0, book);
+                }
+                book.addUnit(course.getUnitId(), course.getUnit(), course.getId(), course.getPeriod());
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 练习册是否已经存在
+     * @param list
+     * @param bookId
+     * @return
+     */
+    private ExerciseBookDto isBookExist (List<ExerciseBookDto> list, String bookId){
+        ExerciseBookDto result = null;
+        for (ExerciseBookDto book : list){
+            if (book.getId().equals(bookId)){
+                result = book;
+                break;
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public String getExerciseBookByBookId(String bookId) {
+        KmtExerciseBookCourse kmtExerciseBookCourse = dao.findOneByBookId(bookId);
+        String result = "";
+        if (kmtExerciseBookCourse != null){
+            result = kmtExerciseBookCourse.getBookName();
+        }
+        return result;
+    }
+
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public List<KmtExerciseBookCourse> findByUnitId(String unitId) {
+        return dao.findByUnitId(unitId);
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public List<KmtExerciseBookCourse> findByBookId(String bookId) {
+        return dao.findByBookId(bookId);
+    }
+
+    @Override
+    public Page<BookDTO> findBookPage(String grade, String subject, String bookName, Pageable pageable) {
+        Page<BookDTO> bookDTOPage = queryDao.findBookPage(grade, subject, bookName, pageable);
+
+        List<BookDTO> bookDTOList = bookDTOPage.getContent();
+        if (CollectionUtils.isNotEmpty(bookDTOList)) {
+            KnowledgeVersion knowledgeVersion = new KnowledgeVersion();
+            knowledgeVersion.init();
+
+            //根据版本编号和科目设置版本名称
+            bookDTOList.forEach(bookDTO -> bookDTO.setVersionName(knowledgeVersion.getVersionNameBySubjectAndVersionNum(bookDTO.getSubject(), bookDTO.getVersion())));
+        }
+
+        return bookDTOPage;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public int findVersionTypeByBookId(String bookId) {
+        List<KmtExerciseBookCourse> bookCourses = this.findByBookId(bookId);
+        int bookVersion = 2;
+        if (bookCourses != null && bookCourses.size() > 0){
+            bookVersion = bookCourses.get(0).getVersion();
+        }
+        return bookVersion;
+    }
+
+    @Override
+    public List<KmtExerciseBookCourse> getAllBookCourse(String subject, String grade, int semester, int versionType) {
+        return queryDao.getAllBookCourse(subject, grade, semester, versionType);
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public KmtExerciseBookCourse findBookDataByBookId(String bookId) {
+        List<KmtExerciseBookCourse> bookCourses = this.findByBookId(bookId);
+        KmtExerciseBookCourse bookCourse = null;
+        if (bookCourses != null && bookCourses.size() > 0){
+            bookCourse = bookCourses.get(0);
+        }
+        return bookCourse;
+    }
+
+    @Override
+    public List<KmtExerciseBookCourse> findBookDataByBookIds(List<String> bookIds) {
+        return queryDao.findBookDataByBookIds(bookIds);
+    }
+
+    @Override
+    public String findCourseNameByQuestionId(String questionId) {
+        return dao.findCourseNameByQuestionId(questionId);
+    }
+
+    @Override
+    public List<KmtExerciseBookCourse> findByBookId(List<String> bookIds) {
+        return dao.findByBookIdIn(bookIds);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseBookLibServiceImpl.java

@@ -0,0 +1,41 @@
+package com.ssj.service.kmt.kmt.service.impl;
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseBookLib;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseBookLibDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.service.KmtExerciseBookLibService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @author yanghuan
+ * @title: KmtExerciseBookLibServiceImpl
+ * @projectName ssj
+ * @description: TODO
+ * @date 2020/4/14 17:14
+ */
+@Transactional
+@Service(version = "1.0")
+public class KmtExerciseBookLibServiceImpl extends BaseServiceImpl<KmtExerciseBookLib, String> implements KmtExerciseBookLibService {
+
+    @Autowired
+    private KmtExerciseBookLibDao dao;
+
+    @Override
+    public PagingAndSortingRepository<KmtExerciseBookLib, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public List<KmtExerciseBookLib> findByLibId(String libId) {
+        return dao.findByLibIdAndIsDelete(libId, 0);
+    }
+
+    @Override
+    public List<KmtExerciseBookLib> findByExerciseBookId(String exerciseBookId) {
+        return dao.findByExerciseBookIdAndIsDelete(exerciseBookId, 0);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseBookServiceImpl.java

@@ -0,0 +1,258 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseBook;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseBookLib;
+import com.ssj.bean.weixin.libmy.domain.TbLibJoin;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseBookDao;
+import com.ssj.dao.weixin.library.dao.ILibJoinDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.framework.core.security.exception.CommonException;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.service.kmt.constant.KnowledgeVersion;
+import com.ssj.service.kmt.service.KmtExerciseBookLibService;
+import com.ssj.service.kmt.service.KmtExerciseBookService;
+import com.ssj.service.mapper.KmtExerciseMapper;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.mongodb.core.MongoTemplate;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.Date;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+@Transactional
+@Service(version = "1.0")
+public class KmtExerciseBookServiceImpl extends BaseServiceImpl<KmtExerciseBook, String> implements KmtExerciseBookService {
+
+    @Autowired
+    private KmtExerciseBookDao dao;
+
+    @Autowired
+    private KnowledgeVersion knowledgeVersion;
+
+    @Autowired
+    private ILibJoinDao libJoinDao;
+
+    @Autowired
+    private KmtExerciseBookLibService KmtExerciseBookLibService;
+
+    @Autowired
+    private KmtExerciseMapper kmtExerciseMapper;
+
+    @Autowired
+    private MongoTemplate mongoTemplate;
+
+    @Autowired
+    private KmtExerciseBookLibService kmtExerciseBookLibService;
+
+    @Override
+    public PagingAndSortingRepository<KmtExerciseBook, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public KmtExerciseBook findSameBook(String bookName, String grade, String courseName, int semester, int version, int userYear, int bookType) {
+        return dao.findTopByBookNameAndGradeAndCourseNameAndSemesterAndVersionAndBookYearAndBookType(bookName, grade, courseName, semester, version, userYear, bookType);
+    }
+
+    @Override
+    public void updateAnswerCorrecterIdById(String teacherId, String exerciseBookId) {
+        dao.updateAnswerCorrecterIdById(teacherId, exerciseBookId);
+    }
+
+    @Override
+    public void updateAnswerCorrecterIdByIds(String teacherId, List<String> exerciseBookIds) {
+        //dao.updateAnswerCorrecterIdByIds(teacherId, exerciseBookIds);
+        kmtExerciseMapper.updateAnswerCorrecterIdByIds(teacherId,exerciseBookIds);
+    }
+
+    @Override
+    public void updateHandleUserIdByIds(String teacherId, List<String> exerciseBookIds) {
+        dao.updateHandleUserIdByIds(teacherId, exerciseBookIds);
+    }
+
+    @Override
+    public void updateAuditingUserId(String teacherId, List<String> exerciseBookIds) {
+        dao.updateAuditingUserId(teacherId, exerciseBookIds);
+    }
+
+    @Override
+    public void updateAnalysisUserId(String teacherId, List<String> exerciseBookIds) {
+        dao.updateAnalysisUserId(teacherId, exerciseBookIds);
+    }
+
+    @Override
+    public void updateAnalysisAuditerId(String teacherId, List<String> exerciseBookIds) {
+        dao.updateAnalysisAuditerId(teacherId, exerciseBookIds);
+    }
+
+    @Override
+    public void updateVersion(int type, String subject, Integer version) {
+        List<KmtExerciseBook> list;
+        if (type == 1) {
+            if (StringUtil.isNotBlank(subject)) {
+                if (version != null) {
+                    list = dao.findByCourseNameAndVersion(subject, version);
+                } else {
+                    list = dao.findByCourseName(subject);
+                }
+            } else {
+                list = dao.findAll();
+            }
+        } else {
+            list = dao.findByVersionNameIsNull();
+        }
+        list.forEach(e -> {
+            e.setVersionName(knowledgeVersion.getVersionNameBySubjectAndVersionNum(e.getCourseName(), e.getVersion()));
+        });
+        this.save(list);
+    }
+
+    @Override
+    public void updateExerciseLib() {
+        List<KmtExerciseBook> list = dao.findByLibNameIsNotNull();
+        //保存更新的
+        list.forEach(e -> {
+            //保存更新前的数据
+            e.setMongodbComment("更新馆绑定备份数据");
+            mongoTemplate.save(e);
+            //将已经绑定的图书馆解绑
+            e.setOrgNums(0);
+            List<KmtExerciseBookLib> exerciseBookLibList = KmtExerciseBookLibService.findByExerciseBookId(e.getId());
+            exerciseBookLibList.forEach(exerciseBookLib -> exerciseBookLib.setIsDelete(1));
+            KmtExerciseBookLibService.save(exerciseBookLibList);
+            //重新绑定
+            if (!"0".equals(e.getLibName())) {
+                String[] libNames = e.getLibName().split(",");
+                int nums = libNames.length;
+                for (String libName : libNames) {
+                    List<TbLibJoin> libList = libJoinDao.findByLeagueName(libName);
+                    if (libList.size() == 1) {
+                        KmtExerciseBookLib kmtExerciseBookLib = new KmtExerciseBookLib();
+                        kmtExerciseBookLib.setLibId(libList.get(0).getId());
+                        kmtExerciseBookLib.setExerciseBookId(e.getId());
+                        kmtExerciseBookLib.setIsDelete(0);
+                        KmtExerciseBookLibService.save(kmtExerciseBookLib);
+                    } else if (libList.size() == 0) {
+                        throw new CommonException(libName + "机构不存在");
+                        //System.out.println("不存在的机构:"+libName);
+                        //nums--;
+                    } else if (libList.size() > 0) {
+                        throw new CommonException(libName + "机构找到多个");
+                        //System.out.println("机构找到多个:"+libName);
+                        //nums--;
+                    }
+                }
+                e.setOrgNums(nums);
+            }
+            if (e.getVersion() == 0) {
+                e.setVersion(knowledgeVersion.getVersionNumBySubjectAndVersionName(e.getCourseName(), e.getVersionName()));
+            }
+            e.setLibName(null);
+            this.save(e);
+        });
+    }
+
+    @Override
+    public void mergeSameExerciseBooks() {
+        //所有重复的数据
+        List<KmtExerciseBook> list = kmtExerciseMapper.findSameExerciseBookList();
+        Map<String, KmtExerciseBook> data = new HashMap<>(16);
+        //重复数据存入缓存，以便后面查询
+        list.forEach(e -> {
+            mongoTemplate.save(e);
+            String key = e.getBookName() + e.getCourseName() + e.getGrade() + e.getVersionName() + e.getSemester() + e.getBookType() + e.getBookYear();
+            if (data.get(key) != null) {
+                //后台导入
+                //url1	url2	出版社	印刷年份	使用年份（同前面book_year）关联机构数 被识别次数	编辑人id	编辑人	更新时间 优先级	多年级综合识别率
+                if (e.getPartFlag() == 3) {
+                    KmtExerciseBook book = data.get(key);
+                    book.setUrl1(e.getUrl1());
+                    book.setUrl2(e.getUrl2());
+                    book.setPress(e.getPress());
+                    book.setPrintYear(e.getPrintYear());
+                    book.setBookYear(e.getBookYear());
+                    book.setOrgNums(e.getOrgNums());
+                    book.setIdentifiedNums(e.getIdentifiedNums());
+                    book.setUserId(e.getUserId());
+                    book.setUserName(e.getUserName());
+                    book.setUpdatedTime(e.getUpdatedTime());
+                    book.setTotalGradePriority(e.getTotalGradePriority());
+                    book.setExerciseRelevancyNum(e.getExerciseRelevancyNum());
+                    List<KmtExerciseBookLib> libList = kmtExerciseBookLibService.findByExerciseBookId(e.getId());
+                    libList.forEach(lib->{
+                        KmtExerciseBookLib newLib = new KmtExerciseBookLib();
+                        newLib.setExerciseBookId(book.getId());
+                        newLib.setIsDelete(lib.getIsDelete());
+                        newLib.setLibId(lib.getLibId());
+                        kmtExerciseBookLibService.save(newLib);
+                    });
+                }
+                this.delete(e);
+                System.out.println(e.getId());
+            } else {
+                //因为经过了排序，如果有页面录入的，首个则为页面录入数据
+                data.put(key, e);
+            }
+        });
+        for (KmtExerciseBook kmtExerciseBook : data.values()) {
+            this.save(kmtExerciseBook);
+        }
+    }
+
+    @Override
+    public void updateKmtExerciseBookByKmtExerciseModify(){
+        List<Map<String, String>> list = kmtExerciseMapper.findUpdateExerciseBookList();
+        Date now = new Date();
+        Thread thread1 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                for(int i=0;i<500;i++){
+                    Map<String, String> e=list.get(i);
+                    KmtExerciseBook book = getById(list.get(i).get("id"));
+                    book.setMongodbComment("更新时间："+now+";更新练习册的出版社、印刷年份、关联机构数据（此数据为更新前的备份数据）");
+                    //mongoTemplate.save(book);
+                    book.setPress(e.get("press"));
+                    book.setPrintYear(e.get("print_year"));
+                    book.setLibName(e.get("lib_name"));
+                    save(book);
+                }
+            }
+        });
+        Thread thread2 = new Thread(new Runnable() {
+            @Override
+            public void run() {
+                for(int i=500;i<list.size();i++){
+                    Map<String, String> e=list.get(i);
+                    KmtExerciseBook book = getById(list.get(i).get("id"));
+                    book.setMongodbComment("更新时间："+now+";更新练习册的出版社、印刷年份、关联机构数据（此数据为更新前的备份数据）");
+                    //mongoTemplate.save(book);
+                    book.setPress(e.get("press"));
+                    book.setPrintYear(e.get("print_year"));
+                    book.setLibName(e.get("lib_name"));
+                    save(book);
+                }
+            }
+        });
+        thread1.start();
+        thread2.start();
+        /*list.forEach(e->{
+            KmtExerciseBook book = this.getById(e.get("id"));
+            book.setMongodbComment("更新时间："+now+";更新练习册的出版社、印刷年份、关联机构数据（此数据为更新前的备份数据）");
+            mongoTemplate.save(book);
+            book.setPress(e.get("press"));
+            book.setPrintYear(e.get("print_year"));
+            book.setLibName(e.get("lib_name"));
+            this.save(book);
+        });*/
+        //this.updateExerciseLib();
+    }
+
+    @Override
+    public void updateExerciseBookStatus(String exerciseBookId, String status) {
+        dao.updateExerciseBookStatus(exerciseBookId, status);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseLibPriorityServiceImpl.java

@@ -0,0 +1,46 @@
+package com.ssj.service.kmt.kmt.service.impl;
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseLibPriority;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseLibPriorityDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.service.KmtExerciseLibPriorityService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @author yanghuan
+ * @title: KmtExerciseLibPriorityServiceImpl
+ * @projectName ssj
+ * @description: TODO
+ * @date 2020/6/4 11:10
+ */
+@Transactional
+@Service(version = "1.0")
+public class KmtExerciseLibPriorityServiceImpl extends BaseServiceImpl<KmtExerciseLibPriority,String> implements KmtExerciseLibPriorityService {
+
+
+    @Autowired
+    private KmtExerciseLibPriorityDao dao;
+
+
+    @Override
+    public PagingAndSortingRepository<KmtExerciseLibPriority, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public void deleteOrgCountBySubject(String subject){
+        dao.deleteOrgCountBySubject(subject);
+    }
+
+    @Override
+    public KmtExerciseLibPriority findByLibIdAndSubject(String libId,String subject){
+      return   dao.findKmtExerciseLibPriorityByLibIdAndSubejct(libId,subject);
+    }
+
+    @Override
+    public void deleteOrgCountByLibIdAndSubject(String libId,String subject){
+           dao.deleteOrgCountByLibIdAndSubject(libId,subject);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseQuestionErrorsServiceImpl.java

@@ -0,0 +1,31 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestionErrors;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseQuestionErrorsDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.service.KmtExerciseQuestionErrorsService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @Author: chchen
+ * @Description
+ * @Date Create in 14:43 2020/5/11
+ * @Modified By
+ */
+
+@Transactional
+@Service(version ="1.0")
+public class KmtExerciseQuestionErrorsServiceImpl extends BaseServiceImpl<KmtExerciseQuestionErrors, String> implements KmtExerciseQuestionErrorsService {
+    @Autowired
+    private KmtExerciseQuestionErrorsDao questionErrorsDao;
+
+    @Override
+    public PagingAndSortingRepository<KmtExerciseQuestionErrors, String> getDao() {
+        return questionErrorsDao;
+    }
+
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseQuestionRollbackImpl.java

@@ -0,0 +1,30 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestionRollback;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseQuestionRollbackDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.service.KmtExerciseQuestionRollbackService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtExerciseQuestionRollbackImpl extends BaseServiceImpl<KmtExerciseQuestionRollback, String> implements KmtExerciseQuestionRollbackService {
+    @Autowired
+    private KmtExerciseQuestionRollbackDao questionRollbackDao;
+
+    @Override
+    public PagingAndSortingRepository<KmtExerciseQuestionRollback, String> getDao() {
+        return questionRollbackDao;
+    }
+
+    public List<KmtExerciseQuestionRollback> findAllTouserId(){
+        return questionRollbackDao.findAllTouserId();
+    }
+
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseQuestionServiceKnowImpl.java

@@ -0,0 +1,58 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestionKnow;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseQueryDao;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseQuestionKnowDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.service.KmtExerciseQuestionKnowService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+import java.util.Map;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtExerciseQuestionServiceKnowImpl extends BaseServiceImpl<KmtExerciseQuestionKnow, String> implements KmtExerciseQuestionKnowService {
+
+    @Autowired
+    private KmtExerciseQuestionKnowDao kmtExerciseQuestionKnowDao;
+
+    @Autowired
+    private KmtExerciseQueryDao queryDao;
+
+    @Override
+    public PagingAndSortingRepository<KmtExerciseQuestionKnow, String> getDao() {
+        return kmtExerciseQuestionKnowDao;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public List<Map<String, Object>> findQuestionKnowByQuestionIds(List<String> questionIds, int versionType) {
+        return queryDao.findHowDetailNameByQuestionIds(questionIds, versionType);
+    }
+
+    @Override
+    public List<KmtExerciseQuestionKnow> findByQuestionId(String questionId) {
+        return kmtExerciseQuestionKnowDao.findByQuestionId(questionId);
+    }
+
+    @Override
+    public List<KmtExerciseQuestionKnow> findByQuestionIdIn(List<String> questionIdList) {
+        return kmtExerciseQuestionKnowDao.findByQuestionIdIn(questionIdList);
+    }
+
+    @Override
+    public void deleteByQuestionId (List<String> questionIds) {
+        kmtExerciseQuestionKnowDao.deleteByQuestionId(questionIds);
+
+    }
+
+    @Override
+    public void flush() {
+        kmtExerciseQuestionKnowDao.flush();
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseSubmitServiceImpl.java

@@ -0,0 +1,629 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseBook;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestion;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestionKnow;
+import com.ssj.bean.weixin.libmy.domain.TbLibManager;
+import com.ssj.bean.weixin.push.domain.SendTemplateShort;
+import com.ssj.bean.weixin.user.domain.User;
+import com.ssj.bean.weixin.zyb.domain.ZuoybKnowHowDetailsSort;
+import com.ssj.dao.weixin.library.dao.IBookManagerDao;
+import com.ssj.dao.weixin.user.dao.UserDao;
+import com.ssj.dao.weixin.zuoyb.dao.ZuoybKnowHowDetailsSortDao;
+import com.ssj.es.service.ExerciseQuestionSearchService;
+import com.ssj.es.service.base.BaseSearchService;
+import com.ssj.framework.core.security.manager.TokenManager;
+import com.ssj.framework.core.util.ResponseConstant;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.framework.idworker.IdWorker;
+import com.ssj.framework.weixin.util.DateUtil;
+import com.ssj.service.kmt.dto.KnowHowDetailsDTO;
+import com.ssj.service.kmt.dto.KnowledgeBaseDto;
+import com.ssj.service.kmt.exercisesys.enums.ProofreadStatusEnum;
+import com.ssj.service.kmt.request.AuditingV1Request;
+import com.ssj.service.kmt.request.QuestionUpdateRequest;
+import com.ssj.service.kmt.service.KmtExerciseQuestionService;
+import com.ssj.service.kmt.service.KmtExerciseService;
+import com.ssj.service.kmt.service.KmtExerciseSubmitService;
+import com.ssj.service.mapper.KmtExerciseMapper;
+import com.ssj.service.task.SyncRefreshExerciseBookStatusTask;
+import com.ssj.service.weixin.push.service.PushTemplateService;
+import com.ssj.taskthread.ThreadPool;
+import org.apache.commons.collections.CollectionUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.elasticsearch.index.query.QueryBuilder;
+import org.elasticsearch.index.query.QueryBuilders;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Service(version ="1.0")
+public class KmtExerciseSubmitServiceImpl implements KmtExerciseSubmitService {
+
+    private final Logger logger = LoggerFactory.getLogger(this.getClass());
+
+    @Autowired
+    private IBookManagerDao bookManagerDao;
+    @Autowired
+    private KmtExerciseMapper kmtExerciseMapper;
+    @Autowired
+    private UserDao userDao;
+    @Autowired
+    private ZuoybKnowHowDetailsSortDao zuoybKnowHowDetailsSortDao;
+    @Autowired
+    private KmtExerciseService kmtExerciseService;
+    @Autowired
+    private TokenManager tokenManager;
+    @Autowired
+    private PushTemplateService pushTemplateService;
+    @Autowired
+    private KmtExerciseQuestionService kmtExerciseQuestionService;
+    @Autowired
+    private BaseSearchService baseSearchService;
+    @Autowired
+    private ExerciseQuestionSearchService exerciseQuestionSearchService;
+
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public ResponseEntity submit2Auditing(AuditingV1Request request, String userId) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        if (CollectionUtils.isNotEmpty(request.getQuestions())) {
+            List<String> questionIds = request.getQuestions().stream().map(QuestionUpdateRequest::getQuestionId).collect(Collectors.toList());
+            List<KmtExerciseQuestion> questions = kmtExerciseMapper.findKmtExerciseQuestionsByIdIn(questionIds);
+            kmtExerciseService.appendQuestionDataFromJSONFile(questions); //读文件，把题目信息加载到实体中
+            KmtExerciseBook book = kmtExerciseMapper.findExerciseBookById(questions.get(0).getExerciseBookId());
+            this.appendUser2QuestionBean(questions, book);  //把加工审核人，校对人加载到实体中
+            boolean  isAnswerCorrectSubmit = isAnswerCorrectSubmit(request.getType());  //是否是校对修改提交
+            boolean isManagerSubmit = isManagerSubmit(userId, request.getType());  //是否是管理员提交
+            request.setType(isManagerSubmit ? 3 : request.getType());  //管理员提交修改为3, 管理员修改不改变题目的状态
+
+            if (isExistQuestonsPulish(questions, request.getType())){
+                return responseEntity.failure(ResponseConstant.CODE_000, "题目已发布，不能提交审核");
+            } else if (!isQuestionHandlerSubmitKnowledge(request)) {
+                return responseEntity.failure(ResponseConstant.CODE_000, "请添加知识点");
+            } else {
+                //走事务保存练习册，题目，知识点
+                this.updateBookAndQuestionsAndKnow(questions, book, request,isAnswerCorrectSubmit);
+                // 异步刷新练习册加工状态和题目状态统计
+                ThreadPool.getInstance().addTask(new SyncRefreshExerciseBookStatusTask(Collections.singletonList(questions.get(0).getExerciseBookId()), 2));
+                //数据同步es
+                this.updateEsQuestionAndKnow(questions, questionIds);
+            }
+            responseEntity.success("提交成功");
+        }
+        return responseEntity;
+    }
+
+
+    @Override
+    @Transactional(propagation = Propagation.REQUIRED)
+    public void updateBookAndQuestionsAndKnow (List<KmtExerciseQuestion> questions, KmtExerciseBook book, AuditingV1Request request,Boolean isAnswerCorrectSubmit){
+        List<String> questionIds = request.getQuestions().stream().map(QuestionUpdateRequest::getQuestionId).collect(Collectors.toList());
+
+        //更新练习册
+        int questionCount = getQuestionStatusCount(questions, request.getType());
+        this.updateKmtExerciseBookFinishStatus(questionCount, book, request.getType());
+        kmtExerciseMapper.updateKmtExerciseBookHandleStatus(book);
+
+        //更新题目
+        this.getKmtExerciseQuestionData(questions, request.getQuestions(), request.getType(), isAnswerCorrectSubmit);
+        for (KmtExerciseQuestion kmtExerciseQuestion : questions) {
+            kmtExerciseMapper.updateKmtExerciseQuestions(kmtExerciseQuestion);
+        }
+        //保存大字段文件
+        kmtExerciseService.saveQuestionData2JSONFile(questions);
+
+        //更新知识点, 解析提交和解析发布不更新知识点
+        if (request.getType() != 4 && request.getType() != 5) {
+            kmtExerciseMapper.deleteKmtExerciseQuestionKnowByQuestionIds(questionIds);
+            List<KmtExerciseQuestionKnow> questionKnows = new ArrayList<>();
+            for (QuestionUpdateRequest updateRequest : request.getQuestions()) {
+                if (CollectionUtils.isNotEmpty(updateRequest.getKnowledges())) {
+                    for (KmtExerciseQuestion question : questions) {
+                        if (question.getId().equals(updateRequest.getQuestionId())){
+                            questionKnows.addAll(this.getKmtQuestionKnow(updateRequest.getKnowledges(), question));
+                            break;
+                        }
+                    }
+                }
+            }
+            if (CollectionUtils.isNotEmpty(questionKnows)) {
+                for (KmtExerciseQuestionKnow know : questionKnows){
+                    kmtExerciseMapper.insertKmtExerciseQuestionKnow(know);
+                }
+            }
+        }
+
+    }
+
+    /**
+     * 获取更新的题目的当前状态下的题数
+     * @param questions
+     * @param type
+     * @return
+     */
+    private int getQuestionStatusCount (List<KmtExerciseQuestion> questions, int type){
+        int result = 0;
+        if (type == 0){
+            for (KmtExerciseQuestion q :questions){
+                if (q.getDealStatus() == 0 || q.getDealStatus() == 1) {
+                    result += 1;
+                }
+            }
+        } else if (type == 1){
+            for (KmtExerciseQuestion q :questions){
+                if (q.getDealStatus() == 3 || q.getDealStatus() == 7) {
+                    result += 1;
+                }
+            }
+        } else if (type == 4){
+            for (KmtExerciseQuestion q :questions){
+                if (q.getDealStatus() == 5 || q.getDealStatus() == 8) {
+                    result += 1;
+                }
+            }
+        } else if (type == 5){
+            for (KmtExerciseQuestion q :questions){
+                if (q.getDealStatus() == 9 || q.getDealStatus() == 10) {
+                    result += 1;
+                }
+            }
+        }
+        return result;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public void updateEsQuestionAndKnow (List<KmtExerciseQuestion> questions, List<String> questionIds){
+        for (KmtExerciseQuestion kmtExerciseQuestion : questions){
+            kmtExerciseQuestionService.saveToEs(kmtExerciseQuestion);
+        }
+
+        QueryBuilder queryBuilder = QueryBuilders.termsQuery("question_id.keyword", questionIds);
+        exerciseQuestionSearchService.deleteByQuery("kmt_exercise_question_know", queryBuilder);
+        List<Map<String, Object>> knowEsData = kmtExerciseMapper.findData2EsByQuestionList(questionIds);
+        if (CollectionUtils.isNotEmpty(knowEsData)) {
+            kmtExerciseService.appendQuestionMapFromJSONFile(knowEsData);
+            baseSearchService.insertBatch("kmt_exercise_question_know", knowEsData, true);
+        }
+    }
+
+
+    /**
+     * 是否是管理员提交
+     * @param userId
+     * @param type
+     * @return
+     */
+    private boolean isManagerSubmit (String userId, int type){
+        TbLibManager manager = bookManagerDao.findByUserIdAndType(userId, 18);
+        if (manager != null) {
+            //管理员把状态设置为3，不改任何状态
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 是否是答案校对提交
+     * @param type
+     * @return
+     */
+    private boolean isAnswerCorrectSubmit (int type) {
+        // 答案校对修改提交
+        if (Objects.equals(type, 6)) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * 是否存在已发布的题目
+     * @param questions
+     * @param type
+     * @return
+     */
+    private boolean isExistQuestonsPulish (List<KmtExerciseQuestion> questions, int type){
+        boolean exist = false;
+        if (type == 4 && questions.stream().anyMatch(q -> q.getDealStatus() == 11)) {
+            //解析加工提交， 但是题目存在解析已发布
+            exist = true;
+        } else if (type == 0 && questions.stream().anyMatch(q -> q.getDealStatus() == 4 || q.getDealStatus() == 5 || q.getDealStatus() > 7)) {
+            //题目加工提交，但是题目存在加工已发布
+            exist = true;
+        }
+        return exist;
+    }
+
+    /**
+     * 练习册加工审核是否提交了知识点
+     * @param request
+     * @return
+     */
+    private boolean isQuestionHandlerSubmitKnowledge (AuditingV1Request request){
+        boolean  result = true;
+        if (request.getType() == 0 || request.getType() == 1 || request.getType() == 3){
+            for (QuestionUpdateRequest questionUpdateRequest : request.getQuestions()){
+                if (CollectionUtils.isEmpty(questionUpdateRequest.getKnowledges())){
+                    result = false;
+                    break;
+                }
+            }
+        }
+        return result;
+    }
+
+    /**
+     * 把练习册的加工审核人，校对人加入到题目实体中
+     * @param questions
+     * @param book
+     */
+    private void appendUser2QuestionBean (List<KmtExerciseQuestion> questions, KmtExerciseBook book){
+        if (CollectionUtils.isNotEmpty(questions)){
+            for (KmtExerciseQuestion kmtExerciseQuestion : questions) {
+                kmtExerciseQuestion.setHandleUserId(book.getHandleUserId());
+                kmtExerciseQuestion.setAuditingUserId(book.getAuditingUserId());
+                kmtExerciseQuestion.setAnalysisUserId(book.getAnalysisUserId());
+                kmtExerciseQuestion.setAnalysisAuditerId(book.getAnalysisAuditerId());
+                kmtExerciseQuestion.setAnswerCorrecterId(book.getAnswerCorrecterId());
+            }
+        }
+    }
+
+
+    /**
+     * 提交审核更新为未加工，未审核
+     * @param questionCount
+     * @param exerciseBook
+     * @param dealType
+     */
+    private void updateKmtExerciseBookFinishStatus (int questionCount, KmtExerciseBook exerciseBook, int dealType){
+        int count = 0;
+        if (dealType == 0){
+            //题目加工
+            if (exerciseBook.getHadHandle() == 0){
+                count = kmtExerciseMapper.countUnFinishQuestionsByExerciseBookId(exerciseBook.getId(), 1);
+                if (count <= questionCount){
+                    exerciseBook.setHadHandle(1);
+                }
+            }
+            if (exerciseBook.getHadHandle() == 1 && StringUtil.isNotBlank(exerciseBook.getAuditingUserId())) {
+                //加工完了通知加工审核老师
+                this.push2ExerciseTeacher(exerciseBook.getAuditingUserId(),  exerciseBook, 2);
+            }
+            exerciseBook.setHadAuditing(0);
+        } else if (dealType == 1) {
+            //题目发布
+            if (exerciseBook.getHadAuditing() == 0){
+                count = kmtExerciseMapper.countUnFinishQuestionsByExerciseBookId(exerciseBook.getId(), 2);
+                if (count <= questionCount){
+                    exerciseBook.setHadAuditing(1);
+                }
+            }
+            if (exerciseBook.getHadHandle() == 1 && exerciseBook.getHadAuditing() == 1){
+                //加工完了通知加工审核老师
+                exerciseBook.setProgress("已发布");
+                if (StringUtil.isNotBlank(exerciseBook.getAnalysisUserId())){
+                    this.push2ExerciseTeacher(exerciseBook.getAnalysisUserId(),exerciseBook, 3);
+                }
+            }
+            exerciseBook.setAnalysisHandled(0);
+        } else if (dealType == 4){
+            //题目解析加工
+            if (exerciseBook.getAnalysisHandled() == 0){
+                count = kmtExerciseMapper.countUnFinishQuestionsByExerciseBookId(exerciseBook.getId(), 3);
+                if (count <= questionCount){
+                    exerciseBook.setAnalysisHandled(1);
+                }
+            }
+
+            if (exerciseBook.getHadHandle() == 1 && exerciseBook.getHadAuditing() == 1
+                    && exerciseBook.getAnalysisHandled() == 1 && StringUtil.isNotBlank(exerciseBook.getAnalysisAuditerId())){
+                //加工完了通知加工审核老师
+                this.push2ExerciseTeacher(exerciseBook.getAnalysisAuditerId(), exerciseBook, 4);
+            }
+            exerciseBook.setAnalysisAudited(0);
+        } else if (dealType == 5 && exerciseBook.getAnalysisAudited() == 0){
+            //题目解析发布
+            count = kmtExerciseMapper.countUnFinishQuestionsByExerciseBookId(exerciseBook.getId(), 4);
+            if (count <= questionCount){
+                exerciseBook.setAnalysisAudited(1);
+            }
+        }
+    }
+
+    /**
+     * 练习册加工完推送下一个阶段的老师
+     * @param userId
+     * @param exerciseBook
+     * @param type
+     */
+    private void push2ExerciseTeacher (String userId, KmtExerciseBook exerciseBook,int type){
+        String key = "push_bookId"+exerciseBook.getId()+userId;
+        if(tokenManager.exists(key)){
+            return ;
+        }
+
+        Map<String, String> data = new HashMap<>();
+        String template_id_short = "OPENTM206165551";
+        User user = userDao.findOne(userId);
+        if  (user != null && StringUtils.isNotEmpty(user.getAccount()) ){
+            try{
+                TbLibManager libTeacher = bookManagerDao.findByUserIdAndType(userId, 17);
+                if (libTeacher != null){
+                    String teacherName = null;
+                    teacherName = libTeacher.getName();
+                    if (StringUtils.isEmpty(teacherName)){
+                        teacherName = user.getName();
+                    }
+                    String authName =  null;
+                    switch (type){
+                        case 1: authName="题目加工"; break;
+                        case 2: authName="审核发布"; break;
+                        case 3: authName="解析加工"; break;
+                        case 4: authName="解析发布"; break;
+                        default: authName="加工"; break;
+                    }
+
+
+                    String bookType =  null;
+                    switch (exerciseBook.getBookType()){
+                        case 0: bookType="整本"; break;
+                        case 1: bookType="上半本"; break;
+                        case 2: bookType="下半本"; break;
+                        case 3: bookType="不同的页码的新版练习册"; break;
+                        default: bookType=""; break;
+                    }
+
+                    // 你好，你有一本 数学人教版上册四年级 整本、半本,《我爱写作业(2020)》，
+
+                    StringBuffer sb =new StringBuffer("你好，你有一本");
+                    sb.append(exerciseBook.getCourseName()).append(exerciseBook.getVersionName()).append(exerciseBook.getSemester()==1?"上册":"下册");
+                    sb.append(exerciseBook.getGrade()).append(bookType).append("《").append(exerciseBook.getBookName()).append("》,");
+                    sb.append(authName+"请在规定时间内完成");
+                    data.put("first", sb.toString());
+                    data.put("keyword1", teacherName);
+                    data.put("keyword2", DateUtil.format_yyyyMMddHHmmss(new Date()));
+                    data.put("remark", "请及时登录处理，如有疑问请及时联系相关负责老师。");
+                    SendTemplateShort sendTemplateShort = new SendTemplateShort(user.getAccount(), template_id_short, null, data);
+                    pushTemplateService.saveAndSendPushWxTemplate(sendTemplateShort);
+                    tokenManager.setString(key,authName,12*60*60);
+                } else {
+                    logger.error("没有老师角色" + userId);
+                }
+            } catch (Exception e){
+                logger.error("推送练习册老师失败：", e);
+            }
+        }
+    }
+
+    /**
+     * 更新题目信息
+     * @param questions
+     * @param questionUpdateRequests
+     * @param type
+     */
+    private void getKmtExerciseQuestionData (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests,
+                                                int type, boolean isAnswerCorrectSubmit) {
+        //解析加工或解析审核
+        if (isAnswerCorrectSubmit) {
+            this.updateProofreadStatusSubmit(questions, questionUpdateRequests);
+            String exerciseBookId = questions.get(0).getExerciseBookId();
+              // 如果已经没有需要修改答案的题目，则修改练习册的校对状态为已修改
+            List<String> questionIds = questionUpdateRequests.stream().map(QuestionUpdateRequest::getQuestionId).collect(Collectors.toList());
+
+            int count = kmtExerciseMapper.countAnswerWrongQuestion(exerciseBookId, new HashSet<>(questionIds));
+                if (count < 1) {
+                    kmtExerciseMapper.updateKmtExerciseBookProofreadStatus(exerciseBookId, ProofreadStatusEnum.ManagerModified.getCode());
+                }
+
+        } else if (type == 0) {
+            this.updateHandlerQuestions(questions, questionUpdateRequests);
+        } else if (type == 1) {
+            this.updateAuditingUserQuestion(questions, questionUpdateRequests);
+        } else if (type == 3){
+            this.updateManagerQuestions(questions, questionUpdateRequests);
+        } else if (type == 4) {
+            this.updateAnalysisHandleQuestions(questions, questionUpdateRequests);
+        } else if (type == 5) {
+            this.updateAnalysisAuditingQuestions(questions, questionUpdateRequests);
+        }
+    }
+
+    /**
+     * 解析加工的提交功能，如果是加工人（题目deal_status=5,8）, 记录解析加工时间， 修改题目状态
+     * @param questions
+     * @param questionUpdateRequests
+     */
+    private void updateAnalysisHandleQuestions (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
+        for (KmtExerciseQuestion question : questions) {
+            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
+                if (question.getId().equals(updateRequest.getQuestionId())) {
+                    question.setAnalysisJson(updateRequest.getAnalysisJson());
+                    question.setAnalysis(updateRequest.getQuestionAnalysis());
+                    if (question.getDealStatus() == 5 || question.getDealStatus() == 8) {
+                        question.setAnalysisHandlerSubmitTime(new Date());
+                        question.setDealStatus(9);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 解析加工的发布功能, 记录解析加工时间， 修改题目状态
+     * @param questions
+     * @param questionUpdateRequests
+     */
+    private void updateAnalysisAuditingQuestions (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
+        for (KmtExerciseQuestion question : questions) {
+            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
+                if (question.getId().equals(updateRequest.getQuestionId())) {
+                    question.setAnalysisJson(updateRequest.getAnalysisJson());
+                    question.setAnalysis(updateRequest.getQuestionAnalysis());
+                    question.setDealStatus(11);
+                    question.setAnalysisSubmitTime(new Date());
+                }
+            }
+        }
+    }
+
+    /**
+     * 题目加工提交功能
+     * @param questions
+     * @param questionUpdateRequests
+     */
+    private void updateHandlerQuestions (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
+        //循坏题目
+        for (KmtExerciseQuestion question : questions) {
+            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
+                if (question.getId().equals(updateRequest.getQuestionId())) {
+                    this.updateKmtQuestionCommonData(question, updateRequest);
+                    if (question.getDealStatus() == 0 || question.getDealStatus() == 1) {
+                        question.setHandlerSubmitTime(new Date());
+                        question.setDealStatus(3);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * 题目审核提交发布功能
+     * @param questions
+     * @param questionUpdateRequests
+     */
+    private void updateAuditingUserQuestion (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
+        //循坏题目
+        for (KmtExerciseQuestion question : questions) {
+            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
+                if (question.getId().equals(updateRequest.getQuestionId())) {
+                    this.updateKmtQuestionCommonData(question, updateRequest);
+                    question.setPublishTime(new Date());
+                    question.setDealStatus(5);
+                }
+            }
+        }
+    }
+
+    /**
+     * 管理员提交， 不修改题目状态
+     * @param questions
+     * @param questionUpdateRequests
+     */
+    private void updateManagerQuestions (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
+        //循坏题目
+        for (KmtExerciseQuestion question : questions) {
+            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
+                if (question.getId().equals(updateRequest.getQuestionId())) {
+                    this.updateKmtQuestionCommonData(question, updateRequest);
+                }
+            }
+        }
+    }
+
+    /**
+     * 校对更新提交
+     * @param questions
+     * @param questionUpdateRequests
+     */
+    private void updateProofreadStatusSubmit (List<KmtExerciseQuestion> questions, List<QuestionUpdateRequest> questionUpdateRequests) {
+        //循坏题目
+        for (KmtExerciseQuestion question : questions) {
+            for (QuestionUpdateRequest updateRequest : questionUpdateRequests) {
+                if (question.getId().equals(updateRequest.getQuestionId())) {
+                    this.updateKmtQuestionCommonData(question, updateRequest);
+                    question.setProofreadStatus(ProofreadStatusEnum.ManagerModified.getCode());
+                }
+            }
+        }
+    }
+
+    /**
+     * 更新单个题目的信息
+     * @param question
+     * @param updateRequest
+     */
+    private void updateKmtQuestionCommonData (KmtExerciseQuestion question, QuestionUpdateRequest updateRequest) {
+        question.setQuestionText(updateRequest.getQuestionText());
+        question.setOptionAnswer(updateRequest.getAnswer());
+        question.setAnswerJson(updateRequest.getAnswerJson());
+        question.setAnalysis(updateRequest.getQuestionAnalysis());
+        question.setAnalysisJson(updateRequest.getAnalysisJson());
+
+        if (CollectionUtils.isNotEmpty(updateRequest.getQuestionTypes())) {
+            question.setQuestionType(updateRequest.getQuestionTypes().get(0).getType());
+        }
+        if (CollectionUtils.isNotEmpty(updateRequest.getDifficultyLevels())) {
+            question.setDifficultyLevel(updateRequest.getDifficultyLevels().get(0).getType());
+        }
+
+        if (CollectionUtils.isNotEmpty(updateRequest.getRealExamTypes())) {
+            List<Integer> types = updateRequest.getRealExamTypes().stream().map(KnowledgeBaseDto::getType).collect(Collectors.toList());
+            question.setRealExamType(StringUtils.join(types, ","));
+        }
+
+        if (CollectionUtils.isNotEmpty(updateRequest.getTrainingSkills())) {
+            List<String> names = updateRequest.getTrainingSkills().stream().map(KnowledgeBaseDto::getName).collect(Collectors.toList());
+            question.setTrainingSkill(StringUtils.join(names, ","));
+        }
+    }
+
+    /**
+     * 添加题目关联的知识点 kmt_exercise_question_know， zyb_know_how_details_sort
+     * @param knowledges
+     * @param question
+     */
+    private List<KmtExerciseQuestionKnow> getKmtQuestionKnow (List<KnowHowDetailsDTO> knowledges, KmtExerciseQuestion question){
+        //知识点不为空添加知识点
+        List<KmtExerciseQuestionKnow> questionKnows = new ArrayList<>();
+        if (CollectionUtils.isNotEmpty(knowledges)){
+            for (KnowHowDetailsDTO detail : knowledges){
+                ZuoybKnowHowDetailsSort detailsSort = zuoybKnowHowDetailsSortDao.findOne(detail.getId());
+                if (CollectionUtils.isNotEmpty(detail.getPoints())){
+                    //有考点的情况
+                    detail.getPoints().forEach(point -> {
+                        //添加题目与考点的关联记录
+                        KmtExerciseQuestionKnow  kmtExerciseQuestionKnow = new KmtExerciseQuestionKnow();
+                        kmtExerciseQuestionKnow.setId(IdWorker.generateId());
+                        ZuoybKnowHowDetailsSort pointSort = zuoybKnowHowDetailsSortDao.findOne(point.getId());
+                        kmtExerciseQuestionKnow.setQuestionId(question.getId());
+                        kmtExerciseQuestionKnow.setQuestionParentId(question.getParentId());
+                        kmtExerciseQuestionKnow.setHowDetailsId(detailsSort.getHowDetailsId());
+                        kmtExerciseQuestionKnow.setHowDetailsKdId(pointSort.getHowDetailsKdId());
+                        kmtExerciseQuestionKnow.setVersion(detailsSort.getType());
+                        kmtExerciseQuestionKnow.setLoaded(0);
+                        kmtExerciseQuestionKnow.setCreateTime(new Date());
+                        kmtExerciseQuestionKnow.setUpdateTime(new Date());
+                        kmtExerciseQuestionKnow.setHowDetailSortId(detailsSort.getId());
+                        kmtExerciseQuestionKnow.setHowDetailKdSortId(pointSort.getId());
+                        questionKnows.add(kmtExerciseQuestionKnow);
+
+                    });
+                } else {
+                    //没有考点的情况只记录知识点
+                    KmtExerciseQuestionKnow  kmtExerciseQuestionKnow = new KmtExerciseQuestionKnow();
+                    kmtExerciseQuestionKnow.setId(IdWorker.generateId());
+                    kmtExerciseQuestionKnow.setQuestionId(question.getId());
+                    kmtExerciseQuestionKnow.setQuestionParentId(question.getParentId());
+                    kmtExerciseQuestionKnow.setHowDetailsId(detailsSort.getHowDetailsId());
+                    kmtExerciseQuestionKnow.setHowDetailSortId(detailsSort.getId());
+                    kmtExerciseQuestionKnow.setVersion(detailsSort.getType());
+                    kmtExerciseQuestionKnow.setLoaded(0);
+                    kmtExerciseQuestionKnow.setCreateTime(new Date());
+                    kmtExerciseQuestionKnow.setUpdateTime(new Date());
+                    questionKnows.add(kmtExerciseQuestionKnow);
+                }
+            }
+        }
+        return questionKnows;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseTeacherDataListServiceImpl.java

@@ -0,0 +1,29 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseTeacherDataList;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseTeacherDataListDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.service.KmtExerciseTeacherDataListService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+/**
+ * @Author: chchen
+ * @Description
+ * @Date Create in 11:21 2020/5/29
+ * @Modified By
+ */
+@Transactional
+@Service(version ="1.0")
+public class KmtExerciseTeacherDataListServiceImpl extends BaseServiceImpl<KmtExerciseTeacherDataList, String> implements KmtExerciseTeacherDataListService {
+
+    @Autowired
+    private KmtExerciseTeacherDataListDao dao;
+
+    @Override
+    public PagingAndSortingRepository<KmtExerciseTeacherDataList, String> getDao() {
+        return dao;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtExerciseTeacherRecordServiceImpl.java

@@ -0,0 +1,42 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseBookTeacherRecord;
+import com.ssj.dao.kmt.kmt.dao.KmtExerciseTeacherRecordDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.service.KmtExerciseTeacherRecordService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.List;
+
+/**
+ * @Author: chchen
+ * @Description
+ * @Date Create in 10:58 2020/5/21
+ * @Modified By
+ */
+@Transactional
+@Service(version ="1.0")
+public class KmtExerciseTeacherRecordServiceImpl extends BaseServiceImpl<KmtExerciseBookTeacherRecord, String> implements KmtExerciseTeacherRecordService {
+
+    @Autowired
+    private KmtExerciseTeacherRecordDao dao;
+
+    @Override
+    public PagingAndSortingRepository<KmtExerciseBookTeacherRecord, String> getDao() {
+        return dao;
+    }
+
+
+    @Override
+    public KmtExerciseBookTeacherRecord findByExerciseBookIdAndAuthorityType(String exerciseBookId, int type) {
+        return dao.findByExerciseBookIdAndAuthorityType(exerciseBookId, type);
+    }
+
+    @Override
+    public List<KmtExerciseBookTeacherRecord> findByExerciseBookId(String exerciseBookId) {
+        return dao.findByExerciseBookIdAndLastFlag(exerciseBookId, 1);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtHomeworkWrongQuestionServiceImpl.java

@@ -0,0 +1,135 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtExerciseQuestion;
+import com.ssj.bean.kmt.kmt.domain.KmtHomeworkWrongQuestion;
+import com.ssj.bean.sys.homework.domain.Homework;
+import com.ssj.dao.kmt.kmt.dao.KmtCorrectHomeworkQueryDao;
+import com.ssj.dao.kmt.kmt.dao.KmtHomeworkWrongQuestionDao;
+import com.ssj.es.service.ExerciseQuestionSearchService;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.dto.OriginalQuestionDTO;
+import com.ssj.service.kmt.service.KmtExerciseService;
+import com.ssj.service.kmt.service.KmtHomeworkWrongQuestionService;
+import com.ssj.service.mapper.HomeworkMapper;
+import org.apache.commons.collections.CollectionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.util.*;
+
+/**
+ * @author yrf
+ * @date 2019/1/21 17:19
+ */
+@Transactional
+@Service(version ="1.0")
+public class KmtHomeworkWrongQuestionServiceImpl extends BaseServiceImpl<KmtHomeworkWrongQuestion, String> implements KmtHomeworkWrongQuestionService {
+
+    @Autowired
+    private KmtHomeworkWrongQuestionDao kmtHomeworkWrongQuestionDao;
+
+    @Autowired
+    private KmtCorrectHomeworkQueryDao kmtCorrectHomeworkQueryDao;
+    @Autowired
+    private KmtExerciseService kmtExerciseService;
+    @Autowired
+    private HomeworkMapper homeworkMapper;
+    @Autowired
+    private ExerciseQuestionSearchService exerciseQuestionSearchService;
+
+    @Override
+    public PagingAndSortingRepository<KmtHomeworkWrongQuestion, String> getDao() {
+        return kmtHomeworkWrongQuestionDao;
+    }
+
+    @Override
+    public List<KmtHomeworkWrongQuestion> findList(String homeworkPictureId, boolean isDelete) {
+        return kmtHomeworkWrongQuestionDao.findByHomeworkPictureIdAndIsDelete(homeworkPictureId, isDelete==false?0:1);
+    }
+
+    @Override
+    public List<KmtHomeworkWrongQuestion> findByHomeworkId(String homeworkId) {
+        return kmtHomeworkWrongQuestionDao.findByHomeworkIdAndIsDelete(homeworkId, false);
+    }
+
+
+    @Override
+    public void deleteByHomeworkPictureId(String homeworkPictureId) {
+        kmtHomeworkWrongQuestionDao.deleteByHomeworkPictureId(homeworkPictureId);
+    }
+
+    @Override
+    public Page<Map<String, Object>> findWrongQuestionByPage(Map<String, Object> searchParams, Pageable pageable) {
+        return kmtCorrectHomeworkQueryDao.findWrongQuestionByPage(searchParams, pageable);
+    }
+
+    @Override
+    public Page<Map<String, Object>> findWrongQuestionNewByPage(Map<String, Object> searchParams, Pageable pageable) {
+        return kmtCorrectHomeworkQueryDao.findWrongQuestionNewByPage(searchParams, pageable);
+    }
+
+    @Override
+    public KmtHomeworkWrongQuestion createKmtHomeworkWrongQuestion(Homework homework, Date now, String questionId, Integer wrongType) {
+        KmtHomeworkWrongQuestion kmtHomeworkWrongQuestion = new KmtHomeworkWrongQuestion();
+        kmtHomeworkWrongQuestion.setHomeworkId(homework.getId());
+        kmtHomeworkWrongQuestion.setQuestionId(questionId);
+        kmtHomeworkWrongQuestion.setStudentId(homework.getVipId());
+        kmtHomeworkWrongQuestion.setType(wrongType);
+        kmtHomeworkWrongQuestion.setIsDelete(false);
+        kmtHomeworkWrongQuestion.setCreateTime(now);
+        return kmtHomeworkWrongQuestion;
+    }
+
+    @Override
+    public List<KmtHomeworkWrongQuestion> findByHomeworkPictureIdIn(List<String> homeworkPictureIdList) {
+        return kmtHomeworkWrongQuestionDao.findByHomeworkPictureIdInAndIsDelete(homeworkPictureIdList, false);
+    }
+
+    @Override
+    public void deleteWrongQuesByQuestionId(String questionId) {
+        kmtHomeworkWrongQuestionDao.deleteWrongQuesByQuestionId(questionId);
+    }
+
+    @Override
+    public List<Map<String, Object>> findQuestionList(List<String> homeworkPictureIdList) {
+        List<Map<String, Object>> wrongQuestionIdHomeworkPictureIdMapList = homeworkMapper.findWrongQuestionIdHomeworkPictureId(homeworkPictureIdList);
+        if (CollectionUtils.isEmpty(wrongQuestionIdHomeworkPictureIdMapList)) {
+            return Collections.emptyList();
+        }
+        Map<String, KmtExerciseQuestion> kmtExerciseQuestionMap = new HashMap<>(wrongQuestionIdHomeworkPictureIdMapList.size());
+        List<KmtExerciseQuestion> kmtExerciseQuestionList;
+        for (Map<String, Object> wrongQuestionIdHomeworkPictureIdMap : wrongQuestionIdHomeworkPictureIdMapList) {
+            String questionId = wrongQuestionIdHomeworkPictureIdMap.get("question_id").toString();
+            KmtExerciseQuestion kmtExerciseQuestion = kmtExerciseQuestionMap.get(questionId);
+            if (kmtExerciseQuestion == null) {
+                kmtExerciseQuestionList = exerciseQuestionSearchService.getById(questionId, KmtExerciseQuestion.class);
+                if (CollectionUtils.isNotEmpty(kmtExerciseQuestionList)) {
+                    kmtExerciseQuestion = kmtExerciseQuestionList.get(0);
+                    kmtExerciseQuestionMap.put(kmtExerciseQuestion.getId(), kmtExerciseQuestion);
+                }
+            }
+            if (kmtExerciseQuestion == null) {
+                continue;
+            }
+            wrongQuestionIdHomeworkPictureIdMap.put("question_path", kmtExerciseQuestion.getQuestionPath());
+            wrongQuestionIdHomeworkPictureIdMap.put("parent_id", kmtExerciseQuestion.getParentId());
+        }
+
+        kmtExerciseService.appendQuestionMapFromJSONFile(wrongQuestionIdHomeworkPictureIdMapList);
+        return wrongQuestionIdHomeworkPictureIdMapList;
+    }
+
+    @Override
+    public List<OriginalQuestionDTO> findQuestionContainParentAndBrotherList(List<String> homeworkPictureIdList) {
+        return kmtCorrectHomeworkQueryDao.findQuestionContainParentAndBrotherList(homeworkPictureIdList);
+    }
+
+    @Override
+    public List<Map<String, Object>> findFullBigQuestion(String questionId) {
+        return kmtCorrectHomeworkQueryDao.findFullBigQuestion(questionId);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtImgFaceDetailServiceImpl.java

@@ -0,0 +1,90 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtImgFaceDetail;
+import com.ssj.framework.basic.utils.StringUtils;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtImgFaceDetailDao;
+import com.ssj.dao.kmt.kmt.dao.KmtQueryDao;
+import com.ssj.service.kmt.service.KmtImgFaceDetailService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtImgFaceDetailServiceImpl extends BaseServiceImpl<KmtImgFaceDetail, String> implements KmtImgFaceDetailService {
+
+	@Autowired
+	private KmtImgFaceDetailDao dao;
+	
+	@Autowired
+	private KmtQueryDao kmtQueryDao;
+
+
+	@Override
+	public PagingAndSortingRepository<KmtImgFaceDetail, String> getDao() {
+		return dao;
+	}
+
+
+    @Override
+    public List<Map<String, Object>> findWrongQuestionByCourseKnowId(
+            String courseKnowId) {
+        return kmtQueryDao.findWrongQuestionByCourseKnowId(courseKnowId);
+    }
+
+
+    @Override
+    public List<Map<String, Object>> get121WrongKnowModuleData(String vipId, String subject, String beginTime, String endTime) {
+        return kmtQueryDao.get121WrongKnowModuleData(vipId, subject, beginTime, endTime);
+    }
+
+    @Override
+    public List<Map<String, Object>> get121SkillWrongData(String vipId, String subject, String beginTime, String endTime) {
+        List<Map<String, Object>> list = kmtQueryDao.get121SkillWrongData(vipId, subject, beginTime, endTime);
+        Map<String, Integer> tempMap = new HashMap<>();
+        List<Map<String, Object>> result = new ArrayList<>();
+        String temp = null;
+        Integer tempInt  = null;
+        if (list != null){
+            for (Map<String, Object> map : list){
+                temp = map.get("module") + "";
+                //获取技能的值
+                if (StringUtils.isNotEmpty(temp)){
+                    String[] skills = temp.split(";");
+                    for (String skill : skills){
+                        tempInt = tempMap.get(skill);
+                        if (tempInt != null && tempInt > 0){
+                            tempMap.put(skill, tempInt.intValue() + 1);
+                        } else {
+                            tempMap.put(skill, 1);
+                        }
+                    }
+                }
+            }
+            //把map转成list
+            Map<String, Object> item = null;
+            for (String key : tempMap.keySet()){
+                item = new HashMap<>();
+                item.put("module", key);
+                item.put("count", tempMap.get(key));
+                result.add(item);
+            }
+        }
+        return result;
+    }
+
+    @Override
+    public List<KmtImgFaceDetail> findByFaceId(String faceId) {
+        return dao.findByFaceId(faceId);
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtImgFaceServiceImpl.java

@@ -0,0 +1,43 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import java.util.List;
+
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtImgFace;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtImgFaceDao;
+import com.ssj.service.kmt.service.KmtImgFaceService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtImgFaceServiceImpl extends BaseServiceImpl<KmtImgFace, String> implements KmtImgFaceService {
+	
+	@Autowired
+	private KmtImgFaceDao dao;
+
+	@Override
+	public PagingAndSortingRepository<KmtImgFace, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public List<KmtImgFace> findImgFaceByTId(String teacherId, Integer pageNo,
+			Integer pageSize) {
+		return dao.findImgFaceByTId(teacherId, pageNo, pageSize);
+	}
+
+	@Override
+	public KmtImgFace findImgFaceByTAndSId(String teacherId, String vipId) {
+		return dao.findImgFaceByTAndSId(teacherId, vipId);
+	}
+
+	@Override
+	public KmtImgFace findImgFaceByCourseId(String courseId) {
+		return dao.findByCourseId(courseId);
+	}
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtImgManageServiceImpl.java

@@ -0,0 +1,28 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtImgManage;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtImgManageDao;
+import com.ssj.service.kmt.service.KmtImgManageService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtImgManageServiceImpl extends BaseServiceImpl<KmtImgManage, String> implements KmtImgManageService {
+
+	@Autowired
+	private KmtImgManageDao dao;
+	
+	@Override
+	public PagingAndSortingRepository<KmtImgManage, String> getDao() {
+		return dao;
+	}
+		
+	
+	
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtKnowledgeServiceImpl.java

@@ -0,0 +1,148 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.model.KmtKnowledgeModel;
+import com.ssj.dao.kmt.kmt.dao.KmtKnowledgeQueryDao;
+import com.ssj.framework.core.util.StringUtil;
+import com.ssj.mapper.knowledge.KmtKnowledgeMapper;
+import com.ssj.service.kmt.constant.KnowledgeVersion;
+import com.ssj.service.kmt.dto.KnowHowDTO;
+import com.ssj.service.kmt.dto.KnowHowDetailsDTO;
+import com.ssj.service.kmt.dto.TestPointDTO;
+import com.ssj.service.kmt.request.KnowledgeRequest;
+import com.ssj.service.kmt.request.TestPointRequest;
+import com.ssj.service.kmt.service.KmtKnowledgeService;
+import com.ssj.service.weixin.zuoyb.service.ZuoybKnowHowDetailsService;
+import com.ssj.service.weixin.zuoyb.service.ZuoybKnowHowService;
+
+import org.apache.commons.collections.CollectionUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.springframework.transaction.annotation.Propagation;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtKnowledgeServiceImpl implements KmtKnowledgeService {
+
+    @Autowired
+    private ZuoybKnowHowService zuoybKnowHowService;
+    @Autowired
+    private ZuoybKnowHowDetailsService zuoybKnowHowDetailsService;
+    @Autowired
+    private KmtKnowledgeQueryDao kmtKnowledgeQueryDao;
+    @Autowired
+    private KmtKnowledgeMapper kmtKnowledgeMapper;
+    @Autowired
+    private KnowledgeVersion knowledgeVersion;
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public List<KnowHowDTO> getKnowledge(KnowledgeRequest request) {
+        return zuoybKnowHowService.findListByCondition(request);
+    }
+
+
+    @Override
+    public List<KnowHowDTO> findSortKnowledgeByCondition(KnowledgeRequest request) {
+        Integer moduleType = null;
+        if (request.getModuleType() == 1){
+            moduleType = 0;
+        } else if (request.getModuleType() == 2){
+            moduleType = 1;
+        }
+        List<KmtKnowledgeModel> mapList = kmtKnowledgeMapper.findKmtKnowledgeByGradeCourseNameTypeSemester(request.getGrade(),
+                request.getSubject(), request.getVersionType(), request.getSemester(), moduleType, request.getSearchKey());
+        List<KnowHowDTO> knowHowDTOList = new ArrayList<>();
+        if (CollectionUtils.isNotEmpty(mapList)){
+            Map<String, List<KmtKnowledgeModel>> knwHowMap = mapList.stream().collect(Collectors.groupingBy(temp ->
+                    String.valueOf(temp.getKnowHowId()), LinkedHashMap::new, Collectors.toList()));
+            knwHowMap.forEach((knowHowId, value) -> {
+                KnowHowDTO knowHowDTO = new KnowHowDTO();
+                knowHowDTO.setId(knowHowId);
+                knowHowDTO.setName(String.valueOf(value.get(0).getKnowHowName()));
+                LinkedHashMap<String, List<KmtKnowledgeModel>> knowHowDetailsMap = value.stream().collect(
+                        Collectors.groupingBy(temp -> String.valueOf(temp.getKnowHowDetailsId()), LinkedHashMap::new,
+                                Collectors.toList()));
+                List<KnowHowDetailsDTO> knowHowDetailsDTOList = new ArrayList<>(value.size());
+                knowHowDetailsMap.forEach((knowHowDetailId, value2) -> {
+                    if (knowHowDetailId != null) {
+                        KnowHowDetailsDTO knowHowDetailsDTO = new KnowHowDetailsDTO();
+                        knowHowDetailsDTO.setId(knowHowDetailId);
+                        knowHowDetailsDTO.setName(String.valueOf(value2.get(0).getKnowHowDetailsName()));
+                        knowHowDetailsDTO.setGrade(request.getGrade());
+                        knowHowDetailsDTO.setSemester(request.getSemester());
+                        knowHowDetailsDTO.setVersionName(knowledgeVersion.getVersionNameBySubjectAndVersionNum(request.getSubject(), request.getVersionType()));
+
+                        List<TestPointDTO> testPointDTOList = new ArrayList<>();
+                        value2.forEach(temp4kd -> {
+                            String howDetailsKdId = temp4kd.getHowDetailsKdId();
+                            if (howDetailsKdId != null) {
+                                TestPointDTO testPointDTO = new TestPointDTO();
+                                testPointDTO.setId(String.valueOf(howDetailsKdId));
+                                testPointDTO.setName(String.valueOf(temp4kd.getKnowHowDetailsKdName()));
+                                testPointDTOList.add(testPointDTO);
+                            }
+                        });
+                        knowHowDetailsDTO.setPoints(testPointDTOList);
+                        knowHowDetailsDTOList.add(knowHowDetailsDTO);
+                    }
+                });
+
+                knowHowDTO.setDetails(knowHowDetailsDTOList);
+                knowHowDTOList.add(knowHowDTO);
+            });
+        }
+        return knowHowDTOList;
+    }
+
+    @Override
+    @Transactional(propagation = Propagation.NOT_SUPPORTED)
+    public List<KnowHowDetailsDTO> findTestPoint(TestPointRequest request) {
+        return zuoybKnowHowDetailsService.findTestPoint(request.getDetailIds(), request.getVersionType(),
+                 request.getGrade(), request.getSubject(), request.getSemester());
+    }
+
+    @Override
+    public List<KnowHowDetailsDTO> findByQuestionId(String questionId) {
+        return kmtKnowledgeQueryDao.findByQuestionId(questionId);
+    }
+
+    public List<KnowHowDetailsDTO> findDetailsListWithKd (List<String> detailIds){
+        List<KmtKnowledgeModel> mapList = kmtKnowledgeMapper.findDetailsListWithKd(detailIds);
+        List<KnowHowDetailsDTO> knowHowDetailsDTOList = new ArrayList<>();
+        if (CollectionUtils.isNotEmpty(mapList)){
+            Map<String, List<KmtKnowledgeModel>> listMap = mapList.stream().collect(Collectors.groupingBy(temp ->
+                    String.valueOf(temp.getKnowHowDetailsId()), LinkedHashMap::new, Collectors.toList()));
+            listMap.forEach((key, value) -> {
+                KnowHowDetailsDTO knowHowDetailsDTO = new KnowHowDetailsDTO();
+                knowHowDetailsDTO.setId(key);
+                knowHowDetailsDTO.setName(String.valueOf(value.get(0).getKnowHowDetailsName()));
+                knowHowDetailsDTO.setGrade(value.get(0).getGrade());
+                knowHowDetailsDTO.setSemester(value.get(0).getSemester());
+                knowHowDetailsDTO.setVersionName(knowledgeVersion.getVersionNameBySubjectAndVersionNum(value.get(0).getCourseName(), value.get(0).getType()));
+
+                List<TestPointDTO> testPointDTOList = new ArrayList<>(value.size());
+                value.forEach(map -> {
+                    if (StringUtil.isNotBlank((String)map.getHowDetailsKdId())){
+                        TestPointDTO testPointDTO = new TestPointDTO();
+                        testPointDTO.setId(String.valueOf(map.getHowDetailsKdId()));
+                        testPointDTO.setName(String.valueOf(map.getKnowHowDetailsKdName()));
+                        testPointDTOList.add(testPointDTO);
+                    }
+                });
+
+                knowHowDetailsDTO.setPoints(testPointDTOList);
+                knowHowDetailsDTOList.add(knowHowDetailsDTO);
+            });
+        }
+        return knowHowDetailsDTOList;
+    }
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtLogServiceImpl.java

@@ -0,0 +1,33 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import java.util.List;
+
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtLog;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtLogDao;
+import com.ssj.service.kmt.service.KmtLogService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtLogServiceImpl extends BaseServiceImpl<KmtLog, String> implements KmtLogService {
+	@Autowired
+	private KmtLogDao dao;
+	
+	@Override
+	public PagingAndSortingRepository<KmtLog, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public List<KmtLog> findKmtLog(Integer page, Integer pageSize) {
+		return dao.findKmtLog(page, pageSize);
+	}
+
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtLoginAuthServiceImpl.java

@@ -0,0 +1,66 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.fastjson.JSONArray;
+import com.ssj.bean.kmt.kmt.dto.KmtSysUserAuthDto;
+import com.ssj.bean.kmt.kmt.request.exercise.KmtQuestionOperaterRequest;
+import com.ssj.bean.kmt.kmtsys.domain.KmtSysUser;
+import com.ssj.dao.kmt.kmt.dao.KmtQueryDao;
+
+import com.ssj.framework.core.util.PropertiesUtil;
+import com.ssj.framework.core.util.ResponseConstant;
+import com.ssj.framework.core.util.ResponseEntity;
+import com.ssj.service.kmt.dto.KnowledgeBaseDto;
+import com.ssj.service.kmt.service.KmtSysUserService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.service.kmt.service.KmtLoginAuthService;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtLoginAuthServiceImpl implements KmtLoginAuthService {
+
+    @Autowired
+    private KmtSysUserService kmtSysUserService;
+    @Autowired
+    private KmtQueryDao queryDao;
+
+    @Override
+    public List<KnowledgeBaseDto> getQuestionOperateType() {
+        List<KmtSysUserAuthDto> list = JSONArray.parseArray( PropertiesUtil.getValue("KMT_SYS_USER_AUTH"), KmtSysUserAuthDto.class);
+        List<KnowledgeBaseDto> result = new ArrayList<>();
+        for (KmtSysUserAuthDto kmtSysUserAuthDto : list){
+            KnowledgeBaseDto baseDto = new KnowledgeBaseDto(Integer.parseInt(kmtSysUserAuthDto.getDealType()), kmtSysUserAuthDto.getName());
+            result.add(baseDto);
+        }
+        return result;
+    }
+
+    @Override
+    public ResponseEntity registQuestonOperater(KmtQuestionOperaterRequest request) {
+        ResponseEntity responseEntity = new ResponseEntity();
+        List<KmtSysUserAuthDto> list = JSONArray.parseArray( PropertiesUtil.getValue("KMT_SYS_USER_AUTH"), KmtSysUserAuthDto.class);
+        KmtSysUserAuthDto target = null;
+        for (KmtSysUserAuthDto kmtSysUserAuthDto : list){
+            if (Integer.parseInt(kmtSysUserAuthDto.getDealType()) == request.getType()){
+                target = kmtSysUserAuthDto;
+            }
+        }
+        if (target != null){
+            KmtSysUser sysUser = kmtSysUserService.findKmtSysUserByLoginNameAndType(request.getLoginName(), target.getType());
+            if (sysUser != null){
+                responseEntity.failure(ResponseConstant.CODE_000, "登录名已存在");
+            } else {
+                responseEntity.success(ResponseConstant.CODE_999, "成功");
+                queryDao.insertLogin(request.getLoginName(), request.getPassword(), request.getName(),  target.getName(), target.getType() + "");
+            }
+        } else {
+            responseEntity.failure(ResponseConstant.CODE_000, "初始化信息出错");
+        }
+        return responseEntity;
+    }
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtPlanDetailServiceImpl.java

@@ -0,0 +1,31 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtPlanDetail;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtPlanDetailDao;
+import com.ssj.service.kmt.service.KmtPlanDetailService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtPlanDetailServiceImpl extends BaseServiceImpl<KmtPlanDetail, String> implements KmtPlanDetailService {
+
+	@Autowired
+	private KmtPlanDetailDao dao;
+	
+	@Override
+	public PagingAndSortingRepository<KmtPlanDetail, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public void deletePlanDetailByTempId(String planTempId) {
+		dao.deletePlanDetailByTempId(planTempId);
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtPlanTemplateServiceImpl.java

@@ -0,0 +1,51 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtPlanTemplate;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtPlanTemplateDao;
+import com.ssj.dao.kmt.kmt.dao.KmtQueryDao;
+import com.ssj.service.kmt.service.KmtPlanTemplateService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+import org.springframework.transaction.annotation.Transactional;
+import java.util.List;
+import java.util.Map;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtPlanTemplateServiceImpl   extends BaseServiceImpl<KmtPlanTemplate, String> implements KmtPlanTemplateService {
+
+	
+	@Autowired
+	private KmtPlanTemplateDao dao;
+	
+	@Autowired
+	private KmtQueryDao querydao;
+
+
+	
+	@Override
+	public List<KmtPlanTemplate> findPlanByList(String teacherId) {
+		return dao.findPlanByList(teacherId);
+	}
+
+	@Override
+	public PagingAndSortingRepository<KmtPlanTemplate, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public KmtPlanTemplate findPlanById(String id) {
+		return this.getById(id);
+	}
+
+	@Override
+	public List<Map<String, Object>> findPlanSpeedByList(String studentId,
+			String type) {
+		return querydao.findPlanSpeedByList(studentId, type);
+	}
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtPrintManageServiceImpl.java

@@ -0,0 +1,40 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+import java.util.List;
+
+import org.springframework.transaction.annotation.Transactional;
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtPrintManage;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.dao.kmt.kmt.dao.KmtPrintManageDao;
+import com.ssj.service.kmt.service.KmtPrintManageService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+
+
+@Transactional
+@Service(version ="1.0")
+public class KmtPrintManageServiceImpl   extends BaseServiceImpl<KmtPrintManage, String> implements KmtPrintManageService {
+
+	@Autowired
+	private KmtPrintManageDao dao;
+
+	@Override
+	public PagingAndSortingRepository<KmtPrintManage, String> getDao() {
+		return dao;
+	}
+
+	@Override
+	public List<KmtPrintManage> findPrintManageByList(String teacherId) {
+		return dao.findPrintManageByList(teacherId);
+	}
+
+	@Override
+	public KmtPrintManage findPrintManageByCId(String courseKnowId) {
+		return dao.findPrintManageByCId(courseKnowId);
+	}
+	
+	
+
+}

ssj-sys/src/main/java/com/ssj/service/kmt/kmt/service/impl/KmtQualityQuestionCommentServiceImpl.java

@@ -0,0 +1,29 @@
+package com.ssj.service.kmt.kmt.service.impl;
+
+
+import com.alibaba.dubbo.config.annotation.Service;
+import com.ssj.bean.kmt.kmt.domain.KmtQualityQuestionComment;
+import com.ssj.bean.kmt.kmt.domain.KmtQualityQuestions;
+import com.ssj.dao.kmt.kmt.dao.KmtQualityQuestionCommentDao;
+import com.ssj.framework.core.common.service.BaseServiceImpl;
+import com.ssj.service.kmt.service.KmtQualityQuestionCommentService;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.repository.PagingAndSortingRepository;
+import org.springframework.transaction.annotation.Transactional;
+
+@Transactional
+@Service(version ="1.0")
+public class KmtQualityQuestionCommentServiceImpl  extends BaseServiceImpl<KmtQualityQuestionComment, String> implements KmtQualityQuestionCommentService {
+
+    @Autowired
+    private KmtQualityQuestionCommentDao dao;
+    @Override
+    public PagingAndSortingRepository<KmtQualityQuestionComment, String> getDao() {
+        return dao;
+    }
+
+    @Override
+    public KmtQualityQuestionComment findByQuestionId(String questionId) {
+        return dao.findByQuestionId(questionId);
+    }
+}