tianzeOrg
/
tianze-pro
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

改了下注解

Browse Source
beetlsql3-dev
Mlxa0324 2 years ago
parent 16df4c20cf
commit a25c2e30cf
110 changed files with 342 additions and 342 deletions
Show Stats Download Patch File Download Diff File

6
admin-console/src/main/java/com/ibeetl/admin/console/dao/AuditConsoleDao.java
Unescape Escape View File

@ -4,10 +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;
import org.springframework.stereotype.Repository;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("console.audit")
public interface AuditConsoleDao extends BaseMapper<CoreAudit> {

6
admin-console/src/main/java/com/ibeetl/admin/console/dao/DictConsoleDao.java
Unescape Escape View File

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

6
admin-console/src/main/java/com/ibeetl/admin/console/dao/FunctionConsoleDao.java
Unescape Escape View File

@ -4,10 +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;
import org.springframework.stereotype.Repository;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("console.function")
public interface FunctionConsoleDao extends BaseMapper<CoreFunction> {

6
admin-console/src/main/java/com/ibeetl/admin/console/dao/MenuConsoleDao.java
Unescape Escape View File

@ -4,10 +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;
import org.springframework.stereotype.Repository;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("console.menu")
public interface MenuConsoleDao extends BaseMapper<CoreMenu> {

6
admin-console/src/main/java/com/ibeetl/admin/console/dao/OrgConsoleDao.java
Unescape Escape View File

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

6
admin-console/src/main/java/com/ibeetl/admin/console/dao/RoleConsoleDao.java
Unescape Escape View File

@ -6,12 +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 org.springframework.stereotype.Repository;
import java.util.List;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("console.role")
public interface RoleConsoleDao extends BaseMapper<CoreRole> {

6
admin-console/src/main/java/com/ibeetl/admin/console/dao/RoleFunctionConsoleDao.java
Unescape Escape View File

@ -5,12 +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 org.springframework.stereotype.Repository;
import java.util.List;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("console.roleFunction")
public interface RoleFunctionConsoleDao extends BaseMapper<CoreRoleFunction> {

5
admin-console/src/main/java/com/ibeetl/admin/console/dao/UserConsoleDao.java
Unescape Escape View File

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

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreAuditDao.java
Unescape Escape View File

@ -3,14 +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;
import org.springframework.stereotype.Repository;
/*
*
* gen by starter mapper 2017-08-01
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("core.coreAudit")
public interface CoreAuditDao extends BaseMapper<CoreAudit> {

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreDictDao.java
Unescape Escape View File

@ -4,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -12,8 +12,8 @@ import java.util.Map;
/**
* 字典DAO接口
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("core.coreDict")
public interface CoreDictDao extends BaseMapper<CoreDict> {

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreFunctionDao.java
Unescape Escape View File

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

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreMenuDao.java
Unescape Escape View File

@ -5,12 +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 org.springframework.stereotype.Repository;
import java.util.List;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("core.coreMenu")
public interface CoreMenuDao extends BaseMapper<CoreMenu> {

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreOrgDao.java
Unescape Escape View File

@ -4,12 +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 org.springframework.stereotype.Repository;
import java.util.List;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("core.coreOrg")
public interface CoreOrgDao extends BaseMapper<CoreOrg> {

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreRoleDao.java
Unescape Escape View File

@ -3,10 +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;
import org.springframework.stereotype.Repository;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("core.coreRole")
public interface CoreRoleDao extends BaseMapper<CoreRole> {

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreRoleFunctionDao.java
Unescape Escape View File

@ -3,12 +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 org.springframework.stereotype.Repository;
import java.util.List;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("core.coreRoleFunction")
public interface CoreRoleFunctionDao extends BaseMapper<CoreRoleFunction> {

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreRoleMenuDao.java
Unescape Escape View File

@ -4,12 +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 org.springframework.stereotype.Repository;
import java.util.List;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("core.coreRoleMenu")
public interface CoreRoleMenuDao extends BaseMapper<CoreRoleMenu> {

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreUserDao.java
Unescape Escape View File

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

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreUserRoleDao.java
Unescape Escape View File

@ -3,10 +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;
import org.springframework.stereotype.Repository;
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("core.coresUserRole")
public interface CoreUserRoleDao extends BaseMapper<CoreUserRole> {

6
admin-core/src/main/java/com/ibeetl/admin/core/dao/CoreWorkflowDao.java
Unescape Escape View File

@ -3,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
@ -11,8 +11,8 @@ import java.util.List;
* 业务侧工作流的基本功能，工作流的一些功能将在业务侧完成，比如选人操作
* @author TLT
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("core.workflow")
public interface CoreWorkflowDao extends BaseMapper {

7
admin-core/src/main/resources/codeTemplate/java/dao.java
Unescape Escape View File

@ -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.Repository;
import org.springframework.stereotype.Component;
import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.core.engine.PageQuery;
@ -15,9 +16,9 @@ import org.beetl.sql.mapper.annotation.Update;
/**
* ${entity.displayName} Dao
*/
\// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
@SqlResource("${entity.system}.${entity.code}")
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
\@Repository
\@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);

6
web/src/main/java/com/ibeetl/jlw/dao/AttributeDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* Attribute Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.attribute")
public interface AttributeDao extends BaseMapper<Attribute>{
PageQuery<Attribute> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/AttributeGroupingDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* AttributeGrouping Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.attributeGrouping")
public interface AttributeGroupingDao extends BaseMapper<AttributeGrouping>{
PageQuery<AttributeGrouping> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/AttributeRelationDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* AttributeRelation Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.attributeRelation")
public interface AttributeRelationDao extends BaseMapper<AttributeRelation>{
PageQuery<AttributeRelation> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/CompetitionDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/CompetitionNewsDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* CompetitionNews Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.competitionNews")
public interface CompetitionNewsDao extends BaseMapper<CompetitionNews>{
PageQuery<CompetitionNews> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/CompetitionStudentsDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/CompetitionTaskMainDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 大赛任务 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.competitionTaskMain")
public interface CompetitionTaskMainDao extends BaseMapper<CompetitionTaskMain>{
PageQuery<CompetitionTaskMain> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/CompetitionTaskOneQuestionDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/CompetitionTaskSecondQuestionDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/CompetitionTaskSecondQuestionStepDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/CompetitionTeacherEvaluationDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* CompetitionTeacherEvaluation Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.competitionTeacherEvaluation")
public interface CompetitionTeacherEvaluationDao extends BaseMapper<CompetitionTeacherEvaluation>{
PageQuery<CompetitionTeacherEvaluation> queryByCondition(PageQuery query);

18
web/src/main/java/com/ibeetl/jlw/dao/CoreUserWxDao.java
Unescape Escape View File

@ -1,22 +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.CoreUserWx;
import com.ibeetl.jlw.web.query.CoreUserWxQuery;
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.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* CoreUserWx Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.coreUserWx")
public interface CoreUserWxDao extends BaseMapper<CoreUserWx>{
PageQuery<CoreUserWx> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/CourseInfoDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/CourseLabelDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* CourseLabel Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.courseLabel")
public interface CourseLabelDao extends BaseMapper<CourseLabel>{
PageQuery<CourseLabel> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/ExamDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ExamStudentsDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ExamTaskOneQuestionDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ExamTaskSecondQuestionDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ExamTaskSecondQuestionStepDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ExamTaskThreeQuestionDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ExamTaskThreeQuestionStepDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/HandsOnAchievementDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -14,8 +14,8 @@ import java.util.Map;
/**
* 课程实操 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.handsOnAchievement")
public interface HandsOnAchievementDao extends BaseMapper<HandsOnAchievement>{
PageQuery<HandsOnAchievement> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/HandsOnDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* HandsOn Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.handsOn")
public interface HandsOnDao extends BaseMapper<HandsOn>{
PageQuery<HandsOn> queryByCondition(PageQuery query);

18
web/src/main/java/com/ibeetl/jlw/dao/HandsOnSimulationTasksAssessmentDao.java
Unescape Escape View File

@ -1,22 +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.HandsOnSimulationTasksAssessment;
import com.ibeetl.jlw.web.query.HandsOnSimulationTasksAssessmentQuery;
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.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 课程实操-实训任务考核题目 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.handsOnSimulationTasksAssessment")
public interface HandsOnSimulationTasksAssessmentDao extends BaseMapper<HandsOnSimulationTasksAssessment>{
PageQuery<HandsOnSimulationTasksAssessment> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/HandsOnSimulationTasksDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* HandsOnSimulationTasks Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.handsOnSimulationTasks")
public interface HandsOnSimulationTasksDao extends BaseMapper<HandsOnSimulationTasks>{
PageQuery<HandsOnSimulationTasks> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/HandsOnSimulationTasksFileDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 课程实操-任务附件 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.handsOnSimulationTasksFile")
public interface HandsOnSimulationTasksFileDao extends BaseMapper<HandsOnSimulationTasksFile>{
PageQuery<HandsOnSimulationTasksFile> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/IpAddressDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* IpAddress Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.ipAddress")
public interface IpAddressDao extends BaseMapper<IpAddress>{
PageQuery<IpAddress> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/ResourcesApplicationCourseDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 课程绑定2 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.resourcesApplicationCourse")
public interface ResourcesApplicationCourseDao extends BaseMapper<ResourcesApplicationCourse>{
PageQuery<ResourcesApplicationCourse> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/ResourcesApplicationDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* ResourcesApplication Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.resourcesApplication")
public interface ResourcesApplicationDao extends BaseMapper<ResourcesApplication>{
PageQuery<ResourcesApplication> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/ResourcesCompetitionDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ResourcesCompetitionStepDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ResourcesInfoDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ResourcesQuestionDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ResourcesQuestionSnapshotDao.java
Unescape Escape View File

@ -8,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 题目快照 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.resourcesQuestionSnapshot")
public interface ResourcesQuestionSnapshotDao extends BaseMapper<ResourcesQuestionSnapshot>{
PageQuery<ResourcesQuestionSnapshot> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/ResourcesTrainingDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/ResourcesTrainingStepDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/SchoolClassDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/StatisticalAnalysisDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/StudentClientLinkDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/StudentDao.java
Unescape Escape View File

@ -10,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -19,8 +19,8 @@ import java.util.Map;
/**
* Student Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.student")
public interface StudentDao extends BaseMapper<Student>{
PageQuery queryByConditionQuery(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentDefenceLogDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* StudentDefenceLog Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentDefenceLog")
public interface StudentDefenceLogDao extends BaseMapper<StudentDefenceLog>{
PageQuery<StudentDefenceLog> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentDefenceLogInfoDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* StudentDefenceLogInfo Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentDefenceLogInfo")
public interface StudentDefenceLogInfoDao extends BaseMapper<StudentDefenceLogInfo>{
PageQuery<StudentDefenceLogInfo> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentDefenceLogNoteDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/StudentDirectMessagesDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* StudentDirectMessages Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentDirectMessages")
public interface StudentDirectMessagesDao extends BaseMapper<StudentDirectMessages>{
PageQuery<StudentDirectMessages> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentHandsOnTaskPptDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -14,8 +14,8 @@ import java.util.Map;
/**
* 学生-课程实操ppt Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentHandsOnTaskPpt")
public interface StudentHandsOnTaskPptDao extends BaseMapper<StudentHandsOnTaskPpt>{
PageQuery<StudentHandsOnTaskPpt> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentHandsOnTaskReportDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -14,8 +14,8 @@ import java.util.Map;
/**
* 学生-课程实操-报告撰写 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentHandsOnTaskReport")
public interface StudentHandsOnTaskReportDao extends BaseMapper<StudentHandsOnTaskReport>{
PageQuery<StudentHandsOnTaskReport> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentHandsOnTaskStepDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -14,8 +14,8 @@ import java.util.Map;
/**
* 学生-课程实操实训操作步骤 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentHandsOnTaskStep")
public interface StudentHandsOnTaskStepDao extends BaseMapper<StudentHandsOnTaskStep>{
PageQuery<StudentHandsOnTaskStep> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentHandsOnTaskTheoryDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -14,8 +14,8 @@ import java.util.Map;
/**
* 学生-课程实操理论 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentHandsOnTaskTheory")
public interface StudentHandsOnTaskTheoryDao extends BaseMapper<StudentHandsOnTaskTheory>{
PageQuery<StudentHandsOnTaskTheory> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentHandsOnTaskVideoDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -14,8 +14,8 @@ import java.util.Map;
/**
* 学生-课程实操视频 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentHandsOnTaskVideo")
public interface StudentHandsOnTaskVideoDao extends BaseMapper<StudentHandsOnTaskVideo>{
PageQuery<StudentHandsOnTaskVideo> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentMergeApplicationDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 学生关联应用-排序 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentMergeApplication")
public interface StudentMergeApplicationDao extends BaseMapper<StudentMergeApplication>{
PageQuery<StudentMergeApplication> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentQuestionLogAnswerDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/StudentQuestionLogDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* StudentQuestionLog Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentQuestionLog")
public interface StudentQuestionLogDao extends BaseMapper<StudentQuestionLog>{
PageQuery<StudentQuestionLog> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/StudentQuestionLogInfoDao.java
Unescape Escape View File

@ -5,14 +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;
import org.springframework.stereotype.Repository;
/**
* StudentQuestionLogInfo Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.studentQuestionLogInfo")
public interface StudentQuestionLogInfoDao extends BaseMapper<StudentQuestionLogInfo>{
PageQuery<StudentQuestionLogInfo> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/SysLogDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherDao.java
Unescape Escape View File

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

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherMergeApplicationDao.java
Unescape Escape View File

@ -7,7 +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 org.springframework.stereotype.Repository;
import javax.validation.constraints.NotNull;
import java.util.List;
@ -15,8 +15,8 @@ import java.util.List;
/**
* 教师关联应用 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherMergeApplication")
public interface TeacherMergeApplicationDao extends BaseMapper<TeacherMergeApplication>{
PageQuery<TeacherMergeApplication> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseChatLogDao.java
Unescape Escape View File

@ -7,15 +7,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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 开课互动 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseChatLog")
public interface TeacherOpenCourseChatLogDao extends BaseMapper<TeacherOpenCourseChatLog>{
PageQuery<TeacherOpenCourseChatLog> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseDao.java
Unescape Escape View File

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

7
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseHandsOnDao.java
Unescape Escape View File

@ -2,13 +2,12 @@ package com.ibeetl.jlw.dao;
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.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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -16,8 +15,8 @@ import java.util.Map;
/**
* 教师开课-课程实操 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseHandsOn")
public interface TeacherOpenCourseHandsOnDao extends BaseMapper<TeacherOpenCourseHandsOn>{
PageQuery<TeacherOpenCourseHandsOn> queryByCondition(PageQuery query);

18
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseHandsOnSimulationTasksAssessmentDao.java
Unescape Escape View File

@ -1,22 +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.TeacherOpenCourseHandsOnSimulationTasksAssessment;
import com.ibeetl.jlw.web.query.TeacherOpenCourseHandsOnSimulationTasksAssessmentQuery;
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.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.stereotype.Repository;
import java.util.List;
/**
* 教师开课-课程实操-实训任务考核题目 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseHandsOnSimulationTasksAssessment")
public interface TeacherOpenCourseHandsOnSimulationTasksAssessmentDao extends BaseMapper<TeacherOpenCourseHandsOnSimulationTasksAssessment>{
PageQuery<TeacherOpenCourseHandsOnSimulationTasksAssessment> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseHandsOnSimulationTasksDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 教师开课-课程实操任务 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseHandsOnSimulationTasks")
public interface TeacherOpenCourseHandsOnSimulationTasksDao extends BaseMapper<TeacherOpenCourseHandsOnSimulationTasks>{
PageQuery<TeacherOpenCourseHandsOnSimulationTasks> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseHandsOnSimulationTasksFileDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 教师开课-课程实操任务附件 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseHandsOnSimulationTasksFile")
public interface TeacherOpenCourseHandsOnSimulationTasksFileDao extends BaseMapper<TeacherOpenCourseHandsOnSimulationTasksFile>{
PageQuery<TeacherOpenCourseHandsOnSimulationTasksFile> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseKnowledgePointDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 知识点 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseKnowledgePoint")
public interface TeacherOpenCourseKnowledgePointDao extends BaseMapper<TeacherOpenCourseKnowledgePoint>{
PageQuery<TeacherOpenCourseKnowledgePoint> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseKnowledgePointRelationDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 知识点关联 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseKnowledgePointRelation")
public interface TeacherOpenCourseKnowledgePointRelationDao extends BaseMapper<TeacherOpenCourseKnowledgePointRelation>{
PageQuery<TeacherOpenCourseKnowledgePointRelation> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseMergeCourseInfoDao.java
Unescape Escape View File

@ -9,7 +9,7 @@ import org.beetl.sql.mapper.BaseMapper;
import org.beetl.sql.mapper.annotation.SqlResource;
import org.beetl.sql.mapper.annotation.Update;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Repository;
import javax.validation.constraints.NotNull;
import java.util.List;
@ -18,8 +18,8 @@ import java.util.Map;
/**
* 开课课程拉取 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseMergeCourseInfo")
public interface TeacherOpenCourseMergeCourseInfoDao extends BaseMapper<TeacherOpenCourseMergeCourseInfo>{

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseMergeResourcesInfoDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -14,8 +14,8 @@ import java.util.Map;
/**
* 开课资源拉取 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseMergeResourcesInfo")
public interface TeacherOpenCourseMergeResourcesInfoDao extends BaseMapper<TeacherOpenCourseMergeResourcesInfo>{
PageQuery<TeacherOpenCourseMergeResourcesInfo> queryByCondition(PageQuery query);

2
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseMergeResourcesQuestionDao.java
Unescape Escape View File

@ -18,7 +18,7 @@ import java.util.Map;
/**
* 开课题目拉取 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Component
@Validated
@SqlResource("jlw.teacherOpenCourseMergeResourcesQuestion")

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseMergeScheduleSessionDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import javax.validation.constraints.NotNull;
import java.util.List;
@ -15,8 +15,8 @@ import java.util.Map;
/**
* 开课关联排课配置 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseMergeScheduleSession")
public interface TeacherOpenCourseMergeScheduleSessionDao extends BaseMapper<TeacherOpenCourseMergeScheduleSession>{
PageQuery<TeacherOpenCourseMergeScheduleSession> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseMergeSchoolClassDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 开课关联班级 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseMergeSchoolClass")
public interface TeacherOpenCourseMergeSchoolClassDao extends BaseMapper<TeacherOpenCourseMergeSchoolClass>{
PageQuery<TeacherOpenCourseMergeSchoolClass> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseMergeStudentDao.java
Unescape Escape View File

@ -8,7 +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 org.springframework.stereotype.Repository;
import javax.validation.constraints.NotNull;
import java.util.List;
@ -16,8 +16,8 @@ import java.util.List;
/**
* 开课关联学生 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseMergeStudent")
public interface TeacherOpenCourseMergeStudentDao extends BaseMapper<TeacherOpenCourseMergeStudent>{
PageQuery<TeacherOpenCourseMergeStudent> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseMergeTeacherDao.java
Unescape Escape View File

@ -7,7 +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 org.springframework.stereotype.Repository;
import javax.validation.constraints.NotNull;
import java.util.List;
@ -16,8 +16,8 @@ import java.util.List;
/**
* 课程开课关联教师 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseMergeTeacher")
public interface TeacherOpenCourseMergeTeacherDao extends BaseMapper<TeacherOpenCourseMergeTeacher>{
PageQuery<TeacherOpenCourseMergeTeacher> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseNoticeDao.java
Unescape Escape View File

@ -7,15 +7,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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 通知公告 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseNotice")
public interface TeacherOpenCourseNoticeDao extends BaseMapper<TeacherOpenCourseNotice>{
PageQuery<TeacherOpenCourseNotice> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseQuestionLogDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 题目日志 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseQuestionLog")
public interface TeacherOpenCourseQuestionLogDao extends BaseMapper<TeacherOpenCourseQuestionLog>{
PageQuery<TeacherOpenCourseQuestionLog> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseQuestionLogWrongDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -14,8 +14,8 @@ import java.util.Map;
/**
* 错题集 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseQuestionLogWrong")
public interface TeacherOpenCourseQuestionLogWrongDao extends BaseMapper<TeacherOpenCourseQuestionLogWrong>{
PageQuery<TeacherOpenCourseQuestionLogWrong> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseQuestionSettingDao.java
Unescape Escape View File

@ -6,15 +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 org.springframework.stereotype.Repository;
import java.util.List;
/**
* 题目配置 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseQuestionSetting")
public interface TeacherOpenCourseQuestionSettingDao extends BaseMapper<TeacherOpenCourseQuestionSetting>{
PageQuery<TeacherOpenCourseQuestionSetting> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseScheduleSessionClassDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
@ -14,8 +14,8 @@ import java.util.List;
/**
* 排课教室 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseScheduleSessionClass")
public interface TeacherOpenCourseScheduleSessionClassDao extends BaseMapper<TeacherOpenCourseScheduleSessionClass>{
PageQuery<TeacherOpenCourseScheduleSessionClass> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseScheduleSessionDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -15,8 +15,8 @@ import java.util.Map;
/**
* 新增排课 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseScheduleSession")
public
interface TeacherOpenCourseScheduleSessionDao extends BaseMapper<TeacherOpenCourseScheduleSession>{

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseScheduleSessionSnapDao.java
Unescape Escape View File

@ -7,7 +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 org.springframework.stereotype.Repository;
import javax.validation.constraints.NotNull;
import java.util.Collection;
@ -16,8 +16,8 @@ import java.util.List;
/**
* 课表快照 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseScheduleSessionSnap")
public interface TeacherOpenCourseScheduleSessionSnapDao extends BaseMapper<TeacherOpenCourseScheduleSessionSnap>{
PageQuery<TeacherOpenCourseScheduleSessionSnap> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseScheduleSessionTagDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
@ -14,8 +14,8 @@ import java.util.List;
/**
* 课次 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseScheduleSessionTag")
public interface TeacherOpenCourseScheduleSessionTagDao extends BaseMapper<TeacherOpenCourseScheduleSessionTag>{
PageQuery<TeacherOpenCourseScheduleSessionTag> queryByCondition(PageQuery query);

6
web/src/main/java/com/ibeetl/jlw/dao/TeacherOpenCourseScoreDashboardDao.java
Unescape Escape View File

@ -6,7 +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 org.springframework.stereotype.Repository;
import java.util.List;
import java.util.Map;
@ -14,8 +14,8 @@ import java.util.Map;
/**
* 成绩 Dao
*/
// 实际可以不用加Component注解，调用的地方注入时候，Idea会报红，看着难受
@Component
// 实际可以不用加Repository注解，调用的地方注入时候，Idea会报红，看着难受
@Repository
@SqlResource("jlw.teacherOpenCourseScoreDashboard")
public interface TeacherOpenCourseScoreDashboardDao extends BaseMapper<TeacherOpenCourseScoreDashboard>{
PageQuery<TeacherOpenCourseScoreDashboard> queryByCondition(PageQuery query);

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

Write Preview
Loading…
Cancel
Save