platform / task-web

/**
 * @(#)TaskServiceImpl.java
 *
 * Copyright (c) 2014-2014  苏州犀牛网络科技有限公司 版权所有
 * 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.task.svc;

import com.xiniunet.framework.security.Passport;
import com.xiniunet.framework.util.ValidationUtil;
import com.xiniunet.task.biz.*;
import com.xiniunet.task.request.*;
import com.xiniunet.task.response.*;
import com.xiniunet.task.service.TaskService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

/**
 * Created by 沈振家 on 2016-11-28 16:23:01.
 *
 * @author 沈振家
 */
@Service
public class TaskServiceImpl implements TaskService {

    @Autowired
    private TaskListManager taskListManager;

    @Autowired
    private TaskManager taskManager;

    @Autowired
    private SubtaskManager subtaskManager;

    @Autowired
    private ListUserManager listUserManager;

    @Autowired
    private TaskUserManager taskUserManager;

    /**
     * 根据Id获取任务清单
     *
     * @param request  获取任务清单请求
     * @param passport 用户护照
     * @return 获取任务清单应答
     */
    @Override
    public TaskListGetResponse getTaskList(TaskListGetRequest request, Passport passport) {
        TaskListGetResponse response = new TaskListGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.get(request, passport);
        return response;
    }


    /**
     * 模糊查询任务清单
     *
     * @param request  模糊查询任务清单请求
     * @param passport 用户护照
     * @return 模糊查询任务清单应答
     */
    @Override
    public TaskListSearchResponse searchTaskList(TaskListSearchRequest request, Passport passport) {
        TaskListSearchResponse response = new TaskListSearchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.search(request, passport);
        return response;
    }

    /**
     * 高级查询任务清单
     *
     * @param request  高级查询任务清单请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    public TaskListFindResponse findTaskList(TaskListFindRequest request, Passport passport) {
        TaskListFindResponse response = new TaskListFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.find(request, passport);
        return response;
    }

    /**
     * 按负责人获取各任务清单
     *
     * @param request  按负责人获取各任务清单请求
     * @param passport 用户护照
     * @return 按负责人获取各任务清单应答
     */
    @Override
    public TaskListSummaryFindResponse findTaskListSummary(TaskListSummaryFindRequest request, Passport passport) {
        TaskListSummaryFindResponse response = new TaskListSummaryFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.findSummary(request, passport);
        return response;
    }

    /**
     * 按负责人获取各任务清单
     *
     * @param request  按负责人获取各任务清单请求
     * @param passport 用户护照
     * @return 按负责人获取各任务清单应答
     */
    @Override
    public TaskListFilterFindResponse findTaskListFilter(TaskListFilterFindRequest request, Passport passport) {
        TaskListFilterFindResponse response = new TaskListFilterFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.findFilter(request, passport);
        return response;
    }

    /**
     * 获取所有任务清单列表
     *
     * @param request  获取所有任务清单列表请求
     * @param passport 用户护照
     * @return 获取所有任务清单列表应答
     */
    @Override
    public TaskListGetAllListResponse getTaskListAllList(TaskListGetAllListRequest request, Passport passport) {
        TaskListGetAllListResponse response = new TaskListGetAllListResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.getAllList(request, passport);
        return response;
    }


    /**
     * 创建任务清单
     *
     * @param request  创建任务清单请求
     * @param passport 用户护照
     * @return 创建任务清单应答
     */
    @Override
    public TaskListCreateResponse createTaskList(TaskListCreateRequest request, Passport passport) {
        TaskListCreateResponse response = new TaskListCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.create(request, passport);
        return response;
    }


    /**
     * 更新任务清单
     *
     * @param request  更新任务清单请求
     * @param passport 用户护照
     * @return 更新任务清单应答
     */
    @Override
    public TaskListUpdateResponse updateTaskList(TaskListUpdateRequest request, Passport passport) {
        TaskListUpdateResponse response = new TaskListUpdateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.update(request, passport);
        return response;
    }


    /**
     * 删除任务清单
     *
     * @param request  删除任务清单请求
     * @param passport 用户护照
     * @return 删除任务清单应答
     */
    @Override
    public TaskListDeleteResponse deleteTaskList(TaskListDeleteRequest request, Passport passport) {
        TaskListDeleteResponse response = new TaskListDeleteResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.delete(request, passport);
        return response;
    }


    /**
     * 导入任务清单
     *
     * @param request  导入任务清单请求
     * @param passport 用户护照
     * @return 导入任务清单应答
     */
    @Override
    public TaskListListImportResponse importTaskListList(TaskListListImportRequest request, Passport passport) {
        TaskListListImportResponse response = new TaskListListImportResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskListManager.importList(request, passport);
        return response;
    }


    /**
     * 根据Id获取任务
     *
     * @param request  获取任务请求
     * @param passport 用户护照
     * @return 获取任务应答
     */
    @Override
    public TaskGetResponse getTask(TaskGetRequest request, Passport passport) {
        TaskGetResponse response = new TaskGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.get(request, passport);
        return response;
    }


    /**
     * 模糊查询任务
     *
     * @param request  模糊查询任务请求
     * @param passport 用户护照
     * @return 模糊查询任务应答
     */
    @Override
    public TaskSearchResponse searchTask(TaskSearchRequest request, Passport passport) {
        TaskSearchResponse response = new TaskSearchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.search(request, passport);
        return response;
    }

    /**
     * 高级查询任务
     *
     * @param request  高级查询任务请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    public TaskFindResponse findTask(TaskFindRequest request, Passport passport) {
        TaskFindResponse response = new TaskFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.find(request, passport);
        return response;
    }

    /**
     * 高级查询任务
     *
     * @param request  高级查询任务请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    public TaskFindByTaskUserResponse findTaskByTaskUser(TaskFindByTaskUserRequest request, Passport passport) {
        TaskFindByTaskUserResponse response = new TaskFindByTaskUserResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.findByTaskUser(request, passport);
        return response;
    }

    /**
     * 获取所有任务列表
     *
     * @param request  获取所有任务列表请求
     * @param passport 用户护照
     * @return 获取所有任务列表应答
     */
    @Override
    public TaskGetAllListResponse getTaskAllList(TaskGetAllListRequest request, Passport passport) {
        TaskGetAllListResponse response = new TaskGetAllListResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.getAllList(request, passport);
        return response;
    }


    /**
     * 创建任务
     *
     * @param request  创建任务请求
     * @param passport 用户护照
     * @return 创建任务应答
     */
    @Override
    public TaskCreateResponse createTask(TaskCreateRequest request, Passport passport) {
        TaskCreateResponse response = new TaskCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.create(request, passport);
        return response;
    }


    /**
     * 更新任务
     *
     * @param request  更新任务请求
     * @param passport 用户护照
     * @return 更新任务应答
     */
    @Override
    public TaskUpdateResponse updateTask(TaskUpdateRequest request, Passport passport) {
        TaskUpdateResponse response = new TaskUpdateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.update(request, passport);
        return response;
    }

    /**
     * 更新任务
     *
     * @param request  更新任务请求
     * @param passport 用户护照
     * @return 更新任务应答
     */
    @Override
    public TaskChangeByObjectResponse changeTaskByObject(TaskChangeByObjectRequest request, Passport passport) {
        TaskChangeByObjectResponse response = new TaskChangeByObjectResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.changeByObject(request, passport);
        return response;
    }

    /**
     * 设置任务完成
     *
     * @param request  设置任务完成请求
     * @param passport 用户护照
     * @return 设置任务完成应答
     */
    @Override
    public TaskDoneByObjectResponse doneTaskByObject(TaskDoneByObjectRequest request, Passport passport) {
        TaskDoneByObjectResponse response = new TaskDoneByObjectResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.doneByObject(request, passport);
        return response;
    }

    /**
     * 设置任务未完成
     *
     * @param request  设置任务未完成请求
     * @param passport 用户护照
     * @return 设置任务未完成应答
     */
    @Override
    public TaskTodoByObjectResponse todoTaskByObject(TaskTodoByObjectRequest request, Passport passport) {
        TaskTodoByObjectResponse response = new TaskTodoByObjectResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.todoByObject(request, passport);
        return response;
    }

    /**
     * 设置提醒
     *
     * @param request  设置提醒请求
     * @param passport 用户护照
     * @return 设置提醒应答
     */
    @Override
    public TaskRemindingEnableResponse enableRemindingTask(TaskRemindingEnableRequest request, Passport passport) {
        TaskRemindingEnableResponse response = new TaskRemindingEnableResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.enableReminding(request, passport);
        return response;
    }


    /**
     * 取消提醒
     *
     * @param request  取消提醒请求
     * @param passport 用户护照
     * @return 取消提醒应答
     */
    @Override
    public TaskRemindingDisableResponse disableRemindingTask(TaskRemindingDisableRequest request, Passport passport) {
        TaskRemindingDisableResponse response = new TaskRemindingDisableResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.disableReminding(request, passport);
        return response;
    }


    /**
     * 设置截至日
     *
     * @param request  设置截至日请求
     * @param passport 用户护照
     * @return 设置截至日应答
     */
    @Override
    public TaskDeadlineEnableResponse enableDeadlineTask(TaskDeadlineEnableRequest request, Passport passport) {
        TaskDeadlineEnableResponse response = new TaskDeadlineEnableResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.enableDeadline(request, passport);
        return response;
    }


    /**
     * 取消截至日
     *
     * @param request  取消截至日请求
     * @param passport 用户护照
     * @return 取消截至日应答
     */
    @Override
    public TaskDeadlineDisableResponse disableDeadlineTask(TaskDeadlineDisableRequest request, Passport passport) {
        TaskDeadlineDisableResponse response = new TaskDeadlineDisableResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.disableDeadline(request, passport);
        return response;
    }


    /**
     * 设置星标
     *
     * @param request  设置星标请求
     * @param passport 用户护照
     * @return 设置星标应答
     */
    @Override
    public TaskStarEnableResponse enableStarTask(TaskStarEnableRequest request, Passport passport) {
        TaskStarEnableResponse response = new TaskStarEnableResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.enableStar(request, passport);
        return response;
    }


    /**
     * 取消星标
     *
     * @param request  取消星标请求
     * @param passport 用户护照
     * @return 取消星标应答
     */
    @Override
    public TaskStarDisableResponse disableStarTask(TaskStarDisableRequest request, Passport passport) {
        TaskStarDisableResponse response = new TaskStarDisableResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.disableStar(request, passport);
        return response;
    }


    /**
     * 设置任务完成
     *
     * @param request  设置任务完成请求
     * @param passport 用户护照
     * @return 设置任务完成应答
     */
    @Override
    public TaskDoneResponse doneTask(TaskDoneRequest request, Passport passport) {
        TaskDoneResponse response = new TaskDoneResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.done(request, passport);
        return response;
    }


    /**
     * 设置任务未完成
     *
     * @param request  设置任务未完成请求
     * @param passport 用户护照
     * @return 设置任务未完成应答
     */
    @Override
    public TaskTodoResponse todoTask(TaskTodoRequest request, Passport passport) {
        TaskTodoResponse response = new TaskTodoResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.todo(request, passport);
        return response;
    }


    /**
     * 删除任务
     *
     * @param request  删除任务请求
     * @param passport 用户护照
     * @return 删除任务应答
     */
    @Override
    public TaskDeleteResponse deleteTask(TaskDeleteRequest request, Passport passport) {
        TaskDeleteResponse response = new TaskDeleteResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.delete(request, passport);
        return response;
    }



    /**
     *  批量创建任务
     *
     * @param request   批量创建任务请求
     * @param passport 用户护照
     * @return  批量创建任务应答
     */
    @Override
    public TaskCreateBatchResponse createBatchTask(TaskCreateBatchRequest request, Passport passport) {
        TaskCreateBatchResponse response = new TaskCreateBatchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.createBatch(request, passport);
        return response;
    }


    /**
     * 导入任务
     *
     * @param request  导入任务请求
     * @param passport 用户护照
     * @return 导入任务应答
     */
    @Override
    public TaskListImportResponse importTaskList(TaskListImportRequest request, Passport passport) {
        TaskListImportResponse response = new TaskListImportResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = taskManager.importList(request, passport);
        return response;
    }


    /**
     * 根据Id获取子任务
     *
     * @param request  获取子任务请求
     * @param passport 用户护照
     * @return 获取子任务应答
     */
    @Override
    public SubtaskGetResponse getSubtask(SubtaskGetRequest request, Passport passport) {
        SubtaskGetResponse response = new SubtaskGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.get(request, passport);
        return response;
    }


    /**
     * 模糊查询子任务
     *
     * @param request  模糊查询子任务请求
     * @param passport 用户护照
     * @return 模糊查询子任务应答
     */
    @Override
    public SubtaskSearchResponse searchSubtask(SubtaskSearchRequest request, Passport passport) {
        SubtaskSearchResponse response = new SubtaskSearchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.search(request, passport);
        return response;
    }

    /**
     * 高级查询子任务
     *
     * @param request  高级查询子任务请求
     * @param passport 用户护照
     * @return 高级查询应答
     */
    @Override
    public SubtaskFindResponse findSubtask(SubtaskFindRequest request, Passport passport) {
        SubtaskFindResponse response = new SubtaskFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.find(request, passport);
        return response;
    }

    /**
     * 获取所有子任务列表
     *
     * @param request  获取所有子任务列表请求
     * @param passport 用户护照
     * @return 获取所有子任务列表应答
     */
    @Override
    public SubtaskGetAllListResponse getSubtaskAllList(SubtaskGetAllListRequest request, Passport passport) {
        SubtaskGetAllListResponse response = new SubtaskGetAllListResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.getAllList(request, passport);
        return response;
    }


    /**
     * 创建子任务
     *
     * @param request  创建子任务请求
     * @param passport 用户护照
     * @return 创建子任务应答
     */
    @Override
    public SubtaskCreateResponse createSubtask(SubtaskCreateRequest request, Passport passport) {
        SubtaskCreateResponse response = new SubtaskCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.create(request, passport);
        return response;
    }


    /**
     * 更新子任务
     *
     * @param request  更新子任务请求
     * @param passport 用户护照
     * @return 更新子任务应答
     */
    @Override
    public SubtaskUpdateResponse updateSubtask(SubtaskUpdateRequest request, Passport passport) {
        SubtaskUpdateResponse response = new SubtaskUpdateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.update(request, passport);
        return response;
    }


    /**
     * 设置子任务完成
     *
     * @param request  设置子任务完成请求
     * @param passport 用户护照
     * @return 设置子任务完成应答
     */
    @Override
    public SubtaskDoneResponse doneSubtask(SubtaskDoneRequest request, Passport passport) {
        SubtaskDoneResponse response = new SubtaskDoneResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.done(request, passport);
        return response;
    }


    /**
     * 设置子任务未完成
     *
     * @param request  设置子任务未完成请求
     * @param passport 用户护照
     * @return 设置子任务未完成应答
     */
    @Override
    public SubtaskTodoResponse todoSubtask(SubtaskTodoRequest request, Passport passport) {
        SubtaskTodoResponse response = new SubtaskTodoResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.todo(request, passport);
        return response;
    }


    /**
     * 删除子任务
     *
     * @param request  删除子任务请求
     * @param passport 用户护照
     * @return 删除子任务应答
     */
    @Override
    public SubtaskDeleteResponse deleteSubtask(SubtaskDeleteRequest request, Passport passport) {
        SubtaskDeleteResponse response = new SubtaskDeleteResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.delete(request, passport);
        return response;
    }


    /**
     * 导入子任务
     *
     * @param request  导入子任务请求
     * @param passport 用户护照
     * @return 导入子任务应答
     */
    @Override
    public SubtaskListImportResponse importSubtaskList(SubtaskListImportRequest request, Passport passport) {
        SubtaskListImportResponse response = new SubtaskListImportResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = subtaskManager.importList(request, passport);
        return response;
    }



    /**
     * 根据Id获取清单成员表
     *
     * @param request 获取清单成员表请求
     * @param passport 用户护照
     * @return 获取清单成员表应答
     */
    @Override
    public ListUserGetResponse getListUser(ListUserGetRequest request, Passport passport) {
        ListUserGetResponse response = new ListUserGetResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = listUserManager.get(request,passport);
        return response;
    }

    /**
     * 模糊查询清单成员表
     *
     * @param request 模糊查询清单成员表请求
     * @param passport 用户护照
     * @return 模糊查询清单成员表应答
     */
    @Override
    public ListUserSearchResponse searchListUser(ListUserSearchRequest request, Passport passport) {
        ListUserSearchResponse response = new ListUserSearchResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = listUserManager.search(request,passport);
        return response;
    }

    /**
     * 高级查询清单成员表
     *
     * @param request 高级查询清单成员表请求
     * @param passport 用户护照
     * @return 高级查询清单成员表应答
     */
    @Override
    public ListUserFindResponse findListUser(ListUserFindRequest request, Passport passport) {
        ListUserFindResponse response = new ListUserFindResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = listUserManager.find(request,passport);
        return response;
    }

    /**
     * 创建清单成员表
     *
     * @param request 创建清单成员表请求
     * @param passport 用户护照
     * @return 创建清单成员表应答
     */
    @Override
    public ListUserCreateResponse createListUser(ListUserCreateRequest request, Passport passport) {
        ListUserCreateResponse response = new ListUserCreateResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = listUserManager.create(request,passport);
        return response;
    }

    /**
     * 更新清单成员表
     *
     * @param request 更新清单成员表请求
     * @param passport 用户护照
     * @return 更新清单成员表应答
     */
    @Override
    public ListUserUpdateResponse updateListUser(ListUserUpdateRequest request, Passport passport) {
        ListUserUpdateResponse response = new ListUserUpdateResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = listUserManager.update(request,passport);
        return response;
    }

    /**
     * 删除清单成员表
     *
     * @param request 删除清单成员表请求
     * @param passport 用户护照
     * @return 删除清单成员表应答
     */
    @Override
    public ListUserDeleteResponse deleteListUser(ListUserDeleteRequest request, Passport passport) {
        ListUserDeleteResponse response = new ListUserDeleteResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = listUserManager.delete(request,passport);
        return response;
    }



    /**
     * 根据Id获取任务分配表
     *
     * @param request 获取任务分配表请求
     * @param passport 用户护照
     * @return 获取任务分配表应答
     */
    @Override
    public TaskUserGetResponse getTaskUser(TaskUserGetRequest request, Passport passport) {
        TaskUserGetResponse response = new TaskUserGetResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = taskUserManager.get(request,passport);
        return response;
    }

    /**
     * 模糊查询任务分配表
     *
     * @param request 模糊查询任务分配表请求
     * @param passport 用户护照
     * @return 模糊查询任务分配表应答
     */
    @Override
    public TaskUserSearchResponse searchTaskUser(TaskUserSearchRequest request, Passport passport) {
        TaskUserSearchResponse response = new TaskUserSearchResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = taskUserManager.search(request,passport);
        return response;
    }

    /**
     * 高级查询任务分配表
     *
     * @param request 高级查询任务分配表请求
     * @param passport 用户护照
     * @return 高级查询任务分配表应答
     */
    @Override
    public TaskUserFindResponse findTaskUser(TaskUserFindRequest request, Passport passport) {
        TaskUserFindResponse response = new TaskUserFindResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = taskUserManager.find(request,passport);
        return response;
    }

    /**
     * 创建任务分配表
     *
     * @param request 创建任务分配表请求
     * @param passport 用户护照
     * @return 创建任务分配表应答
     */
    @Override
    public TaskUserCreateResponse createTaskUser(TaskUserCreateRequest request, Passport passport) {
        TaskUserCreateResponse response = new TaskUserCreateResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = taskUserManager.create(request,passport);
        return response;
    }

    /**
     * 更新任务分配表
     *
     * @param request 更新任务分配表请求
     * @param passport 用户护照
     * @return 更新任务分配表应答
     */
    @Override
    public TaskUserUpdateResponse updateTaskUser(TaskUserUpdateRequest request, Passport passport) {
        TaskUserUpdateResponse response = new TaskUserUpdateResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = taskUserManager.update(request,passport);
        return response;
    }

    /**
     * 删除任务分配表
     *
     * @param request 删除任务分配表请求
     * @param passport 用户护照
     * @return 删除任务分配表应答
     */
    @Override
    public TaskUserDeleteResponse deleteTaskUser(TaskUserDeleteRequest request, Passport passport) {
        TaskUserDeleteResponse response = new TaskUserDeleteResponse();
        ValidationUtil.validate(request,response);
        if(response.hasError()) {
            return response;
        }
        response = taskUserManager.delete(request,passport);
        return response;
    }


}