package com.huimv.cattle.service.impl;

import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.huimv.cattle.mapper.SysFarmMapper;
import com.huimv.cattle.mapper.SysFarmServiceMapper;
import com.huimv.cattle.mapper.SysUserAccountMapper;
import com.huimv.cattle.pojo.SysFarm;
import com.huimv.cattle.pojo.SysFarmService;
import com.huimv.cattle.pojo.SysUserAccount;
import com.huimv.cattle.service.SysUserAccountService;
import com.huimv.cattle.session.AccessToken;
import com.huimv.cattle.token.TokenSign;
import com.huimv.cattle.utils.ConstUtil;
import com.huimv.cattle.utils.DateUtil;
import com.huimv.cattle.utils.ResultUtil;
import com.huimv.common.utils.Result;
import com.huimv.common.utils.ResultCode;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Value;
//import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.text.ParseException;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author zn
 * @since 2022-09-26
 */
@Service
public class SysUserAccountServiceImpl extends ServiceImpl<SysUserAccountMapper, SysUserAccount> implements SysUserAccountService {
    @Resource
    private SysUserAccountMapper sysUserAccountMapper;

    @Resource
    private SysFarmServiceMapper farmServiceMapper;
    @Resource
    private SysFarmMapper farmMapper;
//    @Resource
//    private RedisTemplate redisTemplate;
    @Resource
    private ResultUtil resultUtil;
    @Value("${user.defaultPassword}")
    private String defaultPassword;

    @Override
    public Result login(HttpServletRequest request, Map<String, String> paramsMap) {
        String accountName = paramsMap.get("accountName");
        String password = paramsMap.get("password");
        String remoteHost = request.getRemoteHost();

        QueryWrapper<SysUserAccount> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("account_name", accountName).eq("password", password);
        SysUserAccount resultSysUserAccount = sysUserAccountMapper.selectOne(queryWrapper);
        System.out.println("sysUserAccount=" + resultSysUserAccount);
        if (resultSysUserAccount == null) {
            //账号、密码错误
            return new Result(ConstUtil.ERR_NO_EXIST_CODE, ConstUtil.ERR_NO_EXIST_INFO, false);
        }
        if (resultSysUserAccount.getLoginStatus() == 0) {
            //牧场状态不能为中止服务状态(0)
            return new Result(ConstUtil.ERR_FARM_TIMEOUT_CODE, ConstUtil.ERR_FARM_TIMEOUT_INFO, false);
        } else if (resultSysUserAccount.getLoginStatus() == 2) {
            //牧场状态不能为注销状态(2)
            return new Result(ConstUtil.ERR_FARM_CANCEL_CODE, ConstUtil.ERR_FARM_CANCEL_INFO, false);
        }

        //判断服务状态
        Integer accountClass = resultSysUserAccount.getAccountClass();
        if (accountClass == 2) {
            Date now = new Date();
            List<SysFarmService> farmServices = farmServiceMapper.selectList(new QueryWrapper<SysFarmService>().eq("farm_code", resultSysUserAccount.getFarmCode()).ge("end_date", now).le("start_date", now));
            if (ObjectUtil.isEmpty(farmServices)) {
                return new Result(ConstUtil.ERR_FARM_OVERDUE_CODE, ConstUtil.ERR_FARM_OVERDUE_INFO, false);
            }
        }

        //--更新当前登录状态 --//
        resultSysUserAccount.setLoginTime(new Date());
        sysUserAccountMapper.updateById(resultSysUserAccount);

        //将当前账号加入到set集合当中(退出时从该集合删除该账号信息)
//        _createLoginStatus(accountName);

        //-- 构造token --//
        AccessToken accessToken = new AccessToken();
        Long id = resultSysUserAccount.getId();
        String farmCode = resultSysUserAccount.getFarmCode();
        accessToken.setAccountName(accountName);
        accessToken.setCreated(new Date());
        accessToken.setCode(null);
        accessToken.setMessage("");
        accessToken.setFarmId(farmCode);
        System.out.println("login.farmCode >>>>>>>>>>>>>>>>>>> " + farmCode);
        //构造token
        String token = TokenSign.sign(accountName, id, farmCode, "");
        accessToken.setToken(token);
        accessToken.setId(id.intValue());
        accessToken.setLoginIp(remoteHost);
        accessToken.setUserName(resultSysUserAccount.getUserName());
        accessToken.setType(null);
        accessToken.setAccontClass(resultSysUserAccount.getAccountClass());
        return new Result(ResultCode.SUCCESS, accessToken);
    }

//    private void _createLoginStatus(String accountName) {
//        //-- 将有令牌的登录账户加入缓存集合 --//
//        String key = "TOKEN:ACCOUNT:SET";
////        redisTemplate.opsForValue().set(key, accountName);
//        redisTemplate.opsForSet().add(key, accountName);
//        System.out.println("_createLoginStatus");
//    }

    @Override
    public Result logout(HttpServletRequest request, Map<String, String> paramsMap) {
//        String accountName = paramsMap.get("accountName");
//        String accountName = request.getHeader("accountName");
//        String accountName2 = request.getQueryString();
        //--将有令牌的登录账户从缓存集合中删除--//
//        String key = "TOKEN:ACCOUNT:SET";
//        redisTemplate.opsForSet().remove(key, accountName);
//        return new Result(ResultCode.SUCCESS);
        return null;
    }

    /**
     * @Method : newUserAccount
     * @Description : 创建用户账号
     * @Params : [paramsMap]
     * @Return : com.huimv.common.utils.Result
     * @Author : ZhuoNing
     * @Date : 2022/10/9
     * @Time : 18:03
     */
    @Override
    public Result newUserAccount(HttpServletRequest request, Map<String, String> paramsMap) {
        //登录状态
        String loginStatus = paramsMap.get("loginStatus");
        if (StringUtils.isBlank(loginStatus)) {
            loginStatus = "1";
        }
        String accountType = paramsMap.get("accountType");
        String farmCode ="";
        if ("1".equals(accountType)){
            farmCode = paramsMap.get("farmCode");
        }else {
             farmCode = TokenSign.getFarmCode(request);
        }

//        if ("1".equals(accountClass)){
//            farmCode = "0";
//        }

        if (farmCode == "" ||StringUtils.isBlank(farmCode)){
            farmCode = "0";
        }
        System.out.println(farmCode);
        //查询判断是否有重名存在
        QueryWrapper<SysUserAccount> queryWrapperUserAccount = new QueryWrapper<>();
        queryWrapperUserAccount.eq("account_name", paramsMap.get("accountName"));
        Long userCount = sysUserAccountMapper.selectCount(queryWrapperUserAccount);
        if (userCount > 0) {
            return new Result(ConstUtil.ERR_ACCOUNT_SAME_CODE, ConstUtil.ERR_ACCOUNT_SAME_INFO, false);
        }
        SysUserAccount userAccount = new SysUserAccount();
        userAccount.setUserName(paramsMap.get("userName"));
        userAccount.setMale(Integer.parseInt(paramsMap.get("male")));
        userAccount.setJob(paramsMap.get("job"));
        userAccount.setMobile(paramsMap.get("mobile"));
        userAccount.setAccountClass(Integer.parseInt(paramsMap.get("accountClass")));
        userAccount.setAccountType(Integer.parseInt(paramsMap.get("accountType")));
        userAccount.setAccountName(paramsMap.get("accountName"));
        userAccount.setPassword(paramsMap.get("password"));
//        userAccount.setLoginTime(new java.sql.Date(new Date().getTime()));
        userAccount.setFarmCode(farmCode);
        userAccount.setLoginStatus(Integer.parseInt(loginStatus));
        return resultUtil.getResult(sysUserAccountMapper.insert(userAccount));
    }

    /**
     * @Method : editUserAccount
     * @Description : 编辑用户账号
     * @Params : [paramsMap]
     * @Return : com.huimv.common.utils.Result
     * @Author : ZhuoNing
     * @Date : 2022/10/9
     * @Time : 18:03
     */
    @Override
    public Result editUserAccount(Map<String, String> paramsMap) {
        //登录状态
        String loginStatus = paramsMap.get("loginStatus");
        if (StringUtils.isBlank(loginStatus)) {
            loginStatus = "1";
        }
        //
        String farmCode = paramsMap.get("farmCode");
        if (StringUtils.isBlank(farmCode)||farmCode == "") {
            farmCode = "0";
        }
        String id = paramsMap.get("id");
        SysUserAccount sysUserAccount = sysUserAccountMapper.selectById(id);
        Date loginTime = sysUserAccount.getLoginTime();
        SysUserAccount userAccount = new SysUserAccount();
        userAccount.setId(Long.parseLong(id));
        userAccount.setUserName(paramsMap.get("userName"));
        userAccount.setMale(Integer.parseInt(paramsMap.get("male")));
        userAccount.setJob(paramsMap.get("job"));
        userAccount.setMobile(paramsMap.get("mobile"));
        userAccount.setAccountClass(Integer.parseInt(paramsMap.get("accountClass")));
        userAccount.setAccountType(Integer.parseInt(paramsMap.get("accountType")));
        userAccount.setAccountName(paramsMap.get("accountName"));
        userAccount.setPassword(paramsMap.get("password"));
        userAccount.setLoginTime(loginTime);
        userAccount.setLoginStatus(Integer.parseInt(loginStatus));
        userAccount.setFarmCode(farmCode);
        return resultUtil.getResult(sysUserAccountMapper.updateById(userAccount));
    }

    /**
     * @Method : removeUserAccount
     * @Description : 批量删除用户账户信息
     * @Params : [paramsMap]
     * @Return : com.huimv.common.utils.Result
     * @Author : ZhuoNing
     * @Date : 2022/10/9
     * @Time : 17:45
     */
    @Override
    public Result removeUserAccount(Map<String, String> paramsMap) {
        String ids = paramsMap.get("ids");
        String[] idArray = ids.split(",");
        List<String> idList = Arrays.asList(idArray);

        QueryWrapper<SysUserAccount> queryWrapper = new QueryWrapper<>();
        for (String id : idArray) {
            queryWrapper.eq("id", id);
            SysUserAccount userAccount = sysUserAccountMapper.selectOne(queryWrapper);
            if (userAccount.getAccountClass() == 1 && userAccount.getAccountType() == 1) {
                return new Result(ConstUtil.ERR_NO_DELETE_ADMIN_CODE, ConstUtil.ERR_NO_DELETE_ADMIN_INFO, false);
            } else {
                sysUserAccountMapper.deleteById(userAccount);
            }
        }
        return new Result(ResultCode.SUCCESS);
//        return resultUtil.getResult(sysUserAccountMapper.deleteBatchIds(idList));
    }

    /**
     * @Method : listUserAccount
     * @Description : 列表展示用户账户
     * @Params : [paramsMap]
     * @Return : com.huimv.common.utils.Result
     * @Author : ZhuoNing
     * @Date : 2022/10/9
     * @Time : 18:02
     */
    @Override
    public Result listUserAccount(HttpServletRequest request, Map<String, String> paramsMap) throws ParseException {
        //
        Integer userId = TokenSign.getMemberIdByJwtToken(request);
        DateUtil dateUtil = new DateUtil();
        String pageNo = paramsMap.get("pageNo") + "";
        if (pageNo == null) {
            pageNo = "1";
        }
        String pageSize = paramsMap.get("pageSize") + "";
        if (pageSize == null) {
            pageSize = "10";
        }
        String farmCode = request.getHeader("farmCode");
        String accountName = paramsMap.get("accountName");
        String userName = paramsMap.get("userName");
        String accountClass = paramsMap.get("accountClass");
        QueryWrapper<SysUserAccount> queryWrapper = new QueryWrapper<>();
        queryWrapper.ne("id",userId);
        queryWrapper.eq(StringUtils.isNotBlank(farmCode), "farm_code", farmCode);
        queryWrapper.like(StringUtils.isNotBlank(accountName), "account_name", accountName);
        queryWrapper.like(StringUtils.isNotBlank(userName), "user_name", userName);
//        queryWrapper.eq(StringUtils.isNotBlank(accountClass),"account_class",accountClass);
//        queryWrapper.and(wrapper ->wrapper.eq("account_class", 1).or().eq("account_type",1));
        queryWrapper.and(wrapper -> wrapper.eq("account_type", 1).or().eq("account_type", 2));
        queryWrapper.orderByDesc("login_time");
        //
        Page<SysUserAccount> page = new Page<>(Integer.parseInt(pageNo), Integer.parseInt(pageSize));
        Page<SysUserAccount> pageSysUserAccount = sysUserAccountMapper.selectPage(page, queryWrapper);
        List<SysUserAccount> sysUserAccountList = pageSysUserAccount.getRecords();
        JSONArray dataJa = new JSONArray();
        for (SysUserAccount sysUserAccount : sysUserAccountList) {
            String farmCode1 = sysUserAccount.getFarmCode();
            SysFarm sysFarm = farmMapper.selectOne(new QueryWrapper<SysFarm>().eq("farm_code", farmCode1));
            JSONObject dataJo = (JSONObject) JSONObject.toJSON(sysUserAccount);
            dataJo.put("loginTime", dateUtil.formatDatetimeText(dataJo.getDate("loginTime")));
            dataJo.put("farmName", "");
            if (ObjectUtil.isNotEmpty(sysFarm)) {
                dataJo.put("farmName", sysFarm.getFarmName());
            }
            dataJa.add(dataJo);
        }
        JSONObject resultJo = new JSONObject();
        resultJo.put("records", dataJa);
        resultJo.put("total", pageSysUserAccount.getTotal());
        resultJo.put("size", pageSysUserAccount.getSize());
        resultJo.put("current", pageSysUserAccount.getCurrent());
        resultJo.put("orders", pageSysUserAccount.orders());
        resultJo.put("optimizeCountSql", pageSysUserAccount.optimizeCountSql());
        resultJo.put("searchCount", pageSysUserAccount.searchCount());
        resultJo.put("countId", pageSysUserAccount.countId());
        resultJo.put("maxLimit", pageSysUserAccount.maxLimit());
        resultJo.put("pages", pageSysUserAccount.getPages());
        return new Result(ResultCode.SUCCESS, resultJo);
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result resetPassword(Map<String, String> paramsMap) {
        String ids = paramsMap.get("ids");
        String[] idArray = ids.split(",");
        int rows = 0;
        for (String id : idArray) {
            SysUserAccount SysUserAccount = new SysUserAccount();
            SysUserAccount.setId(Long.parseLong(id));
            SysUserAccount.setPassword(defaultPassword);
            rows += sysUserAccountMapper.updateById(SysUserAccount);
        }
        return resultUtil.getResult(rows);
    }

    @Override
    public Result loginApp(HttpServletRequest request, Map<String, String> paramsMap) {
        String accountName = paramsMap.get("accountName");
        String password = paramsMap.get("password");
        String remoteHost = request.getRemoteHost();

        QueryWrapper<SysUserAccount> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("account_name", accountName).eq("password", password).eq("account_class", 2);
        SysUserAccount resultSysUserAccount = sysUserAccountMapper.selectOne(queryWrapper);
        System.out.println("sysUserAccount=" + resultSysUserAccount);
        if (resultSysUserAccount == null) {
            //账号、密码错误
            return new Result(ConstUtil.ERR_NO_EXIST_CODE, ConstUtil.ERR_NO_EXIST_INFO, false);
        }
        if (resultSysUserAccount.getLoginStatus() == 0) {
            //牧场状态不能为中止服务状态(0)
            return new Result(ConstUtil.ERR_FARM_TIMEOUT_CODE, ConstUtil.ERR_FARM_TIMEOUT_INFO, false);
        } else if (resultSysUserAccount.getLoginStatus() == 2) {
            //牧场状态不能为注销状态(2)
            return new Result(ConstUtil.ERR_FARM_CANCEL_CODE, ConstUtil.ERR_FARM_CANCEL_INFO, false);
        }

        //判断服务状态
        Integer accountClass = resultSysUserAccount.getAccountClass();
        if (accountClass == 2) {
            Date now = new Date();
            List<SysFarmService> farmServices = farmServiceMapper.selectList(new QueryWrapper<SysFarmService>().eq("farm_code", resultSysUserAccount.getFarmCode()).ge("end_date", now).le("start_date", now));

            if (ObjectUtil.isEmpty(farmServices)) {
                return new Result(100012, "该牧场未在服务有效期", false);
            }

        }


        //--更新当前登录状态 --//
        resultSysUserAccount.setLoginTime(new Date());
        sysUserAccountMapper.updateById(resultSysUserAccount);

        //将当前账号加入到set集合当中(退出时从该集合删除该账号信息)
//        _createLoginStatus(accountName);

        //-- 构造token --//
        AccessToken accessToken = new AccessToken();
        Long id = resultSysUserAccount.getId();
        String farmCode = resultSysUserAccount.getFarmCode();
        accessToken.setAccountName(accountName);
        accessToken.setCreated(new Date());
        accessToken.setCode(null);
        accessToken.setMessage("");
        accessToken.setFarmId(farmCode);
        System.out.println("login.farmCode >>>>>>>>>>>>>>>>>>> " + farmCode);
        //构造token
        String token = TokenSign.sign(accountName, id, farmCode, "");
        accessToken.setToken(token);
        accessToken.setId(id.intValue());
        accessToken.setLoginIp(remoteHost);
        accessToken.setUserName(resultSysUserAccount.getUserName());
        accessToken.setType(null);
        accessToken.setAccontClass(resultSysUserAccount.getAccountClass());
        return new Result(ResultCode.SUCCESS, accessToken);
    }

    @Override
    public Result listPlatformUserAndFarmAdmin(HttpServletRequest request, Map<String, String> paramsMap) throws ParseException {
        //
        DateUtil dateUtil = new DateUtil();
        String pageNo = paramsMap.get("pageNo") + "";
        if (StringUtils.isBlank(pageNo)) {
            pageNo = "1";
        }
        String pageSize = paramsMap.get("pageSize") + "";
        if (StringUtils.isBlank(pageSize)) {
            pageSize = "10";
        }
        String accountName = paramsMap.get("accountName");
        String userName = paramsMap.get("userName");
        QueryWrapper<SysUserAccount> queryWrapper = new QueryWrapper<>();
        queryWrapper.like(StringUtils.isNotBlank(accountName), "account_name", accountName);
        queryWrapper.like(StringUtils.isNotBlank(userName), "user_name", userName);
        queryWrapper.and(wrapper -> wrapper.eq("account_class", 1).or().eq("account_type", 1));
        queryWrapper.orderByDesc("login_time");
        //
        Page<SysUserAccount> page = new Page<>(Integer.parseInt(pageNo), Integer.parseInt(pageSize));
        Page<SysUserAccount> pageSysUserAccount = sysUserAccountMapper.selectPage(page, queryWrapper);
        List<SysUserAccount> sysUserAccountList = pageSysUserAccount.getRecords();
        JSONArray dataJa = new JSONArray();
        for (SysUserAccount sysUserAccount : sysUserAccountList) {
            String farmCode1 = sysUserAccount.getFarmCode();
            SysFarm sysFarm = farmMapper.selectOne(new QueryWrapper<SysFarm>().eq("farm_code", farmCode1));
            JSONObject dataJo = (JSONObject) JSONObject.toJSON(sysUserAccount);
            dataJo.put("loginTime", dateUtil.formatDatetimeText(dataJo.getDate("loginTime")));
            dataJo.put("farmName", "");
            if (ObjectUtil.isNotEmpty(sysFarm)) {
                dataJo.put("farmName", sysFarm.getFarmName());
            }
            dataJa.add(dataJo);
        }
        JSONObject resultJo = new JSONObject();
        resultJo.put("records", dataJa);
        resultJo.put("total", pageSysUserAccount.getTotal());
        resultJo.put("size", pageSysUserAccount.getSize());
        resultJo.put("current", pageSysUserAccount.getCurrent());
        resultJo.put("orders", pageSysUserAccount.orders());
        resultJo.put("optimizeCountSql", pageSysUserAccount.optimizeCountSql());
        resultJo.put("searchCount", pageSysUserAccount.searchCount());
        resultJo.put("countId", pageSysUserAccount.countId());
        resultJo.put("maxLimit", pageSysUserAccount.maxLimit());
        resultJo.put("pages", pageSysUserAccount.getPages());
        return new Result(ResultCode.SUCCESS, resultJo);
    }

    @Override
    public Result resetMyPassword(HttpServletRequest request, Map<String, String> paramsMap) {
        String accountName = request.getHeader("accountName");
        String oldPassword = paramsMap.get("oldPassword");
        String password = paramsMap.get("password");
        QueryWrapper<SysUserAccount> queryWrapper = new QueryWrapper();
        queryWrapper.eq("account_name", accountName);
        queryWrapper.eq("password", oldPassword);
        SysUserAccount sysUserAccount = sysUserAccountMapper.selectOne(queryWrapper);
        if (sysUserAccount == null) {
            return new Result(ConstUtil.ERR_PASSWORD_ERROR_CODE, ConstUtil.ERR_PASSWORD_ERROR_INFO, false);
        }
        sysUserAccount.setPassword(password);
        int rows = sysUserAccountMapper.updateById(sysUserAccount);
        if (rows == 0) {
            return new Result(ConstUtil.ERR_UPDATE_PASSWORD_CODE, ConstUtil.ERR_UPDATE_PASSWORD_INFO,false);
        } else {
            return new Result(ResultCode.SUCCESS);
        }
    }

    @Override
    public Result loginScreen(HttpServletRequest request, Map<String, String> paramsMap) {
        String accountName = paramsMap.get("accountName");
        String password = paramsMap.get("password");
        String remoteHost = request.getRemoteHost();

        QueryWrapper<SysUserAccount> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("account_name", accountName).eq("password", password).eq("account_class",1);
        SysUserAccount resultSysUserAccount = sysUserAccountMapper.selectOne(queryWrapper);
        System.out.println("sysUserAccount=" + resultSysUserAccount);
        if (resultSysUserAccount == null) {
            //账号、密码错误
            return new Result(ConstUtil.ERR_NO_EXIST_CODE, ConstUtil.ERR_NO_EXIST_INFO, false);
        }
        if (resultSysUserAccount.getLoginStatus() == 0) {
            //牧场状态不能为中止服务状态(0)
            return new Result(ConstUtil.ERR_FARM_TIMEOUT_CODE, ConstUtil.ERR_FARM_TIMEOUT_INFO, false);
        } else if (resultSysUserAccount.getLoginStatus() == 2) {
            //牧场状态不能为注销状态(2)
            return new Result(ConstUtil.ERR_FARM_CANCEL_CODE, ConstUtil.ERR_FARM_CANCEL_INFO, false);
        }

        //判断服务状态
        Integer accountClass = resultSysUserAccount.getAccountClass();
        if (accountClass == 2) {
            Date now = new Date();
            List<SysFarmService> farmServices = farmServiceMapper.selectList(new QueryWrapper<SysFarmService>().eq("farm_code", resultSysUserAccount.getFarmCode()).ge("end_date", now).le("start_date", now));
            if (ObjectUtil.isEmpty(farmServices)) {
                return new Result(ConstUtil.ERR_FARM_OVERDUE_CODE, ConstUtil.ERR_FARM_OVERDUE_INFO, false);
            }
        }

        //--更新当前登录状态 --//
        resultSysUserAccount.setLoginTime(new Date());
        sysUserAccountMapper.updateById(resultSysUserAccount);

        //将当前账号加入到set集合当中(退出时从该集合删除该账号信息)
//        _createLoginStatus(accountName);

        //-- 构造token --//
        AccessToken accessToken = new AccessToken();
        Long id = resultSysUserAccount.getId();
        String farmCode = resultSysUserAccount.getFarmCode();
        accessToken.setAccountName(accountName);
        accessToken.setCreated(new Date());
        accessToken.setCode(null);
        accessToken.setMessage("");
        accessToken.setFarmId(farmCode);
        System.out.println("login.farmCode >>>>>>>>>>>>>>>>>>> " + farmCode);
        //构造token
        String token = TokenSign.sign(accountName, id, farmCode, "");
        accessToken.setToken(token);
        accessToken.setId(id.intValue());
        accessToken.setLoginIp(remoteHost);
        accessToken.setUserName(resultSysUserAccount.getUserName());
        accessToken.setType(null);
        accessToken.setAccontClass(resultSysUserAccount.getAccountClass());
        return new Result(ResultCode.SUCCESS, accessToken);

    }

}