xinyuxi/ZYZ
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

添加数据库类型别名

Browse Source
This commit is contained in:
luying
2020-12-15 18:08:29 +08:00
parent 1565dd206a
commit 2d774fc0e4
38 changed files with 393 additions and 321 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
game-server/app/services/playerCeService.ts
View File

@@ -9,7 +9,7 @@ import { STATUS } from '../consts/statusCode';
import { resResult, deepCopy } from '../pubUtils/util';
import Hero from '../db/Hero';
import { RoleModel } from '../db/Role';
import { CeAttrData, CeAttr } from '../db/BaseModel';
import { CeAttrData, CeAttr } from '../db/generalField';
import { getFashionsById, getJobInfoById, getJobByGradeAndClass, getHeroInfoById, getHeroStar, getHeroWake, getFiendShipLevel, getFriendShipById, getHeroSkillById, getSeidById } from '../pubUtils/gamedata';
import { getAttrNameByJobStage, getAttrCeRatio, getAtrrNameById, ABI_TYPE_TO_STAGE, ABI_STAGE, SEID_TYPE, HERO_ATTR} from '../consts';
const HERO_CE_RATIO = 100;
@@ -61,6 +61,7 @@ export async function calPlayerCeAndSave(sid: string, roleId: string, heros: Arr
for (let hero of heros) {
let incHeroCe = calPlayerCe(hero, type, args);
incPlayerCe += incHeroCe;
await hero.save();
pushHeros.push({
hid: hero.hid,
@@ -216,7 +217,7 @@ export function calHeroFavourUpIncAttr(hero: any, args: Array<number>) {
difAdd -= lastFiendShipLevel.add;
}
let attrName;
for (let connect of hero.conections) {
for (let connect of hero.connections) {
let heroShip = getFriendShipById(connect.shipId, connect.level);
for (let attr of heroShip.attributes) {
attrName = getAtrrNameById(attr.id);

16
shared/db/ActionPoint.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* 体力系统
@@ -16,7 +16,7 @@ export default class ActionPoint extends BaseModel {
ap: number; // 当前体力
public static async getAp(roleId: string, lean = true) {
let result = await ActionPointModel.findOne({roleId}).select('ap refTime').lean(lean);
let result: ActionPointType = await ActionPointModel.findOne({roleId}).select('ap refTime').lean(lean);
if(!result) {
result = await ActionPointModel.findOneAndUpdate({roleId}, { ap: 0, refTime: 0 }, {new: true, upsert: true}).lean(lean)
}
@@ -24,14 +24,16 @@ export default class ActionPoint extends BaseModel {
}
public static async saveAp(roleId: string, ap: number, refTime: number, lean = true) {
let result = await ActionPointModel.findOneAndUpdate({roleId}, { ap, refTime }, {upsert: true, new: true}).lean(lean);
return result||{};
let result: ActionPointType = await ActionPointModel.findOneAndUpdate({roleId}, { ap, refTime }, {upsert: true, new: true}).lean(lean);
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await ActionPointModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await ActionPointModel.deleteMany({roleId});
return result;
}
}
export const ActionPointModel = getModelForClass(ActionPoint);
export interface ActionPointType extends Pick<DocumentType<ActionPoint>, keyof ActionPoint>{}

10
shared/db/Api.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { COUNTER } from './../consts';
import { CounterModel } from './Counter';
@@ -21,21 +21,23 @@ export default class Api extends BaseModel {
name: string;
public static async getApi(api: string, lean = true) {
let result = await ApiModel.findOne({api}).select('apiId api name').lean(lean);
let result: ApiType = await ApiModel.findOne({api}).select('apiId api name').lean(lean);
return result;
}
public static async getAllApi(lean = true) {
const api = await ApiModel.find().sort({apiId: 1}).lean(lean);
const api: ApiType[] = await ApiModel.find().sort({apiId: 1}).lean(lean);
return api;
}
public static async createApi(api:string, name: string, lean = true) {
const apiId = await CounterModel.getNewCounter(COUNTER.API);
const result = await ApiModel.findOneAndUpdate({apiId}, {$set:{api, name}}, {upsert: true, new: true}).lean(lean);
const result: ApiType = await ApiModel.findOneAndUpdate({apiId}, {$set:{api, name}}, {upsert: true, new: true}).lean(lean);
return result;
}
}
export const ApiModel = getModelForClass(Api);
export interface ApiType extends Pick<DocumentType<Api>, keyof Api>{}

42
shared/db/BaseModel.ts
View File

@@ -23,45 +23,3 @@ export default class BaseModel extends TimeStamps {
@prop()
updatedAt: Date
}
export class CeAttrData {
@prop({ required: true })
base?: number = 0;
@prop({ required: true })
ratioUp: number = 0;
@prop({ required: true })
fixUp: number = 0;
}
export class CeAttr {
@prop({ required: false })
hp?: CeAttrData;
@prop({ required: false })
atk?: CeAttrData;
@prop({ required: false })
matk?: CeAttrData;
@prop({ required: false })
def?: CeAttrData;
@prop({ required: false })
mdef?: CeAttrData;
@prop({ required: false })
agi?: CeAttrData;
@prop({ required: false })
luk?: CeAttrData;
@prop({ required: false })
hit?: CeAttrData;
@prop({ required: false })
cri?: CeAttrData;
@prop({ required: false })
flee?: CeAttrData;
@prop({ required: false })
antCri?: CeAttrData;
@prop({ required: false })
damageIncrease?: CeAttrData;
@prop({ required: false })
damageDecrease?: CeAttrData;
@prop({ required: false })
defIngnore?: CeAttrData;
@prop({ required: false })
bloodSuck?: CeAttrData;
}

14
shared/db/BattleBlueprtDrop.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* 藏宝图掉落记录
@@ -22,21 +22,23 @@ export default class BattleBlueprtDrop extends BaseModel {
costAp: number; // 当天消耗的ap
public static async findByTime(roleId: string, refTime: Date, lean = true) {
const result = await BattleBlueprtDropModel.findOneAndUpdate({ roleId, refTime }, {}, {new: true, upsert: true}).lean(lean);
const result: BattleBlueprtDropType = await BattleBlueprtDropModel.findOneAndUpdate({ roleId, refTime }, {}, {new: true, upsert: true}).lean(lean);
return result;
}
public static async updateByTime(roleId: string, refTime: Date, params: {getNum: number, curCostAp: number, getSum: number, costAp: number}, lean = true) {
const result = await BattleBlueprtDropModel.findOneAndUpdate({roleId, refTime}, {$set: params}).lean(lean);
const result: BattleBlueprtDropType = await BattleBlueprtDropModel.findOneAndUpdate({roleId, refTime}, {$set: params}).lean(lean);
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await BattleBlueprtDropModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await BattleBlueprtDropModel.deleteMany({roleId});
return result;
}
}
export const BattleBlueprtDropModel = getModelForClass(BattleBlueprtDrop);
export interface BattleBlueprtDropType extends Pick<DocumentType<BattleBlueprtDrop>, keyof BattleBlueprtDrop>{}

14
shared/db/BattleDrop.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* 战斗记录接口
@@ -25,19 +25,21 @@ export default class BattleDrop extends BaseModel {
public static async findByGid(roleId: string, battleId: number, gid: number, lean = true) {
const result = await BattleDropModel.findOneAndUpdate({ roleId, battleId, gid}, {}, {new: true, upsert: true}).lean(lean);
const result: BattleDropType = await BattleDropModel.findOneAndUpdate({ roleId, battleId, gid}, {}, {new: true, upsert: true}).lean(lean);
return result;
}
public static async updateByGid(roleId: string, battleId: number, gid: number, params: {getNum: number, allNum: number, getSum: number, allSum: number}, lean = true) {
const result = await BattleDropModel.findOneAndUpdate({roleId, battleId, gid}, {$set: params}).lean(lean);
const result: BattleDropType = await BattleDropModel.findOneAndUpdate({roleId, battleId, gid}, {$set: params}).lean(lean);
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await BattleDropModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await BattleDropModel.deleteMany({roleId});
return result;
}
}
export const BattleDropModel = getModelForClass(BattleDrop);
export interface BattleDropType extends Pick<DocumentType<BattleDrop>, keyof BattleDrop>{}

16
shared/db/BattleRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* 战斗记录接口
@@ -32,29 +32,31 @@ export default class BattleRecord extends BaseModel {
};
public static async getBattleRecordByCode(battleCode: string, lean = true) {
const result = await BattleRecordModel.findOne({ battleCode }).lean(lean);
const result: BattleRecordType = await BattleRecordModel.findOne({ battleCode }).lean(lean);
return result;
}
public static async getBattleRecordByIdAndStatus(roleId: string, battleId: number, status: number, lean = true) {
const result = await BattleRecordModel.findOne({ roleId, battleId, status }).lean(lean);
const result: BattleRecordType = await BattleRecordModel.findOne({ roleId, battleId, status }).lean(lean);
return result;
}
public static async getBattleRecordByIdAndStar(roleId: string, battleId: number, star: number, lean = true) {
const result = await BattleRecordModel.findOne({ roleId, battleId, star: {$lte: star} }).lean(lean);
const result: BattleRecordType = await BattleRecordModel.findOne({ roleId, battleId, star: {$lte: star} }).lean(lean);
return result;
}
public static async updateBattleRecordByCode( battleCode: string, params: object, lean = true) {
const result = await BattleRecordModel.findOneAndUpdate({ battleCode }, params, {new: true, upsert: true}).lean(lean);
const result: BattleRecordType = await BattleRecordModel.findOneAndUpdate({ battleCode }, params, {new: true, upsert: true}).lean(lean);
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await BattleRecordModel.deleteMany({roleId}).lean(lean);
public static async deleteAccount(roleId: string) {
let result = await BattleRecordModel.deleteMany({roleId});
return result||{};
}
}
export const BattleRecordModel = getModelForClass(BattleRecord);
export interface BattleRecordType extends Pick<DocumentType<BattleRecord>, keyof BattleRecord>{}

12
shared/db/BattleSweepRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* 战斗记录接口
@@ -23,14 +23,16 @@ export default class BattleSweepRecord extends BaseModel {
count: number; // 扫荡次数
public static async saveBattleSweepRecordById(roleId: string, battleId: number, params: any, lean = true) {
const result = await BattleSweepRecordModel.findOneAndUpdate({ roleId, battleId }, params, {new: true, upsert: true}).lean(lean);
const result: BattleSweepRecordType = await BattleSweepRecordModel.findOneAndUpdate({ roleId, battleId }, params, {new: true, upsert: true}).lean(lean);
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await BattleSweepRecordModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await BattleSweepRecordModel.deleteMany({roleId});
return result;
}
}
export const BattleSweepRecordModel = getModelForClass(BattleSweepRecord);
export interface BattleSweepRecordType extends Pick<DocumentType<BattleSweepRecord>, keyof BattleSweepRecord>{}

38
shared/db/ComBattleTeam.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
export class RoleStatus {
@prop({ required: true })
@@ -126,48 +126,48 @@ export default class ComBattleTeam extends BaseModel {
bossHpArr: Array<BossHp>;
public static async createTeam(teamData: {teamCode: string, roleIds: Array<string>, pub: boolean, blueprtId: number, quality: number, status: number, roleStatus: Array<RoleStatus>, capId: string, ceLimit: number}, lean = true) {
const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamData.teamCode }, {$set :{...teamData, roleCnt: teamData.roleIds.length}}, {upsert: true, new: true}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamData.teamCode }, {$set :{...teamData, roleCnt: teamData.roleIds.length}}, {upsert: true, new: true}).lean(lean);
return team;
}
public static async addRole(teamCode: string, roleStatus: RoleStatus, lean = true) {
const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode }, {$push: {roleIds: roleStatus.roleId, roleStatus}, $inc: {roleCnt: 1}}, {new: true}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode }, {$push: {roleIds: roleStatus.roleId, roleStatus}, $inc: {roleCnt: 1}}, {new: true}).lean(lean);
return team;
}
public static async removeRole(teamCode: string, roleIdToRm: string, lean = true) {
const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode }, {$pull: {roleIds: roleIdToRm, roleStatus: {roleId: roleIdToRm}}, $inc: {roleCnt: -1}}, {new: true}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode }, {$pull: {roleIds: roleIdToRm, roleStatus: {roleId: roleIdToRm}}, $inc: {roleCnt: -1}}, {new: true}).lean(lean);
return team;
}
public static async removeTeam(teamCode: string, lean = true) {
const team = await ComBattleTeamModel.findOneAndDelete({ teamCode }).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndDelete({ teamCode }).lean(lean);
return team;
}
public static async updateHeroes(teamCode: string, roleId: string, heroes: Array<number>, lean = true) {
const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.heroes': heroes}}, {new: true}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.heroes': heroes}}, {new: true}).lean(lean);
return team;
}
public static async setupBattleInfo(teamCode: string, roleId: string, heroes: Array<number>, battleCode: string, lean = true) {
const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.heroes': heroes, 'roleStatus.$.battleCode': battleCode}}, {new: true}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.heroes': heroes, 'roleStatus.$.battleCode': battleCode}}, {new: true}).lean(lean);
return team;
}
public static async updateRewardSt(teamCode: string, roleId: string, gotReward: boolean, lean = true) {
const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.gotReward': gotReward}}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode, 'roleStatus.roleId': roleId}, {$set: {'roleStatus.$.gotReward': gotReward}}).lean(lean);
return team;
}
public static async syncTeamData(teamData: {teamCode: string, status: number, roleStatus: Array<RoleStatus>, bossHpArr: Array<BossHp>}, lean = true) {
console.log('syncTeamData bossHpArr: ', teamData.bossHpArr);
const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamData.teamCode }, {$set :{...teamData, roleCnt: teamData.roleStatus.length}}, {new: true}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamData.teamCode }, {$set :{...teamData, roleCnt: teamData.roleStatus.length}}, {new: true}).lean(lean);
return team;
}
public static async updateStatus(teamCode: string, status: number, lean = true) {
const team = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamCode }, {status}, {new: true}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOneAndUpdate({ teamCode: teamCode }, {status}, {new: true}).lean(lean);
return team;
}
@@ -199,22 +199,22 @@ export default class ComBattleTeam extends BaseModel {
}
public static async getTeamByCapAndStatus(roleId: string, status: number, lean = true) {
const teams = await ComBattleTeamModel.find({capId: roleId, status}).lean(lean);
const teams: ComBattleTeamType[] = await ComBattleTeamModel.find({capId: roleId, status}).lean(lean);
return teams;
}
public static async getTeamByBlueprt(blueprtIds: Array<number>, status: number, pub = true, limit = 50, lean = true) {
const teams = await ComBattleTeamModel.find({blueprtId: {$in: blueprtIds}, status, pub}).limit(limit).lean(lean);
const teams: ComBattleTeamType[] = await ComBattleTeamModel.find({blueprtId: {$in: blueprtIds}, status, pub}).limit(limit).lean(lean);
return teams;
}
public static async getOneTeamByQualityAndSt(qualityArr: Array<number>, status: number, ce = 0, pub = true, cntLmt = 2, lean = true) {
const team = await ComBattleTeamModel.findOne({quality: {$in: qualityArr}, status, ceLimit: {$lte: ce}, pub, roleCnt: {$lte: cntLmt}}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOne({quality: {$in: qualityArr}, status, ceLimit: {$lte: ce}, pub, roleCnt: {$lte: cntLmt}}).lean(lean);
return team;
}
public static async getOtherTeamByQualityAndSt(roleId: string, qualityArr: Array<number>, status: number, ce = 0, pub = true, cntLmt = 2, lean = true) {
const team = await ComBattleTeamModel.findOne({quality: {$in: qualityArr}, status, ceLimit: {$lte: ce}, pub, roleCnt: {$lte: cntLmt}, roleIds: {$nin: [roleId]}}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOne({quality: {$in: qualityArr}, status, ceLimit: {$lte: ce}, pub, roleCnt: {$lte: cntLmt}, roleIds: {$nin: [roleId]}}).lean(lean);
return team;
}
@@ -229,7 +229,7 @@ export default class ComBattleTeam extends BaseModel {
if (isAssist) {
query = Object.assign(query, {capId: {$ne: roleId}});
}
const teams = await ComBattleTeamModel.find(query).limit(limitCnt).lean(lean);
const teams: ComBattleTeamType[] = await ComBattleTeamModel.find(query).limit(limitCnt).lean(lean);
return teams;
}
@@ -244,19 +244,21 @@ export default class ComBattleTeam extends BaseModel {
if (isAssist) {
query = Object.assign(query, {capId: {$ne: roleId}});
}
const teams = await ComBattleTeamModel.find(query).lean(lean);
const teams: ComBattleTeamType[] = await ComBattleTeamModel.find(query).lean(lean);
return teams;
}
public static async getTeamByRoleAndBattleCode(roleId: string, battleCode: string, lean = true) {
const team = await ComBattleTeamModel.findOne({roleIds: roleId, 'roleStatus.battleCode': battleCode}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOne({roleIds: roleId, 'roleStatus.battleCode': battleCode}).lean(lean);
return team;
}
public static async getTeamByCode(teamCode: string, lean = true) {
const team = await ComBattleTeamModel.findOne({teamCode}).lean(lean);
const team: ComBattleTeamType = await ComBattleTeamModel.findOne({teamCode}).lean(lean);
return team;
}
}
export const ComBattleTeamModel = getModelForClass(ComBattleTeam);
export interface ComBattleTeamType extends Pick<DocumentType<ComBattleTeam>, keyof ComBattleTeam>{};

6
shared/db/Counter.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* 自增 ID
@@ -15,7 +15,7 @@ export default class Counter extends BaseModel {
public static async getNewCounter(param:{name: string, def: number}, lean = true) {
let {name, def:defaultVal} = param;
let counter = await CounterModel.findOneAndUpdate({ name }, { $inc: { seq: 1 } }, { new: true, upsert: true }).lean(lean);
let counter: CounterType = await CounterModel.findOneAndUpdate({ name }, { $inc: { seq: 1 } }, { new: true, upsert: true }).lean(lean);
if(!counter || (counter&&counter.seq == 1) && defaultVal != 1) {
counter = await CounterModel.findOneAndUpdate({ name }, { $set: { seq: defaultVal } }, { new: true, upsert: true }).lean(lean);
}
@@ -25,3 +25,5 @@ export default class Counter extends BaseModel {
}
export const CounterModel = getModelForClass(Counter);
export interface CounterType extends Pick<DocumentType<Counter>, keyof Counter>{};

20
shared/db/DailyRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { DAILY_CONST } from './../consts';
import { setLocalHours } from './../pubUtils/util';
@@ -22,12 +22,12 @@ export default class DailyRecord extends BaseModel {
refTime: number; // 刷新时间
public static async getDailyRecordById(roleId: string, type: number, lean = true) {
const result = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {}, {new: true, upsert: true}).lean(lean);
const result: DailyRecordType = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {}, {new: true, upsert: true}).lean(lean);
return result;
}
public static async refreshRecord(roleId: string, type: number, lean = true) {
const dailyRecord = await DailyRecordModel.findOne({ roleId, type }).lean(lean);
const dailyRecord: DailyRecordType = await DailyRecordModel.findOne({ roleId, type }).lean(lean);
let {count = 0, refTime = 0, buyCount = 0} = dailyRecord||{};
let now = new Date();
let today = setLocalHours(DAILY_CONST.REFRESH_TIME, now);
@@ -35,24 +35,26 @@ export default class DailyRecord extends BaseModel {
if(today > refTime) {
refTime = today; count = 0; buyCount = 0;
}
let result = await DailyRecordModel.findOneAndUpdate({roleId, type}, {$set: {refTime, count, buyCount}}, {new: true, upsert: true});
let result: DailyRecordType = await DailyRecordModel.findOneAndUpdate({roleId, type}, {$set: {refTime, count, buyCount}}, {new: true, upsert: true}).lean(lean);
return result;
}
public static async increseDailyCount(roleId: string, type: number, count: number, lean = true) {
const result = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {$inc: { count } }, {new: true, upsert: true}).lean(lean);
const result: DailyRecordType = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {$inc: { count } }, {new: true, upsert: true}).lean(lean);
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await DailyRecordModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await DailyRecordModel.deleteMany({roleId});
return result;
}
public static async increseBuyCount(roleId: string, type: number, count: number, lean = true) {
const result = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {$inc: { buyCount:count } }, {new: true, upsert: true}).lean(lean);
const result: DailyRecordType = await DailyRecordModel.findOneAndUpdate({ roleId, type }, {$inc: { buyCount:count } }, {new: true, upsert: true}).lean(lean);
return result;
}
}
export const DailyRecordModel = getModelForClass(DailyRecord);
export interface DailyRecordType extends Pick<DocumentType<DailyRecord>, keyof DailyRecord>{};

16
shared/db/Equip.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
class RandSe {
@prop({ required: true })
@@ -50,26 +50,28 @@ export default class Equip extends BaseModel {
holes: Holes[];
public static async findbyRole(roleId: string, lean = true) {
const equips = await EquipModel.find({ roleId }).lean(lean);
const equips: EquipType[] = await EquipModel.find({ roleId }).lean(lean);
return equips;
}
public static async createEquip(equipInfo: {roleId: string, roleName: string, id: number, seqId: number, type: number, name: string, lv?: number}, lean = true) {
const doc = new EquipModel();
const update = Object.assign(doc.toJSON(), equipInfo);
const equip = await EquipModel.findOneAndUpdate({ seqId: equipInfo.seqId }, update, {upsert: true, new: true}).lean(lean);
const equip: EquipType = await EquipModel.findOneAndUpdate({ seqId: equipInfo.seqId }, update, {upsert: true, new: true}).lean(lean);
return equip;
}
public static async putOn(hid: number, equipId: string, lean = true) {
const equip = await EquipModel.findOneAndUpdate({ _id: equipId }, {hid}, {new: true}).lean(lean);
const equip: EquipType = await EquipModel.findOneAndUpdate({ _id: equipId }, {hid}, {new: true}).lean(lean);
return equip;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await EquipModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await EquipModel.deleteMany({roleId});
return result;
}
}
export const EquipModel = getModelForClass(Equip);
export interface EquipType extends Pick<DocumentType<Equip>, keyof Equip>{};

28
shared/db/EventRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
class Question {
@prop({ required: true })
@@ -47,23 +47,23 @@ export default class EventRecord extends BaseModel {
public static async getEventRecordByTime(roleId: string, refTime: number, lean=true ) {
let data = await EventRecordModel.find({roleId, refTime}).select('eventCode eventId type quality status battleId point question').lean(lean);
let data: EventRecordType[] = await EventRecordModel.find({roleId, refTime}).select('eventCode eventId type quality status battleId point question').lean(lean);
return data;
}
public static async getEventRecordByCode(roleId: string, eventCode: string, lean=true ) {
let data = await EventRecordModel.findOne({roleId, eventCode}).lean(lean);
let data: EventRecordType = await EventRecordModel.findOne({roleId, eventCode}).lean(lean);
return data;
}
public static async getHostoryEventRecord(roleId: string, lean=true) {
let latest = await EventRecordModel.findOne({roleId}).sort({turn: -1}).lean();
let latest: EventRecordType = await EventRecordModel.findOne({roleId}).sort({turn: -1}).lean();
let {turn = 0} = latest||{};
let result = await EventRecordModel.find({roleId, turn}).lean(lean);
let result: EventRecordType[] = await EventRecordModel.find({roleId, turn}).lean(lean);
return {history: result, turn};
}
public static async saveEventAnswer(eventCode: string, questionId: number, status: number , lean=true ) {
let data = await EventRecordModel.findOneAndUpdate(
let data: EventRecordType = await EventRecordModel.findOneAndUpdate(
{eventCode, 'question.id': questionId}, { $set: {'question.$.status': status} }, {upsert: true, new: true}).lean(lean);
return data;
}
@@ -71,29 +71,31 @@ export default class EventRecord extends BaseModel {
public static async saveEventRecord(eventCode: string, params: {roleId: string, refTime: number, eventId: number, roleName:string, turn?: number, type: number, quality: number, battleId?: number, status: number, point: number, question: Array<any> } , lean=true ) {
let doc = new EventRecordModel();
let update = Object.assign(doc.toJSON(), params, {eventCode});
let data = await EventRecordModel.findOneAndUpdate({eventCode}, { $set: update }, {upsert: true, new: true}).select('eventCode eventId type quality status battleId point question').lean(lean);
let data: EventRecordType = await EventRecordModel.findOneAndUpdate({eventCode}, { $set: update }, {upsert: true, new: true}).select('eventCode eventId type quality status battleId point question').lean(lean);
return data;
}
public static async setBattleCode(roleId: string, battleId: number, refTime: number, battleCode: string , lean=true ) {
let result = await EventRecordModel.findOneAndUpdate({roleId, battleId, refTime}, {$set:{ battleCode }}).sort({turn: 1}).lean(lean);
let result: EventRecordType = await EventRecordModel.findOneAndUpdate({roleId, battleId, refTime}, {$set:{ battleCode }}).sort({turn: 1}).lean(lean);
return result;
}
public static async setBattleStatus(roleId: string, battleId: number, battleCode: string, status: number , lean=true ) {
let result = await EventRecordModel.findOneAndUpdate({roleId, battleId, battleCode}, {$set:{ status }}).lean(lean);
let result: EventRecordType = await EventRecordModel.findOneAndUpdate({roleId, battleId, battleCode}, {$set:{ status }}).lean(lean);
return result;
}
public static async setStatusByCode(roleId: string, eventCode: string, status: number , lean=true ) {
let result = await EventRecordModel.findOneAndUpdate({ roleId, eventCode }, {$set:{ status }}, {new: true, upsert: true}).lean(lean);
let result: EventRecordType = await EventRecordModel.findOneAndUpdate({ roleId, eventCode }, {$set:{ status }}, {new: true, upsert: true}).lean(lean);
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await EventRecordModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await EventRecordModel.deleteMany({roleId});
return result;
}
}
export const EventRecordModel = getModelForClass(EventRecord);
export interface EventRecordType extends Pick<DocumentType<EventRecord>, keyof EventRecord>{};

16
shared/db/ExpeditionPoint.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* 远征记录
@@ -18,12 +18,12 @@ export default class ExpeditionPoint extends BaseModel {
rewards: Array<{point: number, reward: string, received:boolean, recTime: Date}>; // 领取记录
public static async getExpeditionPoint(roleId: string, lean = true) {
const result = await ExpeditionPointModel.findOne({ roleId, completed: false }).lean(lean);
const result: ExpeditionPointType = await ExpeditionPointModel.findOne({ roleId, completed: false }).lean(lean);
return result;
}
public static async updatePointStatus(roleId: string, point: number, reward: string, lean = true) {
const result = await ExpeditionPointModel.findOneAndUpdate(
const result: ExpeditionPointType = await ExpeditionPointModel.findOneAndUpdate(
{ roleId, completed: false },
{ $set: { pointCost: point }, $push: {rewards:{point, reward, received: true, recTime: new Date()}}},
{ new: true, upsert: true }
@@ -32,17 +32,19 @@ export default class ExpeditionPoint extends BaseModel {
}
public static async completeStatus(roleId: string, lean = true) {
const result = await ExpeditionPointModel.findOneAndUpdate(
const result: ExpeditionPointType = await ExpeditionPointModel.findOneAndUpdate(
{ roleId, completed: false },
{ $set: {completed: true } }
).lean(lean);
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await ExpeditionPointModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await ExpeditionPointModel.deleteMany({roleId});
return result;
}
}
export const ExpeditionPointModel = getModelForClass(ExpeditionPoint);
export interface ExpeditionPointType extends Pick<DocumentType<ExpeditionPoint>, keyof ExpeditionPoint>{};

20
shared/db/ExpeditionRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { genCode } from '../pubUtils/util';
class Heroes {
@@ -33,24 +33,24 @@ export default class ExpeditionRecord extends BaseModel {
public static async getCurRecord(roleId: string, lean = true) {
const result = await ExpeditionRecordModel.findOne({ roleId, status: 1 }).lean(lean);
const result: ExpeditionRecordType = await ExpeditionRecordModel.findOne({ roleId, status: 1 }).lean(lean);
return result;
}
public static async createRecord(params: { roleId: string, roleName: string, heroes: Array<{seqId: number, hp: number, ap: number}>, myCe: number }, lean = true) {
const code = genCode(8);
const result = await ExpeditionRecordModel.findOneAndUpdate({ expeditionCode: code }, {...params, status: 1}, { new: true, upsert: true }).lean(lean);
const result: ExpeditionRecordType = await ExpeditionRecordModel.findOneAndUpdate({ expeditionCode: code }, {...params, status: 1}, { new: true, upsert: true }).lean(lean);
return result;
}
public static async hideRecord(roleId: string, lean = true) {
const result = await ExpeditionRecordModel.findOneAndUpdate({ roleId, status: 1 }, { status: 0 }, { new: true }).lean(lean);
const result: ExpeditionRecordType = await ExpeditionRecordModel.findOneAndUpdate({ roleId, status: 1 }, { status: 0 }, { new: true }).lean(lean);
return result;
}
public static async getExpeditionRecordByCode(expeditionCode: string, lean=true) {
const result = await ExpeditionRecordModel.findOne({expeditionCode}).lean(lean);
const result: ExpeditionRecordType = await ExpeditionRecordModel.findOne({expeditionCode}).lean(lean);
return result
}
@@ -72,7 +72,7 @@ export default class ExpeditionRecord extends BaseModel {
{$set: {'heroes.$.seqId': seqId, 'heroes.$.hp': hp, 'heroes.$.ap': ap}}
)
}
const result = await ExpeditionRecordModel.findOneAndUpdate(
const result: ExpeditionRecordType = await ExpeditionRecordModel.findOneAndUpdate(
{ expeditionCode },
{ $push: {heroes: {$each: pushArr} } }
).lean(lean)
@@ -80,10 +80,12 @@ export default class ExpeditionRecord extends BaseModel {
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await ExpeditionRecordModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await ExpeditionRecordModel.deleteMany({roleId});
return result;
}
}
export const ExpeditionRecordModel = getModelForClass(ExpeditionRecord);
export interface ExpeditionRecordType extends Pick<DocumentType<ExpeditionRecord>, keyof ExpeditionRecord>{};

22
shared/db/ExpeditionWarRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { EXPEDITION_WAR_RECORD_STATUS } from '../consts';
class Enemies {
@@ -79,35 +79,35 @@ export default class ExpeditionWarRecord extends BaseModel {
ce: number; // 敌军战力
public static async getRecordByCode(expeditionCode: string, lean = true) {
const result = await ExpeditionWarRecordModel.find({ expeditionCode, battleStatus: {$gte: EXPEDITION_WAR_RECORD_STATUS.WAITING} }).select('expeditionId battleId battleCode battleStatus ce').sort({expeditionId: 1}).lean(lean);
const result: ExpeditionWarRecordType[] = await ExpeditionWarRecordModel.find({ expeditionCode, battleStatus: {$gte: EXPEDITION_WAR_RECORD_STATUS.WAITING} }).select('expeditionId battleId battleCode battleStatus ce').sort({expeditionId: 1}).lean(lean);
return result;
}
public static async getRecordByCodeAndId(expeditionCode: string, expeditionId: number, lean = true) {
const result = await ExpeditionWarRecordModel.findOne({ expeditionCode, expeditionId }).select('expeditionId battleId battleCode battleStatus enemyFrom enemies enemiesCurHpAp ce').lean(lean);
const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOne({ expeditionCode, expeditionId }).select('expeditionId battleId battleCode battleStatus enemyFrom enemies enemiesCurHpAp ce').lean(lean);
return result;
}
public static async saveRecord(expeditionCode: string, expeditionId: number, params: {roleId: string, battleId: number, enemyFrom: number, enemyId: string, enemies: Array<any>, battleStatus: number}, lean = true) {
const doc = new ExpeditionWarRecordModel();
const update = Object.assign(doc.toJSON(), params, {expeditionCode, expeditionId});
const result = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, update, {new: true, upsert: true}).select('expeditionId battleId battleCode battleStatus enemyFrom enemies enemiesCurHpAp ce').lean(lean);
const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, update, {new: true, upsert: true}).select('expeditionId battleId battleCode battleStatus enemyFrom enemies enemiesCurHpAp ce').lean(lean);
return result;
}
public static async updateStatus(expeditionCode: string, expeditionId: number, battleStatus: number, lean = true) {
const result = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {battleStatus}, {new: true}).lean(lean);
const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {battleStatus}, {new: true}).lean(lean);
return result;
}
public static async updateBattleCode(expeditionCode: string, expeditionId: number, battleStatus: number, battleCode: string, lean = true) {
const result = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {battleStatus, battleCode}, {new: true}).lean(lean);
const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOneAndUpdate({ expeditionCode, expeditionId }, {battleStatus, battleCode}, {new: true}).lean(lean);
return result;
}
public static async updateEnemiesStatus(expeditionCode: string, expeditionId: number, battleStatus: number, enemies: Array<{dataId: number, hp: number, ap: number}>, lean = true) {
const result = ExpeditionWarRecordModel.findOneAndUpdate(
const result: ExpeditionWarRecordType = await ExpeditionWarRecordModel.findOneAndUpdate(
{expeditionCode, expeditionId},
{$set: {battleStatus}, enemiesCurHpAp: enemies},
{new: true}
@@ -115,10 +115,12 @@ export default class ExpeditionWarRecord extends BaseModel {
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await ExpeditionWarRecordModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await ExpeditionWarRecordModel.deleteMany({roleId});
return result;
}
}
export const ExpeditionWarRecordModel = getModelForClass(ExpeditionWarRecord);
export interface ExpeditionWarRecordType extends Pick<DocumentType<ExpeditionWarRecord>, keyof ExpeditionWarRecord>{};

8
shared/db/FriendPoint.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* 情谊点记录
@@ -29,7 +29,7 @@ export default class FriendPoint extends BaseModel {
public static async updatePointToday(roleId: string, roleName: string, cntInc: number, maxPerDay: number, lean = true) {
const curTime = new Date((new Date()).setHours(0, 0, 0, 0));
// 当 oldCnt + cntInc > maxPerDay 时需计算实际可以获得的点数：cntInc - (newCnt - maxPerDay)
const rec = await FriendPointModel.findOneAndUpdate({roleId, roleName, createdAt: {$gte: curTime}, cnt: {$lt: maxPerDay}}, {$inc: {cnt: cntInc}}, {upsert: true, new: true}).lean(lean);
const rec: FriendPointType = await FriendPointModel.findOneAndUpdate({roleId, roleName, createdAt: {$gte: curTime}, cnt: {$lt: maxPerDay}}, {$inc: {cnt: cntInc}}, {upsert: true, new: true}).lean(lean);
return rec;
}
@@ -44,9 +44,11 @@ export default class FriendPoint extends BaseModel {
*/
public static async getFrdPointRecToday(roleId: string, type: number, lean = true) {
const curTime = new Date((new Date()).setHours(0, 0, 0, 0));
const rec = await FriendPointModel.findOne({roleId, createdAt: {$gte: curTime}, type}).lean(lean);
const rec: FriendPointType = await FriendPointModel.findOne({roleId, createdAt: {$gte: curTime}, type}).lean(lean);
return rec;
}
}
export const FriendPointModel = getModelForClass(FriendPoint);
export interface FriendPointType extends Pick<DocumentType<FriendPoint>, keyof FriendPoint>{};

18
shared/db/GMGroup.ts
View File

@@ -1,7 +1,7 @@
import { COUNTER } from './../consts';
import { CounterModel } from './Counter';
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* GM用户组接口
@@ -28,32 +28,32 @@ export default class GMGroup extends BaseModel {
public static async createGroup(group: string, name: string, desc: string, lean = true) {
const id = await CounterModel.getNewCounter(COUNTER.GM_GROUP);
const result = await GMGroupModel.findOneAndUpdate({id}, {group, desc, name, apis: []}, {upsert: true, new: true}).select('uid username name').lean(lean);
const result: GMGroupType = await GMGroupModel.findOneAndUpdate({id}, {group, desc, name, apis: []}, {upsert: true, new: true}).select('uid username name').lean(lean);
return result;
}
public static async editGroup(groupId: number, group: string, name: string, desc: string, lean = true) {
const result = await GMGroupModel.findOneAndUpdate({ id: groupId }, {$set: {group, desc, name}}).select('uid username name').lean(lean);
const result: GMGroupType = await GMGroupModel.findOneAndUpdate({ id: groupId }, {$set: {group, desc, name}}).select('uid username name').lean(lean);
return result;
}
public static async getAllGroup(lean = true) {
const list = await GMGroupModel.find().lean(lean);
const list: GMGroupType[] = await GMGroupModel.find().lean(lean);
return list;
}
public static async getGroup(group: string, lean = true) {
const result = await GMGroupModel.findOne({ group }).lean(lean);
const result: GMGroupType = await GMGroupModel.findOne({ group }).lean(lean);
return result;
}
public static async getGroupById(id: number, lean = true) {
const result = await GMGroupModel.findOne({ id }).lean(lean);
const result: GMGroupType = await GMGroupModel.findOne({ id }).lean(lean);
return result;
}
public static async saveApiToGroup(id: number, apis: Array<number>, lean = true) {
let group = await GMGroupModel.getGroupById(id);
let group: GMGroupType = await GMGroupModel.getGroupById(id);
if(group) {
let originApi = group.apis||[];
let addArr = new Array(), removeArr = new Array();
@@ -66,7 +66,7 @@ export default class GMGroup extends BaseModel {
if(apis.indexOf(api) == -1) removeArr.push(api);
}
await GMGroupModel.findOneAndUpdate({ id }, { $push: {apis: {$each: addArr}} }).lean(lean);
const result = await GMGroupModel.findOneAndUpdate({ id }, { $pull: {apis: {$in: removeArr}} }).lean(lean);
const result: GMGroupType = await GMGroupModel.findOneAndUpdate({ id }, { $pull: {apis: {$in: removeArr}} }).lean(lean);
return result;
}
}
@@ -75,3 +75,5 @@ export default class GMGroup extends BaseModel {
}
export const GMGroupModel = getModelForClass(GMGroup);
export interface GMGroupType extends Pick<DocumentType<GMGroup>, keyof GMGroup>{};

4
shared/db/GMRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* GM用户组接口
@@ -29,3 +29,5 @@ export default class GMRecord extends BaseModel {
}
export const GMRecordModel = getModelForClass(GMRecord);
export interface GMRecordType extends Pick<DocumentType<GMRecord>, keyof GMRecord>{};

20
shared/db/GMUser.ts
View File

@@ -1,7 +1,7 @@
import { COUNTER } from './../consts';
import { CounterModel } from './Counter';
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
const bcrypt = require('bcrypt');
const SALT_WORK_FACTOR = 5
@@ -39,32 +39,32 @@ export default class GMUser extends BaseModel {
}
public static async getGmAccountList(lean = true) {
const user = await GMUserModel.find().select('uid username name token').lean(lean);
const user: GMUserType[] = await GMUserModel.find().select('uid username name token').lean(lean);
return user;
}
public static async getGmAccountByToken(token: string, lean = true) {
// console.log(token)
const user = await GMUserModel.findOne({token}).select('uid username name token').lean(lean);
const user: GMUserType = await GMUserModel.findOne({token}).select('uid username name token').lean(lean);
return user;
}
public static async getGmAccountByUid(uid: number, lean = true) {
const user = await GMUserModel.findOne({uid}).select('uid username name token').lean(lean);
const user: GMUserType = await GMUserModel.findOne({uid}).select('uid username name token').lean(lean);
return user;
}
public static async getGmAccountByUsername(username: string, lean = true) {
const user = await GMUserModel.findOne({username}).select('uid username name token').lean(lean);
const user: GMUserType = await GMUserModel.findOne({username}).select('uid username name token').lean(lean);
return user;
}
public static async login(username: string, password: string, token: string, lean = true) {
const user = await GMUserModel.findOne({username}).select('salt').lean();
const user: GMUserType = await GMUserModel.findOne({username}).select('salt').lean();
if(user) {
let { salt } = user;
let { npassword } = await this.encryptPass(password, salt);
const checkUser = await GMUserModel.findOneAndUpdate({username, password: npassword}, { token }).select('uid username name token').lean(lean);
const checkUser: GMUserType = await GMUserModel.findOneAndUpdate({username, password: npassword}, { token }).select('uid username name token').lean(lean);
return checkUser;
} else {
return null
@@ -74,15 +74,17 @@ export default class GMUser extends BaseModel {
public static async createGmAccount(username: string, password: string, name: string, token: string, lean = true) {
const uid = await CounterModel.getNewCounter(COUNTER.GMUID);
let r = await this.encryptPass(password);
const user = await GMUserModel.findOneAndUpdate({username}, {uid, password: r.npassword, salt: r.salt, name, token}, {upsert: true, new: true}).select('uid username name').lean(lean);
const user: GMUserType = await GMUserModel.findOneAndUpdate({username}, {uid, password: r.npassword, salt: r.salt, name, token}, {upsert: true, new: true}).select('uid username name').lean(lean);
return user;
}
public static async changePass(uid: number, password: string, lean = true) {
let r = await this.encryptPass(password);
const user = await GMUserModel.findOneAndUpdate({uid}, { password: r.npassword, salt: r.salt}).select('uid username name').lean(lean);
const user: GMUserType = await GMUserModel.findOneAndUpdate({uid}, { password: r.npassword, salt: r.salt}).select('uid username name').lean(lean);
return user;
}
}
export const GMUserModel = getModelForClass(GMUser);
export interface GMUserType extends Pick<DocumentType<GMUser>, keyof GMUser>{};

12
shared/db/GMUserGroup.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
/**
* GM账号和用户组关系接口
@@ -17,19 +17,21 @@ export default class GMUserGroup extends BaseModel {
groupId: number;
public static async getUserGroupByUid(uid: number, serverId: number, lean = true) {
const user = await GMUserGroupModel.find({uid, serverId}).lean(lean);
const user: GMUserGroupType[] = await GMUserGroupModel.find({uid, serverId}).lean(lean);
return user;
}
public static async removeUserGroup(uid: number, serverId: number, groups: Array<number>, lean = true) {
const user = await GMUserGroupModel.deleteMany({uid, serverId, groupId: {$in: groups}}).lean(lean);
public static async removeUserGroup(uid: number, serverId: number, groups: Array<number>) {
const user = await GMUserGroupModel.deleteMany({uid, serverId, groupId: {$in: groups}});
return user;
}
public static async addUserGroup(uid: number, serverId: number, groupId: number, lean = true) {
const result = await GMUserGroupModel.findOneAndUpdate({uid, serverId, groupId}, {}, {new:true, upsert:true}).lean(lean);
const result: GMUserGroupType = await GMUserGroupModel.findOneAndUpdate({uid, serverId, groupId}, {}, {new:true, upsert:true}).lean(lean);
return result;
}
}
export const GMUserGroupModel = getModelForClass(GMUserGroup);
export interface GMUserGroupType extends Pick<DocumentType<GMUserGroup>, keyof GMUserGroup>{};

10
shared/db/Game.ts
View File

@@ -1,6 +1,6 @@
import { APP_ID } from './../consts';
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
class ServerInfo {
@prop({ required: true })
@@ -56,7 +56,7 @@ export default class Game extends BaseModel {
versionCode: number;
public static async getAllServerList() {
let game = await GameModel.findOne().lean();
let game: GameType = await GameModel.findOne().lean();
if(game) {
return game.serverList;
} else {
@@ -65,7 +65,7 @@ export default class Game extends BaseModel {
}
public static async getServerListByType(serverType: string) {
let game = await GameModel.findOne().lean();
let game: GameType = await GameModel.findOne().lean();
if (!game) {
const serverInfo: ServerInfo = { id: 1, name: '常山少年', host: 'pinus_test.trgame.cn', port: 3014, status: 1, createTime: new Date(), serverType: 'official' };
const iconUrl = `https://download.tgamebox.cn/avatar/${APP_ID}/1.png`;
@@ -84,9 +84,11 @@ export default class Game extends BaseModel {
public static async newServer(serverId: number, serverType: string, name: string, host: string, port: number, status: number, lean = true) {
let serverInfo: ServerInfo = {id: serverId, name, host, port, status, createTime: new Date(), serverType};
let game = await GameModel.findOneAndUpdate({}, {$push: {serverList: serverInfo}}, {new: true}).lean(lean);
let game: GameType = await GameModel.findOneAndUpdate({}, {$push: {serverList: serverInfo}}, {new: true}).lean(lean);
return game;
}
}
export const GameModel = getModelForClass(Game);
export interface GameType extends Pick<DocumentType<Game>, keyof Game>{};

18
shared/db/HangUpRecord.ts
View File

@@ -1,6 +1,6 @@
import { HANG_UP_CONSTS } from './../consts';
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
class Goods {
@prop({ required: true })
@@ -42,17 +42,17 @@ export default class HangUpRecord extends BaseModel {
const curTime = new Date();
const recDoc = new HangUpRecordModel();
const update = Object.assign(recDoc.toJSON(), {roleId, roleName, startTime: curTime, startLv: HANG_UP_CONSTS.ENABLE_LV});
const rec = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: HANG_UP_CONSTS.ENABLE_LV}, update, {upsert: true, new: true}).lean(lean);
const rec: HangUpRecordType = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: HANG_UP_CONSTS.ENABLE_LV}, update, {upsert: true, new: true}).lean(lean);
return rec;
}
public static async getCurRec(roleId: string, lean = true) {
const rec = await HangUpRecordModel.findOne({roleId, received: false}).lean(lean);
const rec: HangUpRecordType = await HangUpRecordModel.findOne({roleId, received: false}).lean(lean);
return rec;
}
public static async getLastRec(roleId: string, lean = true) {
const rec = await HangUpRecordModel.findOne({roleId, received: true}).sort({endTime: -1}).lean(lean);
const rec: HangUpRecordType = await HangUpRecordModel.findOne({roleId, received: true}).sort({endTime: -1}).lean(lean);
return rec;
}
@@ -61,14 +61,16 @@ export default class HangUpRecord extends BaseModel {
const recDoc = new HangUpRecordModel();
const update = Object.assign(recDoc.toJSON(), {roleId, roleName, startTime: endTime, startLv: endLv});
delete update._id;
const newRec = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: endLv, received: false}, update, {upsert: true, new: true}).lean(lean);
const newRec: HangUpRecordType = await HangUpRecordModel.findOneAndUpdate({roleId, startLv: endLv, received: false}, update, {upsert: true, new: true}).lean(lean);
return newRec;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await HangUpRecordModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await HangUpRecordModel.deleteMany({roleId});
return result;
}
}
export const HangUpRecordModel = getModelForClass(HangUpRecord);
export interface HangUpRecordType extends Pick<DocumentType<HangUpRecord>, keyof HangUpRecord>{};

12
shared/db/HangUpSpdUpRec.ts
View File

@@ -1,6 +1,6 @@
// import { HANG_UP_CONSTS } from './../consts';
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
class Goods {
@prop({ required: true })
@@ -41,7 +41,7 @@ export default class HangUpSpdUpRec extends BaseModel {
public static async updateRec(roleId, roleName, multi, lv, needReceiveGoods: Array<{gid:number, count: number}>, lean = true ) {
if (multi <= 0) return null;
let rec = await HangUpSpdUpRecModel.findOneAndUpdate({roleId, lv, roleName}, {$inc: {cnt: multi}}, {upsert: true, new: true}).lean(lean);
let rec: HangUpSpdUpRecType = await HangUpSpdUpRecModel.findOneAndUpdate({roleId, lv, roleName}, {$inc: {cnt: multi}}, {upsert: true, new: true}).lean(lean);
if(rec && needReceiveGoods.length > 0) {
let {cnt} = rec;
let goods = [{
@@ -53,11 +53,13 @@ export default class HangUpSpdUpRec extends BaseModel {
return rec;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await HangUpSpdUpRecModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await HangUpSpdUpRecModel.deleteMany({roleId});
return result;
}
}
export const HangUpSpdUpRecModel = getModelForClass(HangUpSpdUpRec);
export interface HangUpSpdUpRecType extends Pick<DocumentType<HangUpSpdUpRec>, keyof HangUpSpdUpRec>{};

42
shared/db/Hero.ts
View File

@@ -1,5 +1,6 @@
import BaseModel, { CeAttr } from './BaseModel';
import { index, getModelForClass, prop, Ref, mongoose } from '@typegoose/typegoose';
import BaseModel from './BaseModel';
import { CeAttr } from './generalField';
import { index, getModelForClass, prop, Ref, mongoose, DocumentType } from '@typegoose/typegoose';
import Equip from './Equip';
import { CounterModel } from './Counter';
import { COUNTER } from '../consts';
@@ -35,7 +36,7 @@ interface heroUpdate {
favour?:number;
favourLv?:number;
skins?: Skin[];
conections?: Connect[];
connections?: Connect[];
_id?:number;
}
@@ -98,25 +99,25 @@ export default class Hero extends BaseModel {
equips: Ref<Equip>[]; // 武将装备引用数组
public static async findByRole(roleId: string, lean = true) {
const heros = await HeroModel.find({ roleId }).populate('equips').lean(lean);
return heros || [];
const heros: HeroType[] = await HeroModel.find({ roleId }).populate('equips').lean(lean);
return heros;
}
public static async findBySeqIdRange(seqIds: Array<number>, roleId: string, lean = true) {
const hero = await HeroModel.find({ seqId: {$in: seqIds}, roleId }).lean(lean);
const hero: HeroType[] = await HeroModel.find({ seqId: {$in: seqIds}, roleId }).lean(lean);
return hero;
}
public static async findBySeqIdAndRole(seqId: number, roleId: string, lean = true) {
const hero = await HeroModel.findOne({ seqId, roleId }).lean(lean);
const hero: HeroType = await HeroModel.findOne({ seqId, roleId }).lean(lean);
return hero;
}
public static async findByHidAndRole(hid: number, roleId: string, lean = true) {
const hero = await HeroModel.findOne({ hid, roleId }).lean(lean);
const hero: HeroType = await HeroModel.findOne({ hid, roleId }).lean(lean);
return hero;
}
public static async addEquip(roleId: string, hid: number, equipId: string, lean = true) {
const hero = await HeroModel.findOneAndUpdate({ roleId, hid }, {$push: {equips: equipId}}, {new: true}).lean(lean);
const hero: HeroType = await HeroModel.findOneAndUpdate({ roleId, hid }, {$push: {equips: equipId}}, {new: true}).lean(lean);
if (hero) {
await Equip.putOn(hero.hid, equipId);
}
@@ -128,12 +129,12 @@ export default class Hero extends BaseModel {
const seqId = await CounterModel.getNewCounter(COUNTER.HID)||-1;
const update = Object.assign(doc.toJSON(), heroInfo, {seqId});
delete update._id;
const hero = await HeroModel.findOneAndUpdate({roleId: heroInfo.roleId, hid: heroInfo.hid}, update, {upsert: true, new: true}).select('hid hName lv exp star starStage colorStar colorStarStage quality job jobStage conections favour favourLv skins equips ce ceAttr').lean(lean);
const hero: HeroType = await HeroModel.findOneAndUpdate({roleId: heroInfo.roleId, hid: heroInfo.hid}, update, {upsert: true, new: true}).select('hid hName lv exp star starStage colorStar colorStarStage quality job jobStage conections favour favourLv skins equips ce ceAttr').lean(lean);
return hero;
}
public static async sumTopHeroCe(roleId: string, num: number) {
let ce = await HeroModel.aggregate([
let ce: Array<{historyCe: number}> = await HeroModel.aggregate([
{ $match : { roleId } },
{ $sort: {historyCe: -1} },
{ $limit: num },
@@ -143,7 +144,7 @@ export default class Hero extends BaseModel {
}
public static async sumHeroCe(roleId: string) {
let ce = await HeroModel.aggregate([
let ce: Array<{ce: number}> = await HeroModel.aggregate([
{ $match : { roleId } },
{ $group: { _id: null, ce: { $sum: '$ce' } } }
]);
@@ -151,29 +152,30 @@ export default class Hero extends BaseModel {
}
public static async getTopHero(roleId: string, num: number, lean = true) {
const heroes = await HeroModel.find({roleId}).limit(num).sort({ce: -1}).lean(lean);
const heroes: HeroType[] = await HeroModel.find({roleId}).limit(num).sort({ce: -1}).lean(lean);
return heroes;
}
public static async updateCe(roleId: string, hid: number, ce: number, oldCe: number, historyCe: number, lean = true) {
let distance = ce - oldCe;
let historyDistance = ce > historyCe ?ce - historyCe: 0;
let result = await HeroModel.findOneAndUpdate({roleId, hid}, {$inc:{ce: distance, historyCe: historyDistance}}).lean(lean);
return result||{};
let result: HeroType = await HeroModel.findOneAndUpdate({roleId, hid}, {$inc:{ce: distance, historyCe: historyDistance}}).lean(lean);
return result;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await HeroModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await HeroModel.deleteMany({roleId});
return result;
}
public static async updateHeroInfo(roleId: string, hid:number, heroUpdate:heroUpdate, lean = true) {
delete heroUpdate._id;
let result = await HeroModel.findOneAndUpdate({roleId, hid}, {$set:heroUpdate}).lean(lean);
return result||{};
let result: HeroType = await HeroModel.findOneAndUpdate({roleId, hid}, {$set:heroUpdate}).lean(lean);
return result;
}
}
export const HeroModel = getModelForClass(Hero);
export interface HeroType extends Pick<DocumentType<Hero>, keyof Hero>{};

22
shared/db/Item.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
@index({ roleId: 1, id: 1 })
@index({ seqId: 1 })
@@ -22,36 +22,36 @@ export default class Item extends BaseModel {
public static async findbyRole(roleId: string, lean = true) {
const items = await ItemModel.find({ roleId }).select('id count type').lean(lean);
const items: ItemType[] = await ItemModel.find({ roleId }).select('id count type').lean(lean);
return items;
}
public static async findbyRoleAndIds(roleId: string, ids: Array<number>, lean = true) {
const items = await ItemModel.find({ roleId, id: {$in: ids} }).select('id count type').lean(lean);
const items: ItemType[] = await ItemModel.find({ roleId, id: {$in: ids} }).select('id count type').lean(lean);
return items;
}
public static async findByRoleAndType(roleId: string, type: number, lean = true) {
const items = await ItemModel.find({ roleId, type }).select('id count type').sort({id: 1}).lean(lean);
const items: ItemType[] = await ItemModel.find({ roleId, type }).select('id count type').sort({id: 1}).lean(lean);
return items;
}
public static async findbyRoleAndGidAndCount(roleId: string, id: number, count: number, lean = true) {
const items = await ItemModel.findOne({ roleId, id, count: {$gte: count} }).select('id count type').lean(lean);
const items: ItemType = await ItemModel.findOne({ roleId, id, count: {$gte: count} }).select('id count type').lean(lean);
return items;
}
public static async increaseItem(roleId: string, id: number, count: number, itemInfo: {roleId: string, roleName: string, id: number, itemName: string, type: number, hid?: number }, lean = true) {
const doc = new ItemModel();
const setOnInsert = Object.assign(doc.toJSON(), itemInfo);
const equips = await ItemModel.findOneAndUpdate({roleId, id },{$setOnInsert: setOnInsert, $inc: { count }}, {new: true, upsert: true}).lean(lean);
const equips: ItemType = await ItemModel.findOneAndUpdate({roleId, id },{$setOnInsert: setOnInsert, $inc: { count }}, {new: true, upsert: true}).lean(lean);
return equips;
}
public static async decreaseItems(roleId: string, items: Array<{id: number, count: number}>, lean = true) {
let updateItems = new Array<{id: number, count: number}>(), hasError: boolean = false, result = new Array();
for(let {id, count} of items) {
const rec = await ItemModel.findOneAndUpdate({roleId, id, count: {$gte: count} },{ $inc: { count: -1 * count }}, {new: true}).lean(lean);
const rec: ItemType = await ItemModel.findOneAndUpdate({roleId, id, count: {$gte: count} },{ $inc: { count: -1 * count }}, {new: true}).lean(lean);
if(rec) {
result.push(rec);
updateItems.push({id, count});
@@ -69,10 +69,12 @@ export default class Item extends BaseModel {
}
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await ItemModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await ItemModel.deleteMany({roleId});
return result;
}
}
export const ItemModel = getModelForClass(Item);
export interface ItemType extends Pick<DocumentType<Item>, keyof Item>{};

22
shared/db/PvpDefense.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
class Heroes {
@prop({ required: true })
@@ -36,25 +36,25 @@ export default class PvpDefense extends BaseModel {
public static async findByRoleId(roleId: string, lean = true) {
const result = await PvpDefenseModel.findOne({ roleId }).lean(lean);
const result: PvpDefenseType = await PvpDefenseModel.findOne({ roleId }).lean(lean);
return result;
}
public static async findByScale(roleId: string, min: number, max: number, lean = true) {
const result = await PvpDefenseModel.find({ roleId: {$ne: roleId}, ce: { $lte: max, $gte: min } }).sort({updatedAt: -1}).limit(100).lean(lean);
const result: PvpDefenseType[] = await PvpDefenseModel.find({ roleId: {$ne: roleId}, ce: { $lte: max, $gte: min } }).sort({updatedAt: -1}).limit(100).lean(lean);
return result;
}
public static async createPvpDefense(params: {roleId: string, roleName: string, heroes: Array<any>, ce: number}, lean=true) {
const doc = new PvpDefenseModel();
const update = Object.assign(doc.toJSON(), params);
const defense = await PvpDefenseModel.findOneAndUpdate({ roleId: params.roleId }, update, {upsert: true, new: true}).lean(lean);
const defense: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({ roleId: params.roleId }, update, {upsert: true, new: true}).lean(lean);
return defense;
}
public static async addHeroToDefense(roleId: string, heroInfo: any, ce: number, lean=true) {
const defense = await PvpDefenseModel.findOneAndUpdate({ roleId: roleId }, {
const defense: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({ roleId: roleId }, {
$inc: {ce},
$push: { heroes: heroInfo }
}, {upsert: true, new: true}).lean(lean);
@@ -63,7 +63,7 @@ export default class PvpDefense extends BaseModel {
}
public static async removeHeroFromDefense(roleId: string, hid: number, ce: number, lean=true) {
const defense = await PvpDefenseModel.findOneAndUpdate({ roleId: roleId }, {
const defense: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({ roleId: roleId }, {
$inc: {ce: -1 * ce},
$pull: { heroes: { actorId: hid }}
}, {upsert: true, new: true}).lean(lean);
@@ -73,14 +73,16 @@ export default class PvpDefense extends BaseModel {
public static async updateCe(roleId: string, hid: number, ce: number, oldCe: number, lean = true) {
let distance = ce - oldCe;
const rec = await PvpDefenseModel.findOneAndUpdate({roleId, 'heroes.actorId': hid}, {$inc: {ce: distance}}).lean(lean);
const rec: PvpDefenseType = await PvpDefenseModel.findOneAndUpdate({roleId, 'heroes.actorId': hid}, {$inc: {ce: distance}}).lean(lean);
return rec
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await PvpDefenseModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await PvpDefenseModel.deleteMany({roleId});
return result;
}
}
export const PvpDefenseModel = getModelForClass(PvpDefense);
export interface PvpDefenseType extends Pick<DocumentType<PvpDefense>, keyof PvpDefense>{};

10
shared/db/RScriptRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
@index({ roleId: 1, battleId: 1 })
@@ -28,19 +28,21 @@ export default class RScriptRecord extends BaseModel {
update['scriptAfter'] = script;
}
const items = await RScriptRecordModel.findOneAndUpdate({ roleId, battleId }, update, {upsert: true, new: true}).lean(lean);
const items: RScriptRecordType = await RScriptRecordModel.findOneAndUpdate({ roleId, battleId }, update, {upsert: true, new: true}).lean(lean);
return items;
}
public static async findbyRoleAndBattle(roleId: string, battleId: number, lean = true) {
const items = await RScriptRecordModel.findOne({ roleId, battleId }).select('battleId scriptBefore scriptAfter').sort({battleId: 1}).lean(lean);
const items: RScriptRecordType = await RScriptRecordModel.findOne({ roleId, battleId }).select('battleId scriptBefore scriptAfter').sort({battleId: 1}).lean(lean);
return items;
}
public static async findbyRole(roleId: string, warType: number, lean = true) {
const items = await RScriptRecordModel.find({ roleId, warType }).select('battleId scriptBefore scriptAfter').lean(lean);
const items: RScriptRecordType[] = await RScriptRecordModel.find({ roleId, warType }).select('battleId scriptBefore scriptAfter').lean(lean);
return items;
}
}
export const RScriptRecordModel = getModelForClass(RScriptRecord);
export interface RScriptRecordType extends Pick<DocumentType<RScriptRecord>, keyof RScriptRecord>{};

80
shared/db/Role.ts
View File

@@ -1,6 +1,7 @@
import { HANG_UP_CONSTS } from './../consts';
import BaseModel, { CeAttr } from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import BaseModel from './BaseModel';
import { CeAttr } from './generalField';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import User from './User';
import { shouldRefresh } from '../pubUtils/util';
import { HeroModel } from './Hero';
@@ -162,12 +163,12 @@ export default class Role extends BaseModel {
dungeonHeroes: Array<DungeonHero>; // 秘境首通使用的武将
public static async findByUid(uid: number, serverId: number, lean = true) {
const role = await RoleModel.findOne({ 'userInfo.uid': uid, serverId }).lean(lean);
const role: RoleType = await RoleModel.findOne({ 'userInfo.uid': uid, serverId }).lean(lean);
return role;
}
public static async findByRoleId(roleId: string, lean = true) {
const role = await RoleModel.findOne({ roleId }).lean(lean);
const role: RoleType = await RoleModel.findOne({ roleId }).lean(lean);
return role;
}
@@ -176,7 +177,7 @@ export default class Role extends BaseModel {
if (!user) return null;
const doc = new RoleModel();
const update = Object.assign(doc.toJSON(), roleInfo, { userInfo: user, serverType: user.serverType, serverId });
const role = await RoleModel.findOneAndUpdate({ 'userInfo.uid': uid, serverId }, update, { upsert: true, new: true }).lean(lean);
const role: RoleType = await RoleModel.findOneAndUpdate({ 'userInfo.uid': uid, serverId }, update, { upsert: true, new: true }).lean(lean);
return role;
}
@@ -188,17 +189,18 @@ export default class Role extends BaseModel {
};
}
//.select('uid tel username')
const user = await RoleModel.find(searchObj).lean(lean);
const user: RoleType[] = await RoleModel.find(searchObj).lean(lean);
return user;
}
public static async setEventStatus(roleId: string, eventStatus: number, lean = true) {
await RoleModel.findOneAndUpdate({ roleId }, { eventStatus }, {new: true}).lean(lean);
let role: RoleType = await RoleModel.findOneAndUpdate({ roleId }, { eventStatus }, {new: true}).lean(lean);
return role;
}
public static async towerLvUp(roleId: string, lean = true) {
let role = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerLv: 1}, towerUpTime: new Date()}, {new: true}).lean(lean);
let role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerLv: 1}, towerUpTime: new Date()}, {new: true}).lean(lean);
return role;
}
@@ -207,7 +209,7 @@ export default class Role extends BaseModel {
const result = await RoleModel.findOne({roleId}).lean(lean);
const lastSpdUpTime = result?.lastSpdUpTime;
let role = null;
let role: RoleType;
if (!lastSpdUpTime || (shouldRefresh(lastSpdUpTime, curTime, HANG_UP_CONSTS.REFRESH_TIME, 1) && cnt <= HANG_UP_CONSTS.MAX_SPD_UP_CNT)) {
role = await RoleModel.findOneAndUpdate({roleId}, {hangUpSpdUpCnt: HANG_UP_CONSTS.MAX_SPD_UP_CNT - cnt, lastSpdUpTime: curTime}, {new: true}).lean(lean);
} else {
@@ -217,47 +219,47 @@ export default class Role extends BaseModel {
}
public static async increaseExpeditionPoint(roleId: string, point: number, lean = true) {
let role = await RoleModel.findOneAndUpdate({roleId}, {$inc: { expeditionPoint: point }}, {new: true}).lean(lean);
let role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: { expeditionPoint: point }}, {new: true}).lean(lean);
return role;
}
public static async levelup(roleId: string, lv: number, exp: number, lean = true) {
let role = await RoleModel.findOneAndUpdate({roleId}, {$set: { exp, lv }}, {new: true}).lean(lean);
let role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$set: { exp, lv }}, {new: true}).lean(lean);
return role;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await RoleModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await RoleModel.deleteMany({roleId});
return result;
}
public static async addCoin(roleId: string, cnt: number, lean = true) {
let result = await RoleModel.findOneAndUpdate({roleId}, { $inc: {coin: cnt} }, { "new": true, "upsert": true}).lean(lean);
let result: RoleType = await RoleModel.findOneAndUpdate({roleId}, { $inc: {coin: cnt} }, { "new": true, "upsert": true}).lean(lean);
return result;
}
public static async addGoldFree(roleId: string, cnt: number, lean = true) {
let result = await RoleModel.findOneAndUpdate({roleId}, { $inc: { gold: cnt, giftGold: cnt } }, { "new": true, "upsert": true}).lean(lean);
let result: RoleType = await RoleModel.findOneAndUpdate({roleId}, { $inc: { gold: cnt, giftGold: cnt } }, { "new": true, "upsert": true}).lean(lean);
return result;
}
public static async costCoin(roleId: string, cnt: number, lean = true) {
let result = await RoleModel.findOneAndUpdate({roleId, coin: {$gte: cnt}}, { $inc: { coin: -cnt } }, { "new": true}).lean(lean);
let result: RoleType = await RoleModel.findOneAndUpdate({roleId, coin: {$gte: cnt}}, { $inc: { coin: -cnt } }, { "new": true}).lean(lean);
return result;
}
public static async costGold(roleId: string, cnt: number, lean = true) {
let result = await RoleModel.findOneAndUpdate({roleId, gold: {$gte: cnt}}, { $inc: { gold: -cnt, totalCost: cnt } }, { "new": true}).lean(lean);
let result: RoleType = await RoleModel.findOneAndUpdate({roleId, gold: {$gte: cnt}}, { $inc: { gold: -cnt, totalCost: cnt } }, { "new": true}).lean(lean);
return result;
}
public static async pushWarStar(roleId: string, battleId: number, warType: number, star: number, lean = true) {
let result = await RoleModel.findOneAndUpdate({roleId}, { $addToSet: { warStar: {id: battleId, warType, star }} }, { "new": true, "upsert": true}).lean(lean);
let result: RoleType = await RoleModel.findOneAndUpdate({roleId}, { $addToSet: { warStar: {id: battleId, warType, star }} }, { "new": true, "upsert": true}).lean(lean);
return result;
}
public static async updateWarStar(roleId: string, battleId: number, star: number, lean = true) {
let result = await RoleModel.findOneAndUpdate(
let result: RoleType = await RoleModel.findOneAndUpdate(
{roleId, 'warStar.id': battleId},
{ $set: { 'warStar.$.star': star } },
{ "new": true, "upsert": true}
@@ -267,24 +269,24 @@ export default class Role extends BaseModel {
// 重置派遣次数
public static async resetTowerCnt(roleId: string, curTime: Date, lean = true) {
const role = await RoleModel.findOneAndUpdate({roleId}, {towerTaskCnt: 0, towerTaskRefTime: curTime, towerTaskReCnt: 0}, {new: true}).lean(lean);
const role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {towerTaskCnt: 0, towerTaskRefTime: curTime, towerTaskReCnt: 0}, {new: true}).lean(lean);
return role;
}
// 刷新派遣任务次数增长
public static async increaseTowerCnt(roleId: string, num: number, lean = true) {
const role = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerTaskCnt: num}}, {new: true}).lean(lean);
const role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerTaskCnt: num}}, {new: true}).lean(lean);
return role;
}
// 派遣任务增加刷新次数
public static async increaseTowerRefCnt(roleId: string, num: number, lean = true) {
const role = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerTaskReCnt: num}}, {new: true}).lean(lean);
const role: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$inc: {towerTaskReCnt: num}}, {new: true}).lean(lean);
return role;
}
// 刷新远征重置次数
public static async increaseExpeditionResetCnt(roleId: string, needRefresh: boolean, curTime: Date, lean = true) {
let role = null;
let role: RoleType;
if (needRefresh) {
role = await RoleModel.findOneAndUpdate({roleId}, {expeditionResetCnt: 1, expeditionResetRefTime: curTime}, {new: true}).lean(lean);
} else {
@@ -297,7 +299,7 @@ export default class Role extends BaseModel {
// 购买次数
public static async buyCnt(roleId: string, needRefresh: boolean, inc: number, curTime: Date, lean = true) { console.log('&*&*&*&*&')
let role = null;
let role: RoleType;
if (needRefresh) {
role = await RoleModel.findOneAndUpdate({roleId}, {dungeonCnt: 0, dungeonRefTime: curTime, dungeonBuyCnt: inc}, {new: true}).lean(lean);
} else {
@@ -308,7 +310,7 @@ export default class Role extends BaseModel {
// 增加次数
public static async increaseDungeonCnt(roleId: string, needRefresh: boolean, inc: number, curTime: Date, lean = true) {
let role = null;
let role: RoleType;
if (needRefresh) {
role = await RoleModel.findOneAndUpdate({roleId}, {dungeonCnt: inc, dungeonRefTime: curTime, dungeonBuyCnt: 0}, {new: true}).lean(lean);
} else {
@@ -324,7 +326,7 @@ export default class Role extends BaseModel {
sortBy['towerLv'] = -1;
sortBy['towerUpTime'] = 1;
}
const ranks = await RoleModel.find({serverId}).select(fields.join(' ')).sort(sortBy).limit(limit).skip((page - 1) * limit).lean(lean);
const ranks: RoleType[] = await RoleModel.find({serverId}).select(fields.join(' ')).sort(sortBy).limit(limit).skip((page - 1) * limit).lean(lean);
return ranks;
}
@@ -359,32 +361,36 @@ export default class Role extends BaseModel {
let topFiveCe = topFive.reduce((pre, cur) => {
return pre + cur.ce
}, 0);
await RoleModel.findOneAndUpdate({roleId}, { topFive, topFiveCe, $inc: {ce: distance} }).lean(lean);
role = await RoleModel.findOneAndUpdate({roleId}, { topFive, topFiveCe, $inc: {ce: distance} }).lean(lean);
return role;
}
// 保存秘境首通队伍
public static async saveDungeonHero(roleId: string, battleId: number, heroes: Array<number>, isSuccess: boolean) {
if(isSuccess) {
const role = await Role.findByRoleId(roleId);
let dungeonHeroes = role && role.dungeonHeroes;
let hasHero = dungeonHeroes&&dungeonHeroes.find(cur => cur.battleId == battleId);
if(!dungeonHeroes || !hasHero) {
await RoleModel.findOneAndUpdate({roleId}, {$push:{dungeonHeroes: {battleId, heroes}}})
}
let role = await Role.findByRoleId(roleId);
let dungeonHeroes = role && role.dungeonHeroes;
let hasHero = dungeonHeroes&&dungeonHeroes.find(cur => cur.battleId == battleId);
if(!dungeonHeroes || !hasHero) {
role = await RoleModel.findOneAndUpdate({roleId}, {$push:{dungeonHeroes: {battleId, heroes}}})
}
return role;
}
}
// 保存开启功能
public static async pushFuncs(roleId: string, funcs: Array<number>, lean = true) {
const recs = await RoleModel.findOneAndUpdate({roleId}, {$push: {funcs: {$each: funcs}}}, {new: true}).lean(lean);
const recs: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$push: {funcs: {$each: funcs}}}, {new: true}).lean(lean);
return recs
}
public static async updateRoleInfo(roleId: string, roleUpdate:roleUpdate, lean = true) {
delete roleUpdate._id;
let result = await RoleModel.findOneAndUpdate({roleId}, {$set:roleUpdate}).lean(lean);
return result||{};
let result: RoleType = await RoleModel.findOneAndUpdate({roleId}, {$set:roleUpdate}).lean(lean);
return result;
}
}
export const RoleModel = getModelForClass(Role);
export interface RoleType extends Pick<DocumentType<Role>, keyof Role>{};

10
shared/db/SearchRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
class SearchTask {
@prop({ required: true })
@@ -28,10 +28,12 @@ export default class SearchRecord extends BaseModel {
tasks: Array<SearchTask>;
public static async deleteAccount(roleId: string, lean = true) {
let result = await SearchRecordModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await SearchRecordModel.deleteMany({roleId});
return result;
}
}
export const SearchRecordModel = getModelForClass(SearchRecord);
export interface SearchRecordType extends Pick<DocumentType<SearchRecord>, keyof SearchRecord>{};

11
shared/db/Sms.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
const moment = require('moment');
/**
@@ -27,16 +27,17 @@ export default class Sms extends BaseModel {
countToday: number;
public static async findByTel(tel: string, lean = true) {
const sms = await smsModel.findOne({ tel }).lean(lean);
const sms: SmsType = await smsModel.findOne({ tel }).lean(lean);
return sms;
}
public static async updateByTel(tel: string, code: string, used: boolean, updateTime: Date, countToday: number, lean = true) {
await smsModel.findOneAndUpdate({ tel }, { code, used, updateTime, countToday }, { upsert: true }).lean(lean);
const sms: SmsType = await smsModel.findOneAndUpdate({ tel }, { code, used, updateTime, countToday }, { upsert: true }).lean(lean);
return sms;
}
public static async validateSms(tel: string, code: string, lean = true) {
const record = await smsModel.findOneAndUpdate({ tel, code, used: false }, { used: true }).lean(lean);
const record: SmsType = await smsModel.findOneAndUpdate({ tel, code, used: false }, { used: true }).lean(lean);
return !!record;
}
@@ -63,3 +64,5 @@ export default class Sms extends BaseModel {
}
export const smsModel = getModelForClass(Sms);
export interface SmsType extends Pick<DocumentType<Sms>, keyof Sms>{};

20
shared/db/TowerRecord.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
class WarStatus {
@prop({ required: true })
@@ -38,7 +38,7 @@ export default class TowerRecord extends BaseModel {
const update = Object.assign(recDoc.toJSON(), towerInfo );
const { roleId, lv } = towerInfo;
// console.log(JSON.stringify(towerInfo))
let rec = await TowerRecordModel.findOneAndUpdate({roleId, lv}, {$set: update}, {upsert: true, new: true}).lean(lean);
let rec: TowerRecordType = await TowerRecordModel.findOneAndUpdate({roleId, lv}, {$set: update}, {upsert: true, new: true}).lean(lean);
return rec;
}
@@ -54,7 +54,7 @@ export default class TowerRecord extends BaseModel {
public static async updateRecord(roleId: string, lv: number, battleCode: string, warId: number, heroes: Array<number>, inc: number, lean = true) {
let tower = await TowerRecordModel.findOne({roleId, lv, 'warStatus.warId': warId});
if(tower) {
const rec = await TowerRecordModel.findOneAndUpdate(
const rec: TowerRecordType = await TowerRecordModel.findOneAndUpdate(
{roleId, lv, 'warStatus.warId': warId},
{$set: {'warStatus.$.status': true, 'warStatus.$.battleCode': battleCode, passed: inc === 1 ? true : false}, $push: {heroes: {$each: heroes}}},
{new: true, upsert: true}
@@ -62,7 +62,7 @@ export default class TowerRecord extends BaseModel {
return rec;
} else {
let warStatus = [{warId, status: true,battleCode, passed: inc === 1 ? true : false}];
const rec = await TowerRecordModel.findOneAndUpdate(
const rec: TowerRecordType = await TowerRecordModel.findOneAndUpdate(
{roleId, lv},
{ $push: {heroes: {$each: heroes}, warStatus: {$each: warStatus}}},
{new: true, upsert: true}
@@ -73,12 +73,12 @@ export default class TowerRecord extends BaseModel {
public static async getRecordByLv(roleId: string, lv: number, lean = true) {
const rec = await TowerRecordModel.findOne({roleId, lv}).lean(lean);
const rec: TowerRecordType = await TowerRecordModel.findOne({roleId, lv}).lean(lean);
return rec;
}
public static async resetRecordByLv(roleId: string, lv: number, lean = true) {
const rec = await TowerRecordModel.findOneAndUpdate(
const rec: TowerRecordType = await TowerRecordModel.findOneAndUpdate(
{roleId, lv, passed: false},
{$set: {'warStatus.$[].status': false, 'warStatus.$[].battleCode': '', heroes: []}},
{new: true}).lean(lean);
@@ -86,10 +86,12 @@ export default class TowerRecord extends BaseModel {
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await TowerRecordModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await TowerRecordModel.deleteMany({roleId});
return result;
}
}
export const TowerRecordModel = getModelForClass(TowerRecord);
export interface TowerRecordType extends Pick<DocumentType<TowerRecord>, keyof TowerRecord>{};

32
shared/db/TowerTaskRec.ts
View File

@@ -1,5 +1,5 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
function genCodeTmp(len) {
const chars = '123456789ABCDEFGHJKLMNPQRSTWXYZabcdefghijklmnopqrstuvwxyz';
@@ -43,7 +43,7 @@ export default class TowerTaskRec extends BaseModel {
completeTime: Date; // 派遣结束时间
public static async getCurTasks(roleId: string, lean = true) {
const recs = await TowerTaskRecModel.find({roleId, refreshStatus: 1}).sort({createdAt: 1}).lean(lean);
const recs: TowerTaskRecType[] = await TowerTaskRecModel.find({roleId, refreshStatus: 1}).sort({createdAt: 1}).lean(lean);
return recs;
}
@@ -59,14 +59,14 @@ export default class TowerTaskRec extends BaseModel {
}
public static async getTasksByCode(batchCode: string, lean = true) {
const recs = await TowerTaskRecModel.find({batchCode}).lean(lean);
const recs: TowerTaskRecType[] = await TowerTaskRecModel.find({batchCode}).lean(lean);
return recs;
}
public static async sendHeroes(_roleId: string, batchCode: string, tasks: Array<{taskCode:string, heroes: Array<number>, completeTime: number}>, sendTime: Date, lean = true) {
let recs = new Array();
for (let {taskCode, heroes, completeTime} of tasks) {
const rec = await TowerTaskRecModel.findOneAndUpdate(
const rec: TowerTaskRecType = await TowerTaskRecModel.findOneAndUpdate(
{batchCode, taskCode: taskCode, refreshStatus: 1},
{heroes: heroes, status: 1, sendTime, completeTime: new Date(sendTime.getTime() + completeTime * 1000)},
{new: true}).lean(lean);
@@ -76,32 +76,34 @@ export default class TowerTaskRec extends BaseModel {
return recs;
}
public static async finishTask(batchCode: string, tasks: Array<string>, lean = true) {
const recs = await TowerTaskRecModel.updateMany({batchCode, taskCode: {$in:tasks}}, {status: 3, refreshStatus: -1}).lean(lean);
public static async finishTask(batchCode: string, tasks: Array<string>, _lean = true) {
const recs:{ok: number, n:number, nModified:number} = await TowerTaskRecModel.updateMany({batchCode, taskCode: {$in:tasks}}, {status: 3, refreshStatus: -1});
return recs;
}
// 将隐藏的任务显示出来 0=>1
public static async showTask(roleId: string, bactchCode: string, num: number, lean = true) {
const recs = await TowerTaskRecModel.updateMany({roleId, refreshStatus: 0}, {bactchCode, refreshStatus: 1}).sort({createdAt: 1}).limit(num).lean(lean);
public static async showTask(roleId: string, bactchCode: string, num: number, _lean = true) {
const recs:{ok: number, n:number, nModified:number} = await TowerTaskRecModel.updateMany({roleId, refreshStatus: 0}, {bactchCode, refreshStatus: 1}).sort({createdAt: 1}).limit(num);
return recs;
}
// 刷掉旧任务 1=>-1
public static async hideTask(roleId: string, taskIds: Array<string>, lean = true) {
public static async hideTask(roleId: string, taskIds: Array<string>, _lean = true) {
// console.log(refTime)
const recs = await TowerTaskRecModel.updateMany({roleId, taskCode: {$in: taskIds}, refreshStatus: 1}, {refreshStatus: -1}).lean(lean);
const recs:{ok: number, n:number, nModified:number} = await TowerTaskRecModel.updateMany({roleId, taskCode: {$in: taskIds}, refreshStatus: 1}, {refreshStatus: -1});
return recs;
}
public static async updateBatchCode(roleId: string, taskIds: Array<string>, batchCode: string, lean = true) {
const recs = await TowerTaskRecModel.updateMany({roleId, taskCode: {$in: taskIds}}, {batchCode}).lean(lean);
public static async updateBatchCode(roleId: string, taskIds: Array<string>, batchCode: string, _lean = true) {
const recs:{ok: number, n:number, nModified:number} = await TowerTaskRecModel.updateMany({roleId, taskCode: {$in: taskIds}}, {batchCode});
return recs;
}
public static async deleteAccount(roleId: string, lean = true) {
let result = await TowerTaskRecModel.deleteMany({roleId}).lean(lean);
return result||{};
public static async deleteAccount(roleId: string) {
let result = await TowerTaskRecModel.deleteMany({roleId});
return result;
}
}
export const TowerTaskRecModel = getModelForClass(TowerTaskRec);
export interface TowerTaskRecType extends Pick<DocumentType<TowerTaskRec>, keyof TowerTaskRec>{};

14
shared/db/User.ts
View File

@@ -1,7 +1,7 @@
import { COUNTER } from './../consts';
import { CounterModel } from './Counter';
import BaseModel from './BaseModel';
import { index, getModelForClass, prop } from '@typegoose/typegoose';
import { index, getModelForClass, prop, DocumentType } from '@typegoose/typegoose';
import { genCode } from '../pubUtils/util';
/**
@@ -68,7 +68,7 @@ export default class User extends BaseModel {
auth: number;
public static async updateToken(tel: string, token: string, platform: string, pkgName: string, serverType: string, lean = true) {
let user = await UserModel.findOne({ tel }).lean();
let user: UserType = await UserModel.findOne({ tel }).lean();
const curTime: Date = new Date();
let update = {};
if (!user) {
@@ -83,17 +83,17 @@ export default class User extends BaseModel {
}
public static async findUserByToken(token: string, lean = true) {
const user = await UserModel.findOne({ token }).select('uid token serverType auth').lean(lean);
const user: UserType = await UserModel.findOne({ token }).select('uid token serverType auth').lean(lean);
return user;
}
public static async findUserByTel(tel: string, lean = true) {
const user = await UserModel.findOne({ tel }).select('uid tel').lean(lean);
const user: UserType = await UserModel.findOne({ tel }).select('uid tel').lean(lean);
return user;
}
public static async findUserByUid(uid: number, lean = true) {
const user = await UserModel.findOne({ uid }).select('uid tel').lean(lean);
const user: UserType = await UserModel.findOne({ uid }).select('uid tel').lean(lean);
return user;
}
@@ -105,9 +105,11 @@ export default class User extends BaseModel {
$in: value
};
}
const user = await UserModel.find(searchObj).select('uid tel username').lean(lean);
const user: UserType[] = await UserModel.find(searchObj).select('uid tel username').lean(lean);
return user;
}
}
export const UserModel = getModelForClass(User);
export interface UserType extends Pick<DocumentType<User>, keyof User>{};

43
shared/db/generalField.ts Normal file
View File

@@ -0,0 +1,43 @@
import { prop } from '@typegoose/typegoose';
export class CeAttrData {
@prop({ required: true })
base?: number = 0;
@prop({ required: true })
ratioUp: number = 0;
@prop({ required: true })
fixUp: number = 0;
}
export class CeAttr {
@prop({ required: false })
hp?: CeAttrData;
@prop({ required: false })
atk?: CeAttrData;
@prop({ required: false })
matk?: CeAttrData;
@prop({ required: false })
def?: CeAttrData;
@prop({ required: false })
mdef?: CeAttrData;
@prop({ required: false })
agi?: CeAttrData;
@prop({ required: false })
luk?: CeAttrData;
@prop({ required: false })
hit?: CeAttrData;
@prop({ required: false })
cri?: CeAttrData;
@prop({ required: false })
flee?: CeAttrData;
@prop({ required: false })
antCri?: CeAttrData;
@prop({ required: false })
damageIncrease?: CeAttrData;
@prop({ required: false })
damageDecrease?: CeAttrData;
@prop({ required: false })
defIngnore?: CeAttrData;
@prop({ required: false })
bloodSuck?: CeAttrData;
}

2
shared/pubUtils/dictionary/DicFriendShipLevel.ts
View File

@@ -11,7 +11,7 @@ export interface DicFriendShipLevel {
readonly add: number;
}
const str = readJsonFile(FILENAME.DIC_FRIEND_SHIP);
const str = readJsonFile(FILENAME.DIC_FRIEND_SHIP_LEVEL);
let arr = JSON.parse(str);
export const dicFriendShipLevel = new Array<DicFriendShipLevel>();

2
shared/pubUtils/gamedata.ts
View File

@@ -321,7 +321,7 @@ function parseFiendShipLevelMaps() {
const file = 'dic_zyz_friend_ship_level';
const data = gamedata['jsons'][file] || [];
data.forEach(elem => {
if (elem && elem.id) {
if (elem && elem.level) {
fiendShipLevelMaps.set(elem.level, elem);
}
});

1
web-server/tsconfig.json
View File

@@ -19,6 +19,7 @@
"noFallthroughCasesInSwitch": true,
"skipLibCheck": true,
"skipDefaultLibCheck": true,
"strictNullChecks": false,
"inlineSourceMap": true,
"importHelpers": true,
"baseUrl": ".",