feat:生成代码

dev
username 1 month ago
parent 1762b676b6
commit dcd9c68117

@ -0,0 +1,189 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtGalleryCata;
import com.bs.ct.service.ICtGalleryCataService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "图库目录")
@RestController
@RequestMapping("/gallery/cata")
public class CtGalleryCataController extends BaseController {
@Resource
private ICtGalleryCataService ctGalleryCataService;
/**
*
*/
@ApiOperation("分页查询图库目录列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtGalleryCata ctGalleryCata) {
startPage();
LambdaQueryWrapper<CtGalleryCata> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryCata);
List<CtGalleryCata> list = ctGalleryCataService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询图库目录列表")
@GetMapping("/list")
public AjaxResult list(CtGalleryCata ctGalleryCata) {
LambdaQueryWrapper<CtGalleryCata> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryCata);
List<CtGalleryCata> list = ctGalleryCataService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出图库目录列表")
@Log(title = "图库目录导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtGalleryCata ctGalleryCata) {
LambdaQueryWrapper<CtGalleryCata> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryCata);
List<CtGalleryCata> list = ctGalleryCataService.list(queryWrapper);
ExcelUtil<CtGalleryCata> util = new ExcelUtil<CtGalleryCata>(CtGalleryCata. class);
util.exportExcel(response, list, "图库目录数据");
}
/**
*
*/
@ApiOperation("获取图库目录详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctGalleryCataService.getById(id));
}
/**
*
*/
@ApiOperation("新增图库目录")
@Log(title = "图库目录新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtGalleryCata ctGalleryCata) {
return toAjax(ctGalleryCataService.save(ctGalleryCata));
}
/**
*
*/
@ApiOperation("修改图库目录")
@Log(title = "图库目录修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtGalleryCata ctGalleryCata) {
return toAjax(ctGalleryCataService.updateById(ctGalleryCata));
}
/**
*
*/
@ApiOperation("删除图库目录")
@Log(title = "图库目录删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctGalleryCataService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtGalleryCata> queryWrapper,CtGalleryCata ctGalleryCata){
//id
if(Validator.isNotEmpty(ctGalleryCata.getId())){
queryWrapper.eq(CtGalleryCata::getId,ctGalleryCata.getId());
}
//目录名称
if(Validator.isNotEmpty(ctGalleryCata.getCataName())){
queryWrapper.eq(CtGalleryCata::getCataName,ctGalleryCata.getCataName());
}
//父级id
if(Validator.isNotEmpty(ctGalleryCata.getParentId())){
queryWrapper.eq(CtGalleryCata::getParentId,ctGalleryCata.getParentId());
}
//类型
if(Validator.isNotEmpty(ctGalleryCata.getType())){
queryWrapper.eq(CtGalleryCata::getType,ctGalleryCata.getType());
}
//备注
if(Validator.isNotEmpty(ctGalleryCata.getRemarks())){
queryWrapper.eq(CtGalleryCata::getRemarks,ctGalleryCata.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctGalleryCata.getDelFlag())){
queryWrapper.eq(CtGalleryCata::getDelFlag,ctGalleryCata.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctGalleryCata.getCreateDept())){
queryWrapper.eq(CtGalleryCata::getCreateDept,ctGalleryCata.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctGalleryCata.getCreateBy())){
queryWrapper.eq(CtGalleryCata::getCreateBy,ctGalleryCata.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctGalleryCata.getCreateTime())){
queryWrapper.eq(CtGalleryCata::getCreateTime,ctGalleryCata.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctGalleryCata.getUpdateBy())){
queryWrapper.eq(CtGalleryCata::getUpdateBy,ctGalleryCata.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctGalleryCata.getUpdateTime())){
queryWrapper.eq(CtGalleryCata::getUpdateTime,ctGalleryCata.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctGalleryCata.getTenantId())){
queryWrapper.eq(CtGalleryCata::getTenantId,ctGalleryCata.getTenantId());
}
}
}

@ -0,0 +1,199 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtGalleryCataShare;
import com.bs.ct.service.ICtGalleryCataShareService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "图库目录共享")
@RestController
@RequestMapping("/gallery/cata/share")
public class CtGalleryCataShareController extends BaseController {
@Resource
private ICtGalleryCataShareService ctGalleryCataShareService;
/**
*
*/
@ApiOperation("分页查询图库目录共享列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtGalleryCataShare ctGalleryCataShare) {
startPage();
LambdaQueryWrapper<CtGalleryCataShare> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryCataShare);
List<CtGalleryCataShare> list = ctGalleryCataShareService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询图库目录共享列表")
@GetMapping("/list")
public AjaxResult list(CtGalleryCataShare ctGalleryCataShare) {
LambdaQueryWrapper<CtGalleryCataShare> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryCataShare);
List<CtGalleryCataShare> list = ctGalleryCataShareService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出图库目录共享列表")
@Log(title = "图库目录共享导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtGalleryCataShare ctGalleryCataShare) {
LambdaQueryWrapper<CtGalleryCataShare> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryCataShare);
List<CtGalleryCataShare> list = ctGalleryCataShareService.list(queryWrapper);
ExcelUtil<CtGalleryCataShare> util = new ExcelUtil<CtGalleryCataShare>(CtGalleryCataShare. class);
util.exportExcel(response, list, "图库目录共享数据");
}
/**
*
*/
@ApiOperation("获取图库目录共享详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctGalleryCataShareService.getById(id));
}
/**
*
*/
@ApiOperation("新增图库目录共享")
@Log(title = "图库目录共享新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtGalleryCataShare ctGalleryCataShare) {
return toAjax(ctGalleryCataShareService.save(ctGalleryCataShare));
}
/**
*
*/
@ApiOperation("修改图库目录共享")
@Log(title = "图库目录共享修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtGalleryCataShare ctGalleryCataShare) {
return toAjax(ctGalleryCataShareService.updateById(ctGalleryCataShare));
}
/**
*
*/
@ApiOperation("删除图库目录共享")
@Log(title = "图库目录共享删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctGalleryCataShareService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtGalleryCataShare> queryWrapper,CtGalleryCataShare ctGalleryCataShare){
//id
if(Validator.isNotEmpty(ctGalleryCataShare.getId())){
queryWrapper.eq(CtGalleryCataShare::getId,ctGalleryCataShare.getId());
}
//共享类型目录共享、图片共享
if(Validator.isNotEmpty(ctGalleryCataShare.getType())){
queryWrapper.eq(CtGalleryCataShare::getType,ctGalleryCataShare.getType());
}
//目录id
if(Validator.isNotEmpty(ctGalleryCataShare.getCataId())){
queryWrapper.eq(CtGalleryCataShare::getCataId,ctGalleryCataShare.getCataId());
}
//共享用户
if(Validator.isNotEmpty(ctGalleryCataShare.getUserId())){
queryWrapper.eq(CtGalleryCataShare::getUserId,ctGalleryCataShare.getUserId());
}
//开始时间
if(Validator.isNotEmpty(ctGalleryCataShare.getBeginDate())){
queryWrapper.eq(CtGalleryCataShare::getBeginDate,ctGalleryCataShare.getBeginDate());
}
//结束时间
if(Validator.isNotEmpty(ctGalleryCataShare.getEndDate())){
queryWrapper.eq(CtGalleryCataShare::getEndDate,ctGalleryCataShare.getEndDate());
}
//备注
if(Validator.isNotEmpty(ctGalleryCataShare.getRemarks())){
queryWrapper.eq(CtGalleryCataShare::getRemarks,ctGalleryCataShare.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctGalleryCataShare.getDelFlag())){
queryWrapper.eq(CtGalleryCataShare::getDelFlag,ctGalleryCataShare.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctGalleryCataShare.getCreateDept())){
queryWrapper.eq(CtGalleryCataShare::getCreateDept,ctGalleryCataShare.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctGalleryCataShare.getCreateBy())){
queryWrapper.eq(CtGalleryCataShare::getCreateBy,ctGalleryCataShare.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctGalleryCataShare.getCreateTime())){
queryWrapper.eq(CtGalleryCataShare::getCreateTime,ctGalleryCataShare.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctGalleryCataShare.getUpdateBy())){
queryWrapper.eq(CtGalleryCataShare::getUpdateBy,ctGalleryCataShare.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctGalleryCataShare.getUpdateTime())){
queryWrapper.eq(CtGalleryCataShare::getUpdateTime,ctGalleryCataShare.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctGalleryCataShare.getTenantId())){
queryWrapper.eq(CtGalleryCataShare::getTenantId,ctGalleryCataShare.getTenantId());
}
}
}

@ -0,0 +1,224 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtGalleryImages;
import com.bs.ct.service.ICtGalleryImagesService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "图库图片")
@RestController
@RequestMapping("/gallery/images")
public class CtGalleryImagesController extends BaseController {
@Resource
private ICtGalleryImagesService ctGalleryImagesService;
/**
*
*/
@ApiOperation("分页查询图库图片列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtGalleryImages ctGalleryImages) {
startPage();
LambdaQueryWrapper<CtGalleryImages> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryImages);
List<CtGalleryImages> list = ctGalleryImagesService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询图库图片列表")
@GetMapping("/list")
public AjaxResult list(CtGalleryImages ctGalleryImages) {
LambdaQueryWrapper<CtGalleryImages> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryImages);
List<CtGalleryImages> list = ctGalleryImagesService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出图库图片列表")
@Log(title = "图库图片导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtGalleryImages ctGalleryImages) {
LambdaQueryWrapper<CtGalleryImages> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryImages);
List<CtGalleryImages> list = ctGalleryImagesService.list(queryWrapper);
ExcelUtil<CtGalleryImages> util = new ExcelUtil<CtGalleryImages>(CtGalleryImages. class);
util.exportExcel(response, list, "图库图片数据");
}
/**
*
*/
@ApiOperation("获取图库图片详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctGalleryImagesService.getById(id));
}
/**
*
*/
@ApiOperation("新增图库图片")
@Log(title = "图库图片新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtGalleryImages ctGalleryImages) {
return toAjax(ctGalleryImagesService.save(ctGalleryImages));
}
/**
*
*/
@ApiOperation("修改图库图片")
@Log(title = "图库图片修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtGalleryImages ctGalleryImages) {
return toAjax(ctGalleryImagesService.updateById(ctGalleryImages));
}
/**
*
*/
@ApiOperation("删除图库图片")
@Log(title = "图库图片删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctGalleryImagesService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtGalleryImages> queryWrapper,CtGalleryImages ctGalleryImages){
//id
if(Validator.isNotEmpty(ctGalleryImages.getId())){
queryWrapper.eq(CtGalleryImages::getId,ctGalleryImages.getId());
}
//目录id
if(Validator.isNotEmpty(ctGalleryImages.getCataId())){
queryWrapper.eq(CtGalleryImages::getCataId,ctGalleryImages.getCataId());
}
//图片名称
if(Validator.isNotEmpty(ctGalleryImages.getImageName())){
queryWrapper.eq(CtGalleryImages::getImageName,ctGalleryImages.getImageName());
}
//图片标题
if(Validator.isNotEmpty(ctGalleryImages.getImageTitle())){
queryWrapper.eq(CtGalleryImages::getImageTitle,ctGalleryImages.getImageTitle());
}
//图片路径
if(Validator.isNotEmpty(ctGalleryImages.getImagePath())){
queryWrapper.eq(CtGalleryImages::getImagePath,ctGalleryImages.getImagePath());
}
//图片大小
if(Validator.isNotEmpty(ctGalleryImages.getImageSize())){
queryWrapper.eq(CtGalleryImages::getImageSize,ctGalleryImages.getImageSize());
}
//图片拍摄时间
if(Validator.isNotEmpty(ctGalleryImages.getPhotoTime())){
queryWrapper.eq(CtGalleryImages::getPhotoTime,ctGalleryImages.getPhotoTime());
}
//图片上传时间
if(Validator.isNotEmpty(ctGalleryImages.getUploadTime())){
queryWrapper.eq(CtGalleryImages::getUploadTime,ctGalleryImages.getUploadTime());
}
//是否公开
if(Validator.isNotEmpty(ctGalleryImages.getIsOpen())){
queryWrapper.eq(CtGalleryImages::getIsOpen,ctGalleryImages.getIsOpen());
}
//图片关键字
if(Validator.isNotEmpty(ctGalleryImages.getKeyWords())){
queryWrapper.eq(CtGalleryImages::getKeyWords,ctGalleryImages.getKeyWords());
}
//附件id
if(Validator.isNotEmpty(ctGalleryImages.getFileId())){
queryWrapper.eq(CtGalleryImages::getFileId,ctGalleryImages.getFileId());
}
//备注
if(Validator.isNotEmpty(ctGalleryImages.getRemarks())){
queryWrapper.eq(CtGalleryImages::getRemarks,ctGalleryImages.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctGalleryImages.getDelFlag())){
queryWrapper.eq(CtGalleryImages::getDelFlag,ctGalleryImages.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctGalleryImages.getCreateDept())){
queryWrapper.eq(CtGalleryImages::getCreateDept,ctGalleryImages.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctGalleryImages.getCreateBy())){
queryWrapper.eq(CtGalleryImages::getCreateBy,ctGalleryImages.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctGalleryImages.getCreateTime())){
queryWrapper.eq(CtGalleryImages::getCreateTime,ctGalleryImages.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctGalleryImages.getUpdateBy())){
queryWrapper.eq(CtGalleryImages::getUpdateBy,ctGalleryImages.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctGalleryImages.getUpdateTime())){
queryWrapper.eq(CtGalleryImages::getUpdateTime,ctGalleryImages.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctGalleryImages.getTenantId())){
queryWrapper.eq(CtGalleryImages::getTenantId,ctGalleryImages.getTenantId());
}
}
}

@ -0,0 +1,184 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtGalleryImagesTag;
import com.bs.ct.service.ICtGalleryImagesTagService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "图库图片标签")
@RestController
@RequestMapping("/gallery/images/tag")
public class CtGalleryImagesTagController extends BaseController {
@Resource
private ICtGalleryImagesTagService ctGalleryImagesTagService;
/**
*
*/
@ApiOperation("分页查询图库图片标签列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtGalleryImagesTag ctGalleryImagesTag) {
startPage();
LambdaQueryWrapper<CtGalleryImagesTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryImagesTag);
List<CtGalleryImagesTag> list = ctGalleryImagesTagService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询图库图片标签列表")
@GetMapping("/list")
public AjaxResult list(CtGalleryImagesTag ctGalleryImagesTag) {
LambdaQueryWrapper<CtGalleryImagesTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryImagesTag);
List<CtGalleryImagesTag> list = ctGalleryImagesTagService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出图库图片标签列表")
@Log(title = "图库图片标签导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtGalleryImagesTag ctGalleryImagesTag) {
LambdaQueryWrapper<CtGalleryImagesTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctGalleryImagesTag);
List<CtGalleryImagesTag> list = ctGalleryImagesTagService.list(queryWrapper);
ExcelUtil<CtGalleryImagesTag> util = new ExcelUtil<CtGalleryImagesTag>(CtGalleryImagesTag. class);
util.exportExcel(response, list, "图库图片标签数据");
}
/**
*
*/
@ApiOperation("获取图库图片标签详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctGalleryImagesTagService.getById(id));
}
/**
*
*/
@ApiOperation("新增图库图片标签")
@Log(title = "图库图片标签新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtGalleryImagesTag ctGalleryImagesTag) {
return toAjax(ctGalleryImagesTagService.save(ctGalleryImagesTag));
}
/**
*
*/
@ApiOperation("修改图库图片标签")
@Log(title = "图库图片标签修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtGalleryImagesTag ctGalleryImagesTag) {
return toAjax(ctGalleryImagesTagService.updateById(ctGalleryImagesTag));
}
/**
*
*/
@ApiOperation("删除图库图片标签")
@Log(title = "图库图片标签删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctGalleryImagesTagService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtGalleryImagesTag> queryWrapper,CtGalleryImagesTag ctGalleryImagesTag){
//id
if(Validator.isNotEmpty(ctGalleryImagesTag.getId())){
queryWrapper.eq(CtGalleryImagesTag::getId,ctGalleryImagesTag.getId());
}
//图片id
if(Validator.isNotEmpty(ctGalleryImagesTag.getImageId())){
queryWrapper.eq(CtGalleryImagesTag::getImageId,ctGalleryImagesTag.getImageId());
}
//标签名称
if(Validator.isNotEmpty(ctGalleryImagesTag.getTagName())){
queryWrapper.eq(CtGalleryImagesTag::getTagName,ctGalleryImagesTag.getTagName());
}
//备注
if(Validator.isNotEmpty(ctGalleryImagesTag.getRemarks())){
queryWrapper.eq(CtGalleryImagesTag::getRemarks,ctGalleryImagesTag.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctGalleryImagesTag.getDelFlag())){
queryWrapper.eq(CtGalleryImagesTag::getDelFlag,ctGalleryImagesTag.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctGalleryImagesTag.getCreateDept())){
queryWrapper.eq(CtGalleryImagesTag::getCreateDept,ctGalleryImagesTag.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctGalleryImagesTag.getCreateBy())){
queryWrapper.eq(CtGalleryImagesTag::getCreateBy,ctGalleryImagesTag.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctGalleryImagesTag.getCreateTime())){
queryWrapper.eq(CtGalleryImagesTag::getCreateTime,ctGalleryImagesTag.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctGalleryImagesTag.getUpdateBy())){
queryWrapper.eq(CtGalleryImagesTag::getUpdateBy,ctGalleryImagesTag.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctGalleryImagesTag.getUpdateTime())){
queryWrapper.eq(CtGalleryImagesTag::getUpdateTime,ctGalleryImagesTag.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctGalleryImagesTag.getTenantId())){
queryWrapper.eq(CtGalleryImagesTag::getTenantId,ctGalleryImagesTag.getTenantId());
}
}
}

@ -0,0 +1,204 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtTag;
import com.bs.ct.service.ICtTagService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "标签信息")
@RestController
@RequestMapping("/system/tag")
public class CtTagController extends BaseController {
@Resource
private ICtTagService ctTagService;
/**
*
*/
@ApiOperation("分页查询标签信息列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtTag ctTag) {
startPage();
LambdaQueryWrapper<CtTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTag);
List<CtTag> list = ctTagService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询标签信息列表")
@GetMapping("/list")
public AjaxResult list(CtTag ctTag) {
LambdaQueryWrapper<CtTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTag);
List<CtTag> list = ctTagService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出标签信息列表")
@Log(title = "标签信息导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtTag ctTag) {
LambdaQueryWrapper<CtTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTag);
List<CtTag> list = ctTagService.list(queryWrapper);
ExcelUtil<CtTag> util = new ExcelUtil<CtTag>(CtTag. class);
util.exportExcel(response, list, "标签信息数据");
}
/**
*
*/
@ApiOperation("获取标签信息详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctTagService.getById(id));
}
/**
*
*/
@ApiOperation("新增标签信息")
@Log(title = "标签信息新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtTag ctTag) {
return toAjax(ctTagService.save(ctTag));
}
/**
*
*/
@ApiOperation("修改标签信息")
@Log(title = "标签信息修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtTag ctTag) {
return toAjax(ctTagService.updateById(ctTag));
}
/**
*
*/
@ApiOperation("删除标签信息")
@Log(title = "标签信息删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctTagService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtTag> queryWrapper,CtTag ctTag){
//id
if(Validator.isNotEmpty(ctTag.getId())){
queryWrapper.eq(CtTag::getId,ctTag.getId());
}
//标签名称
if(Validator.isNotEmpty(ctTag.getTagName())){
queryWrapper.eq(CtTag::getTagName,ctTag.getTagName());
}
//标签说明
if(Validator.isNotEmpty(ctTag.getTagDesc())){
queryWrapper.eq(CtTag::getTagDesc,ctTag.getTagDesc());
}
//是否需要拍照
if(Validator.isNotEmpty(ctTag.getIsPhoto())){
queryWrapper.eq(CtTag::getIsPhoto,ctTag.getIsPhoto());
}
//拍照数量要求
if(Validator.isNotEmpty(ctTag.getPhotoNum())){
queryWrapper.eq(CtTag::getPhotoNum,ctTag.getPhotoNum());
}
//照片存放目录
if(Validator.isNotEmpty(ctTag.getSaveDir())){
queryWrapper.eq(CtTag::getSaveDir,ctTag.getSaveDir());
}
//附件id
if(Validator.isNotEmpty(ctTag.getFileId())){
queryWrapper.eq(CtTag::getFileId,ctTag.getFileId());
}
//备注
if(Validator.isNotEmpty(ctTag.getRemarks())){
queryWrapper.eq(CtTag::getRemarks,ctTag.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctTag.getDelFlag())){
queryWrapper.eq(CtTag::getDelFlag,ctTag.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctTag.getCreateDept())){
queryWrapper.eq(CtTag::getCreateDept,ctTag.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctTag.getCreateBy())){
queryWrapper.eq(CtTag::getCreateBy,ctTag.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctTag.getCreateTime())){
queryWrapper.eq(CtTag::getCreateTime,ctTag.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctTag.getUpdateBy())){
queryWrapper.eq(CtTag::getUpdateBy,ctTag.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctTag.getUpdateTime())){
queryWrapper.eq(CtTag::getUpdateTime,ctTag.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctTag.getTenantId())){
queryWrapper.eq(CtTag::getTenantId,ctTag.getTenantId());
}
}
}

@ -0,0 +1,199 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtTaskBranch;
import com.bs.ct.service.ICtTaskBranchService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "任务机构信息")
@RestController
@RequestMapping("/task/branch")
public class CtTaskBranchController extends BaseController {
@Resource
private ICtTaskBranchService ctTaskBranchService;
/**
*
*/
@ApiOperation("分页查询任务机构信息列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtTaskBranch ctTaskBranch) {
startPage();
LambdaQueryWrapper<CtTaskBranch> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskBranch);
List<CtTaskBranch> list = ctTaskBranchService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询任务机构信息列表")
@GetMapping("/list")
public AjaxResult list(CtTaskBranch ctTaskBranch) {
LambdaQueryWrapper<CtTaskBranch> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskBranch);
List<CtTaskBranch> list = ctTaskBranchService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出任务机构信息列表")
@Log(title = "任务机构信息导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtTaskBranch ctTaskBranch) {
LambdaQueryWrapper<CtTaskBranch> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskBranch);
List<CtTaskBranch> list = ctTaskBranchService.list(queryWrapper);
ExcelUtil<CtTaskBranch> util = new ExcelUtil<CtTaskBranch>(CtTaskBranch. class);
util.exportExcel(response, list, "任务机构信息数据");
}
/**
*
*/
@ApiOperation("获取任务机构信息详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctTaskBranchService.getById(id));
}
/**
*
*/
@ApiOperation("新增任务机构信息")
@Log(title = "任务机构信息新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtTaskBranch ctTaskBranch) {
return toAjax(ctTaskBranchService.save(ctTaskBranch));
}
/**
*
*/
@ApiOperation("修改任务机构信息")
@Log(title = "任务机构信息修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtTaskBranch ctTaskBranch) {
return toAjax(ctTaskBranchService.updateById(ctTaskBranch));
}
/**
*
*/
@ApiOperation("删除任务机构信息")
@Log(title = "任务机构信息删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctTaskBranchService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtTaskBranch> queryWrapper,CtTaskBranch ctTaskBranch){
//id
if(Validator.isNotEmpty(ctTaskBranch.getId())){
queryWrapper.eq(CtTaskBranch::getId,ctTaskBranch.getId());
}
//任务id
if(Validator.isNotEmpty(ctTaskBranch.getTaskId())){
queryWrapper.eq(CtTaskBranch::getTaskId,ctTaskBranch.getTaskId());
}
//类型人员、机构
if(Validator.isNotEmpty(ctTaskBranch.getType())){
queryWrapper.eq(CtTaskBranch::getType,ctTaskBranch.getType());
}
//机构代码
if(Validator.isNotEmpty(ctTaskBranch.getBranchCode())){
queryWrapper.eq(CtTaskBranch::getBranchCode,ctTaskBranch.getBranchCode());
}
//机构名称
if(Validator.isNotEmpty(ctTaskBranch.getBranchName())){
queryWrapper.eq(CtTaskBranch::getBranchName,ctTaskBranch.getBranchName());
}
//任务状态
if(Validator.isNotEmpty(ctTaskBranch.getTaskStatus())){
queryWrapper.eq(CtTaskBranch::getTaskStatus,ctTaskBranch.getTaskStatus());
}
//备注
if(Validator.isNotEmpty(ctTaskBranch.getRemarks())){
queryWrapper.eq(CtTaskBranch::getRemarks,ctTaskBranch.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctTaskBranch.getDelFlag())){
queryWrapper.eq(CtTaskBranch::getDelFlag,ctTaskBranch.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctTaskBranch.getCreateDept())){
queryWrapper.eq(CtTaskBranch::getCreateDept,ctTaskBranch.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctTaskBranch.getCreateBy())){
queryWrapper.eq(CtTaskBranch::getCreateBy,ctTaskBranch.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctTaskBranch.getCreateTime())){
queryWrapper.eq(CtTaskBranch::getCreateTime,ctTaskBranch.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctTaskBranch.getUpdateBy())){
queryWrapper.eq(CtTaskBranch::getUpdateBy,ctTaskBranch.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctTaskBranch.getUpdateTime())){
queryWrapper.eq(CtTaskBranch::getUpdateTime,ctTaskBranch.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctTaskBranch.getTenantId())){
queryWrapper.eq(CtTaskBranch::getTenantId,ctTaskBranch.getTenantId());
}
}
}

@ -0,0 +1,254 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtTaskFeedback;
import com.bs.ct.service.ICtTaskFeedbackService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "任务反馈")
@RestController
@RequestMapping("/task/feedback")
public class CtTaskFeedbackController extends BaseController {
@Resource
private ICtTaskFeedbackService ctTaskFeedbackService;
/**
*
*/
@ApiOperation("分页查询任务反馈列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtTaskFeedback ctTaskFeedback) {
startPage();
LambdaQueryWrapper<CtTaskFeedback> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskFeedback);
List<CtTaskFeedback> list = ctTaskFeedbackService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询任务反馈列表")
@GetMapping("/list")
public AjaxResult list(CtTaskFeedback ctTaskFeedback) {
LambdaQueryWrapper<CtTaskFeedback> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskFeedback);
List<CtTaskFeedback> list = ctTaskFeedbackService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出任务反馈列表")
@Log(title = "任务反馈导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtTaskFeedback ctTaskFeedback) {
LambdaQueryWrapper<CtTaskFeedback> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskFeedback);
List<CtTaskFeedback> list = ctTaskFeedbackService.list(queryWrapper);
ExcelUtil<CtTaskFeedback> util = new ExcelUtil<CtTaskFeedback>(CtTaskFeedback. class);
util.exportExcel(response, list, "任务反馈数据");
}
/**
*
*/
@ApiOperation("获取任务反馈详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctTaskFeedbackService.getById(id));
}
/**
*
*/
@ApiOperation("新增任务反馈")
@Log(title = "任务反馈新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtTaskFeedback ctTaskFeedback) {
return toAjax(ctTaskFeedbackService.save(ctTaskFeedback));
}
/**
*
*/
@ApiOperation("修改任务反馈")
@Log(title = "任务反馈修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtTaskFeedback ctTaskFeedback) {
return toAjax(ctTaskFeedbackService.updateById(ctTaskFeedback));
}
/**
*
*/
@ApiOperation("删除任务反馈")
@Log(title = "任务反馈删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctTaskFeedbackService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtTaskFeedback> queryWrapper,CtTaskFeedback ctTaskFeedback){
//id
if(Validator.isNotEmpty(ctTaskFeedback.getId())){
queryWrapper.eq(CtTaskFeedback::getId,ctTaskFeedback.getId());
}
//任务id
if(Validator.isNotEmpty(ctTaskFeedback.getTaskId())){
queryWrapper.eq(CtTaskFeedback::getTaskId,ctTaskFeedback.getTaskId());
}
//机构任务id
if(Validator.isNotEmpty(ctTaskFeedback.getTaskBranchId())){
queryWrapper.eq(CtTaskFeedback::getTaskBranchId,ctTaskFeedback.getTaskBranchId());
}
//机构代码
if(Validator.isNotEmpty(ctTaskFeedback.getBranchCode())){
queryWrapper.eq(CtTaskFeedback::getBranchCode,ctTaskFeedback.getBranchCode());
}
//任务反馈时间
if(Validator.isNotEmpty(ctTaskFeedback.getFeedbackTime())){
queryWrapper.eq(CtTaskFeedback::getFeedbackTime,ctTaskFeedback.getFeedbackTime());
}
//任务完成情况
if(Validator.isNotEmpty(ctTaskFeedback.getTaskDesc())){
queryWrapper.eq(CtTaskFeedback::getTaskDesc,ctTaskFeedback.getTaskDesc());
}
//操作人员工号
if(Validator.isNotEmpty(ctTaskFeedback.getUserId())){
queryWrapper.eq(CtTaskFeedback::getUserId,ctTaskFeedback.getUserId());
}
//操作人员姓名
if(Validator.isNotEmpty(ctTaskFeedback.getUserName())){
queryWrapper.eq(CtTaskFeedback::getUserName,ctTaskFeedback.getUserName());
}
//操作人员部门
if(Validator.isNotEmpty(ctTaskFeedback.getUserDept())){
queryWrapper.eq(CtTaskFeedback::getUserDept,ctTaskFeedback.getUserDept());
}
//是否已拍照留存
if(Validator.isNotEmpty(ctTaskFeedback.getIsPhoto())){
queryWrapper.eq(CtTaskFeedback::getIsPhoto,ctTaskFeedback.getIsPhoto());
}
//附件id
if(Validator.isNotEmpty(ctTaskFeedback.getFileId())){
queryWrapper.eq(CtTaskFeedback::getFileId,ctTaskFeedback.getFileId());
}
//审核人员id
if(Validator.isNotEmpty(ctTaskFeedback.getCheckUserId())){
queryWrapper.eq(CtTaskFeedback::getCheckUserId,ctTaskFeedback.getCheckUserId());
}
//审核人员姓名
if(Validator.isNotEmpty(ctTaskFeedback.getCheckUserName())){
queryWrapper.eq(CtTaskFeedback::getCheckUserName,ctTaskFeedback.getCheckUserName());
}
//审核人员部门
if(Validator.isNotEmpty(ctTaskFeedback.getCheckUserDept())){
queryWrapper.eq(CtTaskFeedback::getCheckUserDept,ctTaskFeedback.getCheckUserDept());
}
//审核时间
if(Validator.isNotEmpty(ctTaskFeedback.getCheckDate())){
queryWrapper.eq(CtTaskFeedback::getCheckDate,ctTaskFeedback.getCheckDate());
}
//审核状态
if(Validator.isNotEmpty(ctTaskFeedback.getStatus())){
queryWrapper.eq(CtTaskFeedback::getStatus,ctTaskFeedback.getStatus());
}
//审核信息
if(Validator.isNotEmpty(ctTaskFeedback.getCheckInfo())){
queryWrapper.eq(CtTaskFeedback::getCheckInfo,ctTaskFeedback.getCheckInfo());
}
//备注
if(Validator.isNotEmpty(ctTaskFeedback.getRemarks())){
queryWrapper.eq(CtTaskFeedback::getRemarks,ctTaskFeedback.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctTaskFeedback.getDelFlag())){
queryWrapper.eq(CtTaskFeedback::getDelFlag,ctTaskFeedback.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctTaskFeedback.getCreateDept())){
queryWrapper.eq(CtTaskFeedback::getCreateDept,ctTaskFeedback.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctTaskFeedback.getCreateBy())){
queryWrapper.eq(CtTaskFeedback::getCreateBy,ctTaskFeedback.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctTaskFeedback.getCreateTime())){
queryWrapper.eq(CtTaskFeedback::getCreateTime,ctTaskFeedback.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctTaskFeedback.getUpdateBy())){
queryWrapper.eq(CtTaskFeedback::getUpdateBy,ctTaskFeedback.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctTaskFeedback.getUpdateTime())){
queryWrapper.eq(CtTaskFeedback::getUpdateTime,ctTaskFeedback.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctTaskFeedback.getTenantId())){
queryWrapper.eq(CtTaskFeedback::getTenantId,ctTaskFeedback.getTenantId());
}
}
}

@ -0,0 +1,184 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtTaskImages;
import com.bs.ct.service.ICtTaskImagesService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "任务图片信息")
@RestController
@RequestMapping("/task/images")
public class CtTaskImagesController extends BaseController {
@Resource
private ICtTaskImagesService ctTaskImagesService;
/**
*
*/
@ApiOperation("分页查询任务图片信息列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtTaskImages ctTaskImages) {
startPage();
LambdaQueryWrapper<CtTaskImages> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskImages);
List<CtTaskImages> list = ctTaskImagesService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询任务图片信息列表")
@GetMapping("/list")
public AjaxResult list(CtTaskImages ctTaskImages) {
LambdaQueryWrapper<CtTaskImages> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskImages);
List<CtTaskImages> list = ctTaskImagesService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出任务图片信息列表")
@Log(title = "任务图片信息导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtTaskImages ctTaskImages) {
LambdaQueryWrapper<CtTaskImages> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskImages);
List<CtTaskImages> list = ctTaskImagesService.list(queryWrapper);
ExcelUtil<CtTaskImages> util = new ExcelUtil<CtTaskImages>(CtTaskImages. class);
util.exportExcel(response, list, "任务图片信息数据");
}
/**
*
*/
@ApiOperation("获取任务图片信息详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctTaskImagesService.getById(id));
}
/**
*
*/
@ApiOperation("新增任务图片信息")
@Log(title = "任务图片信息新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtTaskImages ctTaskImages) {
return toAjax(ctTaskImagesService.save(ctTaskImages));
}
/**
*
*/
@ApiOperation("修改任务图片信息")
@Log(title = "任务图片信息修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtTaskImages ctTaskImages) {
return toAjax(ctTaskImagesService.updateById(ctTaskImages));
}
/**
*
*/
@ApiOperation("删除任务图片信息")
@Log(title = "任务图片信息删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctTaskImagesService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtTaskImages> queryWrapper,CtTaskImages ctTaskImages){
//id
if(Validator.isNotEmpty(ctTaskImages.getId())){
queryWrapper.eq(CtTaskImages::getId,ctTaskImages.getId());
}
//任务id
if(Validator.isNotEmpty(ctTaskImages.getTaskId())){
queryWrapper.eq(CtTaskImages::getTaskId,ctTaskImages.getTaskId());
}
//图片id
if(Validator.isNotEmpty(ctTaskImages.getImageId())){
queryWrapper.eq(CtTaskImages::getImageId,ctTaskImages.getImageId());
}
//备注
if(Validator.isNotEmpty(ctTaskImages.getRemarks())){
queryWrapper.eq(CtTaskImages::getRemarks,ctTaskImages.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctTaskImages.getDelFlag())){
queryWrapper.eq(CtTaskImages::getDelFlag,ctTaskImages.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctTaskImages.getCreateDept())){
queryWrapper.eq(CtTaskImages::getCreateDept,ctTaskImages.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctTaskImages.getCreateBy())){
queryWrapper.eq(CtTaskImages::getCreateBy,ctTaskImages.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctTaskImages.getCreateTime())){
queryWrapper.eq(CtTaskImages::getCreateTime,ctTaskImages.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctTaskImages.getUpdateBy())){
queryWrapper.eq(CtTaskImages::getUpdateBy,ctTaskImages.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctTaskImages.getUpdateTime())){
queryWrapper.eq(CtTaskImages::getUpdateTime,ctTaskImages.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctTaskImages.getTenantId())){
queryWrapper.eq(CtTaskImages::getTenantId,ctTaskImages.getTenantId());
}
}
}

@ -0,0 +1,239 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtTaskInfo;
import com.bs.ct.service.ICtTaskInfoService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "任务信息")
@RestController
@RequestMapping("/task/info")
public class CtTaskInfoController extends BaseController {
@Resource
private ICtTaskInfoService ctTaskInfoService;
/**
*
*/
@ApiOperation("分页查询任务信息列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtTaskInfo ctTaskInfo) {
startPage();
LambdaQueryWrapper<CtTaskInfo> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskInfo);
List<CtTaskInfo> list = ctTaskInfoService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询任务信息列表")
@GetMapping("/list")
public AjaxResult list(CtTaskInfo ctTaskInfo) {
LambdaQueryWrapper<CtTaskInfo> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskInfo);
List<CtTaskInfo> list = ctTaskInfoService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出任务信息列表")
@Log(title = "任务信息导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtTaskInfo ctTaskInfo) {
LambdaQueryWrapper<CtTaskInfo> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskInfo);
List<CtTaskInfo> list = ctTaskInfoService.list(queryWrapper);
ExcelUtil<CtTaskInfo> util = new ExcelUtil<CtTaskInfo>(CtTaskInfo. class);
util.exportExcel(response, list, "任务信息数据");
}
/**
*
*/
@ApiOperation("获取任务信息详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctTaskInfoService.getById(id));
}
/**
*
*/
@ApiOperation("新增任务信息")
@Log(title = "任务信息新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtTaskInfo ctTaskInfo) {
return toAjax(ctTaskInfoService.save(ctTaskInfo));
}
/**
*
*/
@ApiOperation("修改任务信息")
@Log(title = "任务信息修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtTaskInfo ctTaskInfo) {
return toAjax(ctTaskInfoService.updateById(ctTaskInfo));
}
/**
*
*/
@ApiOperation("删除任务信息")
@Log(title = "任务信息删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctTaskInfoService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtTaskInfo> queryWrapper,CtTaskInfo ctTaskInfo){
//id
if(Validator.isNotEmpty(ctTaskInfo.getId())){
queryWrapper.eq(CtTaskInfo::getId,ctTaskInfo.getId());
}
//任务类型
if(Validator.isNotEmpty(ctTaskInfo.getTaskType())){
queryWrapper.eq(CtTaskInfo::getTaskType,ctTaskInfo.getTaskType());
}
//任务标题
if(Validator.isNotEmpty(ctTaskInfo.getTaskTitle())){
queryWrapper.eq(CtTaskInfo::getTaskTitle,ctTaskInfo.getTaskTitle());
}
//任务编号
if(Validator.isNotEmpty(ctTaskInfo.getTaskCode())){
queryWrapper.eq(CtTaskInfo::getTaskCode,ctTaskInfo.getTaskCode());
}
//开始时间
if(Validator.isNotEmpty(ctTaskInfo.getStartDate())){
queryWrapper.eq(CtTaskInfo::getStartDate,ctTaskInfo.getStartDate());
}
//结束时间
if(Validator.isNotEmpty(ctTaskInfo.getEndDate())){
queryWrapper.eq(CtTaskInfo::getEndDate,ctTaskInfo.getEndDate());
}
//任务要求
if(Validator.isNotEmpty(ctTaskInfo.getTaskContent())){
queryWrapper.eq(CtTaskInfo::getTaskContent,ctTaskInfo.getTaskContent());
}
//完成状态
if(Validator.isNotEmpty(ctTaskInfo.getStatus())){
queryWrapper.eq(CtTaskInfo::getStatus,ctTaskInfo.getStatus());
}
//附件id
if(Validator.isNotEmpty(ctTaskInfo.getFileId())){
queryWrapper.eq(CtTaskInfo::getFileId,ctTaskInfo.getFileId());
}
//任务发起人
if(Validator.isNotEmpty(ctTaskInfo.getTaskInitiator())){
queryWrapper.eq(CtTaskInfo::getTaskInitiator,ctTaskInfo.getTaskInitiator());
}
//任务发起单位机构代码
if(Validator.isNotEmpty(ctTaskInfo.getBranchCode())){
queryWrapper.eq(CtTaskInfo::getBranchCode,ctTaskInfo.getBranchCode());
}
//任务发起单位
if(Validator.isNotEmpty(ctTaskInfo.getBranchName())){
queryWrapper.eq(CtTaskInfo::getBranchName,ctTaskInfo.getBranchName());
}
//任务发起部门
if(Validator.isNotEmpty(ctTaskInfo.getDeptId())){
queryWrapper.eq(CtTaskInfo::getDeptId,ctTaskInfo.getDeptId());
}
//任务发布日期
if(Validator.isNotEmpty(ctTaskInfo.getTaskDate())){
queryWrapper.eq(CtTaskInfo::getTaskDate,ctTaskInfo.getTaskDate());
}
//备注
if(Validator.isNotEmpty(ctTaskInfo.getRemarks())){
queryWrapper.eq(CtTaskInfo::getRemarks,ctTaskInfo.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctTaskInfo.getDelFlag())){
queryWrapper.eq(CtTaskInfo::getDelFlag,ctTaskInfo.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctTaskInfo.getCreateDept())){
queryWrapper.eq(CtTaskInfo::getCreateDept,ctTaskInfo.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctTaskInfo.getCreateBy())){
queryWrapper.eq(CtTaskInfo::getCreateBy,ctTaskInfo.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctTaskInfo.getCreateTime())){
queryWrapper.eq(CtTaskInfo::getCreateTime,ctTaskInfo.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctTaskInfo.getUpdateBy())){
queryWrapper.eq(CtTaskInfo::getUpdateBy,ctTaskInfo.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctTaskInfo.getUpdateTime())){
queryWrapper.eq(CtTaskInfo::getUpdateTime,ctTaskInfo.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctTaskInfo.getTenantId())){
queryWrapper.eq(CtTaskInfo::getTenantId,ctTaskInfo.getTenantId());
}
}
}

@ -0,0 +1,209 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtTaskTag;
import com.bs.ct.service.ICtTaskTagService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "任务标签")
@RestController
@RequestMapping("/task/tag")
public class CtTaskTagController extends BaseController {
@Resource
private ICtTaskTagService ctTaskTagService;
/**
*
*/
@ApiOperation("分页查询任务标签列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtTaskTag ctTaskTag) {
startPage();
LambdaQueryWrapper<CtTaskTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskTag);
List<CtTaskTag> list = ctTaskTagService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询任务标签列表")
@GetMapping("/list")
public AjaxResult list(CtTaskTag ctTaskTag) {
LambdaQueryWrapper<CtTaskTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskTag);
List<CtTaskTag> list = ctTaskTagService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出任务标签列表")
@Log(title = "任务标签导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtTaskTag ctTaskTag) {
LambdaQueryWrapper<CtTaskTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskTag);
List<CtTaskTag> list = ctTaskTagService.list(queryWrapper);
ExcelUtil<CtTaskTag> util = new ExcelUtil<CtTaskTag>(CtTaskTag. class);
util.exportExcel(response, list, "任务标签数据");
}
/**
*
*/
@ApiOperation("获取任务标签详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctTaskTagService.getById(id));
}
/**
*
*/
@ApiOperation("新增任务标签")
@Log(title = "任务标签新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtTaskTag ctTaskTag) {
return toAjax(ctTaskTagService.save(ctTaskTag));
}
/**
*
*/
@ApiOperation("修改任务标签")
@Log(title = "任务标签修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtTaskTag ctTaskTag) {
return toAjax(ctTaskTagService.updateById(ctTaskTag));
}
/**
*
*/
@ApiOperation("删除任务标签")
@Log(title = "任务标签删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctTaskTagService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtTaskTag> queryWrapper,CtTaskTag ctTaskTag){
//id
if(Validator.isNotEmpty(ctTaskTag.getId())){
queryWrapper.eq(CtTaskTag::getId,ctTaskTag.getId());
}
//任务模板id
if(Validator.isNotEmpty(ctTaskTag.getTaskId())){
queryWrapper.eq(CtTaskTag::getTaskId,ctTaskTag.getTaskId());
}
//标签名称
if(Validator.isNotEmpty(ctTaskTag.getTagName())){
queryWrapper.eq(CtTaskTag::getTagName,ctTaskTag.getTagName());
}
//标签说明
if(Validator.isNotEmpty(ctTaskTag.getTagDesc())){
queryWrapper.eq(CtTaskTag::getTagDesc,ctTaskTag.getTagDesc());
}
//是否需要拍照
if(Validator.isNotEmpty(ctTaskTag.getIsPhoto())){
queryWrapper.eq(CtTaskTag::getIsPhoto,ctTaskTag.getIsPhoto());
}
//拍照数量要求
if(Validator.isNotEmpty(ctTaskTag.getPhotoNum())){
queryWrapper.eq(CtTaskTag::getPhotoNum,ctTaskTag.getPhotoNum());
}
//照片存放目录
if(Validator.isNotEmpty(ctTaskTag.getSaveDir())){
queryWrapper.eq(CtTaskTag::getSaveDir,ctTaskTag.getSaveDir());
}
//附件id
if(Validator.isNotEmpty(ctTaskTag.getFileId())){
queryWrapper.eq(CtTaskTag::getFileId,ctTaskTag.getFileId());
}
//备注
if(Validator.isNotEmpty(ctTaskTag.getRemarks())){
queryWrapper.eq(CtTaskTag::getRemarks,ctTaskTag.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctTaskTag.getDelFlag())){
queryWrapper.eq(CtTaskTag::getDelFlag,ctTaskTag.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctTaskTag.getCreateDept())){
queryWrapper.eq(CtTaskTag::getCreateDept,ctTaskTag.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctTaskTag.getCreateBy())){
queryWrapper.eq(CtTaskTag::getCreateBy,ctTaskTag.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctTaskTag.getCreateTime())){
queryWrapper.eq(CtTaskTag::getCreateTime,ctTaskTag.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctTaskTag.getUpdateBy())){
queryWrapper.eq(CtTaskTag::getUpdateBy,ctTaskTag.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctTaskTag.getUpdateTime())){
queryWrapper.eq(CtTaskTag::getUpdateTime,ctTaskTag.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctTaskTag.getTenantId())){
queryWrapper.eq(CtTaskTag::getTenantId,ctTaskTag.getTenantId());
}
}
}

@ -0,0 +1,194 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtTaskTemplate;
import com.bs.ct.service.ICtTaskTemplateService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "任务模板")
@RestController
@RequestMapping("/task/template")
public class CtTaskTemplateController extends BaseController {
@Resource
private ICtTaskTemplateService ctTaskTemplateService;
/**
*
*/
@ApiOperation("分页查询任务模板列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtTaskTemplate ctTaskTemplate) {
startPage();
LambdaQueryWrapper<CtTaskTemplate> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskTemplate);
List<CtTaskTemplate> list = ctTaskTemplateService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询任务模板列表")
@GetMapping("/list")
public AjaxResult list(CtTaskTemplate ctTaskTemplate) {
LambdaQueryWrapper<CtTaskTemplate> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskTemplate);
List<CtTaskTemplate> list = ctTaskTemplateService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出任务模板列表")
@Log(title = "任务模板导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtTaskTemplate ctTaskTemplate) {
LambdaQueryWrapper<CtTaskTemplate> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskTemplate);
List<CtTaskTemplate> list = ctTaskTemplateService.list(queryWrapper);
ExcelUtil<CtTaskTemplate> util = new ExcelUtil<CtTaskTemplate>(CtTaskTemplate. class);
util.exportExcel(response, list, "任务模板数据");
}
/**
*
*/
@ApiOperation("获取任务模板详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctTaskTemplateService.getById(id));
}
/**
*
*/
@ApiOperation("新增任务模板")
@Log(title = "任务模板新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtTaskTemplate ctTaskTemplate) {
return toAjax(ctTaskTemplateService.save(ctTaskTemplate));
}
/**
*
*/
@ApiOperation("修改任务模板")
@Log(title = "任务模板修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtTaskTemplate ctTaskTemplate) {
return toAjax(ctTaskTemplateService.updateById(ctTaskTemplate));
}
/**
*
*/
@ApiOperation("删除任务模板")
@Log(title = "任务模板删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctTaskTemplateService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtTaskTemplate> queryWrapper,CtTaskTemplate ctTaskTemplate){
//id
if(Validator.isNotEmpty(ctTaskTemplate.getId())){
queryWrapper.eq(CtTaskTemplate::getId,ctTaskTemplate.getId());
}
//任务类型
if(Validator.isNotEmpty(ctTaskTemplate.getTaskType())){
queryWrapper.eq(CtTaskTemplate::getTaskType,ctTaskTemplate.getTaskType());
}
//模板名称
if(Validator.isNotEmpty(ctTaskTemplate.getTemplateName())){
queryWrapper.eq(CtTaskTemplate::getTemplateName,ctTaskTemplate.getTemplateName());
}
//任务标题
if(Validator.isNotEmpty(ctTaskTemplate.getTaskTitle())){
queryWrapper.eq(CtTaskTemplate::getTaskTitle,ctTaskTemplate.getTaskTitle());
}
//任务要求
if(Validator.isNotEmpty(ctTaskTemplate.getTaskContent())){
queryWrapper.eq(CtTaskTemplate::getTaskContent,ctTaskTemplate.getTaskContent());
}
//备注
if(Validator.isNotEmpty(ctTaskTemplate.getRemarks())){
queryWrapper.eq(CtTaskTemplate::getRemarks,ctTaskTemplate.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctTaskTemplate.getDelFlag())){
queryWrapper.eq(CtTaskTemplate::getDelFlag,ctTaskTemplate.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctTaskTemplate.getCreateDept())){
queryWrapper.eq(CtTaskTemplate::getCreateDept,ctTaskTemplate.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctTaskTemplate.getCreateBy())){
queryWrapper.eq(CtTaskTemplate::getCreateBy,ctTaskTemplate.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctTaskTemplate.getCreateTime())){
queryWrapper.eq(CtTaskTemplate::getCreateTime,ctTaskTemplate.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctTaskTemplate.getUpdateBy())){
queryWrapper.eq(CtTaskTemplate::getUpdateBy,ctTaskTemplate.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctTaskTemplate.getUpdateTime())){
queryWrapper.eq(CtTaskTemplate::getUpdateTime,ctTaskTemplate.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctTaskTemplate.getTenantId())){
queryWrapper.eq(CtTaskTemplate::getTenantId,ctTaskTemplate.getTenantId());
}
}
}

@ -0,0 +1,209 @@
package com.bs.ct.controller;
import java.util.List;
import javax.servlet.http.HttpServletResponse;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.security.access.prepost.PreAuthorize;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.PutMapping;
import org.springframework.web.bind.annotation.DeleteMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.bs.common.annotation.Log;
import com.bs.common.core.controller.BaseController;
import com.bs.common.core.domain.AjaxResult;
import com.bs.common.core.page.TableDataInfo;
import com.bs.common.enums.BusinessType;
import com.bs.common.utils.poi.ExcelUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import cn.hutool.core.lang.Validator;
import com.bs.ct.domain.CtTaskTemplateTag;
import com.bs.ct.service.ICtTaskTemplateTagService;
import javax.annotation.Resource;
/**
* Controller
*
* @author bs
* @date 2025-02-22
*/
@Api(tags = "任务模板标签")
@RestController
@RequestMapping("/task/template/tag")
public class CtTaskTemplateTagController extends BaseController {
@Resource
private ICtTaskTemplateTagService ctTaskTemplateTagService;
/**
*
*/
@ApiOperation("分页查询任务模板标签列表")
@GetMapping("/pageList")
public TableDataInfo pageList(CtTaskTemplateTag ctTaskTemplateTag) {
startPage();
LambdaQueryWrapper<CtTaskTemplateTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskTemplateTag);
List<CtTaskTemplateTag> list = ctTaskTemplateTagService.list(queryWrapper);
return getDataTable(list);
}
/**
*
*/
@ApiOperation("查询任务模板标签列表")
@GetMapping("/list")
public AjaxResult list(CtTaskTemplateTag ctTaskTemplateTag) {
LambdaQueryWrapper<CtTaskTemplateTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskTemplateTag);
List<CtTaskTemplateTag> list = ctTaskTemplateTagService.list(queryWrapper);
return success(list);
}
/**
*
*/
@ApiOperation("导出任务模板标签列表")
@Log(title = "任务模板标签导出", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(HttpServletResponse response, CtTaskTemplateTag ctTaskTemplateTag) {
LambdaQueryWrapper<CtTaskTemplateTag> queryWrapper = new LambdaQueryWrapper();
condition(queryWrapper,ctTaskTemplateTag);
List<CtTaskTemplateTag> list = ctTaskTemplateTagService.list(queryWrapper);
ExcelUtil<CtTaskTemplateTag> util = new ExcelUtil<CtTaskTemplateTag>(CtTaskTemplateTag. class);
util.exportExcel(response, list, "任务模板标签数据");
}
/**
*
*/
@ApiOperation("获取任务模板标签详细信息")
@GetMapping(value = "/{id}")
public AjaxResult getInfo(@PathVariable("id") Long id) {
return success(ctTaskTemplateTagService.getById(id));
}
/**
*
*/
@ApiOperation("新增任务模板标签")
@Log(title = "任务模板标签新增", businessType = BusinessType.INSERT)
@PostMapping
public AjaxResult add(@RequestBody CtTaskTemplateTag ctTaskTemplateTag) {
return toAjax(ctTaskTemplateTagService.save(ctTaskTemplateTag));
}
/**
*
*/
@ApiOperation("修改任务模板标签")
@Log(title = "任务模板标签修改", businessType = BusinessType.UPDATE)
@PutMapping
public AjaxResult edit(@RequestBody CtTaskTemplateTag ctTaskTemplateTag) {
return toAjax(ctTaskTemplateTagService.updateById(ctTaskTemplateTag));
}
/**
*
*/
@ApiOperation("删除任务模板标签")
@Log(title = "任务模板标签删除", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public AjaxResult remove(@PathVariable List<Long> ids) {
return toAjax(ctTaskTemplateTagService.removeBatchByIds(ids));
}
/**
*
*/
private void condition (LambdaQueryWrapper<CtTaskTemplateTag> queryWrapper,CtTaskTemplateTag ctTaskTemplateTag){
//id
if(Validator.isNotEmpty(ctTaskTemplateTag.getId())){
queryWrapper.eq(CtTaskTemplateTag::getId,ctTaskTemplateTag.getId());
}
//任务模板id
if(Validator.isNotEmpty(ctTaskTemplateTag.getTemplateId())){
queryWrapper.eq(CtTaskTemplateTag::getTemplateId,ctTaskTemplateTag.getTemplateId());
}
//标签名称
if(Validator.isNotEmpty(ctTaskTemplateTag.getTagName())){
queryWrapper.eq(CtTaskTemplateTag::getTagName,ctTaskTemplateTag.getTagName());
}
//标签说明
if(Validator.isNotEmpty(ctTaskTemplateTag.getTagDesc())){
queryWrapper.eq(CtTaskTemplateTag::getTagDesc,ctTaskTemplateTag.getTagDesc());
}
//是否需要拍照
if(Validator.isNotEmpty(ctTaskTemplateTag.getIsPhoto())){
queryWrapper.eq(CtTaskTemplateTag::getIsPhoto,ctTaskTemplateTag.getIsPhoto());
}
//拍照数量要求
if(Validator.isNotEmpty(ctTaskTemplateTag.getPhotoNum())){
queryWrapper.eq(CtTaskTemplateTag::getPhotoNum,ctTaskTemplateTag.getPhotoNum());
}
//照片存放目录
if(Validator.isNotEmpty(ctTaskTemplateTag.getSaveDir())){
queryWrapper.eq(CtTaskTemplateTag::getSaveDir,ctTaskTemplateTag.getSaveDir());
}
//附件id
if(Validator.isNotEmpty(ctTaskTemplateTag.getFileId())){
queryWrapper.eq(CtTaskTemplateTag::getFileId,ctTaskTemplateTag.getFileId());
}
//备注
if(Validator.isNotEmpty(ctTaskTemplateTag.getRemarks())){
queryWrapper.eq(CtTaskTemplateTag::getRemarks,ctTaskTemplateTag.getRemarks());
}
//删除标志0代表存在 2代表删除
if(Validator.isNotEmpty(ctTaskTemplateTag.getDelFlag())){
queryWrapper.eq(CtTaskTemplateTag::getDelFlag,ctTaskTemplateTag.getDelFlag());
}
//创建部门
if(Validator.isNotEmpty(ctTaskTemplateTag.getCreateDept())){
queryWrapper.eq(CtTaskTemplateTag::getCreateDept,ctTaskTemplateTag.getCreateDept());
}
//创建人
if(Validator.isNotEmpty(ctTaskTemplateTag.getCreateBy())){
queryWrapper.eq(CtTaskTemplateTag::getCreateBy,ctTaskTemplateTag.getCreateBy());
}
//创建时间
if(Validator.isNotEmpty(ctTaskTemplateTag.getCreateTime())){
queryWrapper.eq(CtTaskTemplateTag::getCreateTime,ctTaskTemplateTag.getCreateTime());
}
//修改人
if(Validator.isNotEmpty(ctTaskTemplateTag.getUpdateBy())){
queryWrapper.eq(CtTaskTemplateTag::getUpdateBy,ctTaskTemplateTag.getUpdateBy());
}
//修改时间
if(Validator.isNotEmpty(ctTaskTemplateTag.getUpdateTime())){
queryWrapper.eq(CtTaskTemplateTag::getUpdateTime,ctTaskTemplateTag.getUpdateTime());
}
//租户ID
if(Validator.isNotEmpty(ctTaskTemplateTag.getTenantId())){
queryWrapper.eq(CtTaskTemplateTag::getTenantId,ctTaskTemplateTag.getTenantId());
}
}
}

@ -0,0 +1,59 @@
package com.bs.ct.domain;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_gallery_cata
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_gallery_cata")
@Data
public class CtGalleryCata extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 目录名称 */
@Excel(name = "目录名称")
@ApiModelProperty(value = "目录名称")
private String cataName;
/** 父级id */
@Excel(name = "父级id")
@ApiModelProperty(value = "父级id")
private Long parentId;
/** 类型 */
@Excel(name = "类型")
@ApiModelProperty(value = "类型")
private String type;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,75 @@
package com.bs.ct.domain;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_gallery_cata_share
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_gallery_cata_share")
@Data
public class CtGalleryCataShare extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 共享类型目录共享、图片共享 */
@Excel(name = "共享类型目录共享、图片共享")
@ApiModelProperty(value = "共享类型目录共享、图片共享")
private String type;
/** 目录id */
@Excel(name = "目录id")
@ApiModelProperty(value = "目录id")
private Long cataId;
/** 共享用户 */
@Excel(name = "共享用户")
@ApiModelProperty(value = "共享用户")
private Long userId;
/** 开始时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "开始时间", width = 30, dateFormat = "yyyy-MM-dd")
@ApiModelProperty(value = "开始时间")
private Date beginDate;
/** 结束时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "结束时间", width = 30, dateFormat = "yyyy-MM-dd")
@ApiModelProperty(value = "结束时间")
private Date endDate;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,106 @@
package com.bs.ct.domain;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_gallery_images
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_gallery_images")
@Data
public class CtGalleryImages extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 目录id */
@Excel(name = "目录id")
@ApiModelProperty(value = "目录id")
private Long cataId;
/** 图片名称 */
@Excel(name = "图片名称")
@ApiModelProperty(value = "图片名称")
private String imageName;
/** 图片标题 */
@Excel(name = "图片标题")
@ApiModelProperty(value = "图片标题")
private String imageTitle;
/** 图片路径 */
@Excel(name = "图片路径")
@ApiModelProperty(value = "图片路径")
private String imagePath;
/** 图片大小 */
@Excel(name = "图片大小")
@ApiModelProperty(value = "图片大小")
private BigDecimal imageSize;
/** 图片拍摄时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "图片拍摄时间", width = 30, dateFormat = "yyyy-MM-dd")
@ApiModelProperty(value = "图片拍摄时间")
private Date photoTime;
/** 图片上传时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "图片上传时间", width = 30, dateFormat = "yyyy-MM-dd")
@ApiModelProperty(value = "图片上传时间")
private Date uploadTime;
/** 是否公开 */
@Excel(name = "是否公开")
@ApiModelProperty(value = "是否公开")
private String isOpen;
/** 图片关键字 */
@Excel(name = "图片关键字")
@ApiModelProperty(value = "图片关键字")
private String keyWords;
/** 附件id */
@Excel(name = "附件id")
@ApiModelProperty(value = "附件id")
private Long fileId;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,53 @@
package com.bs.ct.domain;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_gallery_images_tag
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_gallery_images_tag")
@Data
public class CtGalleryImagesTag extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 图片id */
@Excel(name = "图片id")
@ApiModelProperty(value = "图片id")
private Long imageId;
/** 标签名称 */
@Excel(name = "标签名称")
@ApiModelProperty(value = "标签名称")
private String tagName;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,77 @@
package com.bs.ct.domain;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_tag
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_tag")
@Data
public class CtTag extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 标签名称 */
@Excel(name = "标签名称")
@ApiModelProperty(value = "标签名称")
private String tagName;
/** 标签说明 */
@Excel(name = "标签说明")
@ApiModelProperty(value = "标签说明")
private String tagDesc;
/** 是否需要拍照 */
@Excel(name = "是否需要拍照")
@ApiModelProperty(value = "是否需要拍照")
private String isPhoto;
/** 拍照数量要求 */
@Excel(name = "拍照数量要求")
@ApiModelProperty(value = "拍照数量要求")
private Long photoNum;
/** 照片存放目录 */
@Excel(name = "照片存放目录")
@ApiModelProperty(value = "照片存放目录")
private Long saveDir;
/** 附件id */
@Excel(name = "附件id")
@ApiModelProperty(value = "附件id")
private Long fileId;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,71 @@
package com.bs.ct.domain;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_task_branch
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_task_branch")
@Data
public class CtTaskBranch extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 任务id */
@Excel(name = "任务id")
@ApiModelProperty(value = "任务id")
private Long taskId;
/** 类型人员、机构 */
@Excel(name = "类型人员、机构")
@ApiModelProperty(value = "类型人员、机构")
private String type;
/** 机构代码 */
@Excel(name = "机构代码")
@ApiModelProperty(value = "机构代码")
private String branchCode;
/** 机构名称 */
@Excel(name = "机构名称")
@ApiModelProperty(value = "机构名称")
private String branchName;
/** 任务状态 */
@Excel(name = "任务状态")
@ApiModelProperty(value = "任务状态")
private String taskStatus;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,141 @@
package com.bs.ct.domain;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_task_feedback
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_task_feedback")
@Data
public class CtTaskFeedback extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 任务id */
@Excel(name = "任务id")
@ApiModelProperty(value = "任务id")
private Long taskId;
/** 机构任务id */
@Excel(name = "机构任务id")
@ApiModelProperty(value = "机构任务id")
private Long taskBranchId;
/** 机构代码 */
@Excel(name = "机构代码")
@ApiModelProperty(value = "机构代码")
private String branchCode;
/** 任务反馈时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "任务反馈时间", width = 30, dateFormat = "yyyy-MM-dd")
@ApiModelProperty(value = "任务反馈时间")
private Date feedbackTime;
/** 任务完成情况 */
@Excel(name = "任务完成情况")
@ApiModelProperty(value = "任务完成情况")
private String taskDesc;
/** 操作人员工号 */
@Excel(name = "操作人员工号")
@ApiModelProperty(value = "操作人员工号")
private String userId;
/** 操作人员姓名 */
@Excel(name = "操作人员姓名")
@ApiModelProperty(value = "操作人员姓名")
private String userName;
/** 操作人员部门 */
@Excel(name = "操作人员部门")
@ApiModelProperty(value = "操作人员部门")
private String userDept;
/** 是否已拍照留存 */
@Excel(name = "是否已拍照留存")
@ApiModelProperty(value = "是否已拍照留存")
private String isPhoto;
/** 附件id */
@Excel(name = "附件id")
@ApiModelProperty(value = "附件id")
private Long fileId;
/** 审核人员id */
@Excel(name = "审核人员id")
@ApiModelProperty(value = "审核人员id")
private String checkUserId;
/** 审核人员姓名 */
@Excel(name = "审核人员姓名")
@ApiModelProperty(value = "审核人员姓名")
private String checkUserName;
/** 审核人员部门 */
@Excel(name = "审核人员部门")
@ApiModelProperty(value = "审核人员部门")
private String checkUserDept;
/** 审核时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "审核时间", width = 30, dateFormat = "yyyy-MM-dd")
@ApiModelProperty(value = "审核时间")
private Date checkDate;
/** 审核状态 */
@Excel(name = "审核状态")
@ApiModelProperty(value = "审核状态")
private String status;
/** 审核信息 */
@Excel(name = "审核信息")
@ApiModelProperty(value = "审核信息")
private String checkInfo;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,53 @@
package com.bs.ct.domain;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_task_images
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_task_images")
@Data
public class CtTaskImages extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 任务id */
@Excel(name = "任务id")
@ApiModelProperty(value = "任务id")
private Long taskId;
/** 图片id */
@Excel(name = "图片id")
@ApiModelProperty(value = "图片id")
private Long imageId;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,124 @@
package com.bs.ct.domain;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_task_info
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_task_info")
@Data
public class CtTaskInfo extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 任务类型 */
@Excel(name = "任务类型")
@ApiModelProperty(value = "任务类型")
private String taskType;
/** 任务标题 */
@Excel(name = "任务标题")
@ApiModelProperty(value = "任务标题")
private String taskTitle;
/** 任务编号 */
@Excel(name = "任务编号")
@ApiModelProperty(value = "任务编号")
private String taskCode;
/** 开始时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "开始时间", width = 30, dateFormat = "yyyy-MM-dd")
@ApiModelProperty(value = "开始时间")
private Date startDate;
/** 结束时间 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "结束时间", width = 30, dateFormat = "yyyy-MM-dd")
@ApiModelProperty(value = "结束时间")
private Date endDate;
/** 任务要求 */
@Excel(name = "任务要求")
@ApiModelProperty(value = "任务要求")
private String taskContent;
/** 完成状态 */
@Excel(name = "完成状态")
@ApiModelProperty(value = "完成状态")
private String status;
/** 附件id */
@Excel(name = "附件id")
@ApiModelProperty(value = "附件id")
private Long fileId;
/** 任务发起人 */
@Excel(name = "任务发起人")
@ApiModelProperty(value = "任务发起人")
private String taskInitiator;
/** 任务发起单位机构代码 */
@Excel(name = "任务发起单位机构代码")
@ApiModelProperty(value = "任务发起单位机构代码")
private String branchCode;
/** 任务发起单位 */
@Excel(name = "任务发起单位")
@ApiModelProperty(value = "任务发起单位")
private String branchName;
/** 任务发起部门 */
@Excel(name = "任务发起部门")
@ApiModelProperty(value = "任务发起部门")
private Long deptId;
/** 任务发布日期 */
@JsonFormat(pattern = "yyyy-MM-dd")
@Excel(name = "任务发布日期", width = 30, dateFormat = "yyyy-MM-dd")
@ApiModelProperty(value = "任务发布日期")
private Date taskDate;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,83 @@
package com.bs.ct.domain;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_task_tag
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_task_tag")
@Data
public class CtTaskTag extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 任务模板id */
@Excel(name = "任务模板id")
@ApiModelProperty(value = "任务模板id")
private Long taskId;
/** 标签名称 */
@Excel(name = "标签名称")
@ApiModelProperty(value = "标签名称")
private String tagName;
/** 标签说明 */
@Excel(name = "标签说明")
@ApiModelProperty(value = "标签说明")
private String tagDesc;
/** 是否需要拍照 */
@Excel(name = "是否需要拍照")
@ApiModelProperty(value = "是否需要拍照")
private String isPhoto;
/** 拍照数量要求 */
@Excel(name = "拍照数量要求")
@ApiModelProperty(value = "拍照数量要求")
private Long photoNum;
/** 照片存放目录 */
@Excel(name = "照片存放目录")
@ApiModelProperty(value = "照片存放目录")
private Long saveDir;
/** 附件id */
@Excel(name = "附件id")
@ApiModelProperty(value = "附件id")
private Long fileId;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,65 @@
package com.bs.ct.domain;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_task_template
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_task_template")
@Data
public class CtTaskTemplate extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 任务类型 */
@Excel(name = "任务类型")
@ApiModelProperty(value = "任务类型")
private String taskType;
/** 模板名称 */
@Excel(name = "模板名称")
@ApiModelProperty(value = "模板名称")
private String templateName;
/** 任务标题 */
@Excel(name = "任务标题")
@ApiModelProperty(value = "任务标题")
private String taskTitle;
/** 任务要求 */
@Excel(name = "任务要求")
@ApiModelProperty(value = "任务要求")
private String taskContent;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,83 @@
package com.bs.ct.domain;
import com.bs.common.annotation.Excel;
import com.bs.common.core.domain.BaseEntity;
import lombok.Data;
import lombok.EqualsAndHashCode;
import lombok.experimental.Accessors;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModelProperty;
/**
* ct_task_template_tag
*
* @author bs
* @date 2025-02-22
*/
@EqualsAndHashCode(callSuper = true)
@Accessors(chain = true)
@TableName("ct_task_template_tag")
@Data
public class CtTaskTemplateTag extends BaseEntity{
private static final long serialVersionUID = 1L;
/** id */
@TableId(value = "id",type = IdType.AUTO)
@ApiModelProperty(value = "id")
private Long id;
/** 任务模板id */
@Excel(name = "任务模板id")
@ApiModelProperty(value = "任务模板id")
private Long templateId;
/** 标签名称 */
@Excel(name = "标签名称")
@ApiModelProperty(value = "标签名称")
private String tagName;
/** 标签说明 */
@Excel(name = "标签说明")
@ApiModelProperty(value = "标签说明")
private String tagDesc;
/** 是否需要拍照 */
@Excel(name = "是否需要拍照")
@ApiModelProperty(value = "是否需要拍照")
private String isPhoto;
/** 拍照数量要求 */
@Excel(name = "拍照数量要求")
@ApiModelProperty(value = "拍照数量要求")
private Long photoNum;
/** 照片存放目录 */
@Excel(name = "照片存放目录")
@ApiModelProperty(value = "照片存放目录")
private Long saveDir;
/** 附件id */
@Excel(name = "附件id")
@ApiModelProperty(value = "附件id")
private Long fileId;
/** 备注 */
@Excel(name = "备注")
@ApiModelProperty(value = "备注")
private String remarks;
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtGalleryCata;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtGalleryCataMapper extends BaseMapperX<CtGalleryCata> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtGalleryCataShare;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtGalleryCataShareMapper extends BaseMapperX<CtGalleryCataShare> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtGalleryImages;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtGalleryImagesMapper extends BaseMapperX<CtGalleryImages> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtGalleryImagesTag;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtGalleryImagesTagMapper extends BaseMapperX<CtGalleryImagesTag> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtTag;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtTagMapper extends BaseMapperX<CtTag> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtTaskBranch;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtTaskBranchMapper extends BaseMapperX<CtTaskBranch> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtTaskFeedback;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtTaskFeedbackMapper extends BaseMapperX<CtTaskFeedback> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtTaskImages;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtTaskImagesMapper extends BaseMapperX<CtTaskImages> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtTaskInfo;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtTaskInfoMapper extends BaseMapperX<CtTaskInfo> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtTaskTag;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtTaskTagMapper extends BaseMapperX<CtTaskTag> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtTaskTemplate;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtTaskTemplateMapper extends BaseMapperX<CtTaskTemplate> {
}

@ -0,0 +1,14 @@
package com.bs.ct.mapper;
import com.bs.common.mybatis.mapper.BaseMapperX;
import com.bs.ct.domain.CtTaskTemplateTag;
/**
* Mapper
*
* @author bs
* @date 2025-02-22
*/
public interface CtTaskTemplateTagMapper extends BaseMapperX<CtTaskTemplateTag> {
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtGalleryCata;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtGalleryCataService extends MPJBaseService<CtGalleryCata>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtGalleryCataShare;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtGalleryCataShareService extends MPJBaseService<CtGalleryCataShare>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtGalleryImages;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtGalleryImagesService extends MPJBaseService<CtGalleryImages>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtGalleryImagesTag;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtGalleryImagesTagService extends MPJBaseService<CtGalleryImagesTag>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtTag;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtTagService extends MPJBaseService<CtTag>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtTaskBranch;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtTaskBranchService extends MPJBaseService<CtTaskBranch>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtTaskFeedback;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtTaskFeedbackService extends MPJBaseService<CtTaskFeedback>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtTaskImages;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtTaskImagesService extends MPJBaseService<CtTaskImages>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtTaskInfo;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtTaskInfoService extends MPJBaseService<CtTaskInfo>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtTaskTag;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtTaskTagService extends MPJBaseService<CtTaskTag>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtTaskTemplate;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtTaskTemplateService extends MPJBaseService<CtTaskTemplate>{
}

@ -0,0 +1,14 @@
package com.bs.ct.service;
import com.github.yulichang.base.MPJBaseService;
import com.bs.ct.domain.CtTaskTemplateTag;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
public interface ICtTaskTemplateTagService extends MPJBaseService<CtTaskTemplateTag>{
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtGalleryCataMapper;
import com.bs.ct.domain.CtGalleryCata;
import com.bs.ct.service.ICtGalleryCataService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtGalleryCataServiceImpl extends MPJBaseServiceImpl<CtGalleryCataMapper, CtGalleryCata> implements ICtGalleryCataService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtGalleryCataShareMapper;
import com.bs.ct.domain.CtGalleryCataShare;
import com.bs.ct.service.ICtGalleryCataShareService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtGalleryCataShareServiceImpl extends MPJBaseServiceImpl<CtGalleryCataShareMapper, CtGalleryCataShare> implements ICtGalleryCataShareService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtGalleryImagesMapper;
import com.bs.ct.domain.CtGalleryImages;
import com.bs.ct.service.ICtGalleryImagesService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtGalleryImagesServiceImpl extends MPJBaseServiceImpl<CtGalleryImagesMapper, CtGalleryImages> implements ICtGalleryImagesService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtGalleryImagesTagMapper;
import com.bs.ct.domain.CtGalleryImagesTag;
import com.bs.ct.service.ICtGalleryImagesTagService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtGalleryImagesTagServiceImpl extends MPJBaseServiceImpl<CtGalleryImagesTagMapper, CtGalleryImagesTag> implements ICtGalleryImagesTagService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtTagMapper;
import com.bs.ct.domain.CtTag;
import com.bs.ct.service.ICtTagService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtTagServiceImpl extends MPJBaseServiceImpl<CtTagMapper, CtTag> implements ICtTagService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtTaskBranchMapper;
import com.bs.ct.domain.CtTaskBranch;
import com.bs.ct.service.ICtTaskBranchService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtTaskBranchServiceImpl extends MPJBaseServiceImpl<CtTaskBranchMapper, CtTaskBranch> implements ICtTaskBranchService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtTaskFeedbackMapper;
import com.bs.ct.domain.CtTaskFeedback;
import com.bs.ct.service.ICtTaskFeedbackService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtTaskFeedbackServiceImpl extends MPJBaseServiceImpl<CtTaskFeedbackMapper, CtTaskFeedback> implements ICtTaskFeedbackService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtTaskImagesMapper;
import com.bs.ct.domain.CtTaskImages;
import com.bs.ct.service.ICtTaskImagesService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtTaskImagesServiceImpl extends MPJBaseServiceImpl<CtTaskImagesMapper, CtTaskImages> implements ICtTaskImagesService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtTaskInfoMapper;
import com.bs.ct.domain.CtTaskInfo;
import com.bs.ct.service.ICtTaskInfoService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtTaskInfoServiceImpl extends MPJBaseServiceImpl<CtTaskInfoMapper, CtTaskInfo> implements ICtTaskInfoService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtTaskTagMapper;
import com.bs.ct.domain.CtTaskTag;
import com.bs.ct.service.ICtTaskTagService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtTaskTagServiceImpl extends MPJBaseServiceImpl<CtTaskTagMapper, CtTaskTag> implements ICtTaskTagService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtTaskTemplateMapper;
import com.bs.ct.domain.CtTaskTemplate;
import com.bs.ct.service.ICtTaskTemplateService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtTaskTemplateServiceImpl extends MPJBaseServiceImpl<CtTaskTemplateMapper, CtTaskTemplate> implements ICtTaskTemplateService {
}

@ -0,0 +1,19 @@
package com.bs.ct.service.impl;
import com.bs.ct.mapper.CtTaskTemplateTagMapper;
import com.bs.ct.domain.CtTaskTemplateTag;
import com.bs.ct.service.ICtTaskTemplateTagService;
import com.github.yulichang.base.MPJBaseServiceImpl;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
/**
* Service
*
* @author bs
* @date 2025-02-22
*/
@Service
@Transactional(rollbackFor = Exception.class)
public class CtTaskTemplateTagServiceImpl extends MPJBaseServiceImpl<CtTaskTemplateTagMapper, CtTaskTemplateTag> implements ICtTaskTemplateTagService {
}

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtGalleryCataMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtGalleryImagesMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtGalleryCataShareMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtGalleryImagesTagMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtTagMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtTaskBranchMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtTaskFeedbackMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtTaskImagesMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtTaskInfoMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtTaskTagMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtTaskTemplateMapper">
</mapper>

@ -0,0 +1,7 @@
<?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.bs.ct.mapper.CtTaskTemplateTagMapper">
</mapper>

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询图库目录列表
export function pageListCata(query) {
return request({
url: '/gallery/cata/pageList',
method: 'get',
params: query
})
}
// 查询图库目录列表
export function listCata(query) {
return request({
url: '/gallery/cata/list',
method: 'get',
params: query
})
}
// 查询图库目录详细
export function getCata(id) {
return request({
url: '/gallery/cata/' + id,
method: 'get'
})
}
// 新增图库目录
export function addCata(data) {
return request({
url: '/gallery/cata',
method: 'post',
data: data
})
}
// 修改图库目录
export function updateCata(data) {
return request({
url: '/gallery/cata',
method: 'put',
data: data
})
}
// 删除图库目录
export function delCata(id) {
return request({
url: '/gallery/cata/' + id,
method: 'delete'
})
}
// 导出图库目录
export function exportCata(query) {
return request({
url: '/gallery/cata/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询图库目录共享列表
export function pageListShare(query) {
return request({
url: '/gallery/cata/share/pageList',
method: 'get',
params: query
})
}
// 查询图库目录共享列表
export function listShare(query) {
return request({
url: '/gallery/cata/share/list',
method: 'get',
params: query
})
}
// 查询图库目录共享详细
export function getShare(id) {
return request({
url: '/gallery/cata/share/' + id,
method: 'get'
})
}
// 新增图库目录共享
export function addShare(data) {
return request({
url: '/gallery/cata/share',
method: 'post',
data: data
})
}
// 修改图库目录共享
export function updateShare(data) {
return request({
url: '/gallery/cata/share',
method: 'put',
data: data
})
}
// 删除图库目录共享
export function delShare(id) {
return request({
url: '/gallery/cata/share/' + id,
method: 'delete'
})
}
// 导出图库目录共享
export function exportShare(query) {
return request({
url: '/gallery/cata/share/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询图库图片列表
export function pageListImages(query) {
return request({
url: '/gallery/images/pageList',
method: 'get',
params: query
})
}
// 查询图库图片列表
export function listImages(query) {
return request({
url: '/gallery/images/list',
method: 'get',
params: query
})
}
// 查询图库图片详细
export function getImages(id) {
return request({
url: '/gallery/images/' + id,
method: 'get'
})
}
// 新增图库图片
export function addImages(data) {
return request({
url: '/gallery/images',
method: 'post',
data: data
})
}
// 修改图库图片
export function updateImages(data) {
return request({
url: '/gallery/images',
method: 'put',
data: data
})
}
// 删除图库图片
export function delImages(id) {
return request({
url: '/gallery/images/' + id,
method: 'delete'
})
}
// 导出图库图片
export function exportImages(query) {
return request({
url: '/gallery/images/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询图库图片标签列表
export function pageListTag(query) {
return request({
url: '/gallery/images/tag/pageList',
method: 'get',
params: query
})
}
// 查询图库图片标签列表
export function listTag(query) {
return request({
url: '/gallery/images/tag/list',
method: 'get',
params: query
})
}
// 查询图库图片标签详细
export function getTag(id) {
return request({
url: '/gallery/images/tag/' + id,
method: 'get'
})
}
// 新增图库图片标签
export function addTag(data) {
return request({
url: '/gallery/images/tag',
method: 'post',
data: data
})
}
// 修改图库图片标签
export function updateTag(data) {
return request({
url: '/gallery/images/tag',
method: 'put',
data: data
})
}
// 删除图库图片标签
export function delTag(id) {
return request({
url: '/gallery/images/tag/' + id,
method: 'delete'
})
}
// 导出图库图片标签
export function exportTag(query) {
return request({
url: '/gallery/images/tag/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询标签信息列表
export function pageListTag(query) {
return request({
url: '/system/tag/pageList',
method: 'get',
params: query
})
}
// 查询标签信息列表
export function listTag(query) {
return request({
url: '/system/tag/list',
method: 'get',
params: query
})
}
// 查询标签信息详细
export function getTag(id) {
return request({
url: '/system/tag/' + id,
method: 'get'
})
}
// 新增标签信息
export function addTag(data) {
return request({
url: '/system/tag',
method: 'post',
data: data
})
}
// 修改标签信息
export function updateTag(data) {
return request({
url: '/system/tag',
method: 'put',
data: data
})
}
// 删除标签信息
export function delTag(id) {
return request({
url: '/system/tag/' + id,
method: 'delete'
})
}
// 导出标签信息
export function exportTag(query) {
return request({
url: '/system/tag/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询任务机构信息列表
export function pageListBranch(query) {
return request({
url: '/task/branch/pageList',
method: 'get',
params: query
})
}
// 查询任务机构信息列表
export function listBranch(query) {
return request({
url: '/task/branch/list',
method: 'get',
params: query
})
}
// 查询任务机构信息详细
export function getBranch(id) {
return request({
url: '/task/branch/' + id,
method: 'get'
})
}
// 新增任务机构信息
export function addBranch(data) {
return request({
url: '/task/branch',
method: 'post',
data: data
})
}
// 修改任务机构信息
export function updateBranch(data) {
return request({
url: '/task/branch',
method: 'put',
data: data
})
}
// 删除任务机构信息
export function delBranch(id) {
return request({
url: '/task/branch/' + id,
method: 'delete'
})
}
// 导出任务机构信息
export function exportBranch(query) {
return request({
url: '/task/branch/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询任务反馈列表
export function pageListFeedback(query) {
return request({
url: '/task/feedback/pageList',
method: 'get',
params: query
})
}
// 查询任务反馈列表
export function listFeedback(query) {
return request({
url: '/task/feedback/list',
method: 'get',
params: query
})
}
// 查询任务反馈详细
export function getFeedback(id) {
return request({
url: '/task/feedback/' + id,
method: 'get'
})
}
// 新增任务反馈
export function addFeedback(data) {
return request({
url: '/task/feedback',
method: 'post',
data: data
})
}
// 修改任务反馈
export function updateFeedback(data) {
return request({
url: '/task/feedback',
method: 'put',
data: data
})
}
// 删除任务反馈
export function delFeedback(id) {
return request({
url: '/task/feedback/' + id,
method: 'delete'
})
}
// 导出任务反馈
export function exportFeedback(query) {
return request({
url: '/task/feedback/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询任务图片信息列表
export function pageListImages(query) {
return request({
url: '/task/images/pageList',
method: 'get',
params: query
})
}
// 查询任务图片信息列表
export function listImages(query) {
return request({
url: '/task/images/list',
method: 'get',
params: query
})
}
// 查询任务图片信息详细
export function getImages(id) {
return request({
url: '/task/images/' + id,
method: 'get'
})
}
// 新增任务图片信息
export function addImages(data) {
return request({
url: '/task/images',
method: 'post',
data: data
})
}
// 修改任务图片信息
export function updateImages(data) {
return request({
url: '/task/images',
method: 'put',
data: data
})
}
// 删除任务图片信息
export function delImages(id) {
return request({
url: '/task/images/' + id,
method: 'delete'
})
}
// 导出任务图片信息
export function exportImages(query) {
return request({
url: '/task/images/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询任务信息列表
export function pageListInfo(query) {
return request({
url: '/task/info/pageList',
method: 'get',
params: query
})
}
// 查询任务信息列表
export function listInfo(query) {
return request({
url: '/task/info/list',
method: 'get',
params: query
})
}
// 查询任务信息详细
export function getInfo(id) {
return request({
url: '/task/info/' + id,
method: 'get'
})
}
// 新增任务信息
export function addInfo(data) {
return request({
url: '/task/info',
method: 'post',
data: data
})
}
// 修改任务信息
export function updateInfo(data) {
return request({
url: '/task/info',
method: 'put',
data: data
})
}
// 删除任务信息
export function delInfo(id) {
return request({
url: '/task/info/' + id,
method: 'delete'
})
}
// 导出任务信息
export function exportInfo(query) {
return request({
url: '/task/info/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询任务标签列表
export function pageListTag(query) {
return request({
url: '/task/tag/pageList',
method: 'get',
params: query
})
}
// 查询任务标签列表
export function listTag(query) {
return request({
url: '/task/tag/list',
method: 'get',
params: query
})
}
// 查询任务标签详细
export function getTag(id) {
return request({
url: '/task/tag/' + id,
method: 'get'
})
}
// 新增任务标签
export function addTag(data) {
return request({
url: '/task/tag',
method: 'post',
data: data
})
}
// 修改任务标签
export function updateTag(data) {
return request({
url: '/task/tag',
method: 'put',
data: data
})
}
// 删除任务标签
export function delTag(id) {
return request({
url: '/task/tag/' + id,
method: 'delete'
})
}
// 导出任务标签
export function exportTag(query) {
return request({
url: '/task/tag/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询任务模板列表
export function pageListTemplate(query) {
return request({
url: '/task/template/pageList',
method: 'get',
params: query
})
}
// 查询任务模板列表
export function listTemplate(query) {
return request({
url: '/task/template/list',
method: 'get',
params: query
})
}
// 查询任务模板详细
export function getTemplate(id) {
return request({
url: '/task/template/' + id,
method: 'get'
})
}
// 新增任务模板
export function addTemplate(data) {
return request({
url: '/task/template',
method: 'post',
data: data
})
}
// 修改任务模板
export function updateTemplate(data) {
return request({
url: '/task/template',
method: 'put',
data: data
})
}
// 删除任务模板
export function delTemplate(id) {
return request({
url: '/task/template/' + id,
method: 'delete'
})
}
// 导出任务模板
export function exportTemplate(query) {
return request({
url: '/task/template/' + 'export',
method: 'post',
params: query
})
}

@ -0,0 +1,62 @@
import request from '@/utils/request'
// 分页查询任务模板标签列表
export function pageListTag(query) {
return request({
url: '/task/template/tag/pageList',
method: 'get',
params: query
})
}
// 查询任务模板标签列表
export function listTag(query) {
return request({
url: '/task/template/tag/list',
method: 'get',
params: query
})
}
// 查询任务模板标签详细
export function getTag(id) {
return request({
url: '/task/template/tag/' + id,
method: 'get'
})
}
// 新增任务模板标签
export function addTag(data) {
return request({
url: '/task/template/tag',
method: 'post',
data: data
})
}
// 修改任务模板标签
export function updateTag(data) {
return request({
url: '/task/template/tag',
method: 'put',
data: data
})
}
// 删除任务模板标签
export function delTag(id) {
return request({
url: '/task/template/tag/' + id,
method: 'delete'
})
}
// 导出任务模板标签
export function exportTag(query) {
return request({
url: '/task/template/tag/' + 'export',
method: 'post',
params: query
})
}
Loading…
Cancel
Save