platform / task-web

/*
 * @(#)AnnouncementServiceImpl.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.svc;

import com.xiniunet.announcement.request.*;
import com.xiniunet.announcement.response.*;
import com.xiniunet.framework.annotation.MethodConfig;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.framework.util.ValidationUtil;
import com.xiniunet.announcement.biz.*;
import com.xiniunet.announcement.service.AnnouncementService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

/**
 * 公告通知的契约接口的实现.
 * @author 
 */
@Service
public class AnnouncementServiceImpl implements AnnouncementService {

    @Autowired
    private AnnouncementManager announcementManager;

    /**
     * 根据Id获取公告通知
     *
     * @param request 获取公告通知请求
     * @param passport 用户护照
     * @return 获取公告通知应答
     */
    @Override
    @MethodConfig(dataSource = "slaveDataSource")
    public AnnouncementGetResponse getAnnouncement(AnnouncementGetRequest request, Passport passport) {
        AnnouncementGetResponse response = new AnnouncementGetResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.get(request,passport);
        return response;
    }
    /**
     * 分享公告通知推送消息
     *
     * @param request 获取公告通知请求
     * @param passport 用户护照
     * @return 获取公告通知应答
     */
    @Override
    public AnnouncementSharePushMessageResponse shareAnnouncementPushMessage(AnnouncementSharePushMessageRequest request, Passport passport){
        AnnouncementSharePushMessageResponse response = new AnnouncementSharePushMessageResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.sharePushMessage(request,passport);
        return response;
    }
    /**
     * 高级查询公告进度
     *
     * @param request  高级查询任务请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    @Transactional(readOnly = true)
    @MethodConfig(dataSource = "slaveDataSource")
    public AnnouncementCommentFindResponse findAnnouncementComment(AnnouncementCommentFindRequest request, Passport passport){
        AnnouncementCommentFindResponse response = new AnnouncementCommentFindResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.findComment(request,passport);
        return response;
    }
    /**
     * 模糊查询公告通知
     *
     * @param request 模糊查询公告通知请求
     * @param passport 用户护照
     * @return 模糊查询公告通知应答
     */
    @Override
    public AnnouncementSearchResponse searchAnnouncement(AnnouncementSearchRequest request, Passport passport) {
        AnnouncementSearchResponse response = new AnnouncementSearchResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.search(request,passport);
        return response;
    }

    /**
     * 高级查询公告通知
     *
     * @param request 高级查询公告通知请求
     * @param passport 用户护照
     * @return 高级查询公告通知应答
     */
    @Override
    @MethodConfig(dataSource = "slaveDataSource")
    public AnnouncementFindResponse findAnnouncement(AnnouncementFindRequest request, Passport passport) {
        AnnouncementFindResponse response = new AnnouncementFindResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.find(request,passport);
        return response;
    }
    /**
     * 高级查询公告通知
     *
     * @param request 高级查询公告通知请求
     * @param passport 用户护照
     * @return 高级查询公告通知应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public AnnouncementIsActorResponse isAnnouncementActor(AnnouncementIsActorRequest request, Passport passport){
        AnnouncementIsActorResponse response = new AnnouncementIsActorResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.isActor(request,passport);
        return response;
    }

    /**
     * 高级自己发布的公告数
     *
     * @param request 高级查询公告通知请求
     * @param passport 用户护照
     * @return 高级查询公告通知应答
     */
    @Override
    public AnnouncementOwnCountGetResponse findAnnouncementOwnCount(AnnouncementOwnCountGetRequest request, Passport passport){
        AnnouncementOwnCountGetResponse response = new AnnouncementOwnCountGetResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.findOwnCount(request,passport);
        return response;
    }
    /**
     * 高级查询公告通知
     *
     * @param request 高级查询公告通知请求
     * @param passport 用户护照
     * @return 高级查询公告通知应答
     */
    @Override
    public AnnouncementFindResponse findAnnouncementByUser(AnnouncementFindRequest request, Passport passport){
        AnnouncementFindResponse response = new AnnouncementFindResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.findByUser(request,passport);
        return response;
    }
    /**
     * 创建公告通知
     *
     * @param request 创建公告通知请求
     * @param passport 用户护照
     * @return 创建公告通知应答
     */
    @Override
    @Transactional(rollbackFor=Exception.class)
    public AnnouncementCreateResponse createAnnouncement(AnnouncementCreateRequest request, Passport passport) {
        AnnouncementCreateResponse response = new AnnouncementCreateResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.create(request,passport);
        return response;
    }
    /**
     * 创建公告通知评论
     *
     * @param request 创建公告通知评论请求
     * @param passport 用户护照
     * @return 创建公告通知评论应答
     */
    @Override
    @Transactional(rollbackFor=Exception.class)
    public AnnouncementCommentCreateResponse createAnnouncementComment(AnnouncementCommentCreateRequest request, Passport passport) {
        AnnouncementCommentCreateResponse response = new AnnouncementCommentCreateResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.createComment(request,passport);
        return response;
    }
    /**
     * 撤销公告通知
     *
     * @param request 撤销公告通知请求
     * @param passport 用户护照
     * @return 撤销公告通知应答
     */
    @Override
    @Transactional(rollbackFor=Exception.class)
    public AnnouncementRevokeResponse revokeAnnouncement(AnnouncementRevokeRequest request, Passport passport) {
        AnnouncementRevokeResponse response = new AnnouncementRevokeResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.revoke(request,passport);
        return response;
    }
    /**
     * 全部确认公告通知
     *
     * @param request 全部确认公告通知请求
     * @param passport 用户护照
     * @return 全部确认公告通知应答
     */
    @Override
    public AnnouncementAllConfirmResponse allConfirmAnnouncement(AnnouncementAllConfirmRequest request, Passport passport) {
        AnnouncementAllConfirmResponse response = new AnnouncementAllConfirmResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.allConfirm(request,passport);
        return response;
    }
    /**
     * 更新公告通知
     *
     * @param request 更新公告通知请求
     * @param passport 用户护照
     * @return 更新公告通知应答
     */
    @Override
    @Transactional(rollbackFor=Exception.class)
    public AnnouncementUpdateResponse updateAnnouncement(AnnouncementUpdateRequest request, Passport passport) {
        AnnouncementUpdateResponse response = new AnnouncementUpdateResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.update(request,passport);
        return response;
    }

    /**
     * 删除公告通知
     *
     * @param request 删除公告通知请求
     * @param passport 用户护照
     * @return 删除公告通知应答
     */
    @Override
    @Transactional(rollbackFor=Exception.class)
    public AnnouncementDeleteResponse deleteAnnouncement(AnnouncementDeleteRequest request, Passport passport) {
        AnnouncementDeleteResponse response = new AnnouncementDeleteResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementManager.delete(request,passport);
        return response;
    }
    @Autowired
    private AnnouncementUserManager announcementUserManager;

    /**
     * 根据Id获取被通知用户
     *
     * @param request 获取被通知用户请求
     * @param passport 用户护照
     * @return 获取被通知用户应答
     */
    @Override
    public AnnouncementUserGetResponse getAnnouncementUser(AnnouncementUserGetRequest request, Passport passport) {
        AnnouncementUserGetResponse response = new AnnouncementUserGetResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementUserManager.get(request,passport);
        return response;
    }

    /**
     * 模糊查询被通知用户
     *
     * @param request 模糊查询被通知用户请求
     * @param passport 用户护照
     * @return 模糊查询被通知用户应答
     */
    @Override
    public AnnouncementUserSearchResponse searchAnnouncementUser(AnnouncementUserSearchRequest request, Passport passport) {
        AnnouncementUserSearchResponse response = new AnnouncementUserSearchResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementUserManager.search(request,passport);
        return response;
    }

    /**
     * 高级查询被通知用户
     *
     * @param request 高级查询被通知用户请求
     * @param passport 用户护照
     * @return 高级查询被通知用户应答
     */
    @Override
    public AnnouncementUserFindResponse findAnnouncementUser(AnnouncementUserFindRequest request, Passport passport) {
        AnnouncementUserFindResponse response = new AnnouncementUserFindResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementUserManager.find(request,passport);
        return response;
    }
    /**
     * 高级查询被通知用户
     *
     * @param request 高级查询被通知用户请求
     * @param passport 用户护照
     * @return 高级查询被通知用户应答
     */
    @Override
    public AnnouncementUserFindResponse getAnnouncementUserList(AnnouncementUserFindRequest request, Passport passport) {
        AnnouncementUserFindResponse response = new AnnouncementUserFindResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementUserManager.getUserList(request,passport);
        return response;
    }

    /**
     * 创建被通知用户
     *
     * @param request 创建被通知用户请求
     * @param passport 用户护照
     * @return 创建被通知用户应答
     */
    @Override
    @Transactional(rollbackFor=Exception.class)
    public AnnouncementUserCreateResponse createAnnouncementUser(AnnouncementUserCreateRequest request, Passport passport) {
        AnnouncementUserCreateResponse response = new AnnouncementUserCreateResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementUserManager.create(request,passport);
        return response;
    }

    /**
     * 更新被通知用户
     *
     * @param request 更新被通知用户请求
     * @param passport 用户护照
     * @return 更新被通知用户应答
     */
    @Override
    public AnnouncementUserUpdateResponse updateAnnouncementUser(AnnouncementUserUpdateRequest request, Passport passport) {
        AnnouncementUserUpdateResponse response = new AnnouncementUserUpdateResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementUserManager.update(request,passport);
        return response;
    }
    /**
     * 被通知用户确认
     *
     * @param request 更新被通知用户请求
     * @param passport 用户护照
     * @return 更新被通知用户应答
     */
    @Override
    @Transactional(rollbackFor=Exception.class)
    public AnnouncementUserConfirmResponse confirmAnnouncementUser(AnnouncementUseConfirmRequest request, Passport passport){
        AnnouncementUserConfirmResponse response = new AnnouncementUserConfirmResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementUserManager.confirm(request,passport);
        return response;
    }

    /**
     * 被通知用户取消
     *
     * @param request 更新被通知用户请求
     * @param passport 用户护照
     * @return 更新被通知用户应答
     */
    @Override
    @Transactional(rollbackFor=Exception.class)
    public AnnouncementUserCancelResponse cancelAnnouncementUser(AnnouncementUseCancelRequest request, Passport passport){
        AnnouncementUserCancelResponse response = new AnnouncementUserCancelResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementUserManager.cancel(request,passport);
        return response;
    }
    /**
     * 删除被通知用户
     *
     * @param request 删除被通知用户请求
     * @param passport 用户护照
     * @return 删除被通知用户应答
     */
    @Override
    public AnnouncementUserDeleteResponse deleteAnnouncementUser(AnnouncementUserDeleteRequest request, Passport passport) {
        AnnouncementUserDeleteResponse response = new AnnouncementUserDeleteResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = announcementUserManager.delete(request,passport);
        return response;
    }

    
}