customer / shanghai-railway-web

package com.xiniunet.service.railway.svc;

import com.xiniunet.framework.security.Passport;
import com.xiniunet.framework.util.ValidationUtil;
import com.xiniunet.railway.request.*;
import com.xiniunet.railway.response.*;
import com.xiniunet.railway.service.RailwayService;
import com.xiniunet.service.railway.biz.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * Created on 2017/4/20.
 *
 * @author 薛磊
 * @since 1.0.0
 */
@Component
public class RailwayServiceImpl implements RailwayService {

    @Autowired
    private ApiLogManager apiLogManager;

    @Autowired
    private EscortAttendanceLogManager escortAttendanceLogManager;

    @Autowired
    private EscortAttendanceManager escortAttendanceManager;

    @Autowired
    private OrganizationManager organizationManager;

    @Autowired
    private SafetyEscortManager safetyEscortManager;

    @Autowired
    private UserManager userManager;
    @Autowired
    private RailwayThirdManager railwayThirdManager;


    /**
     * 根据Id获取远程调用日志
     *
     * @param request  获取远程调用日志请求
     * @param passport 用户护照
     * @return 获取远程调用日志应答
     */
    @Override
    public ApiLogGetResponse getApiLog(ApiLogGetRequest request, Passport passport) {
        ApiLogGetResponse response = new ApiLogGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = apiLogManager.get(request, passport);
        return response;
    }

    /**
     * 模糊查询远程调用日志
     *
     * @param request  模糊查询远程调用日志请求
     * @param passport 用户护照
     * @return 模糊查询远程调用日志应答
     */
    @Override
    public ApiLogSearchResponse searchApiLog(ApiLogSearchRequest request, Passport passport) {
        ApiLogSearchResponse response = new ApiLogSearchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = apiLogManager.search(request, passport);
        return response;
    }

    /**
     * 高级查询远程调用日志
     *
     * @param request  高级查询远程调用日志请求
     * @param passport 用户护照
     * @return 高级查询远程调用日志应答
     */
    @Override
    public ApiLogFindResponse findApiLog(ApiLogFindRequest request, Passport passport) {
        ApiLogFindResponse response = new ApiLogFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = apiLogManager.find(request, passport);
        return response;
    }

    /**
     * 创建远程调用日志
     *
     * @param request  创建远程调用日志请求
     * @param passport 用户护照
     * @return 创建远程调用日志应答
     */
    @Override
    public ApiLogCreateResponse createApiLog(ApiLogCreateRequest request, Passport passport) {
        ApiLogCreateResponse response = new ApiLogCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = apiLogManager.create(request, passport);
        return response;
    }

    /**
     * 更新远程调用日志
     *
     * @param request  更新远程调用日志请求
     * @param passport 用户护照
     * @return 更新远程调用日志应答
     */
    @Override
    public ApiLogUpdateResponse updateApiLog(ApiLogUpdateRequest request, Passport passport) {
        ApiLogUpdateResponse response = new ApiLogUpdateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = apiLogManager.update(request, passport);
        return response;
    }

    /**
     * 删除远程调用日志
     *
     * @param request  删除远程调用日志请求
     * @param passport 用户护照
     * @return 删除远程调用日志应答
     */
    @Override
    public ApiLogDeleteResponse deleteApiLog(ApiLogDeleteRequest request, Passport passport) {
        ApiLogDeleteResponse response = new ApiLogDeleteResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = apiLogManager.delete(request, passport);
        return response;
    }

    /**
     * 根据Id获取护航员考勤日志
     *
     * @param request  获取护航员考勤日志请求
     * @param passport 用户护照
     * @return 获取护航员考勤日志应答
     */
    @Override
    public EscortAttendanceLogGetResponse getEscortAttendanceLog(EscortAttendanceLogGetRequest request, Passport passport) {
        EscortAttendanceLogGetResponse response = new EscortAttendanceLogGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceLogManager.get(request, passport);
        return response;
    }

    /**
     * 模糊查询护航员考勤日志
     *
     * @param request  模糊查询护航员考勤日志请求
     * @param passport 用户护照
     * @return 模糊查询护航员考勤日志应答
     */
    @Override
    public EscortAttendanceLogSearchResponse searchEscortAttendanceLog(EscortAttendanceLogSearchRequest request, Passport passport) {
        EscortAttendanceLogSearchResponse response = new EscortAttendanceLogSearchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceLogManager.search(request, passport);
        return response;
    }

    /**
     * 高级查询护航员考勤日志
     *
     * @param request  高级查询护航员考勤日志请求
     * @param passport 用户护照
     * @return 高级查询护航员考勤日志应答
     */
    @Override
    public EscortAttendanceLogFindResponse findEscortAttendanceLog(EscortAttendanceLogFindRequest request, Passport passport) {
        EscortAttendanceLogFindResponse response = new EscortAttendanceLogFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceLogManager.find(request, passport);
        return response;
    }

    /**
     * 创建护航员考勤日志
     *
     * @param request  创建护航员考勤日志请求
     * @param passport 用户护照
     * @return 创建护航员考勤日志应答
     */
    @Override
    public EscortAttendanceLogCreateResponse createEscortAttendanceLog(EscortAttendanceLogCreateRequest request, Passport passport) {
        EscortAttendanceLogCreateResponse response = new EscortAttendanceLogCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceLogManager.create(request, passport);
        return response;
    }

    /**
     * 更新护航员考勤日志
     *
     * @param request  更新护航员考勤日志请求
     * @param passport 用户护照
     * @return 更新护航员考勤日志应答
     */
    @Override
    public EscortAttendanceLogUpdateResponse updateEscortAttendanceLog(EscortAttendanceLogUpdateRequest request, Passport passport) {
        EscortAttendanceLogUpdateResponse response = new EscortAttendanceLogUpdateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceLogManager.update(request, passport);
        return response;
    }

    /**
     * 删除护航员考勤日志
     *
     * @param request  删除护航员考勤日志请求
     * @param passport 用户护照
     * @return 删除护航员考勤日志应答
     */
    @Override
    public EscortAttendanceLogDeleteResponse deleteEscortAttendanceLog(EscortAttendanceLogDeleteRequest request, Passport passport) {
        EscortAttendanceLogDeleteResponse response = new EscortAttendanceLogDeleteResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceLogManager.delete(request, passport);
        return response;
    }

    /**
     * 根据Id获取护航员考勤
     *
     * @param request  获取护航员考勤请求
     * @param passport 用户护照
     * @return 获取护航员考勤应答
     */
    @Override
    public EscortAttendanceGetResponse getEscortAttendance(EscortAttendanceGetRequest request, Passport passport) {
        EscortAttendanceGetResponse response = new EscortAttendanceGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.get(request, passport);
        return response;
    }

    /**
     * 模糊查询护航员考勤
     *
     * @param request  模糊查询护航员考勤请求
     * @param passport 用户护照
     * @return 模糊查询护航员考勤应答
     */
    @Override
    public EscortAttendanceSearchResponse searchEscortAttendance(EscortAttendanceSearchRequest request, Passport passport) {
        EscortAttendanceSearchResponse response = new EscortAttendanceSearchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.search(request, passport);
        return response;
    }

    /**
     * 高级查询护航员考勤
     *
     * @param request  高级查询护航员考勤请求
     * @param passport 用户护照
     * @return 高级查询护航员考勤应答
     */
    @Override
    public EscortAttendanceFindResponse findEscortAttendance(EscortAttendanceFindRequest request, Passport passport) {
        EscortAttendanceFindResponse response = new EscortAttendanceFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.find(request, passport);
        return response;
    }

    /**
     * 创建护航员考勤
     *
     * @param request  创建护航员考勤请求
     * @param passport 用户护照
     * @return 创建护航员考勤应答
     */
    @Override
    public EscortAttendanceCreateResponse createEscortAttendance(EscortAttendanceCreateRequest request, Passport passport) {
        EscortAttendanceCreateResponse response = new EscortAttendanceCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.create(request, passport);
        return response;
    }

    /**
     * 更新护航员考勤
     *
     * @param request  更新护航员考勤请求
     * @param passport 用户护照
     * @return 更新护航员考勤应答
     */
    @Override
    public EscortAttendanceUpdateResponse updateEscortAttendance(EscortAttendanceUpdateRequest request, Passport passport) {
        EscortAttendanceUpdateResponse response = new EscortAttendanceUpdateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.update(request, passport);
        return response;
    }

    /**
     * 删除护航员考勤
     *
     * @param request  删除护航员考勤请求
     * @param passport 用户护照
     * @return 删除护航员考勤应答
     */
    @Override
    public EscortAttendanceDeleteResponse deleteEscortAttendance(EscortAttendanceDeleteRequest request, Passport passport) {
        EscortAttendanceDeleteResponse response = new EscortAttendanceDeleteResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.delete(request, passport);
        return response;
    }

    /**
     * 根据Id获取组织部门
     *
     * @param request  获取组织部门请求
     * @param passport 用户护照
     * @return 获取组织部门应答
     */
    @Override
    public OrganizationGetResponse getOrganization(OrganizationGetRequest request, Passport passport) {
        OrganizationGetResponse response = new OrganizationGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = organizationManager.get(request, passport);
        return response;
    }

    /**
     * 模糊查询组织部门
     *
     * @param request  模糊查询组织部门请求
     * @param passport 用户护照
     * @return 模糊查询组织部门应答
     */
    @Override
    public OrganizationSearchResponse searchOrganization(OrganizationSearchRequest request, Passport passport) {
        OrganizationSearchResponse response = new OrganizationSearchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = organizationManager.search(request, passport);
        return response;
    }

    /**
     * 高级查询组织部门
     *
     * @param request  高级查询组织部门请求
     * @param passport 用户护照
     * @return 高级查询组织部门应答
     */
    @Override
    public OrganizationFindResponse findOrganization(OrganizationFindRequest request, Passport passport) {
        OrganizationFindResponse response = new OrganizationFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = organizationManager.find(request, passport);
        return response;
    }

    /**
     * 创建组织部门
     *
     * @param request  创建组织部门请求
     * @param passport 用户护照
     * @return 创建组织部门应答
     */
    @Override
    public OrganizationCreateResponse createOrganization(OrganizationCreateRequest request, Passport passport) {
        OrganizationCreateResponse response = new OrganizationCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = organizationManager.create(request, passport);
        return response;
    }

    /**
     * 更新组织部门
     *
     * @param request  更新组织部门请求
     * @param passport 用户护照
     * @return 更新组织部门应答
     */
    @Override
    public OrganizationUpdateResponse updateOrganization(OrganizationUpdateRequest request, Passport passport) {
        OrganizationUpdateResponse response = new OrganizationUpdateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = organizationManager.update(request, passport);
        return response;
    }

    /**
     * 删除组织部门
     *
     * @param request  删除组织部门请求
     * @param passport 用户护照
     * @return 删除组织部门应答
     */
    @Override
    public OrganizationDeleteResponse deleteOrganization(OrganizationDeleteRequest request, Passport passport) {
        OrganizationDeleteResponse response = new OrganizationDeleteResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = organizationManager.delete(request, passport);
        return response;
    }

    /**
     * 根据Id获取安全护航员
     *
     * @param request  获取安全护航员请求
     * @param passport 用户护照
     * @return 获取安全护航员应答
     */
    @Override
    public SafetyEscortGetResponse getSafetyEscort(SafetyEscortGetRequest request, Passport passport) {
        SafetyEscortGetResponse response = new SafetyEscortGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = safetyEscortManager.get(request, passport);
        return response;
    }

    /**
     * 模糊查询安全护航员
     *
     * @param request  模糊查询安全护航员请求
     * @param passport 用户护照
     * @return 模糊查询安全护航员应答
     */
    @Override
    public SafetyEscortSearchResponse searchSafetyEscort(SafetyEscortSearchRequest request, Passport passport) {
        SafetyEscortSearchResponse response = new SafetyEscortSearchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = safetyEscortManager.search(request, passport);
        return response;
    }

    /**
     * 高级查询安全护航员
     *
     * @param request  高级查询安全护航员请求
     * @param passport 用户护照
     * @return 高级查询安全护航员应答
     */
    @Override
    public SafetyEscortFindResponse findSafetyEscort(SafetyEscortFindRequest request, Passport passport) {
        SafetyEscortFindResponse response = new SafetyEscortFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = safetyEscortManager.find(request, passport);
        return response;
    }

    /**
     * 创建安全护航员
     *
     * @param request  创建安全护航员请求
     * @param passport 用户护照
     * @return 创建安全护航员应答
     */
    @Override
    public SafetyEscortCreateResponse createSafetyEscort(SafetyEscortCreateRequest request, Passport passport) {
        SafetyEscortCreateResponse response = new SafetyEscortCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = safetyEscortManager.create(request, passport);
        return response;
    }

    /**
     * 更新安全护航员
     *
     * @param request  更新安全护航员请求
     * @param passport 用户护照
     * @return 更新安全护航员应答
     */
    @Override
    public SafetyEscortUpdateResponse updateSafetyEscort(SafetyEscortUpdateRequest request, Passport passport) {
        SafetyEscortUpdateResponse response = new SafetyEscortUpdateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = safetyEscortManager.update(request, passport);
        return response;
    }

    /**
     * 删除安全护航员
     *
     * @param request  删除安全护航员请求
     * @param passport 用户护照
     * @return 删除安全护航员应答
     */
    @Override
    public SafetyEscortDeleteResponse deleteSafetyEscort(SafetyEscortDeleteRequest request, Passport passport) {
        SafetyEscortDeleteResponse response = new SafetyEscortDeleteResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = safetyEscortManager.delete(request, passport);
        return response;
    }

    /**
     * 根据Id获取用户
     *
     * @param request  获取用户请求
     * @param passport 用户护照
     * @return 获取用户应答
     */
    @Override
    public UserGetResponse getUser(UserGetRequest request, Passport passport) {
        UserGetResponse response = new UserGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = userManager.get(request, passport);
        return response;
    }

    /**
     * 模糊查询用户
     *
     * @param request  模糊查询用户请求
     * @param passport 用户护照
     * @return 模糊查询用户应答
     */
    @Override
    public UserSearchResponse searchUser(UserSearchRequest request, Passport passport) {
        UserSearchResponse response = new UserSearchResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = userManager.search(request, passport);
        return response;
    }

    /**
     * 高级查询用户
     *
     * @param request  高级查询用户请求
     * @param passport 用户护照
     * @return 高级查询用户应答
     */
    @Override
    public UserFindResponse findUser(UserFindRequest request, Passport passport) {
        UserFindResponse response = new UserFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = userManager.find(request, passport);
        return response;
    }
    /**
     * 注册用户
     *
     * @param request  注册用户
     * @return 创建用户应答
     */
    @Override
    public UserRegisterResponse registerUser(UserRegisterRequest request){
        UserRegisterResponse response = new UserRegisterResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = userManager.register(request);
        return response;
    }
    /**
     * 用户登录
     *
     * @param request  用户登录
     * @return 用户登录应答
     */
    @Override
    public UserLoginResponse loginUser(UserLoginRequest request){
        UserLoginResponse response = new UserLoginResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = userManager.login(request);
        return response;
    }
    /**
     * 创建用户
     *
     * @param request  创建用户请求
     * @param passport 用户护照
     * @return 创建用户应答
     */
    @Override
    public UserCreateResponse createUser(UserCreateRequest request, Passport passport) {
        UserCreateResponse response = new UserCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = userManager.create(request, passport);
        return response;
    }

    /**
     * 更新用户
     *
     * @param request  更新用户请求
     * @param passport 用户护照
     * @return 更新用户应答
     */
    @Override
    public UserUpdateResponse updateUser(UserUpdateRequest request, Passport passport) {
        UserUpdateResponse response = new UserUpdateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = userManager.update(request, passport);
        return response;
    }

    /**
     * 删除用户
     *
     * @param request  删除用户请求
     * @param passport 用户护照
     * @return 删除用户应答
     */
    @Override
    public UserDeleteResponse deleteUser(UserDeleteRequest request, Passport passport) {
        UserDeleteResponse response = new UserDeleteResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = userManager.delete(request, passport);
        return response;
    }
    /**
     * 调用第三方接口(获取位置信息)
     * @param request
     * @return
     */
    @Override
    public RailwayGetPositionResponse railwayGetPosition(RailwayGetPositionRequest request,Passport passport){
        RailwayGetPositionResponse response = new RailwayGetPositionResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = railwayThirdManager.getPosition(request,passport);
        return response;
    }
}