xinyilu/xinelu-api
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

学习培训

Browse Source
This commit is contained in:
zhangheng 2023-11-24 14:22:54 +08:00
parent 7ca22bdf5f
commit 8fbac0aa4c
27 changed files with 3113 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
pom.xml
View File

@ -37,6 +37,7 @@
<knife4j.version>3.0.3</knife4j.version>
<simple-xml.version>2.7.1</simple-xml.version>
<wechatpay-apiv3.version>0.4.4</wechatpay-apiv3.version>
<jave.version>1.0.2</jave.version>
</properties>
<!-- 依赖声明 -->
@ -243,6 +244,13 @@
<artifactId>wechatpay-apache-httpclient</artifactId>
<version>${wechatpay-apiv3.version}</version>
</dependency>
<!-- 音频依赖 -->
<dependency>
<groupId>it.sauronsoftware</groupId>
<artifactId>jave</artifactId>
<version>${jave.version}</version>
</dependency>
</dependencies>
</dependencyManagement>

6
xinelu-common/pom.xml
View File

@ -191,6 +191,12 @@
<artifactId>core</artifactId>
<version>3.4.0</version>
</dependency>
<!-- 音频依赖 -->
<dependency>
<groupId>it.sauronsoftware</groupId>
<artifactId>jave</artifactId>
</dependency>
</dependencies>
</project>

46
xinelu-common/src/main/java/com/xinelu/common/enums/TrainingItemTypeEnum.java Normal file
View File

@ -0,0 +1,46 @@
package com.xinelu.common.enums;
import lombok.Getter;
/**
* 培训项目类型枚举
*
* @author ljh
* @version 1.0
* Create by 2023/4/20 17:33
*/
@Getter
public enum TrainingItemTypeEnum {
/**
* 视频学习
*/
VIDEO_LEARNING("VIDEO_LEARNING"),
/**
* 图文学习
*/
GRAPHIC_LEARNING("GRAPHIC_LEARNING"),
/**
* 直播课程
*/
LIVE_COURSES("LIVE_COURSES"),
/**
* 线下培训
*/
OFFLINE_TRAINING("OFFLINE_TRAINING"),
/**
* 学习培训项目组
*/
LEARNING_ITEM_GROUP("LEARNING_ITEM_GROUP"),
;
final private String info;
TrainingItemTypeEnum(String info) {
this.info = info;
}
}

29
xinelu-common/src/main/java/com/xinelu/common/enums/TrainingShelfFlagEnum.java Normal file
View File

@ -0,0 +1,29 @@
package com.xinelu.common.enums;
import lombok.Getter;
/**
* @Description 学习培训课程上架状态枚举
* @Author 纪寒
* @Date 2023-04-25 16:27:58
* @Version 1.0
*/
@Getter
public enum TrainingShelfFlagEnum {
/**
* 已上架
*/
SHEL(0),
/**
* 未上架
*/
NOT_SHEL(1),
;
final private Integer info;
TrainingShelfFlagEnum(Integer info) {
this.info = info;
}
}

76
xinelu-common/src/main/java/com/xinelu/common/utils/file/FileUtils.java
View File

@ -6,7 +6,9 @@ import com.xinelu.common.exception.ServiceException;
import com.xinelu.common.utils.DateUtils;
import com.xinelu.common.utils.StringUtils;
import com.xinelu.common.utils.uuid.IdUtils;
import java.util.Base64;
import it.sauronsoftware.jave.Encoder;
import it.sauronsoftware.jave.MultimediaInfo;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.io.IOUtils;
@ -22,6 +24,7 @@ import java.nio.charset.StandardCharsets;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Base64;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
@ -31,6 +34,7 @@ import java.util.regex.Pattern;
*
* @author xinelu
*/
@Slf4j
public class FileUtils {
public static String FILENAME_PATTERN = "[a-zA-Z0-9_\\-\\|\\.\\u4e00-\\u9fa5]+";
@ -339,6 +343,37 @@ public class FileUtils {
}
}
/**
* 根据视频文件地址获取对应的视频时长
*
* @param videoPath 视频地址
* @return 视频时长
*/
public static LocalTime getVideoDuration(String videoPath) {
LocalTime duration;
File source = new File(videoPath);
if (source.length() > 0) {
Encoder encoder = new Encoder();
try {
MultimediaInfo m = encoder.getInfo(source);
long ls = m.getDuration() / 1000;
int hour = (int) (ls / 3600);
int minute = (int) (ls % 3600) / 60;
int second = (int) (ls - hour * 3600 - minute * 60);
String hourStr = hour < 10 ? "0" + hour : String.valueOf(hour);
String minuteStr = minute < 10 ? "0" + minute : String.valueOf(minute);
String secondStr = second < 10 ? "0" + second : String.valueOf(second);
String durationStr = hourStr + ":" + minuteStr + ":" + secondStr;
duration = LocalTime.parse(DateTimeFormatter.ofPattern("HH:mm:ss").format(LocalTime.parse(durationStr)));
return duration;
} catch (Exception e) {
log.error("计算视频时长异常，异常信息为：{}", e.getMessage());
return null;
}
}
return null;
}
/**
* 图片上传接口
*
@ -357,25 +392,26 @@ public class FileUtils {
return ajax;
}
//将图片转换成Base64格式的数据集
public static String PicToBase64(String filePath) {
Base64.Encoder encoder = Base64.getEncoder();
byte[] ImgContainer = null;
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream(filePath);
ImgContainer = new byte[fileInputStream.available()];
fileInputStream.read(ImgContainer);
String Base64ImgData = encoder.encodeToString(ImgContainer);
fileInputStream.close();
return "data:image/png" + ";base64," + Base64ImgData;
} catch (FileNotFoundException e) {
return "找不到指定文件!";
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
//将图片转换成Base64格式的数据集
public static String PicToBase64(String filePath) {
Base64.Encoder encoder = Base64.getEncoder();
byte[] ImgContainer = null;
FileInputStream fileInputStream = null;
try {
fileInputStream = new FileInputStream(filePath);
ImgContainer = new byte[fileInputStream.available()];
fileInputStream.read(ImgContainer);
String Base64ImgData = encoder.encodeToString(ImgContainer);
fileInputStream.close();
return "data:image/png" + ";base64," + Base64ImgData;
} catch (FileNotFoundException e) {
return "找不到指定文件!";
} catch (IOException e) {
e.printStackTrace();
}
return null;
}
/**
* 视频上传接口
*

110
xinelu-nurse-manage/src/main/java/com/xinelu/manage/controller/trainingcategory/TrainingCategoryController.java Normal file
View File

@ -0,0 +1,110 @@
package com.xinelu.manage.controller.trainingcategory;
import com.xinelu.common.annotation.Log;
import com.xinelu.common.constant.Constants;
import com.xinelu.common.core.controller.BaseController;
import com.xinelu.common.core.domain.AjaxResult;
import com.xinelu.common.core.page.TableDataInfo;
import com.xinelu.common.enums.BusinessType;
import com.xinelu.common.utils.poi.ExcelUtil;
import com.xinelu.manage.domain.trainingcategory.TrainingCategory;
import com.xinelu.manage.service.trainingcategory.ITrainingCategoryService;
import org.apache.commons.lang3.StringUtils;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import java.util.List;
import java.util.Objects;
/**
* 学习培训分类Controller
*
* @author xinyilu
* @date 2023-04-20
*/
@RestController
@RequestMapping("/system/trainingCategory")
public class TrainingCategoryController extends BaseController {
@Resource
private ITrainingCategoryService trainingCategoryService;
/**
* 查询学习培训分类列表
*/
@PreAuthorize("@ss.hasPermi('system:trainingCategory:list')")
@GetMapping("/list")
public TableDataInfo list(TrainingCategory trainingCategory) {
startPage();
List<TrainingCategory> list = trainingCategoryService.selectTrainingCategoryList(trainingCategory);
return getDataTable(list);
}
/**
* 导出学习培训分类列表
*/
@PreAuthorize("@ss.hasPermi('system:trainingCategory:export')")
@Log(title = "学习培训分类", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, TrainingCategory trainingCategory) {
List<TrainingCategory> list = trainingCategoryService.selectTrainingCategoryList(trainingCategory);
ExcelUtil<TrainingCategory> util = new ExcelUtil<>(TrainingCategory.class);
util.exportExcel(response, list, "学习培训分类数据");
}
/**
* 获取学习培训分类详细信息
*/
@PreAuthorize("@ss.hasPermi('system:trainingCategory:query')")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return AjaxResult.success(trainingCategoryService.selectTrainingCategoryById(id));
}
/**
* 新增学习培训分类
*/
@PreAuthorize("@ss.hasPermi('system:trainingCategory:add')")
@Log(title = "学习培训分类", businessType = BusinessType.INSERT)
@PostMapping("/add")
public AjaxResult add(@RequestBody TrainingCategory trainingCategory) {
return toAjax(trainingCategoryService.insertTrainingCategory(trainingCategory));
}
/**
* 修改学习培训分类
*/
@PreAuthorize("@ss.hasPermi('system:trainingCategory:edit')")
@Log(title = "学习培训分类", businessType = BusinessType.UPDATE)
@PostMapping("/edit")
public AjaxResult edit(@RequestBody TrainingCategory trainingCategory) {
return trainingCategoryService.updateTrainingCategory(trainingCategory);
}
/**
* 删除学习培训分类
*/
@PreAuthorize("@ss.hasPermi('system:trainingCategory:remove')")
@Log(title = "学习培训分类", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids) {
return trainingCategoryService.deleteTrainingCategoryByIds(ids);
}
/**
* 图片上传
*/
@PostMapping("/uploadTrainingCategoryPicture")
public AjaxResult uploadTrainingCategoryPicture(@RequestParam("file") MultipartFile multipartFile) throws Exception {
if (Objects.isNull(multipartFile) || StringUtils.isBlank(multipartFile.getOriginalFilename())) {
return AjaxResult.error("当前文件不存在，无法上传！");
}
if (multipartFile.getOriginalFilename().contains(Constants.EMPTY)) {
return AjaxResult.error("当前文件名含有空格，请先去除空格在上传！");
}
return trainingCategoryService.uploadTrainingCategoryPicture(multipartFile);
}
}

156
xinelu-nurse-manage/src/main/java/com/xinelu/manage/controller/trainingitem/TrainingItemController.java Normal file
View File

@ -0,0 +1,156 @@
package com.xinelu.manage.controller.trainingitem;
import com.xinelu.common.annotation.Log;
import com.xinelu.common.constant.Constants;
import com.xinelu.common.core.controller.BaseController;
import com.xinelu.common.core.domain.AjaxResult;
import com.xinelu.common.core.page.TableDataInfo;
import com.xinelu.common.custominterface.Insert;
import com.xinelu.common.custominterface.Update;
import com.xinelu.common.enums.BusinessType;
import com.xinelu.manage.domain.trainingitem.TrainingItem;
import com.xinelu.manage.dto.trainingitem.TrainingItemAndDirectory;
import com.xinelu.manage.service.trainingitem.ITrainingItemService;
import com.xinelu.manage.vo.trainingitem.TrainingItemAndCategoryVO;
import org.apache.commons.lang3.StringUtils;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import java.util.List;
import java.util.Objects;
/**
* 学习培训项目信息Controller
*
* @author xinyilu
* @date 2023-04-20
*/
@RestController
@RequestMapping("/system/trainingItem")
public class TrainingItemController extends BaseController {
@Resource
private ITrainingItemService trainingItemService;
/**
* 查询学习培训项目信息列表
*/
@PreAuthorize("@ss.hasPermi('system:trainingItem:list')")
@GetMapping("/list")
public TableDataInfo list(TrainingItem trainingItem) {
startPage();
List<TrainingItemAndCategoryVO> list = trainingItemService.selectTrainingItemList(trainingItem);
return getDataTable(list);
}
/**
* 获取学习培训项目信息详细信息
*/
@PreAuthorize("@ss.hasPermi('system:trainingItem:query')")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
if (Objects.isNull(id)) {
return AjaxResult.error("学习培训课程信息为空！");
}
return AjaxResult.success(trainingItemService.selectTrainingItemById(id));
}
/**
* 新增学习培训项目信息
*/
@PreAuthorize("@ss.hasPermi('system:trainingItem:add')")
@Log(title = "学习培训课程信息", businessType = BusinessType.INSERT)
@PostMapping("/add")
public AjaxResult add(@RequestBody @Validated(Insert.class) TrainingItemAndDirectory trainingItem) {
return trainingItemService.insertTrainingItem(trainingItem);
}
/**
* 修改学习培训项目信息
*/
@PreAuthorize("@ss.hasPermi('system:trainingItem:edit')")
@Log(title = "学习培训课程信息", businessType = BusinessType.UPDATE)
@PostMapping("/edit")
public AjaxResult edit(@RequestBody @Validated(Update.class) TrainingItemAndDirectory trainingItem) {
if (Objects.isNull(trainingItem) || Objects.isNull(trainingItem.getTrainingItemId())) {
return AjaxResult.error("请输入需要修改信息！");
}
return trainingItemService.updateTrainingItem(trainingItem);
}
/**
* 删除学习培训项目信息
*/
@PreAuthorize("@ss.hasPermi('system:trainingItem:remove')")
@Log(title = "学习培训课程信息", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable Long[] ids) {
if (Objects.isNull(ids)) {
return AjaxResult.error("请传入需要删除的信息！");
}
return trainingItemService.deleteTrainingItemByIds(ids);
}
/**
* 图片上传
*/
@PostMapping("/uploadUrl")
public AjaxResult uploadUrl(@RequestParam("file") MultipartFile multipartFile, String type) throws Exception {
if (StringUtils.isBlank(type)) {
return AjaxResult.error("请选择所要上传的路径类型！");
}
if (Objects.isNull(multipartFile) || StringUtils.isBlank(multipartFile.getOriginalFilename())) {
return AjaxResult.error("当前文件不存在，无法上传！");
}
if (multipartFile.getOriginalFilename().contains(Constants.EMPTY)) {
return AjaxResult.error("当前文件名含有空格，请先去除空格在上传！");
}
return trainingItemService.uploadUrl(multipartFile, type);
}
/**
* 上传视频
*/
@PostMapping("/uploadVideoUrl")
public AjaxResult uploadVideoUrl(@RequestParam("file") MultipartFile multipartFile) throws Exception {
if (Objects.isNull(multipartFile)) {
return AjaxResult.error("请选择视频！");
}
return trainingItemService.uploadVideoUrl(multipartFile);
}
/**
* 父级项目组
*/
@GetMapping("/selectTrainingParent")
public TableDataInfo selectTrainingParent(TrainingItemAndDirectory trainingItem) {
startPage();
List<TrainingItemAndCategoryVO> list = trainingItemService.selectTrainingParent(trainingItem);
return getDataTable(list);
}
/**
* 修改上下架状态
*/
@PostMapping("/updateTrainingShelfFlag")
public AjaxResult updateTrainingShelfFlag(@RequestBody TrainingItem trainingItem) {
if (Objects.isNull(trainingItem) || Objects.isNull(trainingItem.getId()) || Objects.isNull(trainingItem.getTrainingShelfFlag())) {
return AjaxResult.error("请选择学习培训项目信息！");
}
return trainingItemService.updateTrainingShelfFlag(trainingItem);
}
/**
* 查询下级项目
*/
@GetMapping("selectSubordinateItem")
public AjaxResult selectSubordinateItem(TrainingItem trainingItem) {
if (Objects.isNull(trainingItem) || Objects.isNull(trainingItem.getTrainingParentId())) {
return AjaxResult.error("请选择需要查询的项目信息！");
}
return trainingItemService.selectSubordinateItem(trainingItem);
}
}

86
xinelu-nurse-manage/src/main/java/com/xinelu/manage/domain/trainingcategory/TrainingCategory.java Normal file
View File

@ -0,0 +1,86 @@
package com.xinelu.manage.domain.trainingcategory;
import com.xinelu.common.annotation.Excel;
import com.xinelu.common.core.domain.BaseDomain;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.io.Serializable;
/**
* 学习培训分类对象 training_category
*
* @author xinyilu
* @date 2023-04-20
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)
@ApiModel(value = "学习培训分类对象", description = "training_category")
public class TrainingCategory extends BaseDomain implements Serializable {
private static final long serialVersionUID = 7472672566803333086L;
/**
* 主键id
*/
private Long id;
/**
* 父级分类id
*/
@ApiModelProperty(value = "父级分类id")
@Excel(name = "父级分类id")
private Long parentId;
/**
* 培训分类名称
*/
@ApiModelProperty(value = "培训分类名称")
@Excel(name = "培训分类名称")
private String trainingCategoryName;
/**
* 培训分类编码
*/
@ApiModelProperty(value = "培训分类编码")
@Excel(name = "培训分类编码")
private String trainingCategoryCode;
/**
* 培训分类图片路径
*/
@ApiModelProperty(value = "培训分类图片路径")
@Excel(name = "培训分类图片路径")
private String trainingCategoryPictureUrl;
/**
* 培训分类排序
*/
@ApiModelProperty(value = "培训分类排序")
@Excel(name = "培训分类排序")
private Integer trainingCategorySort;
@Override
public String toString() {
return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
.append("id", getId())
.append("parentId", getParentId())
.append("trainingCategoryName", getTrainingCategoryName())
.append("trainingCategoryCode", getTrainingCategoryCode())
.append("trainingCategoryPictureUrl", getTrainingCategoryPictureUrl())
.append("trainingCategorySort", getTrainingCategorySort())
.append("remark", getRemark())
.append("createBy", getCreateBy())
.append("createTime", getCreateTime())
.append("updateBy", getUpdateBy())
.append("updateTime", getUpdateTime())
.toString();
}
}

194
xinelu-nurse-manage/src/main/java/com/xinelu/manage/domain/trainingitem/TrainingItem.java Normal file
View File

@ -0,0 +1,194 @@
package com.xinelu.manage.domain.trainingitem;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.xinelu.common.annotation.Excel;
import com.xinelu.common.core.domain.BaseDomain;
import com.xinelu.common.custominterface.Insert;
import com.xinelu.common.custominterface.Update;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import org.springframework.format.annotation.DateTimeFormat;
import javax.validation.constraints.NotBlank;
import java.io.Serializable;
import java.math.BigDecimal;
import java.time.LocalDate;
import java.time.LocalTime;
/**
* 学习培训项目信息对象 training_item
*
* @author xinyilu
* @date 2023-04-20
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)
@ApiModel(value = "学习培训项目信息对象", description = "training_item")
public class TrainingItem extends BaseDomain implements Serializable {
private static final long serialVersionUID = -3956320664123691176L;
/**
* 主键id
*/
private Long id;
/**
* 培训分类表id
*/
@ApiModelProperty(value = "培训分类表id")
@Excel(name = "培训分类表id")
private Long trainingCategoryId;
/**
* 培训项目父级id
*/
private Long trainingParentId;
/**
* 培训项目标题
*/
@NotBlank(message = "培训项目标题不能为空", groups = {Insert.class, Update.class})
@ApiModelProperty(value = "培训项目标题")
@Excel(name = "培训项目标题")
private String trainingItemTitle;
/**
* 培训项目编号
*/
@ApiModelProperty(value = "培训项目编号")
@Excel(name = "培训项目编号")
private String trainingItemCode;
/**
* 培训项目价格
*/
@ApiModelProperty(value = "培训项目价格")
@Excel(name = "培训项目价格")
private BigDecimal trainingItemPrice;
/**
* 培训项目logo图片路径
*/
@ApiModelProperty(value = "培训项目logo图片路径")
@Excel(name = "培训项目logo图片路径")
private String trainingItemCoverUrl;
/**
* 培训项目海报图片路径
*/
@ApiModelProperty(value = "培训项目海报图片路径")
@Excel(name = "培训项目海报图片路径")
private String trainingItemPosterUrl;
/**
* 培训项目类型，视频学习：VIDEO_LEARNING，图文学习：GRAPHIC_LEARNING，直播课程：LIVE_COURSES，线下培训：OFFLINE_TRAINING
*/
@NotBlank(message = "培训项目类型不能为空", groups = {Insert.class, Update.class})
@ApiModelProperty(value = "培训项目类型，学习培训项目组：LEARNING_ITEM_GROUP，视频学习：VIDEO_LEARNING，图文学习：GRAPHIC_LEARNING，直播课程：LIVE_COURSES，线下培训：OFFLINE_TRAINING")
@Excel(name = "培训项目类型，学习培训项目组：LEARNING_ITEM_GROUP，视频学习：VIDEO_LEARNING，图文学习：GRAPHIC_LEARNING，直播课程：LIVE_COURSES，线下培训：OFFLINE_TRAINING")
private String trainingItemType;
/**
* 培训项目详情，视频学习和直播课程培训类型使用
*/
@ApiModelProperty(value = "培训项目详情，视频学习和直播课程培训类型使用")
@Excel(name = "培训项目详情，视频学习和直播课程培训类型使用")
private String trainingItemDetails;
/**
* 培训项目内容，图文学习类型使用，主要存放图文学习类型的内容
*/
@ApiModelProperty(value = "培训项目内容，图文学习类型使用，主要存放图文学习类型的内容")
@Excel(name = "培训项目内容，图文学习类型使用，主要存放图文学习类型的内容")
private String trainingItemContent;
/**
* 培训项目日期，格式：yyyy-MM-dd，直播课程和线下培训类型使用
*/
@ApiModelProperty(value = "培训项目日期，格式：yyyy-MM-dd，直播课程和线下培训类型使用")
@JsonFormat(pattern = "yyyy-MM-dd")
@DateTimeFormat(pattern = "yyyy-MM-dd")
@Excel(name = "培训项目日期，格式：yyyy-MM-dd，直播课程和线下培训类型使用", width = 30, dateFormat = "yyyy-MM-dd")
private LocalDate trainingItemDate;
/**
* 培训项目开始时间，格式：HH:mm:ss，直播课程和线下培训类型使用
*/
@ApiModelProperty(value = "培训项目开始时间，格式：HH:mm:ss，直播课程和线下培训类型使用")
@JsonFormat(pattern = "HH:mm:ss")
@Excel(name = "培训项目开始时间，格式：HH:mm:ss，直播课程和线下培训类型使用", width = 30, dateFormat = "yyyy-MM-dd")
private LocalTime trainingItemStartTime;
/**
* 培训项目结束时间，格式：HH:mm:ss，直播课程和线下培训类型使用
*/
@ApiModelProperty(value = "培训项目结束时间，格式：HH:mm:ss，直播课程和线下培训类型使用")
@JsonFormat(pattern = "HH:mm:ss")
@Excel(name = "培训项目结束时间，格式：HH:mm:ss，直播课程和线下培训类型使用", width = 30, dateFormat = "yyyy-MM-dd")
private LocalTime trainingItemEndTime;
/**
* 培训项目地址，线下培训类型使用，存放线下培训的地址
*/
@ApiModelProperty(value = "培训项目地址，线下培训类型使用，存放线下培训的地址")
@Excel(name = "培训项目地址，线下培训类型使用，存放线下培训的地址")
private String trainingItemAddress;
/**
* 报名须知，线下培训使用，存放线下报名须知信息
*/
@ApiModelProperty(value = "报名须知，线下培训使用，存放线下报名须知信息")
@Excel(name = "报名须知，线下培训使用，存放线下报名须知信息")
private String trainingItemNotes;
/**
* 是否可以购买，0：是，1：否
*/
private Integer buyFlag;
/**
* 培训项目排序
*/
@ApiModelProperty(value = "培训项目排序")
@Excel(name = "培训项目排序")
private Integer trainingItemSort;
/**
* 上架标识，0：已上架，1：未上架
*/
private Integer trainingShelfFlag;
@Override
public String toString() {
return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
.append("id", getId())
.append("trainingCategoryId", getTrainingCategoryId())
.append("trainingItemTitle", getTrainingItemTitle())
.append("trainingItemCode", getTrainingItemCode())
.append("trainingItemPrice", getTrainingItemPrice())
.append("trainingItemCoverUrl", getTrainingItemCoverUrl())
.append("trainingItemPosterUrl", getTrainingItemPosterUrl())
.append("trainingItemType", getTrainingItemType())
.append("trainingItemDetails", getTrainingItemDetails())
.append("trainingItemContent", getTrainingItemContent())
.append("trainingItemDate", getTrainingItemDate())
.append("trainingItemStartTime", getTrainingItemStartTime())
.append("trainingItemEndTime", getTrainingItemEndTime())
.append("trainingItemAddress", getTrainingItemAddress())
.append("trainingItemNotes", getTrainingItemNotes())
.append("trainingItemSort", getTrainingItemSort())
.append("createBy", getCreateBy())
.append("createTime", getCreateTime())
.append("updateBy", getUpdateBy())
.append("updateTime", getUpdateTime())
.toString();
}
}

109
xinelu-nurse-manage/src/main/java/com/xinelu/manage/domain/trainingitemdirectory/TrainingItemDirectory.java Normal file
View File

@ -0,0 +1,109 @@
package com.xinelu.manage.domain.trainingitemdirectory;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.xinelu.common.annotation.Excel;
import com.xinelu.common.core.domain.BaseDomain;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.NoArgsConstructor;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.io.Serializable;
import java.time.LocalTime;
/**
* 学习培训项目章节对象 training_item_directory
*
* @author xinyilu
* @date 2023-04-20
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@EqualsAndHashCode(callSuper = true)
@ApiModel(value = "学习培训项目章节对象", description = "training_item_directory")
public class TrainingItemDirectory extends BaseDomain implements Serializable {
private static final long serialVersionUID = -1110703661850660701L;
/**
* 主键id
*/
private Long id;
/**
* 培训项目表id
*/
@ApiModelProperty(value = "培训项目表id")
@Excel(name = "培训项目表id")
private Long trainingItemId;
/**
* 培训项目章节名称
*/
@ApiModelProperty(value = "培训项目章节名称")
@Excel(name = "培训项目章节名称")
private String itemDirectoryName;
/**
* 培训项目章节编码
*/
@ApiModelProperty(value = "培训项目章节编码")
@Excel(name = "培训项目章节编码")
private String itemDirectoryCode;
/**
* 培训项目章节标题
*/
@ApiModelProperty(value = "培训项目章节标题")
@Excel(name = "培训项目章节标题")
private String itemDirectoryTitle;
/**
* 培训项目章节视频存放地址
*/
@ApiModelProperty(value = "培训项目章节视频存放地址")
@Excel(name = "培训项目章节视频存放地址")
private String itemDirectoryUrl;
/**
* 培训章节视频时长
*/
@JsonFormat(pattern = "HH:mm:ss")
private LocalTime itemDirectoryVideoDuration;
/**
* 培训项目章节内容简介
*/
@ApiModelProperty(value = "培训项目章节内容简介")
@Excel(name = "培训项目章节内容简介")
private String itemDirectoryIntroduce;
/**
* 培训项目章节排序
*/
@ApiModelProperty(value = "培训项目章节排序")
@Excel(name = "培训项目章节排序")
private Integer itemDirectorySort;
@Override
public String toString() {
return new ToStringBuilder(this, ToStringStyle.MULTI_LINE_STYLE)
.append("id", getId())
.append("trainingItemId", getTrainingItemId())
.append("itemDirectoryName", getItemDirectoryName())
.append("itemDirectoryCode", getItemDirectoryCode())
.append("itemDirectoryTitle", getItemDirectoryTitle())
.append("itemDirectoryUrl", getItemDirectoryUrl())
.append("itemDirectoryIntroduce", getItemDirectoryIntroduce())
.append("itemDirectorySort", getItemDirectorySort())
.append("createBy", getCreateBy())
.append("createTime", getCreateTime())
.append("updateBy", getUpdateBy())
.append("updateTime", getUpdateTime())
.toString();
}
}

58
xinelu-nurse-manage/src/main/java/com/xinelu/manage/dto/trainingitem/NurseAppletPersonTrainingItemDTO.java Normal file
View File

@ -0,0 +1,58 @@
package com.xinelu.manage.dto.trainingitem;
import lombok.Data;
import java.io.Serializable;
/**
* 护理员学习培训DTO
*
* @author ljh
* @version 1.0
* Create by 2023/4/21 11:02
*/
@Data
public class NurseAppletPersonTrainingItemDTO implements Serializable {
private static final long serialVersionUID = 8981152698442355834L;
/**
* 分类id
**/
private Long trainingCategoryId;
/**
* 培训项目id
*/
private Long trainingItemId;
/**
* 培训项目父级id
*/
private Long trainingParentId;
/**
* 培训项目类型，视频学习：VIDEO_LEARNING，图文学习：GRAPHIC_LEARNING，直播课程：LIVE_COURSES，线下培训：OFFLINE_TRAINING，学习培训项目组：LEARNING_ITEM_GROUP
*/
private String trainingItemType;
/**
* 护理员表id
*/
private Long nurseStationPersonId;
/**
* 订单状态，待付款：WAIT_PAY，已付款：PAY，退款中：WAIT_REFUND，已退款：REFUNDED，已取消：CANCEL
*/
private String trainingOrderStatus;
/**
* 订单明细id
*/
private Long trainingOrderDetailsId;
/**
* 订单编号
*/
private String trainingOrderNo;
}

41
xinelu-nurse-manage/src/main/java/com/xinelu/manage/dto/trainingitem/TrainingItemAndDirectory.java Normal file
View File

@ -0,0 +1,41 @@
package com.xinelu.manage.dto.trainingitem;
import com.xinelu.manage.domain.trainingitem.TrainingItem;
import com.xinelu.manage.vo.trainingitemdirectory.TrainingItemDirectoryVO;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
/**
* 学习培训项目信息对象 training_item
*
* @author zh
* @date 2023-04-21
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class TrainingItemAndDirectory extends TrainingItem implements Serializable {
private static final long serialVersionUID = -5750779226642929884L;
/**
* 章节视频
*/
private List<TrainingItemDirectoryVO> trainingItemDirectoryList;
/**
* 学习培训项目信息对象主键id
*/
private Long trainingItemId;
/**
* 分类名字
*/
private String trainingCategoryName;
/**
* 父级项目名称
*/
private String trainingParentName;
}

28
xinelu-nurse-manage/src/main/java/com/xinelu/manage/dto/trainingitem/TrainingItemDTO.java Normal file
View File

@ -0,0 +1,28 @@
package com.xinelu.manage.dto.trainingitem;
import com.xinelu.manage.domain.trainingitem.TrainingItem;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* @author ljh
* @version 1.0
* Create by 2023/4/26 13:56
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class TrainingItemDTO extends TrainingItem implements Serializable {
private static final long serialVersionUID = 7823310897700958081L;
/**
* 护理人员id
*/
private Long nurseStationPersonId;
/**
* 订单状态，待付款：WAIT_PAY，已付款：PAY，退款中：WAIT_REFUND，已退款：REFUNDED，已取消：CANCEL',
*/
private String trainingOrderStatus;
}

53
xinelu-nurse-manage/src/main/java/com/xinelu/manage/dto/trainingorder/NurseAppletPersonTrainingItemOrderDTO.java Normal file
View File

@ -0,0 +1,53 @@
package com.xinelu.manage.dto.trainingorder;
import com.xinelu.common.custominterface.Insert;
import lombok.Data;
import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;
import java.io.Serializable;
import java.math.BigDecimal;
/**
* @author ljh
* @version 1.0
* Create by 2023/4/21 14:38
*/
@Data
public class NurseAppletPersonTrainingItemOrderDTO implements Serializable {
private static final long serialVersionUID = 3880260231562214744L;
/**
* 培训项目表id
*/
@NotNull(message = "学习课程信息不存在，无法购买！", groups = {Insert.class})
private Long trainingItemId;
/**
* 培训项目表父id
*/
private Long trainingParentId;
/**
* 护理站id
*/
@NotNull(message = "所属护理站信息不存在，无法购买！", groups = {Insert.class})
private Long nurseStationId;
/**
* 护理员表id
*/
@NotNull(message = "护理员人员信息不存在，无法够买！", groups = {Insert.class})
private Long nurseStationPersonId;
/**
* 订单金额
*/
@NotNull(message = "订单金额错误，无法购买！", groups = {Insert.class})
private BigDecimal trainingOrderAmount;
/**
* 护理员名称
*/
@NotBlank(message = "护理员姓名不存在，无法购买！", groups = {Insert.class})
private String nursePersonName;
}

70
xinelu-nurse-manage/src/main/java/com/xinelu/manage/mapper/trainingcategory/TrainingCategoryMapper.java Normal file
View File

@ -0,0 +1,70 @@
package com.xinelu.manage.mapper.trainingcategory;
import com.xinelu.manage.domain.trainingcategory.TrainingCategory;
import java.util.List;
/**
* 学习培训分类Mapper接口
*
* @author xinyilu
* @date 2023-04-20
*/
public interface TrainingCategoryMapper {
/**
* 查询学习培训分类
*
* @param id 学习培训分类主键
* @return 学习培训分类
*/
TrainingCategory selectTrainingCategoryById(Long id);
/**
* 查询学习培训分类列表
*
* @param trainingCategory 学习培训分类
* @return 学习培训分类集合
*/
List<TrainingCategory> selectTrainingCategoryList(TrainingCategory trainingCategory);
/**
* 新增学习培训分类
*
* @param trainingCategory 学习培训分类
* @return 结果
*/
int insertTrainingCategory(TrainingCategory trainingCategory);
/**
* 修改学习培训分类
*
* @param trainingCategory 学习培训分类
* @return 结果
*/
int updateTrainingCategory(TrainingCategory trainingCategory);
/**
* 删除学习培训分类
*
* @param id 学习培训分类主键
* @return 结果
*/
int deleteTrainingCategoryById(Long id);
/**
* 批量删除学习培训分类
*
* @param ids 需要删除的数据主键集合
* @return 结果
*/
int deleteTrainingCategoryByIds(Long[] ids);
/**
* 查询学习培训分类
*
* @param ids 学习培训分类主键
* @return 学习培训分类
*/
List<TrainingCategory> selectTrainingCategoryByIds(Long[] ids);
}

151
xinelu-nurse-manage/src/main/java/com/xinelu/manage/mapper/trainingitem/TrainingItemMapper.java Normal file
View File

@ -0,0 +1,151 @@
package com.xinelu.manage.mapper.trainingitem;
import com.xinelu.manage.domain.trainingitem.TrainingItem;
import com.xinelu.manage.dto.trainingitem.NurseAppletPersonTrainingItemDTO;
import com.xinelu.manage.dto.trainingitem.TrainingItemAndDirectory;
import com.xinelu.manage.dto.trainingitem.TrainingItemDTO;
import com.xinelu.manage.dto.trainingorder.NurseAppletPersonTrainingItemOrderDTO;
import com.xinelu.manage.vo.trainingitem.NurseAppletPersonTrainingItemVO;
import com.xinelu.manage.vo.trainingitem.TrainingItemAndCategoryVO;
import com.xinelu.manage.vo.trainingitem.TrainingItemVO;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 学习培训项目信息Mapper接口
*
* @author xinyilu
* @date 2023-04-20
*/
public interface TrainingItemMapper {
/**
* 查询学习培训项目信息
*
* @param id 学习培训项目信息主键
* @return 学习培训项目信息
*/
TrainingItem selectTrainingItemById(Long id);
/**
* 查询学习培训项目信息列表
*
* @param trainingItem 学习培训项目信息
* @return 学习培训项目信息集合
*/
List<TrainingItem> selectTrainingItemList(TrainingItem trainingItem);
/**
* 新增学习培训项目信息
*
* @param trainingItem 学习培训项目信息
* @return 结果
*/
int insertTrainingItem(TrainingItem trainingItem);
/**
* 修改学习培训项目信息
*
* @param trainingItem 学习培训项目信息
* @return 结果
*/
int updateTrainingItem(TrainingItem trainingItem);
/**
* 删除学习培训项目信息
*
* @param id 学习培训项目信息主键
* @return 结果
*/
int deleteTrainingItemById(Long id);
/**
* 批量删除学习培训项目信息
*
* @param ids 需要删除的数据主键集合
* @return 结果
*/
int deleteTrainingItemByIds(List<Long> ids);
/**
* 查询学习培训项目信息列表
*
* @param trainingItem 学习培训项目信息
* @return 学习培训项目信息集合
*/
List<NurseAppletPersonTrainingItemVO> selectTrainingLearnItemList(NurseAppletPersonTrainingItemOrderDTO trainingItem);
/**
* 查询学习培训项目详情信息
*
* @param trainingItem 学习培训项目信息
* @return 学习培训项目信息集合
*/
NurseAppletPersonTrainingItemVO selectTrainingLearnItemDetailsList(NurseAppletPersonTrainingItemDTO trainingItem);
/**
* 查询学习培训项目信息列表
*
* @param trainingItem 学习培训项目信息
* @return 学习培训项目信息集合
*/
List<TrainingItemAndCategoryVO> selectTrainingItemAndCategoryList(TrainingItem trainingItem);
/**
* 查询学习培训项目信息
*
* @param id 学习培训项目信息主键
* @return 学习培训项目信息
*/
TrainingItemAndDirectory selectTrainingItemAndDirectoryById(Long id);
/**
* 根据id集合查询学习培训项目信息列表集合
*
* @param trainingItemIdList 学习培训项目id集合
* @return 学习培训项目信息集合
*/
List<TrainingItem> selectTrainingItemByIdList(@Param("trainingItemIdList") List<Long> trainingItemIdList);
/**
* 项目信息
*
* @param ids 项目ids
* @param trainingParentIds 项目ids
* @return TrainingItemAndDirectory
*/
List<TrainingItemAndDirectory> selectTrainingItemAndDirectoryList(@Param("ids") Long[] ids, @Param("trainingParentIds") Long[] trainingParentIds);
/**
* 查询学习培训项目信息列表
*
* @param trainingItem 学习培训项目信息
* @return 学习培训项目信息集合
*/
List<TrainingItemAndCategoryVO> selectTrainingItems(TrainingItemAndDirectory trainingItem);
/**
* 查询学习培训项目信息列表
*
* @param trainingItem 学习培训项目信息
* @return 学习培训项目信息集合
*/
List<TrainingItemVO> getTrainingItemList(TrainingItemDTO trainingItem);
/**
* 修改学习培训项目信息
*
* @param trainingItem 学习培训项目信息
* @return 结果
*/
int updateTrainingItems(TrainingItem trainingItem);
/**
* 修改学习培训项目信息
*
* @param trainingItem 学习培训项目信息
* @return 结果
*/
int updateTrainingItemList(TrainingItem trainingItem);
}

72
xinelu-nurse-manage/src/main/java/com/xinelu/manage/mapper/trainingitemdirectory/TrainingItemDirectoryMapper.java Normal file
View File

@ -0,0 +1,72 @@
package com.xinelu.manage.mapper.trainingitemdirectory;
import com.xinelu.manage.domain.trainingitemdirectory.TrainingItemDirectory;
import com.xinelu.manage.vo.trainingitemdirectory.TrainingItemDirectoryVO;
import java.util.List;
/**
* 学习培训项目章节Mapper接口
*
* @author xinyilu
* @date 2023-04-20
*/
public interface TrainingItemDirectoryMapper {
/**
* 查询学习培训项目章节
*
* @param id 学习培训项目章节主键
* @return 学习培训项目章节
*/
TrainingItemDirectory selectTrainingItemDirectoryById(Long id);
/**
* 查询学习培训项目章节列表
*
* @param trainingItemDirectory 学习培训项目章节
* @return 学习培训项目章节集合
*/
List<TrainingItemDirectory> selectTrainingItemDirectoryList(TrainingItemDirectory trainingItemDirectory);
/**
* 新增学习培训项目章节
*
* @param trainingItemDirectory 学习培训项目章节
* @return 结果
*/
int insertTrainingItemDirectory(TrainingItemDirectory trainingItemDirectory);
/**
* 修改学习培训项目章节
*
* @param trainingItemDirectory 学习培训项目章节
* @return 结果
*/
int updateTrainingItemDirectory(TrainingItemDirectory trainingItemDirectory);
/**
* 删除学习培训项目章节
*
* @param id 学习培训项目章节主键
* @return 结果
*/
int deleteTrainingItemDirectoryById(Long id);
/**
* 批量删除学习培训项目章节
*
* @param ids 需要删除的数据主键集合
* @return 结果
*/
int deleteTrainingItemDirectoryByIds(Long[] ids);
/**
* 批量
*
* @param trainingItemDirectoryList 章节集合
* @return int
*/
int insertTrainingItemDirectoryList(List<TrainingItemDirectoryVO> trainingItemDirectoryList);
}

65
xinelu-nurse-manage/src/main/java/com/xinelu/manage/service/trainingcategory/ITrainingCategoryService.java Normal file
View File

@ -0,0 +1,65 @@
package com.xinelu.manage.service.trainingcategory;
import com.xinelu.common.core.domain.AjaxResult;
import com.xinelu.manage.domain.trainingcategory.TrainingCategory;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
/**
* 学习培训分类Service接口
*
* @author xinyilu
* @date 2023-04-20
*/
public interface ITrainingCategoryService {
/**
* 查询学习培训分类
*
* @param id 学习培训分类主键
* @return 学习培训分类
*/
TrainingCategory selectTrainingCategoryById(Long id);
/**
* 查询学习培训分类列表
*
* @param trainingCategory 学习培训分类
* @return 学习培训分类集合
*/
List<TrainingCategory> selectTrainingCategoryList(TrainingCategory trainingCategory);
/**
* 新增学习培训分类
*
* @param trainingCategory 学习培训分类
* @return 结果
*/
int insertTrainingCategory(TrainingCategory trainingCategory);
/**
* 修改学习培训分类
*
* @param trainingCategory 学习培训分类
* @return 结果
*/
AjaxResult updateTrainingCategory(TrainingCategory trainingCategory);
/**
* 批量删除学习培训分类
*
* @param ids 需要删除的学习培训分类主键集合
* @return 结果
*/
AjaxResult deleteTrainingCategoryByIds(Long[] ids);
/**
* 上传文件
*
* @param multipartFile 文件
* @return AjaxResult
* @throws Exception 异常信息
*/
AjaxResult uploadTrainingCategoryPicture(MultipartFile multipartFile) throws Exception;
}

135
xinelu-nurse-manage/src/main/java/com/xinelu/manage/service/trainingcategory/Impl/TrainingCategoryServiceImpl.java Normal file
View File

@ -0,0 +1,135 @@
package com.xinelu.manage.service.trainingcategory.Impl;
import com.xinelu.common.config.XinELuConfig;
import com.xinelu.common.constant.Constants;
import com.xinelu.common.core.domain.AjaxResult;
import com.xinelu.common.utils.SecurityUtils;
import com.xinelu.common.utils.codes.GenerateSystemCodeUtil;
import com.xinelu.common.utils.file.FileUtils;
import com.xinelu.manage.domain.trainingcategory.TrainingCategory;
import com.xinelu.manage.mapper.trainingcategory.TrainingCategoryMapper;
import com.xinelu.manage.service.trainingcategory.ITrainingCategoryService;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Objects;
/**
* 学习培训分类Service业务层处理
*
* @author xinyilu
* @date 2023-04-20
*/
@Service
public class TrainingCategoryServiceImpl implements ITrainingCategoryService {
@Resource
private TrainingCategoryMapper trainingCategoryMapper;
@Resource
private XinELuConfig xinYiLuConfig;
@Resource
private GenerateSystemCodeUtil generateSystemCodeUtil;
/**
* 查询学习培训分类
*
* @param id 学习培训分类主键
* @return 学习培训分类
*/
@Override
public TrainingCategory selectTrainingCategoryById(Long id) {
return trainingCategoryMapper.selectTrainingCategoryById(id);
}
/**
* 查询学习培训分类列表
*
* @param trainingCategory 学习培训分类
* @return 学习培训分类
*/
@Override
public List<TrainingCategory> selectTrainingCategoryList(TrainingCategory trainingCategory) {
return trainingCategoryMapper.selectTrainingCategoryList(trainingCategory);
}
/**
* 新增学习培训分类
*
* @param trainingCategory 学习培训分类
* @return 结果
*/
@Override
public int insertTrainingCategory(TrainingCategory trainingCategory) {
trainingCategory.setCreateTime(LocalDateTime.now());
trainingCategory.setCreateBy(SecurityUtils.getUsername());
trainingCategory.setTrainingCategoryCode(Constants.TRAINING_CATEGORY + generateSystemCodeUtil.generateSystemCode(Constants.TRAINING_CATEGORY));
return trainingCategoryMapper.insertTrainingCategory(trainingCategory);
}
/**
* 修改学习培训分类
*
* @param trainingCategory 学习培训分类
* @return 结果
*/
@Transactional(rollbackFor = Exception.class)
@Override
public AjaxResult updateTrainingCategory(TrainingCategory trainingCategory) {
TrainingCategory initial = trainingCategoryMapper.selectTrainingCategoryById(trainingCategory.getId());
if (Objects.isNull(initial)) {
return AjaxResult.error("当前分类信息不存在，无法修改，请联系管理员！");
}
trainingCategory.setUpdateTime(LocalDateTime.now());
trainingCategory.setUpdateBy(SecurityUtils.getUsername());
//删除原有上传的分类图片
if (StringUtils.isNotBlank(trainingCategory.getTrainingCategoryPictureUrl()) && StringUtils.isNotBlank(initial.getTrainingCategoryPictureUrl())
&& !trainingCategory.getTrainingCategoryPictureUrl().equals(initial.getTrainingCategoryPictureUrl())) {
FileUtils.deleteSystemFile(initial.getTrainingCategoryPictureUrl());
}
return AjaxResult.success(trainingCategoryMapper.updateTrainingCategory(trainingCategory));
}
/**
* 批量删除学习培训分类
*
* @param ids 需要删除的学习培训分类主键
* @return 结果
*/
@Transactional(rollbackFor = Exception.class)
@Override
public AjaxResult deleteTrainingCategoryByIds(Long[] ids) {
if (Objects.isNull(ids)) {
return AjaxResult.error("请选择需要删除的信息！");
}
List<TrainingCategory> trainingCategories = trainingCategoryMapper.selectTrainingCategoryByIds(ids);
if (CollectionUtils.isEmpty(trainingCategories)) {
return AjaxResult.success();
}
trainingCategoryMapper.deleteTrainingCategoryByIds(ids);
for (TrainingCategory trainingCategory : trainingCategories) {
if (StringUtils.isBlank(trainingCategory.getTrainingCategoryPictureUrl())) {
continue;
}
FileUtils.deleteSystemFile(trainingCategory.getTrainingCategoryPictureUrl());
}
return AjaxResult.success();
}
/**
* 上传文件
*
* @param multipartFile 文件
* @return AjaxResult
* @throws Exception 异常信息
*/
@Override
public AjaxResult uploadTrainingCategoryPicture(MultipartFile multipartFile) throws Exception {
String uploadPathUrl = XinELuConfig.getProfile() + xinYiLuConfig.getTrainingCategoryPictureUrl();
return FileUtils.uploadImages(uploadPathUrl, multipartFile);
}
}

102
xinelu-nurse-manage/src/main/java/com/xinelu/manage/service/trainingitem/ITrainingItemService.java Normal file
View File

@ -0,0 +1,102 @@
package com.xinelu.manage.service.trainingitem;
import com.xinelu.common.core.domain.AjaxResult;
import com.xinelu.manage.domain.trainingitem.TrainingItem;
import com.xinelu.manage.dto.trainingitem.TrainingItemAndDirectory;
import com.xinelu.manage.vo.trainingitem.TrainingItemAndCategoryVO;
import org.springframework.web.multipart.MultipartFile;
import java.util.List;
/**
* 学习培训项目信息Service接口
*
* @author xinyilu
* @date 2023-04-20
*/
public interface ITrainingItemService {
/**
* 查询学习培训项目信息
*
* @param id 学习培训项目信息主键
* @return 学习培训项目信息
*/
TrainingItemAndDirectory selectTrainingItemById(Long id);
/**
* 查询学习培训项目信息列表
*
* @param trainingItem 学习培训项目信息
* @return 学习培训项目信息集合
*/
List<TrainingItemAndCategoryVO> selectTrainingItemList(TrainingItem trainingItem);
/**
* 新增学习培训项目信息
*
* @param trainingItem 学习培训项目信息
* @return 结果
*/
AjaxResult insertTrainingItem(TrainingItemAndDirectory trainingItem);
/**
* 修改学习培训项目信息
*
* @param trainingItem 学习培训项目信息
* @return 结果
*/
AjaxResult updateTrainingItem(TrainingItemAndDirectory trainingItem);
/**
* 批量删除学习培训项目信息
*
* @param ids 需要删除的学习培训项目信息主键集合
* @return 结果
*/
AjaxResult deleteTrainingItemByIds(Long[] ids);
/**
* 上传文件
*
* @param multipartFile 文件
* @param type 文件路径
* @return AjaxResult
* @throws Exception 错误信息
*/
AjaxResult uploadUrl(MultipartFile multipartFile, String type) throws Exception;
/**
* 上传文件
*
* @param multipartFile 文件
* @return AjaxResult
* @throws Exception 错误信息
*/
AjaxResult uploadVideoUrl(MultipartFile multipartFile) throws Exception;
/**
* 查询父级项目列表
*
* @param trainingItem 信息
* @return AjaxResult
*/
List<TrainingItemAndCategoryVO> selectTrainingParent(TrainingItemAndDirectory trainingItem);
/**
* 修改上下架状态
*
* @param trainingItem 学习培训项目信息
* @return AjaxResult
*/
AjaxResult updateTrainingShelfFlag(TrainingItem trainingItem);
/**
* 查询下级项目
*
* @param trainingItem 父级id
* @return AjaxResult
*/
AjaxResult selectSubordinateItem(TrainingItem trainingItem);
}

427
xinelu-nurse-manage/src/main/java/com/xinelu/manage/service/trainingitem/Impl/TrainingItemServiceImpl.java Normal file
View File

@ -0,0 +1,427 @@
package com.xinelu.manage.service.trainingitem.Impl;
import com.xinelu.common.config.XinELuConfig;
import com.xinelu.common.constant.Constants;
import com.xinelu.common.core.domain.AjaxResult;
import com.xinelu.common.enums.TrainingItemTypeEnum;
import com.xinelu.common.enums.TrainingShelfFlagEnum;
import com.xinelu.common.exception.ServiceException;
import com.xinelu.common.utils.SecurityUtils;
import com.xinelu.common.utils.codes.GenerateSystemCodeUtil;
import com.xinelu.common.utils.file.FileUtils;
import com.xinelu.manage.domain.trainingitem.TrainingItem;
import com.xinelu.manage.domain.trainingitemdirectory.TrainingItemDirectory;
import com.xinelu.manage.dto.trainingitem.TrainingItemAndDirectory;
import com.xinelu.manage.mapper.trainingitem.TrainingItemMapper;
import com.xinelu.manage.mapper.trainingitemdirectory.TrainingItemDirectoryMapper;
import com.xinelu.manage.service.trainingitem.ITrainingItemService;
import com.xinelu.manage.vo.trainingitem.TrainingItemAndCategoryVO;
import com.xinelu.manage.vo.trainingitemdirectory.TrainingItemDirectoryVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.compress.utils.Lists;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.time.LocalDateTime;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
/**
* 学习培训项目信息Service业务层处理
*
* @author xinyilu
* @date 2023-04-20
*/
@Slf4j
@Service
public class TrainingItemServiceImpl implements ITrainingItemService {
@Resource
private TrainingItemMapper trainingItemMapper;
@Resource
private TrainingItemDirectoryMapper trainingItemDirectoryMapper;
@Resource
private GenerateSystemCodeUtil generateSystemCodeUtil;
@Resource
private XinELuConfig xinYiLuConfig;
/**
* 查询学习培训项目信息
*
* @param id 学习培训项目信息主键
* @return 学习培训项目信息
*/
@Override
public TrainingItemAndDirectory selectTrainingItemById(Long id) {
return trainingItemMapper.selectTrainingItemAndDirectoryById(id);
}
/**
* 查询学习培训项目信息列表
*
* @param trainingItem 学习培训项目信息
* @return 学习培训项目信息
*/
@Override
public List<TrainingItemAndCategoryVO> selectTrainingItemList(TrainingItem trainingItem) {
trainingItem.setTrainingParentId(Constants.TRAINING_PARENT_ID);
return trainingItemMapper.selectTrainingItemAndCategoryList(trainingItem);
}
/**
* 新增学习培训项目信息
*
* @param trainingItem 学习培训项目信息
* @return 结果
*/
@Transactional(rollbackFor = Exception.class)
@Override
public AjaxResult insertTrainingItem(TrainingItemAndDirectory trainingItem) {
if (Objects.nonNull(trainingItem.getTrainingItemPrice()) && trainingItem.getTrainingItemPrice().compareTo(BigDecimal.ZERO) <= 0) {
return AjaxResult.error("价格不能为负数或零！");
}
if (Objects.nonNull(trainingItem.getTrainingItemSort()) && trainingItem.getTrainingItemSort() <= 0) {
return AjaxResult.error("排序不能为负数或零！");
}
trainingItem.setCreateBy(SecurityUtils.getUsername());
trainingItem.setCreateTime(LocalDateTime.now());
trainingItem.setTrainingItemCode(Constants.TRAINING_ITEM + generateSystemCodeUtil.generateSystemCode(Constants.TRAINING_ITEM));
if (Objects.isNull(trainingItem.getTrainingParentId()) || TrainingItemTypeEnum.LEARNING_ITEM_GROUP.getInfo().equals(trainingItem.getTrainingItemType())) {
trainingItem.setTrainingParentId(Constants.TRAINING_PARENT_ID);
}
trainingItem.setTrainingShelfFlag(TrainingShelfFlagEnum.NOT_SHEL.getInfo());
int insertTrainingItem = trainingItemMapper.insertTrainingItem(trainingItem);
if (insertTrainingItem <= 0) {
throw new ServiceException("新增学习培训课程信息失败，请联系管理员！");
}
//新增章节视频
if (!TrainingItemTypeEnum.VIDEO_LEARNING.getInfo().equals(trainingItem.getTrainingItemType())) {
return AjaxResult.success();
}
if (TrainingItemTypeEnum.VIDEO_LEARNING.getInfo().equals(trainingItem.getTrainingItemType()) && CollectionUtils.isEmpty(trainingItem.getTrainingItemDirectoryList())) {
throw new ServiceException("请添加章节视频信息！");
}
for (TrainingItemDirectory trainingItemDirectory : trainingItem.getTrainingItemDirectoryList()) {
trainingItemDirectory.setTrainingItemId(Objects.isNull(trainingItem.getId()) ? null : trainingItem.getId());
if (StringUtils.isBlank(trainingItemDirectory.getItemDirectoryUrl())) {
throw new ServiceException("请添加章节视频信息！");
}
if (StringUtils.isNotBlank(trainingItemDirectory.getItemDirectoryUrl())) {
trainingItemDirectory.setItemDirectoryVideoDuration(FileUtils.getVideoDuration(trainingItemDirectory.getItemDirectoryUrl().replaceAll(Constants.D_RESOURCE_PREFIX, Constants.D_UPLOAD_PREFIX)));
}
if (Objects.nonNull(trainingItemDirectory.getItemDirectorySort()) && trainingItemDirectory.getItemDirectorySort() <= 0) {
throw new ServiceException("排序不能为负数或零！");
}
trainingItemDirectory.setItemDirectoryCode(Constants.TRAINING_ITEM_DIRECTORY + generateSystemCodeUtil.generateSystemCode(Constants.TRAINING_ITEM_DIRECTORY));
}
int count = trainingItemDirectoryMapper.insertTrainingItemDirectoryList(trainingItem.getTrainingItemDirectoryList());
if (count <= 0) {
throw new ServiceException("新增章节视频信息失败，请联系管理员！");
}
return AjaxResult.success();
}
/**
* 修改学习培训项目信息
*
* @param trainingItem 学习培训项目信息
* @return 结果
*/
@Transactional(rollbackFor = Exception.class)
@Override
public AjaxResult updateTrainingItem(TrainingItemAndDirectory trainingItem) {
if (Objects.isNull(trainingItem.getTrainingItemId())) {
return AjaxResult.error("学习培训课程信息不能为空！");
}
if (Objects.nonNull(trainingItem.getTrainingItemPrice()) && trainingItem.getTrainingItemPrice().compareTo(BigDecimal.ZERO) <= 0) {
return AjaxResult.error("价格不能为负数或零！");
}
if (Objects.nonNull(trainingItem.getTrainingItemSort()) && trainingItem.getTrainingItemSort() <= 0) {
return AjaxResult.error("排序不能为负数或零！");
}
if (Objects.nonNull(trainingItem.getTrainingParentId()) && trainingItem.getTrainingParentId().equals(trainingItem.getTrainingItemId())) {
return AjaxResult.error("父级项目与本项目有冲突！请选择其他父级项目！");
}
//查询数据库信息
TrainingItemAndDirectory trainingItemAndDirectory = trainingItemMapper.selectTrainingItemAndDirectoryById(trainingItem.getTrainingItemId());
trainingItem.setUpdateBy(SecurityUtils.getUsername());
trainingItem.setUpdateTime(LocalDateTime.now());
trainingItem.setId(trainingItem.getTrainingItemId());
if (Objects.isNull(trainingItem.getTrainingParentId()) || TrainingItemTypeEnum.LEARNING_ITEM_GROUP.getInfo().equals(trainingItem.getTrainingItemType())) {
trainingItem.setTrainingParentId(Constants.TRAINING_PARENT_ID);
}
int updateTrainingItem = trainingItemMapper.updateTrainingItems(trainingItem);
if (updateTrainingItem <= 0) {
throw new ServiceException("修改培训课程信息失败，请联系管理员！");
}
//新增章节视频
if (!TrainingItemTypeEnum.VIDEO_LEARNING.getInfo().equals(trainingItem.getTrainingItemType())) {
//富文本修改
if (StringUtils.isNotBlank(trainingItemAndDirectory.getTrainingItemContent()) && StringUtils.isNotBlank(trainingItem.getTrainingItemContent()) && !trainingItemAndDirectory.getTrainingItemContent().equals(trainingItem.getTrainingItemContent())) {
FileUtils.deleteTextUrl(trainingItemAndDirectory.getTrainingItemContent(), trainingItem.getTrainingItemContent());
}
return AjaxResult.success();
}
if (TrainingItemTypeEnum.VIDEO_LEARNING.getInfo().equals(trainingItem.getTrainingItemType()) && CollectionUtils.isEmpty(trainingItem.getTrainingItemDirectoryList())) {
throw new ServiceException("请添加章节视频信息！");
}
//修改章节
updateTrainingItemDirectory(trainingItemAndDirectory, trainingItem);
//富文本修改
if (StringUtils.isNotBlank(trainingItemAndDirectory.getTrainingItemContent()) && StringUtils.isNotBlank(trainingItem.getTrainingItemContent()) && !trainingItemAndDirectory.getTrainingItemContent().equals(trainingItem.getTrainingItemContent())) {
FileUtils.deleteTextUrl(trainingItemAndDirectory.getTrainingItemContent(), trainingItem.getTrainingItemContent());
}
return AjaxResult.success();
}
/**
* 批量删除学习培训项目信息
*
* @param ids 需要删除的学习培训项目信息主键
* @return 结果
*/
@Transactional(rollbackFor = Exception.class)
@Override
public AjaxResult deleteTrainingItemByIds(Long[] ids) {
//查询数据库信息
List<TrainingItemAndDirectory> trainingItemAndDirectories = trainingItemMapper.selectTrainingItemAndDirectoryList(ids, null);
if (CollectionUtils.isEmpty(trainingItemAndDirectories)) {
return AjaxResult.success();
}
List<TrainingItemAndDirectory> childTrainingItemAndDirectories = trainingItemMapper.selectTrainingItemAndDirectoryList(null, ids);
if (CollectionUtils.isEmpty(childTrainingItemAndDirectories) && CollectionUtils.isEmpty(trainingItemAndDirectories)) {
return AjaxResult.success();
}
List<Long> dataList = Lists.newArrayList();
List<Long> childIdsList = childTrainingItemAndDirectories.stream().filter(Objects::nonNull).map(TrainingItemAndDirectory::getTrainingItemId).filter(Objects::nonNull).collect(Collectors.toList()).stream().filter(Objects::nonNull).collect(Collectors.toList());
dataList.addAll(Arrays.asList(ids));
dataList.addAll(childIdsList);
int count = trainingItemMapper.deleteTrainingItemByIds(dataList);
if (count <= 0) {
throw new ServiceException("删除信息失败，请联系管理员！");
}
//删除章节
deleteTrainingItemDirectory(trainingItemAndDirectories);
if (CollectionUtils.isNotEmpty(childTrainingItemAndDirectories)) {
deleteTrainingItemDirectory(childTrainingItemAndDirectories);
}
//删除图片视频
deleteUrl(trainingItemAndDirectories);
if (CollectionUtils.isNotEmpty(childTrainingItemAndDirectories)) {
deleteUrl(childTrainingItemAndDirectories);
}
return AjaxResult.success();
}
/**
* 上传文件
*
* @param multipartFile 文件
* @return AjaxResult
* @throws Exception 错误信息
*/
@Override
public AjaxResult uploadUrl(MultipartFile multipartFile, String type) throws Exception {
//获取不同的文件路径
String uploadPathUrl = "";
if (Constants.TRAINING_ITEM_COVER_URL.equals(type)) {
uploadPathUrl = XinELuConfig.getProfile() + xinYiLuConfig.getTrainingItemCoverUrl();
}
if (Constants.TRAINING_ITEM_POSTER_URL.equals(type)) {
uploadPathUrl = XinELuConfig.getProfile() + xinYiLuConfig.getTrainingItemPosterUrl();
}
if (StringUtils.isEmpty(uploadPathUrl)) {
return AjaxResult.success();
}
return FileUtils.uploadImages(uploadPathUrl, multipartFile);
}
/**
* 上传文件
*
* @param multipartFile 文件
* @return AjaxResult
* @throws Exception 错误信息
*/
@Override
public AjaxResult uploadVideoUrl(MultipartFile multipartFile) throws Exception {
if (Objects.isNull(multipartFile) || StringUtils.isBlank(multipartFile.getOriginalFilename())) {
return AjaxResult.error("当前文件视频不存在，无法上传！");
}
if (multipartFile.getOriginalFilename().contains(Constants.EMPTY)) {
return AjaxResult.error("当前视频文件名含有空格，请先去除空格在上传！");
}
String uploadPathUrl = XinELuConfig.getProfile() + xinYiLuConfig.getItemDirectoryUrl();
return FileUtils.uploadVideo(uploadPathUrl, multipartFile);
}
/**
* 查询父级项目列表
*
* @param trainingItem 信息
* @return AjaxResult
*/
@Override
public List<TrainingItemAndCategoryVO> selectTrainingParent(TrainingItemAndDirectory trainingItem) {
trainingItem.setTrainingItemType(TrainingItemTypeEnum.LEARNING_ITEM_GROUP.getInfo());
return trainingItemMapper.selectTrainingItems(trainingItem);
}
/**
* 修改上下架状态
*
* @param trainingItem 学习培训项目信息
* @return AjaxResult
*/
@Transactional(rollbackFor = Exception.class)
@Override
public AjaxResult updateTrainingShelfFlag(TrainingItem trainingItem) {
//修改本级状态
int updateTrainingItem = trainingItemMapper.updateTrainingItem(trainingItem);
if (updateTrainingItem <= 0) {
log.error("修改学习培训课程组信息失败，学习培训课程组id为：{}", trainingItem.getId());
throw new ServiceException("修改上下架状态失败！");
}
//修改下级状态
if (StringUtils.isNotBlank(trainingItem.getTrainingItemType()) && TrainingItemTypeEnum.LEARNING_ITEM_GROUP.getInfo().equals(trainingItem.getTrainingItemType())) {
trainingItem.setTrainingParentId(trainingItem.getId());
int count = trainingItemMapper.updateTrainingItemList(trainingItem);
if (count < 0) {
log.error("修改学习培训视频课程信息失败，所属课程组id为：{}", trainingItem.getId());
throw new ServiceException("修改上下架状态失败！");
}
}
return AjaxResult.success();
}
/**
* 查询下级项目
*
* @param trainingItem 父级id
* @return AjaxResult
*/
@Override
public AjaxResult selectSubordinateItem(TrainingItem trainingItem) {
return AjaxResult.success(trainingItemMapper.selectTrainingItemAndCategoryList(trainingItem));
}
/**
* 修改章节信息
*
* @param trainingItemAndDirectory 数据库数据库信息
* @param trainingItem 前端传入
*/
private void updateTrainingItemDirectory(TrainingItemAndDirectory trainingItemAndDirectory, TrainingItemAndDirectory trainingItem) {
List<Long> databaseDirectoryIds = trainingItemAndDirectory.getTrainingItemDirectoryList().stream().filter(Objects::nonNull).map(TrainingItemDirectoryVO::getTrainingItemDirectoryId).filter(Objects::nonNull).collect(Collectors.toList());
List<Long> afferentDirectoryIds = trainingItem.getTrainingItemDirectoryList().stream().filter(Objects::nonNull).map(TrainingItemDirectoryVO::getTrainingItemDirectoryId).filter(Objects::nonNull).collect(Collectors.toList());
List<String> itemDirectoryUrlList = trainingItemAndDirectory.getTrainingItemDirectoryList().stream().filter(Objects::nonNull).map(TrainingItemDirectory::getItemDirectoryUrl).filter(StringUtils::isNotBlank).collect(Collectors.toList());
List<String> afferentUrlList = trainingItem.getTrainingItemDirectoryList().stream().filter(Objects::nonNull).map(TrainingItemDirectory::getItemDirectoryUrl).filter(StringUtils::isNotBlank).collect(Collectors.toList());
if (CollectionUtils.isEmpty(afferentUrlList)) {
throw new ServiceException("请添加章节视频信息！");
}
//databaseDirectoryIds减afferentDirectoryIds,删除
List<Long> subtractIds = new ArrayList<>(CollectionUtils.subtract(databaseDirectoryIds, afferentDirectoryIds));
if (CollectionUtils.isNotEmpty(subtractIds)) {
Long[] longs = subtractIds.stream().filter(Objects::nonNull).toArray(Long[]::new);
int deleteCount = trainingItemDirectoryMapper.deleteTrainingItemDirectoryByIds(longs);
if (deleteCount <= 0) {
log.error("删除章节信息失败!");
throw new ServiceException("修改培训课程信息失败，请联系管理员！");
}
}
//id为空新增
List<TrainingItemDirectoryVO> trainingItemDirectoryList = new ArrayList<>();
for (TrainingItemDirectoryVO trainingItemDirectory : trainingItem.getTrainingItemDirectoryList()) {
if (StringUtils.isBlank(trainingItemDirectory.getItemDirectoryTitle()) && StringUtils.isBlank(trainingItemDirectory.getItemDirectoryName()) && StringUtils.isBlank(trainingItemDirectory.getItemDirectoryUrl()) && StringUtils.isBlank(trainingItemDirectory.getItemDirectoryIntroduce())) {
continue;
}
if (StringUtils.isBlank(trainingItemDirectory.getItemDirectoryTitle()) || StringUtils.isBlank(trainingItemDirectory.getItemDirectoryName()) || StringUtils.isBlank(trainingItemDirectory.getItemDirectoryUrl()) || StringUtils.isBlank(trainingItemDirectory.getItemDirectoryIntroduce())) {
throw new ServiceException("请添加章节视频信息！");
}
if (Objects.nonNull(trainingItemDirectory.getItemDirectoryUrl())) {
trainingItemDirectory.setItemDirectoryVideoDuration(FileUtils.getVideoDuration(trainingItemDirectory.getItemDirectoryUrl().replaceAll(Constants.D_RESOURCE_PREFIX, Constants.D_UPLOAD_PREFIX)));
}
if (Objects.isNull(trainingItemDirectory.getTrainingItemDirectoryId())) {
trainingItemDirectory.setTrainingItemId(trainingItem.getId());
trainingItemDirectory.setItemDirectoryCode(Constants.TRAINING_ITEM_DIRECTORY + generateSystemCodeUtil.generateSystemCode(Constants.TRAINING_ITEM_DIRECTORY));
trainingItemDirectoryList.add(trainingItemDirectory);
}
//不为空修改
if (Objects.nonNull(trainingItemDirectory.getTrainingItemDirectoryId())) {
trainingItemDirectory.setId(trainingItemDirectory.getTrainingItemDirectoryId());
trainingItemDirectoryMapper.updateTrainingItemDirectory(trainingItemDirectory);
}
}
if (CollectionUtils.isNotEmpty(trainingItemDirectoryList)) {
int insertDirectoryCount = trainingItemDirectoryMapper.insertTrainingItemDirectoryList(trainingItemDirectoryList);
if (insertDirectoryCount <= 0) {
log.error("新增项目章节信息失败！");
throw new ServiceException("修改培训课程信息失败，请联系管理员！");
}
}
List<String> subtractUrl = new ArrayList<>(CollectionUtils.subtract(itemDirectoryUrlList, afferentUrlList));
for (String itemDirectoryUrl : subtractUrl) {
FileUtils.deleteSystemFile(itemDirectoryUrl);
}
}
/**
* 删除视频主表
*
* @param trainingItemAndDirectories 文件信息
*/
private void deleteTrainingItemDirectory(List<TrainingItemAndDirectory> trainingItemAndDirectories) {
List<Long> trainingItemDirectoryIdList = new ArrayList<>();
for (TrainingItemAndDirectory trainingItemAndDirectory : trainingItemAndDirectories) {
if (CollectionUtils.isEmpty(trainingItemAndDirectory.getTrainingItemDirectoryList())) {
continue;
}
List<Long> trainingItemDirectoryIds = trainingItemAndDirectory.getTrainingItemDirectoryList().stream().filter(Objects::nonNull).map(TrainingItemDirectoryVO::getTrainingItemDirectoryId).filter(Objects::nonNull).collect(Collectors.toList());
trainingItemDirectoryIdList.addAll(trainingItemDirectoryIds);
}
if (CollectionUtils.isNotEmpty(trainingItemDirectoryIdList)) {
trainingItemDirectoryMapper.deleteTrainingItemDirectoryByIds(trainingItemDirectoryIdList.toArray(new Long[0]));
}
}
/**
* 删除图片视频
*
* @param trainingItemAndDirectories 文件
*/
private void deleteUrl(List<TrainingItemAndDirectory> trainingItemAndDirectories) {
//取出课程信息的封面路径和海报路径
List<String> trainingItemCoverUrlList = trainingItemAndDirectories.stream().filter(Objects::nonNull).map(TrainingItemAndDirectory::getTrainingItemCoverUrl).filter(StringUtils::isNotBlank).collect(Collectors.toList());
List<String> trainingItemPosterUrList = trainingItemAndDirectories.stream().filter(Objects::nonNull).map(TrainingItemAndDirectory::getTrainingItemPosterUrl).filter(StringUtils::isNotBlank).collect(Collectors.toList());
trainingItemCoverUrlList.addAll(trainingItemPosterUrList);
for (TrainingItemAndDirectory trainingItemAndDirectory : trainingItemAndDirectories) {
if (CollectionUtils.isEmpty(trainingItemAndDirectory.getTrainingItemDirectoryList())) {
continue;
}
List<String> itemDirectoryUrlList = trainingItemAndDirectory.getTrainingItemDirectoryList().stream().filter(Objects::nonNull).map(TrainingItemDirectory::getItemDirectoryUrl).filter(StringUtils::isNotBlank).collect(Collectors.toList());
trainingItemCoverUrlList.addAll(itemDirectoryUrlList);
}
//删除图片
if (CollectionUtils.isNotEmpty(trainingItemCoverUrlList)) {
for (String trainingItemCoverUrl : trainingItemCoverUrlList) {
FileUtils.deleteSystemFile(trainingItemCoverUrl);
}
}
//富文本删除
List<String> trainingItemContentList = trainingItemAndDirectories.stream().filter(Objects::nonNull).map(TrainingItem::getTrainingItemContent).filter(StringUtils::isNotBlank).collect(Collectors.toList());
if (CollectionUtils.isNotEmpty(trainingItemContentList)) {
for (String trainingItemContent : trainingItemContentList) {
FileUtils.deleteTextUrl(trainingItemContent, null);
}
}
}
}

47
xinelu-nurse-manage/src/main/java/com/xinelu/manage/vo/trainingitem/NurseAppletPersonTrainingItemVO.java Normal file
View File

@ -0,0 +1,47 @@
package com.xinelu.manage.vo.trainingitem;
import com.xinelu.manage.domain.trainingitem.TrainingItem;
import com.xinelu.manage.vo.trainingitemdirectory.TrainingItemDirectoryVO;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.util.List;
/**
* 护理员学习培训VO
*
* @author ljh
* @version 1.0
* Create by 2023/4/21 11:04
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class NurseAppletPersonTrainingItemVO extends TrainingItem implements Serializable {
private static final long serialVersionUID = 4910038250164588018L;
/**
* 学习培训项目章节信息表
*/
List<TrainingItemDirectoryVO> trainingItemDirectoryList;
/**
* 学习培训项目信息对象主键id
*/
private Long trainingItemId;
/**
* 学习培训项目章节对象主键id
*/
private Long trainingItemDirectoryId;
/**
* 订单状态，待付款：WAIT_PAY，已付款：PAY，退款中：WAIT_REFUND，已退款：REFUNDED，已取消：CANCEL
*/
private String trainingOrderStatus;
/**
* 是否购买此包 BUY：已购买，NOT_BUY：未购买
*/
private String trainingOrderDetailsBuy;
}

35
xinelu-nurse-manage/src/main/java/com/xinelu/manage/vo/trainingitem/TrainingItemAndCategoryVO.java Normal file
View File

@ -0,0 +1,35 @@
package com.xinelu.manage.vo.trainingitem;
import com.xinelu.manage.domain.trainingitem.TrainingItem;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* 学习培训项目信息对象 training_item
*
* @author zh
* @date 2023-04-21
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class TrainingItemAndCategoryVO extends TrainingItem implements Serializable {
private static final long serialVersionUID = 8011776285939512204L;
/**
* 培训分类名称
*/
private String trainingCategoryName;
/**
* 父级项目名称
*/
private String trainingParentName;
/**
* 父级项目id
*/
private Long trainingParentId;
}

27
xinelu-nurse-manage/src/main/java/com/xinelu/manage/vo/trainingitem/TrainingItemVO.java Normal file
View File

@ -0,0 +1,27 @@
package com.xinelu.manage.vo.trainingitem;
import com.xinelu.manage.domain.trainingitem.TrainingItem;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
/**
* @author ljh
* @version 1.0
* Create by 2023/4/25 10:51
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class TrainingItemVO extends TrainingItem implements Serializable {
private static final long serialVersionUID = 4886684550435223303L;
/**
* 是否购买此包 BUY：已购买，NOT_BUY：未购买
*/
private String trainingOrderDetailsBuy;
/**
* 订单编号
*/
private String trainingOrderNo;
}

79
xinelu-nurse-manage/src/main/java/com/xinelu/manage/vo/trainingitemdirectory/TrainingItemDirectoryVO.java Normal file
View File

@ -0,0 +1,79 @@
package com.xinelu.manage.vo.trainingitemdirectory;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.xinelu.manage.domain.trainingitemdirectory.TrainingItemDirectory;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serializable;
import java.time.LocalDate;
import java.time.LocalTime;
/**
* 学习培训项目章节对象 training_item_directory
*
* @author xinyilu
* @date 2023-04-20
*/
@EqualsAndHashCode(callSuper = true)
@Data
public class TrainingItemDirectoryVO extends TrainingItemDirectory implements Serializable {
private static final long serialVersionUID = 1329246346741098330L;
/**
* 主键id
*/
private Long trainingItemDirectoryId;
/**
* 是否购买学习培训项目章节 BUY：已购买，NOT_BUY：未购买
*/
private String trainingOrderItemDirectoryBuy;
/**
* 未观看：NOT_WATCHED，已观看：WATCHED，已看完：FINISHED_READING
**/
private String itemDirectoryWatchStatus;
/**
* 订单编号
*/
private String trainingOrderNo;
/**
* 订单主表id
*/
private Long trainingOrderId;
/**
* 护理站id
*/
private Long nurseStationId;
/**
* 护理站人员id
*/
private Long nurseStationPersonId;
/**
* 护理站人员名称
*/
private String nursePersonName;
/**
* 订单状态，待付款：WAIT_PAY，已付款：PAY，退款中：WAIT_REFUND，已退款：REFUNDED，已取消：CANCEL
*/
private String trainingOrderStatus;
/**
* 观看日期，格式：yyyy-MM-dd
*/
@JsonFormat(pattern = "yyyy-MM-dd")
private LocalDate watchDate;
/**
* 培训项目观看时间点，格式：HH:mm:ss，视频学习类型使用
*/
@JsonFormat(pattern = "HH:mm:ss")
private LocalTime watchTime;
}

170
xinelu-nurse-manage/src/main/resources/mapper/manage/trainingcategory/TrainingCategoryMapper.xml Normal file
View File

@ -0,0 +1,170 @@
<?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="com.xinelu.manage.mapper.trainingcategory.TrainingCategoryMapper">
<resultMap type="TrainingCategory" id="TrainingCategoryResult">
<result property="id" column="id"/>
<result property="parentId" column="parent_id"/>
<result property="trainingCategoryName" column="training_category_name"/>
<result property="trainingCategoryCode" column="training_category_code"/>
<result property="trainingCategoryPictureUrl" column="training_category_picture_url"/>
<result property="trainingCategorySort" column="training_category_sort"/>
<result property="remark" column="remark"/>
<result property="createBy" column="create_by"/>
<result property="createTime" column="create_time"/>
<result property="updateBy" column="update_by"/>
<result property="updateTime" column="update_time"/>
</resultMap>
<sql id="selectTrainingCategoryVo">
select id,
parent_id,
training_category_name,
training_category_code,
training_category_picture_url,
training_category_sort,
remark,
create_by,
create_time,
update_by,
update_time
from training_category
</sql>
<select id="selectTrainingCategoryList" parameterType="TrainingCategory" resultMap="TrainingCategoryResult">
<include refid="selectTrainingCategoryVo"/>
<where>
<if test="parentId != null ">
and parent_id = #{parentId}
</if>
<if test="trainingCategoryName != null and trainingCategoryName != ''">
and training_category_name like concat('%', #{trainingCategoryName}, '%')
</if>
<if test="trainingCategoryCode != null and trainingCategoryCode != ''">
and training_category_code = #{trainingCategoryCode}
</if>
<if test="trainingCategoryPictureUrl != null and trainingCategoryPictureUrl != ''">
and training_category_picture_url = #{trainingCategoryPictureUrl}
</if>
<if test="trainingCategorySort != null ">
and training_category_sort = #{trainingCategorySort}
</if>
</where>
</select>
<select id="selectTrainingCategoryById" parameterType="Long"
resultMap="TrainingCategoryResult">
<include refid="selectTrainingCategoryVo"/>
where id = #{id}
</select>
<insert id="insertTrainingCategory" parameterType="TrainingCategory" useGeneratedKeys="true"
keyProperty="id">
insert into training_category
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="parentId != null">parent_id,
</if>
<if test="trainingCategoryName != null">training_category_name,
</if>
<if test="trainingCategoryCode != null">training_category_code,
</if>
<if test="trainingCategoryPictureUrl != null">training_category_picture_url,
</if>
<if test="trainingCategorySort != null">training_category_sort,
</if>
<if test="remark != null">remark,
</if>
<if test="createBy != null">create_by,
</if>
<if test="createTime != null">create_time,
</if>
<if test="updateBy != null">update_by,
</if>
<if test="updateTime != null">update_time,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="parentId != null">#{parentId},
</if>
<if test="trainingCategoryName != null">#{trainingCategoryName},
</if>
<if test="trainingCategoryCode != null">#{trainingCategoryCode},
</if>
<if test="trainingCategoryPictureUrl != null">#{trainingCategoryPictureUrl},
</if>
<if test="trainingCategorySort != null">#{trainingCategorySort},
</if>
<if test="remark != null">#{remark},
</if>
<if test="createBy != null">#{createBy},
</if>
<if test="createTime != null">#{createTime},
</if>
<if test="updateBy != null">#{updateBy},
</if>
<if test="updateTime != null">#{updateTime},
</if>
</trim>
</insert>
<update id="updateTrainingCategory" parameterType="TrainingCategory">
update training_category
<trim prefix="SET" suffixOverrides=",">
<if test="parentId != null">parent_id =
#{parentId},
</if>
<if test="trainingCategoryName != null">training_category_name =
#{trainingCategoryName},
</if>
<if test="trainingCategoryCode != null">training_category_code =
#{trainingCategoryCode},
</if>
<if test="trainingCategoryPictureUrl != null">training_category_picture_url =
#{trainingCategoryPictureUrl},
</if>
<if test="trainingCategorySort != null">training_category_sort =
#{trainingCategorySort},
</if>
<if test="remark != null">remark =
#{remark},
</if>
<if test="createBy != null">create_by =
#{createBy},
</if>
<if test="createTime != null">create_time =
#{createTime},
</if>
<if test="updateBy != null">update_by =
#{updateBy},
</if>
<if test="updateTime != null">update_time =
#{updateTime},
</if>
</trim>
where id = #{id}
</update>
<delete id="deleteTrainingCategoryById" parameterType="Long">
delete
from training_category
where id = #{id}
</delete>
<delete id="deleteTrainingCategoryByIds" parameterType="String">
delete from training_category where id in
<foreach item="id" collection="array" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
<select id="selectTrainingCategoryByIds"
resultType="com.xinelu.manage.domain.trainingcategory.TrainingCategory">
<include refid="selectTrainingCategoryVo"/>
where id in
<foreach item="ids" collection="array" open="(" separator="," close=")">
#{ids}
</foreach>
</select>
</mapper>

753
xinelu-nurse-manage/src/main/resources/mapper/manage/trainingitem/TrainingItemMapper.xml Normal file
View File

@ -0,0 +1,753 @@
<?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="com.xinelu.manage.mapper.trainingitem.TrainingItemMapper">
<resultMap type="TrainingItem" id="TrainingItemResult">
<result property="id" column="id"/>
<result property="trainingCategoryId" column="training_category_id"/>
<result property="trainingParentId" column="training_parent_id"/>
<result property="trainingItemTitle" column="training_item_title"/>
<result property="trainingItemCode" column="training_item_code"/>
<result property="trainingItemPrice" column="training_item_price"/>
<result property="trainingItemCoverUrl" column="training_item_cover_url"/>
<result property="trainingItemPosterUrl" column="training_item_poster_url"/>
<result property="trainingItemType" column="training_item_type"/>
<result property="trainingItemDetails" column="training_item_details"/>
<result property="trainingItemContent" column="training_item_content"/>
<result property="trainingItemDate" column="training_item_date"/>
<result property="trainingItemStartTime" column="training_item_start_time"/>
<result property="trainingItemEndTime" column="training_item_end_time"/>
<result property="trainingItemAddress" column="training_item_address"/>
<result property="trainingItemNotes" column="training_item_notes"/>
<result property="trainingItemSort" column="training_item_sort"/>
<result property="buyFlag" column="buy_flag"/>
<result property="trainingShelfFlag" column="training_shelf_flag"/>
<result property="createBy" column="create_by"/>
<result property="createTime" column="create_time"/>
<result property="updateBy" column="update_by"/>
<result property="updateTime" column="update_time"/>
</resultMap>
<resultMap type="com.xinelu.manage.vo.trainingitem.NurseAppletPersonTrainingItemVO"
id="NurseAppletPersonTrainingItemVOResult">
<result property="trainingItemId" column="trainingItemId"/>
<result property="trainingCategoryId" column="training_category_id"/>
<result property="trainingParentId" column="training_parent_id"/>
<result property="trainingItemTitle" column="training_item_title"/>
<result property="trainingItemCode" column="training_item_code"/>
<result property="trainingItemPrice" column="training_item_price"/>
<result property="trainingItemCoverUrl" column="training_item_cover_url"/>
<result property="trainingItemPosterUrl" column="training_item_poster_url"/>
<result property="trainingItemType" column="training_item_type"/>
<result property="trainingItemDetails" column="training_item_details"/>
<result property="trainingItemContent" column="training_item_content"/>
<result property="trainingItemDate" column="training_item_date"/>
<result property="trainingItemStartTime" column="training_item_start_time"/>
<result property="trainingItemEndTime" column="training_item_end_time"/>
<result property="trainingItemAddress" column="training_item_address"/>
<result property="trainingItemNotes" column="training_item_notes"/>
<result property="trainingItemSort" column="training_item_sort"/>
<result property="buyFlag" column="buy_flag"/>
<result property="trainingOrderDetailsBuy" column="trainingOrderDetailsBuy"/>
<result property="createBy" column="create_by"/>
<result property="createTime" column="create_time"/>
<result property="updateBy" column="update_by"/>
<result property="updateTime" column="update_time"/>
<collection property="trainingItemDirectoryList" javaType="java.util.List"
resultMap="TrainingItemDirectoryResult"/>
</resultMap>
<resultMap type="com.xinelu.manage.vo.trainingitemdirectory.TrainingItemDirectoryVO"
id="TrainingItemDirectoryResult">
<result property="trainingItemDirectoryId" column="trainingItemDirectoryId"/>
<result property="trainingOrderItemDirectoryBuy" column="trainingOrderItemDirectoryBuy"/>
<result property="trainingItemId" column="training_item_id"/>
<result property="itemDirectoryName" column="item_directory_name"/>
<result property="itemDirectoryCode" column="item_directory_code"/>
<result property="itemDirectoryTitle" column="item_directory_title"/>
<result property="itemDirectoryUrl" column="item_directory_url"/>
<result property="itemDirectoryVideoDuration" column="item_directory_video_duration"/>
<result property="itemDirectoryIntroduce" column="item_directory_introduce"/>
<result property="itemDirectorySort" column="item_directory_sort"/>
<result property="createBy" column="create_by"/>
<result property="createTime" column="create_time"/>
<result property="updateBy" column="update_by"/>
<result property="updateTime" column="update_time"/>
</resultMap>
<resultMap type="com.xinelu.manage.dto.trainingitem.TrainingItemAndDirectory" id="TrainingItemAndDirectoryResult">
<result property="trainingItemId" column="trainingItemId"/>
<result property="trainingCategoryId" column="training_category_id"/>
<result property="trainingParentId" column="training_parent_id"/>
<result property="trainingItemTitle" column="training_item_title"/>
<result property="trainingItemCode" column="training_item_code"/>
<result property="trainingItemPrice" column="training_item_price"/>
<result property="trainingItemCoverUrl" column="training_item_cover_url"/>
<result property="trainingItemPosterUrl" column="training_item_poster_url"/>
<result property="trainingItemType" column="training_item_type"/>
<result property="trainingItemDetails" column="training_item_details"/>
<result property="trainingItemContent" column="training_item_content"/>
<result property="trainingItemDate" column="training_item_date"/>
<result property="trainingItemStartTime" column="training_item_start_time"/>
<result property="trainingItemEndTime" column="training_item_end_time"/>
<result property="trainingItemAddress" column="training_item_address"/>
<result property="trainingItemNotes" column="training_item_notes"/>
<result property="trainingItemSort" column="training_item_sort"/>
<result property="buyFlag" column="buy_flag"/>
<result property="trainingCategoryName" column="training_category_name"/>
<result property="trainingParentName" column="trainingParentName"/>
<collection property="trainingItemDirectoryList" javaType="java.util.List"
resultMap="TrainingItemDirectoryVOResult"/>
</resultMap>
<resultMap type="com.xinelu.manage.vo.trainingitemdirectory.TrainingItemDirectoryVO"
id="TrainingItemDirectoryVOResult">
<result property="trainingItemDirectoryId" column="trainingItemDirectoryId"/>
<result property="trainingItemId" column="training_item_id"/>
<result property="itemDirectoryName" column="item_directory_name"/>
<result property="itemDirectoryCode" column="item_directory_code"/>
<result property="itemDirectoryTitle" column="item_directory_title"/>
<result property="itemDirectoryUrl" column="item_directory_url"/>
<result property="itemDirectoryVideoDuration" column="item_directory_video_duration"/>
<result property="itemDirectoryIntroduce" column="item_directory_introduce"/>
<result property="itemDirectorySort" column="item_directory_sort"/>
</resultMap>
<sql id="selectTrainingItemVo">
select id,
training_category_id,
training_parent_id,
training_item_title,
training_item_code,
training_item_price,
training_item_cover_url,
training_item_poster_url,
training_item_type,
training_item_details,
training_item_content,
training_item_date,
training_item_start_time,
training_item_end_time,
training_item_address,
training_item_notes,
training_item_sort,
buy_flag,
training_shelf_flag,
create_by,
create_time,
update_by,
update_time
from training_item
</sql>
<select id="selectTrainingItemList" parameterType="TrainingItem" resultMap="TrainingItemResult">
<include refid="selectTrainingItemVo"/>
<where>
<if test="id != null ">
and id = #{id}
</if>
<if test="trainingParentId != null ">
and training_parent_id = #{trainingParentId}
</if>
<if test="trainingCategoryId != null ">
and training_category_id = #{trainingCategoryId}
</if>
<if test="trainingItemTitle != null and trainingItemTitle != ''">
and training_item_title = #{trainingItemTitle}
</if>
<if test="trainingItemCode != null and trainingItemCode != ''">
and training_item_code = #{trainingItemCode}
</if>
<if test="trainingItemPrice != null ">
and training_item_price = #{trainingItemPrice}
</if>
<if test="trainingItemCoverUrl != null and trainingItemCoverUrl != ''">
and training_item_cover_url = #{trainingItemCoverUrl}
</if>
<if test="trainingItemPosterUrl != null and trainingItemPosterUrl != ''">
and training_item_poster_url = #{trainingItemPosterUrl}
</if>
<if test="trainingItemType != null and trainingItemType != ''">
and training_item_type = #{trainingItemType}
</if>
<if test="trainingItemDetails != null and trainingItemDetails != ''">
and training_item_details = #{trainingItemDetails}
</if>
<if test="trainingItemContent != null and trainingItemContent != ''">
and training_item_content = #{trainingItemContent}
</if>
<if test="trainingItemDate != null ">
and training_item_date = #{trainingItemDate}
</if>
<if test="trainingItemStartTime != null ">
and training_item_start_time = #{trainingItemStartTime}
</if>
<if test="trainingItemEndTime != null ">
and training_item_end_time = #{trainingItemEndTime}
</if>
<if test="trainingItemAddress != null and trainingItemAddress != ''">
and training_item_address = #{trainingItemAddress}
</if>
<if test="trainingItemNotes != null and trainingItemNotes != ''">
and training_item_notes = #{trainingItemNotes}
</if>
<if test="trainingItemSort != null ">
and training_item_sort = #{trainingItemSort}
</if>
<if test="trainingShelfFlag != null ">
and training_shelf_flag = #{trainingShelfFlag}
</if>
</where>
</select>
<select id="selectTrainingItemById" parameterType="Long"
resultMap="TrainingItemResult">
<include refid="selectTrainingItemVo"/>
where id = #{id}
</select>
<insert id="insertTrainingItem" parameterType="TrainingItem" useGeneratedKeys="true"
keyProperty="id">
insert into training_item
<trim prefix="(" suffix=")" suffixOverrides=",">
<if test="trainingCategoryId != null">training_category_id,
</if>
<if test="trainingParentId != null">training_parent_id,
</if>
<if test="trainingItemTitle != null">training_item_title,
</if>
<if test="trainingItemCode != null">training_item_code,
</if>
<if test="trainingItemPrice != null">training_item_price,
</if>
<if test="trainingItemCoverUrl != null">training_item_cover_url,
</if>
<if test="trainingItemPosterUrl != null">training_item_poster_url,
</if>
<if test="trainingItemType != null">training_item_type,
</if>
<if test="trainingItemDetails != null">training_item_details,
</if>
<if test="trainingItemContent != null">training_item_content,
</if>
<if test="trainingItemDate != null">training_item_date,
</if>
<if test="trainingItemStartTime != null">training_item_start_time,
</if>
<if test="trainingItemEndTime != null">training_item_end_time,
</if>
<if test="trainingItemAddress != null">training_item_address,
</if>
<if test="trainingItemNotes != null">training_item_notes,
</if>
<if test="trainingItemSort != null">training_item_sort,
</if>
<if test="buyFlag != null">buy_flag,
</if>
<if test="trainingShelfFlag != null">training_shelf_flag,
</if>
<if test="createBy != null">create_by,
</if>
<if test="createTime != null">create_time,
</if>
<if test="updateBy != null">update_by,
</if>
<if test="updateTime != null">update_time,
</if>
</trim>
<trim prefix="values (" suffix=")" suffixOverrides=",">
<if test="trainingCategoryId != null">#{trainingCategoryId},
</if>
<if test="trainingParentId != null">#{trainingParentId},
</if>
<if test="trainingItemTitle != null">#{trainingItemTitle},
</if>
<if test="trainingItemCode != null">#{trainingItemCode},
</if>
<if test="trainingItemPrice != null">#{trainingItemPrice},
</if>
<if test="trainingItemCoverUrl != null">#{trainingItemCoverUrl},
</if>
<if test="trainingItemPosterUrl != null">#{trainingItemPosterUrl},
</if>
<if test="trainingItemType != null">#{trainingItemType},
</if>
<if test="trainingItemDetails != null">#{trainingItemDetails},
</if>
<if test="trainingItemContent != null">#{trainingItemContent},
</if>
<if test="trainingItemDate != null">#{trainingItemDate},
</if>
<if test="trainingItemStartTime != null">#{trainingItemStartTime},
</if>
<if test="trainingItemEndTime != null">#{trainingItemEndTime},
</if>
<if test="trainingItemAddress != null">#{trainingItemAddress},
</if>
<if test="trainingItemNotes != null">#{trainingItemNotes},
</if>
<if test="trainingItemSort != null">#{trainingItemSort},
</if>
<if test="buyFlag != null">#{buyFlag},
</if>
<if test="trainingShelfFlag != null">#{trainingShelfFlag},
</if>
<if test="createBy != null">#{createBy},
</if>
<if test="createTime != null">#{createTime},
</if>
<if test="updateBy != null">#{updateBy},
</if>
<if test="updateTime != null">#{updateTime},
</if>
</trim>
</insert>
<update id="updateTrainingItem" parameterType="TrainingItem">
update training_item
<trim prefix="SET" suffixOverrides=",">
<if test="trainingCategoryId != null">training_category_id =
#{trainingCategoryId},
</if>
<if test="trainingParentId != null">training_parent_id =
#{trainingParentId},
</if>
<if test="trainingItemTitle != null">training_item_title =
#{trainingItemTitle},
</if>
<if test="trainingItemCode != null">training_item_code =
#{trainingItemCode},
</if>
<if test="trainingItemPrice != null">training_item_price =
#{trainingItemPrice},
</if>
<if test="trainingItemCoverUrl != null">training_item_cover_url =
#{trainingItemCoverUrl},
</if>
<if test="trainingItemPosterUrl != null">training_item_poster_url =
#{trainingItemPosterUrl},
</if>
<if test="trainingItemType != null">training_item_type =
#{trainingItemType},
</if>
<if test="trainingItemDetails != null">training_item_details =
#{trainingItemDetails},
</if>
<if test="trainingItemContent != null">training_item_content =
#{trainingItemContent},
</if>
<if test="trainingItemDate != null">training_item_date =
#{trainingItemDate},
</if>
<if test="trainingItemStartTime != null">training_item_start_time =
#{trainingItemStartTime},
</if>
<if test="trainingItemEndTime != null">training_item_end_time =
#{trainingItemEndTime},
</if>
<if test="trainingItemAddress != null">training_item_address =
#{trainingItemAddress},
</if>
<if test="trainingItemNotes != null">training_item_notes =
#{trainingItemNotes},
</if>
<if test="trainingItemSort != null">training_item_sort =
#{trainingItemSort},
</if>
<if test="buyFlag != null">buy_flag =
#{buyFlag},
</if>
<if test="trainingShelfFlag != null">training_shelf_flag =
#{trainingShelfFlag},
</if>
<if test="createBy != null">create_by =
#{createBy},
</if>
<if test="createTime != null">create_time =
#{createTime},
</if>
<if test="updateBy != null">update_by =
#{updateBy},
</if>
<if test="updateTime != null">update_time =
#{updateTime},
</if>
</trim>
where id = #{id}
</update>
<delete id="deleteTrainingItemById" parameterType="Long">
delete
from training_item
where id = #{id}
</delete>
<delete id="deleteTrainingItemByIds" parameterType="String">
delete from training_item where id in
<foreach item="id" collection="list" open="(" separator="," close=")">
#{id}
</foreach>
</delete>
<select id="selectTrainingItemAndCategoryList" parameterType="TrainingItem"
resultType="com.xinelu.manage.vo.trainingitem.TrainingItemAndCategoryVO">
select ti.id,
ti.training_item_title,
ti.training_parent_id,
ti.training_item_code,
ti.training_item_price,
ti.training_item_type,
ti.training_item_date,
ti.training_item_start_time,
ti.training_item_end_time,
ti.training_item_sort,
ti.training_shelf_flag,
tc.training_category_name
from training_item ti
left join training_category tc ON tc.id = ti.training_category_id
<where>
<if test="trainingParentId != null">
ti.training_parent_id = #{trainingParentId}
</if>
<if test="trainingCategoryId != null ">
and ti.training_category_id = #{trainingCategoryId}
</if>
<if test="trainingItemTitle != null and trainingItemTitle != ''">
and ti.training_item_title like concat('%', #{trainingItemTitle}, '%')
</if>
<if test="trainingItemCode != null and trainingItemCode != ''">
and ti.training_item_code = #{trainingItemCode}
</if>
<if test="trainingItemType != null and trainingItemType != ''">
and ti.training_item_type = #{trainingItemType}
</if>
<if test="trainingItemDate != null ">
and ti.training_item_date = #{trainingItemDate}
</if>
</where>
order by ti.id desc
</select>
<select id="selectTrainingLearnItemList"
parameterType="com.xinelu.manage.dto.trainingorder.NurseAppletPersonTrainingItemOrderDTO"
resultMap="NurseAppletPersonTrainingItemVOResult">
SELECT
ti.id trainingItemId,
ti.training_category_id,
ti.training_parent_id,
ti.training_item_title,
ti.training_item_code,
ti.training_item_price,
ti.training_item_cover_url,
ti.training_item_poster_url,
ti.training_item_type,
ti.training_item_details,
ti.training_item_content,
ti.training_item_date,
ti.training_item_start_time,
ti.training_item_end_time,
ti.training_item_address,
ti.training_item_notes,
ti.training_item_sort,
ti.buy_flag,
tid.id trainingItemDirectoryId,
tid.training_item_id,
tid.item_directory_name,
tid.item_directory_code,
tid.item_directory_title,
tid.item_directory_url,
tid.item_directory_video_duration,
tid.item_directory_introduce,
tid.item_directory_sort
FROM
training_item ti
LEFT JOIN training_item_directory tid ON tid.training_item_id = ti.id
<where>
<if test="trainingItemId != null ">
and ti.id = #{trainingItemId}
</if>
<if test="trainingParentId != null ">
OR ti.training_parent_id = #{trainingParentId}
</if>
</where>
</select>
<select id="selectTrainingLearnItemDetailsList"
parameterType="com.xinelu.manage.dto.trainingitem.NurseAppletPersonTrainingItemDTO"
resultMap="NurseAppletPersonTrainingItemVOResult">
SELECT
ti.id trainingItemId,
ti.training_category_id,
ti.training_parent_id,
ti.training_item_title,
ti.training_item_code,
ti.training_item_price,
ti.training_item_cover_url,
ti.training_item_poster_url,
ti.training_item_type,
ti.training_item_details,
ti.training_item_content,
ti.training_item_sort,
ti.buy_flag,
tid.id trainingItemDirectoryId,
tid.training_item_id,
tid.item_directory_name,
tid.item_directory_code,
tid.item_directory_title,
tid.item_directory_url,
tid.item_directory_video_duration,
tid.item_directory_introduce,
tid.item_directory_sort,
IF((SELECT COUNT( 1 ) FROM training_order_details tod
INNER JOIN training_order t ON tod.training_order_no = t.training_order_no
WHERE tod.training_item_id = ti.id
AND t.del_flag = 0
AND tod.del_flag = 0
AND t.nurse_station_person_id = #{nurseStationPersonId}
AND t.training_order_status = #{trainingOrderStatus}) > 0 , 'BUY' ,'NOT_BUY')
trainingOrderDetailsBuy
FROM
training_item ti
LEFT JOIN training_item_directory tid ON tid.training_item_id = ti.id
<where>
<if test="trainingItemId != null ">
and ti.id = #{trainingItemId}
</if>
<if test="trainingCategoryId != null ">
and ti.training_category_id = #{trainingCategoryId}
</if>
<if test="trainingParentId != null ">
and ti.training_parent_id = #{trainingParentId}
</if>
<if test="trainingItemType != null and trainingItemType != ''">
and ti.training_item_type = #{trainingItemType}
</if>
</where>
</select>
<select id="selectTrainingItemAndDirectoryById"
resultType="com.xinelu.manage.dto.trainingitem.TrainingItemAndDirectory"
resultMap="TrainingItemAndDirectoryResult">
select ti.id trainingItemId,
ti.training_category_id,
ti.training_parent_id,
ti.training_item_title,
ti.training_item_code,
ti.training_item_price,
ti.training_item_cover_url,
ti.training_item_poster_url,
ti.training_item_type,
ti.training_item_details,
ti.training_item_content,
ti.training_item_date,
ti.training_item_start_time,
ti.training_item_end_time,
ti.training_item_address,
ti.training_item_notes,
ti.training_item_sort,
ti.buy_flag,
tc.training_category_name,
tid.id trainingItemDirectoryId,
tid.item_directory_name,
tid.item_directory_title,
tid.item_directory_url,
tid.item_directory_introduce,
tid.item_directory_sort,
(select training_item_title from training_item where id = ti.training_parent_id) trainingParentName
from training_item ti
LEFT JOIN training_item_directory tid ON ti.id = tid.training_item_id
LEFT JOIN training_category tc ON tc.id = ti.training_category_id
where ti.id = #{id}
</select>
<select id="selectTrainingItemByIdList" parameterType="Long"
resultMap="TrainingItemResult">
<include refid="selectTrainingItemVo"/>
<where>
<if test="trainingItemIdList != null and trainingItemIdList.size() > 0">
and training_parent_id in
<foreach item="trainingItemIdList" collection="trainingItemIdList" open="(" separator=","
close=")">
#{trainingItemIdList}
</foreach>
</if>
</where>
</select>
<select id="selectTrainingItemAndDirectoryList"
resultType="com.xinelu.manage.dto.trainingitem.TrainingItemAndDirectory"
resultMap="TrainingItemAndDirectoryResult">
select
ti.id trainingItemId,
ti.training_item_title,
ti.training_item_cover_url,
ti.training_item_poster_url,
ti.training_item_content,
tid.item_directory_url
from training_item ti
LEFT JOIN training_item_directory tid ON ti.id = tid.training_item_id
<where>
<if test="ids != null and ids.length > 0">
ti.id in
<foreach item="ids" collection="ids" open="(" separator="," close=")">
#{ids}
</foreach>
</if>
<if test="trainingParentIds != null and trainingParentIds.length > 0">
and ti.training_parent_id in
<foreach item="trainingParentIds" collection="trainingParentIds" open="(" separator="," close=")">
#{trainingParentIds}
</foreach>
</if>
</where>
</select>
<select id="selectTrainingItems" resultType="com.xinelu.manage.vo.trainingitem.TrainingItemAndCategoryVO">
select id,
training_parent_id,
training_item_title trainingParentName,
training_item_code,
training_item_price,
training_item_type,
buy_flag
from training_item
<where>
<if test="id != null">
and id &lt;&gt; #{id}
</if>
<if test="trainingItemCode != null and trainingItemCode != ''">
and training_item_code = #{trainingItemCode}
</if>
<if test="trainingItemType != null and trainingItemType != ''">
and training_item_type = #{trainingItemType}
</if>
<if test="trainingParentName != null and trainingParentName != ''">
and training_item_title like concat('%', #{trainingParentName}, '%')
</if>
AND training_parent_id = 0
</where>
</select>
<select id="getTrainingItemList" parameterType="com.xinelu.manage.dto.trainingitem.TrainingItemDTO"
resultType="com.xinelu.manage.vo.trainingitem.TrainingItemVO">
SELECT
ti.id,
ti.training_parent_id,
ti.training_item_title,
ti.training_item_code,
ti.training_item_price,
ti.training_item_cover_url,
ti.training_item_poster_url,
ti.training_item_type,
ti.training_item_details,
ti.training_item_content,
ti.training_item_sort,
ti.buy_flag,
ti.training_shelf_flag,
IF((SELECT COUNT( 1 ) FROM training_order_details tod
INNER JOIN training_order t ON tod.training_order_no = t.training_order_no
WHERE tod.training_item_id = ti.id
AND t.del_flag = 0
AND tod.del_flag = 0
AND t.nurse_station_person_id = #{nurseStationPersonId}
AND t.training_order_status = #{trainingOrderStatus}) > 0 , 'BUY' ,'NOT_BUY')
trainingOrderDetailsBuy
FROM
training_item ti
<where>
<if test="id != null ">
and ti.id = #{id}
</if>
<if test="trainingParentId != null ">
and ti.training_parent_id = #{trainingParentId}
</if>
<if test="trainingShelfFlag != null ">
and ti.training_shelf_flag = #{trainingShelfFlag}
</if>
<if test="buyFlag != null ">
and ti.buy_flag = #{buyFlag}
</if>
<if test="trainingItemType != null and trainingItemType != ''">
and ti.training_item_type &lt;&gt; #{trainingItemType}
</if>
</where>
ORDER BY
ti.training_item_sort
</select>
<update id="updateTrainingItems" parameterType="TrainingItem">
update training_item
<trim prefix="SET" suffixOverrides=",">
<if test="trainingCategoryId != null">training_category_id =
#{trainingCategoryId},
</if>
<if test="trainingParentId != null">training_parent_id =
#{trainingParentId},
</if>
<if test="trainingItemTitle != null">training_item_title =
#{trainingItemTitle},
</if>
<if test="trainingItemCode != null">training_item_code =
#{trainingItemCode},
</if>
training_item_price = #{trainingItemPrice},
<if test="trainingItemCoverUrl != null">training_item_cover_url =
#{trainingItemCoverUrl},
</if>
<if test="trainingItemPosterUrl != null">training_item_poster_url =
#{trainingItemPosterUrl},
</if>
<if test="trainingItemType != null">training_item_type =
#{trainingItemType},
</if>
<if test="trainingItemDetails != null">training_item_details =
#{trainingItemDetails},
</if>
<if test="trainingItemContent != null">training_item_content =
#{trainingItemContent},
</if>
<if test="trainingItemDate != null">training_item_date =
#{trainingItemDate},
</if>
<if test="trainingItemStartTime != null">training_item_start_time =
#{trainingItemStartTime},
</if>
<if test="trainingItemEndTime != null">training_item_end_time =
#{trainingItemEndTime},
</if>
<if test="trainingItemAddress != null">training_item_address =
#{trainingItemAddress},
</if>
<if test="trainingItemNotes != null">training_item_notes =
#{trainingItemNotes},
</if>
training_item_sort = #{trainingItemSort},
buy_flag = #{buyFlag},
<if test="trainingShelfFlag != null">training_shelf_flag =
#{trainingShelfFlag},
</if>
<if test="createBy != null">create_by =
#{createBy},
</if>
<if test="createTime != null">create_time =
#{createTime},
</if>
<if test="updateBy != null">update_by =
#{updateBy},
</if>
<if test="updateTime != null">update_time =
#{updateTime},
</if>
</trim>
where id = #{id}
</update>
<update id="updateTrainingItemList">
update training_item
set training_shelf_flag = #{trainingShelfFlag}
where training_parent_id = #{trainingParentId}
</update>
</mapper>