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.AnnouncementUserMapper;
import com.xiniunet.announcement.po.AnnouncementUserPO;
import com.xiniunet.announcement.request.*;
import com.xiniunet.announcement.response.*;
import com.xiniunet.foundation.domain.Attachment;
import com.xiniunet.foundation.domain.Comment;
import com.xiniunet.foundation.domain.FileAttachmentBind;
import com.xiniunet.foundation.request.AttachmentGetByBizInfoRequest;
import com.xiniunet.foundation.request.CommentPostFindByPageRequest;
import com.xiniunet.foundation.request.FileCreateBindAttachBatchRequest;
import com.xiniunet.foundation.request.IdsGetRequest;
import com.xiniunet.foundation.response.AttachmentGetByBizInfoResponse;
import com.xiniunet.foundation.response.CommentPostFindByPageResponse;
import com.xiniunet.foundation.response.FileCreateBindAttachmentBatchResponse;
import com.xiniunet.foundation.response.IdsGetResponse;
import com.xiniunet.framework.base.BaseManagerImpl;
import com.xiniunet.framework.base.BaseResponse;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.announcement.dal.AnnouncementMapper;
import com.xiniunet.announcement.po.AnnouncementPO;
import com.xiniunet.foundation.service.FoundationService;
import com.xiniunet.master.domain.system.User;
import com.xiniunet.master.request.system.UserFindRequest;
import com.xiniunet.master.response.system.UserFindResponse;
import com.xiniunet.master.service.MasterService;
import com.xiniunet.task.constant.Message;
import com.xiniunet.task.domain.Task;
import com.xiniunet.task.enumeration.BusinessTypeEnum;
import com.xiniunet.workflow.response.CommentFindResponse;
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 com.xiniunet.framework.exception.ErrorType;
import com.xiniunet.announcement.domain.*;
import org.springframework.transaction.interceptor.TransactionAspectSupport;


import java.util.*;

/**
 * 公告通知的管理方法实现.
 * @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.getById(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(readOnly = true)
    public AnnouncementCommentFindResponse findProcess(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();
        //一级评论的id
        List<Long> ids = new ArrayList<>();
        for(Comment comment:commentList){
            ids.add(comment.getId());
        }
        // 获取附件信息
        AttachmentGetByBizInfoRequest attachmentGetByBizInfoRequest = new AttachmentGetByBizInfoRequest();
        attachmentGetByBizInfoRequest.setBusinessType(BusinessTypeEnum.TASK_PROCESS.toString());
        attachmentGetByBizInfoRequest.setBusinessIds(ids);
        AttachmentGetByBizInfoResponse attachmentGetByBizInfoResponse = foundationService.getAttachmentsByBizInfo(attachmentGetByBizInfoRequest,passport);
        if(attachmentGetByBizInfoResponse.hasError()){
            response.addErrors(attachmentGetByBizInfoResponse.getErrors());
            return  response;
        }
        //组装id和附件的关系
        Map<Long ,List<Attachment>> taskListAttachmentMap = new HashMap<>();
        List<Attachment> attachments = null;
        for(Attachment attachment : attachmentGetByBizInfoResponse.getAttachmentList()){
            if(taskListAttachmentMap.get(attachment.getId()) == null){
                attachments = new ArrayList<>();
            }else {
                attachments = taskListAttachmentMap.get(attachment.getId());
            }
            attachments.add(attachment);
            taskListAttachmentMap.put(attachment.getBusinessId(),attachments);
        }
        //设置通告的附件
        for(Comment comment:commentList){
            if(taskListAttachmentMap.get(comment.getId())!= null){
                comment.setAttachmentList(taskListAttachmentMap.get(comment.getId()));
            }
        }
        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 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)
    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);
            }
            //获取头像
            UserFindRequest userFindRequest = new UserFindRequest();
            userFindRequest.setPageSize(0);
            userFindRequest.setIds(userIdList);
            UserFindResponse userFindResponse = masterService.findUser(userFindRequest,passport);
            if(userFindResponse.hasError()){
                response.addErrors(userFindResponse.getErrors());
                return response;
            }
            List<User> userList = userFindResponse.getResult();
            //组装用户id和头像
            Map<Long,String> userAvarMap = new HashMap<>();
            for(User user :  userList){
                userAvarMap.put(user.getId(),user.getAvatar());
            }
            if(userAvarMap != null && userAvarMap.size() > 0){
                for(Announcement announcement : modelList){
                    if(userAvarMap.get(announcement.getId()) != null ){
                        announcement.setAvatarUrl(userAvarMap.get(announcement.getId()));
                    }
                }
            }
        }

        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<AnnouncementUserPO> userPOList = new ArrayList<>();
        //添加创建者的信息
        AnnouncementUserPO userPO = new AnnouncementUserPO();
        userPO.setUserId(entity.getOwnerUserId());
        userPO.setUserName(entity.getOwnerUserName());
        userPOList.add(userPO);
        if(CollectionUtils.isNotEmpty(request.getUserList()) ){
            IdsGetRequest idsGetRequest = new IdsGetRequest();
            idsGetRequest.setCount(request.getUserList().size());
            IdsGetResponse idsGetResponse = foundationService.getNewIds(idsGetRequest);
            List<Long> listUserIds = idsGetResponse.getIds();
            int index = 0;
            for(AnnouncementUser announcementUser: request.getUserList()){
                AnnouncementUserPO announcementUserPO = this.getMapper().map(announcementUser,AnnouncementUserPO.class);
                announcementUserPO.setAnnouncementId(entity.getId());
                announcementUserPO.setId(listUserIds.get(index));
                userPOList.add(announcementUserPO);
                index++;
            }
        }
        //批量创建通知用户信息
        if (CollectionUtils.isNotEmpty(userPOList)) {
            if (userPOList.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;
        }

        response.setId(entity.getId());
        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;
        }

        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
    }
}