作者：张哲

时间：2023/02/10
类型：开发
描述：里程碑(2)知识专辑PC端-点评模块及首页数据处理

src/main/java/com/redxun/knowledge/album/controller/AlbumInfoController.java

@@ -1,25 +1,17 @@
 package com.redxun.knowledge.album.controller;
 
-import com.google.j2objc.annotations.AutoreleasePool;
 import com.redxun.common.annotation.ClassDefine;
 import com.redxun.common.base.db.BaseService;
 import com.redxun.common.base.entity.JsonResult;
-import com.redxun.knowledge.album.entity.dao.AlbumApprovalNode;
+import com.redxun.knowledge.album.entity.consts.AlbumConst;
 import com.redxun.knowledge.album.entity.dao.AlbumInfo;
-import com.redxun.knowledge.album.entity.dao.AlbumYelpApprovalNode;
-import com.redxun.knowledge.album.entity.dto.AlbumApprovalNodeDto;
-import com.redxun.knowledge.album.entity.dto.AlbumApprovalRemark;
-import com.redxun.knowledge.album.entity.dto.AlbumInfoDto;
-import com.redxun.knowledge.album.entity.dto.TransferOwnerDto;
+import com.redxun.knowledge.album.entity.dto.*;
 import com.redxun.knowledge.album.entity.vo.*;
 import com.redxun.knowledge.album.service.*;
 import com.redxun.web.controller.BaseController;
 import io.swagger.annotations.Api;
-import io.swagger.annotations.ApiModelProperty;
 import io.swagger.annotations.ApiOperation;
 import lombok.extern.slf4j.Slf4j;
-import org.checkerframework.checker.index.qual.GTENegativeOne;
-import org.checkerframework.checker.signature.qual.ClassGetName;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.*;
 
@@ -48,6 +40,9 @@ public class AlbumInfoController extends BaseController<AlbumInfo> {
     @Autowired
     private AlbumCategoryServiceImpl albumCategoryService;
 
+    @Autowired
+    private AlbumYelpServiceImpl albumYelpService;
+
 
     @Override
     public BaseService getBaseService() {
@@ -67,6 +62,15 @@ public class AlbumInfoController extends BaseController<AlbumInfo> {
         return jsonResult.setData(pkId);
     }
 
+    @ApiOperation("PC端编辑知识专辑")
+    @PostMapping("edit")
+    public JsonResult edit(@RequestBody AlbumInfoEditDto albumInfoEditDto){
+        JsonResult jsonResult = JsonResult.getSuccessResult("");
+        String message = albumInfoService.edit(albumInfoEditDto);
+        jsonResult.setMessage(message);
+        return jsonResult.setData(albumInfoEditDto.getPkId());
+    }
+
     @ApiOperation("根据知识专辑ID获取知识专辑详情数据")
     @GetMapping("detail")
     public JsonResult detail(@RequestParam("pkId") String pkId){
@@ -83,12 +87,21 @@ public class AlbumInfoController extends BaseController<AlbumInfo> {
         return jsonResult.setData(albumVersionDetailVo);
     }
 
+    @ApiOperation("删除知识专辑")
+    @Override
+    public JsonResult del(String ids) {
+        JsonResult jsonResult = JsonResult.getSuccessResult("");
+        String del = albumInfoService.del(ids);
+        jsonResult.setMessage(del);
+        return jsonResult;
+    }
+
     @ApiOperation("转移专辑负责人")
     @PostMapping("transferOwner")
     public JsonResult transferOwner(@RequestBody TransferOwnerDto transferOwnerDto){
         JsonResult jsonResult = JsonResult.getSuccessResult("");
         albumInfoService.transferOwner(transferOwnerDto);
-        jsonResult.setMessage("操作成功");
+        jsonResult.setMessage(AlbumConst.OPERATOR_SUCCESS);
         jsonResult.setData(transferOwnerDto.getPkId());
         return jsonResult;
     }
@@ -106,7 +119,7 @@ public class AlbumInfoController extends BaseController<AlbumInfo> {
     public JsonResult batchUpdateApproveFlows(@RequestBody List<AlbumApprovalNodeDto> albumApprovalNodeDtoList){
         JsonResult jsonResult = JsonResult.getSuccessResult("");
         albumInfoService.batchUpdateApproveFlows(albumApprovalNodeDtoList);
-        return jsonResult.setData("批量添加成功!");
+        return jsonResult.setMessage(AlbumConst.BATCH_APPROVAL_SUCCESS);
     }
     
     @ApiOperation("获取当前审核流程列表数据")
@@ -121,7 +134,7 @@ public class AlbumInfoController extends BaseController<AlbumInfo> {
             List<AlbumApproverNodeVo> albumApproverNodeVos = albumInfoService.approveFlowsAlbumYelpApprovalNode();
             return jsonResult.setData(albumApproverNodeVos);
         } else {
-            return jsonResult.setMessage("类型错误");
+            return jsonResult.setMessage(AlbumConst.NO_TYPE);
         }
     }
 
@@ -138,7 +151,7 @@ public class AlbumInfoController extends BaseController<AlbumInfo> {
     public JsonResult approve(@RequestBody AlbumApprovalRemark albumApprovalRemark){
         JsonResult jsonResult = JsonResult.getSuccessResult("");
         albumApprovalService.approve(albumApprovalRemark);
-        return jsonResult.setMessage("审核成功!");
+        return jsonResult.setMessage(AlbumConst.APPROVAL_SUCCESS);
 
     }
 
@@ -175,5 +188,19 @@ public class AlbumInfoController extends BaseController<AlbumInfo> {
         return jsonResult.setData(albumCategoryPcVos);
     }
 
+    @ApiOperation("PC端对专辑进行点评或者回复点评（回复）内容")
+    @PostMapping("yelp")
+    public JsonResult yelp(@RequestBody YelpDto yelpDto){
+        JsonResult jsonResult = JsonResult.getSuccessResult("");
+        String result = albumYelpService.yelp(yelpDto);
+        jsonResult.setData(result);
+        if (yelpDto.getType() == 1){
+            return jsonResult.setMessage(AlbumConst.YELP_SUCCESS);
+        } else {
+            return jsonResult.setMessage(AlbumConst.REPLY_SUCCESS);
+        }
+
+    }
+
 }
 

src/main/java/com/redxun/knowledge/album/entity/consts/AlbumConst.java

@@ -0,0 +1,32 @@
+package com.redxun.knowledge.album.entity.consts;
+
+/**
+ * 文件名: AlbumConst
+ * 作者: Zizg
+ * 时间: 2023/2/8
+ * 描述:
+ * 修改人:
+ * 修改时间:
+ * 修改内容:
+ */
+public class AlbumConst {
+
+    public static final String EDIT_FAIL = "不是专辑负责人,编辑失败";
+
+    public static final String OPERATOR_SUCCESS = "操作成功!";
+
+    public static final String APPROVAL_SUCCESS = "审核成功!";
+
+    public static final String BATCH_APPROVAL_SUCCESS = "批量审核成功!";
+
+    public static final String NO_TYPE = "类型错误";
+
+    public static final String DEL_FAIL = "无法删除,该专辑未关闭";
+
+    public static final String DEL_SUCCESS = "删除成功!";
+
+    public static final String YELP_SUCCESS = "您发布的内容已提交后台审核，审核通过后全员可见!";
+
+    public static final String REPLY_SUCCESS = "回复成功!";
+
+}

src/main/java/com/redxun/knowledge/album/entity/dao/AlbumInfo.java

@@ -7,6 +7,8 @@ import lombok.Getter;
 import lombok.Setter;
 import lombok.experimental.Accessors;
 
+import java.util.Objects;
+
 /**
  * <pre>
  *
@@ -64,6 +66,12 @@ public class AlbumInfo  extends BaseExtEntity<String> {
     @TableField(value = "IS_DEL")
     private Integer isDel;
 
+    @TableField(exist = false)
+    private String versionId;
+
+    @TableField(exist = false)
+    private Integer versionState;
+
 
 
     @Override
@@ -76,6 +84,19 @@ public class AlbumInfo  extends BaseExtEntity<String> {
         this.pkId=pkId;
     }
 
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        if (!super.equals(o)) return false;
+        AlbumInfo albumInfo = (AlbumInfo) o;
+        return Objects.equals(pkId, albumInfo.pkId) && Objects.equals(categoryId, albumInfo.categoryId) && Objects.equals(name, albumInfo.name) && Objects.equals(cover, albumInfo.cover) && Objects.equals(ownerCompanyId, albumInfo.ownerCompanyId) && Objects.equals(ownerDepartmentId, albumInfo.ownerDepartmentId) && Objects.equals(ownerId, albumInfo.ownerId) && Objects.equals(state, albumInfo.state) && Objects.equals(views, albumInfo.views) && Objects.equals(isDel, albumInfo.isDel) && Objects.equals(versionId, albumInfo.versionId) && Objects.equals(versionState, albumInfo.versionState);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(super.hashCode(), pkId, categoryId, name, cover, ownerCompanyId, ownerDepartmentId, ownerId, state, views, isDel, versionId, versionState);
+    }
 
     /**
     生成子表属性的Array List

src/main/java/com/redxun/knowledge/album/entity/dao/AlbumYelp.java

@@ -54,6 +54,9 @@ public class AlbumYelp  extends BaseExtEntity<String> {
     @TableField(value = "IS_DEL")
     private Integer isDel;
 
+    @TableField(value = "APPROVAL_STATE")
+    private Integer approvalState;
+
 
 
     @Override

src/main/java/com/redxun/knowledge/album/entity/dao/AlbumYelpApprove.java

@@ -69,6 +69,9 @@ public class AlbumYelpApprove  extends BaseExtEntity<String> {
     @TableLogic
     @TableField(value = "IS_DEL")
     private Integer isDel;
+    //节点名称
+    @TableField(value = "NAME")
+    private String name;
 
 
 

src/main/java/com/redxun/knowledge/album/entity/dto/AlbumCatalogueDto.java

@@ -26,5 +26,5 @@ public class AlbumCatalogueDto implements Serializable {
     private String name;
 
     @ApiModelProperty("知识Id集合")
-    private List<Long> contents;
+    private List<String> contents;
 }

src/main/java/com/redxun/knowledge/album/entity/dto/AlbumInfoEditDto.java

@@ -0,0 +1,45 @@
+package com.redxun.knowledge.album.entity.dto;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import javax.validation.constraints.NotBlank;
+import java.io.Serializable;
+import java.util.List;
+
+/**
+ * 文件名: AlbumInfoEditDto
+ * 作者: Zizg
+ * 时间: 2023/2/8
+ * 描述:
+ * 修改人:
+ * 修改时间:
+ * 修改内容:
+ */
+@ApiModel("专辑编辑")
+@Data
+public class AlbumInfoEditDto implements Serializable {
+
+    @NotBlank(message = "专辑Id不能为空")
+    @ApiModelProperty("专辑Id")
+    private String pkId;
+    
+    @ApiModelProperty("版本Id 传值 修改当前版本 不传值 新增版本")
+    private String versionId;
+
+    @ApiModelProperty("专辑名称")
+    private String name;
+
+    @ApiModelProperty("专辑封面")
+    private String cover;
+
+    @ApiModelProperty("专辑分类Id")
+    private String categoryId;
+
+    @ApiModelProperty("专辑简介")
+    private String summary;
+
+    @ApiModelProperty("专辑目录")
+    private List<AlbumCatalogueDto> catalogues;
+}

src/main/java/com/redxun/knowledge/album/entity/dto/YelpDto.java

@@ -0,0 +1,33 @@
+package com.redxun.knowledge.album.entity.dto;
+
+import io.swagger.annotations.ApiModel;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.io.Serializable;
+
+/**
+ * 文件名: YelpDto
+ * 作者: Zizg
+ * 时间: 2023/2/10
+ * 描述:
+ * 修改人:
+ * 修改时间:
+ * 修改内容:
+ */
+@ApiModel("点评或回复Dto")
+@Data
+public class YelpDto implements Serializable {
+
+    @ApiModelProperty("专辑ID")
+    private String albumId;
+
+    @ApiModelProperty("类型 1-点评  2-回复")
+    private Integer type;
+
+    @ApiModelProperty("点评内容")
+    private String content;
+
+    @ApiModelProperty("回复点评ID 对应专辑的点评ID")
+    private String yelpId;
+}

src/main/java/com/redxun/knowledge/album/entity/vo/AlbumApproveListVo.java

@@ -81,4 +81,7 @@ public class AlbumApproveListVo implements Serializable {
     @ApiModelProperty("节点审核人Id 前端不需要使用")
     private String approverId;
 
+    @ApiModelProperty("收入知识量")
+    private Integer knowledgeTotal;
+
 }

src/main/java/com/redxun/knowledge/album/entity/vo/AlbumInfoDetailPcVo.java

@@ -35,4 +35,7 @@ public class AlbumInfoDetailPcVo extends AlbumInfoDetailVo {
 
     @ApiModelProperty("版本Id")
     private String versionId;
+
+    @ApiModelProperty("专辑所属人Id")
+    private String ownerId;
 }

src/main/java/com/redxun/knowledge/album/mapper/AlbumApproveMapper.java

@@ -15,4 +15,10 @@ import java.util.Map;
 public interface AlbumApproveMapper extends BaseDao<AlbumApprove> {
 
     IPage findAllAlbumApprove(IPage page, @Param("params") Map<String, Object> params, @Param("w") Map<String, Object> order);
+
+    /**
+     * 根据版本Id删除记录
+     * @param pkId
+     */
+    void deleteByVersionId(String pkId);
 }

src/main/java/com/redxun/knowledge/album/mapper/AlbumCatalogueKnowledgeMapper.java

@@ -3,6 +3,9 @@ package com.redxun.knowledge.album.mapper;
 import com.redxun.common.base.db.BaseDao;
 import com.redxun.knowledge.album.entity.dao.AlbumCatalogueKnowledge;
 import org.apache.ibatis.annotations.Mapper;
+import org.apache.ibatis.annotations.Param;
+
+import java.util.List;
 
 /**
 * 业务--专辑目录知识表数据库访问层
@@ -10,4 +13,9 @@ import org.apache.ibatis.annotations.Mapper;
 @Mapper
 public interface AlbumCatalogueKnowledgeMapper extends BaseDao<AlbumCatalogueKnowledge> {
 
+    /**
+     * 批量删除知识
+     * @param albumCatalogueIdList
+     */
+    void deleteByCatalogueId(@Param("ids") List<String> albumCatalogueIdList);
 }

src/main/java/com/redxun/knowledge/album/mapper/AlbumCatalogueMapper.java

@@ -15,4 +15,6 @@ import java.util.Map;
 public interface AlbumCatalogueMapper extends BaseDao<AlbumCatalogue> {
 
     IPage findAllAlbumCatalogue(IPage page, @Param("params") Map<String, Object> params, @Param("order") Map<String, Object> order);
+
+    void deleteByVersionId(String versionId);
 }

src/main/java/com/redxun/knowledge/album/mapper/AlbumInfoMapper.java

@@ -6,6 +6,7 @@ import com.redxun.knowledge.album.entity.dao.AlbumInfo;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 
+import java.util.List;
 import java.util.Map;
 
 /**
@@ -16,5 +17,35 @@ public interface AlbumInfoMapper extends BaseDao<AlbumInfo> {
 
     IPage findAllAlbumInfo(IPage<AlbumInfo> page, @Param("params") Map<String, Object> params, @Param("w") Map<String, Object> order);
 
+    /**
+     * 版本收入知识量
+     * @param albumId
+     * @param versionId
+     * @return
+     */
     Integer selectCountKnowledge(@Param("albumId") String albumId, @Param("versionId") String versionId);
+
+    /**
+     * 我的专辑分页(scope = 1)
+     * @param page
+     * @param params
+     * @param params1
+     * @return
+     */
+    IPage findAllAlbumInfoByOwnerIds(IPage page, @Param("params")Map<String, Object> params, @Param("w") Map<String, Object> params1);
+
+    /**
+     * 我的专辑和已发布的专辑
+     * @param page
+     * @param params
+     * @param params1
+     * @return
+     */
+    List<AlbumInfo> findAllAlbumInfoByVersionState(IPage page, @Param("params")Map<String, Object> params, @Param("w") Map<String, Object> params1);
+
+    /**
+     * 删除知识专辑
+     * @param ids
+     */
+    void deleteByIds(String ids);
 }

src/main/java/com/redxun/knowledge/album/mapper/AlbumVersionMapper.java

@@ -10,4 +10,9 @@ import org.apache.ibatis.annotations.Mapper;
 @Mapper
 public interface AlbumVersionMapper extends BaseDao<AlbumVersion> {
 
+    /**
+     * 删除该专辑下的版本信息
+     * @param ids 专辑Id
+     */
+    void deleteByAlbumId(String ids);
 }

src/main/java/com/redxun/knowledge/album/mapper/AlbumYelpApproveMapper.java

@@ -10,4 +10,9 @@ import org.apache.ibatis.annotations.Mapper;
 @Mapper
 public interface AlbumYelpApproveMapper extends BaseDao<AlbumYelpApprove> {
 
+    /**
+     * 根据专辑Id删除点评审核流程
+     * @param ids
+     */
+    void deleteByAlbumId(String ids);
 }

src/main/java/com/redxun/knowledge/album/mapper/AlbumYelpMapper.java

@@ -11,5 +11,9 @@ import org.apache.ibatis.annotations.Mapper;
 public interface AlbumYelpMapper extends BaseDao<AlbumYelp> {
 
 
-
+    /**
+     * 根据专辑Id删除点评信息
+     * @param ids
+     */
+    void deleteByAlbumId(String ids);
 }

src/main/java/com/redxun/knowledge/album/service/AlbumApproveServiceImpl.java

@@ -128,12 +128,28 @@ public class AlbumApproveServiceImpl extends SuperServiceImpl<AlbumApproveMapper
     private List<AlbumApproveVo> getApprovals(String versionId){
         List<AlbumApprove> albumApproveList = albumApproveMapper.selectList(new LambdaQueryWrapper<AlbumApprove>().
                 eq(AlbumApprove::getVersionId, versionId).orderByAsc(AlbumApprove::getSort));
-        List<AlbumApproveVo> albumApproveVoList = albumApproveList.parallelStream().map(e -> {
+        //结果集
+        List<AlbumApproveVo> albumApproveVoList = new ArrayList<>();
+        boolean flag = true;
+        for (int i = 0; i < albumApproveList.size(); i++) {
             AlbumApproveVo albumApproveVo = new AlbumApproveVo();
-            BeanUtils.copyProperties(e, albumApproveVo);
-            albumApproveVo.setComment(e.getRemark());
-            return albumApproveVo;
-        }).collect(Collectors.toList());
+            BeanUtils.copyProperties(albumApproveList.get(i), albumApproveVo);
+            albumApproveVo.setComment(albumApproveList.get(i).getRemark());
+            if (albumApproveList.get(i).getResult() == null) {
+                if (flag) {
+                    albumApproveVo.setApprovalStatus("提交审核");
+                    flag = false;
+                } else {
+                    albumApproveVo.setApprovalStatus("");
+                }
+            } else if (albumApproveList.get(i).getResult() == 0) {
+                albumApproveVo.setApprovalStatus("审核驳回");
+                flag = false;
+            } else if (albumApproveList.get(i).getResult() == 1) {
+                albumApproveVo.setApprovalStatus("审核通过");
+            }
+            albumApproveVoList.add(albumApproveVo);
+        }
         return albumApproveVoList;
     }
 
@@ -148,7 +164,7 @@ public class AlbumApproveServiceImpl extends SuperServiceImpl<AlbumApproveMapper
         Map<String, Object> params = PageHelper.constructParams(queryFilter);
         String type = (String) queryFilter.getParams().get("type");
         //获取全部数据
-        IPage page = albumApproveMapper.findAllAlbumApprove(queryFilter.getPage(), queryFilter.getParams(), params);;
+        IPage page = albumApproveMapper.findAllAlbumApprove(queryFilter.getPage(), queryFilter.getParams(), params);
         List<AlbumApprove> albumApproveList = page.getRecords();
         //根据专辑Id进行数据分组
         Map<String, List<AlbumApprove>> albumApproveMap = albumApproveList.stream().collect(Collectors.groupingBy(AlbumApprove::getAlbumId));
@@ -178,6 +194,8 @@ public class AlbumApproveServiceImpl extends SuperServiceImpl<AlbumApproveMapper
                 albumApproveListVo.setApproverId(value.get(i).getApproverId());
                 albumApproveListVo.setVersionId(value.get(i).getAlbumVersion().getPkId());
                 albumApproveListVo.setApprovalId(value.get(i).getPkId());
+                Integer knowledgeTotal = albumInfoMapper.selectCountKnowledge(value.get(i).getAlbumInfo().getPkId(), value.get(i).getAlbumVersion().getPkId());
+                albumApproveListVo.setKnowledgeTotal(knowledgeTotal);
                 List<String> actionFlag = new ArrayList<>();
                 if (value.get(i).getAlbumVersion().getApprovalState() == 1 || value.get(i).getAlbumVersion().getApprovalState() == 2) {
                     actionFlag.add("approve");
@@ -268,6 +286,7 @@ public class AlbumApproveServiceImpl extends SuperServiceImpl<AlbumApproveMapper
         if (StringUtils.isEmpty(albumApprovalRemark.getRemark())){
             albumApprovalRemark.setRemark("");
         }
+        // TODO: 2023/2/8  判断是否审核过且是否有资格审核
         approvalIdList.forEach(approvalId -> {
             //插入审核结论
             AlbumApprove albumApprove = new AlbumApprove();
@@ -326,4 +345,12 @@ public class AlbumApproveServiceImpl extends SuperServiceImpl<AlbumApproveMapper
         });
 
     }
+
+    /**
+     * 根据版本Id删除记录
+     * @param pkId
+     */
+    public void deleteByVersionId(String pkId) {
+        albumApproveMapper.deleteByVersionId(pkId);
+    }
 }

src/main/java/com/redxun/knowledge/album/service/AlbumCatalogueServiceImpl.java

@@ -2,6 +2,7 @@ package com.redxun.knowledge.album.service;
 
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
 import com.redxun.common.base.db.BaseDao;
 import com.redxun.common.base.db.BaseService;
 import com.redxun.common.base.db.PageHelper;
@@ -114,4 +115,21 @@ public class AlbumCatalogueServiceImpl extends SuperServiceImpl<AlbumCatalogueMa
         }
         return page;
     }
+
+    /**
+     * 清除该版本下原有目录(同时清除目录下的知识)
+     * @param versionId
+     */
+    public void deleteByVersionId(String versionId) {
+        albumCatalogueMapper.deleteByVersionId(versionId);
+        //清除知识
+        List<AlbumCatalogue> albumCatalogueList = albumCatalogueMapper.
+                selectList(new LambdaQueryWrapper<AlbumCatalogue>().eq(AlbumCatalogue::getVersionId, versionId));
+        List<String> albumCatalogueIdList = albumCatalogueList.parallelStream().map(AlbumCatalogue::getPkId).collect(Collectors.toList());
+        //批量删除知识
+        if (CollectionUtils.isNotEmpty(albumCatalogueIdList)){
+            albumCatalogueKnowledgeMapper.deleteByCatalogueId(albumCatalogueIdList);
+        }
+
+    }
 }

src/main/java/com/redxun/knowledge/album/service/AlbumInfoServiceImpl.java

@@ -1,5 +1,6 @@
 package com.redxun.knowledge.album.service;
 
+import cn.hutool.core.util.StrUtil;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.metadata.IPage;
@@ -11,12 +12,11 @@ import com.redxun.common.base.db.PageHelper;
 import com.redxun.common.base.search.QueryFilter;
 import com.redxun.common.service.impl.SuperServiceImpl;
 import com.redxun.common.tool.IdGenerator;
+import com.redxun.common.tool.StringUtils;
 import com.redxun.dto.user.OsUserDto;
+import com.redxun.knowledge.album.entity.consts.AlbumConst;
 import com.redxun.knowledge.album.entity.dao.*;
-import com.redxun.knowledge.album.entity.dto.AlbumApprovalNodeDto;
-import com.redxun.knowledge.album.entity.dto.AlbumCatalogueDto;
-import com.redxun.knowledge.album.entity.dto.AlbumInfoDto;
-import com.redxun.knowledge.album.entity.dto.TransferOwnerDto;
+import com.redxun.knowledge.album.entity.dto.*;
 import com.redxun.knowledge.album.entity.enums.AlbumInfoEnum;
 import com.redxun.knowledge.album.entity.enums.AlbumVersionEnum;
 import com.redxun.knowledge.album.entity.vo.*;
@@ -26,25 +26,26 @@ import com.redxun.knowledge.entity.dao.Knowledge;
 import com.redxun.knowledge.entity.vo.KnowledgeCategoryAdminVo;
 import com.redxun.knowledge.service.KnowledgeCategoryServiceImpl;
 import com.redxun.knowledge.service.KnowledgeServiceImpl;
+import com.redxun.knowledge.utils.PageListUtils;
 import com.sun.xml.bind.v2.TODO;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
 import javax.annotation.Resource;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.io.Serializable;
+import java.util.*;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 
 /**
-* [业务--专辑基本信息表]业务服务类
-*/
+ * [业务--专辑基本信息表]业务服务类
+ */
+@Slf4j
 @Service
 public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, AlbumInfo> implements BaseService<AlbumInfo> {
 
@@ -76,10 +77,13 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
     private AlbumApproveServiceImpl albumApproveService;
 
     @Autowired
-    private KnowledgeServiceImpl knowledgeService;
+    private AlbumCatalogueServiceImpl albumCatalogueService;
 
     @Autowired
-    private KnowledgeCategoryServiceImpl knowledgeCategoryService;
+    private AlbumYelpServiceImpl albumYelpService;
+
+    @Autowired
+    private AlbumYelpApproveServiceImpl albumYelpApproveService;
 
     @Autowired
     private UserService userService;
@@ -94,6 +98,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
 
     /**
      * 新增专辑
+     *
      * @param albumInfoDto 专辑基本信息&专辑目录&目录下收录知识
      * @return
      */
@@ -120,78 +125,76 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
         albumVersion.setSummary(albumInfoDto.getSummary());
         albumVersion.setUpdateBy(osUserDto.getUserId());
         albumVersionMapper.insert(albumVersion);
-        //拉取专辑审核节点表
-        List<AlbumApprovalNode> albumApprovalNodeList = albumApprovalNodeService.
-                findAll(new QueryWrapper<AlbumApprovalNode>().orderByAsc("IS_FINAL", "CREATE_TIME_"));
-        //将版本推送至专辑审核表中(各个节点都推送)
-        AtomicInteger sort = new AtomicInteger(1);
-        List<AlbumApprove> albumApproveList = albumApprovalNodeList.stream().map(albumApprovalNode -> {
-            AlbumApprove albumApprove = new AlbumApprove();
-            albumApprove.setPkId(IdGenerator.getIdStr());
-            albumApprove.setAlbumId(albumInfo.getPkId());
-            albumApprove.setVersionId(albumVersion.getPkId());
-            albumApprove.setApproverId(albumApprovalNode.getApproverId());
-            albumApprove.setApproverName(albumApprovalNode.getApproverName());
-            albumApprove.setSort(sort.getAndIncrement());
-            albumApprove.setIsFinal(albumApprovalNode.getIsFinal());
-            albumApprove.setUpdateBy(userService.queryLoginUser());
-            albumApprove.setName(albumApprovalNode.getName());
-            return albumApprove;
-        }).collect(Collectors.toList());
-        albumApproveService.saveBatch(albumApproveList);
-        // 向专辑目录表中添加记录
-        if (CollectionUtils.isNotEmpty(albumInfoDto.getCatalogues())){
-            List<AlbumCatalogueDto> catalogueDtoList = albumInfoDto.getCatalogues();
-            AtomicInteger i = new AtomicInteger(1);
-            catalogueDtoList.forEach(catalogueDto -> {
-                AlbumCatalogue albumCatalogue = new AlbumCatalogue();
-                albumCatalogue.setPkId(IdGenerator.getIdStr());
-                albumCatalogue.setAlbumId(albumInfo.getPkId());
-                albumCatalogue.setVersionId(albumVersion.getPkId());
-                albumCatalogue.setName(catalogueDto.getName());
-                albumCatalogue.setSort(i.getAndIncrement());
-                albumCatalogue.setUpdateBy(osUserDto.getUserId());
-                //向专辑目录知识表中添加记录
-                if (CollectionUtils.isNotEmpty(catalogueDto.getContents())){
-                    List<Long> contentIdList = catalogueDto.getContents();
-                    contentIdList.forEach(contentId -> {
-                        AlbumCatalogueKnowledge albumCatalogueKnowledge = new AlbumCatalogueKnowledge();
-                        albumCatalogueKnowledge.setPkId(IdGenerator.getIdStr());
-                        albumCatalogueKnowledge.setCatalogueId(albumCatalogue.getPkId());
-                        albumCatalogueKnowledge.setKnowledgeId(contentId.toString());
-                        albumCatalogueKnowledge.setUpdateBy(osUserDto.getUserId());
-                        albumCatalogueKnowledgeMapper.insert(albumCatalogueKnowledge);
-                    });
-                }
-                albumCatalogueMapper.insert(albumCatalogue);
-            });
+        //生成目录
+        if (CollectionUtils.isNotEmpty(albumInfoDto.getCatalogues())) {
+            createCatalogue(albumInfoDto.getCatalogues(), albumInfo.getPkId(), albumVersion.getPkId());
         }
+        //生成最新版审核流程数据
+        createAlbumApprove(albumInfo.getPkId(), albumVersion.getPkId());
+
         return albumInfo.getPkId();
     }
 
     public IPage query(QueryFilter queryFilter) {
         Map<String, Object> params = PageHelper.constructParams(queryFilter);
+        //构建PC端参数
+        Map<String, Object> map = new HashMap<>();
         //PC端条件过滤
-        if (queryFilter.getParams().containsKey("scope")){
+        if (queryFilter.getParams().containsKey("scope")) {
             String scope = (String) queryFilter.getParams().get("scope");
-            Map<String, Object> map = new HashMap<>();
-            if (scope.equals("1")){
-                //我的专辑
-                map.put("ownerId",userService.queryLoginUser());
-                queryFilter.setParams(map);
-            }else if (scope.equals("2")){
-                // TODO: 2023/2/6 查看已发布的专辑和我自己的待审核的专辑
-                //已发布的专辑
-                map.put("state",2);
-                queryFilter.setParams(map);
-            }else if (scope.equals("3")){
-                // TODO: 2023/2/3  我点评过的专辑
-                map.put("yelp",1);
+
+            switch (scope) {
+                case "1":
+                    //我的专辑
+                    map.put("ownerIds", userService.queryLoginUser());
+                    queryFilter.setParams(map);
+                    //查询我的专辑
+                    IPage page1 = albumInfoMapper.findAllAlbumInfoByOwnerIds(queryFilter.getPage(), queryFilter.getParams(), params);
+                    List<AlbumInfo> records = page1.getRecords();
+                    List<AlbumInfoVo> albumInfoVoList = pageInfo(records);
+                    page1.setRecords(albumInfoVoList);
+                    return page1;
+                case "2":
+                    //我的专辑
+                    QueryWrapper<AlbumInfo> queryWrapper = new QueryWrapper<>();
+                    queryWrapper.eq("OWNER_ID",userService.queryLoginUser());
+                    queryWrapper.eq("STATE",1);
+                    queryWrapper.like(StringUtils.isNotEmpty((String) queryFilter.getParams().get("name")),"NAME",(String) queryFilter.getParams().get("name"));
+                    queryWrapper.orderByDesc("CREATE_TIME_");
+                    List<AlbumInfo> ownerIdsList = albumInfoMapper.selectList(queryWrapper);
+                    //已发布的专辑
+                    map.put("versionState", 2);
+                    queryFilter.setParams(map);
+                    List<AlbumInfo> albumInfoList = albumInfoMapper.findAllAlbumInfoByVersionState(queryFilter.getPage(), queryFilter.getParams(), params);
+                    if (albumInfoList != null){
+                        ownerIdsList.addAll(albumInfoList);
+                    }
+                    List<AlbumInfo> collect = ownerIdsList.stream().distinct().collect(Collectors.toList());
+                    List<AlbumInfoVo> albumInfoVoListResult = pageInfo(collect);
+                    Page page2 = PageListUtils.getPages(queryFilter.getPage().getCurrent(), queryFilter.getPage().getSize(), albumInfoVoListResult);
+                    return page2;
+                case "3":
+                    // TODO: 2023/2/3  我点评过的专辑
+                    map.put("scope", 3);
+                    map.put("scope","3");
+                    break;
             }
         }
         IPage page = albumInfoMapper.findAllAlbumInfo(queryFilter.getPage(), queryFilter.getParams(), params);
-        List<AlbumInfo> records = page.getRecords();
-        List<AlbumInfoVo> albumInfoVoList = records.parallelStream().map(e -> {
+        List<AlbumInfo> collect = page.getRecords();
+        List<AlbumInfoVo> albumInfoVoList = pageInfo(collect);
+        page.setRecords(albumInfoVoList);
+        return page;
+    }
+
+    /**
+     * 分页方法封装
+     * @param collect
+     * @return
+     */
+    private List<AlbumInfoVo> pageInfo(List<AlbumInfo> collect){
+        String userId = userService.queryLoginUser();
+        List<AlbumInfoVo> albumInfoVoList = collect.parallelStream().map(e -> {
             AlbumInfoVo albumInfoVo = new AlbumInfoVo();
             BeanUtils.copyProperties(e, albumInfoVo);
             //专辑分类信息
@@ -205,7 +208,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
                             selectOne(new LambdaQueryWrapper<AlbumCategory>().eq(AlbumCategory::getPkId, albumCategory.getParent()));
                     albumInfoVo.setCategoryName(albumCategoryParent.getName() + "|" + albumCategory.getName());
                 }
-            },threadPoolExecutor);
+            }, threadPoolExecutor);
             //专辑收录知识量(当前生效版本各个目录中知识数量总和)
             CompletableFuture<Void> countKnowledgeCompletableFuture = CompletableFuture.runAsync(() -> {
                 AlbumVersion albumVersion = albumVersionMapper.
@@ -218,7 +221,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
                             selectOne(new LambdaQueryWrapper<AlbumVersion>().
                                     eq(AlbumVersion::getAlbumId, e.getPkId()).
                                     eq(AlbumVersion::getState, 1));
-                    if (albumVersionFirst == null){
+                    if (albumVersionFirst == null) {
                         AlbumVersion albumVersionFour = albumVersionMapper.
                                 selectOne(new LambdaQueryWrapper<AlbumVersion>().
                                         eq(AlbumVersion::getAlbumId, e.getPkId()).
@@ -233,14 +236,14 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
                     Integer countKnowledge = albumInfoMapper.selectCountKnowledge(e.getPkId(), albumVersion.getPkId());
                     albumInfoVo.setKnowledgeTotal(countKnowledge);
                 }
-            },threadPoolExecutor);
+            }, threadPoolExecutor);
             //专辑点评量(当前专辑中通过审核的点评量总和)
             CompletableFuture<Void> countYelpCompletableFuture = CompletableFuture.runAsync(() -> {
                 Integer countYelp = albumYelpMapper.selectCount(new LambdaQueryWrapper<AlbumYelp>().
                         eq(AlbumYelp::getAlbumId, e.getPkId()).
                         eq(AlbumYelp::getState, 1));
                 albumInfoVo.setYelpTotal(countYelp);
-            },threadPoolExecutor);
+            }, threadPoolExecutor);
             //其他参数
             CompletableFuture<Void> anotherCompletableFuture = CompletableFuture.runAsync(() -> {
                 //专辑负责人姓名
@@ -250,7 +253,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
                 //专辑状态名称(0 显示专辑状态,不显示版本状态 1 显示版本状态)
                 List<AlbumVersion> albumVersions = albumVersionMapper.selectList(new LambdaQueryWrapper<AlbumVersion>().
                         eq(AlbumVersion::getAlbumId, e.getPkId()).orderByDesc(AlbumVersion::getCreateTime));
-                if (e.getState() == 0){
+                if (e.getState() == 0) {
                     albumInfoVo.setStateName(AlbumInfoEnum.getMessage(e.getState()));
                 } else {
                     albumInfoVo.setVersionState(albumVersions.get(0).getState());
@@ -261,25 +264,27 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
                 albumInfoVo.setUpdateTime(e.getUpdateTime());
                 //动作标记(M 管理端)
                 List<String> actionFlagM = new ArrayList<>();
-                List<String> actionFlag = new ArrayList<>();
-                if (e.getState() == 0){
+                if (e.getState() == 0) {
                     actionFlagM.add("delete");
-                    //actionFlag.add("view");
-                } else if (e.getState() == 1 && albumVersions.get(0).getState() == 1){
                     actionFlagM.add("view");
-                    //actionFlag.add("view");
-                    //actionFlag.add("edit");
-                } else if (e.getState() == 1 && albumVersions.get(0).getState() == 2){
+                } else if (e.getState() == 1 && albumVersions.get(0).getState() == 1) {
+                    actionFlagM.add("view");
+                } else if (e.getState() == 1 && albumVersions.get(0).getState() == 2) {
                     actionFlagM.add("edit");
-                }else if (e.getState() == 1 && albumVersions.get(0).getState() == 4){
+                } else if (e.getState() == 1 && albumVersions.get(0).getState() == 4) {
                     actionFlagM.add("view");
-                    //actionFlag.add("delete");
-                    //actionFlag.add("view");
-                    //actionFlag.add("edit");
                 }
-                albumInfoVo.setActionFlagM(actionFlagM);
+                //动作标记PC端
+                List<String> actionFlag = new ArrayList<>();
+                if (albumVersions.get(0).getState() == 2 && e.getOwnerId().equals(userId)){
+                    actionFlag.add("edit");
+                } else if(albumVersions.get(0).getState() == 4 && e.getOwnerId().equals(userId)){
+                    actionFlag.add("delete");
+                    actionFlag.add("edit");
+                }
                 albumInfoVo.setActionFlag(actionFlag);
-            },threadPoolExecutor);
+                albumInfoVo.setActionFlagM(actionFlagM);
+            }, threadPoolExecutor);
             CompletableFuture.allOf(
                     categoryCompletableFuture,
                     countKnowledgeCompletableFuture,
@@ -287,19 +292,19 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
                     anotherCompletableFuture).join();
             return albumInfoVo;
         }).collect(Collectors.toList());
-        page.setRecords(albumInfoVoList);
-        return page;
+        return albumInfoVoList;
     }
 
     /**
      * 专辑详情
+     *
      * @param pkId
      * @return
      */
     public AlbumInfoDetailVo detail(String pkId) {
         AlbumInfoDetailVo albumInfoDetailVo = new AlbumInfoDetailVo();
         AlbumInfo albumInfo = albumInfoMapper.selectById(pkId);
-        BeanUtils.copyProperties(albumInfo,albumInfoDetailVo);
+        BeanUtils.copyProperties(albumInfo, albumInfoDetailVo);
         //专辑负责人姓名
         albumInfoDetailVo.setOwner(userService.queryOsUserDto(albumInfo.getOwnerId()).getFullName());
         //所属公司名称
@@ -324,7 +329,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
         albumInfoDetailVo.setYelpTotal(countYelp);
         //专辑版本信息
         QueryWrapper<AlbumVersion> queryWrapper = new QueryWrapper<>();
-        queryWrapper.eq("ALBUM_ID",pkId);
+        queryWrapper.eq("ALBUM_ID", pkId);
         queryWrapper.orderByDesc("CREATE_TIME_");
         List<AlbumVersion> albumVersions = albumVersionMapper.selectList(queryWrapper);
         //最新版本状态
@@ -333,7 +338,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
         //专辑版本集合
         List<AlbumVersionVo> albumVersionVoList = albumVersions.parallelStream().map(albumVersion -> {
             AlbumVersionVo albumVersionVo = new AlbumVersionVo();
-            BeanUtils.copyProperties(albumVersion,albumVersionVo);
+            BeanUtils.copyProperties(albumVersion, albumVersionVo);
             //版本状态名称
             albumVersionVo.setStateName(AlbumVersionEnum.getMessage(albumVersion.getState()));
             return albumVersionVo;
@@ -342,11 +347,11 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
         //专辑详情动作标记
         long count = albumVersions.stream().filter(e -> e.getState() == 2).count();
         List<String> actionFlag = new ArrayList<>();
-        if (albumInfo.getState() == 1 && count > 0){
+        if (albumInfo.getState() == 1 && count > 0) {
             actionFlag.add("edit");
             actionFlag.add("transfer");
             actionFlag.add("close");
-        } else if (albumInfo.getState() == 0 && count > 0){
+        } else if (albumInfo.getState() == 0 && count > 0) {
             actionFlag.add("edit");
             actionFlag.add("transfer");
             actionFlag.add("open");
@@ -357,6 +362,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
 
     /**
      * 专辑版本详情
+     *
      * @param pkId
      * @return
      */
@@ -371,42 +377,42 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
                         eq(AlbumApprove::getVersionId, pkId).
                         isNull(AlbumApprove::getResult).
                         orderByAsc(AlbumApprove::getSort));
-        if (CollectionUtils.isNotEmpty(albumApproveLists)){
+        if (CollectionUtils.isNotEmpty(albumApproveLists)) {
             albumVersionDetailVo.setApprovalId(albumApproveLists.get(0).getPkId());
         }
         //目录下知识的动作标记
         List<String> actionFlag = new ArrayList<>();
-        if (albumVersion.getState() == 1){
+        if (albumVersion.getState() == 1) {
             actionFlag.add("view");
-        } else if (albumVersion.getState() == 2){
+        } else if (albumVersion.getState() == 2) {
             actionFlag.add("delete");
             actionFlag.add("view");
-        } else if (albumVersion.getState() == 3){
+        } else if (albumVersion.getState() == 3) {
             actionFlag.add("view");
         }
         //审批流程节点
         QueryWrapper<AlbumApprove> queryWrapper = new QueryWrapper<>();
-        queryWrapper.eq("ALBUM_ID",albumVersion.getAlbumId());
-        queryWrapper.eq("VERSION_ID",pkId);
+        queryWrapper.eq("ALBUM_ID", albumVersion.getAlbumId());
+        queryWrapper.eq("VERSION_ID", pkId);
         queryWrapper.orderByAsc("SORT");
         List<AlbumApprove> albumApproveList = albumApproveService.findAll(queryWrapper);
         List<AlbumApproveVo> albumApproveVoList = new ArrayList<>();
         boolean flag = true;
         for (int i = 0; i < albumApproveList.size(); i++) {
             AlbumApproveVo albumApproveVo = new AlbumApproveVo();
-            BeanUtils.copyProperties(albumApproveList.get(i),albumApproveVo);
+            BeanUtils.copyProperties(albumApproveList.get(i), albumApproveVo);
             albumApproveVo.setComment(albumApproveList.get(i).getRemark());
-            if (albumApproveList.get(i).getResult() == null){
-                if (flag){
+            if (albumApproveList.get(i).getResult() == null) {
+                if (flag) {
                     albumApproveVo.setApprovalStatus("提交审核");
                     flag = false;
                 } else {
                     albumApproveVo.setApprovalStatus("");
                 }
-            } else if (albumApproveList.get(i).getResult() == 0){
+            } else if (albumApproveList.get(i).getResult() == 0) {
                 albumApproveVo.setApprovalStatus("审核驳回");
                 flag = false;
-            } else if (albumApproveList.get(i).getResult() == 1){
+            } else if (albumApproveList.get(i).getResult() == 1) {
                 albumApproveVo.setApprovalStatus("审核通过");
             }
             albumApproveVoList.add(albumApproveVo);
@@ -418,6 +424,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
 
     /**
      * 批量更新审核流程节点数据
+     *
      * @param albumApprovalNodeDtoList
      */
     @Transactional(rollbackFor = Exception.class)
@@ -458,6 +465,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
 
     /**
      * 查询专辑审核节点表数据
+     *
      * @return
      */
     public List<AlbumApproverNodeVo> approveFlowsAlbumApprovalNode() {
@@ -473,6 +481,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
 
     /**
      * 查询点评审核节点表数据
+     *
      * @return
      */
     public List<AlbumApproverNodeVo> approveFlowsAlbumYelpApprovalNode() {
@@ -487,6 +496,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
 
     /**
      * PC端根据知识专辑ID获取知识专辑详情
+     *
      * @param pkId
      * @return
      */
@@ -497,7 +507,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
         AlbumInfo albumInfo = this.get(pkId);
         //专辑详情(封装数据)
         AlbumInfoDetailVo albumInfoDetailVo = detail(pkId);
-        BeanUtils.copyProperties(albumInfoDetailVo,albumInfoDetailPcVo);
+        BeanUtils.copyProperties(albumInfoDetailVo, albumInfoDetailPcVo);
         albumInfoDetailPcVo.setVersions(new ArrayList<>());
         //专辑分类赋值
         AlbumCategory albumCategory = albumCategoryMapper.selectById(albumInfo.getCategoryId());
@@ -512,19 +522,19 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
         }
         //判断登录人是否是专辑所属人(是 查看审核中的版本(没有审核中的,查看已发布的) 不是 查看已发布的版本)
         String userId = userService.queryLoginUser();
-        if (albumInfo.getOwnerId().equals(userId)){
+        if (albumInfo.getOwnerId().equals(userId)) {
             //查询版本信息(审核中)
             AlbumVersion albumVersion1 = albumVersionMapper.
                     selectOne(new QueryWrapper<AlbumVersion>().eq("ALBUM_ID", pkId).eq("STATE", 1));
             //查询版本信息(驳回)
             AlbumVersion albumVersion4 = albumVersionMapper.
                     selectOne(new QueryWrapper<AlbumVersion>().eq("ALBUM_ID", pkId).eq("STATE", 4));
-            if (albumVersion1 != null){
+            if (albumVersion1 != null) {
                 albumInfoDetailPcVo.setSummary(albumVersion1.getSummary());
                 albumInfoDetailPcVo.setVersionId(albumVersion1.getPkId());
                 albumInfoDetailPcVo.setState(albumVersion1.getState());
                 albumInfoDetailPcVo.setStateName(AlbumInfoEnum.getMessage(albumVersion1.getState()));
-            } else if (albumVersion4 != null){
+            } else if (albumVersion4 != null) {
                 albumInfoDetailPcVo.setSummary(albumVersion4.getSummary());
                 albumInfoDetailPcVo.setVersionId(albumVersion4.getPkId());
                 albumInfoDetailPcVo.setState(albumVersion4.getState());
@@ -539,6 +549,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
                 albumInfoDetailPcVo.setStateName(AlbumInfoEnum.getMessage(albumVersion2.getState()));
             }
             albumInfoDetailPcVo.setShowStatus(1);
+            albumInfoDetailPcVo.setOwnerId(albumInfo.getOwnerId());
             List<String> actionFlag = new ArrayList<>();
             actionFlag.add("edit");
             albumInfoDetailPcVo.setActionFlag(actionFlag);
@@ -546,7 +557,7 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
             //不是专辑所属人,查看已发布的版本信息
             AlbumVersion albumVersion2 = albumVersionMapper.
                     selectOne(new QueryWrapper<AlbumVersion>().eq("ALBUM_ID", pkId).eq("STATE", 2));
-            if (albumVersion2 == null){
+            if (albumVersion2 == null) {
                 albumInfoDetailPcVo.setShowStatus(0);
                 return albumInfoDetailPcVo;
             }
@@ -554,13 +565,16 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
             albumInfoDetailPcVo.setVersionId(albumVersion2.getPkId());
             albumInfoDetailPcVo.setState(albumVersion2.getState());
             albumInfoDetailPcVo.setStateName(AlbumInfoEnum.getMessage(albumVersion2.getState()));
+            albumInfoDetailPcVo.setOwnerId(albumInfo.getOwnerId());
             albumInfoDetailPcVo.setShowStatus(0);
+            albumInfoDetailPcVo.setActionFlag(new ArrayList<>());
         }
         return albumInfoDetailPcVo;
     }
 
     /**
      * 转移专辑负责人
+     *
      * @param transferOwnerDto
      */
     public void transferOwner(TransferOwnerDto transferOwnerDto) {
@@ -574,18 +588,167 @@ public class AlbumInfoServiceImpl extends SuperServiceImpl<AlbumInfoMapper, Albu
 
     /**
      * 关闭专辑&开启专辑
+     *
      * @param transferOwnerDto
      */
-    public void close(TransferOwnerDto transferOwnerDto) {
+    public synchronized void close(TransferOwnerDto transferOwnerDto) {
         String pkId = transferOwnerDto.getPkId();
         AlbumInfo albumInfoById = albumInfoMapper.selectById(pkId);
         AlbumInfo albumInfo = new AlbumInfo();
         albumInfo.setPkId(pkId);
-        if (albumInfoById.getState() == 1){
+        if (albumInfoById.getState() == 1) {
             albumInfo.setState(0);
         } else {
             albumInfo.setState(1);
         }
         albumInfoMapper.updateById(albumInfo);
     }
+
+    /**
+     * PC端编辑知识专辑
+     *
+     * @param albumInfoEditDto
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public String edit(AlbumInfoEditDto albumInfoEditDto) {
+        //判断当前登录人是否是专辑负责人
+        String userId = userService.queryLoginUser();
+        String albumId = albumInfoEditDto.getPkId();
+        AlbumInfo albumInfo = albumInfoMapper.selectById(albumId);
+        if (userId.equals(albumInfo.getOwnerId())) {
+            //修改专辑信息表
+            AlbumInfo albumInfoEdit = new AlbumInfo();
+            BeanUtils.copyProperties(albumInfoEditDto, albumInfoEdit);
+            albumInfoMapper.updateById(albumInfoEdit);
+            //如果有驳回版本的,在驳回的版本上进行修改,不新增版本
+            AlbumVersion albumVersion4 = albumVersionMapper.selectOne(new LambdaQueryWrapper<AlbumVersion>().
+                    eq(AlbumVersion::getAlbumId, albumId).eq(AlbumVersion::getState, 4));
+            AlbumVersion albumVersion = new AlbumVersion();
+            if (albumVersion4 != null) {
+                //修改版本表数据
+                albumVersion.setPkId(albumVersion4.getPkId());
+                albumVersion.setApplyUserId(userId);
+                albumVersion.setSummary(albumInfoEditDto.getSummary());
+                albumVersion.setState(1);
+                albumVersion.setApprovalState(1);
+                albumVersionMapper.updateById(albumVersion);
+                //生成目录
+                if (CollectionUtils.isNotEmpty(albumInfoEditDto.getCatalogues())) {
+                    //清除该版本下原有目录
+                    albumCatalogueService.deleteByVersionId(albumVersion4.getPkId());
+                    //在该版本下生成新的目录
+                    createCatalogue(albumInfoEditDto.getCatalogues(), albumInfo.getPkId(), albumVersion4.getPkId());
+                }
+                //修改审核记录(删除原有流程,生成新的流程)
+                albumApproveService.deleteByVersionId(albumVersion4.getPkId());
+                //生成最新版审核流程数据
+                createAlbumApprove(albumInfo.getPkId(), albumVersion4.getPkId());
+            } else {
+                //新增版本表数据
+                albumVersion.setPkId(IdGenerator.getIdStr());
+                albumVersion.setAlbumId(albumId);
+                albumVersion.setApplyUserId(userId);
+                albumVersion.setSummary(albumInfoEditDto.getSummary());
+                albumVersion.setUpdateBy(userId);
+                albumVersion.setState(1);
+                albumVersion.setApprovalState(1);
+                albumVersionMapper.insert(albumVersion);
+                //在该版本下新增目录
+                if (CollectionUtils.isNotEmpty(albumInfoEditDto.getCatalogues())) {
+                    //在该版本下生成新的目录
+                    createCatalogue(albumInfoEditDto.getCatalogues(), albumInfo.getPkId(), albumVersion.getPkId());
+                }
+                //生成最新版审核流程数据
+                createAlbumApprove(albumInfo.getPkId(), albumVersion.getPkId());
+            }
+            return "";
+        } else {
+            return AlbumConst.EDIT_FAIL;
+        }
+    }
+
+    /**
+     * 生成最新版审核流程数据
+     */
+    private void createAlbumApprove(String albumId, String versionId) {
+        //拉取专辑审核节点表
+        List<AlbumApprovalNode> albumApprovalNodeList = albumApprovalNodeService.
+                findAll(new QueryWrapper<AlbumApprovalNode>().orderByAsc("IS_FINAL", "CREATE_TIME_"));
+        //将版本推送至专辑审核表中(各个节点都推送)
+        AtomicInteger sort = new AtomicInteger(1);
+        List<AlbumApprove> albumApproveList = albumApprovalNodeList.stream().map(albumApprovalNode -> {
+            AlbumApprove albumApprove = new AlbumApprove();
+            albumApprove.setPkId(IdGenerator.getIdStr());
+            albumApprove.setAlbumId(albumId);
+            albumApprove.setVersionId(versionId);
+            albumApprove.setApproverId(albumApprovalNode.getApproverId());
+            albumApprove.setApproverName(albumApprovalNode.getApproverName());
+            albumApprove.setSort(sort.getAndIncrement());
+            albumApprove.setIsFinal(albumApprovalNode.getIsFinal());
+            albumApprove.setUpdateBy(userService.queryLoginUser());
+            albumApprove.setName(albumApprovalNode.getName());
+            return albumApprove;
+        }).collect(Collectors.toList());
+        //批量添加
+        albumApproveService.saveBatch(albumApproveList);
+    }
+
+    /**
+     * 生成专辑目录
+     *
+     * @param catalogueDtoList
+     * @param albumId
+     * @param versionId
+     */
+    private void createCatalogue(List<AlbumCatalogueDto> catalogueDtoList, String albumId, String versionId) {
+        // 向专辑目录表中添加记录
+        AtomicInteger i = new AtomicInteger(1);
+        catalogueDtoList.forEach(catalogueDto -> {
+            AlbumCatalogue albumCatalogue = new AlbumCatalogue();
+            albumCatalogue.setPkId(IdGenerator.getIdStr());
+            albumCatalogue.setAlbumId(albumId);
+            albumCatalogue.setVersionId(versionId);
+            albumCatalogue.setName(catalogueDto.getName());
+            albumCatalogue.setSort(i.getAndIncrement());
+            albumCatalogue.setUpdateBy(userService.queryLoginUser());
+            //向专辑目录知识表中添加记录
+            if (CollectionUtils.isNotEmpty(catalogueDto.getContents())) {
+                List<String> contentIdList = catalogueDto.getContents();
+                contentIdList.forEach(contentId -> {
+                    AlbumCatalogueKnowledge albumCatalogueKnowledge = new AlbumCatalogueKnowledge();
+                    albumCatalogueKnowledge.setPkId(IdGenerator.getIdStr());
+                    albumCatalogueKnowledge.setCatalogueId(albumCatalogue.getPkId());
+                    albumCatalogueKnowledge.setKnowledgeId(contentId);
+                    albumCatalogueKnowledge.setUpdateBy(userService.queryLoginUser());
+                    albumCatalogueKnowledgeMapper.insert(albumCatalogueKnowledge);
+                });
+            }
+            albumCatalogueMapper.insert(albumCatalogue);
+        });
+    }
+
+    /**
+     * 删除知识专辑
+     * @param ids
+     * @return
+     */
+    @Transactional(rollbackFor = Exception.class)
+    public String del(String ids) {
+        List<AlbumVersion> albumVersions = albumVersionMapper.selectList(new LambdaQueryWrapper<AlbumVersion>().eq(AlbumVersion::getAlbumId, ids));
+        //删除专辑信息
+        albumInfoMapper.deleteByIds(ids);
+        //删除专辑版本
+        albumVersionMapper.deleteByAlbumId(ids);
+        albumVersions.forEach(e -> {
+            //删除专辑目录及下面的知识
+            albumCatalogueService.deleteByVersionId(e.getPkId());
+            //删除专辑审核流程
+            albumApproveService.deleteByVersionId(e.getPkId());
+        });
+        //删除专辑的点评信息
+        albumYelpService.deleteByAlbumId(ids);
+        //删除专辑的点评审核流程
+        albumYelpApproveService.deleteByAlbumId(ids);
+        return AlbumConst.DEL_SUCCESS;
+    }
 }

src/main/java/com/redxun/knowledge/album/service/AlbumVersionServiceImpl.java

@@ -111,13 +111,13 @@ public class AlbumVersionServiceImpl extends SuperServiceImpl<AlbumVersionMapper
         List<AlbumCataloguePcVo> albumCataloguePcVos = albumCatalogueList.parallelStream().map(e -> {
             AlbumCataloguePcVo albumCataloguePcVo = new AlbumCataloguePcVo();
             BeanUtils.copyProperties(e, albumCataloguePcVo);
+            //找到对应的版本
+            AlbumVersion albumVersion = albumVersionMapper.selectById(versionId);
             //动作标记
             List<String> actionFlag = new ArrayList<>();
-            if (ownerId.equals(userId)){
+            if (ownerId.equals(userId) && albumVersion.getState() != 1){
                 actionFlag.add("edit");
                 actionFlag.add("delete");
-            } else {
-                actionFlag = null;
             }
             albumCataloguePcVo.setActionFlag(actionFlag);
             return albumCataloguePcVo;

src/main/java/com/redxun/knowledge/album/service/AlbumYelpApproveServiceImpl.java

@@ -23,4 +23,11 @@ public class AlbumYelpApproveServiceImpl extends SuperServiceImpl<AlbumYelpAppro
         return albumYelpApproveMapper;
     }
 
+    /**
+     * 根据专辑Id删除点评审核流程
+     * @param ids
+     */
+    public void deleteByAlbumId(String ids) {
+        albumYelpApproveMapper.deleteByAlbumId(ids);
+    }
 }

src/main/java/com/redxun/knowledge/album/service/AlbumYelpServiceImpl.java

@@ -1,13 +1,22 @@
 package com.redxun.knowledge.album.service;
 
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.redxun.common.base.db.BaseDao;
 import com.redxun.common.base.db.BaseService;
 import com.redxun.common.service.impl.SuperServiceImpl;
-import com.redxun.knowledge.album.entity.dao.AlbumYelp;
+import com.redxun.common.tool.IdGenerator;
+import com.redxun.knowledge.album.entity.dao.*;
+import com.redxun.knowledge.album.entity.dto.YelpDto;
 import com.redxun.knowledge.album.mapper.AlbumYelpMapper;
+import com.redxun.knowledge.common.UserService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import javax.annotation.Resource;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
 
 /**
 * [业务--专辑点评表]业务服务类
@@ -18,9 +27,74 @@ public class AlbumYelpServiceImpl extends SuperServiceImpl<AlbumYelpMapper, Albu
     @Resource
     private AlbumYelpMapper albumYelpMapper;
 
+    @Autowired
+    private AlbumYelpApprovalNodeServiceImpl albumYelpApprovalNodeService;
+
+    @Autowired
+    private AlbumYelpApproveServiceImpl albumYelpApproveService;
+
+    @Autowired
+    private UserService userService;
+
     @Override
     public BaseDao<AlbumYelp> getRepository() {
         return albumYelpMapper;
     }
 
+    /**
+     * 根据专辑Id删除点评信息
+     * @param ids
+     */
+    public void deleteByAlbumId(String ids) {
+        albumYelpMapper.deleteByAlbumId(ids);
+    }
+
+    /**
+     * PC端对专辑进行点评或者回复点评（回复）内容
+     * @param yelpDto
+     * @return
+     */
+    public String yelp(YelpDto yelpDto) {
+        AlbumYelp albumYelp = new AlbumYelp();
+        Integer type = yelpDto.getType();
+        // 类型为1 点评(1级) 类型为2 回复(2级)
+        if (type == 1){
+            //点评表中新增数据
+            albumYelp.setPkId(IdGenerator.getIdStr());
+            BeanUtils.copyProperties(yelpDto,albumYelp);
+            albumYelp.setUpdateBy(userService.queryLoginUser());
+            albumYelpMapper.insert(albumYelp);
+            //推送至审核流程表中
+            createAlbumYelpApprove(albumYelp);
+        } else {
+
+        }
+        return albumYelp.getPkId();
+    }
+
+    /**
+     * 生成最新版审核流程
+     * @param albumYelp
+     */
+    private void createAlbumYelpApprove(AlbumYelp albumYelp){
+        //拉取点评审核节点表
+        List<AlbumYelpApprovalNode> albumYelpApprovalNodeList = albumYelpApprovalNodeService.
+                findAll(new QueryWrapper<AlbumYelpApprovalNode>().orderByAsc("IS_FINAL", "CREATE_TIME_"));
+        //将点评信息推送至点评审核表中(各个节点都推送)
+        AtomicInteger sort = new AtomicInteger(1);
+        List<AlbumYelpApprove> albumYelpApproveList = albumYelpApprovalNodeList.stream().map(albumYelpApprovalNode -> {
+            AlbumYelpApprove albumYelpApprove = new AlbumYelpApprove();
+            albumYelpApprove.setPkId(IdGenerator.getIdStr());
+            albumYelpApprove.setAlbumId(albumYelp.getAlbumId());
+            albumYelpApprove.setApproverId(albumYelpApprovalNode.getApproverId());
+            albumYelpApprove.setApproverName(albumYelpApprovalNode.getApproverName());
+            albumYelpApprove.setSort(sort.getAndIncrement());
+            albumYelpApprove.setIsFinal(albumYelpApprovalNode.getIsFinal());
+            albumYelpApprove.setUpdateBy(userService.queryLoginUser());
+            albumYelpApprove.setName(albumYelpApprovalNode.getName());
+            return albumYelpApprove;
+        }).collect(Collectors.toList());
+        //批量添加
+        albumYelpApproveService.saveBatch(albumYelpApproveList);
+    }
 }

src/main/java/com/redxun/knowledge/common/UserService.java

@@ -10,6 +10,7 @@ import com.redxun.feign.org.OrgClient;
 import com.redxun.feign.org.UserClient;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Component;
 
@@ -37,6 +38,12 @@ public class UserService {
     @Autowired
     private OrgClient orgClient;
 
+    @Value("${uploaderHead.male}")
+    private String male;
+
+    @Value("${uploaderHead.male}")
+    private String female;
+
     /**
      * 获取当前系统登录用户id
      *
@@ -99,11 +106,13 @@ public class UserService {
         String sex = userClient.findByUserId(userId).getSex();
         String photo = userClient.findByUserId(userId).getPhoto();
         if (photo == null){
+            String[] split;
             if (("male").equals(sex)){
-                map.put("photo","1615521393665536002");
+                split = male.split("=");
             } else {
-                map.put("photo","1615521593893220354");
+                split = female.split("=");
             }
+            map.put("photo",split[split.length - 1]);
         } else {
             map.put("photo",photo);
         }

src/main/resources/mapper/knowledge/album/AlbumApproveMapper.xml

@@ -90,16 +90,16 @@
                 )
             </if>
             <if test="@rx.Ognl@isNotEmpty(params.name)">
-                ai.NAME LIKE '%' || #{params.name} || '%'
+                and ai.NAME LIKE '%' || #{params.name} || '%'
             </if>
             <if test="@rx.Ognl@isNotEmpty(params.applyUserName)">
-                os.FULLNAME_ LIKE '%' || #{params.applyUserName} || '%'
+                and os.FULLNAME_ LIKE '%' || #{params.applyUserName} || '%'
             </if>
             <if test="@rx.Ognl@isNotEmpty(params.ownerName)">
-                oss.FULLNAME_ LIKE '%' || #{params.ownerName} || '%'
+                and oss.FULLNAME_ LIKE '%' || #{params.ownerName} || '%'
             </if>
             <if test="@rx.Ognl@isNotEmpty(params.approvalState)">
-                av.APPROVAL_STATE = #{params.approvalState}
+                and av.APPROVAL_STATE = #{params.approvalState}
             </if>
             <if test="@rx.Ognl@isNotEmpty(params.createTimeStart)">
                 and TO_CHAR(av.CREATE_TIME_,'yyyy-mm-dd') &gt;= #{params.createTimeStart}
@@ -107,11 +107,17 @@
             <if test="@rx.Ognl@isNotEmpty(params.createTimeEnd)">
                 and TO_CHAR(av.CREATE_TIME_,'yyyy-mm-dd') &lt;= #{params.createTimeEnd}
             </if>
-            and aa.IS_DEL = 0 and ai.IS_DEL = 0 and av.IS_DEL = 0
+            and aa.IS_DEL = 0 and ai.IS_DEL = 0 and av.IS_DEL = 0 and av.state = 1
         </where>
         order by aa.SORT,av.CREATE_TIME_ desc
     </select>
 
+    <delete id="deleteByVersionId">
+        update KM_ALBUM_APPROVE
+        set IS_DEL = 1
+        where VERSION_ID = #{versionId}
+    </delete>
+
 </mapper>
 
 

src/main/resources/mapper/knowledge/album/AlbumCatalogueKnowledgeMapper.xml

@@ -32,6 +32,15 @@
         </if>
     </select>
 
+    <delete id="deleteByCatalogueId">
+        update km_album_catalogue_knowledge
+        set IS_DEL = 1
+        where CATALOGUE_ID in
+        <foreach collection="ids" open="(" close=")" separator="," item="id">
+            #{id}
+        </foreach>
+    </delete>
+
 </mapper>
 
 

src/main/resources/mapper/knowledge/album/AlbumCatalogueMapper.xml

@@ -46,6 +46,12 @@
         where ALBUM_ID = #{params.albumId} and VERSION_ID = #{params.versionId} and IS_DEL = 0
     </select>
 
+    <update id="deleteByVersionId">
+        update km_album_catalogue
+        set IS_DEL = 1
+        where VERSION_ID = #{versionId}
+    </update>
+
 </mapper>
 
 

src/main/resources/mapper/knowledge/album/AlbumInfoMapper.xml

@@ -23,7 +23,7 @@
     </resultMap>
 
     <sql id="COLUMNS">
-        ai.PK_ID,CATEGORY_ID,NAME,COVER,OWNER_COMPANY_ID,OWNER_DEPARTMENT_ID,OWNER_ID,STATE,VIEWS,ai.IS_DEL,ai.COMPANY_ID_,ai.CREATE_DEP_ID_,
+        distinct ai.PK_ID as pkId,CATEGORY_ID,NAME,COVER,OWNER_COMPANY_ID,OWNER_DEPARTMENT_ID,OWNER_ID,ai.STATE as state,VIEWS,ai.IS_DEL,ai.COMPANY_ID_,ai.CREATE_DEP_ID_,
         ai.TENANT_ID_,ai.CREATE_BY_,ai.CREATE_TIME_,ai.UPDATE_BY_,ai.UPDATE_TIME_
     </sql>
 
@@ -69,28 +69,17 @@
             <if test="@rx.Ognl@isNotEmpty(params.ownerName)">
                 and FULLNAME_ LIKE '%' || #{params.ownerName} || '%'
             </if>
-            <if test="@rx.Ognl@isNotEmpty(params.state)">
-                and STATE = #{params.state}
-            </if>
             <if test="@rx.Ognl@isNotEmpty(params.createTimeStart)">
                 and TO_CHAR(ai.CREATE_TIME_,'yyyy-mm-dd') &gt;= #{params.createTimeStart}
             </if>
             <if test="@rx.Ognl@isNotEmpty(params.createTimeEnd)">
                 and TO_CHAR(ai.CREATE_TIME_,'yyyy-mm-dd') &lt;= #{params.createTimeEnd}
             </if>
-            <if test="@rx.Ognl@isNotEmpty(params.ownerId)">
-                and ai.OWNER_ID = #{params.ownerId}
-            </if>
-            <if test="@rx.Ognl@isNotEmpty(params.state)">
-                and ai.STATE = #{params.state}
-            </if>
-            <if test="@rx.Ognl@isNotEmpty(params.notState)">
-                and ai.STATE != 3
-            </if>
             and ai.IS_DEL = 0
+            <!-- and av.rowid in (select max(rowid) from KM_ALBUM_VERSION group by ALBUM_ID) -->
         </where>
         <if test="@rx.Ognl@isNotEmpty(params.orderBySql)">
-            ORDER BY ai.${params.orderBySql},ai.CREATE_TIME_ DESC
+            ORDER BY ai.${w.orderBySql},ai.CREATE_TIME_ DESC
         </if>
         <if test="@rx.Ognl@isEmpty(params.orderBySql)">
             ORDER BY ai.CREATE_TIME_ DESC
@@ -106,6 +95,43 @@
           and IS_DEL = 0
     </select>
 
+    <select id="findAllAlbumInfoByOwnerIds" resultType="com.redxun.knowledge.album.entity.dao.AlbumInfo">
+        select
+        <include refid="COLUMNS"/>
+        from KM_ALBUM_INFO ai
+        <where>
+            <if test="@rx.Ognl@isNotEmpty(params.name)">
+                ai.NAME LIKE '%' || #{params.name} || '%'
+            </if>
+            and ai.owner_id = #{params.ownerIds} and ai.state = 1
+            and ai.IS_DEL = 0
+        </where>
+        ORDER BY ai.CREATE_TIME_ DESC
+
+    </select>
+
+    <select id="findAllAlbumInfoByVersionState" resultType="com.redxun.knowledge.album.entity.dao.AlbumInfo">
+        select
+        <include refid="COLUMNS"/>
+        from KM_ALBUM_INFO ai
+        join KM_ALBUM_VERSION av
+        on ai.PK_ID = av.ALBUM_ID
+        <where>
+            <if test="@rx.Ognl@isNotEmpty(params.name)">
+                ai.NAME LIKE '%' || #{params.name} || '%'
+            </if>
+            av.STATE = #{params.versionState}
+            and ai.IS_DEL = 0 and av.IS_DEL = 0 and ai.STATE = 1
+        </where>
+        ORDER BY ai.CREATE_TIME_ DESC
+    </select>
+
+    <delete id="deleteByIds">
+        update KM_ALBUM_INFO
+        set IS_DEL = 1
+        where PK_ID = #{pkId}
+    </delete>
+
 </mapper>
 
 

src/main/resources/mapper/knowledge/album/AlbumVersionMapper.xml

@@ -21,7 +21,8 @@
 
 
     <select id="query" resultType="com.redxun.knowledge.album.entity.dao.AlbumVersion" parameterType="java.util.Map">
-        select PK_ID,ALBUM_ID,APPLY_USER_ID,STATE,APPROVAL_STATE,SUMMARY,IS_DEL,COMPANY_ID_,CREATE_DEP_ID_,TENANT_ID_,CREATE_BY_,CREATE_TIME_,UPDATE_BY_,UPDATE_TIME_ from KM_ALBUM_VERSION
+        select PK_ID,ALBUM_ID,APPLY_USER_ID,STATE,APPROVAL_STATE,SUMMARY,IS_DEL,COMPANY_ID_,CREATE_DEP_ID_,
+               TENANT_ID_,CREATE_BY_,CREATE_TIME_,UPDATE_BY_,UPDATE_TIME_ from KM_ALBUM_VERSION
         <where>
             <if test="@rx.Ognl@isNotEmpty(w.whereSql)">
                 ${w.whereSql}
@@ -35,6 +36,12 @@
         </if>
     </select>
 
+    <delete id="deleteByAlbumId">
+        update KM_ALBUM_VERSION
+        set IS_DEL = 1
+        where ALBUM_ID = #{albumId}
+    </delete>
+
 </mapper>
 
 

src/main/resources/mapper/knowledge/album/AlbumYelpApproveMapper.xml

@@ -22,11 +22,14 @@
                 <result property="createTime" column="CREATE_TIME_" jdbcType="DATE"/>
                 <result property="updateBy" column="UPDATE_BY_" jdbcType="VARCHAR"/>
                 <result property="updateTime" column="UPDATE_TIME_" jdbcType="DATE"/>
+                <result property="name" column="NAME" jdbcType="VARCHAR"/>
     </resultMap>
 
 
     <select id="query" resultType="com.redxun.knowledge.album.entity.dao.AlbumYelpApprove" parameterType="java.util.Map">
-        select PK_ID,ALBUM_ID,RESULT,REMARK,APPROVER_ID,APPROVER_NAME,ACTUAL_APPROVER,ACTUAL_APPROVER_NAME,APPROVAL_TIME,SORT,IS_FINAL,IS_DEL,COMPANY_ID_,CREATE_DEP_ID_,TENANT_ID_,CREATE_BY_,CREATE_TIME_,UPDATE_BY_,UPDATE_TIME_ from KM_ALBUM_YELP_APPROVE
+        select PK_ID,ALBUM_ID,RESULT,REMARK,APPROVER_ID,APPROVER_NAME,ACTUAL_APPROVER,ACTUAL_APPROVER_NAME,APPROVAL_TIME,
+               SORT,IS_FINAL,IS_DEL,COMPANY_ID_,CREATE_DEP_ID_,TENANT_ID_,CREATE_BY_,CREATE_TIME_,UPDATE_BY_,UPDATE_TIME_
+        from KM_ALBUM_YELP_APPROVE
         <where>
             <if test="@rx.Ognl@isNotEmpty(w.whereSql)">
                 ${w.whereSql}
@@ -40,6 +43,12 @@
         </if>
     </select>
 
+    <delete id="deleteByAlbumId">
+        update KM_ALBUM_YELP_APPROVE
+        set IS_DEL = 0
+        where ALBUM_ID = #{albumId}
+    </delete>
+
 </mapper>
 
 

src/main/resources/mapper/knowledge/album/AlbumYelpMapper.xml

@@ -17,11 +17,13 @@
                 <result property="createTime" column="CREATE_TIME_" jdbcType="DATE"/>
                 <result property="updateBy" column="UPDATE_BY_" jdbcType="VARCHAR"/>
                 <result property="updateTime" column="UPDATE_TIME_" jdbcType="DATE"/>
+                <result property="approvalState" column="APPROVAL_STATE" jdbcType="INTEGER"/>
     </resultMap>
 
 
     <select id="query" resultType="com.redxun.knowledge.album.entity.dao.AlbumYelp" parameterType="java.util.Map">
-        select PK_ID,ALBUM_ID,TYPE,CONTENT,YELP_ID,STATE,IS_DEL,COMPANY_ID_,CREATE_DEP_ID_,TENANT_ID_,CREATE_BY_,CREATE_TIME_,UPDATE_BY_,UPDATE_TIME_ from KM_ALBUM_YELP
+        select PK_ID,ALBUM_ID,TYPE,CONTENT,YELP_ID,STATE,IS_DEL,COMPANY_ID_,CREATE_DEP_ID_,TENANT_ID_,CREATE_BY_,CREATE_TIME_,
+               UPDATE_BY_,UPDATE_TIME_ from KM_ALBUM_YELP
         <where>
             <if test="@rx.Ognl@isNotEmpty(w.whereSql)">
                 ${w.whereSql}
@@ -35,6 +37,12 @@
         </if>
     </select>
 
+    <delete id="deleteByAlbumId">
+        update KM_ALBUM_YELP
+        set IS_DEL = 1
+        where ALBUM_ID = #{albumId}
+    </delete>
+
 
 </mapper>