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

后台：修改更新活动

Browse Source
This commit is contained in:
luying
2022-07-30 17:21:31 +08:00
parent f38c8b0fc8
commit 347c2ce7ed
10 changed files with 207 additions and 185 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
game-server/app/servers/gm/handler/gmHandler.ts
View File

@@ -2,14 +2,10 @@ import { Application, BackendSession, pinus } from 'pinus';
import { getRandSingleEelm, resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts/statusCode';
import { GMMailModel, GMMailType } from '../../../db/GMMail';
import { delGuildActivityRank } from '../../../services/redisService';
import { ACTIVITY_TYPE, GM_MAIL_STATUS, GM_MAIL_TYPE, MAIL_TIME_TYPE, PUSH_ROUTE, SURVEY_SELECT } from '../../../consts';
import { checkActivityEditable, checkActivityGroupType, checkActivityGroupTypeWithId } from '../../../services/activity/activityService';
import { ActivityModel } from '../../../db/Activity';
import { ActivityGroupModel } from '../../../db/ActivityGroup';
import { ActivityGroupTypeModel } from '../../../db/ActivityGroupType';
import { GuildActivityCityModel } from '../../../db/GuildActivityCity';
import { GuildActivityRecordModel } from '../../../db/GuildActivityRec';
import { getTimeFunM, nowSeconds } from '../../../pubUtils/timeUtil';
import moment = require('moment');
import { sendUngotDividend } from '../../../services/auctionService';
@@ -20,7 +16,6 @@ import { SurveyModel, SurveyUpdate } from '../../../db/Survery';
import { getSurvey } from '../../../services/gmService';
import { sendMessageToAllWithSuc } from '../../../services/pushService';
import { sendMailByContent, sendMailsByGmMail } from '../../../services/mailService';
import { GuildActivityCityDeclareModel } from '../../../db/GuildActivityCityDeclare';
let timer: NodeJS.Timer;
export default function (app: Application) {
return new GmHandler(app);
@@ -122,35 +117,17 @@ export class GmHandler {
}
}
async updateActivity(msg: { activityId: number|string, groupId: number, beginTime: number, endTime: number, type: number, data: string, timeType: number, days: number, delayDay: number, interval: number, name: string, hideDayByServer: number, effectDay: number }, session: BackendSession) {
const { activityId, groupId, beginTime, endTime, type, data, timeType = 3, days = 0, delayDay = 0, interval = 0, name = '', hideDayByServer = 0, effectDay = 0 } = msg;
const uid = session.get('uid');
if (!type || !data) {
return resResult(STATUS.WRONG_PARMS);
}
let aids: number[] = [];
if (typeof activityId == 'number') {
aids.push(activityId);
} else {
activityId.split(',').forEach(aidStr => {
aids.push(parseInt(aidStr));
});
}
async updateActivity(msg: { aids: number[] }, session: BackendSession) {
let { aids }= msg;
let activities = await ActivityModel.findActivityByIds(aids);
// let checkTimeResult = await checkActivityEditable(activities);
// if(!checkTimeResult) return resResult(STATUS.GM_CAN_NOT_EDIT_ACT);
let checkGroup = await checkActivityGroupTypeWithId(groupId, activities);
if(!checkGroup) return resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE);
activities = await ActivityModel.addActivity(aids, groupId, beginTime ? new Date(beginTime) : undefined, endTime ? new Date(endTime) : undefined, type, data, timeType, days, delayDay, interval, name, hideDayByServer, effectDay, uid);
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.updateActivities.toServer(server.id, activities.map(activity => new ActivityInRemote(activity)));
}
if(type == ACTIVITY_TYPE.TIME_LIMIT_RANK) {
pinus.app.rpc.systimer.systimerRemote.updateTimeLimitRank.broadcast(activities);
let timeLimitRanks = activities.filter(cur => cur.type == ACTIVITY_TYPE.TIME_LIMIT_RANK);
if(timeLimitRanks.length > 0) {
pinus.app.rpc.systimer.systimerRemote.updateTimeLimitRank.broadcast(timeLimitRanks);
}
return resResult(STATUS.SUCCESS, {
@@ -158,31 +135,8 @@ export class GmHandler {
});
}
async switchActivity(msg: { activityId: number, isEnable: boolean }, session: BackendSession) {
const { activityId, isEnable } = msg;
const uid = session.get('uid');
let activity = await ActivityModel.findActivity(activityId);
if(!activity) return resResult(STATUS.WRONG_PARMS);
activity = await ActivityModel.setEnable(activityId, isEnable, uid);
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.updateActivities.toServer(server.id, [new ActivityInRemote(activity)]);
}
return resResult(STATUS.SUCCESS, { activity });
}
async deleteActivity(msg: { activityId: number}, session: BackendSession) {
const { activityId } = msg;
const uid = session.get('uid');
const result = await ActivityModel.deleteActivity(activityId, uid);
if (!result) {
return resResult(STATUS.ACTIVITY_MISSING);
}
await ActivityGroupModel.pullByActivityIds([activityId]);
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.deleteActivities.toServer(server.id, [activityId]);
@@ -191,97 +145,17 @@ export class GmHandler {
return resResult(STATUS.SUCCESS);
}
async updateActivityGroup(msg: { groupId: number, groupName: string, serverIds: number[], activities: number[], type: number }, session: BackendSession) {
async updateActivityGroup(msg: { groupId: number, serverIds: number[], activityIds: number[] }, session: BackendSession) {
const uid = session.get('uid');
let { groupId, groupName, serverIds, activities, type } = msg;
let groupTypeObj = await ActivityGroupTypeModel.findByGroupType(type);
if(!groupTypeObj) return resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
{
let result = await this.saveActivitiesToGroup(groupId, type, activities, uid);
if(result.code != 0) return result;
}
{
let result = await this.saveGroupToServer(groupId, serverIds, uid);
if(result.code != 0) return result;
}
await ActivityGroupModel.updateGroup(groupId, {groupName, type}, uid);
return resResult(STATUS.SUCCESS);
}
async saveGroupToServer(groupId: number, serverIds: number[], uid: number) {
// 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, uid);
let { groupId, serverIds, activityIds } = msg;
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.toServer(server.id, groupId, activityIds);
pinus.app.rpc.activity.activityRemote.saveGroupToServer.toServer(server.id, groupId, serverIds);
}
return resResult(STATUS.SUCCESS);
}
/**
* 选择活动组内的活动
*/
async saveActivitiesToGroup(groupId: number, groupType: number, activityIds: number[], uid: number) {
let activities = await ActivityModel.findActivityByIds(activityIds);
let checkResult = await checkActivityGroupType(groupType, activities);
if(!checkResult) return resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE);
await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds, uid);
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.toServer(server.id, groupId, activityIds);
}
return resResult(STATUS.SUCCESS);
}
async saveSingleActivityToGroup(msg: { groupId: number, index: number, activityId: number }, session: BackendSession) {
const { groupId, index, activityId } = msg;
const uid = session.get('uid');
let activity = await ActivityModel.findActivity(activityId);
if(!activity) return resResult(STATUS.ACTIVITY_MISSING);
let checkResult = await checkActivityGroupTypeWithId(groupId, [activity]);
if(checkResult) return checkResult;
let activityGroup = await ActivityGroupModel.findGroupData(groupId);
if(!activityGroup) return resResult(STATUS.GM_ACTIVITY_GROUP_NOT_FOUND);
if(activityGroup.type != 0) {
let activityGroupType = await ActivityGroupTypeModel.findByGroupType(activityGroup.type);
if(!activityGroupType) return resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
let dic = activityGroupType.activityTypes;
let curDic = dic.find(cur => cur.index == index);
// console.log(dic, curDic)
if(curDic.activityType != activity.type) return resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE)
}
let activityIds = activityGroup.activities||[];
if(activityIds.indexOf(activityId) == -1) activityIds.push(activityId);
await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds, uid);
let activityServers = pinus.app.getServersByType('activity');
for(let server of activityServers) {
pinus.app.rpc.activity.activityRemote.saveActivitiesToGroup.toServer(server.id, groupId, activityIds);
}
return resResult(STATUS.SUCCESS)
}
/**
* 开启军团活动到拍卖行debug
* @param msg

36
game-server/app/services/activity/activityService.ts
View File

@@ -44,6 +44,7 @@ import { sendMessageToGuildWithSuc, sendMessageToUserWithSuc } from '../pushServ
import { UserOrderModelType } from '../../db/UserOrder';
import { isArray } from 'underscore';
import { getGuideGachaData } from './gachaService';
import { getPopNoticeData } from './popNoticeService';
/**
* 获取活动数据
@@ -222,6 +223,11 @@ export async function getActivity(serverId: number, roleId: string, guildCode: s
}
case ACTIVITY_TYPE.SHOP:
break
case ACTIVITY_TYPE.POP_NOTICE:
{
activityData = await getPopNoticeData(serverId, activityId, roleId);
break
}
default: {
console.log('未知活动类型.........', activityType)
break;
@@ -358,35 +364,6 @@ export async function checkActivityEditable(activities: ActivityModelType[]) {
return true;
}
export async function checkActivityGroupTypeWithId(groupId: number, activities: ActivityModelType[]) {
let activityGroup = await ActivityGroupModel.findGroupData(groupId);
if(!activityGroup) return false;
if(activityGroup.type != 0) {
return await checkActivityGroupType(activityGroup.type, activities);
}
return true
}
export async function checkActivityGroupType(groupType: number, activities: ActivityModelType[]) {
if(groupType != 0) {
let activityGroupType = await ActivityGroupTypeModel.findByGroupType(groupType);
if(!activityGroupType) return false;
let dic = activityGroupType.activityTypes;
for(let { type } of activities) {
let index = dic.findIndex(cur => cur.activityType == type);
if(index == -1) {
return false;
}
}
}
return true
}
/**
* 达成任务可活动活动积分
* @param type 任务类型，主线、每日、成就
@@ -401,7 +378,6 @@ export async function addActvityTaskPoint(type: number, id: number, session: Bac
let activityTaskPoint = await ActivityTaskPointModel.findData(type, id);
let result: pushActivityInter[] = [];
for (let { activityId, activityType, point } of activityTaskPoint) {
console.log('##### activityTaskPoint:', activityId, activityType, point)
if(activityType == ACTIVITY_TYPE.NEW_HERO_GIFTS) { // 新武将活动
let totalPoint = await newHeroGiftPoint(serverId, activityId, roleId, point);
result.push({ activityId, activityType, param: { totalPoint } });

6
game-server/app/services/checkParam.ts
View File

@@ -858,10 +858,10 @@ export function checkRouteParam(route: string, msg: any) {
}
case "gm.gmHandler.updateActivityGroup":
{
let { groupId, groupName, serverIds, activities, type } = msg;
if(!checkNaturalNumbers(groupId, type)) return false;
let { groupId, groupName, serverIds, activityIds, groupType } = msg;
if(!checkNaturalNumbers(groupId, groupType)) return false;
if(!checkNaturalStrings(groupName)) return false;
if(!checkNumberArray(serverIds, activities)) return false;
if(!checkNumberArray(serverIds, activityIds)) return false;
break;
}
case "gm.gmHandler.saveSingleActivityToGroup":

29
gm-server/app/controller/activity.ts
View File

@@ -1,3 +1,4 @@
import { UpdateActivityParam } from '@domain/backEndField/params';
import { Controller } from 'egg';
export default class ActivityController extends Controller {
@@ -100,4 +101,32 @@ export default class ActivityController extends Controller {
return
}
public async updateActivity() {
const { ctx } = this;
const obj = ctx.request.body;
let param = new UpdateActivityParam(obj);
ctx.body = await ctx.service.activity.updateActivity(param);
return
}
public async switchActivity() {
const { ctx } = this;
const { activityId, isEnable } = ctx.request.body;
ctx.body = await ctx.service.activity.switchActivity(activityId, isEnable);
return
}
public async deleteActivity() {
const { ctx } = this;
const { activityId } = ctx.request.body;
ctx.body = await ctx.service.activity.deleteActivity(activityId);
return
}
public async updateActivityGroup() {
const { ctx } = this;
const { groupId, groupName, serverIds, activityIds, groupType } = ctx.request.body;
ctx.body = await ctx.service.activity.updateActivityGroup(groupId, groupName, serverIds, activityIds, groupType);
return
}
}

4
gm-server/app/router.ts
View File

@@ -72,6 +72,10 @@ export default (app: Application) => {
router.post('/api/activity/getallactivities', tokenParser, controller.activity.getAllActivities);
router.post('/api/activity/getactivitygrouplist', tokenParser, controller.activity.getActivityGroupList);
router.post('/api/activity/getallactivitygroups', tokenParser, controller.activity.getAllActivityGroups);
router.post('/api/activity/updateactivity', controller.activity.updateActivity);
router.post('/api/activity/switchactivity', controller.activity.switchActivity);
router.post('/api/activity/deleteactivity', controller.activity.deleteActivity);
router.post('/api/activity/updategroup', controller.activity.updateActivityGroup);
router.post('/api/activity/creategroup', tokenParser, controller.activity.createGroup);
router.post('/api/activity/deletegroup', tokenParser, controller.activity.deleteGroup);
router.post('/api/activity/getactivitygrouptypelist', tokenParser, controller.activity.getActivityGroupTypeList);

84
gm-server/app/service/Activity.ts
View File

@@ -1,11 +1,12 @@
import { Service } from 'egg';
import { STATUS, ACTIVITY_TYPE } from '@consts';
import { ActivityModel } from '@db/Activity';
import { ActivityModel, ActivityModelType } from '@db/Activity';
import { ActivityGroupModel } from '@db/ActivityGroup';
import { SignInData } from '@domain/activityField/signInField';
import { ActivityGroupTypeModel } from '@db/ActivityGroupType';
import { ActivityTaskPointModel } from '@db/ActivityTaskPoint';
import { gameData } from '@pubUtils/data';
import { UpdateActivityParam } from '@domain/backEndField/params';
/**
* Test Service
@@ -129,7 +130,7 @@ export default class Activity extends Service {
});
}
public async updateActivityGroupType(groupType: number|string, groupTypeName: string, activityTypes: number[]) {
public async updateActivityGroupType(groupType: number|string, groupTypeName: string, activityTypes: number[] = []) {
const { ctx } = this;
let result;
if(groupType == 'new') {
@@ -189,4 +190,83 @@ export default class Activity extends Service {
await ActivityTaskPointModel.deleteData(taskType, taskId, activityId);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
public async updateActivity(data: UpdateActivityParam) {
const { ctx } = this;
if(!data.checkParams()) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
let activities = await ActivityModel.findActivityByIds(data.activityIds);
// let checkTimeResult = await checkActivityEditable(activities);
// if(!checkTimeResult) return resResult(STATUS.GM_CAN_NOT_EDIT_ACT);
let checkGroup = await this.checkActivityGroupTypeWithId(data.groupId, activities);
if(!checkGroup) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE);
activities = await ActivityModel.updateActivity(data.activityIds, data, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS, { aids: activities.map(cur => cur.activityId) });
}
public async switchActivity(aid: number, isEnable: boolean) {
const { ctx } = this;
let activity = await ActivityModel.findActivity(aid);
if(!activity) return ctx.service.utils.resResult(STATUS.WRONG_PARMS);
activity = await ActivityModel.setEnable(aid, isEnable, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS, { aids: [activity.activityId]});
}
public async deleteActivity(aid: number) {
const { ctx } = this;
const result = await ActivityModel.deleteActivity(aid, ctx.user?.uid);
if (!result) {
return ctx.service.utils.resResult(STATUS.ACTIVITY_MISSING);
}
await ActivityGroupModel.pullByActivityIds([aid]);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
public async updateActivityGroup(groupId: number, groupName: string, serverIds: number[], activityIds: number[], groupType: number) {
const { ctx } = this;
let groupTypeObj = await ActivityGroupTypeModel.findByGroupType(groupType);
if(!groupTypeObj) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_GROUP_TYPE_NOT_FOUND);
let activities = await ActivityModel.findActivityByIds(activityIds);
let checkResult = await this.checkActivityGroupType(groupType, activities);
if(!checkResult) return ctx.service.utils.resResult(STATUS.GM_ACTIVITY_NOT_FIT_GROUP_TYPE);
await ActivityGroupModel.setActivitiesToGroupData(groupId, activityIds, ctx.user?.uid);
await ActivityGroupModel.updateServerData(groupId, serverIds, ctx.user?.uid);
await ActivityGroupModel.updateGroup(groupId, {groupName, type: groupType}, ctx.user?.uid);
return ctx.service.utils.resResult(STATUS.SUCCESS);
}
private async checkActivityGroupTypeWithId(groupId: number, activities: ActivityModelType[]) {
let activityGroup = await ActivityGroupModel.findGroupData(groupId);
if(!activityGroup) return false;
if(activityGroup.type != 0) {
return await this.checkActivityGroupType(activityGroup.type, activities);
}
return true
}
private async checkActivityGroupType(groupType: number, activities: ActivityModelType[]) {
if(groupType != 0) {
let activityGroupType = await ActivityGroupTypeModel.findByGroupType(groupType);
if(!activityGroupType) return false;
let dic = activityGroupType.activityTypes;
for(let { type } of activities) {
let index = dic.findIndex(cur => cur.activityType == type);
if(index == -1) {
return false;
}
}
}
return true
}
}

23
shared/db/Activity.ts
View File

@@ -1,8 +1,9 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, ReturnModelType, mongoose } from '@typegoose/typegoose';
import { CounterModel } from './Counter';
import { CounterAllModal } from './CounterAll';
import { COUNTER } from '../consts';
import { ActivityGroupModel } from './ActivityGroup';
import { UpdateActivityParam } from '../domain/backEndField/params';
/**
* 活动系统
@@ -90,25 +91,25 @@ export default class Activity extends BaseModel {
}
//新增活动
public static async addActivity(aids: number[], groupId: number, beginTime: Date, endTime: Date, type: number, data: string, timeType: number, days: number, delayDay: number, interval: number, name: string, hideDayByServer: number, effectDay: number, uid = 1) {
public static async updateActivity(aids: number[], param: UpdateActivityParam, uid = 1) {
let result: ActivityModelType[] = [];
let newAids = [];
for (let activityId of aids) {
if (!activityId) activityId = await CounterModel.getNewCounter(COUNTER.ACTIVITY);
if (!activityId) activityId = await CounterAllModal.getNewCounter(COUNTER.ACTIVITY);
newAids.push(activityId);
let update = { type, data, timeType, days, delayDay, interval, groupId, name, hideDayByServer, effectDay }
if (beginTime != undefined) {
update["beginTime"] = beginTime;
if (!param.beginTime) {
delete param["beginTime"];
}
if (endTime != undefined) {
update["endTime"] = endTime;
if (!param.endTime) {
delete param["endTime"];
}
let rec: ActivityModelType = await ActivityModel.findOneAndUpdate({ activityId }, { $set: { ...update, updatedBy: uid }, $setOnInsert: { isEnable: true, createdBy: uid } },
let rec: ActivityModelType = await ActivityModel.findOneAndUpdate({ activityId }, { $set: { ...param, updatedBy: uid }, $setOnInsert: { isEnable: true, createdBy: uid } },
{ new: true, upsert: true }).lean(true);
result.push(rec);
}
if (groupId != undefined) {
if (groupId == 0) {
if (param.groupId != undefined) {
let groupId = param.groupId;
if (param.groupId == 0) {
let newGroup = await ActivityGroupModel.createGroup(uid);
groupId = newGroup.groupId;
}

4
shared/db/ActivityGroup.ts
View File

@@ -1,6 +1,6 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, ReturnModelType, mongoose } from '@typegoose/typegoose';
import { CounterModel } from './Counter';
import { CounterAllModal } from './CounterAll';
import { COUNTER } from '../consts';
import { ActivityModel } from './Activity';
@@ -28,7 +28,7 @@ export default class Activity_Group extends BaseModel {
//查询组
public static async createGroup(uid = 1) {
let groupId = await CounterModel.getNewCounter(COUNTER.ACTIVITY_GROUP);
let groupId = await CounterAllModal.getNewCounter(COUNTER.ACTIVITY_GROUP);
let result: ActivityGroupModelType = await ActivityGroupModel.findOneAndUpdate({ groupId }, {
$setOnInsert: { groupName: `活动组${groupId}`, activities: [], serverIds: [], createdBy: uid, type: 0 }, $set: { updatedBy: uid }

4
shared/db/ActivityGroupType.ts
View File

@@ -1,6 +1,6 @@
import BaseModel from './BaseModel';
import { index, getModelForClass, prop, DocumentType, ReturnModelType, mongoose } from '@typegoose/typegoose';
import { CounterModel } from './Counter';
import { CounterAllModal } from './CounterAll';
import { COUNTER, ACTIVITY_TYPE } from '../consts';
/**
@@ -42,7 +42,7 @@ export default class Activity_GroupType extends BaseModel {
let activityTypes = types.map((value, index) => {
return { index: index + 1, activityType: value };
});
let groupType = await CounterModel.getNewCounter(COUNTER.ACTIVITY_GROUP_TYPE);
let groupType = await CounterAllModal.getNewCounter(COUNTER.ACTIVITY_GROUP_TYPE);
let result: ActivityGroupTypeInter = await ActivityGroupTypeModel.findOneAndUpdate({ groupType }, {
$setOnInsert: { groupTypeName, activityTypes, createdBy: uid }, $set: { updatedBy: uid }

58
shared/domain/backEndField/params.ts
View File

@@ -4,6 +4,7 @@ import ServerStategy, { GMMail } from "../../db/ServerStategy";
import { RegionType } from "../../db/Region";
import { RewardInter } from "../../pubUtils/interface";
import { isTimestamp } from '../../pubUtils/util';
import { isDate } from "util";
export class UpdateMailParams {
hasGoods: boolean = false; // 是否有道具
@@ -336,4 +337,61 @@ export class SetHeroParam {
if(this.colorStar && !isNumber(this.colorStar)) return false;
return true;
}
}
export class UpdateActivityParam {
activityIds: number[] = [];
groupId: number = 0;
beginTime: Date;
endTime: Date;
type: number = 0;
data: string = '';
timeType: number = 0;
days: number = 0;
delayDay: number = 0;
interval: number = 0;
name: string = '';
hideDayByServer: number = 0;
effectDay: number = 0;
constructor(obj?: any) {
if(!obj) return;
if (typeof obj.activityId == 'number') {
this.activityIds.push(obj.activityId);
} else if (typeof obj.activityId == 'string'){
obj.activityId.split(',').forEach(aidStr => {
this.activityIds.push(parseInt(aidStr));
});
}
this.groupId = obj.groupId;
if(obj.beginTime) this.beginTime = new Date(obj.beginTime);
if(obj.endTime) this.endTime = new Date(obj.endTime);
this.type = obj.type;
this.data = obj.data;
this.timeType = obj.timeType;
this.days = obj.days;
this.delayDay = obj.delayDay;
this.interval = obj.interval;
this.name = obj.name;
this.hideDayByServer = obj.hideDayByServer;
this.effectDay = obj.effectDay;
}
checkParams() {
if(this.activityIds && this.activityIds.length && this.activityIds.find(activityId => !isNumber(activityId))) return false;
if(this.groupId && !isNumber(this.groupId)) return false;
if(this.beginTime && !isDate(this.beginTime)) return false;
if(this.endTime && !isDate(this.endTime)) return false;
if(this.type && !isNumber(this.type)) return false;
if(this.data && !isString(this.data)) return false;
if(this.timeType && !isNumber(this.timeType)) return false;
if(this.days && !isNumber(this.days)) return false;
if(this.delayDay && !isNumber(this.delayDay)) return false;
if(this.interval && !isNumber(this.interval)) return false;
if(this.name && !isString(this.name)) return false;
if(this.hideDayByServer && !isNumber(this.hideDayByServer)) return false;
if(this.effectDay && !isNumber(this.effectDay)) return false;
return true;
}
}