会员卡办理、预约基础内容完成

master
xiaoning 3 weeks ago
parent 1d913c9a4f
commit 13c4681610

@ -3,7 +3,7 @@ package cn.xluobo.business.report.analysis.controller;
import cn.xluobo.business.report.analysis.domain.resp.RespMonthCourseOrderFee;
import cn.xluobo.business.report.analysis.service.AnalysisReportService;
import cn.xluobo.business.sc.order.domain.req.ReqReportMonthCourseIncome;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@ -1,98 +0,0 @@
package cn.xluobo.business.report.dashboard.service;
import cn.xluobo.business.report.dashboard.domain.resp.DashboardData;
import cn.xluobo.business.sc.course.domain.req.time.ReqClaTimeCount;
import cn.xluobo.business.sc.course.repo.enums.ClaTimeAttendStatusEnums;
import cn.xluobo.business.sc.course.repo.model.ScCourse;
import cn.xluobo.business.sc.course.repo.model.ScCourseCla;
import cn.xluobo.business.sc.course.service.IScClaTimeAttendService;
import cn.xluobo.business.sc.course.service.IScClaTimeService;
import cn.xluobo.business.sc.course.service.IScCourseClaService;
import cn.xluobo.business.sc.course.service.IScCourseService;
import cn.xluobo.business.sc.order.enums.OrderTypeEnum;
import cn.xluobo.business.sc.order.service.IScOrderService;
import cn.xluobo.business.sc.student.repo.model.ScStudent;
import cn.xluobo.business.sc.student.service.IScStudentCourseService;
import cn.xluobo.business.sc.student.service.IScStudentService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.utils.SecurityUtils;
import org.joda.time.DateTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
/**
* @author zhangbaoyu
* @date Created in 2020/10/18 15:34
*/
@Service
@Transactional
public class DashboardService {
@Autowired
private IScCourseClaService claService;
@Autowired
private IScCourseService courseService;
@Autowired
private IScStudentService studentService;
@Autowired
private IScClaTimeAttendService attendService;
@Autowired
private IScOrderService orderService;
@Autowired
private IScClaTimeService claTimeService;
@Autowired
private IScStudentCourseService studentCourseService;
/**
*
*
* @return
*/
public DashboardData dashboardData() {
String todayDate = DateTime.now().toString("yyyy-MM-dd");
String thisMonthBegin = DateTime.now().withDayOfMonth(1).toString("yyyy-MM-dd");
String thisMonthEnd = DateTime.now().plusMonths(1).withDayOfMonth(1).minusDays(1).toString("yyyy-MM-dd");
String tenantId=SecurityUtils.getLoginUser().getNowTenantId();
int claCnt = claService.count(new QueryWrapper<ScCourseCla>().eq("tenant_id",tenantId));
int courseCnt = courseService.count(new QueryWrapper<ScCourse>().eq("tenant_id",tenantId));
int studentCnt = studentService.count(new QueryWrapper<ScStudent>().eq("tenant_id",tenantId));
ReqClaTimeCount reqClaTimeCount = ReqClaTimeCount.builder().beginDate(todayDate).endDate(todayDate).hadBegin(null).tenantId(tenantId).build();
Integer todayClaTimeCnt = claTimeService.claTimeCount(reqClaTimeCount);
reqClaTimeCount.setHadBegin(true);
Integer completeTodayClaTimeCnt = claTimeService.claTimeCount(reqClaTimeCount);
Integer todayOrderCnt = orderService.orderCount(todayDate, todayDate, OrderTypeEnum.SIGN_UP.getOrderType());
Integer thisMonthOrderCnt = orderService.orderCount(thisMonthBegin, thisMonthEnd, OrderTypeEnum.SIGN_UP.getOrderType());
Integer todayNeedAttendCnt = attendService.getNeedAttendCount(todayDate, todayDate);
Integer todayRealAttendCnt = attendService.getAttendCount(todayDate, todayDate,
new String[]{ClaTimeAttendStatusEnums.AT_CLASS.getAttendStatus()});
BigDecimal todayNeedCostHour = attendService.getAttendCostHour(todayDate, todayDate, true);
BigDecimal todayRealCostHour = attendService.getAttendCostHour(todayDate, todayDate, false);
Integer arrearsStudentCnt = orderService.arrearsStudentCount();
Integer dateWillExpireCnt = studentCourseService.getWillExpireDateCount(10);
Integer hourWillExpireCnt = studentCourseService.getWillExpireHourCount(5);
return DashboardData.builder()
.todayClaTimeCnt(todayClaTimeCnt)
.completeTodayClaTimeCnt(completeTodayClaTimeCnt)
.todayOrderCnt(todayOrderCnt)
.thisMonthOrderCnt(thisMonthOrderCnt)
.todayRealAttendCnt(todayRealAttendCnt)
.todayNeedAttendCnt(todayNeedAttendCnt)
.todayNeedCostHour(todayNeedCostHour)
.todayRealCostHour(todayRealCostHour)
.studentCnt(studentCnt)
.claCnt(claCnt)
.courseCnt(courseCnt)
.arrearsStudentCnt(arrearsStudentCnt)
.dateWillExpireCnt(dateWillExpireCnt)
.hourWillExpireCnt(hourWillExpireCnt)
.build();
}
}

@ -1,93 +0,0 @@
package cn.xluobo.business.sc.course.controller;
import cn.xluobo.business.sc.course.domain.req.ReqSearchScCourseType;
import cn.xluobo.business.sc.course.repo.model.ScCourseType;
import cn.xluobo.business.sc.course.service.BusinessScCourseTypeService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
/**
* <p>
* Controller
* </p>
*
* @author zhangby
* @since 2020-07-09 08:10:25
*/
@RestController
@RequestMapping("/api/sc/course/type")
public class ScCourseTypeController {
@Autowired
private BusinessScCourseTypeService scCourseTypeService;
/**
*
*
* @param reqSearchScCourseType
* @return
*/
@GetMapping("/list/searchList")
public APIResponse searchList(ReqSearchScCourseType reqSearchScCourseType) {
return scCourseTypeService.searchList(reqSearchScCourseType);
}
/**
* select
*
* @param reqSearchScCourseType
* @return
*/
@GetMapping("/list/select")
public APIResponse select(ReqSearchScCourseType reqSearchScCourseType) {
return scCourseTypeService.select(reqSearchScCourseType);
}
/**
*
*
* @param courseTypeId
* @return
*/
@GetMapping("/info/detailById/{courseTypeId}")
public APIResponse detailById(@PathVariable("courseTypeId") Long courseTypeId) {
return scCourseTypeService.detailById(courseTypeId);
}
/**
*
*
* @param scCourseType
* @return
*/
@PostMapping("/add/addScCourseType")
public APIResponse addScCourseType(@RequestBody ScCourseType scCourseType) {
LoginUser loginUser = SecurityUtils.getLoginUser();
scCourseType.setTenantId(loginUser.getNowTenantId());
return scCourseTypeService.addScCourseType(scCourseType);
}
/**
*
*
* @param scCourseType
* @return
*/
@PutMapping("/update/updateScCourseType")
public APIResponse updateScCourseType(@RequestBody ScCourseType scCourseType) {
return scCourseTypeService.updateScCourseType(scCourseType);
}
/**
*
*
* @param courseTypeIds
* @return
*/
@DeleteMapping("/delete/deleteById/{courseTypeIds}")
public APIResponse deleteById(@PathVariable("courseTypeIds") Long[] courseTypeIds) {
return scCourseTypeService.deleteById(courseTypeIds);
}
}

@ -0,0 +1,13 @@
package cn.xluobo.business.sc.course.domain.req;
import lombok.Data;
import java.math.BigDecimal;
@Data
public class ReqAddMemberChargeItem{
private Long courseTypeId;//课程类型
private BigDecimal cnt;//扣课时次数
private BigDecimal totalFee;//扣费金额
}

@ -1,160 +0,0 @@
package cn.xluobo.business.sc.course.domain.req.course;
import cn.xluobo.core.api.APIBaseResponse;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;
import java.math.BigDecimal;
import java.util.List;
/**
*
*
* @author zhangbaoyu
* @date Created in 2020/7/8 20:34
*/
@Data
public class ReqAddScCourse {
/**
*
*/
private String courseName;
/**
*
*/
private Long courseTypeId;
/**
*
*/
private String teachingMode;
/**
*
*/
private String courseIntro;
/**
* all part
*/
private String courseCampus;
/**
*
*/
private String[] partCampus;
/**
*
*/
private boolean feeModeHour;
/**
*
*/
private boolean feeModeDate;
/**
*
*/
private boolean feeModeCycle;
/**
*
*/
private BigDecimal claFee;
private List<ReqAddScCourseChargeItem> feeModeHourList;
private List<ReqAddScCourseChargeItem> feeModeDateList;
private List<ReqAddScCourseChargeItem> feeModeCycleList;
/**
*
*
* @return
*/
public APIBaseResponse checkParam() {
if (StringUtils.isEmpty(courseName)) {
return APIBaseResponse.fail("请输入课程名称");
} else if (StringUtils.isEmpty(teachingMode)) {
return APIBaseResponse.fail("请选择教学模式");
}
if (StringUtils.isEmpty(courseCampus)) {
return APIBaseResponse.fail("请选择上课校区");
}
if ("部分校区".equals(courseCampus) && null == partCampus) {
return APIBaseResponse.fail("请选择上课校区");
}
if ("部分校区".equals(courseCampus) && partCampus.length == 0) {
return APIBaseResponse.fail("请选择上课校区");
}
if (!feeModeHour && !feeModeDate && !feeModeCycle) {
return APIBaseResponse.fail("请配置收费模式");
}
if (feeModeHour && (null == feeModeHourList || feeModeHourList.isEmpty())) {
return APIBaseResponse.fail("请配置课时收费模式");
}
if (feeModeDate && (null == feeModeDateList || feeModeDateList.isEmpty())) {
return APIBaseResponse.fail("请配置时间收费模式");
}
if (feeModeCycle && (null == feeModeCycleList || feeModeCycleList.isEmpty())) {
return APIBaseResponse.fail("请配置周期收费模式");
}
BigDecimal zero = BigDecimal.ZERO;
if (feeModeHour) {
for (ReqAddScCourseChargeItem item : feeModeHourList) {
BigDecimal cnt = item.getCnt();
BigDecimal totalFee = item.getTotalFee();
String campusName = item.getCampusName();
if(null == cnt || cnt.compareTo(zero)==0){
return APIBaseResponse.fail("请填写"+campusName+"按课时收费 数量");
}
if(null == totalFee || totalFee.compareTo(zero)==0){
return APIBaseResponse.fail("请填写"+campusName+"按课时收费 金额");
}
}
}
if (feeModeDate) {
for (ReqAddScCourseChargeItem item : feeModeDateList) {
BigDecimal cnt = item.getCnt();
BigDecimal totalFee = item.getTotalFee();
String dateType = item.getDateType();
String campusName = item.getCampusName();
if(null == cnt || cnt.compareTo(zero)==0){
return APIBaseResponse.fail("请填写"+campusName+"按时间收费 数量");
}
if(null == totalFee || totalFee.compareTo(zero)==0){
return APIBaseResponse.fail("请填写"+campusName+"按时间收费 金额");
}
if(StringUtils.isEmpty(dateType)){
return APIBaseResponse.fail("请填写"+campusName+"按时间收费 时间段");
}
}
}
if(feeModeCycle) {
for (ReqAddScCourseChargeItem item : feeModeCycleList) {
BigDecimal cnt = item.getCnt();
BigDecimal totalFee = item.getTotalFee();
String campusName = item.getCampusName();
if(null == cnt || cnt.compareTo(zero)==0){
return APIBaseResponse.fail("请填写"+campusName+"按期收费 数量");
}
if(null == totalFee || totalFee.compareTo(zero)==0){
return APIBaseResponse.fail("请填写"+campusName+"按期收费 金额");
}
}
}
return APIBaseResponse.success();
}
}

@ -1,7 +1,7 @@
package cn.xluobo.business.sc.course.domain.resp;
import lombok.Data;
import com.ruoyi.school.course.domain.resp.course.RespBusinessCourseInfo;
import java.io.Serializable;
import java.util.List;

@ -1,6 +1,6 @@
package cn.xluobo.business.sc.course.domain.resp;
import cn.xluobo.business.sc.student.repo.model.ScStudent;
import com.ruoyi.school.member.domain.ScStudent;
import lombok.Data;
import java.io.Serializable;

@ -1,16 +0,0 @@
package cn.xluobo.business.sc.course.repo.mapper;
import cn.xluobo.business.sc.course.repo.model.ScCourseCharge;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* Mapper
* </p>
*
* @author zhangby
* @since 2020-07-08
*/
public interface ScCourseChargeMapper extends BaseMapper<ScCourseCharge> {
}

@ -1,127 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.xluobo.business.sc.course.repo.mapper.ScCourseMapper">
<select id="selectCourseList" resultType="cn.xluobo.business.sc.course.domain.resp.course.RespSearchCourse">
select a.course_id,a.course_name,
a.course_type_id,
b.course_type as course_type_name,a.teaching_mode,
(select count(1) from sc_course_cla cc where a.course_id=cc.course_id) as cla_count,
(select group_concat(distinct charge.charge_type) from sc_course_charge charge where a.course_id=charge.course_id) as charge_names,
(select group_concat(distinct charge.depart_id) from sc_course_charge charge where a.course_id=charge.course_id) as campus_ids,
a.create_time,
a.sale,
a.course_intro,
a.cla_fee
from sc_course a
left join sc_course_type b on a.course_type_id = b.course_type_id and b.in_use='1'
where a.delete_flag='0' and a.tenant_id=#{reqSearchScCourse.tenantId}
<if test="reqSearchScCourse.courseName != null and reqSearchScCourse.courseName != ''">
and a.course_name like concat('%',#{reqSearchScCourse.courseName} ,'%')
</if>
<if test="reqSearchScCourse.sale != null and reqSearchScCourse.sale != ''">
and a.sale = #{reqSearchScCourse.sale}
</if>
<if test="reqSearchScCourse.courseTypeId != null and reqSearchScCourse.courseTypeId != ''">
and a.course_type_id = #{reqSearchScCourse.courseTypeId}
</if>
<if test="reqSearchScCourse.teachingMode != null and reqSearchScCourse.teachingMode != ''">
and a.teaching_mode = #{reqSearchScCourse.teachingMode}
</if>
<if test="reqSearchScCourse.departId != null">
and exists(select 1 from sc_course_charge c where a.course_id=c.course_id and (c.depart_id=#{reqSearchScCourse.departId} or c.depart_id=-1))
</if>
<if test="reqSearchScCourse.chargeType != null and reqSearchScCourse.chargeType != ''">
and exists(select 1 from sc_course_charge c where a.course_id=c.course_id and c.charge_type=#{reqSearchScCourse.chargeType} )
</if>
order by a.sale desc,a.create_time desc
</select>
<select id="selectCourseListWithStudentCourse" resultType="cn.xluobo.business.sc.course.domain.resp.course.RespSearchCourse">
select a.course_id,a.course_name,b.course_type as course_type_name,a.teaching_mode,
(select count(1) from sc_course_cla cc where a.course_id=cc.course_id) as cla_count,
(select group_concat(distinct charge.charge_type) from sc_course_charge charge where a.course_id=charge.course_id) as charge_names,
(select group_concat(distinct charge.depart_id) from sc_course_charge charge where a.course_id=charge.course_id) as campus_ids,
a.create_time,
a.sale,
a.course_intro,
c.student_course_id
from sc_course a
left join sc_course_type b on a.course_type_id = b.course_type_id and b.in_use='1'
left join sc_student_course c on a.course_id=c.course_id and c.student_id = #{reqSearchScCourse.studentId}
where a.delete_flag='0' and a.tenant_id=#{tenantId}
<if test="reqSearchScCourse.courseName != null and reqSearchScCourse.courseName != ''">
and a.course_name like concat('%',#{reqSearchScCourse.courseName} ,'%')
</if>
<if test="reqSearchScCourse.sale != null and reqSearchScCourse.sale != ''">
and a.sale = #{reqSearchScCourse.sale}
</if>
<if test="reqSearchScCourse.courseTypeId != null and reqSearchScCourse.courseTypeId != ''">
and a.course_type_id = #{reqSearchScCourse.courseTypeId}
</if>
<if test="reqSearchScCourse.teachingMode != null and reqSearchScCourse.teachingMode != ''">
and a.teaching_mode = #{reqSearchScCourse.teachingMode}
</if>
<if test="reqSearchScCourse.departId != null">
and exists(select 1 from sc_course_charge c where a.course_id=c.course_id and (c.depart_id=#{reqSearchScCourse.departId} or c.depart_id=-1))
</if>
<if test="reqSearchScCourse.chargeType != null and reqSearchScCourse.chargeType != ''">
and exists(select 1 from sc_course_charge c where a.course_id=c.course_id and c.charge_type=#{reqSearchScCourse.chargeType} )
</if>
order by a.sale desc,a.create_time desc
</select>
<select id="selectCourseForExport" resultType="cn.xluobo.business.sc.course.domain.export.ExpCourse">
select a.course_id,
b.charge_id,
a.course_name,
(select t.course_type from sc_course_type t where t.course_type_id=a.course_type_id) course_type_name,
fcn_dict_name(a.teaching_mode,'teaching_mode') as teaching_mode,
a.create_time,
fcn_dict_name(a.sale,'sale') as sale,
a.course_intro,
case b.depart_id when -1 then '全部校区' else (select t.dept_name from sys_dept t where t.dept_id=b.depart_id) end depart_name,
b.charge_type,fcn_dict_name(b.charge_type,'charge_type') as charge_type_name,
b.date_unit,
fcn_dict_name(b.date_unit,'date_unit') as date_unit_name,
b.count,b.total_fee
from sc_course a,sc_course_charge b
where a.course_id=b.course_id and a.delete_flag='0'
<if test="reqSearchScCourse.courseName != null and reqSearchScCourse.courseName != ''">
and a.course_name like concat('%',#{reqSearchScCourse.courseName} ,'%')
</if>
<if test="reqSearchScCourse.sale != null and reqSearchScCourse.sale != ''">
and a.sale = #{reqSearchScCourse.sale}
</if>
<if test="reqSearchScCourse.courseTypeId != null and reqSearchScCourse.courseTypeId != ''">
and a.course_type_id = #{reqSearchScCourse.courseTypeId}
</if>
<if test="reqSearchScCourse.teachingMode != null and reqSearchScCourse.teachingMode != ''">
and a.teaching_mode = #{reqSearchScCourse.teachingMode}
</if>
<if test="reqSearchScCourse.departId != null">
and b.depart_id=#{reqSearchScCourse.departId}
</if>
<if test="reqSearchScCourse.chargeType != null and reqSearchScCourse.chargeType != ''">
and b.charge_type=#{reqSearchScCourse.chargeType}
</if>
order by a.sale desc,a.create_time desc limit 2000
</select>
<select id="selectCourseCount" resultType="java.lang.Integer">
select count(1) from sc_course a
where 1=1
<if test="deptId != null">
and exists(select 1 from sc_course_charge b where a.course_id=b.course_id and (b.depart_id=#{deptId} or b.depart_id=-1))
</if>
<if test="deptId == null and userId != null and userId != ''">
and (
exists(select 1 from sc_course_charge b,sys_user_dept ud
where ud.user_id=#{userId}
and (ud.dept_id=b.depart_id or ud.dept_id=-1)
and a.course_id=b.course_id)
or exists(select 1 from sc_course_charge b where a.course_id=b.course_id and b.depart_id=-1)
)
</if>
</select>
<select id="selectTenantCourseCount" resultType="java.lang.Integer">
select count(1) from sc_course where tenant_id=#{tenantId}
</select>
</mapper>

@ -1,544 +0,0 @@
package cn.xluobo.business.sc.course.service;
import cn.xluobo.business.sc.course.domain.export.ExpCourse;
import cn.xluobo.business.sc.course.domain.req.ReqBusinessOrderCourseDetail;
import cn.xluobo.business.sc.course.domain.req.ReqSearchScCourse;
import cn.xluobo.business.sc.course.domain.req.ReqSelect;
import cn.xluobo.business.sc.course.domain.req.course.ReqAddScCourse;
import cn.xluobo.business.sc.course.domain.req.course.ReqAddScCourseChargeItem;
import cn.xluobo.business.sc.course.domain.req.course.ReqChangeScCourse;
import cn.xluobo.business.sc.course.domain.resp.RespBusinessChooseCourseCharge;
import cn.xluobo.business.sc.course.domain.resp.RespBusinessChooseCourseInfo;
import cn.xluobo.business.sc.course.domain.resp.course.RespScCourseDetail;
import cn.xluobo.business.sc.course.domain.resp.course.RespSearchCourse;
import cn.xluobo.business.sc.course.repo.mapper.ScCourseMapper;
import cn.xluobo.business.sc.course.repo.model.ScCourse;
import cn.xluobo.business.sc.course.repo.model.ScCourseCharge;
import cn.xluobo.business.sc.course.repo.model.ScCourseCla;
import cn.xluobo.business.sc.course.repo.model.ScCourseType;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import cn.xluobo.business.sc.student.service.IScStudentCourseService;
import cn.xluobo.business.sys.admin.domain.resp.RespTreeSelect;
import cn.xluobo.business.sys.admin.service.BusinessSysDeptService;
import cn.xluobo.business.sys.admin.service.BusinessSysDictDataService;
import cn.xluobo.business.sys.admin.service.ISysDeptService;
import cn.xluobo.business.tool.export.strategy.CourseExportMergeStrategy;
import cn.xluobo.config.properties.UploadConfigProperties;
import cn.xluobo.core.api.APIBaseResponse;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import com.alibaba.excel.EasyExcel;
import com.alibaba.excel.write.style.column.LongestMatchColumnWidthStyleStrategy;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.*;
import java.util.stream.Collectors;
/**
* @author zhangbaoyu
* @date Created in 2020-01-14 17:24
*/
@Service
@Transactional
public class BusinessScCourseService {
@Autowired
private IScCourseService scCourseService;
@Autowired
private IScCourseClaService courseClaService;
@Autowired
private ScCourseMapper courseMapper;
@Autowired
private IScCourseChargeService courseChargeService;
@Autowired
private BusinessSysDeptService deptService;
@Autowired
private ISysDeptService sysDeptService;
@Autowired
private UploadConfigProperties uploadConfigProperties;
@Autowired
private BusinessSysDictDataService dictDataService;
@Autowired
private IScStudentCourseService studentCourseService;
@Autowired
private IScCourseTypeService courseTypeService;
/**
*
*
* @param reqSearchScCourse
* @return
*/
public APIResponse searchList(ReqSearchScCourse reqSearchScCourse) {
RespPage<RespSearchCourse> searchCourseRespPage = scCourseService.searchCourse(reqSearchScCourse);
return APIResponse.toAPIResponse(searchCourseRespPage);
}
/**
*
*
*
* @param reqSearchScCourse
* @return
*/
public APIResponse selectCourseListWithStudentCourse(ReqSearchScCourse reqSearchScCourse) {
RespPage respPage = new RespPage(reqSearchScCourse.getPageNum(), reqSearchScCourse.getPageSize());
List<RespSearchCourse> courseList = courseMapper.selectCourseListWithStudentCourse(reqSearchScCourse, respPage,SecurityUtils.getLoginUser().getNowTenantId());
respPage.setRows(courseList);
return APIResponse.toAPIResponse(respPage);
}
/**
* select
*
* @return
*/
public APIResponse select(ReqSelect reqSelect) {
QueryWrapper qw = new QueryWrapper();
qw.select("course_name", "course_id");
if (StringUtils.isNotEmpty(reqSelect.getSearch())) {
qw.like("course_name", reqSelect.getSearch());
}
qw.eq("tenant_id", SecurityUtils.getLoginUser().getNowTenantId());
qw.orderByDesc("create_time");
List<ScCourse> list = scCourseService.list(qw);
return APIResponse.toAPIResponse(list);
}
/**
*
*
* @param courseId
* @return
*/
public APIResponse detailById(Long courseId) {
if (null == courseId) {
return APIResponse.toAPIResponse(ApiResEnums.PARAM_FAIL);
}
// 课程详情
ScCourse detailInfo = scCourseService.getById(courseId);
RespScCourseDetail respScCourseDetail = new RespScCourseDetail();
respScCourseDetail.setCourseId(detailInfo.getCourseId()+"");
respScCourseDetail.setCourseName(detailInfo.getCourseName());
respScCourseDetail.setCourseTypeId(detailInfo.getCourseTypeId());
respScCourseDetail.setTeachingMode(detailInfo.getTeachingMode());
respScCourseDetail.setCourseIntro(detailInfo.getCourseIntro());
respScCourseDetail.setClaFee(detailInfo.getClaFee());
respScCourseDetail.setCourseCampus("部分校区");
respScCourseDetail.setPartCampus(new String[]{});
if(null != detailInfo.getCourseTypeId()) {
ScCourseType courseType = courseTypeService.getById(detailInfo.getCourseTypeId());
Optional.ofNullable(courseType).ifPresent(item->{
respScCourseDetail.setCourseTypeName(item.getCourseType());
});
}
List<ReqAddScCourseChargeItem> feeModeHourList = Lists.newArrayList();
List<ReqAddScCourseChargeItem> feeModeDateList = Lists.newArrayList();
List<ReqAddScCourseChargeItem> feeModeCycleList = Lists.newArrayList();
// 上课校区
List<String> partCampusList = Lists.newArrayList();
// 所有校区id 对应名称 map
Map<Long, String> campusMap = Maps.newHashMap();
List<RespTreeSelect> campusList = deptService.campusList();
for (RespTreeSelect respTreeSelect : campusList) {
campusMap.put(respTreeSelect.getId(), respTreeSelect.getLabel());
}
campusMap.put(-1L, "全部校区");
// 课程收费配置信息
QueryWrapper<ScCourseCharge> qw = new QueryWrapper<>();
qw.eq("course_id", detailInfo.getCourseId());
List<ScCourseCharge> courseChargeList = courseChargeService.list(qw);
for (ScCourseCharge courseCharge : courseChargeList) {
ReqAddScCourseChargeItem chargeItem = new ReqAddScCourseChargeItem();
Long departId = courseCharge.getDepartId();
if (!partCampusList.contains(departId.toString()) && departId.compareTo(-1L) != 0) {
partCampusList.add(departId.toString());
}
String chargeType = courseCharge.getChargeType();
chargeItem.setChargeId(courseCharge.getChargeId()+"");
chargeItem.setCampusId(courseCharge.getDepartId());
chargeItem.setCampusName(campusMap.get(courseCharge.getDepartId()));
if ("hour".equals(chargeType)) {
chargeItem.setCnt(courseCharge.getCount());
chargeItem.setTotalFee(courseCharge.getTotalFee());
feeModeHourList.add(chargeItem);
} else if ("date".equals(chargeType)) {
chargeItem.setCnt(courseCharge.getCount());
chargeItem.setTotalFee(courseCharge.getTotalFee());
chargeItem.setDateType(courseCharge.getDateUnit());
feeModeDateList.add(chargeItem);
} else if ("cycle".equals(chargeType)) {
chargeItem.setCnt(courseCharge.getCount());
chargeItem.setTotalFee(courseCharge.getTotalFee());
feeModeCycleList.add(chargeItem);
}
}
// 上课校区 所有或部分校区
if (partCampusList.size() == 0) {
respScCourseDetail.setCourseCampus("全部校区");
} else {
respScCourseDetail.setCourseCampus("部分校区");
respScCourseDetail.setPartCampus(partCampusList.toArray(new String[partCampusList.size()]));
}
respScCourseDetail.setFeeModeHourList(feeModeHourList);
respScCourseDetail.setFeeModeDateList(feeModeDateList);
respScCourseDetail.setFeeModeCycleList(feeModeCycleList);
if (!feeModeHourList.isEmpty()) {
respScCourseDetail.setFeeModeHour(true);
}
if (!feeModeDateList.isEmpty()) {
respScCourseDetail.setFeeModeDate(true);
}
if (!feeModeCycleList.isEmpty()) {
respScCourseDetail.setFeeModeCycle(true);
}
return APIResponse.toAPIResponse(respScCourseDetail);
}
/**
*
*
* @param reqAddScCourse
* @return
*/
public APIResponse addScCourse(ReqAddScCourse reqAddScCourse) {
APIBaseResponse checkParam = reqAddScCourse.checkParam();
if (!checkParam.isSuccess()) {
return APIResponse.toExceptionResponse(checkParam.getRespMsg());
}
LoginUser loginUser = SecurityUtils.getLoginUser();
// course 表保存
ScCourse scCourse = new ScCourse();
scCourse.setCourseName(reqAddScCourse.getCourseName());
scCourse.setCourseTypeId(reqAddScCourse.getCourseTypeId());
scCourse.setTeachingMode(reqAddScCourse.getTeachingMode());
scCourse.setCourseIntro(reqAddScCourse.getCourseIntro());
scCourse.setCreateUser(loginUser.getUserId());
scCourse.setLastUpdateUser(loginUser.getUserId());
scCourse.setTenantId(loginUser.getNowTenantId());
scCourse.setClaFee(reqAddScCourse.getClaFee());
boolean addScCourse = scCourseService.save(scCourse);
// course_charge保存
// 按课时收费
if (reqAddScCourse.isFeeModeHour()) {
List<ReqAddScCourseChargeItem> feeModeHourList = reqAddScCourse.getFeeModeHourList();
feeModeHourList.forEach(item -> {
ScCourseCharge courseCharge = new ScCourseCharge();
courseCharge.setCourseId(scCourse.getCourseId());
courseCharge.setDepartId(item.getCampusId());
courseCharge.setChargeType("hour");
courseCharge.setCount(item.getCnt());
courseCharge.setTotalFee(item.getTotalFee());
courseChargeService.save(courseCharge);
});
}
// 按时间收费
if (reqAddScCourse.isFeeModeDate()) {
List<ReqAddScCourseChargeItem> feeModeDateList = reqAddScCourse.getFeeModeDateList();
feeModeDateList.forEach(item -> {
ScCourseCharge courseCharge = new ScCourseCharge();
courseCharge.setCourseId(scCourse.getCourseId());
courseCharge.setDepartId(item.getCampusId());
courseCharge.setChargeType("date");
courseCharge.setCount(item.getCnt());
courseCharge.setTotalFee(item.getTotalFee());
courseCharge.setDateUnit(item.getDateType());
courseChargeService.save(courseCharge);
});
}
// 按期收费
if (reqAddScCourse.isFeeModeCycle()) {
List<ReqAddScCourseChargeItem> feeModeCycleList = reqAddScCourse.getFeeModeCycleList();
feeModeCycleList.forEach(item -> {
ScCourseCharge courseCharge = new ScCourseCharge();
courseCharge.setCourseId(scCourse.getCourseId());
courseCharge.setDepartId(item.getCampusId());
courseCharge.setChargeType("cycle");
courseCharge.setCount(item.getCnt());
courseCharge.setTotalFee(item.getTotalFee());
courseChargeService.save(courseCharge);
});
}
return APIResponse.toOkResponse();
}
/**
*
*
* @param reqChangeScCourse
* @return
*/
public APIResponse updateScCourse(ReqChangeScCourse reqChangeScCourse) {
APIBaseResponse checkParam = reqChangeScCourse.checkParam();
if (!checkParam.isSuccess()) {
return APIResponse.toExceptionResponse(checkParam.getRespMsg());
}
LoginUser loginUser = SecurityUtils.getLoginUser();
// 更新课程信息
ScCourse updateCourse = new ScCourse();
updateCourse.setCourseId(reqChangeScCourse.getCourseId());
updateCourse.setCourseName(reqChangeScCourse.getCourseName());
updateCourse.setCourseTypeId(reqChangeScCourse.getCourseTypeId());
updateCourse.setTeachingMode(reqChangeScCourse.getTeachingMode());
updateCourse.setCourseIntro(reqChangeScCourse.getCourseIntro());
updateCourse.setClaFee(reqChangeScCourse.getClaFee());
updateCourse.setLastUpdateUser(loginUser.getUserId());
updateCourse.setLastUpdateTime(new Date());
updateCourse.setTenantId(loginUser.getNowTenantId());
updateCourse.setSale("1");
updateCourse.setImportId(-1L);
boolean updateScCourse = scCourseService.updateById(updateCourse);
// course_charge 删除
UpdateWrapper uw = new UpdateWrapper();
uw.eq("course_id", updateCourse.getCourseId());
courseChargeService.remove(uw);
// course_charge 新增
// 按课时收费
if (reqChangeScCourse.isFeeModeHour()) {
List<ReqAddScCourseChargeItem> feeModeHourList = reqChangeScCourse.getFeeModeHourList();
feeModeHourList.forEach(item -> {
ScCourseCharge courseCharge = new ScCourseCharge();
courseCharge.setCourseId(updateCourse.getCourseId());
courseCharge.setDepartId(item.getCampusId());
courseCharge.setChargeType("hour");
courseCharge.setCount(item.getCnt());
courseCharge.setTotalFee(item.getTotalFee());
courseChargeService.save(courseCharge);
});
}
// 按时间收费
if (reqChangeScCourse.isFeeModeDate()) {
List<ReqAddScCourseChargeItem> feeModeDateList = reqChangeScCourse.getFeeModeDateList();
feeModeDateList.forEach(item -> {
ScCourseCharge courseCharge = new ScCourseCharge();
courseCharge.setCourseId(updateCourse.getCourseId());
courseCharge.setDepartId(item.getCampusId());
courseCharge.setChargeType("date");
courseCharge.setCount(item.getCnt());
courseCharge.setTotalFee(item.getTotalFee());
courseCharge.setDateUnit(item.getDateType());
courseChargeService.save(courseCharge);
});
}
// 按期收费
if (reqChangeScCourse.isFeeModeCycle()) {
List<ReqAddScCourseChargeItem> feeModeCycleList = reqChangeScCourse.getFeeModeCycleList();
feeModeCycleList.forEach(item -> {
ScCourseCharge courseCharge = new ScCourseCharge();
courseCharge.setCourseId(updateCourse.getCourseId());
courseCharge.setDepartId(item.getCampusId());
courseCharge.setChargeType("cycle");
courseCharge.setCount(item.getCnt());
courseCharge.setTotalFee(item.getTotalFee());
courseChargeService.save(courseCharge);
});
}
return APIResponse.toOkResponse();
}
/**
*
*
* @param courseIds
* @return
*/
public APIResponse deleteById(List<Long> courseIds) {
if (null == courseIds || courseIds.isEmpty()) {
return APIResponse.toExceptionResponse(ApiResEnums.FAIL_WAIT_A_MINUTE);
}
// 如课程对应在用班级,不允许删除
QueryWrapper<ScCourseCla> qw = new QueryWrapper<>();
qw.in("course_id", courseIds);
int courseClaCount = courseClaService.count(qw);
if (courseClaCount != 0) {
return APIResponse.toExceptionResponse("该课程下存在在用班级,无法删除课程");
}
// 有报读记录 不允许删除
QueryWrapper<ScStudentCourse> qwSc = new QueryWrapper<>();
qwSc.in("course_id", courseIds);
int studentCourseCount = studentCourseService.count(qwSc);
if (studentCourseCount != 0) {
return APIResponse.toExceptionResponse("该课程已报读,无法删除课程");
}
boolean deleteScCourse = scCourseService.removeByIds(courseIds);
if (deleteScCourse) {
return APIResponse.toOkResponse();
} else {
return APIResponse.toExceptionResponse(ApiResEnums.FAIL_WAIT_A_MINUTE);
}
}
/**
*
*
* @param scCourse
* @return
*/
public APIResponse changeCourseSale(ScCourse scCourse) {
if (null == scCourse.getCourseId()) {
return APIResponse.toExceptionResponse(ApiResEnums.FAIL_WAIT_A_MINUTE);
}
if (StringUtils.isEmpty(scCourse.getSale())) {
return APIResponse.toExceptionResponse(ApiResEnums.FAIL_WAIT_A_MINUTE);
}
UpdateWrapper uw = new UpdateWrapper();
uw.set("sale", scCourse.getSale());
uw.eq("course_id", scCourse.getCourseId());
boolean updateScCourse = scCourseService.update(uw);
if (updateScCourse) {
return APIResponse.toOkResponse();
} else {
return APIResponse.toExceptionResponse(ApiResEnums.FAIL_WAIT_A_MINUTE);
}
}
/**
*
*
* @param reqSearchScCourse
* @return
*/
public APIResponse exportCourse(ReqSearchScCourse reqSearchScCourse) {
try {
List<ExpCourse> courseList = courseMapper.selectCourseForExport(reqSearchScCourse);
String fileName = "exportCourse_" + System.currentTimeMillis() + UUID.randomUUID().toString();
String fullPath = uploadConfigProperties.getTempSaveExportPath() + "/" + fileName + ".xlsx";
CourseExportMergeStrategy<ExpCourse> mergeStrategy = new CourseExportMergeStrategy<>(courseList, 0, 6);
EasyExcel.write(fullPath, ExpCourse.class)
.registerWriteHandler(mergeStrategy)
.registerWriteHandler(new LongestMatchColumnWidthStyleStrategy())
.sheet("课程列表").doWrite(courseList);
return APIResponse.toAPIResponse(fileName);
} catch (Exception e) {
return APIResponse.toExceptionResponse("下载文件失败" + e.getMessage());
}
}
/**
* -
*
* @param orderCourseDetail
* @return
*/
public APIResponse orderCourseDetail(ReqBusinessOrderCourseDetail orderCourseDetail) {
Long[] courseIds = orderCourseDetail.getCourseIds();
Long deptId = orderCourseDetail.getDeptId();
Long studentId = orderCourseDetail.getStudentId();
if (null == courseIds || courseIds.length == 0) {
return APIResponse.toExceptionResponse("请选择课程");
}
if (null == deptId) {
return APIResponse.toExceptionResponse("请选择校区");
}
// 校验学生是否可报读 课程
APIBaseResponse studentCanSignUpCourse = studentCourseService.checkStudentCanSignUpCourse(studentId, courseIds, deptId);
if (!studentCanSignUpCourse.isSuccess()) {
return APIResponse.toExceptionResponse(studentCanSignUpCourse.getRespMsg());
}
// 学生已报名课程收费模式
Map<Long, String> studentCourseChargeTypeMap = Maps.newHashMap();
if (null != studentId) {
QueryWrapper qw = new QueryWrapper();
qw.select("course_id", "charge_type");
qw.eq("student_id", studentId);
List<ScStudentCourse> studentCourseList = studentCourseService.list(qw);
studentCourseChargeTypeMap = studentCourseList.stream().collect(Collectors.toMap(ScStudentCourse::getCourseId, ScStudentCourse::getChargeType));
}
// 部门信息
SysDept sysDept = sysDeptService.getById(deptId);
List<RespBusinessChooseCourseInfo> courseInfoList = Lists.newArrayList();
for (Long courseId : courseIds) {
ScCourse scCourse = scCourseService.getById(courseId);
if (null == scCourse) {
continue;
}
RespBusinessChooseCourseInfo chooseCourseInfo = RespBusinessChooseCourseInfo.builder()
.courseId(scCourse.getCourseId())
.courseName(scCourse.getCourseName())
.deptId(sysDept.getDeptId())
.deptName(sysDept.getDeptName())
.teachingMode(scCourse.getTeachingMode())
.build();
// 已报读的 收费方式
String studentCourseChargeType = studentCourseChargeTypeMap.get(courseId);
// 转换对象
List<RespBusinessChooseCourseCharge> chooseCourseChargeList = courseChargeService.courseChargeList(courseId, studentCourseChargeType);
chooseCourseInfo.setCourseChargeList(chooseCourseChargeList);
// 是否为续报
chooseCourseInfo.setContinueCourse(StringUtils.isNotEmpty(studentCourseChargeType));
courseInfoList.add(chooseCourseInfo);
}
return APIResponse.toAPIResponse(courseInfoList);
}
/**
*
*
* @param orderCourseDetail
* @return
*/
public APIResponse studentCanSignUpCourse(ReqBusinessOrderCourseDetail orderCourseDetail) {
Long[] courseIds = orderCourseDetail.getCourseIds();
Long studentId = orderCourseDetail.getStudentId();
if (null == studentId) {
return APIResponse.toExceptionResponse("studentId 不能为空");
}
if (null == courseIds || courseIds.length == 0) {
return APIResponse.toOkResponse();
}
APIBaseResponse studentCanSignUpCourse = studentCourseService.checkStudentCanSignUpCourse(studentId, courseIds, null);
if (!studentCanSignUpCourse.isSuccess()) {
return APIResponse.toExceptionResponse(studentCanSignUpCourse.getRespMsg());
}
return APIResponse.toOkResponse();
}
}

@ -1,56 +0,0 @@
package cn.xluobo.business.sc.course.service.impl;
import cn.xluobo.business.sc.course.repo.enums.ClaTimeStatusEnums;
import cn.xluobo.business.sc.course.repo.mapper.ScCourseClaMapper;
import cn.xluobo.business.sc.course.repo.model.ScClaTime;
import cn.xluobo.business.sc.course.repo.model.ScCourseCla;
import cn.xluobo.business.sc.course.service.IScClaTimeService;
import cn.xluobo.business.sc.course.service.IScCourseClaService;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import cn.xluobo.business.sc.student.service.IScStudentCourseService;
import cn.xluobo.core.api.APIBaseResponse;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-03-17 01:11:06
*/
@Service
public class ScCourseClaServiceImpl extends ServiceImpl<ScCourseClaMapper, ScCourseCla> implements IScCourseClaService {
@Autowired
private IScStudentCourseService studentCourseService;
@Autowired
private IScClaTimeService claTimeService;
@Override
public Integer selectStudentCnt(Long claId) {
return baseMapper.selectStudentCnt(claId);
}
@Override
public APIBaseResponse canChangeCourse(Long claId) {
QueryWrapper<ScStudentCourse> qw = new QueryWrapper<>();
qw.eq("cla_id", claId);
int count = studentCourseService.count(qw);
if (count != 0) {
return APIBaseResponse.fail("当前班级有报读学员,无法变更所属课程.");
}
QueryWrapper<ScClaTime> qwClaTime = new QueryWrapper<>();
qwClaTime.eq("cla_id", claId);
qwClaTime.eq("status", ClaTimeStatusEnums.HAD_CLASS.getStatus());
int hadClaTimeCount = claTimeService.count(qwClaTime);
if (hadClaTimeCount != 0) {
return APIBaseResponse.fail("当前班级已有上课记录,无法变更所属课程.");
}
return APIBaseResponse.success();
}
}

@ -2,7 +2,7 @@ package cn.xluobo.business.sc.log.controller;
import cn.xluobo.business.sc.log.domain.req.ReqSearchStuCourseLog;
import cn.xluobo.business.sc.log.service.BusinessScStudentCourseLogService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@ -3,7 +3,7 @@ package cn.xluobo.business.sc.log.service;
import cn.xluobo.business.sc.log.domain.req.ReqSearchStuCourseLog;
import cn.xluobo.business.sc.log.repo.mapper.ScStudentCourseLogMapper;
import cn.xluobo.business.sc.log.repo.model.ScStudentCourseLog;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import cn.xluobo.core.page.RespPage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;

@ -1,6 +1,6 @@
package cn.xluobo.business.sc.order.domain.req;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;

@ -1,28 +0,0 @@
package cn.xluobo.business.sc.order.repo.mapper;
import cn.xluobo.business.sc.order.domain.req.ReqSearchScOrder;
import cn.xluobo.business.sc.order.domain.resp.RespOrder;
import cn.xluobo.business.sc.order.repo.model.ScOrder;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* Mapper
* </p>
*
* @author zhangby
* @since 2020-08-24 10:22:19
*/
public interface ScOrderMapper extends com.baomidou.mybatisplus.core.mapper.BaseMapper<ScOrder> {
List<RespOrder> selectFroSearchTable(@Param("reqSearchScOrder")ReqSearchScOrder reqSearchScOrder, @Param("page")Page page);
/**
*
* @return
*/
Integer selectArrearsStudentCount(@Param("tenantId") String tenantId);
}

@ -1,62 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.xluobo.business.sc.order.repo.mapper.ScOrderMapper">
<select id="selectFroSearchTable" resultType="cn.xluobo.business.sc.order.domain.resp.RespOrder">
select
a.order_id,a.order_type,a.actual_total_fee,a.receipt_fee,a.balance_fee,
(select s.nick_name from sys_user s where s.user_id=a.sale_staff_id) sale_staff_name,
a.order_tag,a.handle_dept_name,a.handle_date,
(select u.nick_name from sys_user u where user_id=a.create_user) as create_user_name,
a.memo,
b.student_name,b.phone,
(select group_concat(od.course_name,'(',d.dept_name,')',',',od.charge_name,' 数量:',od.buy_count separator ';') from sc_order_detail od left join sys_dept d on od.dept_id=d.dept_id where a.order_id=od.order_id) as order_detail,
a.order_status
from sc_order a
left join sc_student b on a.student_id=b.student_id
where 1=1
<if test="reqSearchScOrder.studentId != null">
and a.student_id = #{reqSearchScOrder.studentId}
</if>
<if test="reqSearchScOrder.handleDateBegin != null and reqSearchScOrder.handleDateBegin != ''">
and a.handle_date between #{reqSearchScOrder.handleDateBegin} and #{reqSearchScOrder.handleDateEnd}
</if>
<if test="reqSearchScOrder.arrears">
and actual_total_fee <![CDATA[ > ]]> balance_fee + receipt_fee
</if>
<if test="reqSearchScOrder.arrears != null and reqSearchScOrder.arrears == true">
and actual_total_fee <![CDATA[ > ]]> balance_fee + receipt_fee
</if>
<if test="reqSearchScOrder.arrears != null and reqSearchScOrder.arrears == false">
and actual_total_fee <![CDATA[ = ]]> balance_fee + receipt_fee
</if>
<if test="reqSearchScOrder.deptId != null">
and exists(select 1 from sc_order_detail d where a.order_id=d.order_id and d.dept_id=#{reqSearchScOrder.deptId} )
</if>
<if test="reqSearchScOrder.courseId != null">
and exists(select 1 from sc_order_detail d where a.order_id=d.order_id and d.course_id=#{reqSearchScOrder.courseId} )
</if>
<if test="reqSearchScOrder.saleStaffId != null">
and a.sale_staff_id = #{reqSearchScOrder.saleStaffId}
</if>
<if test="reqSearchScOrder.orderType != null and reqSearchScOrder.orderType != ''">
and a.order_type = #{reqSearchScOrder.orderType}
</if>
<if test="reqSearchScOrder.orderStatus != null and reqSearchScOrder.orderStatus != ''">
and a.order_status = #{reqSearchScOrder.orderStatus}
</if>
<if test="reqSearchScOrder.createUser != null">
and a.create_user = #{reqSearchScOrder.createUser}
</if>
<if test="reqSearchScOrder.saleSourceTag != null and reqSearchScOrder.saleSourceTag != ''">
and a.sale_source_tag = #{reqSearchScOrder.saleSourceTag}
</if>
order by a.create_time desc
</select>
<select id="selectArrearsStudentCount" resultType="java.lang.Integer">
select count(distinct o.student_id) from sc_order o
where o.order_status='2'
and o.tenant_id=#{tenantId}
and o.receipt_fee+o.balance_fee <![CDATA[ < ]]> o.actual_total_fee
</select>
</mapper>

@ -1,66 +1,39 @@
package cn.xluobo.business.sc.order.service;
import cn.xluobo.business.sc.course.enums.CourseChargeTypeEnum;
import cn.xluobo.business.sc.course.repo.model.ScCourse;
import cn.xluobo.business.sc.course.repo.model.ScCourseCharge;
import cn.xluobo.business.sc.course.repo.model.ScCourseCla;
import cn.xluobo.business.sc.course.service.IScClaTimeAttendService;
import cn.xluobo.business.sc.course.service.IScCourseChargeService;
import cn.xluobo.business.sc.course.service.IScCourseClaService;
import cn.xluobo.business.sc.course.service.IScCourseService;
import cn.xluobo.business.sc.log.enums.LogTypeEnum;
import cn.xluobo.business.sc.log.repo.model.ScStudentCourseLog;
import cn.xluobo.business.sc.log.service.IScStudentCourseLogService;
import cn.xluobo.business.sc.order.domain.req.ReqBusinessSignUp;
import cn.xluobo.business.sc.order.domain.req.ReqBusinessSignUpItem;
import cn.xluobo.business.sc.order.domain.req.ReqBusinessSignUpReceipt;
import cn.xluobo.business.sc.order.domain.req.ReqSearchScOrder;
import cn.xluobo.business.sc.order.domain.resp.RespOrder;
import cn.xluobo.business.sc.order.enums.OrderStatusEnum;
import cn.xluobo.business.sc.order.repo.mapper.ScOrderMapper;
import cn.xluobo.business.sc.order.repo.model.ScOrder;
import cn.xluobo.business.sc.order.repo.model.ScOrderAccount;
import cn.xluobo.business.sc.order.repo.model.ScOrderDetail;
import cn.xluobo.business.sc.salary.repo.model.ScCommissionPlans;
import cn.xluobo.business.sc.salary.service.ScCommissionPlansService;
import cn.xluobo.business.sc.student.repo.model.ScStudent;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder;
import cn.xluobo.business.sc.student.service.IScStudentAccountService;
import cn.xluobo.business.sc.student.service.IScStudentCourseOrderService;
import cn.xluobo.business.sc.student.service.IScStudentCourseService;
import cn.xluobo.business.sc.student.service.IScStudentService;
import cn.xluobo.business.sys.admin.service.ISysDeptService;
import cn.xluobo.business.sys.admin.service.ISysUserService;
import cn.xluobo.business.sys.receipt.repo.model.SysReceiptAccount;
import cn.xluobo.business.sys.receipt.service.ISysReceiptAccountService;
import cn.xluobo.business.sys.tag.service.ISysTagService;
import cn.xluobo.config.exception.BusinessException;
import cn.xluobo.core.api.APIBaseResponse;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import cn.xluobo.core.utils.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.google.common.collect.Maps;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import com.ruoyi.school.course.service.IScClaTimeAttendService;
import com.ruoyi.school.course.service.IScCourseChargeService;
import com.ruoyi.school.course.service.IScCourseClaService;
import com.ruoyi.school.course.service.IScCourseService;
import com.ruoyi.school.member.domain.resp.MemberCardVO;
import com.ruoyi.school.member.service.IScMemberCardService;
import com.ruoyi.school.order.domain.ScOrder;
import com.ruoyi.school.order.domain.req.ReqSearchScOrder;
import com.ruoyi.school.order.domain.resp.RespOrder;
import com.ruoyi.school.order.enums.OrderStatusEnum;
import com.ruoyi.school.order.mapper.ScOrderMapper;
import com.ruoyi.school.order.service.IScOrderService;
import com.ruoyi.school.salary.service.ScCommissionPlansService;
import com.ruoyi.school.student.service.IScStudentAccountService;
import com.ruoyi.school.student.service.IScStudentService;
import lombok.extern.slf4j.Slf4j;
import org.joda.time.DateTime;
import org.joda.time.Period;
import org.joda.time.PeriodType;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @author zhangbaoyu
@ -79,10 +52,7 @@ public class BusinessScOrderService {
private ISysReceiptAccountService receiptAccountService;
@Autowired
private IScOrderAccountService orderAccountService;
@Autowired
private IScStudentCourseService studentCourseService;
@Autowired
private IScStudentCourseOrderService courseOrderService;
@Autowired
private IScCourseService scCourseService;
@Autowired
@ -109,6 +79,11 @@ public class BusinessScOrderService {
@Autowired
private IScStudentCourseLogService scStudentCourseLogService;
@Autowired
private IScMemberCardService memberCardService;
@Autowired
private ISysReceiptAccountService accountService;
/**
*
*
@ -136,433 +111,19 @@ public class BusinessScOrderService {
// 订单信息
ScOrder order = scOrderService.getById(orderId);
// 经办人姓名
if (null != order.getCreateUser()) {
SysUser user = userService.getOne(new QueryWrapper<SysUser>().select("nick_name").eq("user_id",order.getCreateUser()));
order.setHandleStaffName(user.getNickName());
}
detailMap.put("orderInfo", order);
// 订单明细
List<ScOrderDetail> orderDetail = orderDetailService.getByOrderDetail(orderId);
detailMap.put("orderDetail", orderDetail);
// 会员卡详情
MemberCardVO memberCardVO=memberCardService.getByCardNo(order.getCardNo());
detailMap.put("orderDetail", memberCardVO);
// 收款账户
List<ScOrderAccount> orderAccountList = orderAccountService.getOrderAccountList(orderId);
detailMap.put("orderAccountList", orderAccountList);
SysReceiptAccount account = accountService.getById(order.getAccountId());
detailMap.put("orderAccount", account);
return APIResponse.toAPIResponse(detailMap);
}
/**
*
*
* @param reqBusinessSignUp
* @return
*/
public APIResponse signUp(ReqBusinessSignUp reqBusinessSignUp) {
LoginUser loginUser = SecurityUtils.getLoginUser();
//校验参数
APIResponse checkParam = reqBusinessSignUp.checkParam();
if (!checkParam.isSuccess()) {
return checkParam;
}
Long studentId = reqBusinessSignUp.getStudentId();
Long handleDepartId = reqBusinessSignUp.getHandleDepartId();
ScStudent student = studentService.getById(studentId);
if (null == student) {
return APIResponse.toExceptionResponse("无法获取学生信息,请重试!");
}
SysDept handleDept = deptService.getById(handleDepartId);
if (null == handleDept) {
return APIResponse.toExceptionResponse("无法获取经办校区信息,请重试!");
}
ScCommissionPlans commissionPlans= commissionPlansService.getById(reqBusinessSignUp.getCommissionPlansId());
if (null == commissionPlans) {
return APIResponse.toExceptionResponse("无法获取经佣金信息,请重试!");
}
BigDecimal reqReceiptWaySumMoney = reqBusinessSignUp.getReceiptWaySumMoney();
List<ReqBusinessSignUpReceipt> signUpReceiptList = reqBusinessSignUp.getSignUpReceiptList();
List<ReqBusinessSignUpItem> signUpItemList = reqBusinessSignUp.getSignUpItemList();
for (ReqBusinessSignUpItem signUpItem : signUpItemList) {
// 校验学生是否可报读 课程
APIBaseResponse studentCanSignUpCourse = studentCourseService.checkStudentCanSignUpCourse(studentId, signUpItem.getCourseId(), signUpItem.getDepartId(), null);
if (!studentCanSignUpCourse.isSuccess()) {
return APIResponse.toExceptionResponse(studentCanSignUpCourse.getRespMsg());
}
}
// 原价
BigDecimal originalTotalFee = BigDecimal.ZERO;
// 实际价格
BigDecimal actualTotalFee = BigDecimal.ZERO;
// 应收
BigDecimal needReceiptFee = BigDecimal.ZERO;
// 实收
BigDecimal receiptWaySumMoney = BigDecimal.ZERO;
// 计算实收
for (ReqBusinessSignUpReceipt signUpReceipt : signUpReceiptList) {
receiptWaySumMoney = receiptWaySumMoney.add(signUpReceipt.getReceiptMoney());
}
if (reqReceiptWaySumMoney.compareTo(receiptWaySumMoney) != 0) {
return APIResponse.toExceptionResponse("实收金额不一致,请重试");
}
// 课程信息、收费模式缓存
Map<Long, ScCourse> courseCacheMap = Maps.newHashMap();
Map<Long, ScCourseCharge> chargeCacheMap = Maps.newHashMap();
// 计算原价 实际价格 应收
for (ReqBusinessSignUpItem signUpItem : signUpItemList) {
Long courseId = signUpItem.getCourseId();
Long chargeId = signUpItem.getChargeId();
boolean openDiscount = signUpItem.isOpenDiscount();
boolean openDiscountFee = signUpItem.isOpenDiscountFee();
ScCourse scCourse = scCourseService.getById(courseId);
ScCourseCharge courseCharge = courseChargeService.getById(chargeId);
if (!signUpItem.getChargeType().equals(courseCharge.getChargeType())) {
throw new BusinessException(scCourse.getCourseName() + "收费方式不一致,请重试");
}
courseCacheMap.put(courseId, scCourse);
chargeCacheMap.put(chargeId, courseCharge);
Integer buyCount = signUpItem.getBuyCount();
BigDecimal chargeTotalFee = courseCharge.getTotalFee();
BigDecimal courseOriginalTotalFee = chargeTotalFee.multiply(new BigDecimal(buyCount));
BigDecimal courseActualTotalFee = courseOriginalTotalFee;
// 折扣
if (openDiscount) {
// 实际价格= 实际价格 * 折扣(9.8/10)
courseActualTotalFee = courseActualTotalFee.multiply(signUpItem.getDiscount()).divide(new BigDecimal(10));
}
// 优惠金额
if (openDiscountFee) {
courseActualTotalFee = courseActualTotalFee.subtract(signUpItem.getDiscountFee());
}
// 原价
originalTotalFee = originalTotalFee.add(courseOriginalTotalFee);
actualTotalFee = actualTotalFee.add(courseActualTotalFee);
}
// 实收 = 应收 - 余额支付
needReceiptFee = actualTotalFee.subtract(reqBusinessSignUp.getBalancePayValue());
if (needReceiptFee.compareTo(reqBusinessSignUp.getNeedReceiptFee()) != 0) {
throw new BusinessException("应收金额不一致,请重试");
}
// 入 sc_order 表
Long orderId = null;
{
ScOrder order = ScOrder.builder()
.studentId(studentId)
.studentName(student.getStudentName())
.phone(student.getPhone())
.orderType("1")
.originalTotalFee(originalTotalFee)
.actualTotalFee(actualTotalFee)
.receiptFee(receiptWaySumMoney)
.balanceFee(reqBusinessSignUp.getBalancePayValue())
.orderStatus(OrderStatusEnum.HAD_PAY.getOrderStatus())
.memo(reqBusinessSignUp.getMemo())
.handleDeptId(handleDept.getDeptId())
.handleDeptName(handleDept.getDeptName())
.handleDate(reqBusinessSignUp.getHandleDate())
.createUser(loginUser.getUserId())
.lastUpdateUser(loginUser.getUserId())
.commissionPlansId(reqBusinessSignUp.getCommissionPlansId())
.build();
if (null != reqBusinessSignUp.getOrderTag()) {
order.setOrderTag(String.join(",", reqBusinessSignUp.getOrderTag()));
}
if (null != reqBusinessSignUp.getSaleSourceTag()) {
order.setSaleSourceTag(String.join(",", reqBusinessSignUp.getSaleSourceTag()));
}
if (null != reqBusinessSignUp.getSaleStaffId()) {
SysUser saleStaff = userService.getOne(new QueryWrapper<SysUser>().select("user_id","nick_name").eq("user_id",reqBusinessSignUp.getSaleStaffId()));
if (null == saleStaff) {
throw new BusinessException("无法获取销售员工信息");
}
order.setSaleStaffId(saleStaff.getUserId());
order.setSaleStaffName(saleStaff.getNickName());
}
order.setTenantId(SecurityUtils.getLoginUser().getNowTenantId());
scOrderService.save(order);
orderId = order.getOrderId();
log.info("save order success,orderId={}", orderId);
if (null != reqBusinessSignUp.getOrderTag()) {
tagService.autoCreateTag(reqBusinessSignUp.getOrderTag(), "2", loginUser.getNowTenantId(), loginUser.getUserId());
}
if (null != reqBusinessSignUp.getSaleSourceTag()) {
tagService.autoCreateTag(reqBusinessSignUp.getSaleSourceTag(), "1", loginUser.getNowTenantId(), loginUser.getUserId());
}
}
// 入sc_order_account
for (ReqBusinessSignUpReceipt signUpReceipt : signUpReceiptList) {
SysReceiptAccount receiptAccount = receiptAccountService.getById(signUpReceipt.getAccountId());
if (null == receiptAccount) {
throw new BusinessException("无法获取收款账户,请核查后重试!");
}
ScOrderAccount orderAccount = new ScOrderAccount();
orderAccount.setOrderId(orderId);
orderAccount.setAccountId(signUpReceipt.getAccountId());
orderAccount.setAccountName(receiptAccount.getAccountName());
orderAccount.setFee(signUpReceipt.getReceiptMoney());
orderAccountService.save(orderAccount);
}
// 报读课程
for (ReqBusinessSignUpItem signUpItem : signUpItemList) {
Long courseId = signUpItem.getCourseId();
Long departId = signUpItem.getDepartId();
Long claId = signUpItem.getClaId();
Long chargeId = signUpItem.getChargeId();
boolean openDiscount = signUpItem.isOpenDiscount();
boolean openDiscountFee = signUpItem.isOpenDiscountFee();
ScCourse scCourse = courseCacheMap.get(courseId);
ScCourseCla scCourseCla = new ScCourseCla();
if (null != claId) {
scCourseCla = courseClaService.getById(claId);
if (null == scCourseCla) {
throw new BusinessException("无法获取" + scCourse.getCourseName() + "对应的班级,请重试");
}
}
ScCourseCharge courseCharge = chargeCacheMap.get(chargeId);
if (!signUpItem.getChargeType().equals(courseCharge.getChargeType())) {
throw new BusinessException(scCourse.getCourseName() + "收费方式不一致,请重试");
}
Integer buyCount = signUpItem.getBuyCount();
BigDecimal chargeTotalFee = courseCharge.getTotalFee();
BigDecimal courseOriginalTotalFee = chargeTotalFee.multiply(new BigDecimal(buyCount));
BigDecimal courseActualTotalFee = courseOriginalTotalFee;
// 折扣
if (openDiscount) {
// 实际价格= 实际价格 * 折扣(9.8/10)
courseActualTotalFee = courseActualTotalFee.multiply(signUpItem.getDiscount()).divide(new BigDecimal(10));
}
// 优惠金额
if (openDiscountFee) {
courseActualTotalFee = courseActualTotalFee.subtract(signUpItem.getDiscountFee());
}
// 已报读本课程信息
ScStudentCourse dbStudentCourse = studentCourseService.selectByStudentIdCourseId(studentId, courseId);
BigDecimal addedHour = BigDecimal.ZERO;
int addedDays = 0;
if (CourseChargeTypeEnum.HOUR.getChargeType().equals(courseCharge.getChargeType())) {
// 新增课时
addedHour = courseCharge.getCount().multiply(new BigDecimal(buyCount));
} else if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
// 校验报读时间段是否重复
boolean checkDateCover = courseOrderService.checkDateCover(studentId, courseId, signUpItem.getBeginDate(), signUpItem.getEndDate());
if (checkDateCover) {
throw new BusinessException(scCourse.getCourseName() + "报读日期存在覆盖,请重新选择报读日期范围!");
}
// 新增天数
DateTime beginDate = DateUtil.yyyMMddDayBegin(signUpItem.getBeginDate());
DateTime endDate = DateUtil.yyyMMddDayBegin(signUpItem.getEndDate());
Period period = new Period(beginDate, endDate, PeriodType.days());
addedDays = period.getDays() + 1;
} else if (CourseChargeTypeEnum.CYCLE.getChargeType().equals(courseCharge.getChargeType())) {
// 新增课时
addedHour = courseCharge.getCount().multiply(new BigDecimal(buyCount));
}
// 插入 sc_order_detail
Long orderDetailId = null;
{
SysDept dept = deptService.getById(departId);
ScOrderDetail orderDetail = ScOrderDetail.builder()
.orderId(orderId)
.courseId(courseId)
.courseName(scCourse.getCourseName())
.claId(claId)
.claName(scCourseCla.getClaName())
.deptId(dept.getDeptId())
.deptName(dept.getDeptName())
.detailTag(signUpItem.getDetailTag())
.chargeName(courseCharge.getChargeName())
.chargeType(courseCharge.getChargeType())
.chargeCount(courseCharge.getCount())
.chargeFee(courseCharge.getTotalFee())
.dateUnit(courseCharge.getDateUnit())
.buyCount(new BigDecimal(buyCount))
.originalFee(courseOriginalTotalFee)
.actualFee(courseActualTotalFee)
.insideMemo(signUpItem.getInsideMemo())
.outsideMemo(signUpItem.getOutsideMemo())
.orderDetailStatus(OrderStatusEnum.HAD_PAY.getOrderStatus())
.createUser(loginUser.getUserId())
.lastUpdateUser(loginUser.getUserId())
.build();
if (openDiscount) {
orderDetail.setDirectDiscount(signUpItem.getDiscount());
}
if (openDiscountFee) {
orderDetail.setDirectReduceFee(signUpItem.getDiscountFee());
}
if (signUpItem.isOpenExpire()) {
orderDetail.setExpireDate(signUpItem.getExpireDate());
}
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
orderDetail.setBeginDate(signUpItem.getBeginDate());
orderDetail.setEndDate(signUpItem.getEndDate());
}
orderDetailService.save(orderDetail);
orderDetailId = orderDetail.getOrderDetailId();
}
// 插入/更新 sc_student_course表
Long studentCourseId = null;
{
// db中包含
if (null != dbStudentCourse) {
UpdateWrapper<ScStudentCourse> uw = new UpdateWrapper<>();
uw.eq("student_course_id", dbStudentCourse.getStudentCourseId());
uw.eq("total_fee", dbStudentCourse.getTotalFee());
if (CourseChargeTypeEnum.HOUR.getChargeType().equals(courseCharge.getChargeType())) {
uw.eq("balance_hour", dbStudentCourse.getBalanceHour());
uw.eq("total_hour", dbStudentCourse.getTotalHour());
uw.set("balance_hour", dbStudentCourse.getBalanceHour().add(addedHour));
uw.set("total_hour", dbStudentCourse.getTotalHour().add(addedHour));
} else if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
uw.eq("total_day", dbStudentCourse.getTotalDay());
uw.set("total_day", dbStudentCourse.getTotalDay().add(new BigDecimal(addedDays)));
} else if (CourseChargeTypeEnum.CYCLE.getChargeType().equals(courseCharge.getChargeType())) {
uw.eq("balance_hour", dbStudentCourse.getBalanceHour());
uw.eq("total_hour", dbStudentCourse.getTotalHour());
uw.set("balance_hour", dbStudentCourse.getBalanceHour().add(addedHour));
uw.set("total_hour", dbStudentCourse.getTotalHour().add(addedHour));
}
uw.set("total_fee", dbStudentCourse.getTotalFee().add(courseActualTotalFee));
uw.set("last_update_user", loginUser.getUserId());
uw.set("last_update_time", new Date());
boolean update = studentCourseService.update(uw);
if (!update) {
throw new BusinessException("学员新增课时失败,请稍后重试");
}
studentCourseId = dbStudentCourse.getStudentCourseId();
} else {
ScStudentCourse addStudentCourse = new ScStudentCourse();
addStudentCourse.setStudentId(studentId);
addStudentCourse.setCourseId(courseId);
addStudentCourse.setCourseName(scCourse.getCourseName());
addStudentCourse.setDeptId(departId);
if (null != claId) {
addStudentCourse.setClaId(scCourseCla.getClaId());
addStudentCourse.setClaName(scCourseCla.getClaName());
}
addStudentCourse.setChargeType(courseCharge.getChargeType());
if (CourseChargeTypeEnum.HOUR.getChargeType().equals(courseCharge.getChargeType())) {
addStudentCourse.setTotalHour(addedHour);
addStudentCourse.setBalanceHour(addedHour);
} else if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
addStudentCourse.setTotalDay(new BigDecimal(addedDays));
} else if (CourseChargeTypeEnum.CYCLE.getChargeType().equals(courseCharge.getChargeType())) {
addStudentCourse.setTotalHour(addedHour);
addStudentCourse.setBalanceHour(addedHour);
}
addStudentCourse.setTotalFee(courseActualTotalFee);
addStudentCourse.setStatus("1");
addStudentCourse.setCreateUser(loginUser.getUserId());
addStudentCourse.setLastUpdateUser(loginUser.getUserId());
addStudentCourse.setTenantId(SecurityUtils.getLoginUser().getNowTenantId());
studentCourseService.save(addStudentCourse);
studentCourseId = addStudentCourse.getStudentCourseId();
}
}
// 插入sc_student_course_order
{
ScStudentCourseOrder studentCourseOrder = ScStudentCourseOrder.builder()
.studentCourseId(studentCourseId)
.orderId(orderId)
.orderDetailId(orderDetailId)
.totalHour(addedHour)
.balanceHour(addedHour)
.totalDay(new BigDecimal(addedDays))
.totalFee(courseActualTotalFee)
.createUser(loginUser.getUserId())
.lastUpdateUser(loginUser.getUserId())
.build();
if (signUpItem.isOpenExpire()) {
studentCourseOrder.setExpireDate(signUpItem.getExpireDate());
}
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
studentCourseOrder.setBeginDate(signUpItem.getBeginDate());
studentCourseOrder.setEndDate(signUpItem.getEndDate());
// 单价 = 总价/天
studentCourseOrder.setUnitFee(courseActualTotalFee.divide(new BigDecimal(addedDays), 2, BigDecimal.ROUND_HALF_UP));
} else {
// 单价 = 总价/课时数
studentCourseOrder.setUnitFee(courseActualTotalFee.divide(addedHour, 2, BigDecimal.ROUND_HALF_UP));
}
courseOrderService.save(studentCourseOrder);
}
// 学生报读 日志
StringBuffer sb = new StringBuffer("");
if ("1".equals(signUpItem.getDetailTag())) {
sb.append("新报,");
} else if ("2".equals(signUpItem.getDetailTag())) {
sb.append("续报,");
}
sb.append("课程'").append(scCourse.getCourseName()).append("',");
sb.append("金额").append(courseActualTotalFee.toString()).append("元,");
ScStudentCourseLog studentCourseLog = ScStudentCourseLog.builder()
.studentId(studentId)
.logType(LogTypeEnum.PAY_FEE.getLogType())
.courseId(courseId)
.courseName(scCourse.getCourseName())
.claId(claId)
.claName(scCourseCla.getClaName())
.deptName(handleDept.getDeptName())
.changeFee(courseActualTotalFee)
.createUser(loginUser.getUserId())
.createUserName(loginUser.getUsername())
.createTime(new Date())
.build();
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
sb.append("增加'").append(addedDays).append("'天");
sb.append("(").append(signUpItem.getBeginDate()).append("~").append(signUpItem.getEndDate()).append(").");
} else {
sb.append("增加'").append(addedHour.toString()).append("'课时,");
studentCourseLog.setChangeHour(addedHour);
// 增加后剩余
if (null != dbStudentCourse) {
studentCourseLog.setAfterBalanceHour(dbStudentCourse.getBalanceHour().add(addedHour));
sb.append("增加后剩余").append(dbStudentCourse.getBalanceHour().add(addedHour).toString()).append("'课时").append(".");
} else {
studentCourseLog.setAfterBalanceHour(addedHour);
sb.append("增加后剩余").append(addedHour.toString()).append("'课时").append(".");
}
}
studentCourseLog.setMemo(sb.toString());
scStudentCourseLogService.save(studentCourseLog);
}
// 实收 > 应收, 增加 学生账户余额
if (receiptWaySumMoney.compareTo(needReceiptFee) > 0) {
BigDecimal addBalanceFee = receiptWaySumMoney.subtract(needReceiptFee);
studentAccountService.addBalance(studentId, addBalanceFee, loginUser.getUserId());
}
return APIResponse.toOkResponse();
}
/**
*
@ -570,6 +131,7 @@ public class BusinessScOrderService {
* @param orderIds
* @return
*/
@Transactional
public APIResponse invalidById(Long[] orderIds) {
if (null == orderIds || orderIds.length == 0) {
return APIResponse.toExceptionResponse(ApiResEnums.FAIL_WAIT_A_MINUTE);
@ -595,163 +157,36 @@ public class BusinessScOrderService {
dealFailCnt++;
continue;
}
// 所有未作废的订单明细
List<ScOrderDetail> orderDetailList = orderDetailService.getByOrderDetail(orderId, new String[]{OrderStatusEnum.INVALID.getOrderStatus()});
// 订单明细map
Map<Long, ScOrderDetail> orderDetailMap = Maps.newHashMap();
for (ScOrderDetail orderDetail : orderDetailList) {
orderDetailMap.put(orderDetail.getOrderDetailId(), orderDetail);
}
// 所有关联的课程订单
List<Long> orderDetailIdList = orderDetailList.stream().map(ScOrderDetail::getOrderDetailId).collect(Collectors.toList());
QueryWrapper<ScStudentCourseOrder> qw = new QueryWrapper<>();
qw.eq("order_id", orderId);
qw.in("order_detail_id", orderDetailIdList);
List<ScStudentCourseOrder> courseOrderList = courseOrderService.list(qw);
// 校验 如果消耗课时 不允许作废
for (ScStudentCourseOrder courseOrder : courseOrderList) {
ScOrderDetail orderDetail = orderDetailMap.get(courseOrder.getOrderDetailId());
if (CourseChargeTypeEnum.DATE.getChargeType().equals(orderDetail.getChargeType())) {
String beginDate = courseOrder.getBeginDate();
String endDate = courseOrder.getEndDate();
Long studentCourseId = courseOrder.getStudentCourseId();
int studentCourseAttendCount = claTimeAttendService.studentCourseAttendCount(studentCourseId, beginDate, endDate);
if (0 != studentCourseAttendCount) {
// 订单日期范围内 有上课记录,不允许作废
ScStudentCourse studentCourse = studentCourseService.getById(studentCourseId);
ScCourse scCourse = scCourseService.getById(studentCourse.getCourseId());
errorSb.append("订单'").append(order.getOrderId()).append("',");
errorSb.append(scCourse.getCourseName()).append(",在").append(beginDate).append("~").append(endDate).append(",有上课记录(").append(studentCourseAttendCount).append("次),无发作废;");
// 相关会员卡
MemberCardVO memberCardVO=memberCardService.getByCardNo(order.getCardNo());
if(memberCardVO.getChargeType().equals("count") ){
if (memberCardVO.getTotalCount().compareTo(memberCardVO.getRemainingCount())!=0)
{ errorSb.append("订单'").append(orderId).append("',");
errorSb.append("订单中的会员卡已经开始使用,无法作废;");
dealFailCnt++;
continue;
}
} else {
if (null != courseOrder.getBalanceHour() && courseOrder.getBalanceHour().compareTo(courseOrder.getTotalHour()) < 0) {
// 按课时收费 并且 剩余课时<总课时 已消耗,不允许作废
ScStudentCourse studentCourse = studentCourseService.getById(courseOrder.getStudentCourseId());
ScCourse scCourse = scCourseService.getById(studentCourse.getCourseId());
errorSb.append("订单:").append(order.getOrderId()).append(",");
errorSb.append(scCourse.getCourseName()).append(",已消耗课时,无法作废;");
dealFailCnt++;
continue;
} else if (null != courseOrder.getBalanceHour() && courseOrder.getBalanceHour().compareTo(courseOrder.getTotalHour()) > 0) {
// 按课时收费 并且 剩余课时>总课时 删除上课记录 恢复课时后,剩余课时>总课时,不允许作废
ScStudentCourse studentCourse = studentCourseService.getById(courseOrder.getStudentCourseId());
ScCourse scCourse = scCourseService.getById(studentCourse.getCourseId());
errorSb.append("订单:").append(order.getOrderId()).append(",");
errorSb.append(scCourse.getCourseName()).append(",剩余课时大于总课时,无法作废");
}
if (memberCardVO.getChargeType().equals("days") ){
if (!memberCardVO.getTotalDays().equals(memberCardVO.getRemainingDays())){
errorSb.append("订单'").append(orderId).append("',");
errorSb.append("订单中的会员卡已经开始使用,无法作废;");
dealFailCnt++;
continue;
}
}
dealSuccessCnt++;
}
if(dealFailCnt != 0) {
return APIResponse.toExceptionResponse("操作失败,成功:" + dealSuccessCnt + ",失败:" + dealFailCnt + ",原因如下:" + errorSb.toString());
}
// 订单作废、订单明细作废
scOrderService.invalidOrder(orderId);
orderDetailService.invalidOrder(orderId, orderDetailIdList);
// 课程订单 失效、 剩余课时、时间 作废
for (ScStudentCourseOrder courseOrder : courseOrderList) {
// 课程订单 失效
UpdateWrapper<ScStudentCourseOrder> uw = new UpdateWrapper<>();
uw.eq("course_order_id", courseOrder.getCourseOrderId());
uw.set("valid", false);
courseOrderService.update(uw);
// 学生课程信息
ScStudentCourse studentCourse = studentCourseService.getById(courseOrder.getStudentCourseId());
ScOrderDetail orderDetail = orderDetailMap.get(courseOrder.getOrderDetailId());
// 收费方式
String chargeType = orderDetail.getChargeType();
// 实际价格
BigDecimal actualFee = orderDetail.getActualFee();
Long studentCourseId = courseOrder.getStudentCourseId();
BigDecimal totalDay = courseOrder.getTotalDay();
BigDecimal totalHour = courseOrder.getTotalHour();
// 学生日志
StringBuffer sb = new StringBuffer("作废订单,");
ScStudentCourseLog studentCourseLog = ScStudentCourseLog.builder()
.studentId(order.getStudentId())
.logType(LogTypeEnum.INVALID_ORDER.getLogType())
.courseId(orderDetail.getCourseId())
.courseName(orderDetail.getCourseName())
.claId(orderDetail.getClaId())
.claName(orderDetail.getClaName())
.deptName(orderDetail.getDeptName())
.changeFee(actualFee.negate())
.createUser(loginUser.getUserId())
.createUserName(loginUser.getUsername())
.createTime(new Date())
.build();
if (CourseChargeTypeEnum.DATE.getChargeType().equals(chargeType)) {
// 总天数 = 总天数 - 作废天数
// 总学费 = 总学费 - 作废学费
UpdateWrapper<ScStudentCourse> uwStudentCourse = new UpdateWrapper<>();
uwStudentCourse
.eq("student_course_id", studentCourseId)
.eq("total_day", studentCourse.getTotalDay())
.eq("total_fee", studentCourse.getTotalFee())
.eq("charge_type", "date")
.set("total_day", studentCourse.getTotalDay().subtract(totalDay))
.set("total_fee", studentCourse.getTotalFee().subtract(actualFee))
.set("last_update_user", loginUser.getUserId())
.set("last_update_time", new Date());
boolean update = studentCourseService.update(uwStudentCourse);
if (!update) {
throw new BusinessException("学员报读恢复失败,请重试!");
}
// 当总天数、总费用为0时删除报读
studentCourseService.deleteWhenTotalDayZeroForInvalid(studentCourseId);
sb.append("作废").append(totalDay.toString()).append("天,")
.append(actualFee.toString()).append("元");
} else {
// 剩余课时 = 剩余课时 - 作废课时
// 总学费 = 总学费 - 作废学费
UpdateWrapper<ScStudentCourse> uwStudentCourse = new UpdateWrapper<>();
uwStudentCourse
.eq("student_course_id", studentCourseId)
.eq("total_hour", studentCourse.getTotalHour())
.eq("balance_hour", studentCourse.getBalanceHour())
.eq("total_fee", studentCourse.getTotalFee())
.ne("charge_type", "date")
.set("total_hour", studentCourse.getTotalHour().subtract(totalHour))
.set("balance_hour", studentCourse.getBalanceHour().subtract(totalHour))
.set("total_fee", studentCourse.getTotalFee().subtract(actualFee))
.set("last_update_user", loginUser.getUserId())
.set("last_update_time", new Date());
boolean update = studentCourseService.update(uwStudentCourse);
if (!update) {
throw new BusinessException("学员报读恢复失败,请重试!");
}
// 当总课时、总费用为0时删除报读
studentCourseService.deleteWhenTotalHourZeroForInvalid(studentCourseId);
studentCourseLog.setChangeHour(totalHour.negate());
studentCourseLog.setAfterBalanceHour(studentCourse.getBalanceHour().subtract(totalHour));
sb.append("作废").append(totalHour.toString()).append("课时,")
.append(actualFee.toString()).append("元");
if (memberCardVO.getChargeType().equals("total_fee")){
if (memberCardVO.getTotalFee().compareTo(memberCardVO.getRemainingTotalFee())!=0){
errorSb.append("订单'").append(orderId).append("',");
errorSb.append("订单中的会员卡已经开始使用,无法作废;");
dealFailCnt++;
continue;
}
studentCourseLog.setMemo(sb.toString());
scStudentCourseLogService.save(studentCourseLog);
}
// // 订单作废
scOrderService.invalidOrder(orderId);
memberCardService.suspendCard(memberCardVO.getId());
}
if (dealFailCnt == 0) {

@ -1,6 +1,6 @@
package cn.xluobo.business.sc.order.service.impl;
import cn.xluobo.business.sc.order.enums.OrderStatusEnum;
import com.ruoyi.school.order.enums.OrderStatusEnum;
import cn.xluobo.business.sc.order.repo.mapper.ScOrderDetailMapper;
import cn.xluobo.business.sc.order.repo.model.ScOrderDetail;
import cn.xluobo.business.sc.order.service.IScOrderDetailService;

@ -1,119 +0,0 @@
package cn.xluobo.business.sc.student.controller;
import cn.xluobo.business.sc.student.domain.req.*;
import cn.xluobo.business.sc.student.domain.resp.RespCourseClaStudent;
import cn.xluobo.business.sc.student.domain.resp.RespStuCourseSignUpStudent;
import cn.xluobo.business.sc.student.domain.resp.RespStudentCourse;
import cn.xluobo.business.sc.student.service.BusinessScStudentCourseService;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.page.RespPage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
*
*
* @author zhangbaoyu
* @date Created in 2020/9/2 15:05
*/
@RestController
@RequestMapping("/api/sc/studentCourse")
public class ScStudentCourseController {
@Autowired
private BusinessScStudentCourseService studentCourseService;
/**
*
* @param studentId
* @return
*/
@GetMapping("/info/studentCourseInfo/{studentId}")
public APIResponse studentCourseInfo(@PathVariable("studentId") Long studentId){
return studentCourseService.studentCourseInfo(studentId);
}
/**
*
* @param reqSearchStudentCourseCla
* @return
*/
@GetMapping("/list/searchCourseClaStudent")
public APIResponse searchCourseClaStudent(ReqSearchStudentCourseCla reqSearchStudentCourseCla){
RespPage<RespCourseClaStudent> respPage = studentCourseService.searchCourseClaStudent(reqSearchStudentCourseCla);
return APIResponse.toAPIResponse(respPage);
}
/**
*
* @return
*/
// @PostMapping("/update/studentCourseChooseCla")
// public APIResponse studentCourseChooseCla(@RequestBody ReqStudentCourseChooseCla studentCourseChooseCla){
// return studentCourseService.studentCourseChooseCla(studentCourseChooseCla);
// }
/**
*
* @param reqClaTimeAttend
* @return
*/
@PostMapping("/update/claTimeAttend")
public APIResponse claTimeAttend(@RequestBody ReqClaTimeAttend reqClaTimeAttend){
return studentCourseService.claTimeAttend(reqClaTimeAttend);
}
/**
*
* @param studentCourseId
* @return
*/
@PostMapping("/update/stopStudentCourseStatus/{studentCourseId}")
public APIResponse stopStudentCourseStatus(@PathVariable("studentCourseId") Long studentCourseId) {
return studentCourseService.stopStudentCourseStatus(studentCourseId);
}
/**
*
* @param studentCourseId
* @return
*/
@PostMapping("/update/atClaStudentCourseStatus/{studentCourseId}")
public APIResponse atClaStudentCourseStatus(@PathVariable("studentCourseId") Long studentCourseId) {
return studentCourseService.atClaStudentCourseStatus(studentCourseId);
}
/**
*
* @param reqSearchStudentCourse
* @return
*/
@GetMapping("/list/searchStudentCourse")
public APIResponse searchStudentCourse(ReqSearchStudentCourse reqSearchStudentCourse){
List<RespStudentCourse> respStudentCourses = studentCourseService.searchStudentCourse(reqSearchStudentCourse);
return APIResponse.toAPIResponse(respStudentCourses);
}
/**
*
* @param reqSearchStuCourseSignUp
* @return
*/
@GetMapping("/list/searchStuCourseSignUpList")
public APIResponse searchStuCourseSignUpList(ReqSearchStuCourseSignUp reqSearchStuCourseSignUp){
RespPage<RespStuCourseSignUpStudent> respPage = studentCourseService.searchStuCourseSignUpList(reqSearchStuCourseSignUp);
return APIResponse.toAPIResponse(respPage);
}
/**
*
* @param studentCourseId
* @return
*/
// @PostMapping("/update/removeStuFromCla/{studentCourseId}")
// public APIResponse removeStuFromCla(@PathVariable("studentCourseId") Long studentCourseId) {
// return studentCourseService.removeStuFromCla(studentCourseId);
// }
}

@ -1,106 +0,0 @@
package cn.xluobo.business.sc.student.domain.req;
import cn.xluobo.core.api.APIResponse;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;
import java.util.List;
/**
*
*
* @author zhangbaoyu
* @date Created in 2020/10/1 19:44
*/
@Data
public class ReqClaTimeAttend {
// 上课方式 排课记上课rule、自定义上课custom
private String attendType;
// 排课编号
private Long courseTimeId;
private Long claId;
private Long teacherId;
private Long roomId;
private String claDate;
private String startTime;
private String endTime;
private String classTheme;
private String memo;
List<ReqClaTimeAttendItem> studentAttendList;
/**
*
* @return
*/
public APIResponse checkParam() {
if(null == studentAttendList || studentAttendList.size() ==0) {
return APIResponse.toExceptionResponse("排课记上课,请选择上课学生");
}
for (ReqClaTimeAttendItem attendItem : studentAttendList) {
if(StringUtils.isAnyEmpty(attendItem.getAttendStatus())) {
return APIResponse.toExceptionResponse("请选择学员到课状态");
} else if(null == attendItem.getStudentCourseId()) {
return APIResponse.toExceptionResponse("请选择学员");
} else if(null == attendItem.getStuLoseHour()) {
return APIResponse.toExceptionResponse("请选择扣减课时");
}
}
if("rule".equals(attendType)) {
// 排课记上课
if(null == courseTimeId) {
return APIResponse.toExceptionResponse("排课记上课,未选择上课日期!");
} else if(StringUtils.isAnyEmpty(startTime,endTime)) {
return APIResponse.toExceptionResponse("排课记上课,未选择上下课时间!");
}
} else if ("custom".equals(attendType)) {
// 自定义记上课
if(StringUtils.isAnyEmpty(claDate,startTime,endTime)) {
return APIResponse.toExceptionResponse("自定义记上课,未选择上课日期,上下课时间!");
} else if( null == teacherId) {
return APIResponse.toExceptionResponse("自定义记上课,请选择上课教师!");
}
}
return APIResponse.toOkResponse();
}
/**
*
*
* @return
*/
public APIResponse checkParamForUpdateHadClaTime() {
if(null == studentAttendList || studentAttendList.size() ==0) {
return APIResponse.toExceptionResponse("排课记上课,请选择上课学生");
}
for (ReqClaTimeAttendItem attendItem : studentAttendList) {
if(StringUtils.isAnyEmpty(attendItem.getAttendStatus())) {
return APIResponse.toExceptionResponse("请选择学员到课状态");
} else if(null == attendItem.getStudentCourseId()) {
return APIResponse.toExceptionResponse("请选择学员");
} else if(null == attendItem.getStuLoseHour()) {
return APIResponse.toExceptionResponse("请选择扣减课时");
}
}
// 自定义记上课
if(StringUtils.isAnyEmpty(claDate,startTime,endTime)) {
return APIResponse.toExceptionResponse("自定义记上课,未选择上课日期,上下课时间!");
} else if( null == teacherId) {
return APIResponse.toExceptionResponse("自定义记上课,请选择上课教师!");
}
return APIResponse.toOkResponse();
}
}

@ -1,113 +0,0 @@
package cn.xluobo.business.sc.student.domain.resp;
import cn.xluobo.business.sc.course.enums.CourseChargeTypeEnum;
import lombok.Data;
import org.joda.time.DateTime;
import org.joda.time.Period;
import org.joda.time.PeriodType;
import java.math.BigDecimal;
import java.util.Date;
/**
*
*
* @author zhangbaoyu
* @date Created in 2020/9/28 16:51
*/
@Data
public class RespCourseClaStudent {
private Long studentCourseId;
private Long claId;
private Long courseId;
// 报读校区
private String deptName;
private Long studentId;
private String studentName;
private String sex;
private String phone;
// 联系人信息
private String contactInfo;
private String chargeType;
private BigDecimal totalDay;
private BigDecimal totalHour;
private BigDecimal balanceHour;
// 过期课时
private BigDecimal expireHour;
// 即将生效的 总天数
private BigDecimal comingEffectDay;
/**
*
*
*/
private Date endDate;
// 状态
private String status;
// 首次报名时间
private Date firstSignTime;
// 最后一次续费时间
private Date lastSignTime;
/**
*
* @return
*/
public BigDecimal getBalanceDays() {
try {
if(CourseChargeTypeEnum.DATE.getChargeType().equals(chargeType)) {
if(null == this.endDate) {
// 无生效周期
return comingEffectDay;
} else {
// 有生效周期
Period period = new Period(DateTime.now(), new DateTime(this.endDate), PeriodType.days());
return new BigDecimal(period.getDays() + 1).add(comingEffectDay);
}
} else {
return BigDecimal.ZERO;
}
} catch (Exception e) {
e.printStackTrace();
return BigDecimal.ZERO;
}
}
/**
* ()
* @return
*/
public boolean isEffect() {
try{
if(CourseChargeTypeEnum.DATE.getChargeType().equals(chargeType)) {
if(null == this.endDate) {
// 未生效
return false;
} else {
return true;
}
} else {
return true;
}
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
}

@ -1,16 +0,0 @@
package cn.xluobo.business.sc.student.repo.mapper;
import cn.xluobo.business.sc.student.repo.model.ScStudentContact;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
/**
* <p>
* Mapper
* </p>
*
* @author zhangby
* @since 2020-09-27
*/
public interface ScStudentContactMapper extends BaseMapper<ScStudentContact> {
}

@ -1,101 +0,0 @@
package cn.xluobo.business.sc.student.repo.mapper;
import cn.xluobo.business.sc.student.domain.req.ReqSearchStuCourseSignUp;
import cn.xluobo.business.sc.student.domain.req.ReqSearchStudentCourse;
import cn.xluobo.business.sc.student.domain.req.ReqSearchStudentCourseCla;
import cn.xluobo.business.sc.student.domain.resp.RespCourseClaStudent;
import cn.xluobo.business.sc.student.domain.resp.RespStuCourseSignUpStudent;
import cn.xluobo.business.sc.student.domain.resp.RespStudentCourse;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* <p>
* Mapper
* </p>
*
* @author zhangby
* @since 2020-08-21
*/
public interface ScStudentCourseMapper extends BaseMapper<ScStudentCourse> {
/**
*
* @param studentId
* @return
*/
List<String> selectStudentCourseNameList(Long studentId);
/**
*
* @param studentId
* @return
*/
List<String> selectStudentDeptNameList(Long studentId);
/**
*
*
* @param reqSearchStudentCourseCla
* @param page
* @return
*/
List<RespCourseClaStudent> selectStudentList(@Param("reqSearchStudentCourseCla")ReqSearchStudentCourseCla reqSearchStudentCourseCla, @Param("page")Page page);
/**
*
* @param claId
* @return
*/
int selectClaNeedAttendCnt(Long claId);
/**
*
* @param searchStudentCourse
* @return
*/
List<RespStudentCourse> selectStudentCourseList(ReqSearchStudentCourse searchStudentCourse);
/**
* 0
* @param studentCourseId
* @return
*/
int deleteWhenTotalHourZeroForInvalid(Long studentCourseId);
/**
* 0
* @param studentCourseId
* @return
*/
int deleteWhenTotalDayZeroForInvalid(Long studentCourseId);
/**
* minBalanceDay
* + < minBalanceDay
* @param minBalanceDay
* @return
*/
Integer selectWillExpireDateCount( @Param("minBalanceDay") Integer minBalanceDay, @Param("tenantId") String tenantId);
/**
* minBalanceHour
* - < minBalanceHour
* @param minBalanceHour
* @return
*/
Integer selectWillExpireHourCount(@Param("minBalanceHour")Integer minBalanceHour, @Param("tenantId") String tenantId);
/**
*
*
* @param reqSearchStuCourseSignUp
* @param page
* @return
*/
List<RespStuCourseSignUpStudent> selectStudentSignUpList(@Param("reqSearchStuCourseSignUp") ReqSearchStuCourseSignUp reqSearchStuCourseSignUp, @Param("page")Page page);
}

@ -1,71 +0,0 @@
package cn.xluobo.business.sc.student.repo.mapper;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.apache.ibatis.annotations.Param;
import java.math.BigDecimal;
import java.util.List;
/**
* <p>
* Mapper
* </p>
*
* @author zhangby
* @since 2020-08-21
*/
public interface ScStudentCourseOrderMapper extends BaseMapper<ScStudentCourseOrder> {
/**
*
*
* @param studentId
* @param courseId
* @param beginDate
* @param endDate
* @return
*/
int checkDateCover(@Param("studentId") Long studentId, @Param("courseId") Long courseId,
@Param("beginDate") String beginDate, @Param("endDate") String endDate);
/**
*
* @param studentCourseId
* @return
*/
ScStudentCourseOrder selectSubtractHourOrder(Long studentCourseId);
/**
*
* @param studentCourseId
* @return
*/
ScStudentCourseOrder selectNowValidDateOrder(Long studentCourseId);
/**
*
* @param studentCourseId
* @return
*/
List<ScStudentCourseOrder> selectSubtractHourOrderList(Long studentCourseId);
/**
*
* @param studentCourseId
* @return
*/
List<ScStudentCourseOrder> selectRecoverHourOrderList(Long studentCourseId);
/**
*
* @param courseOrderId
* @param newHour
* @param oldHour
* @return
*/
int updateSubtractHour(@Param("courseOrderId") Long courseOrderId,
@Param("newHour") BigDecimal newHour,
@Param("oldHour") BigDecimal oldHour);
}

@ -1,5 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.xluobo.business.sc.student.repo.mapper.ScStudentAccountLogMapper">
</mapper>

@ -1,196 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.xluobo.business.sc.student.repo.mapper.ScStudentCourseMapper">
<select id="selectStudentCourseNameList" resultType="java.lang.String">
select distinct b.course_name
from sc_student_course a
left join sc_course b on a.course_id=b.course_id
where a.student_id = #{studentId} and a.status = '1'
</select>
<select id="selectStudentDeptNameList" resultType="java.lang.String">
select distinct c.dept_name
from sc_student_course a
left join sc_course_cla b on a.cla_id=b.cla_id
left join sys_dept c on b.depart_id=c.dept_id
where a.student_id = #{studentId} and a.status = '1' and a.cla_id is not null
</select>
<select id="selectStudentList" resultType="cn.xluobo.business.sc.student.domain.resp.RespCourseClaStudent">
select a.student_course_id,a.cla_id,a.course_id,
d.dept_name,
a.charge_type,a.total_day,a.total_hour,
a.balance_hour,
case a.charge_type when 'date' then null else (select ifnull(sum(co.balance_hour),0) from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ > ]]> co.expire_date) end as expire_hour,
case a.charge_type when 'date' then (select ifnull(sum(co.total_day),0) from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ < ]]> co.begin_date) end as coming_effect_day,
case a.charge_type when 'date' then (select co.end_date from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') between co.begin_date and co.end_date limit 1) end as end_date,
a.status,
a.create_time as first_sign_time,
(select co.create_time from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 order by co.create_time desc limit 1) as last_sign_time,
b.student_id,b.student_name,b.sex,b.phone,
(select group_concat(sc.contact_nick,'(',fcn_dict_name(sc.contact_relation,'contact_relation'),') ',sc.contact_phone separator ';') from sc_student_contact sc where sc.student_id=b.student_id) as contact_info
from sc_student_course a left join sys_dept d on a.dept_id=d.dept_id
,sc_student b
where a.student_id=b.student_id
<if test="reqSearchStudentCourseCla.claId != null">
and a.cla_id=#{reqSearchStudentCourseCla.claId}
</if>
<if test="reqSearchStudentCourseCla.departId != null">
and a.dept_id=#{reqSearchStudentCourseCla.departId}
</if>
<if test="reqSearchStudentCourseCla.deptId == null and reqSearchStudentCourseCla.userId != null and reqSearchStudentCourseCla.userId != ''">
and exists(select 1 from sys_user_dept ud
where ud.user_id=#{reqSearchStudentCourseCla.userId}
and (ud.dept_id=a.dept_id or ud.dept_id=-1))
</if>
<if test="reqSearchStudentCourseCla.courseId != null">
and a.course_id=#{reqSearchStudentCourseCla.courseId}
</if>
<if test="reqSearchStudentCourseCla.unChooseCla != null and reqSearchStudentCourseCla.unChooseCla == true">
and a.cla_id is null
</if>
<if test="reqSearchStudentCourseCla.unChooseCla != null and reqSearchStudentCourseCla.unChooseCla == false">
and a.cla_id is not null
</if>
<if test="reqSearchStudentCourseCla.effect != null and reqSearchStudentCourseCla.effect == true">
and a.status='1'
and (charge_type in ('hour','cycle')
or (charge_type='date' and exists(
select 1 from sc_student_course_order sco
where a.student_course_id=sco.student_course_id
and sco.valid=1
and date_format(now(),'%Y-%m-%d') between sco.begin_date and sco.end_date)))
</if>
order by a.create_time desc
</select>
<select id="selectClaNeedAttendCnt" resultType="int">
select count(1) from sc_student_course sc
where sc.cla_id=#{claId}
and sc.status='1'
and (charge_type in ('hour','cycle')
or (charge_type='date' and exists(
select 1 from sc_student_course_order sco
where sc.student_course_id=sco.student_course_id
and sco.valid=1
and date_format(now(),'%Y-%m-%d') between sco.begin_date and sco.end_date)))
</select>
<select id="selectStudentCourseList" resultType="cn.xluobo.business.sc.student.domain.resp.RespStudentCourse">
select a.student_course_id,a.course_name,a.charge_type,a.total_day,a.total_hour,
a.balance_hour,
case a.charge_type when 'date' then null else (select ifnull(sum(co.balance_hour),0) from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ > ]]> co.expire_date) end as expire_hour,
a.total_fee,a.status,
b.student_id,b.student_name,c.dept_name,d.cla_name,
(select case a.charge_type
when 'date' then group_concat(sco.total_day, ',', sco.begin_date, '~', sco.end_date separator ';')
else group_concat(sco.total_hour, ',', date_format(sco.create_time, '%Y%m%d') separator ';')
end
from sc_student_course_order sco
where a.student_course_id = sco.student_course_id and sco.valid=1) as order_detail,
case a.charge_type when 'date' then (select ifnull(sum(co.total_day),0) from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ < ]]> co.begin_date) end as coming_effect_day,
case a.charge_type when 'date' then (select co.end_date from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') between co.begin_date and co.end_date limit 1) end as end_date
from sc_student_course a
left join sc_student b on a.student_id=b.student_id
left join sys_dept c on a.dept_id=c.dept_id
left join sc_course_cla d on a.cla_id=d.cla_id
where 1=1
<if test="studentId != null">
and a.student_id=#{studentId}
</if>
<if test="deptId != null">
and a.dept_id=#{deptId}
</if>
<if test="deptId == null and userId != null and userId != ''">
and exists(select 1 from sys_user_dept ud
where ud.user_id=#{userId}
and (ud.dept_id=a.dept_id or ud.dept_id=-1))
</if>
order by a.create_time desc
</select>
<delete id="deleteWhenTotalHourZeroForInvalid">
delete from sc_student_course where student_course_id=#{studentCourseId} and charge_type <![CDATA[ <> ]]> 'date' and total_hour=0 and total_fee=0
</delete>
<delete id="deleteWhenTotalDayZeroForInvalid">
delete from sc_student_course where student_course_id=#{studentCourseId} and charge_type = 'date' and total_day=0 and total_fee=0
</delete>
<select id="selectWillExpireDateCount" resultType="java.lang.Integer">
select count(1) from sc_student_course sc
where sc.charge_type='date' and sc.status='1'
and exists(select 1 from sc_student_course_order sco
where sc.student_course_id=sc.student_course_id
and sco.valid=1
and sc.tenant_id=#{tenantId}
and date_format(now(),'%Y-%m-%d') between sco.begin_date and sco.end_date
and (datediff(sco.end_date,now())+1+((select ifnull(sum(sco.total_day),0) from sc_student_course_order sco_will_effect
where sco_will_effect.student_course_id=sc.student_course_id
and sco_will_effect.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ < ]]> sco_will_effect.begin_date))
) <![CDATA[ <= ]]> #{minBalanceDay})
</select>
<select id="selectWillExpireHourCount" resultType="java.lang.Integer">
select count(1) from sc_student_course sc
where sc.charge_type <![CDATA[ <> ]]> 'date'
and sc.status='1'
and sc.tenant_id=#{tenantId}
and (sc.balance_hour - (select ifnull(sum(sco.balance_hour),0)
from sc_student_course_order sco
where sc.student_course_id=sco.student_course_id
and sco.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ > ]]> sco.expire_date)
) <![CDATA[ <= ]]> #{minBalanceHour}
</select>
<select id="selectStudentSignUpList" resultType="cn.xluobo.business.sc.student.domain.resp.RespStuCourseSignUpStudent">
select a.student_course_id,
a.cla_id,a.cla_name,
a.course_id,a.course_name,
d.dept_name,
a.charge_type,a.total_day,a.total_hour,
a.balance_hour,
(select case a.charge_type
when 'date' then group_concat(sco.total_day, ',', sco.begin_date, '~', sco.end_date separator ';')
else group_concat(sco.total_hour, ',', date_format(sco.create_time, '%Y%m%d') separator ';')
end
from sc_student_course_order sco
where a.student_course_id = sco.student_course_id and sco.valid=1) as order_detail,
(select sum(co.total_fee) from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1) as total_fee,
(select sum(co.balance_hour * co.unit_fee) from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1) as balance_fee,
case a.charge_type when 'date' then null else (select ifnull(sum(co.balance_hour),0) from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ > ]]> co.expire_date) end as expire_hour,
case a.charge_type when 'date' then null else (select ifnull(sum(co.balance_hour * co.unit_fee),0) from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ > ]]> co.expire_date) end as expire_fee,
case a.charge_type when 'date' then (select ifnull(sum(co.total_day),0) from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ < ]]> co.begin_date) end as coming_effect_day,
case a.charge_type when 'date' then (select co.end_date from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 and date_format(now(),'%Y-%m-%d') between co.begin_date and co.end_date limit 1) end as end_date,
a.status,
a.create_time as first_sign_time,
(select co.create_time from sc_student_course_order co where a.student_course_id=co.student_course_id and co.valid=1 order by co.create_time desc limit 1) as last_sign_time,
b.student_id,b.student_name,b.sex,b.phone,
(select group_concat(sc.contact_nick,'(',fcn_dict_name(sc.contact_relation,'contact_relation'),') ',sc.contact_phone separator ';') from sc_student_contact sc where sc.student_id=b.student_id) as contact_info
from sc_student_course a
left join sys_dept d on a.dept_id=d.dept_id
,sc_student b
where a.student_id=b.student_id and d.tenant_id=#{reqSearchStuCourseSignUp.tenantId}
<if test="reqSearchStuCourseSignUp.claId != null">
and a.cla_id=#{reqSearchStuCourseSignUp.claId}
</if>
<if test="reqSearchStuCourseSignUp.departId != null">
and a.dept_id=#{reqSearchStuCourseSignUp.departId}
</if>
<if test="reqSearchStuCourseSignUp.courseId != null">
and a.course_id=#{reqSearchStuCourseSignUp.courseId}
</if>
<if test="reqSearchStuCourseSignUp.minBalanceDay != null">
and a.charge_type='date' and a.status='1'
and exists(select 1 from sc_student_course_order sco
where sco.student_course_id=a.student_course_id
and sco.valid=1
and date_format(now(),'%Y-%m-%d') between sco.begin_date and sco.end_date
and (datediff(sco.end_date,now())+1+((select ifnull(sum(sco.total_day),0) from sc_student_course_order sco_will_effect
where sco_will_effect.student_course_id=a.student_course_id
and sco_will_effect.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ < ]]> sco_will_effect.begin_date))
) <![CDATA[ <= ]]> #{reqSearchStuCourseSignUp.minBalanceDay})
</if>
<if test="reqSearchStuCourseSignUp.minBalanceHour != null">
and a.charge_type <![CDATA[ <> ]]> 'date' and a.status='1'
and (a.balance_hour - (select ifnull(sum(sco.balance_hour),0)
from sc_student_course_order sco
where a.student_course_id=sco.student_course_id
and sco.valid=1 and date_format(now(),'%Y-%m-%d') <![CDATA[ > ]]> sco.expire_date)
) <![CDATA[ <= ]]> #{reqSearchStuCourseSignUp.minBalanceHour}
</if>
order by a.create_time desc
</select>
</mapper>

@ -1,52 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.xluobo.business.sc.student.repo.mapper.ScStudentCourseOrderMapper">
<select id="checkDateCover" resultType="int">
select count(1) from sc_student_course a,sc_student_course_order b
where a.student_course_id=b.student_course_id
and a.student_id=#{studentId}
and a.course_id=#{courseId}
and b.valid=1
and exists(select 1 from sc_order_detail c where b.order_detail_id=c.order_detail_id and c.charge_type='date')
and (#{beginDate} between b.begin_date and b.end_date or #{endDate} between b.begin_date and b.end_date)
</select>
<select id="selectSubtractHourOrder" resultType="cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder">
select * from sc_student_course_order a
where a.student_course_id=#{studentCourseId}
and ((a.expire_date is not null and date_format(now(),'%Y-%m-%d') <![CDATA[ <= ]]> a.expire_date)
or (a.expire_date is null))
and a.valid=1
and exists(select 1 from sc_order_detail b where a.order_detail_id=b.order_detail_id and b.charge_type <![CDATA[ <> ]]> 'date')
order by create_time limit 1
</select>
<select id="selectNowValidDateOrder" resultType="cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder">
select * from sc_student_course_order a
where a.student_course_id=#{studentCourseId}
and a.total_day <![CDATA[ > ]]> 0
and date_format(now(),'%Y-%m-%d') between a.begin_date and a.end_date
and a.valid=1
and exists(select 1 from sc_order_detail b where a.order_detail_id=b.order_detail_id and b.charge_type = 'date')
order by create_time limit 1
</select>
<select id="selectSubtractHourOrderList" resultType="cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder">
select * from sc_student_course_order a
where a.student_course_id=#{studentCourseId}
and a.balance_hour <![CDATA[ > ]]> 0
and ((a.expire_date is not null and date_format(now(),'%Y-%m-%d') <![CDATA[ <= ]]> a.expire_date)
or (a.expire_date is null))
and a.valid=1
and exists(select 1 from sc_order_detail b where a.order_detail_id=b.order_detail_id and b.charge_type <![CDATA[ <> ]]> 'date')
order by create_time
</select>
<select id="selectRecoverHourOrderList" resultType="cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder">
select * from sc_student_course_order a
where a.student_course_id=#{studentCourseId}
and a.valid=1
and exists(select 1 from sc_order_detail b where a.order_detail_id=b.order_detail_id and b.charge_type <![CDATA[ <> ]]> 'date')
order by create_time desc
</select>
<update id="updateSubtractHour">
update sc_student_course_order set balance_hour = #{newHour} where course_order_id=#{courseOrderId} and balance_hour = #{oldHour}
</update>
</mapper>

@ -1,71 +0,0 @@
package cn.xluobo.business.sc.student.repo.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.util.Date;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-09-27
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sc_student_contact")
public class ScStudentContact implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
@TableId(value = "contact_id", type = IdType.ASSIGN_ID)
private Long contactId;
/**
*
*/
@TableField("student_id")
private Long studentId;
/**
*
*/
@TableField("contact_nick")
private String contactNick;
/**
*
*/
@TableField("contact_relation")
private String contactRelation;
/**
*
*/
@TableField("contact_phone")
private String contactPhone;
/**
*
*/
@TableField("create_user")
private Long createUser;
/**
*
*/
@TableField("create_time")
private Date createTime;
}

@ -1,134 +0,0 @@
package cn.xluobo.business.sc.student.repo.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-08-21
*/
@Data
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sc_student_course")
public class ScStudentCourse implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
@TableId(value = "student_course_id", type = IdType.ASSIGN_ID)
private Long studentCourseId;
/**
*
*/
@TableField("student_id")
private Long studentId;
/**
*
*/
@TableField("course_id")
private Long courseId;
/**
*
*/
@TableField("course_name")
private String courseName;
/**
*
*/
@TableField("dept_id")
private Long deptId;
/**
*
*/
@TableField("cla_id")
private Long claId;
/**
*
*/
@TableField("cla_name")
private String claName;
/**
* hour: date: cycle:
*/
@TableField("charge_type")
private String chargeType;
/**
*
*/
@TableField("total_day")
private BigDecimal totalDay;
/**
*
*/
@TableField("total_hour")
private BigDecimal totalHour;
/**
*
*/
@TableField("balance_hour")
private BigDecimal balanceHour;
/**
*
*/
@TableField("total_fee")
private BigDecimal totalFee;
/**
* 1 2
*/
@TableField("status")
private String status;
/**
*
*/
@TableField("create_user")
private Long createUser;
/**
*
*/
@TableField("create_time")
private Date createTime;
/**
*
*/
@TableField("last_update_user")
private Long lastUpdateUser;
/**
*
*/
@TableField("last_update_time")
private Date lastUpdateTime;
private String tenantId;
}

@ -1,133 +0,0 @@
package cn.xluobo.business.sc.student.repo.model;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Builder;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.Date;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-08-21
*/
@Data
@Builder
@EqualsAndHashCode(callSuper = false)
@Accessors(chain = true)
@TableName("sc_student_course_order")
public class ScStudentCourseOrder implements Serializable {
private static final long serialVersionUID = 1L;
/**
*
*/
@TableId(value = "course_order_id", type = IdType.ASSIGN_ID)
private Long courseOrderId;
@TableField("student_course_id")
private Long studentCourseId;
/**
*
*/
@TableField("order_id")
private Long orderId;
/**
*
*/
@TableField("order_detail_id")
private Long orderDetailId;
/**
*
*/
@TableField("total_hour")
private BigDecimal totalHour;
/**
*
*/
@TableField("balance_hour")
private BigDecimal balanceHour;
/**
*
*/
@TableField("total_day")
private BigDecimal totalDay;
/**
*
*/
@TableField("begin_date")
private String beginDate;
/**
*
*/
@TableField("end_date")
private String endDate;
/**
*
*/
@TableField("expire_date")
private String expireDate;
/**
*
*/
@TableField("total_fee")
private BigDecimal totalFee;
/**
*
*/
@TableField("unit_fee")
private BigDecimal unitFee;
/**
* 1 0
*/
@TableField("valid")
private Boolean valid;
/**
*
*/
@TableField("create_user")
private Long createUser;
/**
*
*/
@TableField("create_time")
private Date createTime;
/**
*
*/
@TableField("last_update_user")
private Long lastUpdateUser;
/**
*
*/
@TableField("last_update_time")
private Date lastUpdateTime;
}

@ -1,583 +0,0 @@
package cn.xluobo.business.sc.student.service;
import cn.xluobo.business.sc.base.repo.model.ScRoom;
import cn.xluobo.business.sc.base.service.IScRoomService;
import cn.xluobo.business.sc.course.enums.CourseChargeTypeEnum;
import cn.xluobo.business.sc.course.repo.enums.ClaTimeAttendStatusEnums;
import cn.xluobo.business.sc.course.repo.enums.ClaTimeSourceEnums;
import cn.xluobo.business.sc.course.repo.enums.ClaTimeStatusEnums;
import cn.xluobo.business.sc.course.repo.model.ScClaTime;
import cn.xluobo.business.sc.course.repo.model.ScClaTimeAttend;
import cn.xluobo.business.sc.course.repo.model.ScCourse;
import cn.xluobo.business.sc.course.repo.model.ScCourseCla;
import cn.xluobo.business.sc.course.service.IScClaTimeAttendService;
import cn.xluobo.business.sc.course.service.IScClaTimeService;
import cn.xluobo.business.sc.course.service.IScCourseClaService;
import cn.xluobo.business.sc.course.service.IScCourseService;
import cn.xluobo.business.sc.log.enums.LogTypeEnum;
import cn.xluobo.business.sc.log.repo.model.ScStudentCourseLog;
import cn.xluobo.business.sc.log.service.IScStudentCourseLogService;
import cn.xluobo.business.sc.student.domain.req.*;
import cn.xluobo.business.sc.student.domain.resp.RespBusinessStudentCourseInfo;
import cn.xluobo.business.sc.student.domain.resp.RespCourseClaStudent;
import cn.xluobo.business.sc.student.domain.resp.RespStuCourseSignUpStudent;
import cn.xluobo.business.sc.student.domain.resp.RespStudentCourse;
import cn.xluobo.business.sc.student.enums.StudentCourseStatusEnum;
import cn.xluobo.business.sc.student.repo.mapper.ScStudentCourseMapper;
import cn.xluobo.business.sc.student.repo.model.ScStudent;
import cn.xluobo.business.sc.student.repo.model.ScStudentContact;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder;
import cn.xluobo.business.sys.admin.service.ISysDeptService;
import cn.xluobo.config.exception.BusinessException;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.google.common.collect.Lists;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.service.ISysUserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;
/**
* @author zhangbaoyu
* @date Created in 2020/9/2 15:06
*/
@Service
@Transactional
public class BusinessScStudentCourseService {
@Autowired
private ScStudentCourseMapper studentCourseMapper;
@Autowired
private IScStudentService studentService;
@Autowired
private IScStudentContactService contactService;
@Autowired
private IScCourseClaService claService;
@Autowired
private IScCourseService courseService;
@Autowired
private IScStudentCourseService studentCourseService;
@Autowired
private IScClaTimeService claTimeService;
@Autowired
private ISysDeptService deptService;
@Autowired
private IScRoomService roomService;
@Autowired
private IScClaTimeAttendService attendService;
@Autowired
private ISysUserService staffService;
@Autowired
private IScStudentCourseOrderService courseOrderService;
@Autowired
private IScStudentCourseLogService scStudentCourseLogService;
/**
*
*
* @param studentId
* @return
*/
public APIResponse studentCourseInfo(Long studentId) {
if (null == studentId) {
return APIResponse.toExceptionResponse(ApiResEnums.PARAM_FAIL);
}
ScStudent student = studentService.getById(studentId);
// 联系人信息
List<ScStudentContact> contactList = contactService.getStudentContactList(studentId);
List<String> contactPhoneList = contactList.stream().map(item -> item.getContactPhone() + "(" + item.getContactNick() + ")").collect(Collectors.toList());
// 报读课程
List<String> courseNameList = studentCourseMapper.selectStudentCourseNameList(studentId);
// 报读校区
List<String> deptNameList = studentCourseMapper.selectStudentDeptNameList(studentId);
RespBusinessStudentCourseInfo studentCourseInfo = RespBusinessStudentCourseInfo.builder()
.contactPhone(student.getPhone())
.contactPhoneDetail(String.join(",", contactPhoneList))
.courseNames(String.join(",", courseNameList))
.deptNames(String.join(",", deptNameList))
.build();
return APIResponse.toAPIResponse(studentCourseInfo);
}
/**
*
*
* @param reqSearchStudentCourseCla
* @return
*/
public RespPage<RespCourseClaStudent> searchCourseClaStudent(ReqSearchStudentCourseCla reqSearchStudentCourseCla) {
RespPage<RespCourseClaStudent> page = new RespPage<>(reqSearchStudentCourseCla.getPageNum(), reqSearchStudentCourseCla.getPageSize());
List<RespCourseClaStudent> claStudentList = studentCourseMapper.selectStudentList(reqSearchStudentCourseCla, page);
page.setRows(claStudentList);
return page;
}
/**
*
*
* @param studentCourseChooseCla
* @return
*/
public APIResponse studentCourseChooseCla(ReqStudentCourseChooseCla studentCourseChooseCla) {
if (!studentCourseChooseCla.checkParam()) {
return APIResponse.toExceptionResponse(ApiResEnums.PARAM_FAIL);
}
Long courseId = studentCourseChooseCla.getCourseId();
Long claId = studentCourseChooseCla.getClaId();
Long[] studentCourseIds = studentCourseChooseCla.getChooseStudentCourseIds();
if (null == studentCourseIds || studentCourseIds.length == 0) {
return APIResponse.toExceptionResponse("未选择学生,请稍后重试");
}
ScCourseCla courseCla = claService.getById(claId);
if (null == courseCla) {
return APIResponse.toExceptionResponse("无法获取班级,请稍后重试");
}
// 更新
UpdateWrapper<ScStudentCourse> uw = new UpdateWrapper<>();
uw.set("cla_id", claId);
uw.set("cla_name", courseCla.getClaName());
uw.in("student_course_id", studentCourseIds);
uw.isNull("cla_id");
uw.eq("course_id", courseId);
studentCourseService.update(uw);
// 日志
LoginUser loginUser = SecurityUtils.getLoginUser();
SysDept sysDept = deptService.getById(courseCla.getDepartId());
List<ScStudentCourseLog> courseLogList = Lists.newArrayList();
for (Long studentCourseId : studentCourseIds) {
ScStudentCourse studentCourse = studentCourseService.getById(studentCourseId);
ScStudentCourseLog studentCourseLog = ScStudentCourseLog.builder()
.studentId(studentCourse.getStudentId())
.logType(LogTypeEnum.IN_CLA.getLogType())
.courseId(studentCourse.getCourseId())
.courseName(studentCourse.getCourseName())
.claId(courseCla.getClaId())
.claName(courseCla.getClaName())
.deptName(sysDept.getDeptName())
.memo("进入班级,进入班级'" + studentCourse.getClaName() + "'")
.createUser(loginUser.getUserId())
.createUserName(loginUser.getUsername())
.build();
courseLogList.add(studentCourseLog);
}
scStudentCourseLogService.saveBatch(courseLogList);
return APIResponse.toOkResponse();
}
/**
*
*
* @param reqClaTimeAttend
* @return
*/
public APIResponse claTimeAttend(ReqClaTimeAttend reqClaTimeAttend) {
APIResponse checkParam = reqClaTimeAttend.checkParam();
if (!checkParam.isSuccess()) {
return checkParam;
}
LoginUser loginUser = SecurityUtils.getLoginUser();
String attendType = reqClaTimeAttend.getAttendType();
String startTime = reqClaTimeAttend.getStartTime();
String endTime = reqClaTimeAttend.getEndTime();
Long teacherId = reqClaTimeAttend.getTeacherId();
Long courseTimeId = reqClaTimeAttend.getCourseTimeId();
Long claId = reqClaTimeAttend.getClaId();
ScCourseCla dbCla = claService.getById(claId);
if (null == dbCla) {
return APIResponse.toExceptionResponse("无法获取班级信息,请稍后重试");
}
Long courseId = dbCla.getCourseId();
ScCourse scCourse = courseService.getById(courseId);
if (null == scCourse) {
return APIResponse.toExceptionResponse("无法获取班级信息,请稍后重试");
}
Long departId = dbCla.getDepartId();
SysDept sysDept = deptService.getById(departId);
if (null == sysDept) {
return APIResponse.toExceptionResponse("无法获取校区信息,请稍后重试");
}
List<ReqClaTimeAttendItem> studentAttendList = reqClaTimeAttend.getStudentAttendList();
// 总消耗课时金额
BigDecimal totalPayFee = BigDecimal.ZERO;
// 可课时消耗
BigDecimal totalPayHour = BigDecimal.ZERO;
// 实到人数
Long realAttendCnt = studentAttendList.stream().filter(item -> item.getAttendStatus().equals(ClaTimeAttendStatusEnums.AT_CLASS.getAttendStatus())).count();
// 请假人数
Long leaveCnt = studentAttendList.stream().filter(item -> item.getAttendStatus().equals(ClaTimeAttendStatusEnums.LEAVE_CLASS.getAttendStatus())).count();
// 旷课人数
Long outCnt = studentAttendList.stream().filter(item -> item.getAttendStatus().equals(ClaTimeAttendStatusEnums.OUT_CLASS.getAttendStatus())).count();
// 应到人数
int needAttendCnt = studentCourseMapper.selectClaNeedAttendCnt(dbCla.getClaId());
if ("rule".equals(attendType)) {
// 排课记上课
ScClaTime claTime = claTimeService.getById(courseTimeId);
if (!ClaTimeStatusEnums.WAIT_CLASS.getStatus().equals(claTime.getStatus())) {
return APIResponse.toExceptionResponse("选择计划上课日期,非待上课状态,无法重复上课!");
}
teacherId = claTime.getTeacherId();
// 变更状态为已上课
ScClaTime updateClaTime = new ScClaTime();
updateClaTime.setCourseTimeId(courseTimeId);
updateClaTime.setRealClaDate(claTime.getClaDate());
updateClaTime.setRealStartTime(startTime);
updateClaTime.setRealEndTime(endTime);
updateClaTime.setStatus(ClaTimeStatusEnums.HAD_CLASS.getStatus());
updateClaTime.setBookAttendCnt(needAttendCnt);
updateClaTime.setRealAttendCnt(realAttendCnt.intValue());
updateClaTime.setMemo(reqClaTimeAttend.getMemo());
updateClaTime.setLastUpdateUser(loginUser.getUserId());
updateClaTime.setLastUpdateTime(new Date());
claTimeService.updateById(updateClaTime);
} else if ("change".equals(attendType)) {
// 变更上课记录
ScClaTime claTime = claTimeService.getById(courseTimeId);
if (!ClaTimeStatusEnums.WAIT_CLASS.getStatus().equals(claTime.getStatus())) {
return APIResponse.toExceptionResponse("选择计划上课日期,非待上课状态,无法重复上课!");
}
// 变更状态为已上课
ScClaTime updateClaTime = new ScClaTime();
updateClaTime.setCourseTimeId(courseTimeId);
updateClaTime.setRealClaDate(reqClaTimeAttend.getClaDate());
updateClaTime.setTeacherId(reqClaTimeAttend.getTeacherId());
updateClaTime.setClassTheme(reqClaTimeAttend.getClassTheme());
updateClaTime.setRealStartTime(startTime);
updateClaTime.setRealEndTime(endTime);
updateClaTime.setStatus(ClaTimeStatusEnums.HAD_CLASS.getStatus());
updateClaTime.setBookAttendCnt(needAttendCnt);
updateClaTime.setRealAttendCnt(realAttendCnt.intValue());
updateClaTime.setMemo(reqClaTimeAttend.getMemo());
updateClaTime.setLastUpdateUser(loginUser.getUserId());
updateClaTime.setLastUpdateTime(new Date());
claTimeService.updateById(updateClaTime);
} else if ("custom".equals(attendType)) {
// 记录自定义上课信息
ScClaTime addClaTime = new ScClaTime();
addClaTime.setClaId(reqClaTimeAttend.getClaId());
addClaTime.setClaDate(reqClaTimeAttend.getClaDate());
addClaTime.setTeacherId(reqClaTimeAttend.getTeacherId());
addClaTime.setClassTheme(reqClaTimeAttend.getClassTheme());
addClaTime.setStartTime(reqClaTimeAttend.getStartTime());
addClaTime.setEndTime(reqClaTimeAttend.getEndTime());
addClaTime.setRealClaDate(reqClaTimeAttend.getClaDate());
addClaTime.setRealStartTime(reqClaTimeAttend.getStartTime());
addClaTime.setRealEndTime(reqClaTimeAttend.getEndTime());
addClaTime.setSource(ClaTimeSourceEnums.UN_PLAN_CLA_TIME.getSource());
addClaTime.setStatus(ClaTimeStatusEnums.HAD_CLASS.getStatus());
addClaTime.setPayHour(dbCla.getEveryStuLoseHour());
addClaTime.setBookAttendCnt(needAttendCnt);
addClaTime.setRealAttendCnt(realAttendCnt.intValue());
addClaTime.setMemo(reqClaTimeAttend.getMemo());
addClaTime.setCreateUser(loginUser.getUserId());
addClaTime.setCreateTime(new Date());
addClaTime.setLastUpdateUser(loginUser.getUserId());
addClaTime.setLastUpdateTime(new Date());
// 教室不为空 设置教室
if (null != reqClaTimeAttend.getRoomId()) {
ScRoom room = roomService.getById(reqClaTimeAttend.getRoomId());
addClaTime.setRoomId(reqClaTimeAttend.getRoomId());
addClaTime.setRoomName(room.getRoomName());
}
claTimeService.save(addClaTime);
courseTimeId = addClaTime.getCourseTimeId();
}
// 教师信息
SysUser sysStaff = staffService.selectUserById(teacherId);
// 保存上课记录
List<ScClaTimeAttend> saveAttendList = Lists.newArrayList();
// 保存学生日志
List<ScStudentCourseLog> studentCourseLogList = Lists.newArrayList();
for (ReqClaTimeAttendItem attendItem : studentAttendList) {
Long studentCourseId = attendItem.getStudentCourseId();
String attendStatus = attendItem.getAttendStatus();
String memo = attendItem.getMemo();
BigDecimal stuLoseHour = attendItem.getStuLoseHour();
// 如果是请假,消耗课时0
if (ClaTimeAttendStatusEnums.LEAVE_CLASS.getAttendStatus().equals(attendStatus)) {
stuLoseHour = BigDecimal.ZERO;
}
// 获取学生报读班级信息
ScStudentCourse studentCourse = studentCourseService.getById(studentCourseId);
String studentDbChargeType = studentCourse.getChargeType();
// 消耗金额
BigDecimal payFee;
// 上课后剩余课时
BigDecimal changeAfterBalanceHour = null;
// 本次上课对应的订单
Long courseOrderId = null;
if (CourseChargeTypeEnum.DATE.getChargeType().equals(studentDbChargeType)) {
// 按时间上课,不扣减课时
// 获取 消耗金额
ScStudentCourseOrder courseOrder = courseOrderService.getNowValidDateOrder(studentCourseId);
payFee = courseOrder.getUnitFee();
courseOrderId = courseOrder.getCourseOrderId();
} else {
// 本次上课对应的订单
ScStudentCourseOrder courseOrder = courseOrderService.getSubtractHourOrder(studentCourseId);
if (null == courseOrder) {
throw new BusinessException("无法获取对应课时订单,无法扣减课时,id=" + studentCourseId);
}
courseOrderId = courseOrder.getCourseOrderId();
BigDecimal balanceHour = studentCourse.getBalanceHour();
balanceHour = balanceHour.subtract(stuLoseHour);
changeAfterBalanceHour = balanceHour;
// 课时不足 不允许上课
if (balanceHour.compareTo(BigDecimal.ZERO) < 0) {
throw new BusinessException("学员课时不足,不允许上课!");
}
// 更新剩余课时 cas
UpdateWrapper<ScStudentCourse> uwStudentCourse = new UpdateWrapper<>();
uwStudentCourse
.eq("student_course_id", studentCourseId)
.eq("balance_hour", studentCourse.getBalanceHour())
.set("balance_hour", balanceHour)
.set("last_update_user", loginUser.getUserId())
.set("last_update_time", new Date());
boolean update = studentCourseService.update(uwStudentCourse);
if (!update) {
throw new BusinessException("学员课时余额扣减失败,请重试!");
}
// 订单扣减课时,获取 消耗金额
payFee = courseOrderService.subtractCourseOrderBalanceHour(studentCourseId, stuLoseHour);
}
// 消耗总金额
totalPayFee = totalPayFee.add(payFee);
// 每个上课记录
ScClaTimeAttend addClaTimeAttend = new ScClaTimeAttend();
addClaTimeAttend.setStudentCourseId(studentCourseId);
addClaTimeAttend.setCourseOrderId(courseOrderId);
addClaTimeAttend.setCourseTimeId(courseTimeId);
addClaTimeAttend.setStudentId(studentCourse.getStudentId());
addClaTimeAttend.setClaId(studentCourse.getClaId());
addClaTimeAttend.setCourseId(studentCourse.getCourseId());
addClaTimeAttend.setTeacherId(teacherId);
addClaTimeAttend.setTeacherName(sysStaff.getNickName());
addClaTimeAttend.setChargeType(studentDbChargeType);
if (CourseChargeTypeEnum.DATE.getChargeType().equals(studentDbChargeType)) {
addClaTimeAttend.setTeacherGetHour(null);
addClaTimeAttend.setPayHour(null);
} else {
addClaTimeAttend.setTeacherGetHour(stuLoseHour);
addClaTimeAttend.setPayHour(stuLoseHour);
totalPayHour = totalPayHour.add(stuLoseHour);
}
addClaTimeAttend.setAttendStatus(attendStatus);
addClaTimeAttend.setMemo(memo);
addClaTimeAttend.setCreateUser(loginUser.getUserId());
addClaTimeAttend.setPayFee(payFee);
saveAttendList.add(addClaTimeAttend);
// 上课日志
StringBuffer sb = new StringBuffer("");
sb.append("上课[").append(ClaTimeAttendStatusEnums.getNameByStatus(attendStatus)).append("],上课时间").append(reqClaTimeAttend.getClaDate()).append(" ")
.append(reqClaTimeAttend.getStartTime()).append("~").append(reqClaTimeAttend.getEndTime()).append(",");
ScStudentCourseLog studentCourseLog = ScStudentCourseLog.builder()
.studentId(studentCourse.getStudentId())
.logType(LogTypeEnum.ATTEND_CLA.getLogType())
.courseId(scCourse.getCourseId())
.courseName(scCourse.getCourseName())
.claId(dbCla.getClaId())
.claName(dbCla.getClaName())
.deptName(sysDept.getDeptName())
.changeFee(payFee.negate())
.createUser(loginUser.getUserId())
.createUserName(loginUser.getUsername())
.createTime(new Date())
.build();
if (!CourseChargeTypeEnum.DATE.getChargeType().equals(studentDbChargeType)) {
studentCourseLog.setChangeHour(stuLoseHour.negate());
studentCourseLog.setAfterBalanceHour(changeAfterBalanceHour);
sb.append("扣减").append(stuLoseHour.toString()).append("课时,");
sb.append("消耗").append(payFee).append("元.");
}
studentCourseLog.setMemo(sb.toString());
studentCourseLogList.add(studentCourseLog);
}
// 保存上课记录
attendService.saveBatch(saveAttendList);
// 保存学生日志
scStudentCourseLogService.saveBatch(studentCourseLogList);
// 更新上课总课时 人数信息
ScClaTime updateClaTime = new ScClaTime();
updateClaTime.setCourseTimeId(courseTimeId);
updateClaTime.setPayTotalHour(totalPayHour);
updateClaTime.setPayTotalFee(totalPayFee);
updateClaTime.setAtClassCnt(realAttendCnt.intValue());
// updateClaTime.setLeaveCnt(leaveCnt.intValue());
updateClaTime.setOutCnt(outCnt.intValue());
claTimeService.updateById(updateClaTime);
return APIResponse.toOkResponse();
}
/**
*
*
* @param studentCourseId
* @return
*/
public APIResponse stopStudentCourseStatus(Long studentCourseId) {
if (null == studentCourseId) {
return APIResponse.toExceptionResponse(ApiResEnums.PARAM_FAIL);
}
ScStudentCourse studentCourse = studentCourseService.getById(studentCourseId);
if (null == studentCourse) {
return APIResponse.toExceptionResponse("无法获取停课信息,请稍后重试!");
}
if (StudentCourseStatusEnum.STOP_CLA.getStudentCourseStatus().equals(studentCourse.getStatus())) {
return APIResponse.toExceptionResponse("当前状态为停课,无需停课!");
}
// ScStudentCourse update = new ScStudentCourse();
// update.setStudentCourseId(studentCourseId);
// update.setStatus(StudentCourseStatusEnum.STOP_CLA.getStudentCourseStatus());
studentCourseService.update(new UpdateWrapper<ScStudentCourse>()
.eq("student_course_id",studentCourseId)
.set("status",StudentCourseStatusEnum.STOP_CLA.getStudentCourseStatus()));
return APIResponse.toOkResponse();
}
/**
*
*
* @param studentCourseId
* @return
*/
public APIResponse atClaStudentCourseStatus(Long studentCourseId) {
if (null == studentCourseId) {
return APIResponse.toExceptionResponse(ApiResEnums.PARAM_FAIL);
}
ScStudentCourse studentCourse = studentCourseService.getById(studentCourseId);
if (null == studentCourse) {
return APIResponse.toExceptionResponse("无法获取课程信息,请稍后重试!");
}
if (StudentCourseStatusEnum.AT_CLA.getStudentCourseStatus().equals(studentCourse.getStatus())) {
return APIResponse.toExceptionResponse("当前状态为在读,无需变更!");
}
// ScStudentCourse update = new ScStudentCourse();
// update.setStudentCourseId(studentCourseId);
// update.setStatus(StudentCourseStatusEnum.AT_CLA.getStudentCourseStatus());
// studentCourseService.updateById(update);
studentCourseService.update(new UpdateWrapper<ScStudentCourse>()
.eq("student_course_id",studentCourseId)
.set("status",StudentCourseStatusEnum.AT_CLA.getStudentCourseStatus()));
return APIResponse.toOkResponse();
}
/**
*
*
* @return
*/
public List<RespStudentCourse> searchStudentCourse(ReqSearchStudentCourse reqSearchStudentCourse) {
return studentCourseMapper.selectStudentCourseList(reqSearchStudentCourse);
}
/**
*
*
* @param reqSearchStuCourseSignUp
* @return
*/
public RespPage<RespStuCourseSignUpStudent> searchStuCourseSignUpList(ReqSearchStuCourseSignUp reqSearchStuCourseSignUp) {
RespPage<RespStuCourseSignUpStudent> page = new RespPage<>(reqSearchStuCourseSignUp.getPageNum(), reqSearchStuCourseSignUp.getPageSize());
List<RespStuCourseSignUpStudent> signUpStudents = studentCourseMapper.selectStudentSignUpList(reqSearchStuCourseSignUp, page);
page.setRows(signUpStudents);
return page;
}
/**
*
*
* @param studentCourseId
* @return
*/
public APIResponse removeStuFromCla(Long studentCourseId) {
if (null == studentCourseId) {
return APIResponse.toExceptionResponse(ApiResEnums.PARAM_FAIL);
}
ScStudentCourse studentCourse = studentCourseService.getById(studentCourseId);
if (null == studentCourse) {
return APIResponse.toExceptionResponse("无法获取班级学员信息,请稍后重试");
}
Long claId = studentCourse.getClaId();
if (null == claId) {
return APIResponse.toExceptionResponse("未报读班级,无需移除");
}
LoginUser loginUser = SecurityUtils.getLoginUser();
SysDept sysDept = deptService.getById(studentCourse.getDeptId());
UpdateWrapper<ScStudentCourse> uw = new UpdateWrapper<>();
uw.eq("student_course_id", studentCourse.getStudentCourseId());
uw.isNotNull("cla_id");
uw.set("cla_id", null);
uw.set("cla_name", null);
uw.set("last_update_user", loginUser.getUserId());
uw.set("last_update_time", new Date());
boolean update = studentCourseService.update(uw);
if (!update) {
return APIResponse.toExceptionResponse("从班级中移除失败,请稍后重试");
}
// 日志
ScStudentCourseLog studentCourseLog = ScStudentCourseLog.builder()
.studentId(studentCourse.getStudentId())
.logType(LogTypeEnum.OUT_CLA.getLogType())
.courseId(studentCourse.getCourseId())
.courseName(studentCourse.getCourseName())
.deptName(sysDept.getDeptName())
.memo("退出班级,从'" + studentCourse.getClaName() + "'班级删除")
.createUser(loginUser.getUserId())
.createUserName(loginUser.getUsername())
.build();
scStudentCourseLogService.save(studentCourseLog);
return APIResponse.toOkResponse();
}
}

@ -1,24 +0,0 @@
package cn.xluobo.business.sc.student.service;
import cn.xluobo.business.sc.student.repo.model.ScStudentContact;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-09-27
*/
public interface IScStudentContactService extends IService<ScStudentContact> {
/**
*
* @param studentId
* @return
*/
List<ScStudentContact> getStudentContactList(Long studentId);
}

@ -1,70 +0,0 @@
package cn.xluobo.business.sc.student.service;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder;
import com.baomidou.mybatisplus.extension.service.IService;
import java.math.BigDecimal;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-08-21
*/
public interface IScStudentCourseOrderService extends IService<ScStudentCourseOrder> {
/**
*
*
* @param studentId
* @param courseId
* @param beginDate
* @param endDate
* @return
*/
boolean checkDateCover(Long studentId, Long courseId,
String beginDate, String endDate);
/**
*
* @param studentCourseId
* @return
*/
ScStudentCourseOrder getSubtractHourOrder(Long studentCourseId);
/**
*
* @param studentCourseId
* @return
*/
ScStudentCourseOrder getNowValidDateOrder(Long studentCourseId);
/**
*
* @param studentCourseId
* @param loseHour
* @return
*/
BigDecimal subtractCourseOrderBalanceHour(Long studentCourseId, BigDecimal loseHour);
/**
*
*
* @param studentCourseId
* @param recoverHour
* @return
*/
void recoverOrderLoseHour(Long studentCourseId, BigDecimal recoverHour);
/**
*
* @param courseOrderId
* @param newBalanceHour
* @param oldBalanceHour
*/
void updateBalanceHour(Long courseOrderId, BigDecimal newBalanceHour, BigDecimal oldBalanceHour);
}

@ -1,89 +0,0 @@
package cn.xluobo.business.sc.student.service;
import cn.xluobo.business.sc.course.repo.model.ScClaTime;
import cn.xluobo.business.sc.course.repo.model.ScClaTimeAttend;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import cn.xluobo.core.api.APIBaseResponse;
import com.baomidou.mybatisplus.extension.service.IService;
import com.ruoyi.common.core.domain.model.LoginUser;
import java.util.Map;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-08-21
*/
public interface IScStudentCourseService extends IService<ScStudentCourse> {
/**
*
*
* @param studentId
* @param courseIds
* @param deptId
* @return
*/
APIBaseResponse checkStudentCanSignUpCourse(Long studentId, Long[] courseIds, Long deptId);
/**
*
*
* @param studentId
* @param courseId
* @param deptId
* @param studentCourseChargeTypeMap null
* @return
*/
APIBaseResponse checkStudentCanSignUpCourse(Long studentId,
Long courseId,
Long deptId,
Map<Long, String> studentCourseChargeTypeMap);
/**
*
* @param studentId
* @param courseId
* @return
*/
ScStudentCourse selectByStudentIdCourseId(Long studentId, Long courseId);
/**
* 0
* @param studentCourseId
* @return
*/
int deleteWhenTotalHourZeroForInvalid(Long studentCourseId);
/**
* 0
* @param studentCourseId
* @return
*/
int deleteWhenTotalDayZeroForInvalid(Long studentCourseId);
/**
*
* @return
*/
Integer getWillExpireDateCount(Integer minBalanceDay);
/**
*
* @param minBalanceHour
* @return
*/
Integer getWillExpireHourCount(Integer minBalanceHour);
/**
*
* @param claTimeAttend
* @param claTime
* @param loginUser
*/
void recoverStudentCourseHour(ScClaTimeAttend claTimeAttend, ScClaTime claTime, LoginUser loginUser);
}

@ -1,31 +0,0 @@
package cn.xluobo.business.sc.student.service.impl;
import cn.xluobo.business.sc.student.repo.mapper.ScStudentContactMapper;
import cn.xluobo.business.sc.student.repo.model.ScStudentContact;
import cn.xluobo.business.sc.student.service.IScStudentContactService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-09-27
*/
@Service
public class ScStudentContactServiceImpl extends ServiceImpl<ScStudentContactMapper, ScStudentContact> implements IScStudentContactService {
@Override
public List<ScStudentContact> getStudentContactList(Long studentId) {
QueryWrapper<ScStudentContact> qw = new QueryWrapper<>();
qw.eq("student_id", studentId);
qw.orderByAsc("create_time");
List<ScStudentContact> contacts = this.list(qw);
return contacts;
}
}

@ -1,154 +0,0 @@
package cn.xluobo.business.sc.student.service.impl;
import cn.xluobo.business.sc.student.repo.mapper.ScStudentCourseMapper;
import cn.xluobo.business.sc.student.repo.mapper.ScStudentCourseOrderMapper;
import cn.xluobo.business.sc.student.repo.mapper.ScStudentMapper;
import cn.xluobo.business.sc.student.repo.model.ScStudent;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder;
import cn.xluobo.business.sc.student.service.IScStudentCourseOrderService;
import cn.xluobo.config.exception.BusinessException;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.List;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-08-21
*/
@Service
public class ScStudentCourseOrderServiceImpl extends ServiceImpl<ScStudentCourseOrderMapper, ScStudentCourseOrder> implements IScStudentCourseOrderService {
@Autowired
private ScStudentCourseMapper studentCourseMapper;
@Autowired
private ScStudentMapper studentMapper;
@Override
public boolean checkDateCover(Long studentId, Long courseId, String beginDate, String endDate) {
int checkDateCover = baseMapper.checkDateCover(studentId, courseId, beginDate, endDate);
if (checkDateCover == 0) {
return false;
} else {
return true;
}
}
@Override
public ScStudentCourseOrder getSubtractHourOrder(Long studentCourseId) {
return baseMapper.selectSubtractHourOrder(studentCourseId);
}
@Override
public ScStudentCourseOrder getNowValidDateOrder(Long studentCourseId) {
return baseMapper.selectNowValidDateOrder(studentCourseId);
}
@Override
public BigDecimal subtractCourseOrderBalanceHour(Long studentCourseId, BigDecimal loseHour) {
List<ScStudentCourseOrder> studentCourseOrderList = baseMapper.selectSubtractHourOrderList(studentCourseId);
BigDecimal payFee = BigDecimal.ZERO;
for (ScStudentCourseOrder courseOrder : studentCourseOrderList) {
if (loseHour.compareTo(BigDecimal.ZERO) == 0) {
break;
}
BigDecimal balanceHour = courseOrder.getBalanceHour();
// 订单剩余课时不足扣减
if (balanceHour.compareTo(loseHour) < 0) {
payFee = payFee.add(balanceHour.multiply(courseOrder.getUnitFee()));
// 剩余课时不足扣减, 将剩余课时扣减完毕
int updateSubtractHour = baseMapper.updateSubtractHour(courseOrder.getCourseOrderId(), BigDecimal.ZERO, balanceHour);
if (updateSubtractHour == 0) {
throw new BusinessException("订单扣减课时失败,请重试!");
}
loseHour = loseHour.subtract(balanceHour);
} else {
payFee = payFee.add(loseHour.multiply(courseOrder.getUnitFee()));
// 直接扣减课时
BigDecimal newHour = balanceHour.subtract(loseHour);
int updateSubtractHour = baseMapper.updateSubtractHour(courseOrder.getCourseOrderId(), newHour, balanceHour);
if (updateSubtractHour == 0) {
throw new BusinessException("订单扣减课时失败,请重试!");
}
}
}
return payFee;
}
@Override
public void recoverOrderLoseHour(Long studentCourseId, BigDecimal recoverHour) {
if(recoverHour.compareTo(BigDecimal.ZERO) == 0) {
return;
}
List<ScStudentCourseOrder> recoverHourOrderList = baseMapper.selectRecoverHourOrderList(studentCourseId);
if (recoverHourOrderList.size() == 0) {
ScStudentCourse studentCourse = studentCourseMapper.selectById(studentCourseId);
ScStudent student = studentMapper.selectById(studentCourse.getStudentId());
throw new BusinessException("学员:" + student.getStudentName() + ",无生效订单,无法恢复课时!");
}
for (int i = 0; i < recoverHourOrderList.size(); i++) {
if(recoverHour.compareTo(BigDecimal.ZERO) == 0) {
return;
}
// 是否为最后一条记录
boolean lastRecord = (i == (recoverHourOrderList.size() - 1));
ScStudentCourseOrder studentCourseOrder = recoverHourOrderList.get(i);
BigDecimal balanceHour = studentCourseOrder.getBalanceHour();
BigDecimal totalHour = studentCourseOrder.getTotalHour();
if(lastRecord) {
BigDecimal newBalanceHour = studentCourseOrder.getBalanceHour().add(recoverHour);
this.updateBalanceHour(studentCourseOrder.getCourseOrderId(), newBalanceHour, balanceHour);
break;
} else {
if(balanceHour.compareTo(totalHour) < 0) {
// 可恢复课时数量
BigDecimal canRecoverHour = totalHour.subtract(balanceHour);
if(canRecoverHour.compareTo(recoverHour) > 0) {
// 订单可恢复课时数量canRecoverHour > 需要恢复的课时数量recoverHour直接全部恢复
BigDecimal newBalanceHour = studentCourseOrder.getBalanceHour().add(recoverHour);
this.updateBalanceHour(studentCourseOrder.getCourseOrderId(), newBalanceHour, balanceHour);
recoverHour = BigDecimal.ZERO;
} else {
// 订单可恢复课时数量canRecoverHour <= 需要恢复的课时数量recoverHour
BigDecimal newBalanceHour = studentCourseOrder.getBalanceHour().add(canRecoverHour);
this.updateBalanceHour(studentCourseOrder.getCourseOrderId(), newBalanceHour, balanceHour);
// 剩余需恢复课时
recoverHour = recoverHour.subtract(canRecoverHour);
}
}
}
}
}
@Override
public void updateBalanceHour(Long courseOrderId, BigDecimal newBalanceHour, BigDecimal oldBalanceHour) {
UpdateWrapper<ScStudentCourseOrder> uw = new UpdateWrapper<>();
uw.eq("course_order_id", courseOrderId);
uw.eq("balance_hour", oldBalanceHour);
uw.set("balance_hour", newBalanceHour);
boolean update = this.update(uw);
if (!update) {
throw new BusinessException("订单恢复课时失败,请重试!");
}
}
}

@ -1,209 +0,0 @@
package cn.xluobo.business.sc.student.service.impl;
import cn.xluobo.business.sc.course.enums.CourseChargeTypeEnum;
import cn.xluobo.business.sc.course.repo.mapper.ScCourseChargeMapper;
import cn.xluobo.business.sc.course.repo.mapper.ScCourseMapper;
import cn.xluobo.business.sc.course.repo.model.ScClaTime;
import cn.xluobo.business.sc.course.repo.model.ScClaTimeAttend;
import cn.xluobo.business.sc.course.repo.model.ScCourse;
import cn.xluobo.business.sc.course.repo.model.ScCourseCharge;
import cn.xluobo.business.sc.log.enums.LogTypeEnum;
import cn.xluobo.business.sc.log.repo.model.ScStudentCourseLog;
import cn.xluobo.business.sc.log.service.IScStudentCourseLogService;
import cn.xluobo.business.sc.student.repo.mapper.ScStudentCourseMapper;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import cn.xluobo.business.sc.student.service.IScStudentCourseOrderService;
import cn.xluobo.business.sc.student.service.IScStudentCourseService;
import cn.xluobo.business.sys.admin.repo.mapper.ISysDeptMapper;
import cn.xluobo.config.exception.BusinessException;
import cn.xluobo.core.api.APIBaseResponse;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* <p>
*
* </p>
*
* @author zhangby
* @since 2020-08-21
*/
@Service
public class ScStudentCourseServiceImpl extends ServiceImpl<ScStudentCourseMapper, ScStudentCourse> implements IScStudentCourseService {
@Autowired
private ScCourseChargeMapper courseChargeMapper;
@Autowired
private ScCourseMapper courseMapper;
@Autowired
private ISysDeptMapper deptMapper;
@Autowired
private IScStudentCourseOrderService courseOrderService;
@Autowired
private IScStudentCourseLogService scStudentCourseLogService;
@Override
public APIBaseResponse checkStudentCanSignUpCourse(Long studentId, Long[] courseIds, Long deptId) {
// 学生已报名课程收费模式
QueryWrapper<ScStudentCourse> qw = new QueryWrapper<>();
qw.select("course_id", "charge_type");
qw.eq("student_id", studentId);
List<ScStudentCourse> studentCourseList = this.list(qw);
Map<Long, String> studentCourseChargeTypeMap = studentCourseList.stream().collect(Collectors.toMap(ScStudentCourse::getCourseId, ScStudentCourse::getChargeType));
for (Long courseId : courseIds) {
APIBaseResponse response = this.checkStudentCanSignUpCourse(studentId, courseId, deptId, studentCourseChargeTypeMap);
if(!response.isSuccess()) {
return response;
}
}
return APIBaseResponse.success();
}
@Override
public APIBaseResponse checkStudentCanSignUpCourse(Long studentId, Long courseId, Long deptId,Map<Long, String> studentCourseChargeTypeMap) {
if (null == studentCourseChargeTypeMap) {
QueryWrapper<ScStudentCourse> qw = new QueryWrapper<>();
qw.select("course_id", "charge_type");
qw.eq("student_id", studentId);
List<ScStudentCourse> studentCourseList = this.list(qw);
studentCourseChargeTypeMap = studentCourseList.stream().collect(Collectors.toMap(ScStudentCourse::getCourseId, ScStudentCourse::getChargeType));
}
ScCourse scCourse = courseMapper.selectById(courseId);
if( null == scCourse) {
return APIBaseResponse.fail("无法获取课程信息,请重试");
}
// 已报读的 收费方式
String studentCourseChargeType = studentCourseChargeTypeMap.get(courseId);
if("cycle".equals(studentCourseChargeType)) {
return APIBaseResponse.fail("该学生 已" + CourseChargeTypeEnum.getChargeType(studentCourseChargeType) + "报读'" + scCourse.getCourseName() + "',无法重复报读!");
}
// 课程收费配置信息
QueryWrapper<ScCourseCharge> qw = new QueryWrapper<>();
qw.eq("course_id", courseId);
if (StringUtils.isNotEmpty(studentCourseChargeType)) {
qw.eq("charge_type", studentCourseChargeType);
}
List<ScCourseCharge> courseChargeList = courseChargeMapper.selectList(qw);
// 校验学生是否可选择课程 (是否含 已报读的 收费方式)
if (studentCourseChargeTypeMap.containsKey(courseId)) {
// 是否包含
boolean checkHasStudentCourseChargeType = courseChargeList.stream().anyMatch(item -> item.getChargeType().equals(studentCourseChargeType));
if (!checkHasStudentCourseChargeType) {
return APIBaseResponse.fail("该学生 已" + CourseChargeTypeEnum.getChargeType(studentCourseChargeType) + "报读'" + scCourse.getCourseName() + "',目前该课程暂无此收费模式,请核查!");
}
}
if (null != deptId) {
// 校验是否配置了本校区
boolean checkChargeDept = courseChargeList.stream().anyMatch(item -> item.getDepartId().compareTo(deptId) == 0 || item.getDepartId().compareTo(-1L) == 0);
if (!checkChargeDept) {
SysDept sysDept = deptMapper.selectById(deptId);
return APIBaseResponse.fail(scCourse.getCourseName() + "(" + CourseChargeTypeEnum.getChargeType(studentCourseChargeType) + ")未在'" + sysDept.getDeptName() + "'开课");
}
}
return APIBaseResponse.success();
}
@Override
public ScStudentCourse selectByStudentIdCourseId(Long studentId, Long courseId) {
QueryWrapper qw = new QueryWrapper();
qw.eq("student_id",studentId);
qw.eq("course_id",courseId);
return this.getOne(qw);
}
@Override
public int deleteWhenTotalHourZeroForInvalid(Long studentCourseId) {
return baseMapper.deleteWhenTotalHourZeroForInvalid(studentCourseId);
}
@Override
public int deleteWhenTotalDayZeroForInvalid(Long studentCourseId) {
return baseMapper.deleteWhenTotalDayZeroForInvalid(studentCourseId);
}
@Override
public Integer getWillExpireDateCount(Integer minBalanceDay) {
return baseMapper.selectWillExpireDateCount(minBalanceDay, SecurityUtils.getLoginUser().getNowTenantId());
}
@Override
public Integer getWillExpireHourCount(Integer minBalanceHour) {
return baseMapper.selectWillExpireHourCount(minBalanceHour, SecurityUtils.getLoginUser().getNowTenantId());
}
@Override
public void recoverStudentCourseHour(ScClaTimeAttend claTimeAttend, ScClaTime claTime, LoginUser loginUser) {
Long studentCourseId = claTimeAttend.getStudentCourseId();
String chargeType = claTimeAttend.getChargeType();
BigDecimal payHour = claTimeAttend.getPayHour();
// 学员日志
StringBuffer sb = new StringBuffer("");
sb.append("恢复课时[编辑/删除上课记录],").append("上课时间").append(claTime.getRealClaDate()).append(" ")
.append(claTime.getRealStartTime()).append("~").append(claTime.getRealEndTime()).append(",");
ScStudentCourseLog studentCourseLog = ScStudentCourseLog.builder()
.studentId(claTimeAttend.getStudentId())
.logType(LogTypeEnum.DELETE_ATTEND_CLA.getLogType())
.courseId(claTimeAttend.getCourseId())
.courseName(claTime.getCourseName())
.claId(claTimeAttend.getClaId())
.claName(claTime.getClaName())
.deptName(claTime.getDeptName())
.changeHour(claTimeAttend.getPayHour())
.changeFee(claTimeAttend.getPayFee())
.createUser(loginUser.getUserId())
.createUserName(loginUser.getUsername())
.createTime(new Date())
.build();
if (!CourseChargeTypeEnum.DATE.getChargeType().equals(chargeType)) {
ScStudentCourse studentCourse = this.getById(studentCourseId);
if (null == studentCourse) {
throw new BusinessException("恢复学生课时失败,无法获取学生课时信息!");
}
// 消耗课时> 0 , 恢复课时
if (payHour.compareTo(BigDecimal.ZERO) > 0) {
UpdateWrapper<ScStudentCourse> uwStudentCourse = new UpdateWrapper<>();
uwStudentCourse
.eq("student_course_id", studentCourseId)
.eq("balance_hour", studentCourse.getBalanceHour())
.set("balance_hour", studentCourse.getBalanceHour().add(payHour))
.set("last_update_user", loginUser.getUserId())
.set("last_update_time", new Date());
boolean update = this.update(uwStudentCourse);
if (!update) {
throw new BusinessException("学员剩余课时恢复失败,请重试!");
}
studentCourseLog.setAfterBalanceHour(studentCourse.getBalanceHour().add(payHour));
} else {
studentCourseLog.setAfterBalanceHour(studentCourse.getBalanceHour().add(payHour));
}
sb.append("恢复").append(payHour.toString()).append("课时");
// 恢复订单课时
courseOrderService.recoverOrderLoseHour(studentCourse.getStudentCourseId(), payHour);
}
studentCourseLog.setMemo(sb.toString());
scStudentCourseLogService.save(studentCourseLog);
}
}

@ -1,9 +1,9 @@
package cn.xluobo.business.sys.admin.controller;
import cn.xluobo.business.sys.admin.domain.resp.RespTreeSelect;
import cn.xluobo.business.sys.admin.service.BusinessSysDeptService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.system.domain.resp.RespTreeSelect;
import com.ruoyi.system.service.impl.BusinessSysDeptService;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@ -3,8 +3,8 @@ package cn.xluobo.business.sys.admin.controller;
import cn.xluobo.business.sys.admin.domain.req.ReqPageSelect;
import cn.xluobo.business.sys.admin.domain.req.ReqSearchSysDictData;
import cn.xluobo.business.sys.admin.service.BusinessSysDictDataService;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import com.ruoyi.common.core.domain.entity.SysDictData;
import org.springframework.beans.factory.annotation.Autowired;

@ -2,6 +2,7 @@ package cn.xluobo.business.sys.admin.domain.resp;
import com.google.common.collect.Lists;
import com.ruoyi.common.core.domain.entity.SysMenu;
import com.ruoyi.system.domain.resp.RespTreeSelect;
import java.util.*;

@ -2,8 +2,8 @@ package cn.xluobo.business.sys.admin.service;
import cn.xluobo.business.sys.admin.domain.req.ReqPageSelect;
import cn.xluobo.business.sys.admin.domain.req.ReqSearchSysDictData;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.core.domain.entity.SysDictData;
@ -17,7 +17,6 @@ import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
/**

@ -3,8 +3,6 @@ package cn.xluobo.business.sys.admin.service;
import com.baomidou.mybatisplus.extension.service.IService;
import com.ruoyi.common.core.domain.entity.SysDept;
import java.util.List;
/**
* <p>
*
@ -15,41 +13,4 @@ import java.util.List;
*/
public interface ISysDeptService extends IService<SysDept> {
/**
*
* @param departId
* @return
*/
boolean hadChild(Long departId);
/**
*
* @param departId
* @return
*/
boolean hadUser(Long departId);
/**
*
* @param deptId ID
* @param newAncestors ID
* @param oldAncestors ID
*/
void updateDeptChildren(Long deptId, String newAncestors, String oldAncestors);
/**
*
* @return
*/
List<SysDept> selectUserCampusList(Long userId);
/**
* dept
*
*
* @param userId
* @param deptId
* @return
*/
boolean checkUserDeptInUse(Long userId, Long deptId);
}

@ -2,13 +2,10 @@ package cn.xluobo.business.sys.admin.service.impl;
import cn.xluobo.business.sys.admin.repo.mapper.ISysDeptMapper;
import cn.xluobo.business.sys.admin.service.ISysDeptService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.ruoyi.common.core.domain.entity.SysDept;
import org.springframework.stereotype.Service;
import java.util.List;
/**
* <p>
*
@ -20,50 +17,4 @@ import java.util.List;
@Service
public class ISysDeptServiceImpl extends ServiceImpl<ISysDeptMapper, SysDept> implements ISysDeptService {
/**
*
* @param departId
* @return
*/
public boolean hadChild(Long departId){
QueryWrapper qw = new QueryWrapper();
qw.eq("parent_id",departId);
List list = list(qw);
if(list.isEmpty()){
return false;
}else {
return true;
}
}
@Override
public boolean hadUser(Long departId) {
// TODO: 2020-01-18 是否存在用户
return false;
}
@Override
public void updateDeptChildren(Long deptId, String newAncestors, String oldAncestors) {
QueryWrapper qw = new QueryWrapper();
qw.eq("parent_id",deptId);
List<SysDept> childrenList = list(qw);
if(!childrenList.isEmpty()){
for (SysDept children : childrenList) {
children.setAncestors(children.getAncestors().replace(oldAncestors, newAncestors));
}
updateBatchById(childrenList);
}
}
@Override
public List<SysDept> selectUserCampusList(Long userId) {
return baseMapper.selectUserCampusList(userId, "2");
}
@Override
public boolean checkUserDeptInUse(Long userId, Long deptId) {
SysDept sysDept = baseMapper.selectUserDeptInUse(userId, deptId);
return null != sysDept;
}
}

@ -1,7 +1,7 @@
package cn.xluobo.business.sys.holiday.service;
import cn.xluobo.business.sys.holiday.repo.model.SysHoliday;
import cn.xluobo.core.api.APIBaseResponse;
import com.ruoyi.core.api.APIBaseResponse;
import com.baomidou.mybatisplus.extension.service.IService;
import java.util.List;

@ -3,7 +3,7 @@ package cn.xluobo.business.sys.holiday.service.impl;
import cn.xluobo.business.sys.holiday.repo.mapper.SysHolidayMapper;
import cn.xluobo.business.sys.holiday.repo.model.SysHoliday;
import cn.xluobo.business.sys.holiday.service.ISysHolidayService;
import cn.xluobo.core.api.APIBaseResponse;
import com.ruoyi.core.api.APIBaseResponse;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

@ -3,7 +3,7 @@ package cn.xluobo.business.sys.receipt.controller;
import cn.xluobo.business.sys.receipt.domain.req.ReqSearchSysReceiptAccount;
import cn.xluobo.business.sys.receipt.repo.model.SysReceiptAccount;
import cn.xluobo.business.sys.receipt.service.BusinessSysReceiptAccountService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -2,8 +2,8 @@ package cn.xluobo.business.sys.receipt.service;
import cn.xluobo.business.sys.receipt.domain.req.ReqSearchSysReceiptAccount;
import cn.xluobo.business.sys.receipt.repo.model.SysReceiptAccount;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.core.domain.model.LoginUser;

@ -1,16 +1,12 @@
package cn.xluobo.business.sys.staff.controller;
import cn.xluobo.business.sc.course.domain.req.ReqSelect;
import com.ruoyi.common.core.domain.AjaxResult;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.system.service.ISysUserService;
import com.ruoyi.system.service.columns.ISysTeacherService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
/**
* <p>
* Controller
@ -23,21 +19,22 @@ import java.util.List;
@RequestMapping("/api/sys/staff")
public class SysStaffController {
@Autowired
private ISysUserService userService;
@Autowired
private ISysTeacherService teacherService;
/**
* select
*
* @return
*/
@GetMapping("/list/teacherSelect")
public AjaxResult teacherSelect(ReqSelect reqSelect) {
SysUser sysUser = new SysUser();
sysUser.setTeacher(1);
List<SysUser> sysUsers = userService.selectUserList(sysUser);
return AjaxResult.success(sysUsers);
public AjaxResult teacherSelect() {
// SysUser sysUser = new SysUser();
// sysUser.setTeacher(1);
// List<SysUser> sysUsers = teacherService.(sysUser);
return AjaxResult.success();
}

@ -3,7 +3,7 @@ package cn.xluobo.business.sys.tag.controller;
import cn.xluobo.business.sys.tag.domain.req.ReqSearchSysTag;
import cn.xluobo.business.sys.tag.repo.model.SysTag;
import cn.xluobo.business.sys.tag.service.BusinessSysTagService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -2,8 +2,8 @@ package cn.xluobo.business.sys.tag.service;
import cn.xluobo.business.sys.tag.domain.req.ReqSearchSysTag;
import cn.xluobo.business.sys.tag.repo.model.SysTag;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.core.domain.model.LoginUser;

@ -3,7 +3,7 @@ package cn.xluobo.business.tool.impt.controller;
import cn.xluobo.business.tool.impt.domain.ReqDownImplTemplate;
import cn.xluobo.business.tool.impt.domain.ReqUploadImplData;
import cn.xluobo.business.tool.impt.service.BusinessImportService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -1,18 +1,18 @@
package cn.xluobo.business.tool.impt.listener;
import cn.hutool.core.util.ObjectUtil;
import cn.xluobo.business.sc.course.repo.enums.ClaTimeRepeatTypeEnums;
import cn.xluobo.business.sc.course.repo.enums.ClaTimeRuleTypeEnums;
import cn.xluobo.business.sc.course.repo.model.ScClaTimeRule;
import cn.xluobo.business.sc.course.repo.model.ScCourseCla;
import cn.xluobo.business.sc.course.service.BusinessClaTimeRuleService;
import cn.xluobo.business.sc.course.service.IScCourseClaService;
import com.ruoyi.school.course.enums.ClaTimeRepeatTypeEnums;
import com.ruoyi.school.course.enums.ClaTimeRuleTypeEnums;
import com.ruoyi.school.course.domain.ScClaTimeRule;
import com.ruoyi.school.course.domain.ScCourseCla;
import com.ruoyi.school.course.service.BusinessClaTimeRuleService;
import com.ruoyi.school.course.service.IScCourseClaService;
import cn.xluobo.business.tool.impt.domain.ImportCourseCla;
import cn.xluobo.core.api.APIBaseResponse;
import cn.xluobo.core.utils.DateUtil;
import com.ruoyi.core.utils.DateUtil;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.google.common.collect.Lists;
import com.ruoyi.core.api.APIBaseResponse;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
@ -119,7 +119,6 @@ public class ImportCourseClaListener extends AnalysisEventListener<ImportCourseC
cla.setClaName(courseCla.getClaName());
cla.setCapacity(Integer.parseInt(courseCla.getCapacity()));
cla.setRecruitStatus(recruitStatus);
cla.setEveryStuLoseHour(new BigDecimal(courseCla.getEveryStuLoseHour()));
cla.setOpenDate(courseCla.getOpenDate());
cla.setCloseDate(courseCla.getCloseDate());
cla.setMemo(courseCla.getMemo());

@ -1,16 +1,16 @@
package cn.xluobo.business.tool.impt.listener;
import cn.xluobo.business.sc.course.enums.CourseChargeTypeEnum;
import cn.xluobo.business.sc.course.repo.model.ScCourse;
import cn.xluobo.business.sc.course.repo.model.ScCourseCharge;
import cn.xluobo.business.sc.course.service.IScCourseChargeService;
import cn.xluobo.business.sc.course.service.IScCourseService;
import cn.xluobo.business.tool.impt.domain.ImportCourse;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.alibaba.fastjson.JSON;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.ruoyi.school.course.enums.CourseChargeTypeEnum;
import com.ruoyi.school.course.domain.ScCourse;
import com.ruoyi.school.course.domain.req.course.ScCourseCharge;
import com.ruoyi.school.course.service.IScCourseChargeService;
import com.ruoyi.school.course.service.IScCourseService;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;

@ -1,753 +0,0 @@
package cn.xluobo.business.tool.impt.listener;
import cn.hutool.core.util.ObjectUtil;
import cn.xluobo.business.sc.course.domain.export.ExpCourse;
import cn.xluobo.business.sc.course.domain.req.ReqCourseClaSelect;
import cn.xluobo.business.sc.course.domain.req.ReqSearchScCourse;
import cn.xluobo.business.sc.course.domain.resp.RespCourseClaSelectInfo;
import cn.xluobo.business.sc.course.enums.ChargeDateUnitEnum;
import cn.xluobo.business.sc.course.enums.CourseChargeTypeEnum;
import cn.xluobo.business.sc.course.repo.mapper.ScCourseClaMapper;
import cn.xluobo.business.sc.course.repo.mapper.ScCourseMapper;
import cn.xluobo.business.sc.course.repo.model.ScCourseCharge;
import cn.xluobo.business.sc.course.service.IScCourseChargeService;
import cn.xluobo.business.sc.log.enums.LogTypeEnum;
import cn.xluobo.business.sc.log.repo.model.ScStudentCourseLog;
import cn.xluobo.business.sc.log.service.IScStudentCourseLogService;
import cn.xluobo.business.sc.order.enums.OrderStatusEnum;
import cn.xluobo.business.sc.order.repo.model.ScOrder;
import cn.xluobo.business.sc.order.repo.model.ScOrderAccount;
import cn.xluobo.business.sc.order.repo.model.ScOrderDetail;
import cn.xluobo.business.sc.order.service.IScOrderAccountService;
import cn.xluobo.business.sc.order.service.IScOrderDetailService;
import cn.xluobo.business.sc.order.service.IScOrderService;
import cn.xluobo.business.sc.student.repo.model.ScStudent;
import cn.xluobo.business.sc.student.repo.model.ScStudentContact;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourseOrder;
import cn.xluobo.business.sc.student.service.IScStudentContactService;
import cn.xluobo.business.sc.student.service.IScStudentCourseOrderService;
import cn.xluobo.business.sc.student.service.IScStudentCourseService;
import cn.xluobo.business.sc.student.service.IScStudentService;
import cn.xluobo.business.sys.admin.domain.resp.RespTreeSelect;
import cn.xluobo.business.sys.admin.service.BusinessSysDeptService;
import cn.xluobo.business.sys.admin.service.BusinessSysDictDataService;
import cn.xluobo.business.sys.receipt.repo.model.SysReceiptAccount;
import cn.xluobo.business.sys.receipt.service.ISysReceiptAccountService;
import cn.xluobo.business.tool.impt.domain.ImportStudentOrder;
import cn.xluobo.core.api.APIBaseResponse;
import cn.xluobo.core.page.RespPage;
import cn.xluobo.core.utils.DateUtil;
import cn.xluobo.utils.ContextUtils;
import com.alibaba.excel.context.AnalysisContext;
import com.alibaba.excel.event.AnalysisEventListener;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.system.service.ISysUserService;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.joda.time.Period;
import org.joda.time.PeriodType;
import java.math.BigDecimal;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* @author zhangbaoyu
* @date Created in 2020/10/12 17:12
*/
@Slf4j
@Data
public class ImportStudentOrderListener extends AnalysisEventListener<ImportStudentOrder> {
private IScStudentService studentService;
private IScOrderService orderService;
private IScOrderDetailService orderDetailService;
private IScStudentContactService studentContactService;
private IScStudentCourseService studentCourseService;
private IScStudentCourseOrderService courseOrderService;
private IScOrderAccountService orderAccountService;
private BusinessSysDictDataService dictDataService;
private BusinessSysDeptService deptService;
private ScCourseMapper courseMapper;
private ScCourseClaMapper claMapper;
private ISysReceiptAccountService receiptAccountService;
private ISysUserService staffService;
private IScCourseChargeService courseChargeService;
private IScStudentCourseLogService scStudentCourseLogService;
/**
*
*/
private Boolean needSave;
// key=value value=contactRelationId
private Map<String, String> contactRelationMap = Maps.newHashMap();
// key=value value=sexId
private Map<String, String> sexMap = Maps.newHashMap();
// key=schoolName value=schoolId
private Map<String, Long> schoolMap = Maps.newHashMap();
// key=detailTagName value=detailTagId
private Map<String, String> orderDetailTagMap = Maps.newHashMap();
// key=deptName value=deptId
private Map<String, Long> campusMap = Maps.newHashMap();
// key=courseChargeName value=chargeId
private Map<String, Long> courseChargeMap = Maps.newHashMap();
private Map<String, RespCourseClaSelectInfo> claMap = Maps.newHashMap();
// key=courseId value=value
private Map<Long, String> courseMap = Maps.newHashMap();
// key=name value=receiptAccountId
private Map<String, Long> receiptAccountMap = Maps.newHashMap();
// key=staffName value=staffId
private Map<String, Long> staffMap = Maps.newHashMap();
private Map<Long, ScCourseCharge> chargeCacheMap = Maps.newHashMap();
// key=studentName value=studentId
private Map<String, Long> studentMap = Maps.newHashMap();
private boolean hadMoreStudent;
// 登录用户id
private Long loginUserId = 0L;
private LoginUser loginUser;
// 导入id
private Long importId;
// 需保存的successRecordList
private List<ImportStudentOrder> successRecordList = Lists.newArrayList();
// 校验失败的列表
private List<ImportStudentOrder> failRecordList = Lists.newArrayList();
/**
*
*/
int maxRecord = 200;
/**
*
*/
int hadReadRecord = 0;
public ImportStudentOrderListener() {
studentService = ContextUtils.getBean(IScStudentService.class);
orderService = ContextUtils.getBean(IScOrderService.class);
orderDetailService = ContextUtils.getBean(IScOrderDetailService.class);
studentContactService = ContextUtils.getBean(IScStudentContactService.class);
studentCourseService = ContextUtils.getBean(IScStudentCourseService.class);
courseOrderService = ContextUtils.getBean(IScStudentCourseOrderService.class);
orderAccountService = ContextUtils.getBean(IScOrderAccountService.class);
dictDataService = ContextUtils.getBean(BusinessSysDictDataService.class);
deptService = ContextUtils.getBean(BusinessSysDeptService.class);
courseMapper = ContextUtils.getBean(ScCourseMapper.class);
claMapper = ContextUtils.getBean(ScCourseClaMapper.class);
receiptAccountService = ContextUtils.getBean(ISysReceiptAccountService.class);
courseChargeService = ContextUtils.getBean(IScCourseChargeService.class);
scStudentCourseLogService = ContextUtils.getBean(IScStudentCourseLogService.class);
this.initCacheMap();
}
@Override
public void invoke(ImportStudentOrder data, AnalysisContext context) {
APIBaseResponse checkParam = checkParam(data);
if (!checkParam.isSuccess()) {
data.setFailMsg(checkParam.getRespMsg());
failRecordList.add(data);
return;
}
successRecordList.add(data);
}
@Override
public void doAfterAllAnalysed(AnalysisContext context) {
if (needSave) {
saveStudentOrder();
}
log.info("doAfterAllAnalysed");
}
@Override
public boolean hasNext(AnalysisContext context) {
if (hadReadRecord++ < maxRecord) {
return true;
}
return false;
}
/**
*
*/
public void saveStudentOrder() {
for (ImportStudentOrder studentOrder : successRecordList) {
String studentName = studentOrder.getStudentName();
Long studentId = studentMap.get(studentName);
if (null == studentId && hadMoreStudent) {
studentId = studentService.selectIdByName(studentName);
}
// 如无学生信息,新建学生信息
if (null == studentId) {
ScStudent student = new ScStudent();
student.setStudentName(studentName);
if (StringUtils.isNotEmpty(studentOrder.getSex())) {
student.setSex(sexMap.get(studentOrder.getSex()));
}
student.setPhone(studentOrder.getContactPhone());
if (StringUtils.isNotEmpty(studentOrder.getInTime())) {
student.setInTime(studentOrder.getInTime());
}
student.setCreateUser(loginUserId);
studentService.save(student);
studentId = student.getStudentId();
// 保存联系人信息
ScStudentContact studentContact = new ScStudentContact();
String contactRelation = contactRelationMap.get(studentOrder.getContactRelation());
studentContact.setContactRelation(contactRelation);
studentContact.setContactPhone(studentOrder.getContactPhone());
studentContact.setContactNick(studentOrder.getContactRelation());
studentContact.setCreateUser(loginUserId);
studentContact.setStudentId(student.getStudentId());
studentContactService.save(studentContact);
}
// 订单信息
BigDecimal receiptFee = new BigDecimal(studentOrder.getReceiptFee());
BigDecimal actualFee = new BigDecimal(studentOrder.getActualFee());
Long handleDeptId = campusMap.get(studentOrder.getHandleDeptName());
ScOrder order = ScOrder.builder()
.studentId(studentId)
.studentName(studentOrder.getStudentName())
.phone(studentOrder.getContactPhone())
.orderType("1")
.originalTotalFee(actualFee)
.actualTotalFee(actualFee)
.receiptFee(receiptFee)
.balanceFee(BigDecimal.ZERO)
.orderStatus(OrderStatusEnum.HAD_PAY.getOrderStatus())
.memo(studentOrder.getMemo())
.handleDeptId(Long.valueOf(handleDeptId))
.handleDeptName(studentOrder.getHandleDeptName())
.handleDate(studentOrder.getHandleDate())
.createUser(loginUserId)
.lastUpdateUser(loginUserId)
.build();
if (StringUtils.isNotEmpty(studentOrder.getSaleStaffName())) {
Long saleStaffId = staffMap.get(studentOrder.getSaleStaffName());
order.setSaleStaffId(saleStaffId);
order.setSaleStaffName(studentOrder.getSaleStaffName());
}
orderService.save(order);
// 订单明细
Long deptId = campusMap.get(studentOrder.getDeptName());
Long chargeId = courseChargeMap.get(studentOrder.getCourseName());
ScCourseCharge courseCharge = chargeCacheMap.get(chargeId);
RespCourseClaSelectInfo claInfo = claMap.get(studentOrder.getClaName());
String detailTagId = orderDetailTagMap.get(studentOrder.getOrderDetailTag());
String buyCount = studentOrder.getBuyCount();
if (StringUtils.isEmpty(buyCount)) {
buyCount = "1";
}
Integer buyCountInt = Integer.parseInt(buyCount);
ScOrderDetail orderDetail = ScOrderDetail.builder()
.orderId(order.getOrderId())
.courseId(courseCharge.getCourseId())
.courseName("导入:" + courseMap.get(courseCharge.getCourseId()))
.deptId(Long.valueOf(deptId))
.deptName(studentOrder.getDeptName())
.detailTag(detailTagId)
.chargeName(courseCharge.getChargeName())
.chargeType(courseCharge.getChargeType())
.chargeCount(courseCharge.getCount())
.chargeFee(actualFee)
.dateUnit(courseCharge.getDateUnit())
.buyCount(new BigDecimal(buyCount))
.originalFee(actualFee)
.actualFee(receiptFee)
.insideMemo(null == studentOrder.getMemo() ? "导入" : "导入" + studentOrder.getMemo())
.outsideMemo("")
.orderDetailStatus(OrderStatusEnum.HAD_PAY.getOrderStatus())
.createUser(loginUserId)
.lastUpdateUser(loginUserId)
.build();
if (StringUtils.isNotEmpty(studentOrder.getExpireDate())) {
orderDetail.setExpireDate(studentOrder.getExpireDate());
}
if (null != claInfo) {
orderDetail.setClaId(claInfo.getClaId());
orderDetail.setClaName(claInfo.getClaName());
}
String beginDate = studentOrder.getBeginDate();
DateTime beginDateTime = DateUtil.yyyMMddDayBegin(beginDate);
DateTime endDateTime = DateUtil.yyyMMddDayEnd(beginDate);
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
if (ChargeDateUnitEnum.DAY.getDateUnit().equals(courseCharge.getDateUnit())) {
endDateTime = beginDateTime.plusDays(buyCountInt).minusDays(1);
} else if (ChargeDateUnitEnum.MONTH.getDateUnit().equals(courseCharge.getDateUnit())) {
endDateTime = beginDateTime.plusMonths(buyCountInt).minusDays(1);
} else if (ChargeDateUnitEnum.SEASON.getDateUnit().equals(courseCharge.getDateUnit())) {
endDateTime = beginDateTime.plusMonths(buyCountInt * 3).minusDays(1);
} else if (ChargeDateUnitEnum.YEAR.getDateUnit().equals(courseCharge.getDateUnit())) {
endDateTime = beginDateTime.plusYears(buyCountInt).minusDays(1);
}
orderDetail.setBeginDate(studentOrder.getBeginDate());
orderDetail.setEndDate(endDateTime.toString("yyyy-MM-dd"));
} else {
// 收费方式按课时收费,实际课时数量
orderDetail.setChargeCount(new BigDecimal(studentOrder.getBuyHour()));
}
orderDetailService.save(orderDetail);
// 收款账户
Long accountId = receiptAccountMap.get(studentOrder.getAccountName());
ScOrderAccount orderAccount = new ScOrderAccount();
orderAccount.setOrderId(order.getOrderId());
orderAccount.setAccountId(accountId);
orderAccount.setAccountName(studentOrder.getAccountName());
orderAccount.setFee(receiptFee);
orderAccountService.save(orderAccount);
// sc_student_course表
ScStudentCourse dbStudentCourse = studentCourseService.selectByStudentIdCourseId(studentId, courseCharge.getCourseId());
BigDecimal buyHour = BigDecimal.ZERO;
BigDecimal addedHour = BigDecimal.ZERO;
int addedDays = 0;
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
Period period = new Period(beginDateTime, endDateTime, PeriodType.days());
addedDays = period.getDays() + 1;
} else {
// 新增课时
buyHour = new BigDecimal(studentOrder.getBuyHour());
addedHour = new BigDecimal(studentOrder.getBalanceHour());
}
Long studentCourseId = null;
{
// db中包含
if (null != dbStudentCourse) {
ScStudentCourse updateStudentCourse = new ScStudentCourse();
updateStudentCourse.setStudentCourseId(dbStudentCourse.getStudentCourseId());
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
updateStudentCourse.setTotalDay(dbStudentCourse.getTotalDay().add(new BigDecimal(addedDays)));
} else {
updateStudentCourse.setTotalHour(dbStudentCourse.getTotalHour().add(new BigDecimal(studentOrder.getBuyHour())));
updateStudentCourse.setBalanceHour(dbStudentCourse.getBalanceHour().add(addedHour));
}
updateStudentCourse.setTotalFee(dbStudentCourse.getTotalFee().add(receiptFee));
updateStudentCourse.setLastUpdateUser(loginUserId);
updateStudentCourse.setLastUpdateTime(new Date());
studentCourseService.updateById(updateStudentCourse);
studentCourseId = updateStudentCourse.getStudentCourseId();
} else {
ScStudentCourse addStudentCourse = new ScStudentCourse();
addStudentCourse.setStudentId(studentId);
addStudentCourse.setCourseId(courseCharge.getCourseId());
addStudentCourse.setCourseName(courseMap.get(courseCharge.getCourseId()));
addStudentCourse.setDeptId(Long.valueOf(deptId));
if (null != claInfo) {
addStudentCourse.setClaId(claInfo.getClaId());
addStudentCourse.setClaName(claInfo.getClaName());
}
addStudentCourse.setChargeType(courseCharge.getChargeType());
if (CourseChargeTypeEnum.HOUR.getChargeType().equals(courseCharge.getChargeType())) {
addStudentCourse.setTotalHour(new BigDecimal(studentOrder.getBuyHour()));
addStudentCourse.setBalanceHour(addedHour);
} else if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
addStudentCourse.setTotalDay(new BigDecimal(addedDays));
} else if (CourseChargeTypeEnum.CYCLE.getChargeType().equals(courseCharge.getChargeType())) {
addStudentCourse.setTotalHour(new BigDecimal(studentOrder.getBuyHour()));
addStudentCourse.setBalanceHour(addedHour);
}
addStudentCourse.setTotalFee(receiptFee);
addStudentCourse.setStatus("1");
addStudentCourse.setCreateUser(loginUserId);
addStudentCourse.setLastUpdateUser(loginUserId);
studentCourseService.save(addStudentCourse);
studentCourseId = addStudentCourse.getStudentCourseId();
}
}
// 插入sc_student_course_order
{
ScStudentCourseOrder studentCourseOrder = ScStudentCourseOrder.builder()
.studentCourseId(studentCourseId)
.orderId(order.getOrderId())
.orderDetailId(orderDetail.getOrderDetailId())
.totalFee(actualFee)
.createUser(loginUserId)
.lastUpdateUser(loginUserId)
.build();
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
studentCourseOrder.setTotalDay(new BigDecimal(addedDays));
studentCourseOrder.setBeginDate(beginDateTime.toString("yyyy-MM-dd"));
studentCourseOrder.setEndDate(endDateTime.toString("yyyy-MM-dd"));
if (StringUtils.isNotEmpty(studentOrder.getExpireDate())) {
studentCourseOrder.setExpireDate(studentOrder.getExpireDate());
}
// 单价 = 总价/天
studentCourseOrder.setUnitFee(actualFee.divide(new BigDecimal(addedDays), 2, BigDecimal.ROUND_HALF_UP));
} else {
studentCourseOrder.setTotalHour(new BigDecimal(studentOrder.getBuyHour()));
studentCourseOrder.setBalanceHour(addedHour);
// 按课时收费 如果 学生 剩余课时<0表示欠课时
if (null != dbStudentCourse && dbStudentCourse.getBalanceHour().compareTo(BigDecimal.ZERO) < 0) {
// 剩余课时 = 购买课时 - 欠课时
studentCourseOrder.setBalanceHour(addedHour.add(dbStudentCourse.getBalanceHour()));
}
// 单价 = 总价/课时数
studentCourseOrder.setUnitFee(actualFee.divide(buyHour, 2, BigDecimal.ROUND_HALF_UP));
}
courseOrderService.save(studentCourseOrder);
}
// 学生报读 日志
StringBuffer sb = new StringBuffer("");
if ("1".equals(detailTagId)) {
sb.append("[导入]新报,");
} else if ("2".equals(detailTagId)) {
sb.append("[导入]续报,");
}
sb.append("课程'").append(courseMap.get(courseCharge.getCourseId())).append("',");
sb.append("金额").append(receiptFee.toString()).append("元,");
ScStudentCourseLog studentCourseLog = ScStudentCourseLog.builder()
.studentId(studentId)
.logType(LogTypeEnum.PAY_FEE.getLogType())
.courseId(courseCharge.getCourseId())
.courseName(courseMap.get(courseCharge.getCourseId()))
.deptName(studentOrder.getDeptName())
.changeFee(receiptFee)
.createUser(loginUser.getUserId())
.createUserName(loginUser.getUsername())
.createTime(new Date())
.build();
if (null != claInfo) {
studentCourseLog.setClaId(claInfo.getClaId());
studentCourseLog.setClaName(claInfo.getClaName());
}
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
sb.append("增加'").append(addedDays).append("'天");
sb.append("(").append(beginDateTime.toString("yyyy-MM-dd")).append("~").append(endDateTime.toString("yyyy-MM-dd")).append(").");
} else {
sb.append("增加'").append(addedHour.toString()).append("'课时,");
studentCourseLog.setChangeHour(addedHour);
// 增加后剩余
if (null != dbStudentCourse) {
studentCourseLog.setAfterBalanceHour(dbStudentCourse.getBalanceHour().add(addedHour));
sb.append("增加后剩余").append(dbStudentCourse.getBalanceHour().add(addedHour).toString()).append("'课时").append(".");
} else {
studentCourseLog.setAfterBalanceHour(addedHour);
sb.append("增加后剩余").append(addedHour.toString()).append("'课时").append(".");
}
}
studentCourseLog.setMemo(sb.toString());
scStudentCourseLogService.save(studentCourseLog);
}
}
/**
*
*
* @param data
* @return
*/
public APIBaseResponse checkParam(ImportStudentOrder data) {
if(receiptAccountMap.isEmpty()) {
return APIBaseResponse.fail("系统未配置收款账户,请配置收款账户");
}
String studentName = data.getStudentName();
if (StringUtils.isEmpty(data.getStudentName())) {
return APIBaseResponse.fail("学生姓名未填写");
} else if (studentName.length() > 20) {
return APIBaseResponse.fail("学生姓名最多20个字符");
} else if (StringUtils.isEmpty(data.getContactPhone())) {
return APIBaseResponse.fail("联系电话未填写");
} else if (data.getContactPhone().length() > 30) {
return APIBaseResponse.fail("联系电话最多30个字符");
} else if (StringUtils.isEmpty(data.getDeptName())) {
return APIBaseResponse.fail("报读校区未填写");
} else if (StringUtils.isEmpty(data.getCourseName())) {
return APIBaseResponse.fail("报读课程未填写");
} else if (StringUtils.isEmpty(data.getReceiptFee())) {
return APIBaseResponse.fail("实缴学费未填写");
} else if (StringUtils.isEmpty(data.getActualFee())) {
return APIBaseResponse.fail("应收学费未填写");
} else if (StringUtils.isEmpty(data.getHandleDeptName())) {
return APIBaseResponse.fail("经办校区未填写");
}
try {
new BigDecimal(data.getReceiptFee());
new BigDecimal(data.getActualFee());
} catch (Exception e) {
return APIBaseResponse.fail("实缴、应收学费格式错误,请按照正确格式填写");
}
if (new BigDecimal(data.getReceiptFee()).compareTo(new BigDecimal(data.getActualFee())) > 0) {
return APIBaseResponse.fail("实缴应大于应收,应小于等于应收");
}
Long chargeId = courseChargeMap.get(data.getCourseName());
if (null == chargeId) {
return APIBaseResponse.fail("根据课程无法获取对应信息,请核对填写信息或重新下载导入模板进行导入");
}
ScCourseCharge courseCharge = chargeCacheMap.get(chargeId);
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
if (StringUtils.isEmpty(data.getBeginDate())) {
return APIBaseResponse.fail("按时间收费,开始日期未填写");
} else if (StringUtils.isEmpty(data.getBuyCount())) {
return APIBaseResponse.fail("按时间收费,购买数量未填写");
}
try {
DateUtil.yyyMMddDayBegin(data.getBeginDate());
} catch (Exception e) {
return APIBaseResponse.fail("按时间收费开始日期格式错误,请按照正确格式填写开始日期");
}
try {
Integer.parseInt(data.getBuyCount());
if (Integer.parseInt(data.getBuyCount()) == 0) {
return APIBaseResponse.fail("按时间收费购买数量不能为0");
}
} catch (Exception e) {
return APIBaseResponse.fail("按时间收费购买数量格式错误,请按照正确格式填写购买数量");
}
} else {
if (StringUtils.isEmpty(data.getBuyHour())) {
return APIBaseResponse.fail("购买课时未填写");
} else if (StringUtils.isEmpty(data.getBalanceHour())) {
return APIBaseResponse.fail("剩余课时未填写");
}
try {
new BigDecimal(data.getBuyHour());
new BigDecimal(data.getBalanceHour());
} catch (Exception e) {
return APIBaseResponse.fail("购买课时、剩余课时格式错误,请按照正确格式填写");
}
if (new BigDecimal(data.getBuyHour()).compareTo(new BigDecimal(data.getBalanceHour())) < 0) {
return APIBaseResponse.fail("购买课时小于剩余课时,请核对后重新填写");
}
if (new BigDecimal(data.getBuyHour()).compareTo(BigDecimal.ZERO) < 0) {
return APIBaseResponse.fail("购买课时小于0");
} else if (new BigDecimal(data.getBalanceHour()).compareTo(BigDecimal.ZERO) < 0) {
return APIBaseResponse.fail("剩余课时小于0");
}
if (StringUtils.isNotEmpty(data.getExpireDate())) {
try {
DateUtil.yyyMMddDayBegin(data.getExpireDate());
} catch (Exception e) {
return APIBaseResponse.fail("按课时、周期收费,请按照正确格式填写课程到期日期");
}
}
}
if (StringUtils.isNotEmpty(data.getContactRelation())) {
String contactRelationId = contactRelationMap.get(data.getContactRelation());
if (StringUtils.isEmpty(contactRelationId)) {
return APIBaseResponse.fail("根据主要联系人无法获取对应信息,请核对填写信息或重新下载导入模板进行导入");
}
} else {
// 如未填,默认为其他
data.setContactRelation("其他");
}
if (StringUtils.isNotEmpty(data.getSex())) {
String sexId = sexMap.get(data.getSex());
if (StringUtils.isEmpty(sexId)) {
return APIBaseResponse.fail("根据性别无法获取对应信息,请核对填写信息或重新下载导入模板进行导入");
}
} else {
// 如未填,默认为男
data.setSex("男");
}
if (StringUtils.isNotEmpty(data.getOrderDetailTag())) {
String detailTagId = orderDetailTagMap.get(data.getOrderDetailTag());
if (StringUtils.isEmpty(detailTagId)) {
return APIBaseResponse.fail("根据订单类型无法获取对应信息,请核对填写信息或重新下载导入模板进行导入");
}
} else {
// 如未填,默认为新报
data.setOrderDetailTag("新报");
}
Long deptId = campusMap.get(data.getDeptName());
if (ObjectUtil.isEmpty(deptId)) {
return APIBaseResponse.fail("根据报读校区无法获取对应信息,请核对填写信息或重新下载导入模板进行导入");
}
if (courseCharge.getDepartId() != -1 && courseCharge.getDepartId().compareTo(Long.valueOf(deptId)) != 0) {
return APIBaseResponse.fail("报读校区与报读课程不匹配,请核对后重新导入");
}
if (StringUtils.isNotEmpty(data.getClaName())) {
RespCourseClaSelectInfo claInfo = claMap.get(data.getClaName());
if (null == claInfo) {
return APIBaseResponse.fail("根据报读班级无法获取对应信息,请核对填写信息或重新下载导入模板进行导入");
} else if (claInfo.getCourseId().compareTo(courseCharge.getCourseId()) != 0) {
return APIBaseResponse.fail("报读班级与报读课程不匹配,请核对后重新导入");
} else if (claInfo.getDeptId().compareTo(Long.valueOf(deptId)) != 0) {
return APIBaseResponse.fail("报读班级与报读课程不匹配,请核对后重新导入");
}
}
Long handleDeptId = campusMap.get(data.getHandleDeptName());
if (ObjectUtil.isEmpty(handleDeptId)) {
return APIBaseResponse.fail("根据经办校区无法获取对应信息,请核对填写信息或重新下载导入模板进行导入");
}
if (StringUtils.isNotEmpty(data.getHandleDate())) {
try {
DateUtil.yyyMMddDayBegin(data.getHandleDate());
} catch (Exception e) {
return APIBaseResponse.fail("请按照正确格式填写经办日期");
}
} else {
data.setHandleDate(DateTime.now().toString("yyyy-MM-dd"));
}
if (StringUtils.isNotEmpty(data.getAccountName())) {
Long accountId = receiptAccountMap.get(data.getAccountName());
if (null == accountId) {
return APIBaseResponse.fail("根据收款账户无法获取对应信息,请核对填写信息或重新下载导入模板进行导入");
}
} else if (!receiptAccountMap.isEmpty()) {
String key = receiptAccountMap.keySet().iterator().next();
// 如未填,默认第一个
data.setAccountName(key);
}
if (StringUtils.isNotEmpty(data.getSaleStaffName())) {
Long staffId = staffMap.get(data.getSaleStaffName());
if (null == staffId) {
return APIBaseResponse.fail("根据销售员工无法获取对应信息,请核对填写信息或重新下载导入模板进行导入");
}
}
// 校验学生报读方式 是否与老报读方式一致
Long studentId = studentMap.get(studentName);
if (null == studentId && hadMoreStudent) {
studentId = studentService.selectIdByName(studentName);
}
if (null != studentId) {
ScStudentCourse studentCourse = studentCourseService.selectByStudentIdCourseId(studentId, courseCharge.getCourseId());
if (null != studentCourse && !studentCourse.getChargeType().equals(courseCharge.getChargeType())) {
return APIBaseResponse.fail("该学生 已" + CourseChargeTypeEnum.getChargeType(studentCourse.getChargeType()) + "报读,无法按" + courseCharge.getChargeType() + "重复报读!");
}
}
// 按时间报读,报读日期是否存在覆盖
if (CourseChargeTypeEnum.DATE.getChargeType().equals(courseCharge.getChargeType())) {
String beginDate = data.getBeginDate();
DateTime beginDateTime = DateUtil.yyyMMddDayBegin(beginDate);
DateTime endDateTime = DateUtil.yyyMMddDayEnd(beginDate);
if (ChargeDateUnitEnum.DAY.getDateUnit().equals(courseCharge.getDateUnit())) {
endDateTime = beginDateTime.plusDays(Integer.parseInt(data.getBuyCount())).minusDays(1);
} else if (ChargeDateUnitEnum.MONTH.getDateUnit().equals(courseCharge.getDateUnit())) {
endDateTime = beginDateTime.plusMonths(Integer.parseInt(data.getBuyCount())).minusDays(1);
} else if (ChargeDateUnitEnum.SEASON.getDateUnit().equals(courseCharge.getDateUnit())) {
endDateTime = beginDateTime.plusMonths(Integer.parseInt(data.getBuyCount()) * 3).minusDays(1);
} else if (ChargeDateUnitEnum.YEAR.getDateUnit().equals(courseCharge.getDateUnit())) {
endDateTime = beginDateTime.plusYears(Integer.parseInt(data.getBuyCount())).minusDays(1);
}
boolean checkDateCover = courseOrderService.checkDateCover(studentId, courseCharge.getCourseId(), beginDateTime.toString("yyyy-MM-dd"), endDateTime.toString("yyyy-MM-dd"));
if (checkDateCover) {
return APIBaseResponse.fail("按时间收费,报读日期存在覆盖,请重新选择开始日期!");
}
}
return APIBaseResponse.success();
}
public void initCacheMap() {
// 性别
List<SysDictData> sexList = dictDataService.dictTypeDataList("sys_user_sex");
// 订单类型
List<SysDictData> orderDetailTagList = dictDataService.dictTypeDataList("course_order_type");
// 报读校区
List<RespTreeSelect> campusList = deptService.campusList();
// 报读课程 课程-收费方式(校区)
ReqSearchScCourse reqSearchScCourse = new ReqSearchScCourse();
reqSearchScCourse.setSale("1");
List<ExpCourse> courseList = courseMapper.selectCourseForExport(reqSearchScCourse);
// 报读班级 班级(教师)-课程
List<RespCourseClaSelectInfo> claList = claMapper.selectForSelect(new ReqCourseClaSelect());
// 收款账户
List<SysReceiptAccount> receiptAccountList = receiptAccountService.select();
// 销售员工
List<SysUser> staffList = staffService.selectUserList(new SysUser());
// 收费模式
QueryWrapper<ScCourseCharge> qw = new QueryWrapper<>();
List<ScCourseCharge> courseChargeList = courseChargeService.list(qw);
sexList.forEach(item -> {
sexMap.put(item.getDictLabel(), item.getDictValue());
});
orderDetailTagList.forEach(item -> {
orderDetailTagMap.put(item.getDictLabel(), item.getDictValue());
});
campusList.forEach(item -> {
campusMap.put(item.getLabel(), item.getId());
});
courseList.forEach(item -> {
String courseName = item.getCourseName() + "(" + item.getDepartName() + ")-" + item.getChargeTypeName();
if (CourseChargeTypeEnum.DATE.getChargeType().equals(item.getChargeType())) {
courseName = courseName + "(" + item.getTotalFee().toString() + item.getDateUnitName() + ")";
} else {
courseName = courseName + "(" + item.getCount().toString() + "课时," + item.getTotalFee().toString() + "元)";
}
courseChargeMap.put(courseName, item.getChargeId());
});
courseList.forEach(item -> {
courseMap.put(item.getCourseId(), item.getCourseName());
});
claList.forEach(item -> {
String key = item.getDeptName() + "-" + item.getClaName() + "(" + item.getStaffName() + ")" + "-" + item.getCourseName();
claMap.put(key, item);
});
receiptAccountList.forEach(item -> {
receiptAccountMap.put(item.getAccountName(), item.getAccountId());
});
staffList.forEach(item -> {
staffMap.put(item.getNickName(), item.getUserId());
});
courseChargeList.forEach(item -> {
chargeCacheMap.put(item.getChargeId(), item);
});
RespPage<ScStudent> scStudentRespPage = studentService.selectStudentList(500);
long pages = scStudentRespPage.getPages();
hadMoreStudent = pages > 1;
// 学生信息
scStudentRespPage.getRows().forEach(item -> {
studentMap.put(item.getStudentName(), item.getStudentId());
});
}
public int getSuccessRecordSize() {
return this.successRecordList.size();
}
public int getFailRecordSize() {
return this.failRecordList.size();
}
}

@ -5,10 +5,10 @@ import cn.xluobo.business.tool.export.handler.bean.SelectValidationData;
import cn.xluobo.business.tool.impt.domain.ReqDownImplTemplate;
import cn.xluobo.business.tool.impt.domain.ReqUploadImplData;
import cn.xluobo.business.tool.impt.service.strategy.ImportContext;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import cn.xluobo.core.file.FileUtils;
import cn.xluobo.core.utils.ServletUtils;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import cn.xluobo.core.file.FileUtils;
import com.alibaba.excel.EasyExcel;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.StringUtils;

@ -1,7 +1,7 @@
package cn.xluobo.business.tool.impt.service.strategy;
import cn.xluobo.business.tool.export.handler.bean.SelectValidationData;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import com.google.common.collect.Lists;
import org.springframework.web.multipart.MultipartFile;

@ -1,7 +1,7 @@
package cn.xluobo.business.tool.impt.service.strategy;
import cn.xluobo.business.tool.export.handler.bean.SelectValidationData;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;

@ -5,7 +5,7 @@ import cn.xluobo.business.tool.impt.domain.ReqUploadImplData;
import cn.xluobo.business.tool.impt.repo.model.ToolImport;
import cn.xluobo.business.tool.impt.repo.service.IToolImportService;
import cn.xluobo.config.properties.UploadConfigProperties;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import lombok.extern.slf4j.Slf4j;

@ -1,299 +0,0 @@
package cn.xluobo.business.tool.impt.service.strategy.impl;
import cn.xluobo.business.sc.base.domain.req.ReqRoomSelect;
import cn.xluobo.business.sc.base.domain.resp.RespRoomSelect;
import cn.xluobo.business.sc.base.service.IScRoomService;
import cn.xluobo.business.sc.course.repo.model.ScCourse;
import cn.xluobo.business.sc.course.service.BusinessClaTimeRuleService;
import cn.xluobo.business.sc.course.service.IScCourseClaService;
import cn.xluobo.business.sc.course.service.IScCourseService;
import cn.xluobo.business.sys.admin.domain.resp.RespTreeSelect;
import cn.xluobo.business.sys.admin.service.BusinessSysDeptService;
import cn.xluobo.business.sys.admin.service.BusinessSysDictDataService;
import cn.xluobo.business.tool.export.handler.bean.SelectValidationData;
import cn.xluobo.business.tool.impt.domain.ImportCourseCla;
import cn.xluobo.business.tool.impt.listener.ImportCourseClaListener;
import cn.xluobo.business.tool.impt.service.strategy.AbstractImportStrategy;
import cn.xluobo.config.properties.UploadConfigProperties;
import cn.xluobo.core.api.APIResponse;
import com.alibaba.excel.EasyExcel;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.service.ISysUserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
/**
* @author zhangbaoyu
* @date Created in 2020/10/10 16:45
*/
@Service("import_course_cla")
@Slf4j
public class ImportCourseClaImpl extends AbstractImportStrategy {
@Autowired
private IScCourseService courseService;
@Autowired
private IScCourseClaService claService;
@Autowired
private BusinessSysDeptService deptService;
@Autowired
private ISysUserService staffService;
@Autowired
private BusinessSysDictDataService dictDataService;
@Autowired
private BusinessClaTimeRuleService businessClaTimeRuleService;
@Autowired
private IScRoomService roomService;
@Autowired
private UploadConfigProperties uploadConfigProperties;
private static final String FILE_TYPE = "import_course_cla";
@Override
public List<SelectValidationData> selectValidateConfig() {
// 课程
QueryWrapper<ScCourse> qwCourse = new QueryWrapper<>();
qwCourse.select("course_name");
qwCourse.eq("sale", "1");
qwCourse.eq("delete_flag", "0");
List<ScCourse> courseList = courseService.list(qwCourse);
String[] courseNameStringArray = courseList.stream().map(ScCourse::getCourseName).toArray(String[]::new);
// 全部校区
List<RespTreeSelect> campusList = deptService.campusList();
String[] campusNameStringArray = campusList.stream().map(RespTreeSelect::getLabel).toArray(String[]::new);
// 教师列表
List<SysUser> teacherList = staffService.selectUserList(new SysUser());
String[] teacherNameStringArray = teacherList.stream().map(SysUser::getNickName).toArray(String[]::new);
// 招生状态
List<SysDictData> recruitStatusList = dictDataService.dictTypeDataList("recruit_status");
String[] chargeTypeStringArray = recruitStatusList.stream().map(SysDictData::getDictLabel).toArray(String[]::new);
// 排课重复方式
List<SysDictData> claTimeRepeatTypeList = dictDataService.dictTypeDataList("cla_time_repeat_type");
String[] claTimeRepeatTypeStringArray = claTimeRepeatTypeList.stream().map(SysDictData::getDictLabel).toArray(String[]::new);
// 所有教室
List<RespRoomSelect> roomList = roomService.selectRoomSelect(new ReqRoomSelect());
String[] roomNameStringArray = roomList.stream().map(RespRoomSelect::getRoomName).toArray(String[]::new);
return Lists.newArrayList(
SelectValidationData.builder().firstCol(1).lastCol(1).firstRow(1).lastRow(106).selectDataArray(courseNameStringArray).build(),
SelectValidationData.builder().firstCol(2).lastCol(2).firstRow(1).lastRow(106).selectDataArray(campusNameStringArray).build(),
SelectValidationData.builder().firstCol(3).lastCol(3).firstRow(1).lastRow(106).selectDataArray(teacherNameStringArray).build(),
SelectValidationData.builder().firstCol(5).lastCol(5).firstRow(1).lastRow(106).selectDataArray(chargeTypeStringArray).build(),
SelectValidationData.builder().firstCol(12).lastCol(12).firstRow(1).lastRow(106).selectDataArray(claTimeRepeatTypeStringArray).build(),
SelectValidationData.builder().firstCol(14).lastCol(14).firstRow(1).lastRow(106).selectDataArray(new String[]{"过滤", "不过滤"}).build(),
SelectValidationData.builder().firstCol(17).lastCol(17).firstRow(1).lastRow(106).selectDataArray(roomNameStringArray).build()
);
}
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public APIResponse importDataByFileId(Long importId, String fileId) throws IOException {
String path = uploadConfigProperties.getTempSaveImportPath();
path = path + "/" + FILE_TYPE;
File file = new File(path, fileId);
if (!file.exists()) {
return APIResponse.toExceptionResponse("无法获取文件,请重试");
}
// 课程
QueryWrapper<ScCourse> qwCourse = new QueryWrapper<>();
qwCourse.select("course_name", "course_id");
qwCourse.eq("sale", "1");
qwCourse.eq("delete_flag", "0");
List<ScCourse> courseList = courseService.list(qwCourse);
// 全部校区
List<RespTreeSelect> campusList = deptService.campusList();
// 教师列表
List<SysUser> teacherList = staffService.selectUserList(new SysUser());
// 招生状态
List<SysDictData> recruitStatusList = dictDataService.dictTypeDataList("recruit_status");
// 排课重复方式
List<SysDictData> claTimeRepeatTypeList = dictDataService.dictTypeDataList("cla_time_repeat_type");
// 所有教室
List<RespRoomSelect> roomList = roomService.selectRoomSelect(new ReqRoomSelect());
// 上课星期
List<SysDictData> weekDayList = dictDataService.dictTypeDataList("week_day");
Map<String, Long> courseMap = Maps.newHashMap();
Map<String, Long> campusMap = Maps.newHashMap();
Map<String, Long> teacherMap = Maps.newHashMap();
Map<String, String> recruitStatusMap = Maps.newHashMap();
Map<String, String> claTimeRepeatTypeMap = Maps.newHashMap();
Map<String, Long> roomMap = Maps.newHashMap();
Map<String, String> weekDayMap = Maps.newHashMap();
courseList.forEach(item -> {
courseMap.put(item.getCourseName(), item.getCourseId());
});
campusList.forEach(item -> {
campusMap.put(item.getLabel(), item.getId());
});
teacherList.forEach(item -> {
teacherMap.put(item.getNickName(), item.getUserId());
});
recruitStatusList.forEach(item -> {
recruitStatusMap.put(item.getDictLabel(), item.getDictValue());
});
claTimeRepeatTypeList.forEach(item -> {
claTimeRepeatTypeMap.put(item.getDictLabel(), item.getDictValue());
});
roomList.forEach(item -> {
roomMap.put(item.getRoomName(), item.getRoomId());
});
weekDayList.forEach(item -> {
weekDayMap.put(item.getDictLabel(), item.getDictValue());
});
LoginUser loginUser = SecurityUtils.getLoginUser();
ImportCourseClaListener importListener = new ImportCourseClaListener(claService, businessClaTimeRuleService);
importListener.setNeedSave(true);
importListener.setCourseMap(courseMap);
importListener.setCampusMap(campusMap);
importListener.setTeacherMap(teacherMap);
importListener.setRecruitStatusMap(recruitStatusMap);
importListener.setClaTimeRepeatTypeMap(claTimeRepeatTypeMap);
importListener.setRoomMap(roomMap);
importListener.setWeekDayMap(weekDayMap);
importListener.setLoginUserId(loginUser.getUserId());
importListener.setImportId(importId);
InputStream is = new FileInputStream(file);
EasyExcel.read(is, ImportCourseCla.class, importListener).sheet().autoTrim(true).headRowNumber(5).doRead();
int successRecord = importListener.getSuccessRecord();
int failRecord = importListener.getFailRecord();
file.delete();
return APIResponse.toAPIResponse("导入成功" + successRecord + "条,导入失败:" + failRecord);
}
@Override
public APIResponse checkData(MultipartFile multipartFile) throws IOException {
long fileSize = multipartFile.getSize();
if (fileSize > 1024 * 1024 * 2) {
return APIResponse.toExceptionResponse("导入文件需小于2M");
}
// 课程
QueryWrapper<ScCourse> qwCourse = new QueryWrapper<>();
qwCourse.select("course_name", "course_id");
qwCourse.eq("sale", "1");
qwCourse.eq("delete_flag", "0");
List<ScCourse> courseList = courseService.list(qwCourse);
// 全部校区
List<RespTreeSelect> campusList = deptService.campusList();
// 教师列表
List<SysUser> teacherList = staffService.selectUserList(new SysUser());
// 招生状态
List<SysDictData> recruitStatusList = dictDataService.dictTypeDataList("recruit_status");
// 排课重复方式
List<SysDictData> claTimeRepeatTypeList = dictDataService.dictTypeDataList("cla_time_repeat_type");
// 所有教室
List<RespRoomSelect> roomList = roomService.selectRoomSelect(new ReqRoomSelect());
// 上课星期
List<SysDictData> weekDayList = dictDataService.dictTypeDataList("week_day");
Map<String, Long> courseMap = Maps.newHashMap();
Map<String, Long> campusMap = Maps.newHashMap();
Map<String, Long> teacherMap = Maps.newHashMap();
Map<String, String> recruitStatusMap = Maps.newHashMap();
Map<String, String> claTimeRepeatTypeMap = Maps.newHashMap();
Map<String, Long> roomMap = Maps.newHashMap();
Map<String, String> weekDayMap = Maps.newHashMap();
courseList.forEach(item -> {
courseMap.put(item.getCourseName(), item.getCourseId());
});
campusList.forEach(item -> {
campusMap.put(item.getLabel(), item.getId());
});
teacherList.forEach(item -> {
teacherMap.put(item.getNickName(), item.getUserId());
});
recruitStatusList.forEach(item -> {
recruitStatusMap.put(item.getDictLabel(), item.getDictValue());
});
claTimeRepeatTypeList.forEach(item -> {
claTimeRepeatTypeMap.put(item.getDictLabel(), item.getDictValue());
});
roomList.forEach(item -> {
roomMap.put(item.getRoomName(), item.getRoomId());
});
weekDayList.forEach(item -> {
weekDayMap.put(item.getDictLabel(), item.getDictValue());
});
LoginUser loginUser = SecurityUtils.getLoginUser();
ImportCourseClaListener importListener = new ImportCourseClaListener(claService, businessClaTimeRuleService);
importListener.setNeedSave(false);
importListener.setCourseMap(courseMap);
importListener.setCampusMap(campusMap);
importListener.setTeacherMap(teacherMap);
importListener.setRecruitStatusMap(recruitStatusMap);
importListener.setClaTimeRepeatTypeMap(claTimeRepeatTypeMap);
importListener.setRoomMap(roomMap);
importListener.setWeekDayMap(weekDayMap);
importListener.setLoginUserId(loginUser.getUserId());
// 保存文件
String fileId = IdWorker.getIdStr();
String fileName = DateTime.now().toString("yyyyMMddHHmmss") + "_" + fileId;
String originalFileName = multipartFile.getOriginalFilename();
String suffix = FilenameUtils.getExtension(originalFileName);
if (StringUtils.isNotEmpty(suffix)) {
fileName = fileName + "." + suffix;
}
String path = uploadConfigProperties.getTempSaveImportPath();
//上传文件夹
path = path + "/" + FILE_TYPE;
File uploadFileDir = new File(path);
if (!uploadFileDir.exists()) {
uploadFileDir.mkdir();
}
File uploadFile = new File(uploadFileDir, fileName);
FileUtils.copyInputStreamToFile(multipartFile.getInputStream(), uploadFile);
InputStream is = new FileInputStream(uploadFile);
EasyExcel.read(is, ImportCourseCla.class, importListener).sheet().autoTrim(true).headRowNumber(5).doRead();
List<ImportCourseCla> saveCourseClaList = importListener.getSaveCourseClaList();
List<ImportCourseCla> failCourseClaList = importListener.getFailCourseClaList();
Map<String, Object> resultMap = Maps.newHashMap();
resultMap.put("successList", saveCourseClaList);
resultMap.put("failList", failCourseClaList);
resultMap.put("fileId", fileName);
return APIResponse.toAPIResponse(resultMap);
}
}

@ -1,159 +0,0 @@
package cn.xluobo.business.tool.impt.service.strategy.impl;
import cn.xluobo.business.sc.course.repo.model.ScCourseType;
import cn.xluobo.business.sc.course.service.IScCourseChargeService;
import cn.xluobo.business.sc.course.service.IScCourseService;
import cn.xluobo.business.sc.course.service.IScCourseTypeService;
import cn.xluobo.business.sys.admin.domain.resp.RespTreeSelect;
import cn.xluobo.business.sys.admin.service.BusinessSysDeptService;
import cn.xluobo.business.sys.admin.service.BusinessSysDictDataService;
import cn.xluobo.business.tool.export.handler.bean.SelectValidationData;
import cn.xluobo.business.tool.impt.domain.ImportCourse;
import cn.xluobo.business.tool.impt.listener.ImportCourseListener;
import cn.xluobo.business.tool.impt.service.strategy.AbstractImportStrategy;
import cn.xluobo.core.api.APIResponse;
import com.alibaba.excel.EasyExcel;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* select
*
* @author zhangbaoyu
* @date Created in 2020/8/2 18:56
*/
@Service("import_course")
@Slf4j
public class ImportCourseImpl extends AbstractImportStrategy {
@Autowired
private BusinessSysDeptService deptService;
@Autowired
private IScCourseTypeService scCourseTypeService;
@Autowired
private BusinessSysDictDataService dictDataService;
@Autowired
private IScCourseService courseService;
@Autowired
private IScCourseChargeService courseChargeService;
@Override
public List<SelectValidationData> selectValidateConfig() {
// 全部校区
List<RespTreeSelect> campusList = deptService.campusList();
List<String> campusNameList = Lists.newArrayList("全部校区");
List<String> allDbCampusList = campusList.stream().map(RespTreeSelect::getLabel).collect(Collectors.toList());
campusNameList.addAll(allDbCampusList);
String[] campusNameStringArray = campusNameList.toArray(new String[allDbCampusList.size()]);
// 课程类型
QueryWrapper<ScCourseType> qw = new QueryWrapper<>();
qw.eq("in_use", "1");
qw.orderByDesc("create_time");
List<ScCourseType> courseTypeList = scCourseTypeService.list(qw);
String[] courseTypeStringArray = courseTypeList.stream().map(ScCourseType::getCourseType).toArray(String[]::new);
// 收费模式
List<SysDictData> chargeTypeList = dictDataService.dictTypeDataList("charge_type");
String[] chargeTypeStringArray = chargeTypeList.stream().map(SysDictData::getDictLabel).toArray(String[]::new);
// 时间段
List<SysDictData> dateUnitList = dictDataService.dictTypeDataList("date_unit");
String[] dateUnitListStringArray = dateUnitList.stream().map(SysDictData::getDictLabel).toArray(String[]::new);
return Lists.newArrayList(
SelectValidationData.builder().firstCol(1).lastCol(1).firstRow(1).lastRow(206).selectDataArray(courseTypeStringArray).build(),
SelectValidationData.builder().firstCol(2).lastCol(2).firstRow(1).lastRow(206).selectDataArray(new String[]{"班课", "一对一"}).build(),
SelectValidationData.builder().firstCol(4).lastCol(4).firstRow(1).lastRow(206).selectDataArray(new String[]{"开售", "不开售"}).build(),
SelectValidationData.builder().firstCol(5).lastCol(5).firstRow(1).lastRow(206).selectDataArray(campusNameStringArray).build(),
SelectValidationData.builder().firstCol(6).lastCol(6).firstRow(1).lastRow(206).selectDataArray(chargeTypeStringArray).build(),
SelectValidationData.builder().firstCol(9).lastCol(9).firstRow(1).lastRow(206).selectDataArray(dateUnitListStringArray).build()
);
}
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public APIResponse importData(Long importId, MultipartFile multipartFile) throws IOException {
long fileSize = multipartFile.getSize();
if (fileSize > 1024 * 1024 * 2) {
return APIResponse.toExceptionResponse("导入文件需小于2M");
}
LoginUser loginUser = SecurityUtils.getLoginUser();
// 课程类型
QueryWrapper qw = new QueryWrapper();
qw.eq("in_use", "1");
qw.orderByDesc("create_time");
List<ScCourseType> courseTypeList = scCourseTypeService.list(qw);
// 全部校区
List<RespTreeSelect> campusList = deptService.campusList();
campusList.add(RespTreeSelect.builder().id(-1L).label("全部校区").build());
// 收费模式
List<SysDictData> chargeTypeList = dictDataService.dictTypeDataList("charge_type");
// 时间段
List<SysDictData> dateUnitList = dictDataService.dictTypeDataList("date_unit");
// 课程类型key value key为名称 value为ID
Map<String, Long> courseTypeMap = Maps.newHashMap();
for (ScCourseType scCourseType : courseTypeList) {
courseTypeMap.put(scCourseType.getCourseType(), scCourseType.getCourseTypeId());
}
// 校区key value
Map<String, Long> campusMap = Maps.newHashMap();
for (RespTreeSelect respTreeSelect : campusList) {
campusMap.put(respTreeSelect.getLabel(), Long.valueOf(respTreeSelect.getId()));
}
// 收费模式
Map<String, String> chargeTypeMap = Maps.newHashMap();
for (SysDictData sysDictData : chargeTypeList) {
chargeTypeMap.put(sysDictData.getDictLabel(), sysDictData.getDictValue());
}
// 时间段
Map<String, String> dateUnitMap = Maps.newHashMap();
for (SysDictData sysDictData : dateUnitList) {
dateUnitMap.put(sysDictData.getDictLabel(), sysDictData.getDictValue());
}
Map<String, String> saleMap = Maps.newHashMap();
saleMap.put("开售", "1");
saleMap.put("不开售", "2");
Map<String, String> teachingModeMap = Maps.newHashMap();
teachingModeMap.put("班课", "1");
teachingModeMap.put("一对一", "2");
ImportCourseListener importCourseListener = new ImportCourseListener(courseService, courseChargeService);
importCourseListener.setCourseTypeMap(courseTypeMap);
importCourseListener.setCampusMap(campusMap);
importCourseListener.setChargeTypeMap(chargeTypeMap);
importCourseListener.setDateUnitMap(dateUnitMap);
importCourseListener.setSaleMap(saleMap);
importCourseListener.setTeachingModeMap(teachingModeMap);
importCourseListener.setLoginUserId(loginUser.getUserId());
importCourseListener.setImportId(importId);
EasyExcel.read(multipartFile.getInputStream(), ImportCourse.class, importCourseListener).sheet().autoTrim(true).headRowNumber(7).doRead();
int successRecord = importCourseListener.getSuccessRecord();
int failRecord = importCourseListener.getFailRecord();
return APIResponse.toAPIResponse("导入成功" + successRecord + "条,导入失败:" + failRecord);
}
}

@ -1,205 +0,0 @@
package cn.xluobo.business.tool.impt.service.strategy.impl;
import cn.xluobo.business.sc.course.domain.export.ExpCourse;
import cn.xluobo.business.sc.course.domain.req.ReqCourseClaSelect;
import cn.xluobo.business.sc.course.domain.req.ReqSearchScCourse;
import cn.xluobo.business.sc.course.domain.resp.RespCourseClaSelectInfo;
import cn.xluobo.business.sc.course.enums.CourseChargeTypeEnum;
import cn.xluobo.business.sc.course.repo.mapper.ScCourseClaMapper;
import cn.xluobo.business.sc.course.repo.mapper.ScCourseMapper;
import cn.xluobo.business.sys.admin.domain.resp.RespTreeSelect;
import cn.xluobo.business.sys.admin.service.BusinessSysDeptService;
import cn.xluobo.business.sys.admin.service.BusinessSysDictDataService;
import cn.xluobo.business.sys.receipt.repo.model.SysReceiptAccount;
import cn.xluobo.business.sys.receipt.service.ISysReceiptAccountService;
import cn.xluobo.business.tool.export.handler.bean.SelectValidationData;
import cn.xluobo.business.tool.impt.domain.ImportStudentOrder;
import cn.xluobo.business.tool.impt.listener.ImportStudentOrderListener;
import cn.xluobo.business.tool.impt.service.strategy.AbstractImportStrategy;
import cn.xluobo.config.properties.UploadConfigProperties;
import cn.xluobo.core.api.APIResponse;
import com.alibaba.excel.EasyExcel;
import com.baomidou.mybatisplus.core.toolkit.IdWorker;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.ruoyi.common.core.domain.entity.SysDictData;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.system.service.ISysUserService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.io.FileUtils;
import org.apache.commons.io.FilenameUtils;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
/**
*
*
* @author zhangbaoyu
* @date Created in 2020/10/12 16:24
*/
@Service("import_student_order")
@Slf4j
public class ImportStudentOrderImpl extends AbstractImportStrategy {
@Autowired
private BusinessSysDictDataService dictDataService;
@Autowired
private BusinessSysDeptService deptService;
@Autowired
private ScCourseMapper courseMapper;
@Autowired
private ScCourseClaMapper claMapper;
@Autowired
private ISysReceiptAccountService receiptAccountService;
@Autowired
private ISysUserService staffService;
@Autowired
private UploadConfigProperties uploadConfigProperties;
private static final String FILE_TYPE = "import_student_order";
@Override
public List<SelectValidationData> selectValidateConfig() {
// 联系人关系
List<SysDictData> contactRelationList = dictDataService.dictTypeDataList("contact_relation");
String[] contactRelationArray = contactRelationList.stream().map(SysDictData::getDictLabel).toArray(String[]::new);
// 性别
List<SysDictData> sexList = dictDataService.dictTypeDataList("sex");
String[] sexArray = sexList.stream().map(SysDictData::getDictLabel).toArray(String[]::new);
// 订单类型
List<SysDictData> orderDetailTagList = dictDataService.dictTypeDataList("order_detail_tag");
String[] orderDetailTagArray = orderDetailTagList.stream().map(SysDictData::getDictLabel).toArray(String[]::new);
// 报读校区
List<RespTreeSelect> campusList = deptService.campusList();
String[] campusNameArray = campusList.stream().map(RespTreeSelect::getLabel).toArray(String[]::new);
// 报读课程 课程-收费方式(校区)
ReqSearchScCourse reqSearchScCourse = new ReqSearchScCourse();
reqSearchScCourse.setSale("1");
List<ExpCourse> courseList = courseMapper.selectCourseForExport(reqSearchScCourse);
String[] courseNameArray = courseList.stream().map(item -> {
String courseName = item.getCourseName() + "(" + item.getDepartName() + ")-" + item.getChargeTypeName();
if (CourseChargeTypeEnum.DATE.getChargeType().equals(item.getChargeType())) {
courseName = courseName + "(" + item.getTotalFee().toString() + item.getDateUnitName() + ")";
} else {
courseName = courseName + "(" + item.getCount().toString() + "课时," + item.getTotalFee().toString() + "元)";
}
return courseName;
}).toArray(String[]::new);
// 报读班级 班级(教师)-课程
List<RespCourseClaSelectInfo> claList = claMapper.selectForSelect(new ReqCourseClaSelect());
String[] claNameArray = claList.stream().map(item -> item.getDeptName() + "-" + item.getClaName() + "(" + item.getStaffName() + ")" + "-" + item.getCourseName()).toArray(String[]::new);
// 收款账户
List<SysReceiptAccount> receiptAccountList = receiptAccountService.select();
String[] receiptAccountNameArray = receiptAccountList.stream().map(SysReceiptAccount::getAccountName).toArray(String[]::new);
// 销售员工
List<SysUser> staffList = staffService.selectUserList(new SysUser());
String[] staffNameArray = staffList.stream().map(SysUser::getNickName).toArray(String[]::new);
return Lists.newArrayList(
SelectValidationData.builder().firstCol(1).lastCol(1).firstRow(2).lastRow(206).selectDataArray(contactRelationArray).build(),
SelectValidationData.builder().firstCol(3).lastCol(3).firstRow(2).lastRow(206).selectDataArray(sexArray).build(),
SelectValidationData.builder().firstCol(6).lastCol(6).firstRow(2).lastRow(206).selectDataArray(orderDetailTagArray).build(),
SelectValidationData.builder().firstCol(7).lastCol(7).firstRow(2).lastRow(206).selectDataArray(campusNameArray).build(),
SelectValidationData.builder().firstCol(8).lastCol(8).firstRow(2).lastRow(206).selectDataArray(courseNameArray).build(),
SelectValidationData.builder().firstCol(9).lastCol(9).firstRow(2).lastRow(206).selectDataArray(claNameArray).build(),
SelectValidationData.builder().firstCol(16).lastCol(16).firstRow(2).lastRow(206).selectDataArray(campusNameArray).build(),
SelectValidationData.builder().firstCol(19).lastCol(19).firstRow(2).lastRow(206).selectDataArray(receiptAccountNameArray).build(),
SelectValidationData.builder().firstCol(20).lastCol(20).firstRow(2).lastRow(206).selectDataArray(staffNameArray).build()
);
}
@Override
@Transactional(propagation = Propagation.REQUIRES_NEW)
public APIResponse importDataByFileId(Long importId, String fileId) throws IOException {
String path = uploadConfigProperties.getTempSaveImportPath();
path = path + "/" + FILE_TYPE;
File file = new File(path, fileId);
if (!file.exists()) {
return APIResponse.toExceptionResponse("无法获取文件,请重试");
}
LoginUser loginUser = SecurityUtils.getLoginUser();
ImportStudentOrderListener importListener = new ImportStudentOrderListener();
importListener.setNeedSave(true);
importListener.setLoginUserId(loginUser.getUserId());
importListener.setLoginUser(loginUser);
importListener.setImportId(importId);
InputStream is = new FileInputStream(file);
EasyExcel.read(is, ImportStudentOrder.class, importListener).sheet().autoTrim(true).headRowNumber(5).doRead();
int successRecord = importListener.getSuccessRecordSize();
int failRecord = importListener.getFailRecordSize();
file.delete();
return APIResponse.toAPIResponse("导入成功" + successRecord + "条,导入失败:" + failRecord);
}
@Override
public APIResponse checkData(MultipartFile multipartFile) throws IOException {
long fileSize = multipartFile.getSize();
if (fileSize > 1024 * 1024 * 4) {
return APIResponse.toExceptionResponse("导入文件需小于4M");
}
LoginUser loginUser = SecurityUtils.getLoginUser();
ImportStudentOrderListener importListener = new ImportStudentOrderListener();
importListener.setNeedSave(false);
importListener.setLoginUserId(loginUser.getUserId());
// 保存文件
String fileId = IdWorker.getIdStr();
String fileName = DateTime.now().toString("yyyyMMddHHmmss") + "_" + fileId;
String originalFileName = multipartFile.getOriginalFilename();
String suffix = FilenameUtils.getExtension(originalFileName);
if (StringUtils.isNotEmpty(suffix)) {
fileName = fileName + "." + suffix;
}
String path = uploadConfigProperties.getTempSaveImportPath();
//上传文件夹
path = path + "/" + FILE_TYPE;
File uploadFileDir = new File(path);
if (!uploadFileDir.exists()) {
uploadFileDir.mkdir();
}
File uploadFile = new File(uploadFileDir, fileName);
FileUtils.copyInputStreamToFile(multipartFile.getInputStream(), uploadFile);
InputStream is = new FileInputStream(uploadFile);
EasyExcel.read(is, ImportStudentOrder.class, importListener).sheet().autoTrim(true).headRowNumber(5).doRead();
List<ImportStudentOrder> saveStudentOrderList = importListener.getSuccessRecordList();
List<ImportStudentOrder> failStudentList = importListener.getFailRecordList();
Map<String, Object> resultMap = Maps.newHashMap();
resultMap.put("successList", saveStudentOrderList);
resultMap.put("failList", failStudentList);
resultMap.put("fileId", fileName);
return APIResponse.toAPIResponse(resultMap);
}
}

@ -3,7 +3,7 @@ package cn.xluobo.business.wechat.cp.controller;
import cn.xluobo.business.wechat.cp.domain.req.ReqSearchWechatCpAccount;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpAccount;
import cn.xluobo.business.wechat.cp.service.BusinessWechatCpAccountService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -3,7 +3,7 @@ package cn.xluobo.business.wechat.cp.controller;
import cn.xluobo.business.wechat.cp.domain.req.ReqSearchWechatCpContact;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpContact;
import cn.xluobo.business.wechat.cp.service.BusinessWechatCpContactService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -3,7 +3,7 @@ package cn.xluobo.business.wechat.cp.controller;
import cn.xluobo.business.wechat.cp.domain.req.ReqSearchWechatCpContactWay;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpContactWay;
import cn.xluobo.business.wechat.cp.service.BusinessWechatCpContactWayService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -2,7 +2,7 @@ package cn.xluobo.business.wechat.cp.controller;
import cn.xluobo.business.wechat.cp.domain.req.ReqSearchCpCustomer;
import cn.xluobo.business.wechat.cp.service.BusinessWechatCpCustomerService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@ -3,7 +3,7 @@ package cn.xluobo.business.wechat.cp.controller;
import cn.xluobo.business.wechat.cp.domain.req.ReqSearchWechatCpGroupTag;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpGroupTag;
import cn.xluobo.business.wechat.cp.service.BusinessWechatCpGroupTagService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -1,8 +1,8 @@
package cn.xluobo.business.wechat.cp.controller;
import cn.xluobo.business.sc.course.domain.req.ReqSelect;
import cn.xluobo.business.wechat.cp.service.BusinessWechatCpUserService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.school.course.domain.req.course.ReqSelect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@ -64,7 +64,7 @@ public class WechatCpContact implements Serializable {
private Integer type;
/**
* 0- 1- 2-
*
*/
@TableField("gender")
private Integer gender;

@ -1,6 +1,6 @@
package cn.xluobo.business.wechat.cp.repo.model;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;

@ -71,7 +71,7 @@ public class WechatCpUser implements Serializable {
private String position;
/**
* 012
*
*/
@TableField("gender")
private String gender;

@ -2,8 +2,8 @@ package cn.xluobo.business.wechat.cp.service;
import cn.xluobo.business.wechat.cp.domain.req.ReqSearchWechatCpAccount;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpAccount;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.core.domain.model.LoginUser;

@ -2,8 +2,8 @@ package cn.xluobo.business.wechat.cp.service;
import cn.xluobo.business.wechat.cp.domain.req.ReqSearchWechatCpContact;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpContact;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.core.domain.model.LoginUser;

@ -4,8 +4,8 @@ import cn.xluobo.business.wechat.cp.domain.req.ReqSearchWechatCpContactWay;
import cn.xluobo.business.wechat.cp.domain.req.RespWechatCpContactWay;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpAccount;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpContactWay;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import cn.xluobo.core.page.RespPage;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;

@ -1,7 +1,7 @@
package cn.xluobo.business.wechat.cp.service;
import cn.xluobo.business.wechat.cp.domain.req.ReqSearchCpCustomer;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@ -3,8 +3,8 @@ package cn.xluobo.business.wechat.cp.service;
import cn.xluobo.business.wechat.cp.domain.req.ReqSearchWechatCpGroupTag;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpGroup;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpGroupTag;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.api.ApiResEnums;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.core.api.ApiResEnums;
import cn.xluobo.core.domain.select.GroupSelect;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

@ -1,10 +1,10 @@
package cn.xluobo.business.wechat.cp.service;
import cn.xluobo.business.sc.course.domain.req.ReqSelect;
import cn.xluobo.business.wechat.cp.repo.model.WechatCpUser;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.school.course.domain.req.course.ReqSelect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

@ -55,7 +55,7 @@ public class WechatUserInfo implements Serializable {
private String nickName;
/**
* 012
*
*/
@TableField("sex")
private String sex;

@ -1,6 +1,6 @@
package cn.xluobo.config.security;
import cn.xluobo.core.api.APIBaseResponse;
import com.ruoyi.core.api.APIBaseResponse;
import com.alibaba.fastjson.JSON;
import org.springframework.http.MediaType;
import org.springframework.security.core.AuthenticationException;

@ -1,7 +1,7 @@
package cn.xluobo.config.security;
import cn.xluobo.business.sys.log.service.ISysUserLoginLogService;
import cn.xluobo.core.api.APIBaseResponse;
import com.ruoyi.core.api.APIBaseResponse;
import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.MediaType;
@ -11,7 +11,6 @@ import org.springframework.security.web.savedrequest.HttpSessionRequestCache;
import org.springframework.security.web.savedrequest.RequestCache;
import org.springframework.security.web.savedrequest.SavedRequest;
import org.springframework.security.web.util.UrlUtils;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import javax.servlet.ServletException;

@ -44,6 +44,16 @@ public class SysTeacherController extends BaseController
List<SysTeacher> list = sysTeacherService.selectSysTeacherList(sysTeacher);
return getDataTable(list);
}
/**
*
*/
@GetMapping("/teacherSelect")
public AjaxResult teacherSelect(SysTeacher sysTeacher)
{
sysTeacher.setTenantId(SecurityUtils.getLoginUser().getNowTenantId());
List<SysTeacher> list = sysTeacherService.selectSysTeacherList(sysTeacher);
return AjaxResult.successData(list);
}
@PreAuthorize("@ss.hasPermi('system:teacher:list')")
@GetMapping("/getUserForTeacher")
@ -55,6 +65,7 @@ public class SysTeacherController extends BaseController
return AjaxResult.successData(list);
}
/**
*
*/

@ -1,11 +1,7 @@
package com.ruoyi.web.controller.mall;
import cn.hutool.core.util.ObjectUtil;
import cn.xluobo.business.sc.course.domain.req.ReqSearchScCourse;
import cn.xluobo.business.sc.course.domain.resp.course.RespSearchCourse;
import cn.xluobo.business.sc.course.repo.model.ScCourse;
import cn.xluobo.business.sc.course.service.IScCourseService;
import cn.xluobo.core.page.RespPage;
import com.ruoyi.common.page.RespPage;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.core.controller.BaseController;
import com.ruoyi.common.enums.BusinessType;
@ -13,6 +9,10 @@ import com.ruoyi.mall.domain.Product;
import com.ruoyi.mall.domain.query.ProductQuery;
import com.ruoyi.mall.domain.vo.ProductVO;
import com.ruoyi.mall.service.ProductService;
import com.ruoyi.school.course.domain.req.course.ReqSearchScCourse;
import com.ruoyi.school.course.domain.resp.course.RespSearchCourse;
import com.ruoyi.school.course.domain.ScCourse;
import com.ruoyi.school.course.service.IScCourseService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;

@ -1,11 +1,11 @@
package cn.xluobo.business.sc.course.controller;
package com.ruoyi.web.controller.school.course;
import cn.xluobo.business.sc.course.domain.req.time.ReqSearchScClaTimeAttend;
import cn.xluobo.business.sc.course.domain.resp.time.RespClaTimeAttend;
import cn.xluobo.business.sc.course.repo.model.ScClaTimeAttend;
import cn.xluobo.business.sc.course.service.BusinessScClaTimeAttendService;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.page.RespPage;
import com.ruoyi.common.page.RespPage;
import com.ruoyi.school.course.domain.req.time.ReqSearchScClaTimeAttend;
import com.ruoyi.school.course.domain.resp.time.RespClaTimeAttend;
import com.ruoyi.school.course.domain.ScClaTimeAttend;
import com.ruoyi.school.course.service.BusinessScClaTimeAttendService;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -1,15 +1,15 @@
package cn.xluobo.business.sc.course.controller;
import cn.xluobo.business.sc.course.domain.req.time.ReqSearchClaTime;
import cn.xluobo.business.sc.course.domain.resp.time.RespBusinessClaTimeCalendar;
import cn.xluobo.business.sc.course.domain.resp.time.RespClaTime;
import cn.xluobo.business.sc.course.domain.resp.time.RespClaTimeCalendar;
import cn.xluobo.business.sc.course.repo.model.ScClaTime;
import cn.xluobo.business.sc.course.repo.model.ScClaTimeVo;
import cn.xluobo.business.sc.course.service.BusinessClaTimeService;
import cn.xluobo.business.sc.student.domain.req.ReqClaTimeAttend;
import cn.xluobo.core.api.APIResponse;
import cn.xluobo.core.page.RespPage;
package com.ruoyi.web.controller.school.course;
import com.ruoyi.common.page.RespPage;
import com.ruoyi.school.course.domain.req.time.ReqSearchClaTime;
import com.ruoyi.school.course.domain.resp.time.RespBusinessClaTimeCalendar;
import com.ruoyi.school.course.domain.resp.time.RespClaTime;
import com.ruoyi.school.course.domain.resp.time.RespClaTimeCalendar;
import com.ruoyi.school.course.domain.ScClaTime;
import com.ruoyi.school.course.domain.ScClaTimeVo;
import com.ruoyi.school.course.service.BusinessClaTimeService;
import com.ruoyi.school.student.domain.req.ReqClaTimeAttend;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@ -37,6 +37,13 @@ public class ScClaTimeController {
return claTimeService.searchListForCalendar(reqSearchClaTime);
}
@GetMapping("/list/searchListForCalendarByMemberId")
public APIResponse searchListForCalendarByMemberId(ReqSearchClaTime reqSearchClaTime) {
return claTimeService.searchMemberId(reqSearchClaTime);
}
/**
*
*
@ -106,21 +113,14 @@ public class ScClaTimeController {
}
/**
*
*
* @param reqClaTimeAttend
* @return
*/
@PostMapping("/update/changeHadClaTimeAttend")
public APIResponse changeHadClaTimeAttend(@RequestBody ReqClaTimeAttend reqClaTimeAttend) {
return claTimeService.changeHadClaTimeAttend(reqClaTimeAttend);
@PostMapping("/update/confirmCla")
public APIResponse confirmCla(@RequestBody ReqClaTimeAttend reqClaTimeAttend) {
return claTimeService.confirmCla(reqClaTimeAttend);
}
/**
*
* @return
*/
@DeleteMapping("/delete/deleteHadClaTimeAttend/{courseTimeId}")
public APIResponse deleteHadClaTimeAttend(@PathVariable("courseTimeId") Long courseTimeId) {
return claTimeService.deleteHadClaTimeAttend(courseTimeId);
}
}

@ -1,9 +1,9 @@
package cn.xluobo.business.sc.course.controller;
package com.ruoyi.web.controller.school.course;
import cn.xluobo.business.sc.course.domain.req.time.ReqSearchScClaTimeRule;
import cn.xluobo.business.sc.course.repo.model.ScClaTimeRule;
import cn.xluobo.business.sc.course.service.BusinessClaTimeRuleService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.school.course.domain.req.time.ReqSearchScClaTimeRule;
import com.ruoyi.school.course.domain.ScClaTimeRule;
import com.ruoyi.school.course.service.BusinessClaTimeRuleService;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -1,11 +1,12 @@
package cn.xluobo.business.sc.course.controller;
package com.ruoyi.web.controller.school.course;
import cn.xluobo.business.sc.course.domain.req.ReqAddScCourseCla;
import cn.xluobo.business.sc.course.domain.req.ReqSearchScCourseCla;
import cn.xluobo.business.sc.course.domain.resp.cla.RespClaAllDetailInfo;
import cn.xluobo.business.sc.course.repo.model.ScCourseCla;
import cn.xluobo.business.sc.course.service.BusinessScCourseClaService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.school.course.domain.ScCourseCla;
import com.ruoyi.school.course.domain.req.cla.ReqAddScCourseCla;
import com.ruoyi.school.course.domain.req.cla.ReqSearchScCourseCla;
import com.ruoyi.school.course.domain.req.time.ReqSearchClaTime;
import com.ruoyi.school.course.domain.resp.cla.RespClaAllDetailInfo;
import com.ruoyi.school.course.service.impl.BusinessScCourseClaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@ -34,6 +35,16 @@ public class ScCourseClaController {
return scCourseClaService.searchList(reqSearchScCourseCla);
}
/**
*
* @param
* @return
*/
@GetMapping("/list/searchCourseClaStudent")
public APIResponse searchCourseClaStudent(ReqSearchClaTime reqSearchClaTime) {
return scCourseClaService.searchCourseClaStudent(reqSearchClaTime);
}
/**
*
*
@ -58,6 +69,8 @@ public class ScCourseClaController {
return APIResponse.toAPIResponse(allDetailInfo);
}
/**
*
*
@ -91,4 +104,5 @@ public class ScCourseClaController {
return scCourseClaService.deleteById(claIds);
}
}

@ -1,14 +1,12 @@
package cn.xluobo.business.sc.course.controller;
import cn.xluobo.business.sc.course.domain.req.ReqBusinessOrderCourseDetail;
import cn.xluobo.business.sc.course.domain.req.ReqSearchScCourse;
import cn.xluobo.business.sc.course.domain.req.ReqSelect;
import cn.xluobo.business.sc.course.domain.req.course.ReqAddScCourse;
import cn.xluobo.business.sc.course.domain.req.course.ReqChangeScCourse;
import cn.xluobo.business.sc.course.repo.model.ScCourse;
import cn.xluobo.business.sc.course.service.BusinessScCourseService;
import cn.xluobo.business.sc.course.service.IScCourseService;
import cn.xluobo.core.api.APIResponse;
package com.ruoyi.web.controller.school.course;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.school.course.domain.req.course.ReqSearchScCourse;
import com.ruoyi.school.course.domain.req.course.ReqSelect;
import com.ruoyi.school.course.domain.req.course.ReqAddScCourse;
import com.ruoyi.school.course.domain.req.course.ReqChangeScCourse;
import com.ruoyi.school.course.domain.ScCourse;
import com.ruoyi.school.course.service.BusinessScCourseService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@ -29,9 +27,6 @@ public class ScCourseController {
@Autowired
private BusinessScCourseService scCourseService;
@Autowired
private IScCourseService courseService;
/**
*
*
@ -120,36 +115,7 @@ public class ScCourseController {
return scCourseService.changeCourseSale(scCourse);
}
/**
*
*
* @param reqSearchScCourse
*/
@GetMapping("/export/exportCourse")
public APIResponse exportCourse(ReqSearchScCourse reqSearchScCourse) {
return scCourseService.exportCourse(reqSearchScCourse);
}
/**
*
*
*
* @param orderCourseDetail
* @return
*/
@GetMapping("/info/orderCourseDetail")
public APIResponse orderCourseDetail(ReqBusinessOrderCourseDetail orderCourseDetail) {
return scCourseService.orderCourseDetail(orderCourseDetail);
}
/**
*
*
* @param orderCourseDetail
* @return
*/
@GetMapping("/info/studentCanSignUpCourse")
public APIResponse studentCanSignUpCourse(ReqBusinessOrderCourseDetail orderCourseDetail) {
return scCourseService.studentCanSignUpCourse(orderCourseDetail);
}
}

@ -0,0 +1,152 @@
package com.ruoyi.web.controller.school.course;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.core.domain.model.LoginUser;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.school.course.domain.req.course.ReqSearchScCourseType;
import com.ruoyi.school.course.domain.resp.course.RespCourseSelect;
import com.ruoyi.school.course.domain.resp.course.RespCourseTypeSelect;
import com.ruoyi.school.course.domain.ScCourse;
import com.ruoyi.school.course.domain.ScCourseType;
import com.ruoyi.school.course.service.BusinessScCourseTypeService;
import com.ruoyi.school.course.service.impl.ScCourseServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* Controller
* </p>
*
* @author zhangby
* @since 2020-07-09 08:10:25
*/
@RestController
@RequestMapping("/api/sc/course/type")
public class ScCourseTypeController {
@Autowired
private BusinessScCourseTypeService scCourseTypeService;
@Autowired
private ScCourseServiceImpl scCourseService;
/**
*
*
* @param reqSearchScCourseType
* @return
*/
@GetMapping("/list/searchList")
public APIResponse searchList(ReqSearchScCourseType reqSearchScCourseType) {
return scCourseTypeService.searchList(reqSearchScCourseType);
}
/**
* select
*
* @param reqSearchScCourseType
* @return
*/
@GetMapping("/list/select")
public APIResponse select(ReqSearchScCourseType reqSearchScCourseType) {
List<ScCourseType> list = scCourseTypeService.select(reqSearchScCourseType);
return APIResponse.toAPIResponse(list);
}
/**
* select
*
* @param
* @return
*/
@GetMapping("/list/selectForCheckbox")
public APIResponse selectForCheckbox() {
List<ScCourseType> list = scCourseTypeService.select(new ReqSearchScCourseType());
List<RespCourseTypeSelect> typeList= list.stream().map(RespCourseTypeSelect::new).collect(Collectors.toList());
return APIResponse.toAPIResponse(typeList);
}
/**
* select
*
* @param reqSearchScCourseType
* @return
*/
@GetMapping("/list/selectByTypeIds")
public APIResponse selectByTypeIds(ReqSearchScCourseType reqSearchScCourseType) {
List<ScCourseType> list = scCourseTypeService.select(reqSearchScCourseType);
List<RespCourseTypeSelect> typeList= list.stream().map(RespCourseTypeSelect::new).collect(Collectors.toList());
typeList.forEach(l->{
List<ScCourse> list1= scCourseService.list(new QueryWrapper<ScCourse>()
.eq("course_type_id",l.getId())
.eq("delete_flag",'0')
);
List<RespCourseSelect> list2= list1.stream().map(RespCourseSelect::new).collect(Collectors.toList());
l.setCourseList(list2);
});
return APIResponse.toAPIResponse(typeList);
}
/**
*
*
* @param courseTypeId
* @return
*/
@GetMapping("/info/detailById/{courseTypeId}")
public APIResponse detailById(@PathVariable("courseTypeId") Long courseTypeId) {
return scCourseTypeService.detailById(courseTypeId);
}
/**
*
*
* @param scCourseType
* @return
*/
@PostMapping("/add/addScCourseType")
public APIResponse addScCourseType(@RequestBody ScCourseType scCourseType) {
LoginUser loginUser = SecurityUtils.getLoginUser();
scCourseType.setTenantId(loginUser.getNowTenantId());
return scCourseTypeService.addScCourseType(scCourseType);
}
/**
*
*
* @param scCourseType
* @return
*/
@PutMapping("/update/updateScCourseType")
public APIResponse updateScCourseType(@RequestBody ScCourseType scCourseType) {
return scCourseTypeService.updateScCourseType(scCourseType);
}
/**
*
*
* @param courseTypeIds
* @return
*/
@DeleteMapping("/delete/deleteById/{courseTypeIds}")
public APIResponse deleteById(@PathVariable("courseTypeIds") Long[] courseTypeIds) {
return scCourseTypeService.deleteById(courseTypeIds);
}
/**
*
*
* @param
* @return
*/
@PutMapping("/changeCourseTypeSale")
public APIResponse changeCourseTypeSale(@RequestBody ScCourseType scCourseType) {
return scCourseTypeService.changeCourseTypeSale(scCourseType);
}
}

@ -1,10 +1,10 @@
package cn.xluobo.business.sc.base.controller;
package com.ruoyi.web.controller.school.course;
import cn.xluobo.business.sc.base.domain.req.ReqRoomSelect;
import cn.xluobo.business.sc.base.domain.req.ReqSearchScRoom;
import cn.xluobo.business.sc.base.repo.model.ScRoom;
import cn.xluobo.business.sc.base.service.BusinessScRoomService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.school.room.domain.req.ReqRoomSelect;
import com.ruoyi.school.room.domain.req.ReqSearchScRoom;
import com.ruoyi.school.room.domain.ScRoom;
import com.ruoyi.school.room.service.BusinessScRoomService;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -0,0 +1,154 @@
package com.ruoyi.web.controller.school.member;
import com.ruoyi.common.page.RespPage;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.school.member.domain.req.CreateMemberCardDTO;
import com.ruoyi.school.member.domain.resp.MemberCardDTO;
import com.ruoyi.school.member.domain.resp.MemberCardVO;
import com.ruoyi.school.member.service.IScMemberCardService;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import javax.validation.Valid;
import java.util.List;
import java.util.Map;
/**
* <p>
* Controller
* </p>
*
*/
@RestController
@RequestMapping("/api/sc/memberCard")
public class ScMemberCardController {
@Autowired
private IScMemberCardService memberCardService;
@PostMapping("/list")
@ApiOperation("分页查询会员卡列表")
public APIResponse getCardList(
@Valid @RequestBody MemberCardDTO queryDTO) {
RespPage<MemberCardVO> result = memberCardService.getCardList(queryDTO);
return APIResponse.toAPIResponse(result);
}
@PostMapping("/create")
@ApiOperation("创建会员卡")
public APIResponse createMemberCard(@Valid @RequestBody CreateMemberCardDTO dto) {
MemberCardDTO result = memberCardService.createMemberCard(dto);
return APIResponse.toAPIResponse(result);
}
@PostMapping("/checkIn")
@ApiOperation("批量签到")
public APIResponse checkIn( @Valid @RequestBody Map<String , List<Long> > map
) {
List<Long> bookIds=map.get("bookIds");
return memberCardService.checkInByIds(bookIds);
}
@GetMapping("/{cardNo}")
@ApiOperation("根据卡号查询会员卡")
public APIResponse getByCardNo(@PathVariable String cardNo) {
MemberCardVO result = memberCardService.getByCardNo(cardNo);
return APIResponse.toAPIResponse(result);
}
@PostMapping("/{cardId}/activate")
@ApiOperation("激活会员卡")
public APIResponse activateCard(@PathVariable Long cardId) {
boolean result = memberCardService.activateCard(cardId);
return APIResponse.toAPIResponse(result);
}
@GetMapping("/member/{memberId}")
@ApiOperation("查询会员的会员卡列表")
public APIResponse getMemberCards(@PathVariable Long memberId) {
List<MemberCardVO> result = memberCardService.getMemberCards(memberId);
return APIResponse.toAPIResponse(result);
}
@PostMapping("/member/{cardId}")
@ApiOperation("暂停会员卡")
public APIResponse suspendCard(
@ApiParam(value = "会员卡ID", required = true)
@PathVariable Long cardId) {
boolean result = memberCardService.suspendCard(cardId);
return APIResponse.toAPIResponse(result ? "暂停成功" : "暂停失败");
}
// @PostMapping("/renew")
// @ApiOperation("续费会员卡")
// public APIResponse renewCard(
// @Valid @RequestBody RenewCardDTO dto) {
// boolean result = memberCardService.renewCard(dto.getCardId(), dto.getDays());
// return APIResponse.toAPIResponse(result ? "续费成功" : "续费失败");
// }
@PostMapping("/add-count")
@ApiOperation("增加次数")
public APIResponse addCardCount(
@ApiParam(value = "会员卡ID", required = true)
@RequestParam Long cardId,
@ApiParam(value = "增加次数", required = true)
@RequestParam Integer count) {
boolean result = memberCardService.addCardCount(cardId, count);
return APIResponse.toAPIResponse(result ? "增加成功" : "增加失败");
}
@PostMapping("/deduct-count")
@ApiOperation("扣减次数")
public APIResponse deductCardCount(
@ApiParam(value = "会员卡ID", required = true)
@RequestParam Long cardId,
@ApiParam(value = "扣减次数", required = true)
@RequestParam Integer count) {
boolean result = memberCardService.deductCardCount(cardId, count);
return APIResponse.toAPIResponse(result ? "扣减成功" : "扣减失败");
}
@GetMapping("/valid/{memberId}")
@ApiOperation("查询会员有效的会员卡")
public APIResponse getValidMemberCards(
@ApiParam(value = "会员ID", required = true)
@PathVariable Long memberId) {
List<MemberCardVO> result = memberCardService.getValidMemberCards(memberId);
return APIResponse.toAPIResponse(result);
}
@PostMapping("/check-status/{cardId}")
@ApiOperation("检查会员卡状态")
public APIResponse checkCardStatus(
@ApiParam(value = "会员卡ID", required = true)
@PathVariable Long cardId) {
boolean result = memberCardService.checkCardStatus(cardId);
return APIResponse.toAPIResponse(result ? "卡状态正常" : "卡状态异常");
}
@DeleteMapping("/{id}")
@ApiOperation("删除会员卡(逻辑删除)")
public APIResponse deleteCard(
@ApiParam(value = "会员卡ID", required = true)
@PathVariable Long id) {
boolean result = memberCardService.removeById(id);
return APIResponse.toAPIResponse(result ? "删除成功" : "删除失败");
}
@GetMapping("/todayCardCount")
@ApiOperation("查询今日办卡数量")
public APIResponse getTodayCardCount() {
Integer result = memberCardService.getTodayCardCount();
return APIResponse.toAPIResponse(result);
}
}

@ -0,0 +1,295 @@
package com.ruoyi.web.controller.school.member;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.core.domain.entity.SysUser;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.school.course.domain.req.course.ReqBusinessOrderCourseDetail;
import com.ruoyi.school.course.domain.resp.course.RespCourseTypeSelect;
import com.ruoyi.school.course.domain.ScCourseType;
import com.ruoyi.school.course.service.IScCourseTypeService;
import com.ruoyi.school.member.domain.ScMemberCard;
import com.ruoyi.school.member.domain.ScMemberCardCharge;
import com.ruoyi.school.member.domain.ScMemberCardCourses;
import com.ruoyi.school.member.domain.ScMemberCardTypes;
import com.ruoyi.school.member.domain.req.ReqAddMemberChargeItem;
import com.ruoyi.school.member.service.IScMemberCardService;
import com.ruoyi.school.member.service.ScMemberCardChargeService;
import com.ruoyi.school.member.service.ScMemberCardCourseService;
import com.ruoyi.school.member.service.ScMemberCardTypesService;
import com.ruoyi.system.service.ISysUserService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
/**
* <p>
* Controller
* </p>
*
*/
@RestController
@RequestMapping("/api/sc/memberCardTypes")
public class ScMemberCardTypesController {
@Autowired
private ScMemberCardTypesService typesService;
@Autowired
private IScCourseTypeService courseTypeService;
@Autowired
private ScMemberCardChargeService cardChargeService;
@Autowired
private ScMemberCardCourseService cardCoursesService;
@Autowired
private ISysUserService userService;
@Autowired
private IScMemberCardService memberCardService;
/**
*
*
* @param
* @return
*/
@GetMapping("/list/searchList")
public APIResponse searchList(ScMemberCardTypes types) {
QueryWrapper qw = new QueryWrapper();
qw.eq("tenant_id", SecurityUtils.getLoginUser().getNowTenantId());
// qw.eq("delete_flag", "0");
if (StringUtils.isNotEmpty(types.getCardName())) {
qw.eq("card_name", types.getCardName());
}
if (StringUtils.isNotEmpty(types.getSale())) {
qw.eq("sale", types.getSale());
}
if (StrUtil.isNotEmpty(types.getCardType()) && !types.getCardType().equals("total_fee")){// count 按课时 date_unit 按时间
qw.isNotNull(types.getCardType());
qw.ne(types.getCardType(),"");
}
qw.last(ObjectUtil.isNotEmpty(types.getCourseTypeId())," and JSON_CONTAINS(course_types, CAST("+types.getCourseTypeId()+" AS JSON)) ");
RespPage<ScMemberCardTypes> respPage = new RespPage<>(types.getPageNum(),types.getPageSize());
RespPage<ScMemberCardTypes> listPage =typesService.page(respPage, qw);
listPage.getRows().forEach(l->{
//获取课程分类 名
if (ObjectUtil.isNotEmpty(l.getCourseTypes())||l.getCourseTypes().length>0){
List<Long> courseTypeIds = Arrays.asList(l.getCourseTypes());
List<ScCourseType> courseTypeList=courseTypeService.listByIds(courseTypeIds);
String typesName= courseTypeList.stream().map(ScCourseType::getCourseType)
.collect(Collectors.joining(","));
l.setCourseTypesName(typesName);
}
//付费模式 default customize自定义
if (l.getChargeType().equals("customize")){
List<ReqAddMemberChargeItem> list=cardChargeService.getByMemberId(l.getCardTypeId());
l.setFeeModeHourList(list);
}
//限制教师
if (l.getRestrictedTeacher().equals("2") ){
List<SysUser> users= userService.selectUserByIds(l.getTeacherList());
String userNames= users.stream().map(SysUser::getNickName).collect(Collectors.joining(","));
l.setTeachersName(userNames);
}
//限制课程
if (l.getRestrictedCourses().equals("2")){
//课程类别名称 课程名称
List<ScMemberCardCourses> cardCoursesList=cardCoursesService.getByCardId(l.getCardTypeId());
l.setCourses(cardCoursesList);
}
});
return APIResponse.toAPIResponse(listPage);
}
/**
* select
*
* @return
*/
@GetMapping("/list/select")
public APIResponse select(ScMemberCardTypes types) {
QueryWrapper<ScMemberCardTypes> qw = new QueryWrapper();
qw.eq("tenant_id", SecurityUtils.getLoginUser().getNowTenantId());
qw.eq("delete_flag", "0");
qw.eq("sale", "1");
if (StringUtils.isNotEmpty(types.getCardName())) {
qw.eq("card_name", types.getCardName());
}
return APIResponse.toAPIResponse(typesService.list(qw));
}
/**
*
*
* @param
* @return
*/
@GetMapping("/info/detailById/{cardId}")
public APIResponse detailById(@PathVariable("cardId") Long cardId) {
ScMemberCardTypes types=typesService.getById(cardId);
//限制课程
if (types.getRestrictedCourses().equals("2") ){
List<ScMemberCardCourses> cardCoursesList= cardCoursesService.list(new QueryWrapper<ScMemberCardCourses>()
.eq("card_type_id",types.getCardTypeId()));
List<RespCourseTypeSelect> typeList= cardCoursesList.stream().map(RespCourseTypeSelect::new).collect(Collectors.toList());
types.setCourseListInType(typeList);
}
//付费模式 自定义
if (types.getChargeType().equals("customize") ){
List<ScMemberCardCharge> cardChargeList= cardChargeService.list(new QueryWrapper<ScMemberCardCharge>()
.eq("card_type_id",types.getCardTypeId()));
List<ReqAddMemberChargeItem> chargeItems= BeanUtil.copyToList(cardChargeList,ReqAddMemberChargeItem.class);
types.setFeeModeHourList(chargeItems);
}
return APIResponse.toAPIResponse(types);
}
/**
*
*
* @param
* @return
*/
@PostMapping("/add/memberCardTypes")
@Transactional
public APIResponse addScCourse(@RequestBody ScMemberCardTypes types) {
//todo 会员卡项修改记录
types.checkParam();
types.setTenantId(SecurityUtils.getLoginUser().getNowTenantId());
types.setCreateUser(SecurityUtils.getUserId());
typesService.save(types);
Long cardTypeId=types.getCardTypeId();
//限制课程 会员卡项 课程类型 课程id[]
List<RespCourseTypeSelect> list=types.getCourseListInType();
if (types.getRestrictedCourses().equals("2") && list.size()>0){
List<ScMemberCardCourses> cardCoursesList= new ArrayList<>();
for (RespCourseTypeSelect type : list) {
Long[] courses= type.getSelectedCourses();
if (ObjectUtil.isEmpty(courses) || courses.length<1) continue;
ScMemberCardCourses cardCourse=new ScMemberCardCourses();
cardCourse.setCardTypeId(cardTypeId);
cardCourse.setCourseTypeId(type.getId());
cardCourse.setCourses(courses);
cardCoursesList.add(cardCourse);
}
cardCoursesService.saveBatch(cardCoursesList);
}
//付费模式: 会员卡项 课程类型 扣卡次数 扣卡金额
List<ReqAddMemberChargeItem> feeList= types.getFeeModeHourList();
if (types.getChargeType().equals("customize") && feeList.size()>0){
List<ScMemberCardCharge> cardChargeList= BeanUtil.copyToList(feeList,ScMemberCardCharge.class);
cardChargeList.forEach(l->{
l.setCardTypeId(cardTypeId);
});
cardChargeService.saveBatch(cardChargeList);
}
return APIResponse.toOkResponse();
}
/**
*
*
* @param
* @return
*/
@PutMapping("/update/updateMemberCardTypes")
@Transactional
public APIResponse updateScCourse(@RequestBody ScMemberCardTypes types) {
types.setLastUpdateUser(SecurityUtils.getUserId());
typesService.updateById(types);
cardChargeService.remove(new QueryWrapper<ScMemberCardCharge>()
.eq("card_type_id",types.getCardTypeId()));
cardCoursesService.remove(new QueryWrapper<ScMemberCardCourses>()
.eq("card_type_id",types.getCardTypeId()));
//限制课程 会员卡项 课程类型 课程id[]
List<RespCourseTypeSelect> list=types.getCourseListInType();
if (types.getRestrictedCourses().equals("2") && list.size()>0){
List<ScMemberCardCourses> cardCoursesList= new ArrayList<>();
for (RespCourseTypeSelect type : list) {
Long[] courses= type.getSelectedCourses();
if (ObjectUtil.isEmpty(courses) || courses.length<1) continue;
ScMemberCardCourses cardCourse=new ScMemberCardCourses();
cardCourse.setCardTypeId(types.getCardTypeId());
cardCourse.setCourseTypeId(type.getId());
cardCourse.setCourses(courses);
cardCoursesList.add(cardCourse);
}
cardCoursesService.saveBatch(cardCoursesList);
}
//付费模式: 会员卡项 课程类型 扣卡次数 扣卡金额
List<ReqAddMemberChargeItem> feeList= types.getFeeModeHourList();
if (types.getChargeType().equals("customize") && feeList.size()>0){
List<ScMemberCardCharge> cardChargeList= BeanUtil.copyToList(feeList,ScMemberCardCharge.class);
cardChargeList.forEach(l->{
l.setCardTypeId(types.getCardTypeId());
});
cardChargeService.saveBatch(cardChargeList);
}
return APIResponse.toOkResponse();
}
@PutMapping("/update/editSale")
@Transactional
public APIResponse editSale(@RequestBody ScMemberCardTypes types) {
types.setLastUpdateUser(SecurityUtils.getUserId());
typesService.updateById(types);
return APIResponse.toOkResponse();
}
/**
*
*
* @param
* @return
*/
@DeleteMapping("/delete/deleteById/{cardIds}")
@Transactional
public APIResponse deleteById(@PathVariable("cardIds") List<Long> cardIds) {
//判断 卡类下是否有会员
int count=memberCardService.count(new QueryWrapper<ScMemberCard>().in("card_type_id",cardIds));
if (count>0){
return APIResponse.toExceptionResponse("当前卡类已办理会员,无法删除!");
}
typesService.removeByIds(cardIds);
cardChargeService.remove(new QueryWrapper<ScMemberCardCharge>()
.in("card_type_id",cardIds));
cardCoursesService.remove(new QueryWrapper<ScMemberCardCourses>()
.in("card_type_id",cardIds));
return APIResponse.toOkResponse();
}
@GetMapping("/info/orderCardTypeDetail")
public APIResponse orderCardTypeDetail(ReqBusinessOrderCourseDetail orderCourseDetail) {
return typesService.orderCardTypeDetail(orderCourseDetail);
}
}

@ -1,10 +1,10 @@
package cn.xluobo.business.sc.student.controller;
package com.ruoyi.web.controller.school.member;
import cn.xluobo.business.sc.student.domain.req.ReqSearchScStudent;
import cn.xluobo.business.sc.student.domain.req.ReqStudentSelect;
import cn.xluobo.business.sc.student.repo.model.ScStudent;
import cn.xluobo.business.sc.student.service.BusinessScStudentService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.school.member.domain.req.ReqSearchScStudent;
import com.ruoyi.school.member.domain.req.ReqStudentSelect;
import com.ruoyi.school.member.domain.ScStudent;
import com.ruoyi.school.student.service.BusinessScStudentService;
import com.ruoyi.core.api.APIResponse;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@ -1,8 +1,8 @@
package cn.xluobo.business.report.dashboard.controller;
package com.ruoyi.web.controller.school.order;
import cn.xluobo.business.report.dashboard.domain.resp.DashboardData;
import cn.xluobo.business.report.dashboard.service.DashboardService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.school.dashboard.domain.resp.DashboardData;
import com.ruoyi.school.dashboard.service.DashboardService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;

@ -1,9 +1,8 @@
package cn.xluobo.business.sc.order.controller;
package com.ruoyi.web.controller.school.order;
import cn.xluobo.business.sc.order.domain.req.ReqBusinessSignUp;
import cn.xluobo.business.sc.order.domain.req.ReqSearchScOrder;
import cn.xluobo.business.sc.order.service.BusinessScOrderService;
import cn.xluobo.core.api.APIResponse;
import com.ruoyi.core.api.APIResponse;
import com.ruoyi.school.order.domain.req.ReqSearchScOrder;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
@ -43,16 +42,7 @@ public class ScOrderController {
return scOrderService.detailById(orderId);
}
/**
*
*
* @param reqBusinessSignUp
* @return
*/
@PostMapping("/add/signUp")
public APIResponse signUp(@RequestBody ReqBusinessSignUp reqBusinessSignUp) {
return scOrderService.signUp(reqBusinessSignUp);
}
/**
*

@ -1,9 +1,9 @@
package cn.xluobo.business.sc.salary.controller;
package com.ruoyi.web.controller.school.salary;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.xluobo.business.sc.salary.repo.model.ScCommissionPlans;
import cn.xluobo.business.sc.salary.service.ScCommissionPlansService;
import com.ruoyi.school.salary.domain.ScCommissionPlans;
import com.ruoyi.school.salary.service.ScCommissionPlansService;
import cn.xluobo.core.page.RespPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.common.core.domain.AjaxResult;

@ -1,8 +1,5 @@
package com.ruoyi.web.controller.system;
import cn.xluobo.business.sc.student.repo.model.ScStudentCourse;
import cn.xluobo.business.sc.student.service.IScStudentCourseService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.ruoyi.common.annotation.Log;
import com.ruoyi.common.constant.UserConstants;
import com.ruoyi.common.core.controller.BaseController;
@ -31,8 +28,6 @@ public class SysDeptController extends BaseController
{
@Autowired
private ISysDeptService deptService;
@Autowired
private IScStudentCourseService studentCourseService;
/**
*
*/
@ -157,12 +152,12 @@ public class SysDeptController extends BaseController
return AjaxResult.error("部门存在用户,不允许删除");
}
// 如果已报读 不允许删除
QueryWrapper<ScStudentCourse> qwSc = new QueryWrapper<>();
qwSc.eq("dept_id", deptId);
int studentCourseCount = studentCourseService.count(qwSc);
if (studentCourseCount != 0) {
return AjaxResult.error("该校区已有报读学员,无法删除");
}
// QueryWrapper<ScStudentCourse> qwSc = new QueryWrapper<>();
// qwSc.eq("dept_id", deptId);
// int studentCourseCount = studentCourseService.count(qwSc);
// if (studentCourseCount != 0) {
// return AjaxResult.error("该校区已有报读学员,无法删除");
// }
return toAjax(deptService.deleteDeptById(deptId));
}
}

@ -1,121 +0,0 @@
package com.ruoyi.web.core.config;
import com.ruoyi.common.config.RuoYiConfig;
import io.swagger.annotations.ApiOperation;
import io.swagger.models.auth.In;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.*;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spi.service.contexts.SecurityContext;
import springfox.documentation.spring.web.plugins.Docket;
import java.util.ArrayList;
import java.util.List;
/**
* Swagger2
*
* @author ruoyi
*/
@Configuration
public class SwaggerConfig
{
/** 系统基础配置 */
@Autowired
private RuoYiConfig ruoyiConfig;
/** 是否开启swagger */
@Value("${swagger.enabled}")
private boolean enabled;
/** 设置请求的统一前缀 */
@Value("${swagger.pathMapping}")
private String pathMapping;
/**
* API
*/
@Bean
public Docket createRestApi()
{
return new Docket(DocumentationType.OAS_30)
// 是否启用Swagger
.enable(enabled)
// 用来创建该API的基本信息展示在文档的页面中自定义展示的信息
.apiInfo(apiInfo())
// 设置哪些接口暴露给Swagger展示
.select()
// 扫描所有有注解的api用这种方式更灵活
.apis(RequestHandlerSelectors.withMethodAnnotation(ApiOperation.class))
// 扫描指定包中的swagger注解
// .apis(RequestHandlerSelectors.basePackage("com.ruoyi.project.tool.swagger"))
// 扫描所有 .apis(RequestHandlerSelectors.any())
.paths(PathSelectors.any())
.build()
/* 设置安全模式swagger可以设置访问token */
.securitySchemes(securitySchemes())
.securityContexts(securityContexts())
.pathMapping(pathMapping);
}
/**
* tokenAuthorization
*/
private List<SecurityScheme> securitySchemes()
{
List<SecurityScheme> apiKeyList = new ArrayList<SecurityScheme>();
apiKeyList.add(new ApiKey("Authorization", "Authorization", In.HEADER.toValue()));
return apiKeyList;
}
/**
*
*/
private List<SecurityContext> securityContexts()
{
List<SecurityContext> securityContexts = new ArrayList<>();
securityContexts.add(
SecurityContext.builder()
.securityReferences(defaultAuth())
.operationSelector(o -> o.requestMappingPattern().matches("/.*"))
.build());
return securityContexts;
}
/**
*
*/
private List<SecurityReference> defaultAuth()
{
AuthorizationScope authorizationScope = new AuthorizationScope("global", "accessEverything");
AuthorizationScope[] authorizationScopes = new AuthorizationScope[1];
authorizationScopes[0] = authorizationScope;
List<SecurityReference> securityReferences = new ArrayList<>();
securityReferences.add(new SecurityReference("Authorization", authorizationScopes));
return securityReferences;
}
/**
*
*/
private ApiInfo apiInfo()
{
// 用ApiInfoBuilder进行定制
return new ApiInfoBuilder()
// 设置标题
.title("标题:接口文档")
// 描述
.description("描述:用于管理集团旗下公司的人员信息,具体包括XXX,XXX模块...")
// 作者信息
.contact(new Contact(ruoyiConfig.getName(), null, null))
// 版本
.version("版本号:" + ruoyiConfig.getVersion())
.build();
}
}

@ -1,11 +1,12 @@
package com.ruoyi.common.annotation;
import com.ruoyi.common.utils.poi.ExcelHandlerAdapter;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.math.BigDecimal;
import com.ruoyi.common.utils.poi.ExcelHandlerAdapter;
/**
* Excel
@ -37,7 +38,7 @@ public @interface Excel
public String dictType() default "";
/**
* (: 0=,1=,2=)
*
*/
public String readConverterExp() default "";

@ -50,7 +50,7 @@ public class SysUser extends BaseEntity
private String phonenumber;
/** 用户性别 */
@Excel(name = "用户性别", readConverterExp = "0=男,1=女,2=未知")
@Excel(name = "用户性别", readConverterExp = "")
private String sex;
/** 用户头像 */

@ -1,5 +1,8 @@
package com.ruoyi.common.core.page;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.ruoyi.common.json.LongJsonSerializer;
import java.io.Serializable;
import java.util.List;
@ -13,6 +16,7 @@ public class TableDataInfo implements Serializable
private static final long serialVersionUID = 1L;
/** 总记录数 */
@JsonSerialize(using = LongJsonSerializer.class)
private long total;
/** 列表数据 */

@ -1,66 +1,5 @@
package com.ruoyi.common.utils.poi;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.stream.Collectors;
import javax.servlet.http.HttpServletResponse;
import org.apache.poi.hssf.usermodel.HSSFClientAnchor;
import org.apache.poi.hssf.usermodel.HSSFPicture;
import org.apache.poi.hssf.usermodel.HSSFPictureData;
import org.apache.poi.hssf.usermodel.HSSFShape;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ooxml.POIXMLDocumentPart;
import org.apache.poi.ss.usermodel.BorderStyle;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.CellStyle;
import org.apache.poi.ss.usermodel.CellType;
import org.apache.poi.ss.usermodel.ClientAnchor;
import org.apache.poi.ss.usermodel.DataValidation;
import org.apache.poi.ss.usermodel.DataValidationConstraint;
import org.apache.poi.ss.usermodel.DataValidationHelper;
import org.apache.poi.ss.usermodel.DateUtil;
import org.apache.poi.ss.usermodel.Drawing;
import org.apache.poi.ss.usermodel.FillPatternType;
import org.apache.poi.ss.usermodel.Font;
import org.apache.poi.ss.usermodel.HorizontalAlignment;
import org.apache.poi.ss.usermodel.IndexedColors;
import org.apache.poi.ss.usermodel.PictureData;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.VerticalAlignment;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.XSSFClientAnchor;
import org.apache.poi.xssf.usermodel.XSSFDataValidation;
import org.apache.poi.xssf.usermodel.XSSFDrawing;
import org.apache.poi.xssf.usermodel.XSSFPicture;
import org.apache.poi.xssf.usermodel.XSSFShape;
import org.apache.poi.xssf.usermodel.XSSFSheet;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
import org.openxmlformats.schemas.drawingml.x2006.spreadsheetDrawing.CTMarker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.annotation.Excel.ColumnType;
import com.ruoyi.common.annotation.Excel.Type;
@ -76,6 +15,26 @@ import com.ruoyi.common.utils.file.FileTypeUtils;
import com.ruoyi.common.utils.file.FileUtils;
import com.ruoyi.common.utils.file.ImageUtils;
import com.ruoyi.common.utils.reflect.ReflectUtils;
import org.apache.poi.hssf.usermodel.*;
import org.apache.poi.ooxml.POIXMLDocumentPart;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.ss.util.CellRangeAddress;
import org.apache.poi.ss.util.CellRangeAddressList;
import org.apache.poi.util.IOUtils;
import org.apache.poi.xssf.streaming.SXSSFWorkbook;
import org.apache.poi.xssf.usermodel.*;
import org.openxmlformats.schemas.drawingml.x2006.spreadsheetDrawing.CTMarker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import javax.servlet.http.HttpServletResponse;
import java.io.*;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.*;
import java.util.stream.Collectors;
/**
* Excel
@ -912,7 +871,7 @@ public class ExcelUtil<T>
}
/**
* 0=,1=,2=
*
*
* @param propertyValue
* @param converterExp
@ -949,7 +908,7 @@ public class ExcelUtil<T>
}
/**
* =0,=1,=2
*
*
* @param propertyValue
* @param converterExp

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

Loading…
Cancel
Save