platform / task-web

/*
 * @(#)AnnouncementManagerImpl.java
 *
 * Copyright (c) 2014-2017   版权所有
 * xiniunet. All rights reserved.
 *
 * This software is the confidential and proprietary
 * information of  xiniunet.
 * ("Confidential Information"). You shall not disclose
 * such Confidential Information and shall use it only
 * in accordance with the terms of the contract agreement
 * you entered into with xiniunet.
 */
package com.xiniunet.announcement.biz;

import com.alibaba.dubbo.common.utils.CollectionUtils;
import com.xiniunet.announcement.dal.AnnouncementMapper;
import com.xiniunet.announcement.dal.AnnouncementUserMapper;
import com.xiniunet.announcement.domain.Announcement;
import com.xiniunet.announcement.domain.AnnouncementUser;
import com.xiniunet.announcement.po.AnnouncementPO;
import com.xiniunet.announcement.po.AnnouncementUserPO;
import com.xiniunet.announcement.request.*;
import com.xiniunet.announcement.response.*;
import com.xiniunet.foundation.domain.Comment;
import com.xiniunet.foundation.domain.FileAttachmentBind;
import com.xiniunet.foundation.request.*;
import com.xiniunet.foundation.response.*;
import com.xiniunet.foundation.service.FoundationService;
import com.xiniunet.framework.annotation.MethodConfig;
import com.xiniunet.framework.base.BaseManagerImpl;
import com.xiniunet.framework.base.BaseResponse;
import com.xiniunet.framework.exception.ErrorType;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.master.service.MasterService;
import com.xiniunet.task.constant.Message;
import com.xiniunet.task.enumeration.BusinessTypeEnum;
import com.xiniunet.util.ListUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 公告通知的管理方法实现.
 * @author 
 */
@Transactional
@Service("NoticeAnnouncementManager")
public class AnnouncementManagerImpl extends BaseManagerImpl implements AnnouncementManager {

    @Autowired
    private FoundationService foundationService;

    @Autowired
    private AnnouncementMapper announcementMapper;
    @Autowired
    private MasterService masterService;

    @Autowired
    private AnnouncementUserMapper announcementUserMapper;

    @Autowired
    private AnnouncementUserManager announcementUserManager;

    /**
     * 根据Id获取公告通知
     *
     * @param request 获取公告通知请求
     * @param passport 用户护照
     * @return 获取公告通知应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementGetResponse get(AnnouncementGetRequest request, Passport passport) {
        AnnouncementGetResponse response = new AnnouncementGetResponse();
        AnnouncementPO entity = announcementMapper.getInfoById(request.getId(), passport);
        if (entity == null) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
            return response;
        }
        Announcement announcement = this.getMapper().map(entity, Announcement.class);
        //获取通知人
        AnnouncementUserFindRequest announcementUserFindRequest = new AnnouncementUserFindRequest();
        announcementUserFindRequest.setPageSize(0);
        announcementUserFindRequest.setAnnouncementId(request.getId());
        AnnouncementUserFindResponse announcementUserFindResponse = announcementUserManager.find(announcementUserFindRequest,passport);
        if(announcementUserFindResponse.hasError()){
            response.addErrors(announcementUserFindResponse.getErrors());
            return response;
        }
        List<AnnouncementUser> announcementUsers = new ArrayList<>();
        //排除掉创建者
        if(CollectionUtils.isNotEmpty(announcementUserFindResponse.getResult())){
            for(AnnouncementUser announcementUser:announcementUserFindResponse.getResult()){
                if(!announcementUser.getUserId().equals(entity.getOwnerUserId())){
                    announcementUsers.add(announcementUser);
                }
            }
        }
        //设置通知者
        announcement.setUserList(announcementUsers);
        // 获取附件信息
        AttachmentGetByBizInfoRequest attachmentGetByBizInfoRequest = new AttachmentGetByBizInfoRequest();
        attachmentGetByBizInfoRequest.setBusinessType(BusinessTypeEnum.ANNOUNCEMENT.toString());
        attachmentGetByBizInfoRequest.setBusinessId(request.getId());
        AttachmentGetByBizInfoResponse attachmentGetByBizInfoResponse = foundationService.getAttachmentsByBizInfo(attachmentGetByBizInfoRequest,passport);
        if(attachmentGetByBizInfoResponse.hasError()){
            response.addErrors(attachmentGetByBizInfoResponse.getErrors());
            return  response;
        }
        if(attachmentGetByBizInfoResponse.getAttachmentList() != null && attachmentGetByBizInfoResponse.getAttachmentList().size()>0){
            announcement.setAttachmentList(attachmentGetByBizInfoResponse.getAttachmentList());
        }
        response.setAnnouncement(announcement );
        return response;
    }

    /**
     * 分享公告通知推送消息
     *
     * @param request 获取公告通知请求
     * @param passport 用户护照
     * @return 获取公告通知应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementSharePushMessageResponse sharePushMessage(AnnouncementSharePushMessageRequest request, Passport passport){
        AnnouncementSharePushMessageResponse response = new AnnouncementSharePushMessageResponse();
        AnnouncementPO announcementPO = announcementMapper.getById(request.getAnnouncementId(),passport);
        if(announcementPO == null){
            response.addError(ErrorType.BUSINESS_ERROR,"公告通知不能为空！");
        }
        if(CollectionUtils.isNotEmpty(request.getUserIdList())){
            //返回地址：todo pageName 待确认
            String resultUrl = "xntalk://rnapp.open/noticeSys?page=notificationDetail&tenantId=" + passport.getTenantId() + "&id=" + announcementPO.getId()
                    + "&name=" + announcementPO.getOwnerUserName()+ "&isRevoke=" + announcementPO.getIsRevoke()+"&ownerUserId="+announcementPO.getOwnerUserId();
            MessageBatchCreateRequest messageBatchCreateRequest = new MessageBatchCreateRequest();
            messageBatchCreateRequest.setMessageTitle("【"+announcementPO.getTitle()+"】通知分享");
            messageBatchCreateRequest.setMessageContent(passport.getUserName()+"将【"+announcementPO.getTitle()+"】公告分享给了您");
            messageBatchCreateRequest.setBusinessId(announcementPO.getId());
            messageBatchCreateRequest.setBusinessType(BusinessTypeEnum.TASK.toString());
            messageBatchCreateRequest.setMessageUrl(resultUrl);
            messageBatchCreateRequest.setReceiptIds(request.getUserIdList());
            messageBatchCreateRequest.setSenderId(10000L);
            messageBatchCreateRequest.setSenderName("系统管理员");
            messageBatchCreateRequest.setSendTime(new Date());
            messageBatchCreateRequest.setMessageTime(new Date());
            MessageBatchCreateResponse messageBatchCreateResponse = foundationService.batchCreateMessage(messageBatchCreateRequest,passport);
            if(messageBatchCreateResponse.hasError()){
                response.addErrors(messageBatchCreateResponse.getErrors());
                return response;
            }
        }
        return response;
    }
    /**
     * 高级查询公告进度
     *
     * @param request  高级查询任务请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    @Transactional(readOnly = true)
    public AnnouncementCommentFindResponse findComment(AnnouncementCommentFindRequest request, Passport passport){
        AnnouncementCommentFindResponse response = new AnnouncementCommentFindResponse();
        //查询任务进度列表信息
        CommentPostFindByPageRequest commentPostFindRequest = new CommentPostFindByPageRequest();
        commentPostFindRequest.setBusinessId(request.getId());
        commentPostFindRequest.setBusinessType(BusinessTypeEnum.ANNOUNCEMENT.toString());
        commentPostFindRequest.setPageNumber(request.getPageNumber());
        CommentPostFindByPageResponse commentPostFindResponse = foundationService.findCommentPostByPage(commentPostFindRequest,passport);
        if(commentPostFindResponse.hasError()){
            response.addErrors(commentPostFindResponse.getErrors());
            return response;
        }
        List<Comment> commentList = commentPostFindResponse.getResult();
        response.setResult(commentList);
        return response;
    }

    /**
     * 模糊查询公告通知
     *
     * @param request 模糊查询公告通知请求
     * @param passport 用户护照
     * @return 模糊查询公告通知应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementSearchResponse search(AnnouncementSearchRequest request, Passport passport) {
        AnnouncementSearchResponse response = new AnnouncementSearchResponse();
        List<Announcement> modelList = new ArrayList<>();
        Long count = announcementMapper.searchCount(request, passport);
    
        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }
    
            //通过关键字查询出用户集合
            List<AnnouncementPO> entityList = announcementMapper.search(request, passport);
    
            for (AnnouncementPO entity : entityList) {
                Announcement announcement = this.getMapper().map(entity, Announcement.class);
                modelList.add(announcement);
            }
        }
    
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }
    /**
     * 高级自己发布的公告数
     *
     * @param request 高级查询公告通知请求
     * @param passport 用户护照
     * @return 高级查询公告通知应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementOwnCountGetResponse findOwnCount(AnnouncementOwnCountGetRequest request, Passport passport) {
        AnnouncementOwnCountGetResponse response = new AnnouncementOwnCountGetResponse();
        AnnouncementFindRequest announcementFindRequest = this.getMapper().map(request,AnnouncementFindRequest.class);
        Long count = announcementMapper.findByUserCount(announcementFindRequest, passport);
        response.setCount(count);
        return response;
    }
    
    /**
     * 高级查询公告通知
     *
     * @param request 高级查询公告通知请求
     * @param passport 用户护照
     * @return 高级查询公告通知应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementFindResponse find(AnnouncementFindRequest request, Passport passport) {
        AnnouncementFindResponse response = new AnnouncementFindResponse();
        List<Announcement> modelList = new ArrayList<>();
        Long count = announcementMapper.findCount(request, passport);
        if (count >0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }
    
            List<AnnouncementPO> entityList = announcementMapper.find(request, passport);
            for (AnnouncementPO entity : entityList) {
                Announcement announcement = this.getMapper().map(entity, Announcement.class);
                modelList.add(announcement);
            }
        }
    
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }


    /**
     * 高级查询公告通知
     *
     * @param request 高级查询公告通知请求
     * @param passport 用户护照
     * @return 高级查询公告通知应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    @MethodConfig(dataSource = "slaveDataSource")
    public AnnouncementIsActorResponse isActor(AnnouncementIsActorRequest request, Passport passport){
        AnnouncementIsActorResponse response = new AnnouncementIsActorResponse();
        //获取通知信息
        AnnouncementPO announcementPO = announcementMapper.getById(request.getId(),passport);
        if(announcementPO == null){
            response.addError(ErrorType.BUSINESS_ERROR,"公告通知不存在或已被删除！");
            return response;
        }
        //获取通知人
        AnnouncementUserFindRequest announcementUserFindRequest = new AnnouncementUserFindRequest();
        announcementUserFindRequest.setPageSize(0);
        announcementUserFindRequest.setAnnouncementId(request.getId());
        announcementUserFindRequest.setIncludeOwner(true);
        AnnouncementUserFindResponse announcementUserFindResponse = announcementUserManager.find(announcementUserFindRequest,passport);
        if(announcementUserFindResponse.hasError()){
            response.addErrors(announcementUserFindResponse.getErrors());
            return response;
        }
        //是否是参与者
        Boolean isActor = false;
        if(announcementUserFindResponse.getResult() != null){
            for(AnnouncementUser announcementUser : announcementUserFindResponse.getResult()){
                if(passport.getUserId().equals(announcementUser.getUserId())){
                    isActor = true;
                    break;
                }
            }
        }
        response.setIsActor(isActor);
        response.setIsRevoke(announcementPO.getIsRevoke());
        return response;
    }

    /**
     * 高级查询公告通知
     *
     * @param request 高级查询公告通知请求
     * @param passport 用户护照
     * @return 高级查询公告通知应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    @MethodConfig(dataSource = "slaveDataSource")
    public AnnouncementFindResponse findByUser(AnnouncementFindRequest request, Passport passport) {
        AnnouncementFindResponse response = new AnnouncementFindResponse();
        List<Announcement> modelList = new ArrayList<>();
        Long count = announcementMapper.findByUserCount(request, passport);
        if (count >0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }
            //用户id集合 == 用户头像由页面查询加载
            List<Long> userIdList = new ArrayList<>();
            List<AnnouncementPO> entityList = announcementMapper.findByUser(request, passport);
            for (AnnouncementPO entity : entityList) {
                Announcement announcement = this.getMapper().map(entity, Announcement.class);
                userIdList.add(announcement.getOwnerUserId());
                modelList.add(announcement);
            }
        }

        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    
    /**
     * 创建公告通知
     *
     * @param request 创建公告通知请求
     * @param passport 用户护照
     * @return 创建公告通知应答
     */
    @Override
    public AnnouncementCreateResponse create(AnnouncementCreateRequest request, Passport passport) {
        AnnouncementCreateResponse response = new AnnouncementCreateResponse();

        AnnouncementPO entity = this.getMapper().map(request, AnnouncementPO.class);
        if(entity.getId() == null) {
            long id = foundationService.getNewId();
            entity.setId(id);
        }

        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity,passport,response);
        if(response.hasError()) {
            return response;
        }
        //如果owerUserId没有传直接取passport的user
        if(request.getOwnerUserId() == null ){
            entity.setOwnerUserId(passport.getUserId());
            entity.setOwnerUserName(passport.getUserName());
        }
        List<AnnouncementUser> users = new ArrayList<>();
        List<AnnouncementUserPO> userPOList = new ArrayList<>();
        //添加创建者的信息
        AnnouncementUser user = new AnnouncementUser();
        user.setUserId(entity.getOwnerUserId());
        user.setUserName(entity.getOwnerUserName());
        user.setIsConfirm(true);
        user.setConfirmUserId(passport.getUserId());
        user.setConfirmUserName(passport.getUserName());
        user.setConfirmTime(new Date());
        users.add(user);
        users.addAll(request.getUserList());
        //推送承租人消息的用户id集合
        List<Long> userIdList = new ArrayList<>();
        if(CollectionUtils.isNotEmpty(users) ){
            IdsGetRequest idsGetRequest = new IdsGetRequest();
            idsGetRequest.setCount(users.size());
            IdsGetResponse idsGetResponse = foundationService.getNewIds(idsGetRequest);
            List<Long> listUserIds = idsGetResponse.getIds();
            int index = 0;
            for(AnnouncementUser announcementUser: users){
                AnnouncementUserPO announcementUserPO = this.getMapper().map(announcementUser,AnnouncementUserPO.class);
                announcementUserPO.setAnnouncementId(entity.getId());
                announcementUserPO.setId(listUserIds.get(index));
                if(!announcementUser.getUserId().equals(entity.getOwnerUserId())){
                    announcementUserPO.setIsConfirm(false);
                    userIdList.add(announcementUser.getUserId());
                }
                announcementUserPO.setIsCancel(false);
                userPOList.add(announcementUserPO);
                index++;
            }
        }
        //批量创建通知用户信息
        if (CollectionUtils.isNotEmpty(userPOList)) {
            if (users.size() != announcementUserMapper.insertBatch(userPOList, passport)) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
                return response;
            }
        }

        if(CollectionUtils.isNotEmpty(request.getAttachmentList()) ){
            //处理文件列表的创建绑定
            FileCreateBindAttachBatchRequest fileCreateBindAttachBatchRequest = this.getMapper().map(request,FileCreateBindAttachBatchRequest.class);
            List<FileAttachmentBind> attachmentList = fileCreateBindAttachBatchRequest.getAttachmentList();
            if(CollectionUtils.isNotEmpty(attachmentList)){
                for(FileAttachmentBind fileAttachmentBind : attachmentList){
                    fileAttachmentBind.setBusinessId(entity.getId());
                    fileAttachmentBind.setBusinessType(BusinessTypeEnum.ANNOUNCEMENT.toString());
                }
                fileCreateBindAttachBatchRequest.setAttachmentList(attachmentList);
            }
            FileCreateBindAttachmentBatchResponse fileCreateBindAttachmentBatchResponse = foundationService.fileCreateBindAttachmentBatch(fileCreateBindAttachBatchRequest,passport);
            if(fileCreateBindAttachmentBatchResponse.hasError()){
                //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addErrors(fileCreateBindAttachmentBatchResponse.getErrors());
                return response;
            }
        }
        if (entity.getAnnouncementTime() == null)
        {
            entity.setAnnouncementTime(new Date());
        }
        if (announcementMapper.insert(entity, passport) == 0) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
            return response;
        }
        //推送消息
        if(CollectionUtils.isNotEmpty(userIdList)){
            //返回地址：todo pageName 待确认
            String resultUrl = "xntalk://rnapp.open/noticeSys?page=notificationDetail&tenantId=" + passport.getTenantId() + "&id=" + entity.getId()
                    + "&name=" + entity.getOwnerUserName()+ "&isRevoke=" + entity.getIsRevoke()+"&ownerUserId="+entity.getOwnerUserId();
            MessageBatchCreateRequest messageBatchCreateRequest = new MessageBatchCreateRequest();
            messageBatchCreateRequest.setMessageTitle("【"+entity.getTitle()+"】"+"通知创建");
            messageBatchCreateRequest.setMessageContent(passport.getUserName()+"创建了【"+entity.getTitle()+"】通知");
            messageBatchCreateRequest.setBusinessId(entity.getId());
            messageBatchCreateRequest.setBusinessType(BusinessTypeEnum.ANNOUNCEMENT.toString());
            messageBatchCreateRequest.setMessageUrl(resultUrl);
            messageBatchCreateRequest.setReceiptIds(userIdList);
            messageBatchCreateRequest.setSenderId(10000L);
            messageBatchCreateRequest.setSenderName("系统管理员");
            messageBatchCreateRequest.setSendTime(new Date());
            messageBatchCreateRequest.setMessageTime(new Date());
            MessageBatchCreateResponse messageBatchCreateResponse = foundationService.batchCreateMessage(messageBatchCreateRequest,passport);
            if(messageBatchCreateResponse.hasError()){
                response.addErrors(messageBatchCreateResponse.getErrors());
                return response;
            }
        }
        response.setId(entity.getId());
        return response;
    }

    /**
     * 创建公告通知评论
     *
     * @param request 创建公告通知评论请求
     * @param passport 用户护照
     * @return 创建公告通知评论应答
     */
    @Override
    public AnnouncementCommentCreateResponse createComment(AnnouncementCommentCreateRequest request, Passport passport){
        AnnouncementCommentCreateResponse response = new AnnouncementCommentCreateResponse();
        //创建评论
        CommentRecordCreateRequest commentRecordCreateRequest = this.getMapper().map(request,CommentRecordCreateRequest.class);
        commentRecordCreateRequest.setBusinessId(request.getId());
        commentRecordCreateRequest.setBusinessType(BusinessTypeEnum.ANNOUNCEMENT.toString());
        commentRecordCreateRequest.setUserId(passport.getUserId());
        CommentRecordCreateResponse commentRecordCreateResponse = foundationService.createCommentRecord(commentRecordCreateRequest,passport);
        if(commentRecordCreateResponse.hasError()){
            response.addErrors(commentRecordCreateResponse.getErrors());
            return response;
        }
        //评论id
        Long commentId = commentRecordCreateResponse.getId();
        response.setId(commentId);
        return response;
    }

    /**
     * 撤销公告通知
     *
     * @param request 撤销公告通知请求
     * @param passport 用户护照
     * @return 撤销公告通知应答
     */
    @Override
    public AnnouncementRevokeResponse revoke(AnnouncementRevokeRequest request, Passport passport){
        AnnouncementRevokeResponse response = new AnnouncementRevokeResponse();
        //查询公告
        AnnouncementPO announcementPO = announcementMapper.getById(request.getId(),passport);
        if(announcementPO == null){
            response.addError(ErrorType.BUSINESS_ERROR, "公告不存在或已被删除！");
            return response;
        }
        AnnouncementPO entity = this.getMapper().map(request, AnnouncementPO.class);
        entity.setRevokeReason(request.getRevokeReason());
        entity.setRowVersion(announcementPO.getRowVersion());
        entity.setIsRevoke(true);
        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity,passport,response);
        if(response.hasError()) {
            return response;
        }

        Long result=announcementMapper.revoke(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }

    /**
     * 全部确认公告通知
     *
     * @param request 全部确认公告通知请求
     * @param passport 用户护照
     * @return 全部确认公告通知应答
     */
    @Override
    public AnnouncementAllConfirmResponse allConfirm(AnnouncementAllConfirmRequest request, Passport passport){
        AnnouncementAllConfirmResponse response = new AnnouncementAllConfirmResponse();
        //查询公告
        AnnouncementPO announcementPO = announcementMapper.getById(request.getId(),passport);
        if(announcementPO == null){
            response.addError(ErrorType.BUSINESS_ERROR, "公告不存在或已被删除！");
            return response;
        }
        AnnouncementPO entity = this.getMapper().map(request, AnnouncementPO.class);
        entity.setRowVersion(announcementPO.getRowVersion());
        Long result=announcementMapper.allConfirm(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }
    /**
     * 更新公告通知
     *
     * @param request 更新公告通知请求
     * @param passport 用户护照
     * @return 更新公告通知应答
     */
    @Override
public AnnouncementUpdateResponse update(AnnouncementUpdateRequest request, Passport passport) {
        AnnouncementUpdateResponse response = new AnnouncementUpdateResponse();

        AnnouncementPO entity = this.getMapper().map(request, AnnouncementPO.class);
        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity,passport,response);
        if(response.hasError()) {
            return response;
        }
        AnnouncementUserFindRequest announcementUserFindRequest = new AnnouncementUserFindRequest();
        announcementUserFindRequest.setPageSize(0);
        announcementUserFindRequest.setAnnouncementId(entity.getId());
        List<AnnouncementUserPO> oldList = announcementUserMapper.find(announcementUserFindRequest, passport);

        List<AnnouncementUser> userList = request.getUserList();
        List<AnnouncementUserPO> addList = new ArrayList<>();
        List<AnnouncementUserPO> updateList = new ArrayList<>();
        if (userList != null && userList.size() > 0) {
            for (AnnouncementUser announcementUser : userList) {
                AnnouncementUserPO announcementUserPO = this.getMapper().map(announcementUser, AnnouncementUserPO.class);
                announcementUserPO.setAnnouncementId(entity.getId());
                if (announcementUser.getUserId() != null) {
                    if (announcementUser.getId() == null) {
                        addList.add(announcementUserPO);
                    } else {
                        updateList.add(announcementUserPO);
                    }
                }
            }
        }
        List<Long> deleteIds = ListUtil.getKeyList(oldList);
        deleteIds.removeAll(ListUtil.getKeyList(updateList));
        if (addList.size() > 0) {
            IdsGetRequest idsGetRequest = new IdsGetRequest();
            idsGetRequest.setCount(addList.size());
            IdsGetResponse idsGetResponse = foundationService.getNewIds(idsGetRequest);
            List<Long> idList = idsGetResponse.getIds();
            int index = 0;
            for (AnnouncementUserPO announcementUserPO : addList) {
                announcementUserPO.setId(idList.get(index));
                index++;
            }
            if (addList.size() != announcementUserMapper.insertBatch(addList, passport)) {
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
                return response;
            }
        }
        if(updateList.size() > 0){
            if(updateList.size() != announcementUserMapper.updateBatch(updateList,passport)){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
                return response;
            }
        }
        if(deleteIds != null && deleteIds.size() > 0){
            if(deleteIds.size() != announcementUserMapper.deleteBatch(deleteIds,passport)){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
                return response;
            }
        }
        //附件处理逻辑
        if(CollectionUtils.isNotEmpty(request.getAttachmentList())){
            //全量删除
            AttachmentDeleteByBusinessIdRequest attachmentDeleteByBusinessIdRequest = new AttachmentDeleteByBusinessIdRequest();
            attachmentDeleteByBusinessIdRequest.setBusinessId(entity.getId());
            attachmentDeleteByBusinessIdRequest.setBusinessType(BusinessTypeEnum.TASK.toString());
            AttachmentsDeleteByBusinessIdResponse attachmentsDeleteByBusinessIdResponse = foundationService.deleteAttachmentsByBusinessId(attachmentDeleteByBusinessIdRequest,passport);
            if(attachmentsDeleteByBusinessIdResponse.hasError()){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addErrors(attachmentsDeleteByBusinessIdResponse.getErrors());
                return response;
            }
            //全量新增
            //处理文件列表的创建绑定
            FileCreateBindAttachBatchRequest fileCreateBindAttachBatchRequest = this.getMapper().map(request,FileCreateBindAttachBatchRequest.class);
            List<FileAttachmentBind> attachmentList = fileCreateBindAttachBatchRequest.getAttachmentList();
            if(CollectionUtils.isNotEmpty(attachmentList)){
                for(FileAttachmentBind fileAttachmentBind : attachmentList){
                    fileAttachmentBind.setBusinessId(entity.getId());
                    fileAttachmentBind.setBusinessType(BusinessTypeEnum.TASK.toString());
                }
                fileCreateBindAttachBatchRequest.setAttachmentList(attachmentList);
            }
            FileCreateBindAttachmentBatchResponse fileCreateBindAttachmentBatchResponse = foundationService.fileCreateBindAttachmentBatch(fileCreateBindAttachBatchRequest,passport);
            if(fileCreateBindAttachmentBatchResponse.hasError()){
                //TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addErrors(fileCreateBindAttachmentBatchResponse.getErrors());
                return response;
            }
        }
        Long result=announcementMapper.update(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }
    
    /**
     * 删除公告通知
     *
     * @param request 删除公告通知请求
     * @param passport 用户护照
     * @return 删除公告通知应答
     */
    @Override
    public AnnouncementDeleteResponse delete(AnnouncementDeleteRequest request, Passport passport) {
        AnnouncementDeleteResponse response = new AnnouncementDeleteResponse();
         Long result= announcementMapper.delete(request.getId(), passport);
         response.setResult(result);
        return response;
    }
    
    

    /**
     * 验证对象
     * @param announcement 公告通知
     * @param passport 用户护照
     */
    private void checkValidate(AnnouncementPO announcement, Passport passport, BaseResponse response) {
        // TODO
    }
}