customer / shanghai-railway-web

/*
 * @(#)UserManagerImpl.java
 *
 * Copyright (c) 2014-2017  xiniunet 版权所有
 * 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.service.railway.biz;

import com.alibaba.dubbo.common.utils.StringUtils;
import com.alibaba.fastjson.JSON;
import com.xiniunet.ebusiness.domain.CommoditySubTitleImport;
import com.xiniunet.ebusiness.response.CommoditySubTitleImportResponse;
import com.xiniunet.foundation.contract.UploadTypeEnum;
import com.xiniunet.foundation.request.FileUploadRequest;
import com.xiniunet.foundation.response.FileUploadResponse;
import com.xiniunet.foundation.service.FoundationService;
import com.xiniunet.framework.base.BaseManagerImpl;
import com.xiniunet.framework.base.BaseResponse;
import com.xiniunet.framework.exception.ErrorType;
import com.xiniunet.framework.log.LogUtil;
import com.xiniunet.framework.security.Passport;
import com.xiniunet.framework.util.DateUtil;
import com.xiniunet.framework.util.SettingUtil;
import com.xiniunet.framework.util.excel.Excel;
import com.xiniunet.framework.util.excel.datatable.DataTable;
import com.xiniunet.framework.util.excel.enumeration.Status;
import com.xiniunet.master.request.membership.MemberCreateRequest;
import com.xiniunet.master.response.membership.MemberCreateResponse;
import com.xiniunet.master.service.MasterService;
import com.xiniunet.railway.domain.*;
import com.xiniunet.railway.enumication.LaidTypeEnum;
import com.xiniunet.railway.request.*;
import com.xiniunet.railway.response.*;
import com.xiniunet.railway.service.RailwayService;
import com.xiniunet.security.contract.VerificationTypeEnum;
import com.xiniunet.security.request.VerificationCheckRequest;
import com.xiniunet.security.response.VerificationCheckResponse;
import com.xiniunet.security.service.SecurityService;
import com.xiniunet.service.railway.Constant;
import com.xiniunet.service.railway.Message;
import com.xiniunet.service.railway.dal.*;
import com.xiniunet.service.railway.po.*;
import com.xiniunet.supporting.excel.enumeration.DataTableMode;
import com.xiniunet.supporting.excel.enumeration.ExcelVersion;
import com.xiniunet.supporting.excel.helper.DataTableHelper;
import com.xiniunet.web.util.ListUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.*;

import static jodd.util.ThreadUtil.sleep;

/**
 * 用户的管理方法实现.
 *
 * @author xiniunet
 */
@Transactional
@Service("RailwayUserManager")
public class UserManagerImpl extends BaseManagerImpl implements UserManager {

    public static List<User> listToExport = new ArrayList<>();

    @Autowired
    private FoundationService foundationService;

    /*@Autowired
    private BasicService basicService;

    @Autowired
    private com.xiniunet.user.service.UserService userService;*/
    @Autowired
    private MasterService masterService;

    @Autowired
    private SecurityService securityService;

    @Autowired
    private SafetyEscortManager safetyEscortManager;

    @Autowired
    private UserMapper userMapper;

    @Autowired
    private UserAttendanceMapper userAttendanceMapper;

    @Autowired
    private SafetyEscortMapper safetyEscortMapper;

    @Autowired
    private EscortAttendanceMapper escortAttendanceMapper;

    @Autowired
    private RailwayService railwayService;

    @Autowired
    private OrganizationMapper organizationMapper;

    /**
     * 根据Id获取用户
     *
     * @param request  获取用户请求
     * @param passport 用户护照
     * @return 获取用户应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public UserGetResponse get(UserGetRequest request, Passport passport) {
        UserGetResponse response = new UserGetResponse();
        UserPO entity = userMapper.getById(request.getId(), passport);
        if (entity != null) {
            User user = this.getMapper().map(entity, User.class);
            if(user.getEscortCount() == null){
                user.setEscortCount(0L);
            }
            if(user.getEscortTime() == null){
                user.setEscortTime(0L);
            }
            response.setUser(user);
        } else {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
        }
        return response;
    }
    /**
     * 根据Id获取用户详情，包含（护航时间，是否自动上离岗）
     *
     * @param request  获取用户请求
     * @param passport 用户护照
     * @return 获取用户应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public UserGetInfoResponse getInfo(UserGetInfoRequest request, Passport passport) {
        UserGetInfoResponse response = new UserGetInfoResponse();
        UserPO entity = userMapper.getById(request.getId(), passport);
        if (entity == null) {
            response.addError(ErrorType.BUSINESS_ERROR, "未获取到用户信息！");
            return  response;
        }
        User user = this.getMapper().map(entity, User.class);
        response.setUser(user);
        SafetyEscortPO safetyEscortPO = safetyEscortMapper.getByUserId(request.getId(), passport);
        if (safetyEscortPO == null) {
            response.addError(ErrorType.BUSINESS_ERROR, "护行员信息不存在！");
            return  response;
        }
        //当前日期（yyyymmdd）
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyyMMdd");
        Date now=new Date();
        String dateId=simpleDateFormat.format(now);


        //取当前周的周一
        Calendar ca=Calendar.getInstance(Locale.CHINA);
        ca.set(Calendar.DAY_OF_WEEK, Calendar.MONDAY);
        String dateIdEnd = simpleDateFormat.format(ca.getTime());

        SafetyEscort safetyEscort = this.getMapper().map(safetyEscortPO,SafetyEscort.class);
        response.setSafetyEscort(safetyEscort);
        EscortAttendanceFindDistinctRequest escortAttendanceFindDistinctRequest = new EscortAttendanceFindDistinctRequest();
        escortAttendanceFindDistinctRequest.setPageSize(1);
        escortAttendanceFindDistinctRequest.setDateId(Long.valueOf(dateId));
        escortAttendanceFindDistinctRequest.setUserId(safetyEscortPO.getUserId());
        escortAttendanceFindDistinctRequest.setType(LaidTypeEnum.LAID_ON.toString());
        //List<EscortAttendancePO> escortAttendancePOS = escortAttendanceMapper.findDistinct(escortAttendanceFindDistinctRequest,passport);
        List<EscortAttendancePO> escortAttendancePOS = userAttendanceMapper.findDistinct(escortAttendanceFindDistinctRequest,passport);
        if(escortAttendancePOS != null && escortAttendancePOS.size() > 0){
            EscortAttendance escortAttendance = this.getMapper().map(escortAttendancePOS.get(0),EscortAttendance.class);
            response.setEscortAttendance(escortAttendance);
        }
        String slave = SettingUtil.getProperty("", "enable.slave.read");
        EscortAttendanceFindRequest escortAttendanceFindRequest = new EscortAttendanceFindRequest();
        escortAttendanceFindRequest.setUserId(request.getId());
        escortAttendanceFindRequest.setDateId(Long.valueOf(dateId));
        if(StringUtils.isEmpty(slave) || slave.toLowerCase().equals("false")){
            //总护航时间
            Long escortTime = escortAttendanceMapper.findEscortTime(escortAttendanceFindRequest,passport);
            response.setEscortTime(escortTime == null ? 0:escortTime);
            //今日上次离岗之前的总护航时间
            Long todayEscortTime = escortAttendanceMapper.findEscortTime(escortAttendanceFindRequest,passport);
            response.setTodayEscortTime(todayEscortTime ==null? 0 :todayEscortTime);
        }else {
            EscortAttendanceEscortTimeFindRequest escortAttendanceEscortTimeFindRequest = new EscortAttendanceEscortTimeFindRequest();
            escortAttendanceEscortTimeFindRequest.setDateId(Long.valueOf(DateUtil.formatDate(new Date(),"yyyyMMdd")));
            escortAttendanceEscortTimeFindRequest.setUserId(request.getId());
            EscortAttendanceEscortTimeFindResponse escortAttendanceEscortTimeFindResponse= railwayService.railwayFindEscortTime(escortAttendanceEscortTimeFindRequest);
            if(escortAttendanceEscortTimeFindResponse.hasError()){
                response.addErrors(escortAttendanceEscortTimeFindResponse.getErrors());
                return response;
            }
            response.setEscortTime(escortAttendanceEscortTimeFindResponse.getEscortTime());
            response.setTodayEscortTime(escortAttendanceEscortTimeFindResponse.getTodayEscortTime());
        }
        escortAttendanceFindRequest.setDateIdEnd(Long.valueOf(dateIdEnd));
        UserGetInfoResponse timesByWeek = escortAttendanceMapper.findEscortTimeByWeek(escortAttendanceFindRequest,passport);
        response.setEscortCountWeek(timesByWeek.getEscortCountWeek());
        response.setEscortTimeWeek(timesByWeek.getEscortTimeWeek());
        return response;
    }

    /**
     * 模糊查询用户
     *
     * @param request  模糊查询用户请求
     * @param passport 用户护照
     * @return 模糊查询用户应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public UserSearchResponse search(UserSearchRequest request, Passport passport) {
        UserSearchResponse response = new UserSearchResponse();
        List<User> modelList = new ArrayList<>();
        Long count = userMapper.searchCount(request, passport);

        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }

            //通过关键字查询出用户集合
            List<UserPO> entityList = userMapper.search(request, passport);

            for (UserPO entity : entityList) {
                User user = this.getMapper().map(entity, User.class);
                modelList.add(user);
            }
        }

        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    /**
     * 高级查询用户
     *
     * @param request  高级查询用户请求
     * @param passport 用户护照
     * @return 高级查询用户应答
     */
    @Override
    @Transactional(propagation = Propagation.NOT_SUPPORTED, readOnly = true)
    public UserFindResponse find(UserFindRequest request, Passport passport) {
        UserFindResponse response = new UserFindResponse();
        List<User> modelList = new ArrayList<>();
        Long count = userMapper.findCount(request, passport);
        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }

            List<UserPO> entityList = userMapper.find(request, passport);
            for (UserPO entity : entityList) {
                User user = this.getMapper().map(entity, User.class);
                modelList.add(user);
            }
        }

        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }
    /**
     * 注册用户
     *
     * @param request  注册用户
     * @return 创建用户应答
     */
    @Override
    public UserRegisterResponse register(UserRegisterRequest request){
        UserRegisterResponse response = new UserRegisterResponse();
        //todo demo验证码不需要校验
        if (request.getType() != 1) {
            // 校验手机验证码
            if (!"XINIUNET".equals(request.getVerifyCode())) {
                VerificationCheckRequest verificationCheckRequest = new VerificationCheckRequest();
                verificationCheckRequest.setCode(request.getVerifyCode());
                verificationCheckRequest.setType(VerificationTypeEnum.MOBILE);
                verificationCheckRequest.setObject(request.getMobilePhone());
                VerificationCheckResponse verificationCheckResponse = securityService.checkValification(verificationCheckRequest);
                if (verificationCheckResponse.getIsVerificated() == null || !verificationCheckResponse.getIsVerificated()) {
                    response.addError(ErrorType.BUSINESS_ERROR, "验证码不正确");
                    return response;
                }
            }
        }
        Passport passport = new Passport();
        passport.setTenantId(request.getTenantId());
        passport.setUserId(0L);
        Date now = new Date();


        MemberCreateRequest memberCreateRequest = new MemberCreateRequest();
        memberCreateRequest.setSourceId(0L);
        memberCreateRequest.setBalancePoint(0.0);
        memberCreateRequest.setCardBalance(0.0);
        memberCreateRequest.setCardNumber(request.getMobilePhone());
        memberCreateRequest.setIsActive(true);
        memberCreateRequest.setLoginPassword(request.getPassword());
        memberCreateRequest.setLoginPassword(request.getPassword());
        memberCreateRequest.setIsOpenCard(true);
        memberCreateRequest.setSourceAccount(request.getMobilePhone());
        memberCreateRequest.setSourcePlatform("PADT");
        memberCreateRequest.setLevelId(917742753075564544L);
        memberCreateRequest.setDateId(Long.valueOf(DateUtil.formatDate(new Date(),"yyyyMMdd")));
        memberCreateRequest.setSourceTypeId(516518817812582400L);
        memberCreateRequest.setName(request.getMobilePhone());
        memberCreateRequest.setUserAccount(request.getMobilePhone());
        MemberCreateResponse memberCreateResponse = masterService.createMember(memberCreateRequest,passport);
        if(memberCreateResponse.hasError()){
            response.addErrors(memberCreateResponse.getErrors());
            return response;
        }


        UserCreateRequest userCreateRequest = new UserCreateRequest();
        userCreateRequest.setId(memberCreateResponse.getMember().getUserId());
        userCreateRequest.setPartyId(28L);
        userCreateRequest.setEscortCount(0L);
        userCreateRequest.setEscortTime(0L);
        UserCreateResponse userCreateResponse = this.create(userCreateRequest,passport);
        if(userCreateResponse.hasError()){
            response.addErrors(userCreateResponse.getErrors());
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }

        //创建护行员
        if (request.getType() != 1) {
            SafetyEscortCreateRequest safetyEscortCreateRequest = new SafetyEscortCreateRequest();
            safetyEscortCreateRequest.setAutoLaid(true);
            safetyEscortCreateRequest.setIsLaid(false);
            safetyEscortCreateRequest.setUserId(memberCreateResponse.getMember().getUserId());
            SafetyEscortCreateResponse safetyEscortCreateResponse = safetyEscortManager.create(safetyEscortCreateRequest,passport);
            if(safetyEscortCreateResponse.hasError()){
                response.addErrors(safetyEscortCreateResponse.getErrors());
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return response;
            }
        }
        response.setId(memberCreateResponse.getMember().getUserId());
        response.setPassport(passport);
        return response;
    }

    /**
     * 获取用户信息（根据account）
     *
     * @param request  account
     * @return 创建用户应答
     */
    @Override
    public UserGetInfoByAccountResponse getUserInfoByAccount(UserGetInfoByAccountRequest request){
        UserGetInfoByAccountResponse response = new UserGetInfoByAccountResponse();
        UserGetInfoResponse userGetInfoResponse = new UserGetInfoResponse();
        Passport passport = new Passport();
        passport.setTenantId(Constant.RAILWAY_TENANT_ID);
        passport.setUserId(Constant.RAILWAY_USER_ID);
        /*Identity identity = new Identity();*/
        Date now = new Date();
        com.xiniunet.master.request.system.UserFindRequest userFindRequest = new com.xiniunet.master.request.system.UserFindRequest();
        userFindRequest.setAccount(request.getAccount());
        com.xiniunet.master.response.system.UserFindResponse userFindResponse = masterService.findUser(userFindRequest,passport);
        if(userFindResponse.hasError()){
            response.addErrors(userFindResponse.getErrors());
            response.addError(ErrorType.BUSINESS_ERROR,"master查询用户接口超时");
            return response;
        }
        if (userFindResponse.getResult() == null || userFindResponse.getResult().size() == 0) {
            com.xiniunet.master.request.system.UserCreateRequest userUserCreateRequest = new com.xiniunet.master.request.system.UserCreateRequest();
            userUserCreateRequest.setAccount(request.getAccount());
            userUserCreateRequest.setName(request.getAccount());
            userUserCreateRequest.setMobilePhone(request.getAccount());
            userUserCreateRequest.setIsMobileBind(true);
            userUserCreateRequest.setIsActive(true);
            userUserCreateRequest.setActiveDate(now);
            com.xiniunet.master.response.system.UserCreateResponse userUserCreateResponse = masterService.createUser(userUserCreateRequest, passport);

            // TODO: 2018/3/22 如果创建失败，sys_user 回滚不了
            if (userUserCreateResponse.hasError()) {
                response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
                response.addErrors(userUserCreateResponse.getErrors());
               /* TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();*/
                return response;
            }
            //创建rw_user用户
            UserPO user = new UserPO();
            user.setId(userUserCreateResponse.getId());
            //DataSourceKeyHolder.setDataSourceKey("masterDataSource");
            Long userCount = userMapper.insert(user, passport);
            if (userCount != 1) {
                response.addError(ErrorType.BUSINESS_ERROR,"创建用户信息失败！");
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return response;
            }
            //创建护行员
            SafetyEscortPO safetyEscort = new SafetyEscortPO();
            safetyEscort.setId(foundationService.getNewId());
            safetyEscort.setAutoLaid(true);
            safetyEscort.setIsLaid(false);
            safetyEscort.setUserId(userUserCreateResponse.getId());
            Long safetyCount  = safetyEscortMapper.insert(safetyEscort, passport);
            if (safetyCount != 1) {
                response.addError(ErrorType.BUSINESS_ERROR,"创建护行员信息失败！");
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return response;
            }
           // DataSourceKeyHolder.setDataSourceKey("slaveDataSource");
            UserPO userPO =  userMapper.getInfomationByAccount(request.getAccount(),passport);
            if(userPO != null && userPO.getCompanyId() != null){
                //DataSourceKeyHolder.setDataSourceKey("masterDataSource");
                userPO.setId(userUserCreateResponse.getId());
                userPO.setRowVersion(0L);
                long count = userMapper.update(userPO,passport);
                if(count != 1){
                    response.addError(ErrorType.BUSINESS_ERROR, "更新用户信息失败");
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    return response;
                }
            }

        }else {
            //如果存在，判断rw_user表中是否存在数据
            UserPO entity = userMapper.getById(userFindResponse.getResult().get(0).getId(), passport);
            if(entity== null){//rw_user 不存在数据则重新创建
                //获取company信息
                UserPO userPO =  userMapper.getInfomationByAccount(request.getAccount(),passport);
                //创建rw_user用户
                UserCreateRequest userCreateRequest = new UserCreateRequest();
                userCreateRequest.setId(userFindResponse.getResult().get(0).getId());
                userCreateRequest.setCompanyId(userPO == null ? null : userPO.getCompanyId());
                UserCreateResponse userCreateResponse = this.create(userCreateRequest, passport);
                if (userCreateResponse.hasError()) {
                    response.addErrors(userCreateResponse.getErrors());
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    return response;
                }
                SafetyEscortPO safetyEscortPO = safetyEscortMapper.getByUserId(userFindResponse.getResult().get(0).getId(),passport);
                if(safetyEscortPO == null){
                    //DataSourceKeyHolder.setDataSourceKey("masterDataSource");
                    //创建护行员
                    SafetyEscortPO safetyEscort = new SafetyEscortPO();
                    safetyEscort.setId(foundationService.getNewId());
                    safetyEscort.setAutoLaid(true);
                    safetyEscort.setIsLaid(false);
                    safetyEscort.setUserId(userFindResponse.getResult().get(0).getId());
                    Long safetyCount  = safetyEscortMapper.insert(safetyEscort, passport);
                    if (safetyCount != 1) {
                        response.addError(ErrorType.BUSINESS_ERROR,"创建护行员信息失败！");
                        TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                        return response;
                    }
                }
            }else{//entity存在
                //判断companyId 有没有如果没有则进行查询设置
                if(entity.getCompanyId() == null){
                    UserPO userPO =  userMapper.getInfomationByAccount(request.getAccount(),passport);
                    if(userPO != null && userPO.getCompanyId() != null){
                        //DataSourceKeyHolder.setDataSourceKey("masterDataSource");
                        entity.setCompanyId(userPO.getCompanyId());
                        long count = userMapper.update(entity,passport);
                        if(count != 1){
                            response.addError(ErrorType.BUSINESS_ERROR, "更新用户信息失败");
                            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                            return response;
                        }
                    }
                }
            }
        }
        com.xiniunet.master.response.system.UserFindResponse accountResponse = masterService.findUser(userFindRequest, passport);
        if (accountResponse.hasError()) {
            response.addErrors(accountResponse.getErrors());
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }
        //查询用户实时位置信息
        UserAttendancePO userAttendancePO = userAttendanceMapper.getById(accountResponse.getResult().get(0).getId(),passport);
       if(userAttendancePO == null){
           //创建用户实时位置信息
           UserAttendancePO userAttendance = new UserAttendancePO();
           userAttendance.setId(accountResponse.getResult().get(0).getId());
           long userAttendanceCount = userAttendanceMapper.insert(userAttendance,passport);
           if (userAttendanceCount != 1) {
               response.addError(ErrorType.BUSINESS_ERROR,"创建用户实时位置信息失败！");
               TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
               return response;
           }
       }
        UserGetInfoRequest userGetInfoRequest = new UserGetInfoRequest();
        if (accountResponse.getResult() != null && accountResponse.getResult().size() > 0) {
            userGetInfoRequest.setId(accountResponse.getResult().get(0).getId());
            userGetInfoResponse = this.getInfo(userGetInfoRequest,passport);
            if(userGetInfoResponse.hasError()){
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                response.addErrors(userGetInfoResponse.getErrors());
                return  response;
            }
        }
        response.setUser(userGetInfoResponse.getUser());
        response.setEscortAttendance(userGetInfoResponse.getEscortAttendance());
        response.setEscortTime(userGetInfoResponse.getEscortTime());
        response.setSafetyEscort(userGetInfoResponse.getSafetyEscort());
        response.setTodayEscortTime(userGetInfoResponse.getTodayEscortTime());
        return response;
    }

    /**
     * 用户登录
     *
     * @param request  用户登录
     * @return 用户登录应答
     */
    @Override
    public UserLoginResponse login(UserLoginRequest request){
        UserLoginResponse response = new UserLoginResponse();
        //登陆操作
        //Long userid = accountResponse.getResult().get(0).getId();
        com.xiniunet.security.request.UserLoginRequest loginRequest = new com.xiniunet.security.request.UserLoginRequest();
        loginRequest.setAccount(request.getAccount()+"@800089");
        System.out.println(request.getPassword());
        loginRequest.setPassword(request.getPassword());
        loginRequest.setIp("192.168.1.102");
        com.xiniunet.security.response.UserLoginResponse loginResponse = securityService.loginUser(loginRequest);
        if(loginResponse.hasError()){
            response.addErrors(loginResponse.getErrors());
            return response;
        }
       /* response = this.getMapper().map(response,UserLoginResponse.class);*/
       //设置passport
        response.setPassport(loginResponse.getPassport());

        //获取sys_user用户信息
        com.xiniunet.master.request.system.UserGetRequest userGetNewRequest = new com.xiniunet.master.request.system.UserGetRequest();
        userGetNewRequest.setId(loginResponse.getPassport().getUserId());
        com.xiniunet.master.response.system.UserGetResponse sysUserGetResponse = masterService.getUser(userGetNewRequest,loginResponse.getPassport());
        if(sysUserGetResponse.hasError()){
            response.addErrors(sysUserGetResponse.getErrors());
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }
        if(sysUserGetResponse.getUser() == null){
            response.addError(ErrorType.BUSINESS_ERROR, "未获取到用户信息！");
            return response;
        }
        //查询用户实时位置信息
        UserAttendancePO userAttendancePO = userAttendanceMapper.getById(sysUserGetResponse.getUser().getId(),loginResponse.getPassport());
        if(userAttendancePO == null){
            //创建用户实时位置信息
            UserAttendancePO userAttendance = new UserAttendancePO();
            userAttendance.setId(sysUserGetResponse.getUser().getId());
            long userAttendanceCount = userAttendanceMapper.insert(userAttendance,loginResponse.getPassport());
            if (userAttendanceCount != 1) {
                response.addError(ErrorType.BUSINESS_ERROR,"创建用户实时位置信息失败！");
                TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                return response;
            }
        }
        User user = this.getMapper().map(sysUserGetResponse.getUser(),User.class);
        //获取用户信息
        UserGetRequest userGetInfoRequest = new UserGetRequest();
        userGetInfoRequest.setId(loginResponse.getPassport().getUserId());
        UserGetResponse userGetInfoResponse = this.get(userGetInfoRequest,loginResponse.getPassport());
        if(userGetInfoResponse.hasError()){
            response.addErrors(userGetInfoResponse.getErrors());
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }
        //二级组织拼接显示
        if (userGetInfoResponse.getUser().getPartyId() != null){
            OrganizationPO organizationPO = organizationMapper.getById(userGetInfoResponse.getUser().getPartyId(),response.getPassport());
            if (organizationPO != null && organizationPO.getPid() != null){
                OrganizationPO organization = organizationMapper.getByCode(organizationPO.getPid(),response.getPassport());
                if (organization != null){
                    userGetInfoResponse.getUser().setPartyName(organization.getName() + "-" + organizationPO.getName());
                }
            }
        }
        //判断companyId 有没有如果没有则进行查询设置
        if(userGetInfoResponse.getUser().getCompanyId() == null){
            UserPO userPO =  userMapper.getInfomationByAccount(request.getAccount(),loginResponse.getPassport());
            if(userPO != null && userPO.getCompanyId() != null){
                userPO.setId(userGetInfoResponse.getUser().getId());
                userPO.setRowVersion(userGetInfoResponse.getUser().getRowVersion());
                long count = userMapper.update(userPO,loginResponse.getPassport());
                if(count != 1){
                    response.addError(ErrorType.BUSINESS_ERROR, "更新用户信息失败");
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    return response;
                }
            }
        }
        //获取积分商城会员ID
        Long memberId = userAttendanceMapper.findMemberId(userGetInfoResponse.getUser().getId(),response.getPassport());
        response.setMemberId(memberId);
        //设置私有表属性
        User userNew = userGetInfoResponse.getUser();
        user.setIsPartyMember(userNew.getIsPartyMember());
        user.setAge(userNew.getAge());
        user.setCompanyId(userNew.getCompanyId());
        user.setCompanyCode(userNew.getCompanyCode());
        user.setCompanyName(userNew.getCompanyName());
        user.setPartyId(userNew.getPartyId());
        user.setPartyCode(userNew.getPartyCode());
        user.setPartyName(userNew.getPartyName());
        user.setGender(userNew.getGender());
        user.setEducation(userNew.getEducation());
        user.setOccupation(userNew.getOccupation());
        user.setPoliticalStatus(userNew.getPoliticalStatus());
        user.setIsEmployee(userNew.getIsEmployee());
        user.setEmployeeNumber(userNew.getEmployeeNumber());
        user.setVolunteerId(userNew.getVolunteerId());
        user.setVolunteerCode(userNew.getVolunteerCode());
        user.setVolunteerName(userNew.getVolunteerName());
        response.setUser(user);
        return response;
    }
    /**
     * 创建用户
     *
     * @param request  创建用户请求
     * @param passport 用户护照
     * @return 创建用户应答
     */
    @Override
    public UserCreateResponse create(UserCreateRequest request, Passport passport) {
        UserCreateResponse response = new UserCreateResponse();

        UserPO entity = this.getMapper().map(request, UserPO.class);
        if (entity.getId() == null) {
            long id = foundationService.getNewId();
            entity.setId(id);
        }

        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity, passport, response);
        if (response.hasError()) {
            return response;
        }

        if (userMapper.insert(entity, passport) == 0) {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_CREATE_FAILURE);
            return response;
        }

        response.setId(entity.getId());
        return response;
    }

    /**
     * 更新用户
     *
     * @param request  更新用户请求
     * @param passport 用户护照
     * @return 更新用户应答
     */
    @Override
    public UserUpdateResponse update(UserUpdateRequest request, Passport passport) {
        UserUpdateResponse response = new UserUpdateResponse();
        if(request.getNickName()!=null && !"".equals(request.getNickName()) ){
            //获取sys_user用户信息
            com.xiniunet.master.request.system.UserGetRequest userGetNewRequest = new com.xiniunet.master.request.system.UserGetRequest();
            userGetNewRequest.setId(request.getId());
            com.xiniunet.master.response.system.UserGetResponse sysUserGetResponse = masterService.getUser(userGetNewRequest,passport);
            if(sysUserGetResponse.hasError()){
                response.addErrors(sysUserGetResponse.getErrors());
                return response;
            }
            if(sysUserGetResponse.getUser() == null){
                response.addError(ErrorType.BUSINESS_ERROR, "未获取到用户信息！");
                return response;
            }
            //更新用户昵称
            com.xiniunet.master.request.system.UserUpdateRequest userUpdateRequest = this.getMapper().map(sysUserGetResponse.getUser(),com.xiniunet.master.request.system.UserUpdateRequest.class);
            userUpdateRequest.setNickName(request.getNickName());
            com.xiniunet.master.response.system.UserUpdateResponse userUpdateResponse =  masterService.updateUser(userUpdateRequest,passport);
            if(userUpdateResponse.hasError()){
                response.addErrors(userUpdateResponse.getErrors());
                return response;
            }
        }

        UserPO userPO = userMapper.getById(request.getId(),passport);
        if(userPO == null){
            response.addError(ErrorType.BUSINESS_ERROR, "用户信息不存在！");
            return response;
        }
        UserPO entity = this.getMapper().map(request, UserPO.class);
        entity.setRowVersion(userPO.getRowVersion());
        // 先检查关键数据是否有重复，在检查通过后才能做插入操作
        checkValidate(entity, passport, response);
        if (response.hasError()) {
            return response;
        }/*
        if(request.getIsEmployee() != null && request.getIsEmployee()){
            //校验用户输入的员工编号是否正确
            Long employeeCount = userMapper.exitAppEmployeeNumber(request.getEmployeeNumber(),passport);
            if(employeeCount ==0){
                response.addError(ErrorType.BUSINESS_ERROR, "员工编号不存在！");
                return response;
            }
        }*/
        Long result = userMapper.update(entity, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }

    /**
     * 更新用户权限
     *
     * @param request  更新用户请求
     * @param passport 用户护照
     * @return 更新用户应答
     */
    @Override
    public UserUpdateResponse updatePermission(UserUpdateRequest request, Passport passport){
        UserUpdateResponse response = new UserUpdateResponse();

        UserGetRequest getRequest = new UserGetRequest();
        getRequest.setId(request.getId());
        UserRolePO entity = userMapper.findUserRoleById(getRequest, passport);
        if(entity == null){
            response.addError(ErrorType.BUSINESS_ERROR, "用户信息不存在！");
            return response;
        }
        request.setRowVersion(entity.getRowVersion());
        Long result = userMapper.updatePermission(request, passport);
        if (result != 1) {
            response.addError(ErrorType.BUSINESS_ERROR, Message.COMMON_UPDATE_FAILURE);
            return response;
        }
        response.setResult(result);
        return response;
    }

    /**
     * 删除用户
     *
     * @param request  删除用户请求
     * @param passport 用户护照
     * @return 删除用户应答
     */
    @Override
    public UserDeleteResponse delete(UserDeleteRequest request, Passport passport) {
        UserDeleteResponse response = new UserDeleteResponse();
        Long result = userMapper.delete(request.getId(), passport);
        response.setResult(result);
        return response;
    }


    /**
     * 验证对象
     *
     * @param user     用户
     * @param passport 用户护照
     */
    private void checkValidate(UserPO user, Passport passport, BaseResponse response) {
        // TODO
    }

    /**
     * 用户列表查询
     * @param request
     * @param passport
     * @return
     */
    @Override
    public UserListResponse findUserList(UserGetInfoByAccountRequest request, Passport passport){
        UserListResponse response = new UserListResponse();
        List<User> modelList = new ArrayList<>();
        UserSearchRequest request1 = new UserSearchRequest();
        BeanUtils.copyProperties(request,request1);
        Long count = userMapper.searchUserCount(request1, passport);

        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }
            //通过关键字查询出用户集合
            List<UserListPO> entityList = userMapper.findUserList(request,passport);
            //if(request!=null && (StringUtils.isNotEmpty(request.getLaidBegin())||StringUtils.isNotEmpty(request.getLaidEen()))){
            List<String> ids = new ArrayList<>();
            for (UserListPO entity : entityList) {
                ids.add(entity.getId().toString());
            }
            request.setIds(ids);
            try {
                List<UserListPO> entityList_Escort = userMapper.findEscortInfo(request,passport);
                //积分
                List<UserListPO> entityList_Points = userMapper.findPointsInfo(request,passport);
                //事件次数
                List<UserListPO> entityList_eventCount = userMapper.findEventInfo(request,passport);
                // }
                for (UserListPO entity : entityList) {
                    User user = this.getMapper().map(entity, User.class);
                    //护航信息
                    for (UserListPO entityEscort : entityList_Escort) {
                        if(entityEscort.getId().equals(entity.getId())){
                            if(StringUtils.isNotEmpty(entityEscort.getEscortTime())){
                                user.setEscortCount(Long.valueOf(entityEscort.getEscortCount()));
                            }
                            user.setEscortTime(Long.valueOf(entityEscort.getEscortTime()));
                        }
                    }
                    //积分
                    for (UserListPO entityPoint : entityList_Points) {
                        if(entityPoint.getId().equals(entity.getId())){
                            user.setPoints(entityPoint.getPoints());
                        }
                    }
                    //事件次数
                    for (UserListPO entityEvent : entityList_eventCount) {
                        if(entityEvent.getId().equals(entity.getId())){
                            user.setEventCount(entityEvent.getEventCount());
                        }
                    }
                    modelList.add(user);
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    /**
     * 用户列表查询
     * @param request
     * @param passport
     * @return
     */
    @Override
    public FileUploadResponse exportUserList(UserGetInfoByAccountRequest request, Passport passport){
        FileUploadResponse uploadResponse = new FileUploadResponse();
        List<User> modelList = new ArrayList<>();
//        listToExport = new ArrayList<>();
//        for(int i=0;i<500;i++){
//            new MyThread(request,passport,i,userMapper).start();
//        }
//        sleep(30000);

//        UserSearchRequest request1 = new UserSearchRequest();
//        BeanUtils.copyProperties(request,request1);
        //通过关键字查询出用户集合
        //Long count = userMapper.searchUserCount(request1, passport);
        List<UserListPO> entityList = userMapper.exportUserList(request,passport);

        List<String> ids = new ArrayList<>();
        for (UserListPO entity : entityList) {
            ids.add(entity.getId().toString());
        }
        request.setIds(ids);
        List<UserListPO> entityList_Escort = userMapper.findEscortInfo(request,passport);

        for (UserListPO entity : entityList) {
            User user = this.getMapper().map(entity, User.class);
            //护航信息
            for (UserListPO entityEscort : entityList_Escort) {
                if(entityEscort.getId().equals(entity.getId())){
                    if(StringUtils.isNotEmpty(entityEscort.getEscortTime())){
                        user.setEscortCount(Long.valueOf(entityEscort.getEscortCount()));
                    }
                    user.setEscortTime(Long.valueOf(entityEscort.getEscortTime()));
                }
            }
            user.setPoliticalName(entity.getIsPartyMember()!=null&&entity.getIsPartyMember()?"党员":"群众");
            modelList.add(user);
        }
        List<UserListExport> timesheetList = JSON.parseArray(JSON.toJSONString(modelList), UserListExport.class);
        com.xiniunet.supporting.excel.core.DataTable<UserListExport> table = null;
        try {
            table = new com.xiniunet.supporting.excel.core.DataTable<>(timesheetList);
        } catch (Exception e) {
            uploadResponse.addError(ErrorType.EXPECTATION_NULL, "数据转换错误");
            return uploadResponse;
        }
        table.setMode(DataTableMode.EXPORT);
        try {
            FileUploadRequest uploadRequest = new FileUploadRequest();
            uploadRequest.setFileStream(DataTableHelper.toExcelByte(ExcelVersion.XLSX, table));
            uploadRequest.setFileExt("xlsx");
            uploadRequest.setType(UploadTypeEnum.TMP);
            uploadRequest.setFileName("员工信息" + "-" + DateUtil.formatDate("yyyyMMddHHmmss"));
            uploadRequest.setIsUploadByFileName(true);
            uploadResponse = foundationService.uploadFile(uploadRequest, passport);
        } catch (IOException e) {
            uploadResponse.addError("", "上传文件出现了小错误。");
        }
        return uploadResponse;
    }

    /**
     * 用户权限列表查询
     * @param request
     * @param passport
     * @return
     */
    @Override
    public UserRoleListResponse findUserRoleList(UserGetInfoByAccountRequest request, Passport passport){
        UserRoleListResponse response = new UserRoleListResponse();
        List<User> modelList = new ArrayList<>();
        UserSearchRequest request1 = new UserSearchRequest();
        request1.setAccount(request.getAccount());
        Long count = userMapper.findUserRoleCount(request1, passport);

        if (count > 0) {
            // 处理分页参数
            if (request.getPageSize() > 0) {
                //如果输入的页码大于实际的分页数，将页码设置为最后一页的页码
                int lastPageNumber = (int) ((count - 1) / request.getPageSize() + 1);
                if (request.getPageNumber() > lastPageNumber) {
                    request.setPageNumber(lastPageNumber);
                }
            }

            request.setRequestIndex((long)(request.getPageNumber() - 1) * 10);
            //通过关键字查询出用户集合
            List<UserRolePO> entityList = userMapper.findUserRoleList(request,passport);

            for (UserRolePO entity : entityList) {
                User user = this.getMapper().map(entity, User.class);
                modelList.add(user);
            }
        }
        response.setTotalCount(count);
        response.setResult(modelList);
        return response;
    }

    /**
     * 发送验证码，判断手机号是否注册
     * @param request
     * @return
     */
    @Override
    public RailwayUserStatusResponse getRailwayUserStatus(UserSearchRequest request){
        RailwayUserStatusResponse response = new RailwayUserStatusResponse();
        Long count = userMapper.searchUserCountPwd(request);
        if (count > 0) {
            response.setStatus(0L);
        }else {
            response.setStatus(1L);
        }
        return response;
    }

    /**
     * 个人信息-员工认证
     * @param request
     * @param passport
     * @return
     */
    @Override
    public RailwayCompanyAuthenticateResponse updateUserCompany(RailwayCompanyAuthenticateRequest request,Passport passport){
        RailwayCompanyAuthenticateResponse response = new RailwayCompanyAuthenticateResponse();
        //校验用户输入的员工编号是否正确
        Long employeeCount = userMapper.exitAppEmployeeNumber(request.getUserCode(),passport);
        if(employeeCount ==0){
            response.addError(ErrorType.BUSINESS_ERROR, "员工编号不存在！");
            response.setCode(1L);
            return response;
        }
        CompanyPO companyPO = userMapper.getCompanyInfo(request.getUserCode(),passport);
        if (companyPO == null){
            response.addError(ErrorType.BUSINESS_ERROR, "员工编号不存在！");
            response.setCode(1L);
            return response;
        }
        UserPO userPO = userMapper.getById(request.getUserId(),passport);
        if(userPO == null){
            response.addError(ErrorType.BUSINESS_ERROR, "用户信息不存在！");
            return response;
        }
        UserPO entity = new UserPO();
        entity.setId(request.getUserId());
        entity.setCompanyId(companyPO.getId());
        entity.setIsEmployee(true);
        entity.setEmployeeNumber(request.getUserCode());
        entity.setAge(userPO.getAge());
        entity.setRowVersion(userPO.getRowVersion());
        long count = userMapper.update(entity,passport);
        if(count != 1){
            response.addError(ErrorType.BUSINESS_ERROR, "更新用户信息失败");
            response.setCode(1L);
            TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
            return response;
        }
        response.setCode(0L);
        return response;
    }

    /**
     * 当前用户的权限信息
     * @param request
     * @param passport
     * @return
     */
    @Override
    public UserGetResponse findUserAndPermission(UserGetRequest request, Passport passport) {
        UserGetResponse response = new UserGetResponse();
        UserRolePO entity = userMapper.findUserRoleById(request, passport);
        if (entity != null) {
            User user = this.getMapper().map(entity, User.class);
            if(user.getEscortCount() == null){
                user.setEscortCount(0L);
            }
            if(user.getEscortTime() == null){
                user.setEscortTime(0L);
            }
            response.setUser(user);
        } else {
            response.addError(ErrorType.EXPECTATION_NULL, Message.COMMON_GET_FAILURE);
        }
        return response;
    }

    /**
     * 批量导入用户权限
     * @param request 批量导入用户权限请求
     * @param passport 用户护照
     * @return 批量导入用户权限应答
     */
    @Override
    public UserPermissionImportResponse importUserPermission(RecommendPermissionListRequest request,Passport passport) {
        UserPermissionImportResponse response = new UserPermissionImportResponse();

        //导入内容
        DataTable<PermissionUpdateImport> table = request.getDataTable();
        List<PermissionUpdateImport> beanList = request.getList();
        List<String> accountList = ListUtil.getKeyList(beanList,"account");
        List<String> nameList = ListUtil.getKeyList(beanList,"name");

        //用户集合
        List<UserPO> userList = userMapper.getByAccountList(accountList,passport);

        // 权限集合
        PermissionFindRequest permissionFindRequest = new PermissionFindRequest();
        permissionFindRequest.setNameList(nameList);
        List<Permission> permissionList = railwayService.findPermissionByNameList(permissionFindRequest, passport).getResult();

        // 更新数据集合
        List<UserPO> updateList = new ArrayList<>();

        Map<String,String> userMap = new HashMap<>();//导入内容用户map，用以判断是否重复存在了

        //检查表格
        int index = 0;
        for (PermissionUpdateImport bean : beanList) {
            //检查用户手机号是否重复
            if (userMap.containsKey(bean.getAccount())) {
                table.setStatus(index, "用户手机号", Status.REPEAT);
            } else {
                String account = bean.getAccount();
                String name = bean.getName();
                userMap.put(account,account);

                //判断用户手机号是否正确
                UserPO user = ListUtil.matchObject(userList,"account",account);
                Permission permission = ListUtil.matchObject(permissionList,"name",name);
                if (user == null){
                    table.setStatus(index, "用户手机号", Status.NOTEXIST);
                } else if (permission == null) {
                    table.setStatus(index, "权限名称", Status.NOTEXIST);
                } else{
                    UserPO updateEntity = user;
                    updateEntity.setId(user.getId());
                    updateEntity.setPermissionId(permission.getId());
                    updateEntity.setRowVersion(user.getRowVersion());
                    updateList.add(updateEntity);
                }
            }
            index ++;
        }

        if (table.getErrorList().size() == 0) {
            //更新用户权限数据
            if (updateList.size() > 0){
                long result = userMapper.updateBatch(updateList,passport);
                if (result != updateList.size()){
                    response.addError(ErrorType.BUSINESS_ERROR,"用户权限批量更新失败");
                    TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();
                    return response;
                }
            }

        } else {
            response.addErrors(table.getErrorList());
            try {
                FileUploadRequest uploadRequest = new FileUploadRequest();
                Excel excel = new Excel(true, table);
                uploadRequest.setFileStream(excel.getBytes());
                uploadRequest.setFileExt("xlsx");
                uploadRequest.setType(UploadTypeEnum.TMP);
                String fileName = new SimpleDateFormat("yyyyMMdd").format(new Date());
                uploadRequest.setFileName("用户权限导入错误文件" + fileName);
                uploadRequest.setIsUploadByFileName(Boolean.TRUE);

                 String url = foundationService.uploadFile(uploadRequest, passport).getUrl();
                response.setUrl(url);
            } catch (IOException e) {
                LogUtil.errorLog(e);
                response.addError(ErrorType.BUSINESS_ERROR, "文件上传出现错误。");
            }
            return response;
        }
        return response;
    }
}

//class MyThread extends Thread {
//
//    private UserMapper userMapper;
//
//    private UserGetInfoByAccountRequest request;
//    private Passport passport;
//    private int i;
//    public MyThread(UserGetInfoByAccountRequest request, Passport passport,int i,UserMapper userMapper) {
//        this.request = request;
//        this.passport = passport;
//        this.i = i;
//        this.userMapper = userMapper;
//    }
//    @Override
//    public void run() {
//        request.setPageNumber((i+1)*200);
//        request.setPageSize(i*200);
//        //通过关键字查询出用户集合
//        List<UserListPO> entityList = userMapper.exportUserList(request,passport);
//        if(entityList.size()>0){
//            List<String> ids = new ArrayList<>();
//            for (UserListPO entity : entityList) {
//                ids.add(entity.getId().toString());
//            }
//            request.setIds(ids);
//            List<UserListPO> entityList_Escort = userMapper.findEscortInfo(request,passport);
//            for (UserListPO entity : entityList) {
//                User user = new User();
//                BeanUtils.copyProperties(entity,user);
//                //护航信息
//                for (UserListPO entityEscort : entityList_Escort) {
//                    if(entityEscort.getId().equals(entity.getId())){
//                        if(StringUtils.isNotEmpty(entityEscort.getEscortTime())){
//                            user.setEscortCount(Long.valueOf(entityEscort.getEscortCount()));
//                        }
//                        user.setEscortTime(Long.valueOf(entityEscort.getEscortTime()));
//                    }
//                }
//                user.setPoliticalName(entity.getIsPartyMember()!=null&&entity.getIsPartyMember()?"党员":"群众");
//                UserManagerImpl.listToExport.add(user);
//            }
//        }
//
//    }
//}