教师重置课程

beetlsql3-dev
Mlxa0324 2 years ago
parent 33dc4c6697
commit 02384adb48

@ -4,7 +4,10 @@ import com.ibeetl.admin.core.entity.CoreAudit;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("console.audit")
public interface AuditConsoleDao extends BaseMapper<CoreAudit> {

@ -5,12 +5,15 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* CoreDict Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("console.dict")
public interface DictConsoleDao extends BaseMapper<CoreDict>{
public PageQuery<CoreDict> queryByCondition(PageQuery query);

@ -4,7 +4,10 @@ import com.ibeetl.admin.core.entity.CoreFunction;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("console.function")
public interface FunctionConsoleDao extends BaseMapper<CoreFunction> {

@ -4,7 +4,10 @@ import com.ibeetl.admin.core.entity.CoreMenu;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("console.menu")
public interface MenuConsoleDao extends BaseMapper<CoreMenu> {

@ -7,9 +7,12 @@ import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.Param;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("console.org")
public interface OrgConsoleDao extends BaseMapper<CoreOrg> {
void queryByCondition(PageQuery<CoreOrg> query);

@ -6,9 +6,12 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("console.role")
public interface RoleConsoleDao extends BaseMapper<CoreRole> {

@ -5,9 +5,12 @@ import com.ibeetl.admin.core.entity.CoreRoleFunction;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("console.roleFunction")
public interface RoleFunctionConsoleDao extends BaseMapper<CoreRoleFunction> {

@ -7,9 +7,12 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("console.user")
public interface UserConsoleDao extends BaseMapper<CoreUser> {

@ -192,6 +192,7 @@ public class CacheConfig {
@Override
public void put(Object key, Object value) {
if (value == null) { return; }
System.out.println(value.getClass().getClassLoader());
redisCache.put(key, value);
clearOtherJVM();

@ -3,11 +3,14 @@ package com.ibeetl.admin.core.dao;
import com.ibeetl.admin.core.entity.CoreAudit;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
/*
*
* gen by starter mapper 2017-08-01
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coreAudit")
public interface CoreAuditDao extends BaseMapper<CoreAudit> {

@ -4,6 +4,7 @@ import com.ibeetl.admin.core.entity.CoreDict;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@ -11,6 +12,8 @@ import java.util.Map;
/**
* DAO
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coreDict")
public interface CoreDictDao extends BaseMapper<CoreDict> {

@ -5,7 +5,10 @@ import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.Param;
import org.beetl.sql.mapper.annotation.Sql;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coreFunction")
public interface CoreFunctionDao extends BaseMapper<CoreFunction> {
@Sql("select * from core_function where code = ?")

@ -5,9 +5,12 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coreMenu")
public interface CoreMenuDao extends BaseMapper<CoreMenu> {

@ -4,9 +4,12 @@ import com.ibeetl.admin.core.entity.CoreOrg;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.Sql;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
import java.util.List;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coreOrg")
public interface CoreOrgDao extends BaseMapper<CoreOrg> {

@ -3,7 +3,10 @@ package com.ibeetl.admin.core.dao;
import com.ibeetl.admin.core.entity.CoreRole;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coreRole")
public interface CoreRoleDao extends BaseMapper<CoreRole> {

@ -3,9 +3,12 @@ package com.ibeetl.admin.core.dao;
import com.ibeetl.admin.core.entity.CoreRoleFunction;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
import java.util.List;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coreRoleFunction")
public interface CoreRoleFunctionDao extends BaseMapper<CoreRoleFunction> {

@ -4,9 +4,12 @@ import com.ibeetl.admin.core.entity.CoreRoleMenu;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coreRoleMenu")
public interface CoreRoleMenuDao extends BaseMapper<CoreRoleMenu> {

@ -7,6 +7,8 @@ import org.springframework.stereotype.Component;
import java.util.List;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coreUser")
public interface CoreUserDao extends BaseMapper<CoreUser> {

@ -3,7 +3,10 @@ package com.ibeetl.admin.core.dao;
import com.ibeetl.admin.core.entity.CoreUserRole;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.coresUserRole")
public interface CoreUserRoleDao extends BaseMapper<CoreUserRole> {

@ -3,6 +3,7 @@ package com.ibeetl.admin.core.dao;
import com.ibeetl.admin.core.entity.CoreUser;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
import java.util.List;
@ -10,6 +11,8 @@ import java.util.List;
*
* @author TLT
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("core.workflow")
public interface CoreWorkflowDao extends BaseMapper {

@ -3,7 +3,6 @@ package com.ibeetl.admin.core.service;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.ArrayUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.ReUtil;
import com.ibeetl.admin.core.util.PlatformException;
import com.ibeetl.admin.core.util.enums.DelFlagEnum;
@ -232,7 +231,7 @@ public class CoreBaseService<T> extends CoreBaseAnnotationParser {
* ArrayUtil.map(ignores, ReUtil::escape)
* [org_id|user_id|_add_time|]$
*/
String regex = String.format("[%s]$", ArrayUtil.join(ArrayUtil.map(ignores, ReUtil::escape), "|"));
String regex = String.format("[%s]$", ArrayUtil.join(ArrayUtil.map(ignores, ReUtil::escape).toArray(), "|"));
log.debug("生成的正则:{}", regex);
// 构建LambdaQuery
@ -240,16 +239,14 @@ public class CoreBaseService<T> extends CoreBaseAnnotationParser {
LambdaQuery<T> tLambdaQuery = sqlManager.lambdaQuery(currentEntityClass);
// 实体类属性转Map
Map<String, Object> stringObjectMap = BeanUtil.beanToMap(condition);
Map<String, Object> stringObjectMap = BeanUtil.beanToMap(condition, true, true);
// 移除空值或者忽略字段
for (String k : stringObjectMap.keySet()) {
Object obj = stringObjectMap.get(k);
/**
* , String
* {@link cn.hutool.core.util.ObjectUtil#isEmpty}
*
*/
if (!(obj instanceof String) || ObjectUtil.isEmpty(obj) || ReUtil.isMatch(regex, k)) {
if (ReUtil.isMatch(regex, k)) {
stringObjectMap.remove(k);
}
}

@ -7,6 +7,7 @@ import ${basePackage}.entity.*;
import ${basePackage}.web.query.${entity.name}Query;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.annotation.Update;
@ -14,7 +15,9 @@ import org.beetl.sql.mapper.annotation.Update;
/**
* ${entity.displayName} Dao
*/
\@SqlResource("${entity.system}.${entity.code}")
\// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("${entity.system}.${entity.code}")
public interface ${entity.name}Dao extends BaseMapper<${entity.name}>{
PageQuery<${entity.name}> queryByCondition(PageQuery query);
PageQuery<${entity.name}> queryByConditionQuery(PageQuery query);

File diff suppressed because it is too large Load Diff

File diff suppressed because it is too large Load Diff

@ -28457,10 +28457,10 @@ INSERT INTO `student_question_log_info` VALUES (151, 130, '2021-09-10 19:22:35',
DROP TABLE IF EXISTS `sys_log`;
CREATE TABLE `sys_log` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
`method` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '请求方法',
`request_url` varchar(200) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '请求URI',
`params` varchar(5000) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '请求参数',
`result` varchar(10000) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NULL DEFAULT NULL COMMENT '结果',
`method` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '请求方法',
`request_url` varchar(1000) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '请求URI',
`params` varchar(5000) CHARACTER SET utf8mb4 NULL DEFAULT NULL COMMENT '请求参数',
`result` text CHARACTER SET utf8mb4 NULL DEFAULT NULL COMMENT '结果',
`ip` varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT 'ip地址',
`create_time` datetime(6) NULL DEFAULT NULL COMMENT '操作时间',
`result_time` datetime(6) NULL DEFAULT NULL COMMENT '响应时间',

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* Attribute Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.attribute")
public interface AttributeDao extends BaseMapper<Attribute>{
public PageQuery<Attribute> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* AttributeGrouping Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.attributeGrouping")
public interface AttributeGroupingDao extends BaseMapper<AttributeGrouping>{
public PageQuery<AttributeGrouping> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* AttributeRelation Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.attributeRelation")
public interface AttributeRelationDao extends BaseMapper<AttributeRelation>{
public PageQuery<AttributeRelation> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* Competition Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.competition")
public interface CompetitionDao extends BaseMapper<Competition>{
public PageQuery<Competition> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* CompetitionNews Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.competitionNews")
public interface CompetitionNewsDao extends BaseMapper<CompetitionNews>{
public PageQuery<CompetitionNews> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* CompetitionStudents Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.competitionStudents")
public interface CompetitionStudentsDao extends BaseMapper<CompetitionStudents>{
public PageQuery<CompetitionStudents> queryByCondition(PageQuery query);

@ -1,19 +1,20 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.CompetitionTaskMain;
import com.ibeetl.jlw.web.query.CompetitionTaskMainQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.competitionTaskMain")
public interface CompetitionTaskMainDao extends BaseMapper<CompetitionTaskMain>{
PageQuery<CompetitionTaskMain> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.List;
@ -14,6 +15,8 @@ import java.util.List;
/**
* CompetitionTaskOneQuestion Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.competitionTaskOneQuestion")
public interface CompetitionTaskOneQuestionDao extends BaseMapper<CompetitionTaskOneQuestion>{
public PageQuery<CompetitionTaskOneQuestion> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* CompetitionTaskSecondQuestion Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.competitionTaskSecondQuestion")
public interface CompetitionTaskSecondQuestionDao extends BaseMapper<CompetitionTaskSecondQuestion>{
public PageQuery<CompetitionTaskSecondQuestion> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* CompetitionTaskSecondQuestionStep Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.competitionTaskSecondQuestionStep")
public interface CompetitionTaskSecondQuestionStepDao extends BaseMapper<CompetitionTaskSecondQuestionStep>{
public PageQuery<CompetitionTaskSecondQuestionStep> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* CompetitionTeacherEvaluation Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.competitionTeacherEvaluation")
public interface CompetitionTeacherEvaluationDao extends BaseMapper<CompetitionTeacherEvaluation>{
public PageQuery<CompetitionTeacherEvaluation> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* CourseInfo Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.courseInfo")
public interface CourseInfoDao extends BaseMapper<CourseInfo>{
public PageQuery<CourseInfo> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* CourseLabel Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.courseLabel")
public interface CourseLabelDao extends BaseMapper<CourseLabel>{
public PageQuery<CourseLabel> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* Exam Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.exam")
public interface ExamDao extends BaseMapper<Exam>{
public PageQuery<Exam> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* ExamStudents Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.examStudents")
public interface ExamStudentsDao extends BaseMapper<ExamStudents>{
public PageQuery<ExamStudents> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
import java.util.List;
@ -14,6 +15,8 @@ import java.util.List;
/**
* ExamTaskOneQuestion Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.examTaskOneQuestion")
public interface ExamTaskOneQuestionDao extends BaseMapper<ExamTaskOneQuestion>{
public PageQuery<ExamTaskOneQuestion> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* ExamTaskSecondQuestion Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.examTaskSecondQuestion")
public interface ExamTaskSecondQuestionDao extends BaseMapper<ExamTaskSecondQuestion>{
public PageQuery<ExamTaskSecondQuestion> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* ExamTaskSecondQuestionStep Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.examTaskSecondQuestionStep")
public interface ExamTaskSecondQuestionStepDao extends BaseMapper<ExamTaskSecondQuestionStep>{
public PageQuery<ExamTaskSecondQuestionStep> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* ExamTaskThreeQuestion Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.examTaskThreeQuestion")
public interface ExamTaskThreeQuestionDao extends BaseMapper<ExamTaskThreeQuestion>{
public PageQuery<ExamTaskThreeQuestion> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* ExamTaskThreeQuestionStep Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.examTaskThreeQuestionStep")
public interface ExamTaskThreeQuestionStepDao extends BaseMapper<ExamTaskThreeQuestionStep>{
public PageQuery<ExamTaskThreeQuestionStep> queryByCondition(PageQuery query);

@ -1,19 +1,21 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.HandsOnAchievement;
import com.ibeetl.jlw.web.query.HandsOnAchievementQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.handsOnAchievement")
public interface HandsOnAchievementDao extends BaseMapper<HandsOnAchievement>{
PageQuery<HandsOnAchievement> queryByCondition(PageQuery query);

@ -1,19 +1,20 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.HandsOn;
import com.ibeetl.jlw.web.query.HandsOnQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* HandsOn Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.handsOn")
public interface HandsOnDao extends BaseMapper<HandsOn>{
PageQuery<HandsOn> queryByCondition(PageQuery query);

@ -1,19 +1,20 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.HandsOnSimulationTasks;
import com.ibeetl.jlw.web.query.HandsOnSimulationTasksQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* HandsOnSimulationTasks Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.handsOnSimulationTasks")
public interface HandsOnSimulationTasksDao extends BaseMapper<HandsOnSimulationTasks>{
PageQuery<HandsOnSimulationTasks> queryByCondition(PageQuery query);

@ -1,19 +1,20 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.HandsOnSimulationTasksFile;
import com.ibeetl.jlw.web.query.HandsOnSimulationTasksFileQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* - Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.handsOnSimulationTasksFile")
public interface HandsOnSimulationTasksFileDao extends BaseMapper<HandsOnSimulationTasksFile>{
PageQuery<HandsOnSimulationTasksFile> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* IpAddress Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.ipAddress")
public interface IpAddressDao extends BaseMapper<IpAddress>{
public PageQuery<IpAddress> queryByCondition(PageQuery query);

@ -6,12 +6,15 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* 2 Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.resourcesApplicationCourse")
public interface ResourcesApplicationCourseDao extends BaseMapper<ResourcesApplicationCourse>{
PageQuery<ResourcesApplicationCourse> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* ResourcesApplication Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.resourcesApplication")
public interface ResourcesApplicationDao extends BaseMapper<ResourcesApplication>{
public PageQuery<ResourcesApplication> queryByCondition(PageQuery query);

@ -10,6 +10,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -17,6 +18,8 @@ import java.util.List;
/**
* ResourcesCompetition Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.resourcesCompetition")
public interface ResourcesCompetitionDao extends BaseMapper<ResourcesCompetition>{
public PageQuery<ResourcesCompetition> queryByCondition(PageQuery query);

@ -5,6 +5,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -12,6 +13,8 @@ import java.util.List;
/**
* ResourcesCompetitionStep Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.resourcesCompetitionStep")
public interface ResourcesCompetitionStepDao extends BaseMapper<ResourcesCompetitionStep>{
public PageQuery<ResourcesCompetitionStep> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* ResourcesInfo Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.resourcesInfo")
public interface ResourcesInfoDao extends BaseMapper<ResourcesInfo>{
public PageQuery<ResourcesInfo> queryByCondition(PageQuery query);

@ -8,6 +8,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -15,6 +16,8 @@ import java.util.List;
/**
* ResourcesQuestion Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.resourcesQuestion")
public interface ResourcesQuestionDao extends BaseMapper<ResourcesQuestion>{
public PageQuery<ResourcesQuestion> queryByCondition(PageQuery query);

@ -8,12 +8,15 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.resourcesQuestionSnapshot")
public interface ResourcesQuestionSnapshotDao extends BaseMapper<ResourcesQuestionSnapshot>{
PageQuery<ResourcesQuestionSnapshot> queryByCondition(PageQuery query);

@ -9,6 +9,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -16,6 +17,8 @@ import java.util.List;
/**
* ResourcesTraining Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.resourcesTraining")
public interface ResourcesTrainingDao extends BaseMapper<ResourcesTraining>{
public PageQuery<ResourcesTraining> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* ResourcesTrainingStep Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.resourcesTrainingStep")
public interface ResourcesTrainingStepDao extends BaseMapper<ResourcesTrainingStep>{
public PageQuery<ResourcesTrainingStep> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* SchoolClass Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.schoolClass")
public interface SchoolClassDao extends BaseMapper<SchoolClass>{
public PageQuery<SchoolClass> queryByCondition(PageQuery query);

@ -1,6 +1,7 @@
package com.ibeetl.jlw.dao;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.Map;
@ -12,6 +13,8 @@ import java.util.Map;
* @Author
* @Date 2022/10/24 20:38
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.statisticalAnalysis")
public interface StatisticalAnalysisDao {

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* StudentClientLink Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentClientLink")
public interface StudentClientLinkDao extends BaseMapper<StudentClientLink>{
public PageQuery<StudentClientLink> queryByCondition(PageQuery query);

@ -9,6 +9,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@ -17,6 +18,8 @@ import java.util.Map;
/**
* Student Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.student")
public interface StudentDao extends BaseMapper<Student>{
public PageQuery queryByConditionQuery(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* StudentDefenceLog Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentDefenceLog")
public interface StudentDefenceLogDao extends BaseMapper<StudentDefenceLog>{
public PageQuery<StudentDefenceLog> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* StudentDefenceLogInfo Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentDefenceLogInfo")
public interface StudentDefenceLogInfoDao extends BaseMapper<StudentDefenceLogInfo>{
public PageQuery<StudentDefenceLogInfo> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* StudentDefenceLogNote Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentDefenceLogNote")
public interface StudentDefenceLogNoteDao extends BaseMapper<StudentDefenceLogNote>{
public PageQuery<StudentDefenceLogNote> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* StudentDirectMessages Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentDirectMessages")
public interface StudentDirectMessagesDao extends BaseMapper<StudentDirectMessages>{
public PageQuery<StudentDirectMessages> queryByCondition(PageQuery query);

@ -1,19 +1,21 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.StudentHandsOnTaskPpt;
import com.ibeetl.jlw.web.query.StudentHandsOnTaskPptQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* -ppt Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentHandsOnTaskPpt")
public interface StudentHandsOnTaskPptDao extends BaseMapper<StudentHandsOnTaskPpt>{
PageQuery<StudentHandsOnTaskPpt> queryByCondition(PageQuery query);

@ -1,19 +1,21 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.StudentHandsOnTaskReport;
import com.ibeetl.jlw.web.query.StudentHandsOnTaskReportQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* -- Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentHandsOnTaskReport")
public interface StudentHandsOnTaskReportDao extends BaseMapper<StudentHandsOnTaskReport>{
PageQuery<StudentHandsOnTaskReport> queryByCondition(PageQuery query);

@ -1,19 +1,21 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.StudentHandsOnTaskStep;
import com.ibeetl.jlw.web.query.StudentHandsOnTaskStepQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* - Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentHandsOnTaskStep")
public interface StudentHandsOnTaskStepDao extends BaseMapper<StudentHandsOnTaskStep>{
PageQuery<StudentHandsOnTaskStep> queryByCondition(PageQuery query);

@ -1,19 +1,21 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.StudentHandsOnTaskTheory;
import com.ibeetl.jlw.web.query.StudentHandsOnTaskTheoryQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* - Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentHandsOnTaskTheory")
public interface StudentHandsOnTaskTheoryDao extends BaseMapper<StudentHandsOnTaskTheory>{
PageQuery<StudentHandsOnTaskTheory> queryByCondition(PageQuery query);

@ -1,19 +1,21 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.StudentHandsOnTaskVideo;
import com.ibeetl.jlw.web.query.StudentHandsOnTaskVideoQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* - Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentHandsOnTaskVideo")
public interface StudentHandsOnTaskVideoDao extends BaseMapper<StudentHandsOnTaskVideo>{
PageQuery<StudentHandsOnTaskVideo> queryByCondition(PageQuery query);

@ -6,12 +6,15 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* - Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentMergeApplication")
public interface StudentMergeApplicationDao extends BaseMapper<StudentMergeApplication>{
PageQuery<StudentMergeApplication> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* StudentQuestionLogAnswer Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentQuestionLogAnswer")
public interface StudentQuestionLogAnswerDao extends BaseMapper<StudentQuestionLogAnswer>{
public PageQuery<StudentQuestionLogAnswer> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* StudentQuestionLog Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentQuestionLog")
public interface StudentQuestionLogDao extends BaseMapper<StudentQuestionLog>{
public PageQuery<StudentQuestionLog> queryByCondition(PageQuery query);

@ -5,11 +5,14 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
/**
* StudentQuestionLogInfo Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.studentQuestionLogInfo")
public interface StudentQuestionLogInfoDao extends BaseMapper<StudentQuestionLogInfo>{
public PageQuery<StudentQuestionLogInfo> queryByCondition(PageQuery query);

@ -5,6 +5,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.Date;
import java.util.List;
@ -14,6 +15,8 @@ import java.util.Map;
/**
* SysLog Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.sysLog")
public interface SysLogDao extends BaseMapper<SysLog> {
PageQuery<SysLog> queryByCondition(PageQuery query);

@ -7,6 +7,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@ -15,6 +16,8 @@ import java.util.Map;
/**
* Teacher Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacher")
public interface TeacherDao extends BaseMapper<Teacher>{
public PageQuery<Teacher> queryByCondition(PageQuery query);

@ -7,6 +7,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import javax.validation.constraints.NotNull;
import java.util.List;
@ -14,6 +15,8 @@ import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherMergeApplication")
public interface TeacherMergeApplicationDao extends BaseMapper<TeacherMergeApplication>{
PageQuery<TeacherMergeApplication> queryByCondition(PageQuery query);

@ -6,12 +6,15 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseChatLog")
public interface TeacherOpenCourseChatLogDao extends BaseMapper<TeacherOpenCourseChatLog>{
PageQuery<TeacherOpenCourseChatLog> queryByCondition(PageQuery query);

@ -7,6 +7,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -14,6 +15,8 @@ import java.util.List;
/**
* TeacherOpenCourse Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourse")
public interface TeacherOpenCourseDao extends BaseMapper<TeacherOpenCourse>{
public PageQuery<TeacherOpenCourse> queryByCondition(PageQuery query);

@ -1,20 +1,23 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.TeacherOpenCourseHandsOn;
import com.ibeetl.jlw.entity.TeacherOpenCourseHandsOnList;
import com.ibeetl.jlw.web.query.GetHandsOnListParam;
import com.ibeetl.jlw.web.query.TeacherOpenCourseHandsOnQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
/**
* - Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseHandsOn")
public interface TeacherOpenCourseHandsOnDao extends BaseMapper<TeacherOpenCourseHandsOn>{
PageQuery<TeacherOpenCourseHandsOn> queryByCondition(PageQuery query);

@ -1,19 +1,20 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.TeacherOpenCourseHandsOnSimulationTasks;
import com.ibeetl.jlw.web.query.TeacherOpenCourseHandsOnSimulationTasksQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* - Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseHandsOnSimulationTasks")
public interface TeacherOpenCourseHandsOnSimulationTasksDao extends BaseMapper<TeacherOpenCourseHandsOnSimulationTasks>{
PageQuery<TeacherOpenCourseHandsOnSimulationTasks> queryByCondition(PageQuery query);

@ -1,19 +1,20 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.TeacherOpenCourseHandsOnSimulationTasksFile;
import com.ibeetl.jlw.web.query.TeacherOpenCourseHandsOnSimulationTasksFileQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* - Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseHandsOnSimulationTasksFile")
public interface TeacherOpenCourseHandsOnSimulationTasksFileDao extends BaseMapper<TeacherOpenCourseHandsOnSimulationTasksFile>{
PageQuery<TeacherOpenCourseHandsOnSimulationTasksFile> queryByCondition(PageQuery query);

@ -1,19 +1,20 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.TeacherOpenCourseKnowledgePoint;
import com.ibeetl.jlw.web.query.TeacherOpenCourseKnowledgePointQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseKnowledgePoint")
public interface TeacherOpenCourseKnowledgePointDao extends BaseMapper<TeacherOpenCourseKnowledgePoint>{
PageQuery<TeacherOpenCourseKnowledgePoint> queryByCondition(PageQuery query);

@ -1,19 +1,20 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.TeacherOpenCourseKnowledgePointRelation;
import com.ibeetl.jlw.web.query.TeacherOpenCourseKnowledgePointRelationQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseKnowledgePointRelation")
public interface TeacherOpenCourseKnowledgePointRelationDao extends BaseMapper<TeacherOpenCourseKnowledgePointRelation>{
PageQuery<TeacherOpenCourseKnowledgePointRelation> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@ -13,6 +14,8 @@ import java.util.Map;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseMergeCourseInfo")
public interface TeacherOpenCourseMergeCourseInfoDao extends BaseMapper<TeacherOpenCourseMergeCourseInfo>{
PageQuery<TeacherOpenCourseMergeCourseInfo> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@ -13,6 +14,8 @@ import java.util.Map;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseMergeResourcesInfo")
public interface TeacherOpenCourseMergeResourcesInfoDao extends BaseMapper<TeacherOpenCourseMergeResourcesInfo>{
PageQuery<TeacherOpenCourseMergeResourcesInfo> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@ -13,6 +14,8 @@ import java.util.Map;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseMergeResourcesQuestion")
public interface TeacherOpenCourseMergeResourcesQuestionDao extends BaseMapper<TeacherOpenCourseMergeResourcesQuestion>{
PageQuery<TeacherOpenCourseMergeResourcesQuestion> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@ -13,6 +14,8 @@ import java.util.Map;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseMergeScheduleSession")
public interface TeacherOpenCourseMergeScheduleSessionDao extends BaseMapper<TeacherOpenCourseMergeScheduleSession>{
PageQuery<TeacherOpenCourseMergeScheduleSession> queryByCondition(PageQuery query);

@ -6,12 +6,15 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseMergeSchoolClass")
public interface TeacherOpenCourseMergeSchoolClassDao extends BaseMapper<TeacherOpenCourseMergeSchoolClass>{
PageQuery<TeacherOpenCourseMergeSchoolClass> queryByCondition(PageQuery query);

@ -8,6 +8,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import javax.validation.constraints.NotNull;
import java.util.List;
@ -15,6 +16,8 @@ import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseMergeStudent")
public interface TeacherOpenCourseMergeStudentDao extends BaseMapper<TeacherOpenCourseMergeStudent>{
PageQuery<TeacherOpenCourseMergeStudent> queryByCondition(PageQuery query);

@ -7,6 +7,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import javax.validation.constraints.NotNull;
import java.util.List;
@ -15,6 +16,8 @@ import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseMergeTeacher")
public interface TeacherOpenCourseMergeTeacherDao extends BaseMapper<TeacherOpenCourseMergeTeacher>{
public PageQuery<TeacherOpenCourseMergeTeacher> queryByCondition(PageQuery query);

@ -1,19 +1,21 @@
package com.ibeetl.jlw.dao;
import java.util.List;
import java.util.Map;
import com.ibeetl.jlw.entity.*;
import com.ibeetl.jlw.entity.SchoolClass;
import com.ibeetl.jlw.entity.TeacherOpenCourseNotice;
import com.ibeetl.jlw.web.query.TeacherOpenCourseNoticeQuery;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseNotice")
public interface TeacherOpenCourseNoticeDao extends BaseMapper<TeacherOpenCourseNotice>{
PageQuery<TeacherOpenCourseNotice> queryByCondition(PageQuery query);

@ -6,12 +6,15 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseQuestionLog")
public interface TeacherOpenCourseQuestionLogDao extends BaseMapper<TeacherOpenCourseQuestionLog>{
PageQuery<TeacherOpenCourseQuestionLog> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.Map;
@ -13,6 +14,8 @@ import java.util.Map;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseQuestionLogWrong")
public interface TeacherOpenCourseQuestionLogWrongDao extends BaseMapper<TeacherOpenCourseQuestionLogWrong>{
PageQuery<TeacherOpenCourseQuestionLogWrong> queryByCondition(PageQuery query);

@ -6,12 +6,15 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseQuestionSetting")
public interface TeacherOpenCourseQuestionSettingDao extends BaseMapper<TeacherOpenCourseQuestionSetting>{
PageQuery<TeacherOpenCourseQuestionSetting> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseScheduleSessionClass")
public interface TeacherOpenCourseScheduleSessionClassDao extends BaseMapper<TeacherOpenCourseScheduleSessionClass>{
public PageQuery<TeacherOpenCourseScheduleSessionClass> queryByCondition(PageQuery query);

@ -6,6 +6,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import java.util.List;
@ -13,6 +14,8 @@ import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseScheduleSession")
public
interface TeacherOpenCourseScheduleSessionDao extends BaseMapper<TeacherOpenCourseScheduleSession>{

@ -7,6 +7,7 @@ import org.beetl.sql.core.engine.PageQuery;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Component;
import javax.validation.constraints.NotNull;
import java.util.Collection;
@ -15,6 +16,8 @@ import java.util.List;
/**
* Dao
*/
// 实际可以不用加Component注解调用的地方注入时候Idea会报红看着难受
@Component
@SqlResource("jlw.teacherOpenCourseScheduleSessionSnap")
public interface TeacherOpenCourseScheduleSessionSnapDao extends BaseMapper<TeacherOpenCourseScheduleSessionSnap>{
PageQuery<TeacherOpenCourseScheduleSessionSnap> queryByCondition(PageQuery query);

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save