ZYZ/web-server/app/service/Auth.ts

import { COUNTER, HERO_SYSTEM_TYPE, DEFAULT_LV, DEFAULT_ITEMS, ITID, DEFAULT_GOLD, DEFAULT_HERO_LV, DEFAULT_EQUIPS, DEFAULT_COIN } from '@consts';
import { DEFAULT_HEROES } from '@consts';
import { HeroModel } from '@db/Hero';
import { RoleModel } from '@db/Role';
import { UserModel } from '@db/User';
import { STATUS } from '@consts';
import { smsModel } from '@db/Sms';
import { Service } from 'egg';
import Counter from '@db/Counter';
import { getHeroInfoById } from 'app/pubUtils/gamedata';
import { calPlayerCeAndSave, reCalAllHeroCe } from 'app/pubUtils/playerCe';
import { getExpByLv, getHeroExpByLv, gameData } from 'app/pubUtils/data';
import { isString } from 'underscore';

/**
 * Test Service
 */
export default class Auth extends Service {

  public checkTelNo(telNo) {
    if (!isString(telNo)) {
      return { status: 1, data: '参数类型错误' };
    }
    if (telNo.length !== 11) {
      return { status: 1, data: '手机号长度错误' };
    }
    return { status: 0, data: '手机号合法' };
  }

  async sendSmsCodeByGuodu(tel, code) {
    const ctx = this.ctx;
    const url = `http://221.179.172.68:8000/QxtSms/QxtFirewall?OperID=bantu3&OperPass=c8XcTffG&DesMobile=${tel}&Content=${encodeURIComponent(`【同人游戏】验证码${code}，您正在登录赵云传，若非本人操作，请勿泄露`)}&Content_Code=1`;
    const result = await ctx.curl(url, {
      method: 'GET',
    });
    return result.data;
  }

  testLimit(sms, interval) {
    if (sms.updateTime.getTime() > Date.now() - interval) {
      return true;
    }
    return false;
  }

  /**
   * 用户获取手机验证码
   * @param telNo - 用户手机号
   */

  public async getSms(tel: string) {

    const telVerify = this.checkTelNo(tel);
    if (telVerify.status !== 0) {
      return telVerify;
    }
    const sms = await smsModel.findByTel(tel, false);
    if (sms) {
      if (await sms.timeLimit(10000)) {
        return this.ctx.service.utils.resResult(STATUS.SMS_IN_60S);
      }
      if (await sms.cntLimit(8)) {
        return this.ctx.service.utils.resResult(STATUS.SMS_CNT_LIMIT);
      }
    }

    let code = '';
    if (sms && (!sms.used || sms.isFixed)) {
      code = sms.code;
    } else {
      code = this.ctx.service.utils.generateNum(6);
    }

    const smsResult = await this.sendSmsCodeByGuodu(tel, code);
    console.log(smsResult);
    await smsModel.updateByTel(tel, code, false, new Date(), sms?.hasSendToday() ? sms.countToday + 1 : 1);
    return this.ctx.service.utils.resResult(STATUS.SUCCESS);
  }

  /**
   * 用户获取到手机验证码之后发送验证登录请求
   * @param tel 登录手机号
   * @param code 登录验证码
   * @param platform 平台
   * @param pkgName 包名
   * @param serverType 服务器类型
   */
  public async smsLogin(tel: string, code: string, platform: string, pkgName: string, serverType: string) {
    const ctx = this.ctx;
    // 参数检查
    const telVerify = this.checkTelNo(tel);
    if (telVerify.status !== 0) {
      return telVerify;
    }

    // ! 测试阶段允许客户端不传验证码，此时不做验证码验证，直接注册或登录账号
    // TODO 上线前改掉或仅保留在测试服
    if (code !== '') {
      if (!isString(code) || code.length !== 6) {
        return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
      }

      // 手机验证码核验
      const smsValid: boolean = await smsModel.validateSms(tel, code);
      if (!smsValid) {
        const sms = await smsModel.findByTel(tel);
        if(sms && sms.isFixed) { // 固定手机号登录
          if (sms.code !== code) {
            return ctx.service.utils.resResult(STATUS.SMS_INVALID);
          }
        } else {
          return ctx.service.utils.resResult(STATUS.SMS_INVALID);
        }
      }
    }

    // 用户注册登录
    const token = ctx.service.utils.generateStr(256);
    const user = await UserModel.updateToken(tel, token, platform, pkgName, serverType);
    return ctx.service.utils.resResult(STATUS.SUCCESS, { token, userCode: user?.userCode });
  }

  public async checkRole(serverId: number) {
    const ctx = this.ctx;
    const { uid } = ctx;
    const role = await RoleModel.findByUid(uid, serverId);
    if (role) {
      return ctx.service.utils.resResult(STATUS.SUCCESS, { roleId: role.roleId });
    }
    return ctx.service.utils.resResult(STATUS.ROLE_NOT_FOUND);
  }

  public async createRole(serverId: number, roleName: string) {
    console.log('enter Auth createRole');
    const ctx = this.ctx;
    const { uid } = ctx;
    const roleId = ctx.service.utils.genCode(10);
    const code = ctx.service.utils.genCode(6);
    const seqId = await Counter.getNewCounter(COUNTER.ROLE) || -1;
    const role = await RoleModel.createRole(uid, serverId, { roleId, code, roleName, seqId, lv: DEFAULT_LV, exp: (getExpByLv(DEFAULT_LV - 1)||{sum:0}).sum||0 });
    if (role) {
      let skinIds = new Array<number>();
      for (let hid of DEFAULT_HEROES) {
        let hero = await HeroModel.findByHidAndRole(hid, roleId);
        if(hero) {
            continue;
        }

        let dicHero = getHeroInfoById(hid);
        if(!dicHero) {
            break;
        }
        let {quality, initialStars: star, jobid: job, name: hName, initialSkin} = dicHero;

        hero = await HeroModel.createHero({
          roleId, roleName: role.roleName, hid, hName, star, quality, job, serverId: role.serverId,
          skins:[{id: initialSkin, enable: true}], lv: DEFAULT_HERO_LV, exp: getHeroExpByLv(DEFAULT_HERO_LV - 1)||0
        });
        skinIds.push(initialSkin);
        await calPlayerCeAndSave(HERO_SYSTEM_TYPE.INIT, roleId, hero, {}, role);

      }
      await reCalAllHeroCe(HERO_SYSTEM_TYPE.ADD_SKIN, roleId, {}, skinIds)

      for(let {id, count} of DEFAULT_ITEMS) {
        let dicGoods = gameData.goods.get(id);
        if(!dicGoods)  continue;
        let itidObj = ITID.get(dicGoods.itid);
        if(!itidObj) continue;
        await ctx.service.utils.addBags(roleId, role.roleName, {id, itemName: dicGoods.name, count, type: itidObj.type, hid: 0});
      }

      for(let {id, count} of DEFAULT_EQUIPS) {
        for(let j = 0; j < count; j++) {
          let dicGoods = gameData.goods.get(id);
          if(!dicGoods)  continue;

          await ctx.service.utils.addEquips(roleId, role.roleName, {id, ...dicGoods, hid: 0});
        }
      }
      await RoleModel.addGoldFree(roleId, DEFAULT_GOLD);
      await RoleModel.addCoin(roleId, DEFAULT_COIN);

      return ctx.service.utils.resResult(STATUS.SUCCESS, { roleId: role.roleId });
    }
    return ctx.service.utils.resResult(STATUS.ROLE_NOT_FOUND);
  }
}