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.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.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

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

    @Autowired
    @Qualifier("NoticeAnnouncementManager")
    private AnnouncementManager announcementManager;

    /**
     * 根据Id获取公告通知
     *
     * @param request 获取公告通知请求
     * @param passport 用户护照
     * @return 获取公告通知应答
     */
    @Override
    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 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
    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
    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
    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
    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
    @Qualifier("NoticeAnnouncementUserManager")
    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 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
    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
    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;
    }

    
}