customer / shanghai-railway-web

package com.xiniunet.service.railway.svc;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.framework.util.ValidationUtil;
import com.xiniunet.railway.domain.DiffLinesEscortsNumberPercent;
import com.xiniunet.railway.domain.OnlineNumber;
import com.xiniunet.railway.domain.TrainLatitudeEscortsNumber;
import com.xiniunet.railway.enumication.ExistSafetyEscortEnum;
import com.xiniunet.railway.request.*;
import com.xiniunet.railway.response.*;
import com.xiniunet.railway.service.RailwayService;
import com.xiniunet.service.railway.Constant;
import com.xiniunet.service.railway.biz.*;
import org.apache.ecs.wml.P;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * 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 EscortAttendanceLogFindResponse findMaxEscortAttendanceLog(EscortAttendanceLogFindRequest request, Passport passport){
        EscortAttendanceLogFindResponse response = new EscortAttendanceLogFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceLogManager.findMax(request, passport);
        return response;
    }
    /**
     * 创建护航员考勤日志
     *
     * @param request  创建护航员考勤日志请求
     * @param passport 用户护照
     * @return 创建护航员考勤日志应答
     */
    @Override
    public EscortAttendanceLogCreateResponse createEscortAttendanceLog(EscortAttendanceLogCreateRequest request) {
        EscortAttendanceLogCreateResponse response = new EscortAttendanceLogCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        Passport passport = new Passport();
        passport.setTenantId(973848199737774088L);
        passport.setUserId(0L);
        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 findDistinctEscortAttendance(EscortAttendanceFindDistinctRequest request){
        EscortAttendanceFindResponse response = new EscortAttendanceFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        Passport passport = new Passport();
        passport.setTenantId(973848199737774088L);
        passport.setUserId(0L);
        response = escortAttendanceManager.findDistinct(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;
        }
        Passport passport = new Passport();
        passport.setTenantId(973848199737774088L);
        passport.setUserId(0L);
        response = escortAttendanceManager.find(request, passport);
        return response;
    }

    /**
     * 创建护航员考勤
     *
     * @param request  创建护航员考勤请求
     * @param passport 用户护照
     * @return 创建护航员考勤应答
     */
    @Override
    public EscortAttendanceCreateResponse createEscortAttendance(EscortAttendanceCreateRequest request) {
        EscortAttendanceCreateResponse response = new EscortAttendanceCreateResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        Passport passport = new Passport();
        passport.setTenantId(Constant.RAILWAY_TENANT_ID);
        passport.setUserId(Constant.RAILWAY_USER_ID);
        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;
        }
        Passport passport = new Passport();
        passport.setTenantId(Constant.RAILWAY_TENANT_ID);
        passport.setUserId(Constant.RAILWAY_USER_ID);
        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;
        }
        Passport passport = new Passport();
        passport.setTenantId(973848199737774088L);
        passport.setUserId(0L);
        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;
    }
    /**
     * 根据Id获取用户详情，包含（护航时间，是否自动上下岗）
     *
     * @param request  获取用户请求
     * @param passport 用户护照
     * @return 获取用户应答
     */
    @Override
    public UserGetInfoResponse getUserInfo(UserGetInfoRequest request/*, Passport passport*/){
        UserGetInfoResponse response = new UserGetInfoResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        Passport passport = new Passport();
        passport.setTenantId(973848199737774088L);
        passport.setUserId(0L);
        response = userManager.getInfo(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;
    }

    /**
     * 获取用户信息（根据account）
     *
     * @param request  注册用户
     * @return 创建用户应答
     */
    @Override
    public UserGetInfoByAccountResponse getUserInfoByAccount(UserGetInfoByAccountRequest request){
        UserGetInfoByAccountResponse response = new UserGetInfoByAccountResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = userManager.getUserInfoByAccount(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;
        }
        Passport passport = new Passport();
        passport.setTenantId(Constant.RAILWAY_TENANT_ID);
        passport.setUserId(Constant.RAILWAY_USER_ID);
        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;
        }
        Passport passport = new Passport();
        passport.setTenantId(973848199737774088L);
        passport.setUserId(0L);
        response = railwayThirdManager.getPosition(request,passport);
        return response;
    }

    /**
     * 调用第三方接口（获取当前时间列车数量信息）
     * @param request
     * @return
     */
    @Override
    public RailwayTransDetailCountGetResponse railwayTransCountDetailGet(RailwayTransDetailGetRequest request){
        RailwayTransDetailCountGetResponse response = new RailwayTransDetailCountGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        Passport passport = new Passport();
        passport.setTenantId(973848199737774088L);
        passport.setUserId(0L);
        response = railwayThirdManager.getTransCountDetail(request,passport);
        return response;
    }
    /**
     * 调用第三方接口（获取当前时间列车信息）
     * @param request
     * @return
     */
    @Override
    public RailwayTransDetailGetResponse railwayTransDetailGet(RailwayTransDetailGetRequest request){
        RailwayTransDetailGetResponse response = new RailwayTransDetailGetResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        Passport passport = new Passport();
        passport.setTenantId(973848199737774088L);
        passport.setUserId(0L);
        response = railwayThirdManager.getTransDetail(request,passport);
        return response;
    }
    /**
     *在线人数的接口
     */
    @Override
    public RailwayOnlineNumberFindResponse railwayOnlineNumberFind(EscortAttendanceFindDistinctRequest request,Passport passport){
        RailwayOnlineNumberFindResponse response = new RailwayOnlineNumberFindResponse();
        response.setValue(100L);
        return response;
    }

    /**
     * 安全护航员人数的接口
     * @param request
     * @return
     */
    @Override
    public RailwayOnlineNumberFindResponse railwaySafetyEscortsNumberFind(EscortAttendanceFindDistinctRequest request,Passport passport){
        RailwayOnlineNumberFindResponse response = new RailwayOnlineNumberFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.findRailwaySafetyEscortsNumber(request, passport);
        return response;
    }

    /**
     * 党员护航员人数的接口
     * @param request
     * @return
     */
    @Override
    public RailwayOnlineNumberFindResponse railwayPartyEscortsNumberFind(EscortAttendanceFindDistinctRequest request,Passport passport){
        RailwayOnlineNumberFindResponse response = new RailwayOnlineNumberFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.findRrailwayPartyEscortsNumber(request, passport);
        return response;
    }

    /**
     *
     */
    /**
     * 安全护航员人数，党员护航员人数，在线人数的接口
     * @param request
     * @return
     */
    @Override
    public SafetyPartyEscortsOnlineNumberFindResponse railwaySafetyPartyEscortsOnlineNumberFind(EscortAttendanceFindDistinctRequest request,Passport passport){
        SafetyPartyEscortsOnlineNumberFindResponse response = new SafetyPartyEscortsOnlineNumberFindResponse();
        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.findRailwaySafetyPartyEscortsOnlineNumber(request, passport);
        return response;
    }

    /**
     * 总列车数的接口
     * @return
     */
    @Override
    public RailwayOnlineNumberFindResponse railwayTrainsTotalNumberGet(EscortAttendanceFindRequest request,Passport passport){
        RailwayOnlineNumberFindResponse response = new RailwayOnlineNumberFindResponse();
        response = escortAttendanceManager.getRailwayTrainsTotalNumber(request,passport);
        return response;
    }

    /**
     * 有护航员列车数的接口
     * @return
     */
    @Override
    public RailwayOnlineNumberFindResponse railwayEscortTrainsNumberGet(EscortAttendanceFindRequest request,Passport passport){
        RailwayOnlineNumberFindResponse response = new RailwayOnlineNumberFindResponse();
        response = escortAttendanceManager.getRailwayEscortTrainsNumber(request,passport);
        return response;
    }

    /**
     * 无护航员列车数的接口
     * @return
     */
    @Override
    public RailwayOnlineNumberFindResponse railwayNoEscortTrainsNumberGet(EscortAttendanceFindRequest request,Passport passport){
        RailwayOnlineNumberFindResponse response = new RailwayOnlineNumberFindResponse();
        response = escortAttendanceManager.getRailwayNoEscortTrainsNumber(request,passport);
        return response;
    }

    /**
     * 合并接口，传回两个数值：有护航员的车厢数及无护航员列车数
     * @return
     */
    @Override
    public NoHaveEscortTrainsNumberGetResponse railwayNoHaveEscortTrainsNumberGet(EscortAttendanceFindRequest request,Passport passport){
        NoHaveEscortTrainsNumberGetResponse response = new NoHaveEscortTrainsNumberGetResponse();
        response = escortAttendanceManager.getRailwayNoHaveEscortTrainsNumber(request,passport);
        return response;
    }

    /**
     * 不同线路运行有护航员列车比例接口
     * @param request
     * @param passport
     * @return
     */
    @Override
    public DiffLinesTrainsEscortsNumberPercentGetResponse railwayDiffLinesTrainsEscortsNumberPercentGet(DiffLinesTrainsEscortsNumberPercentGetRequest request, Passport passport) {
        DiffLinesTrainsEscortsNumberPercentGetResponse response = new DiffLinesTrainsEscortsNumberPercentGetResponse();
        DiffLinesEscortsNumberPercent diffLinesEscortsNumberPercent = new DiffLinesEscortsNumberPercent();
        List<DiffLinesEscortsNumberPercent> list = new ArrayList<>();
        diffLinesEscortsNumberPercent.setX(1L);
        diffLinesEscortsNumberPercent.setY(20L);
        DiffLinesEscortsNumberPercent diffLinesEscortsNumberPercent2 = new DiffLinesEscortsNumberPercent();
        diffLinesEscortsNumberPercent2.setX(2L);
        diffLinesEscortsNumberPercent2.setY(30L);
        DiffLinesEscortsNumberPercent diffLinesEscortsNumberPercent3 = new DiffLinesEscortsNumberPercent();
        diffLinesEscortsNumberPercent3.setX(3L);
        diffLinesEscortsNumberPercent3.setY(50L);
        list.add(diffLinesEscortsNumberPercent);
        list.add(diffLinesEscortsNumberPercent2);
        list.add(diffLinesEscortsNumberPercent3);
        response.setResult(list);
        return response;
    }

    /**
     * 总车厢数接口
     * @param request
     * @param passport
     * @return
     */
    @Override
    public RailwayOnlineNumberFindResponse railwayCarriagesTotalNumberGet(RailwayOnlineNumberFindRequest request, Passport passport) {
        RailwayOnlineNumberFindResponse response = new RailwayOnlineNumberFindResponse();
        response.setValue(20L);
        return response;
    }

    /**
     * 有护航员车厢数的接口
     * @param request
     * @param passport
     * @return
     */
    @Override
    public RailwayOnlineNumberFindResponse railwayEscortCarriagesNumberGet(RailwayOnlineNumberFindRequest request, Passport passport) {
        RailwayOnlineNumberFindResponse response = new RailwayOnlineNumberFindResponse();
        response.setValue(13L);
        return response;
    }

    /**
     * 无护航员车厢数的接口
     * @param request
     * @param passport
     * @return
     */
    @Override
    public RailwayOnlineNumberFindResponse railwayNoEscortCarriagesNumberGet(RailwayOnlineNumberFindRequest request, Passport passport) {
        RailwayOnlineNumberFindResponse response = new RailwayOnlineNumberFindResponse();
        response.setValue(7L);
        return response;
    }

    /**
     * 合并接口，传回两个数值：有护航员的车厢数及无护航员车厢数的接口
     * @param request
     * @param passport
     * @return
     */
    @Override
    public NoHaveEscortTrainsNumberGetResponse railwayNoHaveEscortCarriagesNumberGet(EscortCarriagesFindRequest request, Passport passport) {
        NoHaveEscortTrainsNumberGetResponse response = new NoHaveEscortTrainsNumberGetResponse();
        List<OnlineNumber> list = new ArrayList<>();
        OnlineNumber onlineNumber = new OnlineNumber();
        onlineNumber.setType(ExistSafetyEscortEnum.HAVE_SAFETY_ESCORT);
        onlineNumber.setValue(13L);
        OnlineNumber onlineNumber2 = new OnlineNumber();
        onlineNumber2.setType(ExistSafetyEscortEnum.NO_HAVE_SAFETY_ESCORT);
        onlineNumber2.setValue(7L);
        list.add(onlineNumber);
        list.add(onlineNumber2);
        response.setResult(list);
        return response;
    }

    /**
     * 不同线路运行有护航员车厢比例接口
     * @param request
     * @param passport
     * @return
     */
    @Override
    public DiffLinesTrainsEscortsNumberPercentGetResponse railwayDiffLinesCarriagesEscortsNumberPercentGet(DiffLinesTrainsEscortsNumberPercentGetRequest request, Passport passport) {
        DiffLinesTrainsEscortsNumberPercentGetResponse response = new DiffLinesTrainsEscortsNumberPercentGetResponse();

        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.getDiffLinesCarriagesEscortsNumberPercent(request,passport);
        return response;
    }

    /**
     * 党支部名称，排名，党支部人数接口
     * @return
     */
    @Override
    public RailwayPartyBranchRankNumberFindResponse railwayPartyBranchRankNumberFind(RailwayPartyBranchRankNumberFindRequest request,Passport passport){
        RailwayPartyBranchRankNumberFindResponse response = new RailwayPartyBranchRankNumberFindResponse();
        response = escortAttendanceManager.getRailwayPartyBranchRankNumber(request,passport);
        return response;
    }

    /**
     * 用户ID 	上下岗信息的接口
     */
    @Override
    public UserLaidDetailFindResponse railwayUserLaidDetailFind(EscortAttendanceFindRequest request,Passport passport){
        UserLaidDetailFindResponse response = new UserLaidDetailFindResponse();
        response = escortAttendanceManager.getRailwayUserLaidDetail(request,passport);
        return response;
    }



    /**
     * 宏观列车护航员数量，列车号，上行站点名、下行站点名，列车护航员数量，列车所属线路。
     * @param request
     * @return
     */
    @Override
    public TrainEscortsNumberDetailFindResponse findTrainEscortsNumberDetail(TrainEscortsNumberDetailFindRequest request,Passport passport){
        TrainEscortsNumberDetailFindResponse response = new TrainEscortsNumberDetailFindResponse();

        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.findTrainEscortsNumberDetail(request,passport);
        return response;

    }

    /**
     * 宏观列车护航员数量，列车号，列车经度、纬度坐标，列车护航员数量，列车所属线路。
     * @param request
     * @return
     */
    @Override
    public TrainLatitudeEscortsNumberDetailFindResponse findTrainLatitudeEscortsNumberDetail(TrainLatitudeEscortsNumberDetailFindRequest  request, Passport passport) {
        TrainLatitudeEscortsNumberDetailFindResponse response = new TrainLatitudeEscortsNumberDetailFindResponse();
        List<TrainLatitudeEscortsNumber> list = new ArrayList<>();
        TrainLatitudeEscortsNumber trainLatitudeEscortsNumber = new TrainLatitudeEscortsNumber();
        trainLatitudeEscortsNumber.setTrainNo(101123L);
        BigDecimal lat = new BigDecimal("31.8998");
        trainLatitudeEscortsNumber.setLat(lat);
        BigDecimal lng = new BigDecimal("102.2212");
        trainLatitudeEscortsNumber.setLng(lng);
        trainLatitudeEscortsNumber.setValue(1L);
        trainLatitudeEscortsNumber.setType(1L);
        list.add(trainLatitudeEscortsNumber);

        TrainLatitudeEscortsNumber trainLatitudeEscortsNumber2 = new TrainLatitudeEscortsNumber();
        trainLatitudeEscortsNumber2.setTrainNo(123453L);
        BigDecimal lat2 = new BigDecimal("43.2398");
        trainLatitudeEscortsNumber2.setLat(lat2);
        BigDecimal lng2 = new BigDecimal("123.3312");
        trainLatitudeEscortsNumber2.setLng(lng2);
        trainLatitudeEscortsNumber2.setValue(20L);
        trainLatitudeEscortsNumber2.setType(2L);
        list.add(trainLatitudeEscortsNumber2);
        response.setResult(list);
        return response;
    }
    /**
     * 同时提供四辆车的车厢人数情况并按地铁线路实时更新，每次更新展示不同线路上的四辆车。
     */
    @Override
    public TrainCarriageEscortsNumberDetailFindResponse findTrainCarriageEscortsNumberDetail(TrainCarriageEscortsNumberDetailFindRequest  request, Passport passport){
        TrainCarriageEscortsNumberDetailFindResponse response = new TrainCarriageEscortsNumberDetailFindResponse();

        ValidationUtil.validate(request, response);
        if (response.hasError()) {
            return response;
        }
        response = escortAttendanceManager.findTrainCarriageEscortsNumberDetail(request,passport);
        return response;
    }
}