platform / task-web

/*
 * @(#)AnnouncementUserManagerImpl.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.alibaba.dubbo.common.utils.StringUtils;
import com.xiniunet.announcement.domain.AnnouncementUser;
import com.xiniunet.announcement.po.ConfirmUserCountPO;
import com.xiniunet.framework.base.BaseManagerImpl;
import com.xiniunet.framework.base.BaseResponse;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.announcement.dal.AnnouncementUserMapper;
import com.xiniunet.announcement.po.AnnouncementUserPO;
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 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.request.*;
import com.xiniunet.announcement.response.*;
import com.xiniunet.announcement.domain.*;

import java.util.*;

/**
 * 被通知用户的管理方法实现.
 * @author 
 */
@Transactional
@Service("NoticeAnnouncementUserManager")
public class AnnouncementUserManagerImpl extends BaseManagerImpl implements AnnouncementUserManager {

    @Autowired
    private FoundationService foundationService;

    @Autowired
    private AnnouncementUserMapper announcementUserMapper;

    @Autowired
    private MasterService masterService;


    /**
     * 根据Id获取被通知用户
     *
     * @param request 获取被通知用户请求
     * @param passport 用户护照
     * @return 获取被通知用户应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementUserGetResponse get(AnnouncementUserGetRequest request, Passport passport) {
        AnnouncementUserGetResponse response = new AnnouncementUserGetResponse();
        AnnouncementUserPO entity = announcementUserMapper.getById(request.getId(), passport);
        if (entity != null) {
            AnnouncementUser announcementUser = this.getMapper().map(entity, AnnouncementUser.class);
            response.setAnnouncementUser(announcementUser );
        } else {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
        }
        return response;
    }


    /**
     * 模糊查询被通知用户
     *
     * @param request 模糊查询被通知用户请求
     * @param passport 用户护照
     * @return 模糊查询被通知用户应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementUserSearchResponse search(AnnouncementUserSearchRequest request, Passport passport) {
        AnnouncementUserSearchResponse response = new AnnouncementUserSearchResponse();
        List<AnnouncementUser> modelList = new ArrayList<>();
        Long count = announcementUserMapper.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<AnnouncementUserPO> entityList = announcementUserMapper.search(request, passport);
    
            for (AnnouncementUserPO entity : entityList) {
                AnnouncementUser announcementUser = this.getMapper().map(entity, AnnouncementUser.class);
                modelList.add(announcementUser);
            }
        }
    
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }
    
    /**
     * 高级查询被通知用户
     *
     * @param request 高级查询被通知用户请求
     * @param passport 用户护照
     * @return 高级查询被通知用户应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementUserFindResponse find(AnnouncementUserFindRequest request, Passport passport) {
        AnnouncementUserFindResponse response = new AnnouncementUserFindResponse();
        List<AnnouncementUser> modelList = new ArrayList<>();
        Long count = announcementUserMapper.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<AnnouncementUserPO> entityList = announcementUserMapper.find(request, passport);
            for (AnnouncementUserPO entity : entityList) {
                AnnouncementUser announcementUser = this.getMapper().map(entity, AnnouncementUser.class);
                modelList.add(announcementUser);
            }
        }
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    /**
     * 高级查询被通知用户
     *
     * @param request 高级查询被通知用户请求
     * @param passport 用户护照
     * @return 高级查询被通知用户应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementUserFindResponse getUserList(AnnouncementUserFindRequest request, Passport passport){
        AnnouncementUserFindResponse response = new AnnouncementUserFindResponse();
        List<AnnouncementUser> modelList = new ArrayList<>();

        List<ConfirmUserCountPO> confirmUserCountPOList =  announcementUserMapper.findConfirmCount(request,passport);
        if(CollectionUtils.isNotEmpty(confirmUserCountPOList)){
            for(ConfirmUserCountPO confirmUserCountPO : confirmUserCountPOList){
                if(confirmUserCountPO.getIsConfirm() != null && confirmUserCountPO.getIsConfirm()){
                    response.setConfirmUserCount(confirmUserCountPO.getCount());
                }else{
                    response.setUnConfirmUserCount(confirmUserCountPO.getCount());
                }
            }
        }else {
            response.setConfirmUserCount(0L);
            response.setUnConfirmUserCount(0L);
        }
        Long count = announcementUserMapper.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<AnnouncementUserPO> entityList = announcementUserMapper.find(request, passport);
            Set<Long> userIdSet = new HashSet<>();
            for (AnnouncementUserPO entity : entityList) {
                AnnouncementUser announcementUser = this.getMapper().map(entity, AnnouncementUser.class);
                modelList.add(announcementUser);
                userIdSet.add(announcementUser.getUserId());
            }

            UserFindRequest userFindRequest = new UserFindRequest();
            userFindRequest.setPageSize(0);
            userFindRequest.setIds(new ArrayList<Long>(userIdSet));
            UserFindResponse userFindResponse = masterService.findUser(userFindRequest, passport);
            if (userFindResponse != null && userFindResponse.getResult() != null && userFindResponse.getResult().size() > 0) {
                Map<Long, User> userMap = new HashMap<>();
                for (User user : userFindResponse.getResult()) {
                    userMap.put(user.getId(), user);
                }
                for (AnnouncementUser announcementUser : modelList) {
                    User user = userMap.get(announcementUser.getUserId());
                    if (user != null) {
                        if (StringUtils.isBlank(announcementUser.getUserName())) {
                            announcementUser.setUserName(user.getName());
                        }
                        announcementUser.setAvatarUrl(user.getAvatar());
                    }
                }
            }
        }
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

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

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

        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity,passport,response);
        if(response.hasError()) {
            return response;
        }

        if (announcementUserMapper.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 AnnouncementUserUpdateResponse update(AnnouncementUserUpdateRequest request, Passport passport) {
        AnnouncementUserUpdateResponse response = new AnnouncementUserUpdateResponse();

        AnnouncementUserPO entity = this.getMapper().map(request, AnnouncementUserPO.class);
        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity,passport,response);
        if(response.hasError()) {
            return response;
        }

        Long result=announcementUserMapper.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 AnnouncementUserConfirmResponse confirm(AnnouncementUseConfirmRequest request, Passport passport) {
        AnnouncementUserConfirmResponse response = new AnnouncementUserConfirmResponse();

        AnnouncementUserPO announcementUserPO = announcementUserMapper.getByAnnouncementId(request.getAnnouncementId(),passport);
        if(announcementUserPO == null){
            response.addError(ErrorType.BUSINESS_ERROR, "用户通知不存在或已被删除!");
            return response;
        }
        AnnouncementUserPO entity = this.getMapper().map(request, AnnouncementUserPO.class);
        entity.setRowVersion(announcementUserPO.getRowVersion());
        entity.setIsConfirm(true);
        entity.setConfirmUserId(passport.getUserId());
        entity.setConfirmUserName(passport.getUserName());
        entity.setConfirmTime(new Date());
        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity,passport,response);
        if(response.hasError()) {
            return response;
        }

        Long result=announcementUserMapper.confirm(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 AnnouncementUserCancelResponse cancel(AnnouncementUseCancelRequest request, Passport passport) {
        AnnouncementUserCancelResponse response = new AnnouncementUserCancelResponse();

        AnnouncementUserPO announcementUserPO = announcementUserMapper.getByAnnouncementId(request.getAnnouncementId(),passport);
        if(announcementUserPO == null){
            response.addError(ErrorType.BUSINESS_ERROR, "用户通知不存在或已被删除!");
            return response;
        }
        AnnouncementUserPO entity = this.getMapper().map(request, AnnouncementUserPO.class);
        entity.setRowVersion(announcementUserPO.getRowVersion());
        entity.setIsCancel(true);
        entity.setCancelUserId(passport.getUserId());
        entity.setConfirmUserName(passport.getUserName());
        entity.setCancelTime(new Date());
        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity,passport,response);
        if(response.hasError()) {
            return response;
        }

        Long result=announcementUserMapper.cancel(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 AnnouncementUserDeleteResponse delete(AnnouncementUserDeleteRequest request, Passport passport) {
        AnnouncementUserDeleteResponse response = new AnnouncementUserDeleteResponse();
         Long result= announcementUserMapper.delete(request.getId(), passport);
         response.setResult(result);
        return response;
    }
    
    

    /**
     * 验证对象
     * @param announcementUser 被通知用户
     * @param passport 用户护照
     */
    private void checkValidate(AnnouncementUserPO announcementUser, Passport passport, BaseResponse response) {
        // TODO
    }

}