ZYZ/gm-server/app/service/Activity.ts

import { Service } from 'egg';
import { STATUS } from '@consts';
import { ActivityModel } from '@db/Activity';
import { ActivityGroupModel } from '@db/ActivityGroup';
import { ServerlistModel } from '@db/Serverlist';

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

    /**
     * 获得活动列表
     */
    public async getActivityList(page: number, pageSize: number, 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, 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()
                }
            }), total
        });
    }

    public async updateActivity(activityId: number | string, groupId: number, beginTime: number, endTime: number, type: number, data: string) {
        const { ctx } = this;
        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));
                });
            }
            
            const activities = await ActivityModel.addActivity(aids, groupId, beginTime ? new Date(beginTime) : undefined, endTime ? new Date(endTime) : undefined, type, data);
            return ctx.service.utils.resResult(STATUS.SUCCESS, {
                activity: activities
            })

        } catch (e) {
            return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
        }
    }
    
    public async deleteActivity(activityId: number) {
        const { ctx } = this;
        const result = await ActivityModel.deleteActivity(activityId);
        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()
                }
            }), total
        });
    }

    /**
     * 更新活动组
     */
    public async updateActivityGroupName(groupId: number, groupName: string) {
        const { ctx } = this;
        try {
            await ActivityGroupModel.updateGroupName(groupId, groupName);
        } catch(e) {
            return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
        }
        return ctx.service.utils.resResult(STATUS.SUCCESS)
    }

    /**
     * 选择活动组内的活动
     */
    public async saveActivitiesToGroup(groupId: number, activityIds: number[]) {
        const { ctx } = this;
        try {
            await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds);
    
        } catch(e) {
            return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
        }
        return ctx.service.utils.resResult(STATUS.SUCCESS)
    }

    /**
     * 将活动组添加入服务器内
     */
    public async saveGroupToServer(groupId: number, serverIds: number[]) {
        const { ctx } = this;
        try {
            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);
        } catch(e) {
            return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, e.stack);
        }
        return ctx.service.utils.resResult(STATUS.SUCCESS)
    }

    /**
     * 创建一个新组
     */
    public async createGroup() {
        const { ctx } = this;
        try {
            await ActivityGroupModel.createGroup();
        } catch(e) {
            return ctx.service.utils.resResult(STATUS.INTERNAL_ERR, null, 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, e.stack);
        }
        return ctx.service.utils.resResult(STATUS.SUCCESS)
    }
    
}