295 lines
13 KiB
TypeScript
295 lines
13 KiB
TypeScript
import { Service } from 'egg';
|
|
import { STATUS, ACTIVITY_TYPE } from '@consts';
|
|
import { ActivityModel } from '@db/Activity';
|
|
import { ActivityGroupModel } from '@db/ActivityGroup';
|
|
import { ServerlistModel } from '@db/Serverlist';
|
|
import { GMUserType } from '@db/GMUser';
|
|
import { SignInData } from '@domain/activityField/signInField';
|
|
import { ActivityGroupTypeModel } from '@db/ActivityGroupType';
|
|
import { ActivityTaskPointModel } from '@db/ActivityTaskPoint';
|
|
import { gameData } from '@pubUtils/data';
|
|
|
|
/**
|
|
* Test Service
|
|
*/
|
|
export default class Activity extends Service {
|
|
|
|
/**
|
|
* 获得活动列表
|
|
*/
|
|
public async getActivityList(page: number, pageSize: number, sortField: string, sortOrder: string, type: number = 0, groupId: number = 0, current: boolean = false, activityId: number = 0) {
|
|
const { ctx } = this;
|
|
// console.log('***', page, pageSize, type, groupId, current, activityId)
|
|
const list = await ActivityModel.findByCondition(page, pageSize, sortField, sortOrder, type, groupId, current, activityId);
|
|
const total = await ActivityModel.countByCondition(type, groupId, current, activityId);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
list: list.map(cur => {
|
|
return {
|
|
...cur, beginTime: cur.beginTime.getTime(), endTime: cur.endTime.getTime(), env: ctx.app.config.realEnv
|
|
}
|
|
}), total
|
|
});
|
|
}
|
|
|
|
public async getAllActivities() {
|
|
const { ctx } = this;
|
|
let list = await ActivityModel.findAllActivities();
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { list });
|
|
}
|
|
|
|
public async getAllActivityGroups() {
|
|
const { ctx } = this;
|
|
let list = await ActivityGroupModel.findAllActivityGroups();
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, { list });
|
|
}
|
|
|
|
public async getAllActivityGroupTypes() {
|
|
const { ctx } = this;
|
|
// console.log('***', page, pageSize, type, serverId, current, activityId)
|
|
const list = await ActivityGroupTypeModel.findAllActivityGroupTypes();
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
list
|
|
});
|
|
}
|
|
|
|
public async checkActivityEditable(activityId: number) {
|
|
let now = new Date();
|
|
let activity = await ActivityModel.findActivity(activityId);
|
|
|
|
if(!activity || (activity.beginTime < now && activity.endTime > now)) {
|
|
|
|
if(activity.type == ACTIVITY_TYPE.SIGN_IN || activity.type == ACTIVITY_TYPE.SIGN_IN_VIP) {
|
|
// 签到活动的不显示期内也可以编辑
|
|
let signInObj = new SignInData(activity, 0);
|
|
if(signInObj.beginTime < now.getTime() && signInObj.endTime > now.getTime() ) {
|
|
return this.ctx.service.utils.resResult(STATUS.GM_CAN_NOT_EDIT_ACT);
|
|
}
|
|
} else {
|
|
return this.ctx.service.utils.resResult(STATUS.GM_CAN_NOT_EDIT_ACT);
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
private async checkActivityGroupType(groupId: number, aids: number[], ctx) {
|
|
|
|
let activityGroup = await ActivityGroupModel.findGroupData(groupId);
|
|
if(!activityGroup) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_NOT_FOUND);
|
|
if(activityGroup.type != 0) {
|
|
let activityGroupType = await ActivityGroupTypeModel.findByGroupType(activityGroup.type);
|
|
if(!activityGroupType) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
|
|
let dic = activityGroupType.activityTypes;
|
|
let activities = await ActivityModel.findActivityByIds(aids);
|
|
for(let { type } of activities) {
|
|
let index = dic.findIndex(cur => cur.activityType == type);
|
|
if(index == -1) {
|
|
return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE);
|
|
} else {
|
|
dic.splice(index, 1);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
public async updateActivity(activityId: number | string, groupId: number, beginTime: number, endTime: number, type: number, data: string) {
|
|
const { ctx } = this;
|
|
let gmuser: GMUserType = ctx.user;
|
|
if (!type || !data) {
|
|
return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
}
|
|
try {
|
|
let result = JSON.parse(data);
|
|
ctx.service.utils.checkActivityData(result, type);
|
|
let aids: number[] = [];
|
|
if (typeof activityId == 'number') {
|
|
aids.push(activityId);
|
|
} else {
|
|
activityId.split(',').forEach(aidStr => {
|
|
aids.push(parseInt(aidStr));
|
|
});
|
|
}
|
|
|
|
let checkResult = await this.checkActivityGroupType(groupId, aids, ctx);
|
|
if(checkResult) return checkResult;
|
|
|
|
let activities = await ActivityModel.addActivity(aids, groupId, beginTime ? new Date(beginTime) : undefined, endTime ? new Date(endTime) : undefined, type, data, gmuser.uid);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
activity: activities
|
|
})
|
|
|
|
} catch (e) {
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
|
|
}
|
|
}
|
|
|
|
public async deleteActivity(activityId: number) {
|
|
const { ctx } = this;
|
|
const result = await ActivityModel.deleteActivity(activityId, ctx.user?.uid);
|
|
if (result) {
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
} else {
|
|
return ctx.service.utils.resResult(STATUS.ACTIVITY_MISSING);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* 获得活动组列表
|
|
*/
|
|
public async getActivityGroupList(page: number, pageSize: number, serverId: number = 0, current: boolean = false, groupId: number = 0) {
|
|
const { ctx } = this;
|
|
// console.log('***', page, pageSize, type, serverId, current, activityId)
|
|
const list = await ActivityGroupModel.findByCondition(page, pageSize, serverId, current, groupId);
|
|
const total = await ActivityGroupModel.countByCondition(serverId, current, groupId);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
list: list.map(cur => {
|
|
return {
|
|
...cur, beginTime: cur.beginTime?.getTime(), endTime: cur.endTime?.getTime(), env: ctx.app.config.realEnv
|
|
}
|
|
}), total
|
|
});
|
|
}
|
|
|
|
/**
|
|
* 更新活动组
|
|
*/
|
|
public async updateActivityGroup(groupId: number, groupName: string, activityIds: number[], serverIds: number[], type: number) {
|
|
const { ctx } = this;
|
|
try {
|
|
let groupTypeObj = await ActivityGroupTypeModel.findByGroupType(type);
|
|
if(!groupTypeObj) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
|
|
|
|
await ActivityGroupModel.updateGroup(groupId, {groupName, type}, ctx.user?.uid);
|
|
|
|
// 更新activities
|
|
let checkResult = await this.checkActivityGroupType(groupId, activityIds, ctx);
|
|
if(checkResult) return checkResult;
|
|
await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds, ctx.user?.uid);
|
|
|
|
// 封信servers
|
|
await ServerlistModel.pullByGroupId(groupId);
|
|
let servers = await ServerlistModel.findServerByIds(serverIds);
|
|
for(let server of servers) {
|
|
let pushArr: number[] = [], pullArr: number[] = [];
|
|
let activityGroupId = server.activityGroupId||[];
|
|
if(!activityGroupId.includes(groupId)) {
|
|
pushArr.push(groupId);
|
|
}
|
|
await ServerlistModel.updateActivityGroup(server._id, pushArr, pullArr);
|
|
}
|
|
await ActivityGroupModel.updateServerData(groupId, serverIds, ctx.user?.uid);
|
|
|
|
} catch(e) {
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
|
|
}
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS)
|
|
}
|
|
|
|
/**
|
|
* 创建一个新组
|
|
*/
|
|
public async createGroup() {
|
|
const { ctx } = this;
|
|
try {
|
|
await ActivityGroupModel.createGroup(ctx.user?.uid);
|
|
} catch(e) {
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
|
|
}
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS)
|
|
}
|
|
|
|
public async deleteGroup(groupId: number) {
|
|
const { ctx } = this;
|
|
try {
|
|
let group = await ActivityGroupModel.findGroupData(groupId);
|
|
if(group) {
|
|
if(group.serverIds.length > 0 || group.activities.length > 0) {
|
|
return ctx.service.utils.resResult(STATUS.GM_CAN_NOT_DEL_ACT_GROUP);
|
|
}
|
|
await ActivityGroupModel.deleteGroup(groupId);
|
|
}
|
|
} catch(e) {
|
|
return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, (<Error>e).stack);
|
|
}
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS)
|
|
}
|
|
|
|
/**
|
|
* 获得活动组类型列表
|
|
*/
|
|
public async getActivityGroupTypeList(page: number, pageSize: number, sortField: string, sortOrder: string, groupType: number, groupTypeName: string) {
|
|
const { ctx } = this;
|
|
// console.log('***', page, pageSize, type, serverId, current, activityId)
|
|
const list = await ActivityGroupTypeModel.findByCondition(page, pageSize, sortField, sortOrder, { groupType, groupTypeName });
|
|
const total = await ActivityGroupTypeModel.countByCondition({ groupType, groupTypeName });
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
list, total
|
|
});
|
|
}
|
|
|
|
public async updateActivityGroupType(groupType: number|string, groupTypeName: string, activityTypes: number[]) {
|
|
const { ctx } = this;
|
|
let result;
|
|
if(groupType == 'new') {
|
|
result = await ActivityGroupTypeModel.createActivityGroupType(groupTypeName, activityTypes);
|
|
} else if (typeof groupType == 'number') {
|
|
result = await ActivityGroupTypeModel.updateActivityGroupType(groupType, groupTypeName, activityTypes);
|
|
}
|
|
if(!result) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
public async deleteActivityGroupType(groupType: number) {
|
|
const { ctx } = this;
|
|
await ActivityGroupTypeModel.deleteActivityGroupType(groupType);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
public async getGroupDataById(groupId: number) {
|
|
const { ctx } = this;
|
|
let activityGroup = await ActivityGroupModel.findGroupData(groupId);
|
|
if(!activityGroup) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_NOT_FOUND);
|
|
let { type, activities: activityIds = [] } = activityGroup;
|
|
let activities = await ActivityModel.findActivityByIds(activityIds);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
data: { groupId, groupType: type, activities }
|
|
});
|
|
}
|
|
|
|
public async getActivityTaskPoint(page: number, pageSize: number, sortField: string, sortOrder: string, form: {taskType?: number, taskId?: number, activityId?: number}) {
|
|
const { ctx } = this;
|
|
const list = await ActivityTaskPointModel.findByCondition(page, pageSize, sortField, sortOrder, form);
|
|
const total = await ActivityTaskPointModel.countByCondition(form);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS, {
|
|
list, total
|
|
});
|
|
}
|
|
|
|
public async createTaskToActivity(taskType: number, activityId: number) {
|
|
const { ctx } = this;
|
|
let dicTask = gameData.tasks.get(taskType);
|
|
if(!dicTask) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
|
|
for(let [id, dic] of dicTask) {
|
|
await ActivityTaskPointModel.createDataIfNotExist(taskType, id, activityId, dic['point']||0, ctx.user?.uid);
|
|
}
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
public async updateActivityTaskPoint(taskType: number, taskId: number, activityId: number, point: number) {
|
|
const { ctx } = this;
|
|
let result = await ActivityTaskPointModel.updateData(taskType, taskId, activityId, point, ctx.user?.uid);
|
|
if(!result) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
|
|
public async delActivityTaskPoint(taskType: number, taskId: number, activityId: number) {
|
|
const { ctx } = this;
|
|
|
|
await ActivityTaskPointModel.deleteData(taskType, taskId, activityId);
|
|
return ctx.service.utils.resResult(STATUS.SUCCESS);
|
|
}
|
|
}
|