This commit is contained in:
xy
2026-03-13 01:38:40 +00:00
parent e6e4f88257
commit 28855885cd
311 changed files with 89544 additions and 94350 deletions
@@ -1,118 +1,119 @@
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ENCRYPT_IV, ENCRYPT_KEY, STATUS, TASK_TYPE } from '../../../consts';
import { ActivityGroupModel } from '../../../db/ActivityGroup';
import { getActivitiesWithOrder, getActivity, getActivityById, getActivityByServerId, shouldReplace } from '../../../services/activity/activityService';
import { ActivityModelType } from '../../../db/Activity';
import { UserOrderModel } from '../../../db/UserOrder';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityHandler(app);
}
export class ActivityHandler {
constructor(private app: Application) {
}
/**
* @description 活动是否开启总接口
* @param {{ }} msg
* @param {BackendSession} session
* @memberof ActivityHandler
*/
async getAllOpenActivity(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const uid: number = session.get('userid');
const sid: string = session.get('sid');
let originActivities = await getActivityByServerId(serverId);
let maxIdByType = new Map<number, number>(); // type => max
let activityById = new Map<number, any>(); // id => activity
for(let activity of originActivities) {
let playerActivityData = await getActivity(serverId, roleId, uid, guildCode, activity.activityId, activity.type);
if(!playerActivityData) continue;
let shouldPush = true;
if(shouldReplace(playerActivityData.type)) { // 该类型只能有一个id,选最大的那个
let max = maxIdByType.get(playerActivityData.type)||0;
if(playerActivityData.activityId > max) {
activityById.delete(max);
maxIdByType.set(playerActivityData.type, playerActivityData.activityId);
} else {
shouldPush = false;
}
}
if(shouldPush) activityById.set(activity.activityId, playerActivityData);
}
let groups = await ActivityGroupModel.findByServerId(serverId);
let playerGroupArray = [];
for (let groupData of groups) {
let playerGroupActivityArray = [];
for (let activityId of groupData.activities) {
let playerActivityData = activityById.get(activityId);
if(playerActivityData) {
playerGroupActivityArray.push(playerActivityData);
}
}
if(playerGroupActivityArray.length > 0)
playerGroupArray.push({
id: groupData.groupId,
type: groupData.type,
activities: playerGroupActivityArray
});
console.log(`${roleId} 活动合集 groupId:${groupData.groupId}, 合集类型${groupData.type}, 一共${playerGroupActivityArray.length}`)
}
return resResult(STATUS.SUCCESS, { playerActivityArray: [], playerGroupArray });
}
async getActivitiesByOrder(msg: { localOrderID: string }, session: BackendSession) {
const { localOrderID } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const uid = session.get('userid');
let orderInfo = await UserOrderModel.findOrder(localOrderID);
if (!orderInfo || orderInfo.roleId != roleId) {
return resResult(STATUS.NO_ORDER);
}
let activities: ActivityModelType[] = await getActivitiesWithOrder(orderInfo);
let result = [];
for(let activityData of activities) {
if (!activityData) continue;
let playerActivityData = await getActivity(serverId, roleId, uid, guildCode, activityData.activityId, activityData.type);
if(playerActivityData) {
result.push(playerActivityData);
}
}
return resResult(STATUS.SUCCESS, { activities: result });
}
async debugActivityMemory(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let activities = pinus.app.get('activities');
let activityByType = pinus.app.get('activityByType');
let activityByServer = pinus.app.get('activityByServer');
let groupToServer = pinus.app.get('groupToServer');
console.log('****** activities', activities);
console.log('****** activityByType', activityByType);
console.log('****** activityByServer', activityByServer);
console.log('****** groupToServer', groupToServer);
return resResult(STATUS.SUCCESS, { activities: [...activities], activityByType: [...activityByType], activityByServer: [...activityByServer], groupToServer: [...groupToServer] });
}
}
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ENCRYPT_IV, ENCRYPT_KEY, STATUS, TASK_TYPE } from '../../../consts';
import { ActivityGroupModel } from '@db/ActivityGroup';
import { getActivitiesWithOrder, getActivity, getActivityById, getActivityByServerId, shouldReplace } from '../../../services/activity/activityService';
import { ActivityModelType } from '@db/Activity';
import { UserOrderModel } from '@db/UserOrder';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityHandler(app);
}
export class ActivityHandler {
constructor(private app: Application) {
}
/**
* @description 活动是否开启总接口
* @param {{ }} msg
* @param {BackendSession} session
* @memberof ActivityHandler
*/
async getAllOpenActivity(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const uid: number = session.get('userid');
const sid: string = session.get('sid');
let originActivities = await getActivityByServerId(serverId);
let maxIdByType = new Map<number, number>(); // type => max
let activityById = new Map<number, any>(); // id => activity
for(let activity of originActivities) {
let playerActivityData = await getActivity(serverId, roleId, uid, guildCode, activity.activityId, activity.type);
if(!playerActivityData) continue;
let shouldPush = true;
if(shouldReplace(playerActivityData.type)) { // 该类型只能有一个id,选最大的那个
let max = maxIdByType.get(playerActivityData.type)||0;
if(playerActivityData.activityId > max) {
activityById.delete(max);
maxIdByType.set(playerActivityData.type, playerActivityData.activityId);
} else {
shouldPush = false;
}
}
if(shouldPush) activityById.set(activity.activityId, playerActivityData);
}
let groups = await ActivityGroupModel.findByServerId(serverId);
let playerGroupArray = [];
for (let groupData of groups) {
let playerGroupActivityArray = [];
for (let activityId of groupData.activities) {
let playerActivityData = activityById.get(activityId);
if(playerActivityData) {
playerGroupActivityArray.push(playerActivityData);
}
}
if(playerGroupActivityArray.length > 0)
playerGroupArray.push({
id: groupData.groupId,
type: groupData.type,
activities: playerGroupActivityArray
});
console.log(`${roleId} 活动合集 groupId:${groupData.groupId}, 合集类型${groupData.type}, 一共${playerGroupActivityArray.length}`)
}
return resResult(STATUS.SUCCESS, { playerActivityArray: [], playerGroupArray });
}
async getActivitiesByOrder(msg: { localOrderID: string }, session: BackendSession) {
const { localOrderID } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
const uid = session.get('userid');
let orderInfo = await UserOrderModel.findOrder(localOrderID);
if (!orderInfo || orderInfo.roleId != roleId) {
return resResult(STATUS.NO_ORDER);
}
let activities: ActivityModelType[] = await getActivitiesWithOrder(orderInfo);
let result = [];
for(let activityData of activities) {
if (!activityData) continue;
let playerActivityData = await getActivity(serverId, roleId, uid, guildCode, activityData.activityId, activityData.type);
if(playerActivityData) {
result.push(playerActivityData);
}
}
return resResult(STATUS.SUCCESS, { activities: result });
}
async debugActivityMemory(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let activities = pinus.app.get('activities');
let activityByType = pinus.app.get('activityByType');
let activityByServer = pinus.app.get('activityByServer');
let groupToServer = pinus.app.get('groupToServer');
console.log('****** activities', activities);
console.log('****** activityByType', activityByType);
console.log('****** activityByServer', activityByServer);
console.log('****** groupToServer', groupToServer);
return resResult(STATUS.SUCCESS, { activities: [...activities], activityByType: [...activityByType], activityByServer: [...activityByServer], groupToServer: [...groupToServer] });
}
}
@@ -1,251 +1,252 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { LAND_TYPE, STATUS, CURRENCY_TYPE, CURRENCY_BY_TYPE, BANK_TYPE, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { ActivityMonopolyModel, ActivityMonopolyModelType } from '../../../db/ActivityMonopoly';
import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '../../../db/ActivityMonopolyLand';
import { getPlayerMonopolyData, nextPosition } from '../../../services/activity/monopolyService';
import { random } from 'underscore';
import { handleCost } from '../../../services/role/rewardService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerRefreshShopDataByRoundIndex } from '../../../services/activity/refreshShopService';
import { ActivityRefreshShopModel } from '../../../db/ActivityRefreshShop';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityMonopolyHandler(app);
}
export class ActivityMonopolyHandler {
constructor(private app: Application) {
}
/**
* @description 获取大富翁活动数据
* @param {{activityId: number }} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async getMonopolyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 移动
* @param {{activityId: number }} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async move(msg: { activityId: number, step: number }, session: BackendSession) {
const { activityId, step } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
const roleName = session.get('roleName');
let moveStep = 0;
if (step >= 1 && step <= 6) {//指定,天机骰子
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.SPECIAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
moveStep = step;
} else {//普通骰子
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.NORMAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
moveStep = random(5) + 1;
}
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
let oldPosition = playerData.curPosition;
let newPosition = nextPosition(oldPosition, moveStep, playerData.list.length);
await ActivityMonopolyModel.updatePosition(serverId, activityId, roleId, newPosition, 1)
let landData = playerData.findMonopolyItem(newPosition);
let landReward = null;//土地奖励
let bankReward = null;//银行奖励
if (landData && landData.landType == LAND_TYPE.BANK_NORMAL) {
//土地奖励
if (landData.rewards.length > landData.stopCount) {
let reward = landData.rewards[landData.level - 1];
let rewardArray = stringToRewardParam(reward)
landReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
}
//土地升级
if (landData.rewards.length > landData.level) {
let newLevel = landData.level + 1;
await ActivityMonopolyLandModel.updateLevel(serverId, activityId, roleId, newPosition, newLevel)
landData.level = newLevel;
}
//取钱
if (landData.record.length > 0) {
let records = landData.record.filter(obj => { return obj.type == BANK_TYPE.OUT });
if (records.length < landData.takeOutMax) {
let resource = landData.record[0].resource;
let rewardArray = stringToRewardParam(resource)
bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
landData.record = recordResult.record;
}
}
} else if (landData && ((landData.landType == LAND_TYPE.BANK_COIN) || (landData.landType == LAND_TYPE.BANK_GOLD))) {
//取钱
if (landData.record.length > 0) {
let records = landData.record.filter(obj => { return obj.type == BANK_TYPE.OUT });
if (records.length < landData.takeOutMax) {
let resource = landData.record[0].resource;
let rewardArray = stringToRewardParam(resource)
bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
landData.record = recordResult.record;
}
}
}
await ActivityMonopolyLandModel.updateStopCount(serverId, activityId, roleId, newPosition);
landData.stopCount += 1;
return resResult(STATUS.SUCCESS, { landReward, bankReward, landData, moveStep, newPosition, roundIndex: playerData.roundIndex + 1, });
}
/**
* @description 存钱
* @param {{activityId: number ,addCount: number}} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async bank(msg: { activityId: number, addCount: number }, session: BackendSession) {
const { activityId, addCount } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
let curPosition = playerData.curPosition;
if (curPosition == 0) {
return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
}
let landData = playerData.findMonopolyItem(curPosition);
if (landData.landType != LAND_TYPE.BANK_NORMAL
&& landData.landType != LAND_TYPE.BANK_COIN
&& landData.landType != LAND_TYPE.BANK_GOLD) {
return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
}
if (landData.record.length != 0) {
return resResult(STATUS.MONOPOLY_BANK);
}
if (addCount > landData.saveMax) {
return resResult(STATUS.MONOPOLY_BANK_SAVE_MAX);
}
let resrouseStr = '';
if (landData.landType == LAND_TYPE.BANK_COIN
|| landData.landType == LAND_TYPE.BANK_NORMAL) {
resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN)}&${addCount}`
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (landData.landType == LAND_TYPE.BANK_GOLD) {
resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD)}&${addCount}`
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
}
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, curPosition, BANK_TYPE.IN, resrouseStr);
landData.record = recordResult.record;
return resResult(STATUS.SUCCESS, { landData });
}
/**
* @description 获取商店数据
* @param {{ activityId:number, shopActivityId:number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async getRefreshShopActivity(msg: { activityId: number, shopActivityId: number }, session: BackendSession) {
const { activityId, shopActivityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityId, roleId);
let playerLandData: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findDataByPosition(serverId, activityId, roleId, playerMonopolyData.curPosition);
let playerShopData = await getPlayerRefreshShopDataByRoundIndex(shopActivityId, serverId, roleId, playerLandData.stopCount);
if (!playerShopData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerShopData });
}
/**
* @description 购买非RMB商品
* @param {{ monopolyActivityId:number, shopActivityId: number, roundIndex: number, id: number, pageIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async buyGood(msg: { monopolyActivityId, shopActivityId: number, roundIndex: number, id: number, pageIndex: number }, session: BackendSession) {
const { monopolyActivityId, shopActivityId, roundIndex, id, pageIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, monopolyActivityId, roleId);
let playerData = await getPlayerMonopolyData(monopolyActivityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let landItem = playerData.findMonopolyItem(playerMonopolyData.curPosition)
if (landItem.stopCount > landItem.shoppingCountMax) {
return resResult(STATUS.SHOP_CLOSED);
}
let playerShopData = await getPlayerRefreshShopDataByRoundIndex(shopActivityId, serverId, roleId, landItem.stopCount);
if (!playerShopData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerShopData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let item = playerShopData.findItem(id, pageIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
await ActivityRefreshShopModel.addRecord(shopActivityId, roleId, roundIndex, pageIndex, id, 1);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { shopActivityId, monopolyActivityId, roundIndex, id },
item: item
}));
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '@pubUtils/util';
import { LAND_TYPE, STATUS, CURRENCY_TYPE, CURRENCY_BY_TYPE, BANK_TYPE, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { ActivityMonopolyModel, ActivityMonopolyModelType } from '@db/ActivityMonopoly';
import { ActivityMonopolyLandModel, ActivityMonopolyLandModelType } from '@db/ActivityMonopolyLand';
import { getPlayerMonopolyData, nextPosition } from '../../../services/activity/monopolyService';
import { random } from 'underscore';
import { handleCost } from '../../../services/role/rewardService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerRefreshShopDataByRoundIndex } from '../../../services/activity/refreshShopService';
import { ActivityRefreshShopModel } from '@db/ActivityRefreshShop';
export default function (app: Application) {
new HandlerService(app, {});
return new ActivityMonopolyHandler(app);
}
export class ActivityMonopolyHandler {
constructor(private app: Application) {
}
/**
* @description 获取大富翁活动数据
* @param {{activityId: number }} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async getMonopolyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 移动
* @param {{activityId: number }} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async move(msg: { activityId: number, step: number }, session: BackendSession) {
const { activityId, step } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
const roleName = session.get('roleName');
let moveStep = 0;
if (step >= 1 && step <= 6) {//指定,天机骰子
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.SPECIAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
moveStep = step;
} else {//普通骰子
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.NORMAL_DICE), count: 1 }], ITEM_CHANGE_REASON.MONOPOLY_MOVE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
moveStep = random(5) + 1;
}
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
let oldPosition = playerData.curPosition;
let newPosition = nextPosition(oldPosition, moveStep, playerData.list.length);
await ActivityMonopolyModel.updatePosition(serverId, activityId, roleId, newPosition, 1)
let landData = playerData.findMonopolyItem(newPosition);
let landReward = null;//土地奖励
let bankReward = null;//银行奖励
if (landData && landData.landType == LAND_TYPE.BANK_NORMAL) {
//土地奖励
if (landData.rewards.length > landData.stopCount) {
let reward = landData.rewards[landData.level - 1];
let rewardArray = stringToRewardParam(reward)
landReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
}
//土地升级
if (landData.rewards.length > landData.level) {
let newLevel = landData.level + 1;
await ActivityMonopolyLandModel.updateLevel(serverId, activityId, roleId, newPosition, newLevel)
landData.level = newLevel;
}
//取钱
if (landData.record.length > 0) {
let records = landData.record.filter(obj => { return obj.type == BANK_TYPE.OUT });
if (records.length < landData.takeOutMax) {
let resource = landData.record[0].resource;
let rewardArray = stringToRewardParam(resource)
bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
landData.record = recordResult.record;
}
}
} else if (landData && ((landData.landType == LAND_TYPE.BANK_COIN) || (landData.landType == LAND_TYPE.BANK_GOLD))) {
//取钱
if (landData.record.length > 0) {
let records = landData.record.filter(obj => { return obj.type == BANK_TYPE.OUT });
if (records.length < landData.takeOutMax) {
let resource = landData.record[0].resource;
let rewardArray = stringToRewardParam(resource)
bankReward = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_MOVE);
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, newPosition, BANK_TYPE.OUT, resource);
landData.record = recordResult.record;
}
}
}
await ActivityMonopolyLandModel.updateStopCount(serverId, activityId, roleId, newPosition);
landData.stopCount += 1;
return resResult(STATUS.SUCCESS, { landReward, bankReward, landData, moveStep, newPosition, roundIndex: playerData.roundIndex + 1, });
}
/**
* @description 存钱
* @param {{activityId: number ,addCount: number}} msg
* @param {BackendSession} session
* @memberof ActivityMonopolyHandler
*/
async bank(msg: { activityId: number, addCount: number }, session: BackendSession) {
const { activityId, addCount } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMonopolyData(activityId, serverId, roleId)
let curPosition = playerData.curPosition;
if (curPosition == 0) {
return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
}
let landData = playerData.findMonopolyItem(curPosition);
if (landData.landType != LAND_TYPE.BANK_NORMAL
&& landData.landType != LAND_TYPE.BANK_COIN
&& landData.landType != LAND_TYPE.BANK_GOLD) {
return resResult(STATUS.MONOPOLY_LAND_TYPE_ERROR);
}
if (landData.record.length != 0) {
return resResult(STATUS.MONOPOLY_BANK);
}
if (addCount > landData.saveMax) {
return resResult(STATUS.MONOPOLY_BANK_SAVE_MAX);
}
let resrouseStr = '';
if (landData.landType == LAND_TYPE.BANK_COIN
|| landData.landType == LAND_TYPE.BANK_NORMAL) {
resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN)}&${addCount}`
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (landData.landType == LAND_TYPE.BANK_GOLD) {
resrouseStr = `${ACTIVITY_RESOURCES_TYPE.GOODS}&${CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD)}&${addCount}`
//检查资源
let consumeResult = await handleCost(roleId, sid, [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD), count: addCount }], ITEM_CHANGE_REASON.MONOPOLY_BANK);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
}
let recordResult = await ActivityMonopolyLandModel.addRecord(serverId, activityId, roleId, curPosition, BANK_TYPE.IN, resrouseStr);
landData.record = recordResult.record;
return resResult(STATUS.SUCCESS, { landData });
}
/**
* @description 获取商店数据
* @param {{ activityId:number, shopActivityId:number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async getRefreshShopActivity(msg: { activityId: number, shopActivityId: number }, session: BackendSession) {
const { activityId, shopActivityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, activityId, roleId);
let playerLandData: ActivityMonopolyLandModelType = await ActivityMonopolyLandModel.findDataByPosition(serverId, activityId, roleId, playerMonopolyData.curPosition);
let playerShopData = await getPlayerRefreshShopDataByRoundIndex(shopActivityId, serverId, roleId, playerLandData.stopCount);
if (!playerShopData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerShopData });
}
/**
* @description 购买非RMB商品
* @param {{ monopolyActivityId:number, shopActivityId: number, roundIndex: number, id: number, pageIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async buyGood(msg: { monopolyActivityId, shopActivityId: number, roundIndex: number, id: number, pageIndex: number }, session: BackendSession) {
const { monopolyActivityId, shopActivityId, roundIndex, id, pageIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerMonopolyData: ActivityMonopolyModelType = await ActivityMonopolyModel.findData(serverId, monopolyActivityId, roleId);
let playerData = await getPlayerMonopolyData(monopolyActivityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let landItem = playerData.findMonopolyItem(playerMonopolyData.curPosition)
if (landItem.stopCount > landItem.shoppingCountMax) {
return resResult(STATUS.SHOP_CLOSED);
}
let playerShopData = await getPlayerRefreshShopDataByRoundIndex(shopActivityId, serverId, roleId, landItem.stopCount);
if (!playerShopData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerShopData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let item = playerShopData.findItem(id, pageIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.MONOPOLY_BUY_GOODS);
await ActivityRefreshShopModel.addRecord(shopActivityId, roleId, roundIndex, pageIndex, id, 1);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { shopActivityId, monopolyActivityId, roundIndex, id },
item: item
}));
}
}
@@ -1,65 +1,66 @@
import { Application, BackendSession, HandlerService, } from "pinus";
import { getPlayerAuthorGachaDataShow } from "../../../services/activity/authorGachaService";
import { parseGoodStrWithType, resResult } from "../../../pubUtils/util";
import { ITEM_CHANGE_REASON, STATUS } from "../../../consts";
import { AuthorGachaData } from "../../../domain/activityField/authorGachaField";
import { addReward } from "../../../services/activity/giftPackageService";
import { ActivityAuthorGachaRecModel } from "../../../db/AuthorGachaRec";
export default function (app: Application) {
new HandlerService(app, {});
return new AuthorGachaHandler(app);
}
export class AuthorGachaHandler {
constructor(private app: Application) {
}
/**
* 祈灵获取数据
* @param msg
* @param session
* @returns
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const { activityId } = msg;
let playerData = await getPlayerAuthorGachaDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { ...playerData });
}
/**
* 祈灵获取奖励
* @param msg
* @param session
* @returns
*/
async receiveBox(msg: { activityId: number, count: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const { activityId, count } = msg;
let playerData = await getPlayerAuthorGachaDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = playerData.box.find(cur => cur.count == count);
if (box == undefined || box.hasReceived) return resResult(STATUS.ACTIVITY_REWARDED);
box.hasReceived = true;
let rewards = parseGoodStrWithType(box.rewards);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.AUTHOR_GACHA_REWARD);
await ActivityAuthorGachaRecModel.record(serverId, activityId, playerData.roundIndex, roleId, count);
return resResult(STATUS.SUCCESS, { goods: result.goods, curBox: playerData.box })
}
}
import { Application, BackendSession, HandlerService, } from "pinus";
import { getPlayerAuthorGachaDataShow } from "../../../services/activity/authorGachaService";
import { parseGoodStrWithType, resResult } from "@pubUtils/util";
import { ITEM_CHANGE_REASON, STATUS } from "../../../consts";
import { AuthorGachaData } from "@domain/activityField/authorGachaField";
import { addReward } from "../../../services/activity/giftPackageService";
import { ActivityAuthorGachaRecModel } from "@db/AuthorGachaRec";
export default function (app: Application) {
new HandlerService(app, {});
return new AuthorGachaHandler(app);
}
export class AuthorGachaHandler {
constructor(private app: Application) {
}
/**
* 祈灵获取数据
* @param msg
* @param session
* @returns
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId: number = session.get('serverId');
const { activityId } = msg;
let playerData = await getPlayerAuthorGachaDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { ...playerData });
}
/**
* 祈灵获取奖励
* @param msg
* @param session
* @returns
*/
async receiveBox(msg: { activityId: number, count: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
const { activityId, count } = msg;
let playerData = await getPlayerAuthorGachaDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = playerData.box.find(cur => cur.count == count);
if (box == undefined || box.hasReceived) return resResult(STATUS.ACTIVITY_REWARDED);
box.hasReceived = true;
let rewards = parseGoodStrWithType(box.rewards);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.AUTHOR_GACHA_REWARD);
await ActivityAuthorGachaRecModel.record(serverId, activityId, playerData.roundIndex, roleId, count);
return resResult(STATUS.SUCCESS, { goods: result.goods, curBox: playerData.box })
}
}
@@ -1,156 +1,157 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { BIND_PHONE_STATUS, ITEM_CHANGE_REASON, PUSH_ROUTE, SNS_LINK_TYPE, STATUS } from '../../../consts';
import { getPlayerDailyChallengesData } from '../../../services/activity/dailyChallengesService';
import { DailyItem } from '../../../domain/activityField/dailyChallengesField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '../../../db/ActivityDailyChallenges';
import { getBindPhoneData, getAllSnsLinkDataShow, getPublicAccountData } from '../../../services/activity/bindPhoneService';
import { ActivityBindPhoneRewardModel } from '../../../db/ActivityBindPhoneReward';
import { ActivityPublicAccountCodeModel } from '../../../db/ActivityPublicAccountCode';
import { UserModel } from '../../../db/User';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new BindPhoneHandler(app);
}
export class BindPhoneHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let playerData = await getAllSnsLinkDataShow(activityId, roleId, serverId, uid);
return resResult(STATUS.SUCCESS, {
playerData
})
}
/************************绑定手机****************************/
/**
* @description 绑定手机数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async bind(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getBindPhoneData(activityId, roleId, serverId, uid);
let bindPhoneData = playerData?.bindPhone;
if(!bindPhoneData) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(bindPhoneData.status != BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_HAS_BIND);
await ActivityBindPhoneRewardModel.addRecord(activityId, uid, BIND_PHONE_STATUS.HAS_BIND, { roleId, roleName, serverId });
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.HAS_BIND
});
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async receiveReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getBindPhoneData(activityId, roleId, serverId, uid);
let bindPhoneData = playerData?.bindPhone;
if(!bindPhoneData) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(bindPhoneData.status == BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_BIND_ERR);
if(bindPhoneData.status == BIND_PHONE_STATUS.RECEIVED) return resResult(STATUS.ACTIVITY_BIND_RECEIVED);
await ActivityBindPhoneRewardModel.addRecord(activityId, uid, BIND_PHONE_STATUS.RECEIVED, { roleId, roleName, serverId });
let rewardArray = stringToRewardParam(bindPhoneData.rewards)
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_BIND_PHONE);
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.RECEIVED,
goods, addHeros
});
}
/**
* 领取公众号口令奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async receiveGiftCode(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
let playerData = await getPublicAccountData(activityId, roleId, serverId, user);
let data = playerData?.wxPublicAccount;
if(!data) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(data.status == BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_PUBLIC_ACCOUNT_WAIT);
if(data.status == BIND_PHONE_STATUS.RECEIVED) return resResult(STATUS.ACTIVITY_PUBLIC_ACCOUNT_RECEIVED);
await ActivityPublicAccountCodeModel.receive(activityId, user.channelId);
let rewardArray = stringToRewardParam(data.rewards)
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_BIND_PHONE);
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.RECEIVED,
goods, addHeros
});
}
/**
* 前往论坛,用于前往论坛任务
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async skipOutSide(msg: { activityId: number }, session: BackendSession) {
return resResult(STATUS.SUCCESS);
}
/**
* 公众号设置成可以领取的状态
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async debugSetGiftCodeStatus(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
await ActivityPublicAccountCodeModel.findOneAndUpdate({ activityId, channelId: user.channelId }, { $set: { serverId, roleId, orderId: 'test', hasReceived: false } }, { new: true, upsert: true }).lean();
await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.PUBLIC_ACCOUNT_GIFT, { activityId, type: SNS_LINK_TYPE.WX_PUBLIC_ACCOUNT, status: BIND_PHONE_STATUS.HAS_BIND });
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '@pubUtils/util';
import { BIND_PHONE_STATUS, ITEM_CHANGE_REASON, PUSH_ROUTE, SNS_LINK_TYPE, STATUS } from '../../../consts';
import { getPlayerDailyChallengesData } from '../../../services/activity/dailyChallengesService';
import { DailyItem } from '@domain/activityField/dailyChallengesField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '@db/ActivityDailyChallenges';
import { getBindPhoneData, getAllSnsLinkDataShow, getPublicAccountData } from '../../../services/activity/bindPhoneService';
import { ActivityBindPhoneRewardModel } from '@db/ActivityBindPhoneReward';
import { ActivityPublicAccountCodeModel } from '@db/ActivityPublicAccountCode';
import { UserModel } from '@db/User';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new BindPhoneHandler(app);
}
export class BindPhoneHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let playerData = await getAllSnsLinkDataShow(activityId, roleId, serverId, uid);
return resResult(STATUS.SUCCESS, {
playerData
})
}
/************************绑定手机****************************/
/**
* @description 绑定手机数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async bind(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getBindPhoneData(activityId, roleId, serverId, uid);
let bindPhoneData = playerData?.bindPhone;
if(!bindPhoneData) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(bindPhoneData.status != BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_HAS_BIND);
await ActivityBindPhoneRewardModel.addRecord(activityId, uid, BIND_PHONE_STATUS.HAS_BIND, { roleId, roleName, serverId });
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.HAS_BIND
});
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async receiveReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getBindPhoneData(activityId, roleId, serverId, uid);
let bindPhoneData = playerData?.bindPhone;
if(!bindPhoneData) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(bindPhoneData.status == BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_BIND_ERR);
if(bindPhoneData.status == BIND_PHONE_STATUS.RECEIVED) return resResult(STATUS.ACTIVITY_BIND_RECEIVED);
await ActivityBindPhoneRewardModel.addRecord(activityId, uid, BIND_PHONE_STATUS.RECEIVED, { roleId, roleName, serverId });
let rewardArray = stringToRewardParam(bindPhoneData.rewards)
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_BIND_PHONE);
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.RECEIVED,
goods, addHeros
});
}
/**
* 领取公众号口令奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async receiveGiftCode(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
let playerData = await getPublicAccountData(activityId, roleId, serverId, user);
let data = playerData?.wxPublicAccount;
if(!data) return resResult(STATUS.ACTIVITY_ID_ERROR);
if(data.status == BIND_PHONE_STATUS.WAIT_BIND) return resResult(STATUS.ACTIVITY_PUBLIC_ACCOUNT_WAIT);
if(data.status == BIND_PHONE_STATUS.RECEIVED) return resResult(STATUS.ACTIVITY_PUBLIC_ACCOUNT_RECEIVED);
await ActivityPublicAccountCodeModel.receive(activityId, user.channelId);
let rewardArray = stringToRewardParam(data.rewards)
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_BIND_PHONE);
return resResult(STATUS.SUCCESS, {
activityId,
status: BIND_PHONE_STATUS.RECEIVED,
goods, addHeros
});
}
/**
* 前往论坛,用于前往论坛任务
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async skipOutSide(msg: { activityId: number }, session: BackendSession) {
return resResult(STATUS.SUCCESS);
}
/**
* 公众号设置成可以领取的状态
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof BindPhoneHandler
*/
async debugSetGiftCodeStatus(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
await ActivityPublicAccountCodeModel.findOneAndUpdate({ activityId, channelId: user.channelId }, { $set: { serverId, roleId, orderId: 'test', hasReceived: false } }, { new: true, upsert: true }).lean();
await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.PUBLIC_ACCOUNT_GIFT, { activityId, type: SNS_LINK_TYPE.WX_PUBLIC_ACCOUNT, status: BIND_PHONE_STATUS.HAS_BIND });
return resResult(STATUS.SUCCESS);
}
}
@@ -1,165 +1,166 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerChongYangData, getPlayerChongYangDataShow } from '../../../services/activity/chongyangService';
import { ActivityChongYangRecModel, ChongYangGameRecord } from '../../../db/ActivityChongYangRec';
import { RewardInter } from '../../../pubUtils/interface';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { getZeroPoint } from '../../../pubUtils/timeUtil';
export default function (app: Application) {
new HandlerService(app, {});
return new ChongYangHandler(app);
}
export class ChongYangHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
async gameStart(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
const gameCode = genCode(10);
await ActivityChongYangRecModel.gameRecords(serverId, activityId, playerData.roundIndex, roleId, [{
todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, dayIndex, isSkip: false
}]);
return resResult(STATUS.SUCCESS, { activityId, gameCode });
}
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean, dayIndex: number }, session: BackendSession) {
const { activityId, gameCode, isSuccess, dayIndex } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
let curRecord = playerData.gameRecords.find(cur => cur.gameCode == gameCode);
if (!curRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
if (curRecord.isSuccess) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_USE);
let playerRecord = await ActivityChongYangRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), scene.rewards);
if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
let goods: RewardInter[] = [];
if (isSuccess) {
goods = await addItems(roleId, roleName, sid, stringToRewardParam(scene.rewards), ITEM_CHANGE_REASON.CHONGYANG_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
playCnt: scene.playCnt,
maxPlayCnt: scene.maxPlayCnt,
gameCode,
goods
});
}
async buyCnt(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
const { activityId, dayIndex, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测购买次数
if (scene.buyCnt + count > scene.dailyBuyCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_BUY_COUNT_OVER);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(scene.buyCost), ITEM_CHANGE_REASON.CHONGYANG_COST);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let playerRecord = await ActivityChongYangRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, { dayIndex, buyCnt: count }, scene.isPushBuyRecord);
if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
return resResult(STATUS.SUCCESS, { activityId, dailyBuyCnt: scene.dailyBuyCnt, buyCnt: scene.buyCnt, });
}
async gameSweep(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
const { activityId, dayIndex, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt + count > scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
// 检测通关
let isHasPass = playerData.gameRecords.find(cur => cur.dayIndex == dayIndex && cur.isSuccess && !cur.isSkip && (getZeroPoint() * 1000 <= cur.time.getTime()));
if (!isHasPass) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMESWEEP_LOCK);
let rewards: RewardInter[] = [];
let records: ChongYangGameRecord[] = [];
for (let i = 0; i < count; i++) {
records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: scene.rewards, isSuccess: true, dayIndex, isSkip: true })
rewards.push(...stringToRewardParam(scene.rewards));
}
await ActivityChongYangRecModel.gameRecords(serverId, activityId, playerData.roundIndex, roleId, records);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.CHONGYANG_REWARD)
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
return resResult(STATUS.SUCCESS, {
activityId,
playCnt: scene.playCnt,
maxPlayCnt: scene.maxPlayCnt,
goods
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerChongYangData, getPlayerChongYangDataShow } from '../../../services/activity/chongyangService';
import { ActivityChongYangRecModel, ChongYangGameRecord } from '@db/ActivityChongYangRec';
import { RewardInter } from '@pubUtils/interface';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { getZeroPoint } from '@pubUtils/timeUtil';
export default function (app: Application) {
new HandlerService(app, {});
return new ChongYangHandler(app);
}
export class ChongYangHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
async gameStart(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
const gameCode = genCode(10);
await ActivityChongYangRecModel.gameRecords(serverId, activityId, playerData.roundIndex, roleId, [{
todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, dayIndex, isSkip: false
}]);
return resResult(STATUS.SUCCESS, { activityId, gameCode });
}
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean, dayIndex: number }, session: BackendSession) {
const { activityId, gameCode, isSuccess, dayIndex } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt >= scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
let curRecord = playerData.gameRecords.find(cur => cur.gameCode == gameCode);
if (!curRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
if (curRecord.isSuccess) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_USE);
let playerRecord = await ActivityChongYangRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), scene.rewards);
if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
let goods: RewardInter[] = [];
if (isSuccess) {
goods = await addItems(roleId, roleName, sid, stringToRewardParam(scene.rewards), ITEM_CHANGE_REASON.CHONGYANG_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
playCnt: scene.playCnt,
maxPlayCnt: scene.maxPlayCnt,
gameCode,
goods
});
}
async buyCnt(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
const { activityId, dayIndex, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测购买次数
if (scene.buyCnt + count > scene.dailyBuyCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_BUY_COUNT_OVER);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(scene.buyCost), ITEM_CHANGE_REASON.CHONGYANG_COST);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let playerRecord = await ActivityChongYangRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, { dayIndex, buyCnt: count }, scene.isPushBuyRecord);
if (!playerRecord) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMECODE_NOT_FOUND);
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
return resResult(STATUS.SUCCESS, { activityId, dailyBuyCnt: scene.dailyBuyCnt, buyCnt: scene.buyCnt, });
}
async gameSweep(msg: { activityId: number, dayIndex: number, count: number }, session: BackendSession) {
const { activityId, dayIndex, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerChongYangData(activityId, serverId, roleId);
if (!playerData || !playerData.sceneMap) return resResult(STATUS.ACTIVITY_MISSING);
let scene = playerData.sceneMap.get(dayIndex);
if (!scene) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (scene.playCnt + count > scene.maxPlayCnt) return resResult(STATUS.ACTIVITY_CHONGYANG_NO_NUM);
// 检测解锁
if (dayIndex > playerData.dayIndexUnlock) return resResult(STATUS.ACTIVITY_CHONGYANG_LOCK);
// 检测通关
let isHasPass = playerData.gameRecords.find(cur => cur.dayIndex == dayIndex && cur.isSuccess && !cur.isSkip && (getZeroPoint() * 1000 <= cur.time.getTime()));
if (!isHasPass) return resResult(STATUS.ACTIVITY_CHONGYANG_GAMESWEEP_LOCK);
let rewards: RewardInter[] = [];
let records: ChongYangGameRecord[] = [];
for (let i = 0; i < count; i++) {
records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: scene.rewards, isSuccess: true, dayIndex, isSkip: true })
rewards.push(...stringToRewardParam(scene.rewards));
}
await ActivityChongYangRecModel.gameRecords(serverId, activityId, playerData.roundIndex, roleId, records);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.CHONGYANG_REWARD)
playerData = await getPlayerChongYangData(activityId, serverId, roleId);
scene = playerData.sceneMap.get(dayIndex);
return resResult(STATUS.SUCCESS, {
activityId,
playCnt: scene.playCnt,
maxPlayCnt: scene.maxPlayCnt,
goods
});
}
}
@@ -1,80 +1,81 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerDailyChallengesData } from '../../../services/activity/dailyChallengesService';
import { DailyItem } from '../../../domain/activityField/dailyChallengesField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '../../../db/ActivityDailyChallenges';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyChallengesHandler(app);
}
export class DailyChallengesHandler {
constructor(private app: Application) {
}
/************************今日挑战****************************/
/**
* @description 获取今日挑战活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyChallengesHandler
*/
async getDailyChallengesActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof DailyChallengesHandler
*/
async getDailyChallengeReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: DailyItem = playerData.findDailyChallengesItem(dayIndex, cellIndex, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!dailyItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
dailyItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: dailyItemData,
}));
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerDailyChallengesData } from '../../../services/activity/dailyChallengesService';
import { DailyItem } from '@domain/activityField/dailyChallengesField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '@db/ActivityDailyChallenges';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyChallengesHandler(app);
}
export class DailyChallengesHandler {
constructor(private app: Application) {
}
/************************今日挑战****************************/
/**
* @description 获取今日挑战活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyChallengesHandler
*/
async getDailyChallengesActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof DailyChallengesHandler
*/
async getDailyChallengeReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: DailyItem = playerData.findDailyChallengesItem(dayIndex, cellIndex, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!dailyItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
dailyItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: dailyItemData,
}));
}
}
@@ -1,166 +1,167 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ACTIVITY_RESOURCES_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, DAILY_COIN_BOX_STATUS, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getGoldObject, handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyCoinData, mergeData } from '../../../services/activity/dailyCoinService';
import { ConsumeExchangeFormulaItem, CoinRewardFormulaItem } from '../../../domain/activityField/dailyCoinField';
import { ActivityDailyCoinModel } from '../../../db/ActivityDailyCoin';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ItemInter } from '../../../pubUtils/interface';
import { RoleModel } from '../../../db/Role';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new DailyCoinHandler(app);
}
export class DailyCoinHandler {
constructor(private app: Application) {
}
/************************每日兑换铜币****************************/
/**
* @description 获取每日铜币活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async getDailyCoinActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 兑换
* @param {{ activityId: number, count:number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async exchangeCoin(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let curIndex = playerData.exchangeCount;
if (curIndex + count > playerData.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
let allConsume: Array<ItemInter> = []
let allReward: Array<RewardParam> = [];
let role = await RoleModel.findByRoleId(roleId)
let rateArray = [];//暴击记录
for (let i = 1; i <= count; i++) {
let index = curIndex + i;
if (index > playerData.freeCount) {//消耗资源
let consumeItem: ConsumeExchangeFormulaItem = playerData.findConsumeExchangeFormulaItem(index);
let times = index;
let consumeCount = eval(consumeItem.consumeFormula)
let consume = getGoldObject(consumeCount)
allConsume = allConsume.concat(consume)
}
let rate = playerData.getRate()//翻几倍
rateArray.push(rate);
let lv = role.lv;//玩家等级
let rewardItem: CoinRewardFormulaItem = playerData.findCoinRewardFormulaItem(lv);
if (!rewardItem) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
let coinRewardCount = eval(rewardItem.rewardFormula);
// console.log('******** coinReward', lv, rewardItem.rewardFormula, coinRewardCount)
let baseRewardParamArr: Array<RewardParam> = [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: coinRewardCount, type: ACTIVITY_RESOURCES_TYPE.GOODS }];
// console.log('第几次抽奖:', index, ' 基础奖励翻倍:', rate, JSON.stringify(baseRewardParamArr),)
for (let reward of baseRewardParamArr) {
reward.count = reward.count * rate;
}
allReward = allReward.concat(baseRewardParamArr);
}
let newConsume = mergeData(allConsume);
let newReward = mergeData(allReward);
// console.log('所有消耗', JSON.stringify(newConsume))
// console.log('所有奖励', JSON.stringify(newReward))
//检查资源
let consumeResult = await handleCost(roleId, sid, newConsume, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
let addCoin = 0
let coinId = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN);
for (let obj of newReward) {
if (obj.id === coinId) {
addCoin += obj.count;
}
}
let consumeGold = 0;
let goldId = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD);
for (let obj of newConsume) {
if (obj.id === goldId) {
consumeGold += obj.count;
}
}
//免费期间
let time = moment(new Date()).valueOf();
let result = await addReward(roleId, roleName, sid, serverId, newReward, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
let extraReward = playerData.addExchangeCount(count);
await ActivityDailyCoinModel.addExchangeRecord(serverId, activityId, roleId, playerData.roundIndex, count, addCoin, `${count}&${consumeGold}&${addCoin}&${time}`, playerData.hasNotReceivedBox());
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, count, extraReward },
item: { exchangeCount: playerData.exchangeCount, recordMsg: `${count}&${consumeGold}&${addCoin}&${time}`, rateArray },
}));
}
/**
* @description 领取宝箱
* @param {{ activityId: number, cellIndex:number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async receiveExtraReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = await playerData.findBoxByCellIndex(cellIndex);
if(!box) return resResult(STATUS.DAILY_COIN_BOX_NOT_FOUND);
if(box.status != DAILY_COIN_BOX_STATUS.CAN_OPEN) return resResult(STATUS.DAILY_COIN_BOX_CANNOT_RECEIVE);
let rewardArray = stringToRewardParam(box.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_DAILY_COIN_RECEIVE_BOX);
let item = playerData.receiveBox(cellIndex);
await ActivityDailyCoinModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, cellIndex, playerData.hasNotReceivedBox());
return resResult(STATUS.SUCCESS, Object.assign(result, {
item,
param: { activityId },
}));
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ACTIVITY_RESOURCES_TYPE, CURRENCY_BY_TYPE, CURRENCY_TYPE, DAILY_COIN_BOX_STATUS, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getGoldObject, handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyCoinData, mergeData } from '../../../services/activity/dailyCoinService';
import { ConsumeExchangeFormulaItem, CoinRewardFormulaItem } from '@domain/activityField/dailyCoinField';
import { ActivityDailyCoinModel } from '@db/ActivityDailyCoin';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ItemInter } from '@pubUtils/interface';
import { RoleModel } from '@db/Role';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new DailyCoinHandler(app);
}
export class DailyCoinHandler {
constructor(private app: Application) {
}
/************************每日兑换铜币****************************/
/**
* @description 获取每日铜币活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async getDailyCoinActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 兑换
* @param {{ activityId: number, count:number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async exchangeCoin(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let curIndex = playerData.exchangeCount;
if (curIndex + count > playerData.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
let allConsume: Array<ItemInter> = []
let allReward: Array<RewardParam> = [];
let role = await RoleModel.findByRoleId(roleId)
let rateArray = [];//暴击记录
for (let i = 1; i <= count; i++) {
let index = curIndex + i;
if (index > playerData.freeCount) {//消耗资源
let consumeItem: ConsumeExchangeFormulaItem = playerData.findConsumeExchangeFormulaItem(index);
let times = index;
let consumeCount = eval(consumeItem.consumeFormula)
let consume = getGoldObject(consumeCount)
allConsume = allConsume.concat(consume)
}
let rate = playerData.getRate()//翻几倍
rateArray.push(rate);
let lv = role.lv;//玩家等级
let rewardItem: CoinRewardFormulaItem = playerData.findCoinRewardFormulaItem(lv);
if (!rewardItem) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
let coinRewardCount = eval(rewardItem.rewardFormula);
// console.log('******** coinReward', lv, rewardItem.rewardFormula, coinRewardCount)
let baseRewardParamArr: Array<RewardParam> = [{ id: CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN), count: coinRewardCount, type: ACTIVITY_RESOURCES_TYPE.GOODS }];
// console.log('第几次抽奖:', index, ' 基础奖励翻倍:', rate, JSON.stringify(baseRewardParamArr),)
for (let reward of baseRewardParamArr) {
reward.count = reward.count * rate;
}
allReward = allReward.concat(baseRewardParamArr);
}
let newConsume = mergeData(allConsume);
let newReward = mergeData(allReward);
// console.log('所有消耗', JSON.stringify(newConsume))
// console.log('所有奖励', JSON.stringify(newReward))
//检查资源
let consumeResult = await handleCost(roleId, sid, newConsume, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
let addCoin = 0
let coinId = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.COIN);
for (let obj of newReward) {
if (obj.id === coinId) {
addCoin += obj.count;
}
}
let consumeGold = 0;
let goldId = CURRENCY_BY_TYPE.get(CURRENCY_TYPE.GOLD);
for (let obj of newConsume) {
if (obj.id === goldId) {
consumeGold += obj.count;
}
}
//免费期间
let time = moment(new Date()).valueOf();
let result = await addReward(roleId, roleName, sid, serverId, newReward, ITEM_CHANGE_REASON.DAILY_COIN_EXCHANGE);
let extraReward = playerData.addExchangeCount(count);
await ActivityDailyCoinModel.addExchangeRecord(serverId, activityId, roleId, playerData.roundIndex, count, addCoin, `${count}&${consumeGold}&${addCoin}&${time}`, playerData.hasNotReceivedBox());
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, count, extraReward },
item: { exchangeCount: playerData.exchangeCount, recordMsg: `${count}&${consumeGold}&${addCoin}&${time}`, rateArray },
}));
}
/**
* @description 领取宝箱
* @param {{ activityId: number, cellIndex:number}} msg
* @param {BackendSession} session
* @memberof DailyCoinHandler
*/
async receiveExtraReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyCoinData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = await playerData.findBoxByCellIndex(cellIndex);
if(!box) return resResult(STATUS.DAILY_COIN_BOX_NOT_FOUND);
if(box.status != DAILY_COIN_BOX_STATUS.CAN_OPEN) return resResult(STATUS.DAILY_COIN_BOX_CANNOT_RECEIVE);
let rewardArray = stringToRewardParam(box.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_DAILY_COIN_RECEIVE_BOX);
let item = playerData.receiveBox(cellIndex);
await ActivityDailyCoinModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, cellIndex, playerData.hasNotReceivedBox());
return resResult(STATUS.SUCCESS, Object.assign(result, {
item,
param: { activityId },
}));
}
}
@@ -1,77 +1,78 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerDailyGKData } from '../../../services/activity/dailyGKService';
import { DailyGKItem } from '../../../domain/activityField/dailyGKField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyGKHandler(app);
}
export class DailyGKHandler {
constructor(private app: Application) {
}
/************************每日关卡;按日开启,每日开启一关****************************/
/**
* @description 获取每日关卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyGKHandler
*/
async getDailyGKActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number}} msg
* @param {BackendSession} session
* @memberof DailyGKHandler
*/
async getGK(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (dayIndex > playerData.todayIndex) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
let dailyItemData: DailyGKItem = playerData.findDailyGKItem(dayIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
// if (dailyItemData.isSuccess) {//已经达成
// return resResult(STATUS.ACTIVITY_REWARDED);
// }
// await ActivityDailyGKModel.addRecord(serverId, activityId, roleId, dayIndex);
// let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
// let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
// dailyItemData.isSuccess = true;
return resResult(STATUS.SUCCESS, {
gkId: dailyItemData.gk
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerDailyGKData } from '../../../services/activity/dailyGKService';
import { DailyGKItem } from '@domain/activityField/dailyGKField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyGKHandler(app);
}
export class DailyGKHandler {
constructor(private app: Application) {
}
/************************每日关卡;按日开启,每日开启一关****************************/
/**
* @description 获取每日关卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyGKHandler
*/
async getDailyGKActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number}} msg
* @param {BackendSession} session
* @memberof DailyGKHandler
*/
async getGK(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (dayIndex > playerData.todayIndex) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
let dailyItemData: DailyGKItem = playerData.findDailyGKItem(dayIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
// if (dailyItemData.isSuccess) {//已经达成
// return resResult(STATUS.ACTIVITY_REWARDED);
// }
// await ActivityDailyGKModel.addRecord(serverId, activityId, roleId, dayIndex);
// let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
// let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr)
// dailyItemData.isSuccess = true;
return resResult(STATUS.SUCCESS, {
gkId: dailyItemData.gk
});
}
}
@@ -1,93 +1,94 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyGiftsData } from '../../../services/activity/dailyGiftsService';
import { DailyGiftItem } from '../../../domain/activityField/dailyGiftsField';
import { ActivityDailyGiftsModel } from '../../../db/ActivityDailyGifts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyGiftsHandler(app);
}
export class DailyGiftsHandler {
constructor(private app: Application) {
}
/************************每日特惠礼包****************************/
/**
* @description 获取每日特惠礼包活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyGiftsHandler
*/
async getDailyGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 购买每日特惠礼包
* @param {{ activityId: number, dayIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof DailyGiftsHandler
*/
async buyDailyGiftsCell(msg: { activityId: number, dayIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: DailyGiftItem = playerData.findDailyGiftsItem(dayIndex, cellIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.canBuy()) {//最大次数
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (dayIndex > playerData.today()) {//还未开启
return resResult(STATUS.ACTIVITY_UNOPENED);
}
//货币是否足够
let consumeData = dailyItemData.consumeRes();
let consumeType = consumeData.type;//购买类型
if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表,元宝、金币、体力
let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
dailyItemData.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex },
item: dailyItemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyGiftsData } from '../../../services/activity/dailyGiftsService';
import { DailyGiftItem } from '@domain/activityField/dailyGiftsField';
import { ActivityDailyGiftsModel } from '@db/ActivityDailyGifts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyGiftsHandler(app);
}
export class DailyGiftsHandler {
constructor(private app: Application) {
}
/************************每日特惠礼包****************************/
/**
* @description 获取每日特惠礼包活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyGiftsHandler
*/
async getDailyGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 购买每日特惠礼包
* @param {{ activityId: number, dayIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof DailyGiftsHandler
*/
async buyDailyGiftsCell(msg: { activityId: number, dayIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: DailyGiftItem = playerData.findDailyGiftsItem(dayIndex, cellIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.canBuy()) {//最大次数
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (dayIndex > playerData.today()) {//还未开启
return resResult(STATUS.ACTIVITY_UNOPENED);
}
//货币是否足够
let consumeData = dailyItemData.consumeRes();
let consumeType = consumeData.type;//购买类型
if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表,元宝、金币、体力
let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
dailyItemData.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex },
item: dailyItemData,
}));
}
}
@@ -1,88 +1,89 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyMealData } from '../../../services/activity/dailyMealService';
import { DailyMealItem } from '../../../domain/activityField/dailyMealField';
import { ActivityDailyMealModel } from '../../../db/ActivityDailyMeal';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new DailyMealHandler(app);
}
export class DailyMealHandler {
constructor(private app: Application) {
}
/************************每日午饭/晚饭****************************/
/**
* @description 获取每日午饭/晚饭活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyMealHandler
*/
async getDailyMealActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyMealData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyMealHandler
*/
async getDailyMealReward(msg: { activityId: number, type: number }, session: BackendSession) {
const { activityId, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyMealData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let itemData: DailyMealItem = playerData.findItem(type);
if (!itemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (itemData.isReceive) {//最大次数
return resResult(STATUS.ACTIVITY_REWARDED);
}
let curDate = moment(new Date()).valueOf();
if (curDate < itemData.beginTime) {//没到饭点
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
if (curDate > itemData.endTime) {//补领
//检查资源
let consume = stringToConsumeParam(itemData.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE_REPAIRE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
}
//免费期间
let rewardParamArr: Array<RewardParam> = stringToRewardParam(itemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE);
await ActivityDailyMealModel.addReceiveRecord(serverId, activityId, roleId, type, curDate, playerData.roundIndex);
itemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, type },
item: itemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { getPlayerDailyMealData } from '../../../services/activity/dailyMealService';
import { DailyMealItem } from '@domain/activityField/dailyMealField';
import { ActivityDailyMealModel } from '@db/ActivityDailyMeal';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new DailyMealHandler(app);
}
export class DailyMealHandler {
constructor(private app: Application) {
}
/************************每日午饭/晚饭****************************/
/**
* @description 获取每日午饭/晚饭活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyMealHandler
*/
async getDailyMealActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyMealData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyMealHandler
*/
async getDailyMealReward(msg: { activityId: number, type: number }, session: BackendSession) {
const { activityId, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyMealData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let itemData: DailyMealItem = playerData.findItem(type);
if (!itemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (itemData.isReceive) {//最大次数
return resResult(STATUS.ACTIVITY_REWARDED);
}
let curDate = moment(new Date()).valueOf();
if (curDate < itemData.beginTime) {//没到饭点
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
if (curDate > itemData.endTime) {//补领
//检查资源
let consume = stringToConsumeParam(itemData.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE_REPAIRE);
if (!consumeResult) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
}
//免费期间
let rewardParamArr: Array<RewardParam> = stringToRewardParam(itemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_MEAL_RECEIVE);
await ActivityDailyMealModel.addReceiveRecord(serverId, activityId, roleId, type, curDate, playerData.roundIndex);
itemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, type },
item: itemData,
}));
}
}
@@ -1,95 +1,96 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerDailyRMBGiftsData } from '../../../services/activity/dailyRMBGiftsService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityDailyRMBGiftsModel } from '../../../db/ActivityDailyRMBGifts';
import moment = require('moment');
import { DailyRMBGiftsItem } from '../../../domain/activityField/dailyRMBGiftsField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyRMBGiftsHandler(app);
}
export class DailyRMBGiftsHandler {
constructor(private app: Application) {
}
/************************每日特惠礼包RMB购买4挡,有可能免费,一次性支付购买7天,每天只能领取当天的礼包奖励****************************/
/**
* @description 获取每日特惠礼包活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyRMBGiftsHandler
*/
async getDailyRMBGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyRMBGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 一次性购买7天后,获取当天的礼包
* @param {{ activityId: number, id:number}} msg
* @param {BackendSession} session
* @memberof DailyRMBGiftsHandler
*/
async getDailyRMBGiftsReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyRMBGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items: DailyRMBGiftsItem[] = [];
if(id > 0) {
let item = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (item.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (!playerData.isBuy && item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
items.push(item);
} else {
if (!playerData.isBuy) {
return resResult(STATUS.ACTIVITY_UNOPENED);
}
items.push(...playerData.unReceiveItem());
}
if (items.length == 0) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
let rewardArray: RewardParam[] = [];
let ids: number[] = []
for (let item of items) {
ids.push(item.id);
rewardArray.push(...stringToRewardParam(item.reward));
}
let resultItems = playerData.receiveItems(ids);
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.DAILY_RMB_GIFT)
await ActivityDailyRMBGiftsModel.receiveRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex, ids);
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, unReceiveCount: playerData.unReceiveCount, buttonStatus: playerData.buttonStatus },
items: resultItems
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerDailyRMBGiftsData } from '../../../services/activity/dailyRMBGiftsService';
import { RewardParam } from '@domain/activityField/rewardField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityDailyRMBGiftsModel } from '@db/ActivityDailyRMBGifts';
import moment = require('moment');
import { DailyRMBGiftsItem } from '@domain/activityField/dailyRMBGiftsField';
export default function (app: Application) {
new HandlerService(app, {});
return new DailyRMBGiftsHandler(app);
}
export class DailyRMBGiftsHandler {
constructor(private app: Application) {
}
/************************每日特惠礼包RMB购买4挡,有可能免费,一次性支付购买7天,每天只能领取当天的礼包奖励****************************/
/**
* @description 获取每日特惠礼包活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DailyRMBGiftsHandler
*/
async getDailyRMBGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDailyRMBGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 一次性购买7天后,获取当天的礼包
* @param {{ activityId: number, id:number}} msg
* @param {BackendSession} session
* @memberof DailyRMBGiftsHandler
*/
async getDailyRMBGiftsReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerDailyRMBGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items: DailyRMBGiftsItem[] = [];
if(id > 0) {
let item = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (item.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (!playerData.isBuy && item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
items.push(item);
} else {
if (!playerData.isBuy) {
return resResult(STATUS.ACTIVITY_UNOPENED);
}
items.push(...playerData.unReceiveItem());
}
if (items.length == 0) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
let rewardArray: RewardParam[] = [];
let ids: number[] = []
for (let item of items) {
ids.push(item.id);
rewardArray.push(...stringToRewardParam(item.reward));
}
let resultItems = playerData.receiveItems(ids);
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.DAILY_RMB_GIFT)
await ActivityDailyRMBGiftsModel.receiveRecord(serverId, activityId, roleId, moment(playerData.beginTime).toDate(), playerData.todayIndex, ids);
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, unReceiveCount: playerData.unReceiveCount, buttonStatus: playerData.buttonStatus },
items: resultItems
}));
}
}
@@ -1,137 +1,138 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { parseNumberList, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerDragonBoatData, getPlayerDragonBoatDataShow } from '../../../services/activity/dragonBoatService';
import { ActivityDragonBoatModel } from '../../../db/ActivityDragonBoat';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new DragonBoatHandler(app);
}
export class DragonBoatHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DragonBoatHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDragonBoatDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 挑战开始
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof DragonBoatHandler
*/
async gameStart(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerDragonBoatData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_COUNT_OVER);
let route = playerData.findRoute(id);
if(!route) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_ROUTE_NOTFOUND);
if(route.hasPass) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_ROUTE_HAS_PASS);
if(route.preId && route.preId != '&') {
let preIds = parseNumberList(route.preId);
let hasPass = preIds.find(preId => {
let preRoute = playerData.findRoute(preId);
return preRoute && preRoute.hasPass;
});
if(!hasPass) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_PRE_NOT_PASS);
}
let rewards = stringToRewardParam(route.reward);
let playerRecord = await ActivityDragonBoatModel.record(serverId, activityId, playerData.roundIndex, roleId, { todayIndex: playerData.todayIndex, id, time: new Date(), rewards })
playerData.setPlayerRecords(playerRecord);
await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_DRAGON_BOAT);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
route: playerData.findRoute(id)?.getShowResult()
});
}
/**
* @description 挑战结束
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof DragonBoatHandler
*/
async gameEnd(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDragonBoatData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let route = playerData.findRoute(id);
if(!route) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_ROUTE_NOTFOUND);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
route: route.getShowResult(),
goods: route.resultReward
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof DragonBoatHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerDragonBoatData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_BUY_COUNT_OVER);
if(playerData.todayPlayCnt < playerData.freeCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_CANNOT_BUY);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_DRAGON_BOAT_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityDragonBoatModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// 更新数据
playerData.setPlayerRecords(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { parseNumberList, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerDragonBoatData, getPlayerDragonBoatDataShow } from '../../../services/activity/dragonBoatService';
import { ActivityDragonBoatModel } from '@db/ActivityDragonBoat';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new DragonBoatHandler(app);
}
export class DragonBoatHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof DragonBoatHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDragonBoatDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 挑战开始
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof DragonBoatHandler
*/
async gameStart(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerDragonBoatData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_COUNT_OVER);
let route = playerData.findRoute(id);
if(!route) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_ROUTE_NOTFOUND);
if(route.hasPass) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_ROUTE_HAS_PASS);
if(route.preId && route.preId != '&') {
let preIds = parseNumberList(route.preId);
let hasPass = preIds.find(preId => {
let preRoute = playerData.findRoute(preId);
return preRoute && preRoute.hasPass;
});
if(!hasPass) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_PRE_NOT_PASS);
}
let rewards = stringToRewardParam(route.reward);
let playerRecord = await ActivityDragonBoatModel.record(serverId, activityId, playerData.roundIndex, roleId, { todayIndex: playerData.todayIndex, id, time: new Date(), rewards })
playerData.setPlayerRecords(playerRecord);
await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_DRAGON_BOAT);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
route: playerData.findRoute(id)?.getShowResult()
});
}
/**
* @description 挑战结束
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof DragonBoatHandler
*/
async gameEnd(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerDragonBoatData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let route = playerData.findRoute(id);
if(!route) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_ROUTE_NOTFOUND);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
route: route.getShowResult(),
goods: route.resultReward
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof DragonBoatHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerDragonBoatData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_BUY_COUNT_OVER);
if(playerData.todayPlayCnt < playerData.freeCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_CANNOT_BUY);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_DRAGON_BOAT_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityDragonBoatModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// 更新数据
playerData.setPlayerRecords(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
@@ -1,132 +1,133 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getRandSingleEelm, parseNumberList, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerEntertainData, getPlayerEntertainDataShow } from '../../../services/activity/entertainService';
import { ActivityEntertainRecModel } from '../../../db/ActivityEntertainRec';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new EntertainHandler(app);
}
export class EntertainHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 宴请
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async invite(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let pool = playerData.heroes.filter(hero => {
if(hero.num >= hero.maxNum) return false;
for(let condition of hero.conditionArr) {
if(condition.type == 1 && playerData.invitedHeroNum < condition.param) return false;
if(condition.type == 2 && playerData.invitedHids.indexOf(condition.param) == -1) return false;
}
return true;
});
if(pool.length <= 0) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let randResult = getRandSingleEelm(pool);
if(!randResult) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let rewards = stringToRewardParam(randResult.reward);
let todayIndex = playerData.todayIndex; // 免费挑战算在第几天
if(playerData.todayPlayCnt >= playerData.freeCntDaily && playerData.playCnt < playerData.freeCnt) {
let playerRecord = await ActivityEntertainRecModel.findData(serverId, activityId, playerData.roundIndex, roleId);
let records = playerRecord?.record||[];
for(let i = 1; i <= todayIndex; i++) {
let times = records.filter(cur => cur.todayIndex == i).length;
playerData.playCnt += times;
if(times < playerData.freeCntDaily) {
todayIndex = i; break;
}
}
}
let playerRecord = await ActivityEntertainRecModel.record(serverId, activityId, playerData.roundIndex, roleId, { todayIndex, id: randResult.id, hid: randResult.hid, index: randResult.index, time: new Date(), reward: randResult.reward })
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_ENTERTAIN);
playerData.todayPlayCnt = 0;
playerData.playCnt = 0;
playerData.freeCnt = playerData.freeCntDaily * playerData.todayIndex;
for(let hero of playerData.heroes) hero.num = 0;
playerData.setPlayerRecords(playerRecord);
let newRandResult = playerData.heroes.find(cur => cur.id == randResult.id);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
curHero: newRandResult?.getShowResult(),
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_ENTERTAIN_BUY_COUNT_OVER);
// if(playerData.todayPlayCnt < playerData.freeCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_CANNOT_BUY);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityEntertainRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updateBuyCnt(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getRandSingleEelm, parseNumberList, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerEntertainData, getPlayerEntertainDataShow } from '../../../services/activity/entertainService';
import { ActivityEntertainRecModel } from '@db/ActivityEntertainRec';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new EntertainHandler(app);
}
export class EntertainHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 宴请
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async invite(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let pool = playerData.heroes.filter(hero => {
if(hero.num >= hero.maxNum) return false;
for(let condition of hero.conditionArr) {
if(condition.type == 1 && playerData.invitedHeroNum < condition.param) return false;
if(condition.type == 2 && playerData.invitedHids.indexOf(condition.param) == -1) return false;
}
return true;
});
if(pool.length <= 0) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let randResult = getRandSingleEelm(pool);
if(!randResult) return resResult(STATUS.ACTIVITY_ENTERTAIN_NO_NUM);
let rewards = stringToRewardParam(randResult.reward);
let todayIndex = playerData.todayIndex; // 免费挑战算在第几天
if(playerData.todayPlayCnt >= playerData.freeCntDaily && playerData.playCnt < playerData.freeCnt) {
let playerRecord = await ActivityEntertainRecModel.findData(serverId, activityId, playerData.roundIndex, roleId);
let records = playerRecord?.record||[];
for(let i = 1; i <= todayIndex; i++) {
let times = records.filter(cur => cur.todayIndex == i).length;
playerData.playCnt += times;
if(times < playerData.freeCntDaily) {
todayIndex = i; break;
}
}
}
let playerRecord = await ActivityEntertainRecModel.record(serverId, activityId, playerData.roundIndex, roleId, { todayIndex, id: randResult.id, hid: randResult.hid, index: randResult.index, time: new Date(), reward: randResult.reward })
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_ENTERTAIN);
playerData.todayPlayCnt = 0;
playerData.playCnt = 0;
playerData.freeCnt = playerData.freeCntDaily * playerData.todayIndex;
for(let hero of playerData.heroes) hero.num = 0;
playerData.setPlayerRecords(playerRecord);
let newRandResult = playerData.heroes.find(cur => cur.id == randResult.id);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
curHero: newRandResult?.getShowResult(),
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof EntertainHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerEntertainData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_ENTERTAIN_BUY_COUNT_OVER);
// if(playerData.todayPlayCnt < playerData.freeCnt) return resResult(STATUS.ACTIVITY_DRAGON_BOAT_CANNOT_BUY);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityEntertainRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updateBuyCnt(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
@@ -1,92 +1,93 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { FIRST_GIFT_STATE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerFirstGiftData, getPlayerFirstGiftDataShow } from '../../../services/activity/firstGiftService';
import { RoleModel } from '../../../db/Role';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityFirstGiftModel } from '../../../db/ActivityFirstGift';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new FirstGiftHandler(app);
}
export class FirstGiftHandler {
constructor(private app: Application) {
}
/************************首充礼包****************************/
/**首冲活动按玩家注册时间
* 不充,首充活动就一直在那里
* @description 获取首充礼包数据
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof FirstGiftHandler
*/
async getFirstGiftActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerFirstGiftDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let { totalPay } = await RoleModel.findByRoleId(roleId);
if (totalPay > 0) {//奖励开启
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 领取礼包奖励
* @param {{ activityId: number, index: number}} msg
* @param {BackendSession} session
* @memberof FirstGiftHandler
*/
async getFirstGiftReward(msg: { activityId: number, pageIndex: number }, session: BackendSession) {
const { activityId, pageIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerFirstGiftData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let playerPageData = playerData.findPageByIndex(pageIndex);
if (playerPageData.state === FIRST_GIFT_STATE.NOT_PAY) {
return resResult(STATUS.ACTIVITY_FIRST_GIFT_NOT_OPEN);
}
let items = playerPageData.getCanReceiveItems();
if (items.length === 0) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
let rewardArray: RewardParam[] = [];
let indexArray: number[] = [];
for (let item of items) {
rewardArray.push(...stringToRewardParam(item.reward));
indexArray.push(item.index)
item.isReceive = true;
}
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.FIRST_GIFT);
let isOver = playerPageData.isComplete();
let playerRecord = await ActivityFirstGiftModel.addRecord(activityId, roleId, pageIndex, indexArray, isOver);
playerPageData.setPlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, state: playerPageData.state },
items: items
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { FIRST_GIFT_STATE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerFirstGiftData, getPlayerFirstGiftDataShow } from '../../../services/activity/firstGiftService';
import { RoleModel } from '@db/Role';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityFirstGiftModel } from '@db/ActivityFirstGift';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new FirstGiftHandler(app);
}
export class FirstGiftHandler {
constructor(private app: Application) {
}
/************************首充礼包****************************/
/**首冲活动按玩家注册时间
* 不充,首充活动就一直在那里
* @description 获取首充礼包数据
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof FirstGiftHandler
*/
async getFirstGiftActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerFirstGiftDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let { totalPay } = await RoleModel.findByRoleId(roleId);
if (totalPay > 0) {//奖励开启
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 领取礼包奖励
* @param {{ activityId: number, index: number}} msg
* @param {BackendSession} session
* @memberof FirstGiftHandler
*/
async getFirstGiftReward(msg: { activityId: number, pageIndex: number }, session: BackendSession) {
const { activityId, pageIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerFirstGiftData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let playerPageData = playerData.findPageByIndex(pageIndex);
if (playerPageData.state === FIRST_GIFT_STATE.NOT_PAY) {
return resResult(STATUS.ACTIVITY_FIRST_GIFT_NOT_OPEN);
}
let items = playerPageData.getCanReceiveItems();
if (items.length === 0) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
let rewardArray: RewardParam[] = [];
let indexArray: number[] = [];
for (let item of items) {
rewardArray.push(...stringToRewardParam(item.reward));
indexArray.push(item.index)
item.isReceive = true;
}
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.FIRST_GIFT);
let isOver = playerPageData.isComplete();
let playerRecord = await ActivityFirstGiftModel.addRecord(activityId, roleId, pageIndex, indexArray, isOver);
playerPageData.setPlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, state: playerPageData.state },
items: items
}));
}
}
@@ -1,117 +1,118 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getMetialStr, getPlayerForgeData, getPlayerForgeDataShow } from '../../../services/activity/forgeService';
import { ActivityForgeModel } from '../../../db/ActivityForge';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new ForgeHandler(app);
}
export class ForgeHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getForgeActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 铸造
* @param {{ activityId: number, id: number, material: {id: number, count: number}[]}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async build(msg: { activityId: number, id: number, material: {id: number, count: number}[] }, session: BackendSession) {
const { activityId, id, material } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let materialCnt = material.reduce((pre, cur) => pre + cur.count, 0);
if(materialCnt <= 0) return resResult(STATUS.ACTIVITY_MATERIAL_COUNT_NOT_ZERO);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_MANUAL_DAY_LOCK);
// 铸造次数
if(manual.buildCnt >= manual.freeCnt + manual.buyCnt) return resResult(STATUS.ACTIVITY_BUILD_COUNT);
// 配比是否正确
let isSuccess = manual.checkMaterial(material);
// 扣材料
let costResult = await handleCost(roleId, sid, material, ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.build(serverId, activityId, roleId, playerData.roundIndex, id, { todayIndex: playerData.todayIndex, isSuccess, material: getMetialStr(material) });
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex, playerData.hint);
let activityGoods = undefined;
if(isSuccess) {
let { goods } = await addReward(roleId, roleName, sid, serverId, stringToRewardParam(manual.reward), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
activityGoods = goods;
}
return resResult(STATUS.SUCCESS, {
isSuccess,
curManual: manual,
activityGoods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async buyCnt(msg: { activityId: number, id: number, count: number }, session: BackendSession) {
const { activityId, id, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.buyCnt >= manual.maxBuyCnt) return resResult(STATUS.ACTIVITY_BUY_CNT_MAX);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.buyCnt(serverId, activityId, roleId, playerData.roundIndex, id, count);
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex);
return resResult(STATUS.SUCCESS, {
curManual: manual
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getMetialStr, getPlayerForgeData, getPlayerForgeDataShow } from '../../../services/activity/forgeService';
import { ActivityForgeModel } from '@db/ActivityForge';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new ForgeHandler(app);
}
export class ForgeHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getForgeActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 铸造
* @param {{ activityId: number, id: number, material: {id: number, count: number}[]}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async build(msg: { activityId: number, id: number, material: {id: number, count: number}[] }, session: BackendSession) {
const { activityId, id, material } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let materialCnt = material.reduce((pre, cur) => pre + cur.count, 0);
if(materialCnt <= 0) return resResult(STATUS.ACTIVITY_MATERIAL_COUNT_NOT_ZERO);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_MANUAL_DAY_LOCK);
// 铸造次数
if(manual.buildCnt >= manual.freeCnt + manual.buyCnt) return resResult(STATUS.ACTIVITY_BUILD_COUNT);
// 配比是否正确
let isSuccess = manual.checkMaterial(material);
// 扣材料
let costResult = await handleCost(roleId, sid, material, ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.build(serverId, activityId, roleId, playerData.roundIndex, id, { todayIndex: playerData.todayIndex, isSuccess, material: getMetialStr(material) });
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex, playerData.hint);
let activityGoods = undefined;
if(isSuccess) {
let { goods } = await addReward(roleId, roleName, sid, serverId, stringToRewardParam(manual.reward), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
activityGoods = goods;
}
return resResult(STATUS.SUCCESS, {
isSuccess,
curManual: manual,
activityGoods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async buyCnt(msg: { activityId: number, id: number, count: number }, session: BackendSession) {
const { activityId, id, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerForgeData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let manual = playerData.findManual(id);
if(!manual) return resResult(STATUS.ACTIVITY_MANUAL_NOT_FOUND);
// 解锁日期
if(manual.buyCnt >= manual.maxBuyCnt) return resResult(STATUS.ACTIVITY_BUY_CNT_MAX);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_FORGE_BUILD);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityForgeModel.buyCnt(serverId, activityId, roleId, playerData.roundIndex, id, count);
// 更新数据
manual.setPlayerData(buildResult, playerData.todayIndex);
return resResult(STATUS.SUCCESS, {
curManual: manual
});
}
}
File diff suppressed because it is too large Load Diff
@@ -1,152 +1,153 @@
import { Application, BackendSession, HandlerService, } from "pinus";
import { resResult } from "../../../pubUtils/util";
import { STATUS, ITEM_CHANGE_REASON, GROUP_SHOP_PRICE_STATUS, PUSH_ROUTE, ACTIVITY_TYPE, } from "../../../consts";
import { getGroupShopData, getGroupShopDataShow, getGroupShopPriceStatus, getGroupShopServerData, refundGroupShop } from "../../../services/activity/groupShopService";
import { addItems, getGoldObject, handleCost } from "../../../services/role/rewardService";
import { ActivityGroupShopUserRecModel, GroupShopBuyRecord } from "../../../db/ActivityGroupShopUserRec";
import { ActivityGroupShopRecModel, GroupShopRecord } from "../../../db/ActivityGroupShopRec";
import { pick } from "underscore";
import { addRoleToGroupShopChannel, leaveGroupShopChannel } from "../../../services/chatChannelService";
import { sendMessageToGroupShopWithSuc } from "../../../services/pushService";
import { getActivitiesByType } from "../../../services/activity/activityService";
import { GroupShopData } from "../../../domain/activityField/groupShopField";
export default function (app: Application) {
new HandlerService(app, {});
return new GroupShopHandler(app);
}
export class GroupShopHandler {
constructor(private app: Application) {
}
/**
* @description 1. 进入团购主页面
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async getGroupShopPage(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
let playerData = await getGroupShopDataShow(activityId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
await addRoleToGroupShopChannel(roleId, sid);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 2. 离开团购主页面
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async leaveGroupShopPage(msg: { activityId: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
await leaveGroupShopChannel(roleId, sid)
return resResult(STATUS.SUCCESS);
}
/**
* @description 3. 购买
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async buy(msg: { activityId: number, price: number, itemId: number, buyCnt: number }, session: BackendSession) {
const { activityId, price: clientPrice, itemId, buyCnt } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
let playerData = await getGroupShopData(activityId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.findItemById(itemId);
if (!item) return resResult(STATUS.ACTIVITY_GROUP_SHOP_ITEM_NOT_FOUND);
if(!item.checkBuyCnt(buyCnt)) return resResult(STATUS.ACTIVITY_GROUP_SHOP_BUY_CNT_MAX);
let curDiscount = item.getCurDiscount();
let priceStatus = getGroupShopPriceStatus(clientPrice, curDiscount.price);
if(priceStatus == GROUP_SHOP_PRICE_STATUS.NOT_ENOUGH) return resResult(STATUS.ACTIVITY_GROUP_SHOP_PRICE_ERR);
let cost = [getGoldObject(curDiscount.price)];
let result = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_GROUP_SHOP_BUY);
if(!result) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
// 玩家添加次数
let playerRecord = await ActivityGroupShopUserRecModel.incBuyCnt(activityId, roleId, itemId, item.id, buyCnt, new GroupShopBuyRecord(curDiscount, buyCnt));
playerData.setPlayerRecord([playerRecord]);
// 全服添加次数
let serverRecord = await ActivityGroupShopRecModel.incBuyCnt(activityId, itemId, item.id, buyCnt);
let isRankUp = playerData.incAllRecord(serverRecord);
item = playerData.findItemById(itemId);
let nextDiscount = item.getCurDiscount();
if(isRankUp) {
await ActivityGroupShopRecModel.addRecord(activityId, itemId, new GroupShopRecord(nextDiscount));
// 推送频道
await sendMessageToGroupShopWithSuc(PUSH_ROUTE.GROUP_SHOP_UPDATE, { activityId, itemId, sum: item.sum, curDiscount: nextDiscount });
}
let reward = [{ id: item.id, count: item.count * buyCnt }];
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.ACT_GROUP_SHOP_BUY);
return resResult(STATUS.SUCCESS, {
curItem: pick(item, ['itemId', 'id', 'sum', 'hasBoughtCnt']),
goods,
status: priceStatus,
oldDiscount: curDiscount,
nextDiscount
});
}
async debugRefund(msg: {}, session: BackendSession) {
await refundGroupShop(true);
return resResult(STATUS.SUCCESS);
}
async debugSetSum(msg: { itemId: number, sum: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId = session.get('serverId');
let { itemId = 0, sum = 0 } = msg;
let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.GROUP_SHOP);
if(activities.length <= 0) return resResult(STATUS.ACTIVITY_MISSING);
for(let activityData of activities) {
let recs = await ActivityGroupShopRecModel.debugSetSum(activityData.activityId, itemId, sum);
let playerData = new GroupShopData(activityData, 0, 0);
playerData.setRecords(recs);
let items = itemId == 0? playerData.items: [playerData.findItemById(itemId)];
for(let item of items) {
if(!item) continue;
let nextDiscount = item.getCurDiscount();
// 推送频道
await sendMessageToGroupShopWithSuc(PUSH_ROUTE.GROUP_SHOP_UPDATE, { activityId: activityData.activityId, itemId: item.itemId, sum: item.sum, curDiscount: nextDiscount });
}
}
let playerData = await getGroupShopDataShow(activities[0].activityId, roleId);
return resResult(STATUS.SUCCESS, { playerData });
}
async debugClearCnt(msg: { }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId = session.get('serverId');
let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.GROUP_SHOP);
if(activities.length <= 0) return resResult(STATUS.ACTIVITY_MISSING);
for(let activityData of activities) {
await ActivityGroupShopUserRecModel.clearCnt(activityData.activityId, roleId);
}
let playerData = await getGroupShopDataShow(activities[0].activityId, roleId);
return resResult(STATUS.SUCCESS, { playerData });
}
}
import { Application, BackendSession, HandlerService, } from "pinus";
import { resResult } from "@pubUtils/util";
import { STATUS, ITEM_CHANGE_REASON, GROUP_SHOP_PRICE_STATUS, PUSH_ROUTE, ACTIVITY_TYPE, } from "../../../consts";
import { getGroupShopData, getGroupShopDataShow, getGroupShopPriceStatus, getGroupShopServerData, refundGroupShop } from "../../../services/activity/groupShopService";
import { addItems, getGoldObject, handleCost } from "../../../services/role/rewardService";
import { ActivityGroupShopUserRecModel, GroupShopBuyRecord } from "@db/ActivityGroupShopUserRec";
import { ActivityGroupShopRecModel, GroupShopRecord } from "@db/ActivityGroupShopRec";
import { pick } from "underscore";
import { addRoleToGroupShopChannel, leaveGroupShopChannel } from "../../../services/chatChannelService";
import { sendMessageToGroupShopWithSuc } from "../../../services/pushService";
import { getActivitiesByType } from "../../../services/activity/activityService";
import { GroupShopData } from "@domain/activityField/groupShopField";
export default function (app: Application) {
new HandlerService(app, {});
return new GroupShopHandler(app);
}
export class GroupShopHandler {
constructor(private app: Application) {
}
/**
* @description 1. 进入团购主页面
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async getGroupShopPage(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
let playerData = await getGroupShopDataShow(activityId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
await addRoleToGroupShopChannel(roleId, sid);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 2. 离开团购主页面
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async leaveGroupShopPage(msg: { activityId: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const sid: string = session.get('sid');
await leaveGroupShopChannel(roleId, sid)
return resResult(STATUS.SUCCESS);
}
/**
* @description 3. 购买
* @param {{}} msg
* @param {BackendSession} session
* @memberof GroupShopHandler
*/
async buy(msg: { activityId: number, price: number, itemId: number, buyCnt: number }, session: BackendSession) {
const { activityId, price: clientPrice, itemId, buyCnt } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const sid: string = session.get('sid');
let playerData = await getGroupShopData(activityId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.findItemById(itemId);
if (!item) return resResult(STATUS.ACTIVITY_GROUP_SHOP_ITEM_NOT_FOUND);
if(!item.checkBuyCnt(buyCnt)) return resResult(STATUS.ACTIVITY_GROUP_SHOP_BUY_CNT_MAX);
let curDiscount = item.getCurDiscount();
let priceStatus = getGroupShopPriceStatus(clientPrice, curDiscount.price);
if(priceStatus == GROUP_SHOP_PRICE_STATUS.NOT_ENOUGH) return resResult(STATUS.ACTIVITY_GROUP_SHOP_PRICE_ERR);
let cost = [getGoldObject(curDiscount.price)];
let result = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_GROUP_SHOP_BUY);
if(!result) return resResult(STATUS.BATTLE_GOLD_NOT_ENOUGH);
// 玩家添加次数
let playerRecord = await ActivityGroupShopUserRecModel.incBuyCnt(activityId, roleId, itemId, item.id, buyCnt, new GroupShopBuyRecord(curDiscount, buyCnt));
playerData.setPlayerRecord([playerRecord]);
// 全服添加次数
let serverRecord = await ActivityGroupShopRecModel.incBuyCnt(activityId, itemId, item.id, buyCnt);
let isRankUp = playerData.incAllRecord(serverRecord);
item = playerData.findItemById(itemId);
let nextDiscount = item.getCurDiscount();
if(isRankUp) {
await ActivityGroupShopRecModel.addRecord(activityId, itemId, new GroupShopRecord(nextDiscount));
// 推送频道
await sendMessageToGroupShopWithSuc(PUSH_ROUTE.GROUP_SHOP_UPDATE, { activityId, itemId, sum: item.sum, curDiscount: nextDiscount });
}
let reward = [{ id: item.id, count: item.count * buyCnt }];
let goods = await addItems(roleId, roleName, sid, reward, ITEM_CHANGE_REASON.ACT_GROUP_SHOP_BUY);
return resResult(STATUS.SUCCESS, {
curItem: pick(item, ['itemId', 'id', 'sum', 'hasBoughtCnt']),
goods,
status: priceStatus,
oldDiscount: curDiscount,
nextDiscount
});
}
async debugRefund(msg: {}, session: BackendSession) {
await refundGroupShop(true);
return resResult(STATUS.SUCCESS);
}
async debugSetSum(msg: { itemId: number, sum: number }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId = session.get('serverId');
let { itemId = 0, sum = 0 } = msg;
let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.GROUP_SHOP);
if(activities.length <= 0) return resResult(STATUS.ACTIVITY_MISSING);
for(let activityData of activities) {
let recs = await ActivityGroupShopRecModel.debugSetSum(activityData.activityId, itemId, sum);
let playerData = new GroupShopData(activityData, 0, 0);
playerData.setRecords(recs);
let items = itemId == 0? playerData.items: [playerData.findItemById(itemId)];
for(let item of items) {
if(!item) continue;
let nextDiscount = item.getCurDiscount();
// 推送频道
await sendMessageToGroupShopWithSuc(PUSH_ROUTE.GROUP_SHOP_UPDATE, { activityId: activityData.activityId, itemId: item.itemId, sum: item.sum, curDiscount: nextDiscount });
}
}
let playerData = await getGroupShopDataShow(activities[0].activityId, roleId);
return resResult(STATUS.SUCCESS, { playerData });
}
async debugClearCnt(msg: { }, session: BackendSession) {
const roleId: string = session.get('roleId');
const serverId = session.get('serverId');
let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.GROUP_SHOP);
if(activities.length <= 0) return resResult(STATUS.ACTIVITY_MISSING);
for(let activityData of activities) {
await ActivityGroupShopUserRecModel.clearCnt(activityData.activityId, roleId);
}
let playerData = await getGroupShopDataShow(activities[0].activityId, roleId);
return resResult(STATUS.SUCCESS, { playerData });
}
}
@@ -1,84 +1,85 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerGrowthFundData } from '../../../services/activity/growthFundService';
import { GrowthFundItem } from '../../../domain/activityField/growthFundField';
import { ActivityGrowthFundModel } from '../../../db/ActivityGrowthFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new GrowthFundHandler(app);
}
export class GrowthFundHandler {
constructor(private app: Application) {
}
/************************成长基金****************************/
/**
* @description 获取成长基金活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof GrowthFundHandler
*/
async getGrowthFundActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerGrowthFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_GROWTH_FUND_END);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取成长基金奖励
* @param {{ activityId: number, pageIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof GrowthFundHandler
*/
async getGrowthFundCellReward(msg: { activityId: number, pageIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, pageIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthFundData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.isVipActivity() && !playerData.isBuy(pageIndex)) {//vip高阶活动,需要购买
return resResult(STATUS.ACTIVITY_NEED_BUY);
}
let growthFundItemData: GrowthFundItem = playerData.findGrowthFundItem(pageIndex, cellIndex);
if (!growthFundItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthFundItemData.isComplete) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
let hasReceive = await ActivityGrowthFundModel.exists({ roleId, activityId, pageIndex, cellIndex });
if (hasReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthFundModel.addRecord(activityId, roleId, pageIndex, cellIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthFundItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_FUND)
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, cellIndex },
item: growthFundItemData
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerGrowthFundData } from '../../../services/activity/growthFundService';
import { GrowthFundItem } from '@domain/activityField/growthFundField';
import { ActivityGrowthFundModel } from '@db/ActivityGrowthFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new GrowthFundHandler(app);
}
export class GrowthFundHandler {
constructor(private app: Application) {
}
/************************成长基金****************************/
/**
* @description 获取成长基金活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof GrowthFundHandler
*/
async getGrowthFundActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerGrowthFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_GROWTH_FUND_END);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取成长基金奖励
* @param {{ activityId: number, pageIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof GrowthFundHandler
*/
async getGrowthFundCellReward(msg: { activityId: number, pageIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, pageIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthFundData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.isVipActivity() && !playerData.isBuy(pageIndex)) {//vip高阶活动,需要购买
return resResult(STATUS.ACTIVITY_NEED_BUY);
}
let growthFundItemData: GrowthFundItem = playerData.findGrowthFundItem(pageIndex, cellIndex);
if (!growthFundItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthFundItemData.isComplete) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
let hasReceive = await ActivityGrowthFundModel.exists({ roleId, activityId, pageIndex, cellIndex });
if (hasReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthFundModel.addRecord(activityId, roleId, pageIndex, cellIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthFundItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_FUND)
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, cellIndex },
item: growthFundItemData
}));
}
}
@@ -1,124 +1,125 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerGrowthData } from '../../../services/activity/growthService';
import { GrowthItem, PointRewardItem } from '../../../domain/activityField/growthField';
import { ActivityGrowthModel } from '../../../db/ActivityGrowth';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityGrowthPointModel } from '../../../db/ActivityGrowthPoint';
export default function (app: Application) {
new HandlerService(app, {});
return new GrowthHandler(app);
}
export class GrowthHandler {
constructor(private app: Application) {
}
/************************成长任务****************************/
/**
* @description 获取成长任务活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取成长任务每天完成的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthCellReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let growthItemData: GrowthItem = playerData.findGrowthItem(dayIndex, cellIndex, type);
if (!growthItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!growthItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if(growthItemData.dayIndex < playerData.today()) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
growthItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: growthItemData,
}));
}
/**
* @description 成长任务每天奖章兑换奖励
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthDayReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pointItemData: PointRewardItem = playerData.findPointItem(id);
if (!pointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.getTotalPoint() < pointItemData.progress) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (pointItemData.getPointReward) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
pointItemData.getPointReward = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: pointItemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerGrowthData } from '../../../services/activity/growthService';
import { GrowthItem, PointRewardItem } from '@domain/activityField/growthField';
import { ActivityGrowthModel } from '@db/ActivityGrowth';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityGrowthPointModel } from '@db/ActivityGrowthPoint';
export default function (app: Application) {
new HandlerService(app, {});
return new GrowthHandler(app);
}
export class GrowthHandler {
constructor(private app: Application) {
}
/************************成长任务****************************/
/**
* @description 获取成长任务活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取成长任务每天完成的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthCellReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let growthItemData: GrowthItem = playerData.findGrowthItem(dayIndex, cellIndex, type);
if (!growthItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!growthItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if(growthItemData.dayIndex < playerData.today()) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
growthItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: growthItemData,
}));
}
/**
* @description 成长任务每天奖章兑换奖励
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof GrowthHandler
*/
async getGrowthDayReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pointItemData: PointRewardItem = playerData.findPointItem(id);
if (!pointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.getTotalPoint() < pointItemData.progress) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (pointItemData.getPointReward) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
pointItemData.getPointReward = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: pointItemData,
}));
}
}
@@ -1,86 +1,87 @@
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { isNumber } from 'underscore';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityGuildPayRecordModel } from '../../../db/ActivityGuildPayRecord';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { resResult } from '../../../pubUtils/util';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getGuildPayDataShow, getGuildPayData } from '../../../services/activity/guildPayService';
export default function (app: Application) {
return new GuildPayHandler(app);
}
export class GuildPayHandler {
constructor(private app: Application) {
}
/**
* @description 获取活动数据
* @param {{ }} msg
* @param {BackendSession} session
* @memberof GuildPayHandler
*/
async getGuildPayData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let playerData = await getGuildPayDataShow(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description (一键)领取奖励
* @param {{ }} msg
* @param {BackendSession} session
* @memberof GuildPayHandler
*/
async receiveItems(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
if(!isNumber(cellIndex)) return resResult(STATUS.WRONG_PARMS);
let playerData = await getGuildPayData(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items = playerData.receiveItems(cellIndex);
if(!items) return resResult(STATUS.ACTIVITY_ITEM_CANNOT_RECEIVE);
let records: number[] = [], rewards: RewardParam[] = [];
for(let item of items) {
records.push(item.cellIndex);
rewards.push(...stringToRewardParam(item.reward));
}
await ActivityGuildPayRecordModel.receiveItems(serverId, activityId, playerData.roundIndex, roleId, records);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_GUILD_PAY_REWARD);
return resResult(STATUS.SUCCESS, { items, ...result });
}
async getGuildPayMembers(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let playerData = await getGuildPayData(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, {
payMemberCnt: playerData.payMemberCnt,
payRecord: playerData.payRecord
});
}
}
import { Application, BackendSession, HandlerService, pinus, } from 'pinus';
import { isNumber } from 'underscore';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityGuildPayRecordModel } from '@db/ActivityGuildPayRecord';
import { RewardParam } from '@domain/activityField/rewardField';
import { resResult } from '@pubUtils/util';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getGuildPayDataShow, getGuildPayData } from '../../../services/activity/guildPayService';
export default function (app: Application) {
return new GuildPayHandler(app);
}
export class GuildPayHandler {
constructor(private app: Application) {
}
/**
* @description 获取活动数据
* @param {{ }} msg
* @param {BackendSession} session
* @memberof GuildPayHandler
*/
async getGuildPayData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let playerData = await getGuildPayDataShow(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description (一键)领取奖励
* @param {{ }} msg
* @param {BackendSession} session
* @memberof GuildPayHandler
*/
async receiveItems(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
if(!isNumber(cellIndex)) return resResult(STATUS.WRONG_PARMS);
let playerData = await getGuildPayData(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items = playerData.receiveItems(cellIndex);
if(!items) return resResult(STATUS.ACTIVITY_ITEM_CANNOT_RECEIVE);
let records: number[] = [], rewards: RewardParam[] = [];
for(let item of items) {
records.push(item.cellIndex);
rewards.push(...stringToRewardParam(item.reward));
}
await ActivityGuildPayRecordModel.receiveItems(serverId, activityId, playerData.roundIndex, roleId, records);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_GUILD_PAY_REWARD);
return resResult(STATUS.SUCCESS, { items, ...result });
}
async getGuildPayMembers(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const guildCode = session.get('guildCode');
let playerData = await getGuildPayData(serverId, activityId, roleId, guildCode);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, {
payMemberCnt: playerData.payMemberCnt,
payRecord: playerData.payRecord
});
}
}
@@ -1,134 +1,135 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { newPlayerLimitPackageActivity, getPlayerLimitPackageData } from '../../../services/activity/limitPackageService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityShopModel } from '../../../db/ActivityShop';
import moment = require('moment');
import { RoleModel } from '../../../db/Role';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new LimitPackageHandler(app);
}
export class LimitPackageHandler {
constructor(private app: Application) {
}
/************************新手限定礼包****************************/
/**
* @description 获取新手限定活动数据 开服1-7天可以购买,第8天0-5点只能看,不能买
* @param {{ activityId:number}} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async getNewPlayerLimitPackageActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { createTime } = await RoleModel.findByRoleId(roleId);
let createDate = moment(createTime * 1000).toDate();
let endTime = moment(createDate).startOf('d').add(7, 'd').add(5, 'h').toDate();
if (new Date() > endTime) {
return resResult(STATUS.ACTIVITY_NEW_PLAYER_GIFT_END);
}
let playerData = await newPlayerLimitPackageActivity(serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/************************每日每周限购礼包****************************/
/**
* @description 获取每日/每周限购礼包数据
* @param {{ activityId:number, type:number }} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async getLimitPackageActivity(msg: { activityId: number, type: number }, session: BackendSession) {
const { activityId, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLimitPackageData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 购买礼包
* @param {{ activityId: number, roundIndex: number, id: number}} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async buyGood(msg: { activityId: number, roundIndex: number, id: number }, session: BackendSession) {
const { activityId, roundIndex, id, } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerLimitPackageData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
switch (playerData.type) {
case ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE:
{
let { createTime } = await RoleModel.findByRoleId(roleId);
let createDate = moment(createTime * 1000).toDate();
let endTime = moment(createDate).startOf('d').add(7, 'd').toDate();
if (new Date() > endTime) {
return resResult(STATUS.ACTIVITY_NEW_PLAYER_LIMIT_PACKAGE_END);
}
break;
}
default:
break;
}
let item = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
await ActivityShopModel.addRecord(activityId, roleId, roundIndex, id, 1);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, id },
item: item
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ACTIVITY_TYPE, ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { newPlayerLimitPackageActivity, getPlayerLimitPackageData } from '../../../services/activity/limitPackageService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityShopModel } from '@db/ActivityShop';
import moment = require('moment');
import { RoleModel } from '@db/Role';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new LimitPackageHandler(app);
}
export class LimitPackageHandler {
constructor(private app: Application) {
}
/************************新手限定礼包****************************/
/**
* @description 获取新手限定活动数据 开服1-7天可以购买,第8天0-5点只能看,不能买
* @param {{ activityId:number}} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async getNewPlayerLimitPackageActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { createTime } = await RoleModel.findByRoleId(roleId);
let createDate = moment(createTime * 1000).toDate();
let endTime = moment(createDate).startOf('d').add(7, 'd').add(5, 'h').toDate();
if (new Date() > endTime) {
return resResult(STATUS.ACTIVITY_NEW_PLAYER_GIFT_END);
}
let playerData = await newPlayerLimitPackageActivity(serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/************************每日每周限购礼包****************************/
/**
* @description 获取每日/每周限购礼包数据
* @param {{ activityId:number, type:number }} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async getLimitPackageActivity(msg: { activityId: number, type: number }, session: BackendSession) {
const { activityId, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLimitPackageData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 购买礼包
* @param {{ activityId: number, roundIndex: number, id: number}} msg
* @param {BackendSession} session
* @memberof LimitPackageHandler
*/
async buyGood(msg: { activityId: number, roundIndex: number, id: number }, session: BackendSession) {
const { activityId, roundIndex, id, } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerLimitPackageData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
switch (playerData.type) {
case ACTIVITY_TYPE.NEW_PLAYER_LIMIT_PACKAGE:
{
let { createTime } = await RoleModel.findByRoleId(roleId);
let createDate = moment(createTime * 1000).toDate();
let endTime = moment(createDate).startOf('d').add(7, 'd').toDate();
if (new Date() > endTime) {
return resResult(STATUS.ACTIVITY_NEW_PLAYER_LIMIT_PACKAGE_END);
}
break;
}
default:
break;
}
let item = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_LIMIT_PACKAGE);
await ActivityShopModel.addRecord(activityId, roleId, roundIndex, id, 1);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, id },
item: item
}));
}
}
@@ -1,98 +1,99 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerLuckyDataShow, getPlayerLuckyData } from '../../../services/activity/luckyService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { pick } from 'underscore';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityLuckyModel } from '../../../db/ActivityLuckyRec';
export default function (app: Application) {
new HandlerService(app, {});
return new LuckyTurntableNewHandler(app);
}
export class LuckyTurntableNewHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async getTurntableData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 转转盘
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async pull(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let cost = playerData.getCost(count);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { result, records, goodResult, pool, floor } = playerData.pull(roleName, count);
await ActivityLuckyModel.updateData(serverId, activityId, roleId, playerData.roundIndex, { ...pick(playerData, ['todayCount', 'count', 'records', 'floorRecord']), refTodayCount: new Date() });
await addItems(roleId, roleName, sid, goodResult, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
return resResult(STATUS.SUCCESS, { result, records, todayCount: playerData.todayCount, count: playerData.count, pool, floor });
}
/**
* @description 领宝箱
* @param {{ activityId: number, boxCount: number }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async receiveBox(msg: { activityId: number, boxCount: number }, session: BackendSession) {
const { activityId, boxCount } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let canReceive = playerData.canReceive(boxCount);
if (!canReceive) return resResult(STATUS.BOX_CAN_NOT_RECEIVE);
let box = playerData.findBox(boxCount);
let rewardArray = stringToRewardParam(box.rewards)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_TURNTABLE_RECEIVE_BOX);
await ActivityLuckyModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, boxCount);
return resResult(STATUS.SUCCESS, { ...result, box: { ...box, isReceived: true } });
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerLuckyDataShow, getPlayerLuckyData } from '../../../services/activity/luckyService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { pick } from 'underscore';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityLuckyModel } from '@db/ActivityLuckyRec';
export default function (app: Application) {
new HandlerService(app, {});
return new LuckyTurntableNewHandler(app);
}
export class LuckyTurntableNewHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async getTurntableData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 转转盘
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async pull(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let cost = playerData.getCost(count);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { result, records, goodResult, pool, floor } = playerData.pull(roleName, count);
await ActivityLuckyModel.updateData(serverId, activityId, roleId, playerData.roundIndex, { ...pick(playerData, ['todayCount', 'count', 'records', 'floorRecord']), refTodayCount: new Date() });
await addItems(roleId, roleName, sid, goodResult, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
return resResult(STATUS.SUCCESS, { result, records, todayCount: playerData.todayCount, count: playerData.count, pool, floor });
}
/**
* @description 领宝箱
* @param {{ activityId: number, boxCount: number }} msg
* @param {BackendSession} session
* @memberof LuckyHandler
*/
async receiveBox(msg: { activityId: number, boxCount: number }, session: BackendSession) {
const { activityId, boxCount } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let canReceive = playerData.canReceive(boxCount);
if (!canReceive) return resResult(STATUS.BOX_CAN_NOT_RECEIVE);
let box = playerData.findBox(boxCount);
let rewardArray = stringToRewardParam(box.rewards)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_TURNTABLE_RECEIVE_BOX);
await ActivityLuckyModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, boxCount);
return resResult(STATUS.SUCCESS, { ...result, box: { ...box, isReceived: true } });
}
}
@@ -1,98 +1,99 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerLuckyTurntableDataShow, getPlayerLuckyTurntableData } from '../../../services/activity/luckyTurntableService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { ActivityTurntableModel } from '../../../db/ActivityTurntableRec';
import { pick } from 'underscore';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
export default function (app: Application) {
new HandlerService(app, {});
return new LuckyTurntableHandler(app);
}
export class LuckyTurntableHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async getTurntableData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 转转盘
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async pull(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let cost = playerData.getCost(count);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { result, records, goodResult } = playerData.pull(roleName, count);
await ActivityTurntableModel.updateData(serverId, activityId, roleId, playerData.roundIndex, {...pick(playerData, ['todayCount', 'count', 'records', 'greatRewardCount']), refTodayCount: new Date()});
await addItems(roleId, roleName, sid, goodResult, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
return resResult(STATUS.SUCCESS, { result, records, todayCount: playerData.todayCount, count: playerData.count });
}
/**
* @description 领宝箱
* @param {{ activityId: number, boxCount: number }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async receiveBox(msg: { activityId: number, boxCount: number }, session: BackendSession) {
const { activityId, boxCount } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let canReceive = playerData.canReceive(boxCount);
if(!canReceive) return resResult(STATUS.BOX_CAN_NOT_RECEIVE);
let box = playerData.findBox(boxCount);
let rewardArray = stringToRewardParam(box.rewards)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_TURNTABLE_RECEIVE_BOX);
await ActivityTurntableModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, boxCount);
return resResult(STATUS.SUCCESS, { ...result, box: {...box, isReceived: true} });
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerLuckyTurntableDataShow, getPlayerLuckyTurntableData } from '../../../services/activity/luckyTurntableService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { ActivityTurntableModel } from '@db/ActivityTurntableRec';
import { pick } from 'underscore';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
export default function (app: Application) {
new HandlerService(app, {});
return new LuckyTurntableHandler(app);
}
export class LuckyTurntableHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async getTurntableData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableDataShow(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 转转盘
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async pull(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let cost = playerData.getCost(count);
let costResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let { result, records, goodResult } = playerData.pull(roleName, count);
await ActivityTurntableModel.updateData(serverId, activityId, roleId, playerData.roundIndex, {...pick(playerData, ['todayCount', 'count', 'records', 'greatRewardCount']), refTodayCount: new Date()});
await addItems(roleId, roleName, sid, goodResult, ITEM_CHANGE_REASON.ACT_TURNTABLE_PULL);
return resResult(STATUS.SUCCESS, { result, records, todayCount: playerData.todayCount, count: playerData.count });
}
/**
* @description 领宝箱
* @param {{ activityId: number, boxCount: number }} msg
* @param {BackendSession} session
* @memberof LuckyTurntableHandler
*/
async receiveBox(msg: { activityId: number, boxCount: number }, session: BackendSession) {
const { activityId, boxCount } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerLuckyTurntableData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let canReceive = playerData.canReceive(boxCount);
if(!canReceive) return resResult(STATUS.BOX_CAN_NOT_RECEIVE);
let box = playerData.findBox(boxCount);
let rewardArray = stringToRewardParam(box.rewards)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.ACT_TURNTABLE_RECEIVE_BOX);
await ActivityTurntableModel.receiveBox(serverId, activityId, roleId, playerData.roundIndex, boxCount);
return resResult(STATUS.SUCCESS, { ...result, box: {...box, isReceived: true} });
}
}
@@ -1,183 +1,184 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, getRandSingleEelm, parseNumberList, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { ActivityMidAutumnRecModel } from '../../../db/ActivityMidAutumnRec';
import { RewardInter } from '../../../pubUtils/interface';
import { getPlayerMidAutumnData, getPlayerMidAutumnDataShow } from '../../../services/activity/midAutumnService';
import { combineItems } from '../../../services/role/util';
export default function (app: Application) {
new HandlerService(app, {});
return new MidAutumnHandler(app);
}
export class MidAutumnHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 游戏开始
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
const gameCode = genCode(10);
let playerRecord = await ActivityMidAutumnRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, hasPass: false, isSkip: false
});
playerData.updatePlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode
});
}
/**
* @description 游戏结束
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
const { activityId, gameCode, isSuccess } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
let curRecord = playerData.records.find(cur => cur.gameCode == gameCode);
if(!curRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
if(curRecord.hasPass) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_HAS_PLAY);
let playerRecord = await ActivityMidAutumnRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), playerData.rewards);
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let goods: RewardInter[] = [];
if(isSuccess) {
let rewards = stringToRewardParam(playerData.rewards);
goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.MID_AUTUMN_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
goods
});
}
/**
* @description 扫荡
* @param {{ activityId: number, count: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameSweep(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt + count > playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
if(playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_SWEEP);
let rewards: RewardInter[] = [];
for(let i = 0; i < count; i++) {
let playerRecord = await ActivityMidAutumnRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode: 'sweep', time: new Date(), rewards: playerData.rewards, isSuccess: true, hasPass: true, isSkip: true
});
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
rewards.push(...stringToRewardParam(playerData.rewards));
}
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.MID_AUTUMN_REWARD);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_QIXI_BUY_COUNT_OVER);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityMidAutumnRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updatePlayerRecord(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, getRandSingleEelm, parseNumberList, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { ActivityMidAutumnRecModel } from '@db/ActivityMidAutumnRec';
import { RewardInter } from '@pubUtils/interface';
import { getPlayerMidAutumnData, getPlayerMidAutumnDataShow } from '../../../services/activity/midAutumnService';
import { combineItems } from '../../../services/role/util';
export default function (app: Application) {
new HandlerService(app, {});
return new MidAutumnHandler(app);
}
export class MidAutumnHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 游戏开始
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
const gameCode = genCode(10);
let playerRecord = await ActivityMidAutumnRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, hasPass: false, isSkip: false
});
playerData.updatePlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode
});
}
/**
* @description 游戏结束
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
const { activityId, gameCode, isSuccess } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
let curRecord = playerData.records.find(cur => cur.gameCode == gameCode);
if(!curRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
if(curRecord.hasPass) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_HAS_PLAY);
let playerRecord = await ActivityMidAutumnRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), playerData.rewards);
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let goods: RewardInter[] = [];
if(isSuccess) {
let rewards = stringToRewardParam(playerData.rewards);
goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.MID_AUTUMN_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
goods
});
}
/**
* @description 扫荡
* @param {{ activityId: number, count: number }} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async gameSweep(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt + count > playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_MID_AUTUMN_NO_NUM);
if(playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_SWEEP);
let rewards: RewardInter[] = [];
for(let i = 0; i < count; i++) {
let playerRecord = await ActivityMidAutumnRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode: 'sweep', time: new Date(), rewards: playerData.rewards, isSuccess: true, hasPass: true, isSkip: true
});
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
rewards.push(...stringToRewardParam(playerData.rewards));
}
let goods = await addItems(roleId, roleName, sid, combineItems(rewards), ITEM_CHANGE_REASON.MID_AUTUMN_REWARD);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof MidAutumnHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMidAutumnData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_QIXI_BUY_COUNT_OVER);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityMidAutumnRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updatePlayerRecord(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
@@ -1,217 +1,218 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, MINI_GAME_TYPE, REDIS_KEY, STATUS, TASK_TYPE } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerMiniGameData, getPlayerMiniGameDataShow } from '../../../services/activity/miniGameService';
import { ActivityMiniGameRecModel } from '../../../db/ActivityMiniGameRec';
import { ActivityMiniGameModel } from '../../../db/ActivityMiniGame';
import { handleCost } from '../../../services/role/rewardService';
import { Rank } from '../../../services/rankService';
import { nowSeconds } from '../../../pubUtils/timeUtil';
import { RoleRankInfo } from '../../../domain/rank';
import { getAllServerName } from '../../../services/redisService';
import { checkTask } from '../../../services/task/taskService';
export default function (app: Application) {
new HandlerService(app, {});
return new ForgeHandler(app);
}
export class ForgeHandler {
constructor(private app: Application) {
}
/**
* @description 小游戏数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getMiniGameActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 小游戏开始
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(playerData.playCnt >= playerData.buyCnt + playerData.freeCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_COUNT_LACK);
let record = await ActivityMiniGameRecModel.gameStart(serverId, activityId, playerData.roundIndex, playerData.todayIndex, roleId, playerData.gameType);
return resResult(STATUS.SUCCESS, {
activityId,
gameCode: record.gameCode,
playCnt: playerData.playCnt
});
}
/**
* @description 小游戏结束
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, score: number, params: number[] }, session: BackendSession) {
let { activityId, gameCode, score, params } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 记录得分&次数
let record = await ActivityMiniGameRecModel.gameEnd(activityId, roleId, gameCode, score, params);
if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
if(playerData.gameType == MINI_GAME_TYPE.CATCH_ZONGZI && score > 100) score = 100;
let playerRecord = await ActivityMiniGameModel.incScore(serverId, activityId, playerData.roundIndex, roleId, score, playerData.nextRefreshTime);
if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
playerData.setPlayerData(playerRecord);
playerData.incPlayCnt();
let rewards = stringToRewardParam(playerData.reward);
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
await r.setRankWithRoleInfo(roleId, score, nowSeconds(), null, true);
if(playerData.gameType == MINI_GAME_TYPE.SHOOT) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_SHOOT, { score });
} else if(playerData.gameType == MINI_GAME_TYPE.ERASE) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_ERASE, { step: params[0] });
} else if(playerData.gameType == MINI_GAME_TYPE.EAT_ZONGZI) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_EAT_ZONGZI, { score });
} else if(playerData.gameType == MINI_GAME_TYPE.CATCH_ZONGZI) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_CATCH_ZONGZI, { score });
} else {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_SCORE, { gameType: playerData.gameType, score });
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_STEP, { gameType: playerData.gameType, step: params[0] });
}
return resResult(STATUS.SUCCESS, {
activityId,
gameCode,
playCnt: playerData.playCnt,
score: playerData.score,
goods
});
}
/**
* @description 购买挑战次数
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_BUY_COUNT_MAX);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_MINI_GAME_BUY_CNT);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let playerRecord = await ActivityMiniGameModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count, playerData.nextRefreshTime);
playerData.setPlayerData(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
buyCnt: playerData.buyCnt,
maxBuyCnt: playerData.maxBuyCnt
});
}
/**
* @description 领取宝箱
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async receiveBox(msg: { activityId: number, boxId: number }, session: BackendSession) {
const { activityId, boxId } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = playerData.findBox(boxId);
if(!box) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_NOT_FOUND);
if(box.hasReceived) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
if(box.score > playerData.score) return resResult(STATUS.ACTIVITY_MINI_GAME_SCORE_NOT_ENOUGH);
let result = await ActivityMiniGameModel.receiveBox(serverId, activityId, playerData.roundIndex, roleId, boxId);
if(!result) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
playerData.setPlayerData(result);
let rewards = stringToRewardParam(box.reward);
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
return resResult(STATUS.SUCCESS, {
activityId,
curBox: playerData.findBox(boxId),
goods
});
}
/**
* @description 排行榜
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getRanks(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let serverNames = await getAllServerName();
let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
r.setGenerFieldsFun((obj => {
if(obj instanceof RoleRankInfo) {
return { rank: obj.rank, roleId: obj.roleId, name: obj.roleName, serverId: obj.serverId, serverName: serverNames[obj.serverId], num: obj.num }
}
return null
}));
let { ranks, myRank } = await r.getRankListWithMyRank({ roleId });
if (!myRank) {
myRank = await r.generMyRankWithRole(roleId, playerData.score, nowSeconds());
}
return resResult(STATUS.SUCCESS, {
activityId,
gameType: playerData.gameType,
ranks, myRank
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, MINI_GAME_TYPE, REDIS_KEY, STATUS, TASK_TYPE } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerMiniGameData, getPlayerMiniGameDataShow } from '../../../services/activity/miniGameService';
import { ActivityMiniGameRecModel } from '@db/ActivityMiniGameRec';
import { ActivityMiniGameModel } from '@db/ActivityMiniGame';
import { handleCost } from '../../../services/role/rewardService';
import { Rank } from '../../../services/rankService';
import { nowSeconds } from '@pubUtils/timeUtil';
import { RoleRankInfo } from '@domain/rank';
import { getAllServerName } from '../../../services/redisService';
import { checkTask } from '../../../services/task/taskService';
export default function (app: Application) {
new HandlerService(app, {});
return new ForgeHandler(app);
}
export class ForgeHandler {
constructor(private app: Application) {
}
/**
* @description 小游戏数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getMiniGameActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 小游戏开始
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(playerData.playCnt >= playerData.buyCnt + playerData.freeCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_COUNT_LACK);
let record = await ActivityMiniGameRecModel.gameStart(serverId, activityId, playerData.roundIndex, playerData.todayIndex, roleId, playerData.gameType);
return resResult(STATUS.SUCCESS, {
activityId,
gameCode: record.gameCode,
playCnt: playerData.playCnt
});
}
/**
* @description 小游戏结束
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, score: number, params: number[] }, session: BackendSession) {
let { activityId, gameCode, score, params } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 记录得分&次数
let record = await ActivityMiniGameRecModel.gameEnd(activityId, roleId, gameCode, score, params);
if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
if(playerData.gameType == MINI_GAME_TYPE.CATCH_ZONGZI && score > 100) score = 100;
let playerRecord = await ActivityMiniGameModel.incScore(serverId, activityId, playerData.roundIndex, roleId, score, playerData.nextRefreshTime);
if(!record) return resResult(STATUS.ACTIVITY_MINI_GAME_RECORD_NOT_FOUND);
playerData.setPlayerData(playerRecord);
playerData.incPlayCnt();
let rewards = stringToRewardParam(playerData.reward);
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
await r.setRankWithRoleInfo(roleId, score, nowSeconds(), null, true);
if(playerData.gameType == MINI_GAME_TYPE.SHOOT) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_SHOOT, { score });
} else if(playerData.gameType == MINI_GAME_TYPE.ERASE) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_ERASE, { step: params[0] });
} else if(playerData.gameType == MINI_GAME_TYPE.EAT_ZONGZI) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_EAT_ZONGZI, { score });
} else if(playerData.gameType == MINI_GAME_TYPE.CATCH_ZONGZI) {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_CATCH_ZONGZI, { score });
} else {
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_SCORE, { gameType: playerData.gameType, score });
await checkTask(serverId, roleId, sid, TASK_TYPE.MINI_GAME_STEP, { gameType: playerData.gameType, step: params[0] });
}
return resResult(STATUS.SUCCESS, {
activityId,
gameCode,
playCnt: playerData.playCnt,
score: playerData.score,
goods
});
}
/**
* @description 购买挑战次数
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_MINI_GAME_BUY_COUNT_MAX);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.consume), ITEM_CHANGE_REASON.ACT_MINI_GAME_BUY_CNT);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let playerRecord = await ActivityMiniGameModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count, playerData.nextRefreshTime);
playerData.setPlayerData(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
buyCnt: playerData.buyCnt,
maxBuyCnt: playerData.maxBuyCnt
});
}
/**
* @description 领取宝箱
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async receiveBox(msg: { activityId: number, boxId: number }, session: BackendSession) {
const { activityId, boxId } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let box = playerData.findBox(boxId);
if(!box) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_NOT_FOUND);
if(box.hasReceived) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
if(box.score > playerData.score) return resResult(STATUS.ACTIVITY_MINI_GAME_SCORE_NOT_ENOUGH);
let result = await ActivityMiniGameModel.receiveBox(serverId, activityId, playerData.roundIndex, roleId, boxId);
if(!result) return resResult(STATUS.ACTIVITY_MINI_GAME_BOX_HAS_RECEIVED);
playerData.setPlayerData(result);
let rewards = stringToRewardParam(box.reward);
let { goods } = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_MINI_GAME_REWARD);
return resResult(STATUS.SUCCESS, {
activityId,
curBox: playerData.findBox(boxId),
goods
});
}
/**
* @description 排行榜
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ForgeHandler
*/
async getRanks(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMiniGameData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let serverNames = await getAllServerName();
let r = new Rank(REDIS_KEY.ACTIVITY_MINI_GAME, { activityId, roundIndex: playerData.roundIndex });
r.setGenerFieldsFun((obj => {
if(obj instanceof RoleRankInfo) {
return { rank: obj.rank, roleId: obj.roleId, name: obj.roleName, serverId: obj.serverId, serverName: serverNames[obj.serverId], num: obj.num }
}
return null
}));
let { ranks, myRank } = await r.getRankListWithMyRank({ roleId });
if (!myRank) {
myRank = await r.generMyRankWithRole(roleId, playerData.score, nowSeconds());
}
return resResult(STATUS.SUCCESS, {
activityId,
gameType: playerData.gameType,
ranks, myRank
});
}
}
@@ -1,86 +1,87 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getMonthlyFundData, getMonthlyFundDataShow } from '../../../services/activity/monthlyFundService';
import { ActivityWeeklyFundModel } from '../../../db/ActivityWeeklyFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityMonthlyFundModel } from '../../../db/ActivityMonthlyFund';
import { monthlyFundSchedule } from '../../../services/timeTaskService';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new MonthlyFundHandler(app);
}
export class MonthlyFundHandler {
constructor(private app: Application) {
}
/************************月基金****************************/
/**
* @description 获取数据
* @param {BackendSession} session
* @memberof MonthlyFundHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getMonthlyFundDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到
* @param {BackendSession} session
* @memberof MonthlyFundHandler
*/
async sign(msg: { activityId: number, pageIndex: number, dayIndex: number }, session: BackendSession) {
const { activityId, pageIndex, dayIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getMonthlyFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pageData = playerData.findPage(pageIndex);
if (!pageData) return resResult(STATUS.ACTIVITY_MISSING);
if(!pageData.hasBought) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_NOT_BOUGHT);
let signReward = pageData.findSignReward(dayIndex);
if(!signReward) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_NOT_FOUND);
if(signReward.hasReceived) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_HAS_SIGN);
if(signReward.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_LOCK);
let record = await ActivityMonthlyFundModel.sign(serverId, activityId, roleId, playerData.roundIndex, pageIndex, dayIndex, playerData.todayIndex);
if(!record) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_HAS_SIGN);
pageData.setPlayerRecord(record);
if(pageData.hasReceivedAll()) {
await ActivityMonthlyFundModel.setReceivedAll(serverId, activityId, roleId, playerData.roundIndex, pageIndex);
}
let rewardParamArr = stringToRewardParam(signReward.reward);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.ACT_MONTHLY_FUND_SIGN);
return resResult(STATUS.SUCCESS, {
activityId, dayIndex, pageIndex, goods, addHeros
});
}
async debugSendMonthlyFundReward(msg: {}, session: BackendSession) {
await monthlyFundSchedule(parseInt(moment().format('YYYYMM')));
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getMonthlyFundData, getMonthlyFundDataShow } from '../../../services/activity/monthlyFundService';
import { ActivityWeeklyFundModel } from '@db/ActivityWeeklyFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityMonthlyFundModel } from '@db/ActivityMonthlyFund';
import { monthlyFundSchedule } from '../../../services/timeTaskService';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new MonthlyFundHandler(app);
}
export class MonthlyFundHandler {
constructor(private app: Application) {
}
/************************月基金****************************/
/**
* @description 获取数据
* @param {BackendSession} session
* @memberof MonthlyFundHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getMonthlyFundDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到
* @param {BackendSession} session
* @memberof MonthlyFundHandler
*/
async sign(msg: { activityId: number, pageIndex: number, dayIndex: number }, session: BackendSession) {
const { activityId, pageIndex, dayIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getMonthlyFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pageData = playerData.findPage(pageIndex);
if (!pageData) return resResult(STATUS.ACTIVITY_MISSING);
if(!pageData.hasBought) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_NOT_BOUGHT);
let signReward = pageData.findSignReward(dayIndex);
if(!signReward) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_NOT_FOUND);
if(signReward.hasReceived) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_HAS_SIGN);
if(signReward.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_LOCK);
let record = await ActivityMonthlyFundModel.sign(serverId, activityId, roleId, playerData.roundIndex, pageIndex, dayIndex, playerData.todayIndex);
if(!record) return resResult(STATUS.ACTIVITY_MONTHLY_FUND_HAS_SIGN);
pageData.setPlayerRecord(record);
if(pageData.hasReceivedAll()) {
await ActivityMonthlyFundModel.setReceivedAll(serverId, activityId, roleId, playerData.roundIndex, pageIndex);
}
let rewardParamArr = stringToRewardParam(signReward.reward);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.ACT_MONTHLY_FUND_SIGN);
return resResult(STATUS.SUCCESS, {
activityId, dayIndex, pageIndex, goods, addHeros
});
}
async debugSendMonthlyFundReward(msg: {}, session: BackendSession) {
await monthlyFundSchedule(parseInt(moment().format('YYYYMM')));
return resResult(STATUS.SUCCESS);
}
}
@@ -1,54 +1,55 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, } from '../../../consts';
import { getPlayerMonthlyTicketData, getPlayerMonthlyTicketDayReward } from '../../../services/activity/monthlyTicketService';
export default function (app: Application) {
new HandlerService(app, {});
return new MonthlyTicketHandler(app);
}
export class MonthlyTicketHandler {
constructor(private app: Application) {
}
/************************月卡活动****************************/
/**
* @description 获取月卡活动数据
* @param {BackendSession} session
* @memberof MonthlyTicketHandler
*/
async getMonthlyTicketActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMonthlyTicketData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 领取月卡奖品
* @param {BackendSession} session
* @memberof MonthlyTicketHandler
*/
async getMonthlyTicketReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let result = await getPlayerMonthlyTicketDayReward(roleId, roleName, sid, serverId, activityId)
if (result) {
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId },
}));
}
return resResult(STATUS.NO_MOTHLY_TICKET_REWARD);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, } from '../../../consts';
import { getPlayerMonthlyTicketData, getPlayerMonthlyTicketDayReward } from '../../../services/activity/monthlyTicketService';
export default function (app: Application) {
new HandlerService(app, {});
return new MonthlyTicketHandler(app);
}
export class MonthlyTicketHandler {
constructor(private app: Application) {
}
/************************月卡活动****************************/
/**
* @description 获取月卡活动数据
* @param {BackendSession} session
* @memberof MonthlyTicketHandler
*/
async getMonthlyTicketActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerMonthlyTicketData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 领取月卡奖品
* @param {BackendSession} session
* @memberof MonthlyTicketHandler
*/
async getMonthlyTicketReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let result = await getPlayerMonthlyTicketDayReward(roleId, roleName, sid, serverId, activityId)
if (result) {
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId },
}));
}
return resResult(STATUS.NO_MOTHLY_TICKET_REWARD);
}
}
@@ -1,74 +1,75 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerNewHeroGKData } from '../../../services/activity/newHeroGKService';
import { ActivityNewHeroGKModel } from '../../../db/ActivityNewHeroGK';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGKHandler(app);
}
export class NewHeroGKHandler {
constructor(private app: Application) {
}
/************************新将演绎 (通用每日关卡,分页,自定义每个关卡开放的时间长短);(配置N个武将,每个武将有X个关卡;活动期间,*天(时间自定义)开启每个武将对应的一个关卡,只有第一次通关会获得奖励)****************************/
/**
* @description 获取关卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGKHandler
*/
async getNewHeroGKActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, pageIndex: number, index:number}} msg
* @param {BackendSession} session
* @memberof NewHeroGKHandler
*/
async getGK(msg: { activityId: number, pageIndex: number, index: number }, session: BackendSession) {
const { activityId, pageIndex, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
// let playerData = await getPlayerNewHeroGKData(activityId, serverId, roleId)
// if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// let dailyItemData: NewHeroGKItem = playerData.findNewHeroGKItem(pageIndex, index);
// if (!dailyItemData) {
// return resResult(STATUS.ACTIVITY_DATA_ERROR);
// }
// if (dailyItemData.begin > playerData.todayIndex || dailyItemData.end < playerData.todayIndex) {
// return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
// }
// // await challengeNewHeroGK(serverId, roleId, activityId, pageIndex, dailyItemData.gk)
return resResult(STATUS.SUCCESS);
}
async debugResetGK(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
await ActivityNewHeroGKModel.deleteMany({ roleId });
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerNewHeroGKData } from '../../../services/activity/newHeroGKService';
import { ActivityNewHeroGKModel } from '@db/ActivityNewHeroGK';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGKHandler(app);
}
export class NewHeroGKHandler {
constructor(private app: Application) {
}
/************************新将演绎 (通用每日关卡,分页,自定义每个关卡开放的时间长短);(配置N个武将,每个武将有X个关卡;活动期间,*天(时间自定义)开启每个武将对应的一个关卡,只有第一次通关会获得奖励)****************************/
/**
* @description 获取关卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGKHandler
*/
async getNewHeroGKActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGKData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, pageIndex: number, index:number}} msg
* @param {BackendSession} session
* @memberof NewHeroGKHandler
*/
async getGK(msg: { activityId: number, pageIndex: number, index: number }, session: BackendSession) {
const { activityId, pageIndex, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
// let playerData = await getPlayerNewHeroGKData(activityId, serverId, roleId)
// if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// let dailyItemData: NewHeroGKItem = playerData.findNewHeroGKItem(pageIndex, index);
// if (!dailyItemData) {
// return resResult(STATUS.ACTIVITY_DATA_ERROR);
// }
// if (dailyItemData.begin > playerData.todayIndex || dailyItemData.end < playerData.todayIndex) {
// return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
// }
// // await challengeNewHeroGK(serverId, roleId, activityId, pageIndex, dailyItemData.gk)
return resResult(STATUS.SUCCESS);
}
async debugResetGK(msg: {}, session: BackendSession) {
const roleId = session.get('roleId');
await ActivityNewHeroGKModel.deleteMany({ roleId });
return resResult(STATUS.SUCCESS);
}
}
@@ -1,33 +1,34 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerNewHeroGachaData } from '../../../services/activity/newHeroService';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGachaHandler(app);
}
export class NewHeroGachaHandler {
constructor(private app: Application) {
}
/**
* @description 获取关卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGachaHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGachaData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerNewHeroGachaData } from '../../../services/activity/newHeroService';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGachaHandler(app);
}
export class NewHeroGachaHandler {
constructor(private app: Application) {
}
/**
* @description 获取关卡活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGachaHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGachaData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
}
@@ -1,73 +1,74 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerNewHeroGiftsData } from '../../../services/activity/newHeroService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityNewHeroGiftModel } from '../../../db/ActivityNewHeroGift';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGiftsHandler(app);
}
export class NewHeroGiftsHandler {
constructor(private app: Application) {
}
/************************新将好礼,很多红包,用积分兑换一遍结束****************************/
/**
* @description 获取新将好礼活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGiftsHandler
*/
async getNewHeroGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 兑换点数
* @param {{ activityId: number, index:number}} msg
* @param {BackendSession} session
* @memberof NewHeroGiftsHandler
*/
async exchangePoint(msg: { activityId: number, index: number }, session: BackendSession) {
const { activityId, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerNewHeroGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.findItem(index);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (item.countMax <= item.buyCount) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (playerData.consumePoint + playerData.consumeTotalPoint > playerData.totalPoint) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.NEW_HERO_EXCHANGE)
await ActivityNewHeroGiftModel.addReceiveRecord(serverId, activityId, roleId, index, playerData.consumePoint);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, index },
item: item, consumeTotalPoint: playerData.consumeTotalPoint + playerData.consumePoint
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerNewHeroGiftsData } from '../../../services/activity/newHeroService';
import { RewardParam } from '@domain/activityField/rewardField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityNewHeroGiftModel } from '@db/ActivityNewHeroGift';
export default function (app: Application) {
new HandlerService(app, {});
return new NewHeroGiftsHandler(app);
}
export class NewHeroGiftsHandler {
constructor(private app: Application) {
}
/************************新将好礼,很多红包,用积分兑换一遍结束****************************/
/**
* @description 获取新将好礼活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof NewHeroGiftsHandler
*/
async getNewHeroGiftsActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNewHeroGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 兑换点数
* @param {{ activityId: number, index:number}} msg
* @param {BackendSession} session
* @memberof NewHeroGiftsHandler
*/
async exchangePoint(msg: { activityId: number, index: number }, session: BackendSession) {
const { activityId, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerNewHeroGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.findItem(index);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (item.countMax <= item.buyCount) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (playerData.consumePoint + playerData.consumeTotalPoint > playerData.totalPoint) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.NEW_HERO_EXCHANGE)
await ActivityNewHeroGiftModel.addReceiveRecord(serverId, activityId, roleId, index, playerData.consumePoint);
item.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, index },
item: item, consumeTotalPoint: playerData.consumeTotalPoint + playerData.consumePoint
}));
}
}
@@ -1,170 +1,171 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getPlayerNovemberData, getPlayerNovemberDataShow } from '../../../services/activity/novemberServices';
import { genCode, getRandSingleEelm, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityNovemberRecModel, NovemberRecord } from '../../../db/ActivityNovemberRec';
import { RewardInter } from '../../../pubUtils/interface';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getZeroPoint } from '../../../pubUtils/timeUtil';
/**
* 辜月集会
* @param app
* @returns
*/
export default function (app: Application) {
new HandlerService(app, {});
return new NovemberHandler(app);
}
export class NovemberHandler {
constructor(private app: Application) {
}
/**
* 获取数据
* @param msg
* @param session
* @returns
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNovemberDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* 开始游戏
* @param msg
* @param session
* @returns
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData || playerData.menuIds.length == 0) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
const gameCode = genCode(10);
const menuId = getRandSingleEelm(playerData.menuIds);
await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, [{
todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, isSkip: false, menuId, hasPass: false
}]);
return resResult(STATUS.SUCCESS, { activityId, gameCode, menuId });
}
/**
* 结束游戏
* @param msg
* @param session
* @returns
*/
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
const { activityId, gameCode, isSuccess } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (!playerData.records || playerData.records.length == 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
let record = playerData.records.find(cur => cur.gameCode == gameCode);
if (!record) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
if (record.hasPass) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_USE);
let menuId = record.menuId;
// 检测挑战次数
if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
let rewards: string = playerData.successRewards;
if (!isSuccess) rewards = '&';//playerData.failRewards;
let playerRecord = await ActivityNovemberRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), rewards, true);
if (!playerRecord) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
let goods: RewardInter[] = await addItems(roleId, roleName, sid, stringToRewardParam(rewards), ITEM_CHANGE_REASON.NOVEMBER_REWARD);
return resResult(STATUS.SUCCESS, { activityId, menuId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, freeCnt: playerData.freeCnt, goods });
}
/**
* 购买次数
* @param msg
* @param session
* @returns
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_BUY_COUNT_OVER);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.NOVEMBER_COST);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let buyResult = await ActivityNovemberRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
if (!buyResult) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
return resResult(STATUS.SUCCESS, { activityId, buyCnt: playerData.buyCnt, maxBuyCnt: playerData.maxBuyCnt });
}
/**
* 扫荡
* @param msg
* @param session
* @returns
*/
async gameSweep(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.menuIds.length == 0) return (STATUS.ACTIVITY_NOVEMBER_MENU_NOT_FIND)
if (playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMESWEEP_LOCK);
if (playerData.playCnt + count > playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
let rewards: RewardInter[] = [];
let records: NovemberRecord[] = [];
for (let i = 0; i < count; i++) {
records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: playerData.successRewards, isSuccess: true, isSkip: true, menuId: 0, hasPass: true })
rewards.push(...stringToRewardParam(playerData.successRewards));
}
await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, records);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.NOVEMBER_REWARD)
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
return resResult(STATUS.SUCCESS, { activityId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, goods });
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { getPlayerNovemberData, getPlayerNovemberDataShow } from '../../../services/activity/novemberServices';
import { genCode, getRandSingleEelm, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { ActivityNovemberRecModel, NovemberRecord } from '@db/ActivityNovemberRec';
import { RewardInter } from '@pubUtils/interface';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getZeroPoint } from '@pubUtils/timeUtil';
/**
* 辜月集会
* @param app
* @returns
*/
export default function (app: Application) {
new HandlerService(app, {});
return new NovemberHandler(app);
}
export class NovemberHandler {
constructor(private app: Application) {
}
/**
* 获取数据
* @param msg
* @param session
* @returns
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNovemberDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* 开始游戏
* @param msg
* @param session
* @returns
*/
async gameStart(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData || playerData.menuIds.length == 0) return resResult(STATUS.ACTIVITY_MISSING);
// 检测挑战次数
if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
const gameCode = genCode(10);
const menuId = getRandSingleEelm(playerData.menuIds);
await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, [{
todayIndex: playerData.todayIndex, gameCode, time: new Date(), rewards: '', isSuccess: false, isSkip: false, menuId, hasPass: false
}]);
return resResult(STATUS.SUCCESS, { activityId, gameCode, menuId });
}
/**
* 结束游戏
* @param msg
* @param session
* @returns
*/
async gameEnd(msg: { activityId: number, gameCode: string, isSuccess: boolean }, session: BackendSession) {
const { activityId, gameCode, isSuccess } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (!playerData.records || playerData.records.length == 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
let record = playerData.records.find(cur => cur.gameCode == gameCode);
if (!record) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
if (record.hasPass) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_USE);
let menuId = record.menuId;
// 检测挑战次数
if (playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
let rewards: string = playerData.successRewards;
if (!isSuccess) rewards = '&';//playerData.failRewards;
let playerRecord = await ActivityNovemberRecModel.gameEnd(serverId, activityId, playerData.roundIndex, roleId, gameCode, isSuccess, new Date(), rewards, true);
if (!playerRecord) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
let goods: RewardInter[] = await addItems(roleId, roleName, sid, stringToRewardParam(rewards), ITEM_CHANGE_REASON.NOVEMBER_REWARD);
return resResult(STATUS.SUCCESS, { activityId, menuId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, freeCnt: playerData.freeCnt, goods });
}
/**
* 购买次数
* @param msg
* @param session
* @returns
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_BUY_COUNT_OVER);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.NOVEMBER_COST);
if (!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let buyResult = await ActivityNovemberRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
if (!buyResult) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMECODE_NOT_FOUND);
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
return resResult(STATUS.SUCCESS, { activityId, buyCnt: playerData.buyCnt, maxBuyCnt: playerData.maxBuyCnt });
}
/**
* 扫荡
* @param msg
* @param session
* @returns
*/
async gameSweep(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerNovemberData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.menuIds.length == 0) return (STATUS.ACTIVITY_NOVEMBER_MENU_NOT_FIND)
if (playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_NOVEMBER_GAMESWEEP_LOCK);
if (playerData.playCnt + count > playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_NOVEMBER_NO_NUM);
let rewards: RewardInter[] = [];
let records: NovemberRecord[] = [];
for (let i = 0; i < count; i++) {
records.push({ todayIndex: playerData.todayIndex, gameCode: 'sweep', time: new Date(), rewards: playerData.successRewards, isSuccess: true, isSkip: true, menuId: 0, hasPass: true })
rewards.push(...stringToRewardParam(playerData.successRewards));
}
await ActivityNovemberRecModel.records(serverId, activityId, playerData.roundIndex, roleId, records);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.NOVEMBER_REWARD)
playerData = await getPlayerNovemberData(activityId, serverId, roleId);
return resResult(STATUS.SUCCESS, { activityId, todayPlayCnt: playerData.todayPlayCnt, playCnt: playerData.playCnt, goods });
}
}
@@ -1,197 +1,198 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult, } from '../../../pubUtils/util';
import { STATUS, ITEM_CHANGE_REASON, POP_UP_SHOP_CONDITION_TYPE, ACTIVITY_TYPE, DEBUG_MAGIC_WORD, PUSH_ROUTE, } from '../../../consts';
import { checkPopUpCondition, getPopUpShopData, getPopUpShopDataShow } from '../../../services/activity/popUpShopService';
import { ActivityPopUpShopModel } from '../../../db/ActivityPopUpShop';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { handleCost } from '../../../services/role/rewardService';
import { setInterval } from 'timers';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new PopUpShopHandler(app);
}
export class PopUpShopHandler {
constructor(private app: Application) {
}
/************************弹出式商店****************************/
/**
* @description 获取弹出式商店数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof PopUpShopHandler
*/
async getPopUpShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPopUpShopDataShow(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_THIRTY_DAYS_END);
return resResult(STATUS.SUCCESS, { playerData });
}
async checkPopUpCondition(msg: { conditionType: number }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { conditionType } = msg;
if(
conditionType != POP_UP_SHOP_CONDITION_TYPE.GACHA_RES_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.TERAPH_RES_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.STONE_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.EQUIP_STAR_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.FAVOR_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.EXP_NOT_ENOUGH
) {
return resResult(STATUS.WRONG_PARMS);
}
await checkPopUpCondition(serverId, roleId, conditionType, {});
return resResult(STATUS.SUCCESS);
}
/**
* @description 购买礼包
* @param {{ activityId: number, id: number, beginTimeStamp: number}} msg
* @param {BackendSession} session
* @memberof PopUpShopHandler
*/
async buyGift(msg: { activityId: number, id: number, code: string }, session: BackendSession) {
const { activityId, code, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPopUpShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.type !== ACTIVITY_TYPE.POP_UP_SHOP) {
return resResult(STATUS.ACTIVITY_TYPE_ERROR);
}
let record = await ActivityPopUpShopModel.findByCode(serverId, activityId, roleId, code);
if(!record) return resResult(STATUS.ACTIVITY_TASK_NOT_COMPLETE);
let pkg = playerData.findPackageById(record.id);
let item = pkg?.findItemById(id);
if(!item) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if(item.productID) {
return resResult(STATUS.ACTIVITY_POP_UP_MUST_BUY);
}
let consume = stringToConsumeParam(item.consume);
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT);
if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
record = await ActivityPopUpShopModel.addRecordById(serverId, activityId, roleId, code, id);
let showItem = playerData.updateRecordById(record, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT)
return resResult(STATUS.SUCCESS, {
...result, param: { activityId, id },
item: showItem
});
}
// 客户端展示弹出礼包的通知
async showGift(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let rec = await ActivityPopUpShopModel.show(code);
if (!rec) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS);
}
async debugPushPopUpShop(msg: { conditionType: number, magicWord: string, param: number, needDelete: boolean }, session: BackendSession) {
const roleId = session.get('roleId');
let serverId = session.get('serverId');
const { magicWord, conditionType, param } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
// let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.POP_UP_SHOP);
// for(let { activityId } of activities) {
// let playerData = await getPopUpShopData(activityId, serverId, roleId);
// for(let pkg of playerData.packages) {
// if(pkg.conditionType == conditionType) {
// await ActivityPopUpShopModel.deleteMany({ roleId, activityId, id: pkg.id });
// }
// }
// }
let arr = await checkPopUpCondition(serverId, roleId, conditionType, {
oldLv: param? param - 1: 0,
newLv: param||100,
quality: param||3,
warId: param||128,
seasonWinNum: param||10,
equipStar: param||10
});
return resResult(STATUS.SUCCESS, { activities:arr });
}
private interval: NodeJS.Timer;
private pushId = 0;
async debugPushPopUpInterval(msg: { magicWord: string }, session: BackendSession) {
const roleId = session.get('roleId');
let sid = session.get('sid');
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
if(this.interval) {
clearInterval(this.interval);
}
let fun = async () => {
await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ACTIVITY_UPDATE, {
activities: [{
activityId: 25,
activityType: 24,
param: { popUpShopItems: [
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":1,"name":"超值第一章通关礼包","price":6,"productID":"com.bantu.sgzzyz.yb34-20","consume":"&","reward":"2&11002&20|2&22001&2|2&31001&10000","rebate":1000,"buyCnt":1,"hasBoughtCnt":0},
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":2,"name":"超值第一章通关礼包","price":30,"productID":"com.bantu.sgzzyz.yb34-21","consume":"&","reward":"2&11002&40|2&22001&10|2&31001&20000","rebate":850,"buyCnt":1,"hasBoughtCnt":0},
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":3,"name":"超值第一章通关礼包","price":68,"productID":"com.bantu.sgzzyz.yb34-22","consume":"&","reward":"2&11003&20|2&22001&25|2&31001&40000","rebate":950,"buyCnt":1,"hasBoughtCnt":0}
]},
}],
pushId: ++this.pushId
}, sid);
};
await fun();
this.interval = setInterval(fun, 60000)
return resResult(STATUS.SUCCESS);
}
async debugStopPupUpInterval(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
if(this.interval) {
clearInterval(this.interval);
}
this.pushId = 0;
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult, } from '@pubUtils/util';
import { STATUS, ITEM_CHANGE_REASON, POP_UP_SHOP_CONDITION_TYPE, ACTIVITY_TYPE, DEBUG_MAGIC_WORD, PUSH_ROUTE, } from '../../../consts';
import { checkPopUpCondition, getPopUpShopData, getPopUpShopDataShow } from '../../../services/activity/popUpShopService';
import { ActivityPopUpShopModel } from '@db/ActivityPopUpShop';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { handleCost } from '../../../services/role/rewardService';
import { setInterval } from 'timers';
import { sendMessageToUserWithSuc } from '../../../services/pushService';
export default function (app: Application) {
new HandlerService(app, {});
return new PopUpShopHandler(app);
}
export class PopUpShopHandler {
constructor(private app: Application) {
}
/************************弹出式商店****************************/
/**
* @description 获取弹出式商店数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof PopUpShopHandler
*/
async getPopUpShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPopUpShopDataShow(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_THIRTY_DAYS_END);
return resResult(STATUS.SUCCESS, { playerData });
}
async checkPopUpCondition(msg: { conditionType: number }, session: BackendSession) {
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let { conditionType } = msg;
if(
conditionType != POP_UP_SHOP_CONDITION_TYPE.GACHA_RES_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.TERAPH_RES_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.STONE_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.EQUIP_STAR_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.FAVOR_NOT_ENOUGH &&
conditionType != POP_UP_SHOP_CONDITION_TYPE.EXP_NOT_ENOUGH
) {
return resResult(STATUS.WRONG_PARMS);
}
await checkPopUpCondition(serverId, roleId, conditionType, {});
return resResult(STATUS.SUCCESS);
}
/**
* @description 购买礼包
* @param {{ activityId: number, id: number, beginTimeStamp: number}} msg
* @param {BackendSession} session
* @memberof PopUpShopHandler
*/
async buyGift(msg: { activityId: number, id: number, code: string }, session: BackendSession) {
const { activityId, code, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPopUpShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.type !== ACTIVITY_TYPE.POP_UP_SHOP) {
return resResult(STATUS.ACTIVITY_TYPE_ERROR);
}
let record = await ActivityPopUpShopModel.findByCode(serverId, activityId, roleId, code);
if(!record) return resResult(STATUS.ACTIVITY_TASK_NOT_COMPLETE);
let pkg = playerData.findPackageById(record.id);
let item = pkg?.findItemById(id);
if(!item) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if(item.productID) {
return resResult(STATUS.ACTIVITY_POP_UP_MUST_BUY);
}
let consume = stringToConsumeParam(item.consume);
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT);
if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
record = await ActivityPopUpShopModel.addRecordById(serverId, activityId, roleId, code, id);
let showItem = playerData.updateRecordById(record, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.POP_UP_BUY_GIFT)
return resResult(STATUS.SUCCESS, {
...result, param: { activityId, id },
item: showItem
});
}
// 客户端展示弹出礼包的通知
async showGift(msg: { code: string }, session: BackendSession) {
const { code } = msg;
let rec = await ActivityPopUpShopModel.show(code);
if (!rec) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS);
}
async debugPushPopUpShop(msg: { conditionType: number, magicWord: string, param: number, needDelete: boolean }, session: BackendSession) {
const roleId = session.get('roleId');
let serverId = session.get('serverId');
const { magicWord, conditionType, param } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
// let activities = await getActivitiesByType(serverId, ACTIVITY_TYPE.POP_UP_SHOP);
// for(let { activityId } of activities) {
// let playerData = await getPopUpShopData(activityId, serverId, roleId);
// for(let pkg of playerData.packages) {
// if(pkg.conditionType == conditionType) {
// await ActivityPopUpShopModel.deleteMany({ roleId, activityId, id: pkg.id });
// }
// }
// }
let arr = await checkPopUpCondition(serverId, roleId, conditionType, {
oldLv: param? param - 1: 0,
newLv: param||100,
quality: param||3,
warId: param||128,
seasonWinNum: param||10,
equipStar: param||10
});
return resResult(STATUS.SUCCESS, { activities:arr });
}
private interval: NodeJS.Timer;
private pushId = 0;
async debugPushPopUpInterval(msg: { magicWord: string }, session: BackendSession) {
const roleId = session.get('roleId');
let sid = session.get('sid');
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
if(this.interval) {
clearInterval(this.interval);
}
let fun = async () => {
await sendMessageToUserWithSuc(roleId, PUSH_ROUTE.ACTIVITY_UPDATE, {
activities: [{
activityId: 25,
activityType: 24,
param: { popUpShopItems: [
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":1,"name":"超值第一章通关礼包","price":6,"productID":"com.bantu.sgzzyz.yb34-20","consume":"&","reward":"2&11002&20|2&22001&2|2&31001&10000","rebate":1000,"buyCnt":1,"hasBoughtCnt":0},
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":2,"name":"超值第一章通关礼包","price":30,"productID":"com.bantu.sgzzyz.yb34-21","consume":"&","reward":"2&11002&40|2&22001&10|2&31001&20000","rebate":850,"buyCnt":1,"hasBoughtCnt":0},
{"code":"eefXmwD2","packageId":5,"endTime":Date.now() + 60000,"id":3,"name":"超值第一章通关礼包","price":68,"productID":"com.bantu.sgzzyz.yb34-22","consume":"&","reward":"2&11003&20|2&22001&25|2&31001&40000","rebate":950,"buyCnt":1,"hasBoughtCnt":0}
]},
}],
pushId: ++this.pushId
}, sid);
};
await fun();
this.interval = setInterval(fun, 60000)
return resResult(STATUS.SUCCESS);
}
async debugStopPupUpInterval(msg: { magicWord: string }, session: BackendSession) {
const { magicWord } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
if(this.interval) {
clearInterval(this.interval);
}
this.pushId = 0;
return resResult(STATUS.SUCCESS);
}
}
@@ -1,186 +1,187 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, getRandSingleEelm, parseNumberList, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { getPlayerQixiData, getPlayerQixiDataShow } from '../../../services/activity/qixiService';
import { ActivityQixiRecModel } from '../../../db/ActivityQixiRec';
import { RewardInter } from '../../../pubUtils/interface';
export default function (app: Application) {
new HandlerService(app, {});
return new QiXiHandler(app);
}
export class QiXiHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 召唤鹊桥游戏
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameStart(msg: { activityId: number, progress: number }, session: BackendSession) {
const { activityId, progress } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.progress != progress) return resResult(STATUS.ACTIVITY_QIXI_PROGRESS_NOT_FIT);
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
const gameCode = genCode(10);
let playerRecord = await ActivityQixiRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode, time: new Date(), rewards: '', progress, afterProgress: progress, hasPass: false
});
playerData.updatePlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
progress: playerData.progress
});
}
/**
* @description 召唤鹊桥游戏
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, progress: number, addProgress: number }, session: BackendSession) {
const { activityId, gameCode, progress, addProgress } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.progress != progress) return resResult(STATUS.ACTIVITY_QIXI_PROGRESS_NOT_FIT);
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
let curRecord = playerData.records.find(cur => cur.gameCode == gameCode);
if(!curRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
if(curRecord.hasPass) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_HAS_PLAY);
let playerRecord = await ActivityQixiRecModel.addProgress(serverId, activityId, playerData.roundIndex, roleId, gameCode, addProgress, new Date());
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let goods: RewardInter[] = [];
if(playerData.progress >= playerData.maxProgress) {
await ActivityQixiRecModel.recordReward(serverId, activityId, playerData.roundIndex, roleId, gameCode, playerData.rewards);
let rewards = stringToRewardParam(playerData.rewards);
goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.QIXI_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
progress: playerData.progress,
goods
});
}
/**
* @description 扫荡
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameSweep(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
if(playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_SWEEP);
let playerRecord = await ActivityQixiRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode: '', time: new Date(), rewards: playerData.rewards, progress: 0, afterProgress: playerData.maxProgress, hasPass: true, isSkip: true
});
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let rewards = stringToRewardParam(playerData.rewards);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.QIXI_REWARD)
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
progress: playerData.progress,
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_QIXI_BUY_COUNT_OVER);
// if(playerData.playCnt < playerData.freeCnt) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_BUY);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityQixiRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updatePlayerRecord(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { genCode, getRandSingleEelm, parseNumberList, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { addItems, handleCost } from '../../../services/role/rewardService';
import { getPlayerQixiData, getPlayerQixiDataShow } from '../../../services/activity/qixiService';
import { ActivityQixiRecModel } from '@db/ActivityQixiRec';
import { RewardInter } from '@pubUtils/interface';
export default function (app: Application) {
new HandlerService(app, {});
return new QiXiHandler(app);
}
export class QiXiHandler {
constructor(private app: Application) {
}
/**
* @description 获取火神祭祀活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 召唤鹊桥游戏
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameStart(msg: { activityId: number, progress: number }, session: BackendSession) {
const { activityId, progress } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.progress != progress) return resResult(STATUS.ACTIVITY_QIXI_PROGRESS_NOT_FIT);
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
const gameCode = genCode(10);
let playerRecord = await ActivityQixiRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode, time: new Date(), rewards: '', progress, afterProgress: progress, hasPass: false
});
playerData.updatePlayerRecord(playerRecord);
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
progress: playerData.progress
});
}
/**
* @description 召唤鹊桥游戏
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameEnd(msg: { activityId: number, gameCode: string, progress: number, addProgress: number }, session: BackendSession) {
const { activityId, gameCode, progress, addProgress } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.progress != progress) return resResult(STATUS.ACTIVITY_QIXI_PROGRESS_NOT_FIT);
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
let curRecord = playerData.records.find(cur => cur.gameCode == gameCode);
if(!curRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
if(curRecord.hasPass) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_HAS_PLAY);
let playerRecord = await ActivityQixiRecModel.addProgress(serverId, activityId, playerData.roundIndex, roleId, gameCode, addProgress, new Date());
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let goods: RewardInter[] = [];
if(playerData.progress >= playerData.maxProgress) {
await ActivityQixiRecModel.recordReward(serverId, activityId, playerData.roundIndex, roleId, gameCode, playerData.rewards);
let rewards = stringToRewardParam(playerData.rewards);
goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.QIXI_REWARD)
}
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
gameCode,
progress: playerData.progress,
goods
});
}
/**
* @description 扫荡
* @param {{ activityId: number }} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async gameSweep(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId: string = session.get('roleId');
const roleName: string = session.get('roleName');
const serverId: number = session.get('serverId');
const sid: string = session.get('sid');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 挑战次数
if(playerData.playCnt >= playerData.freeCnt + playerData.buyCnt) return resResult(STATUS.ACTIVITY_QIXI_NO_NUM);
if(playerData.todayPlayCnt <= 0) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_SWEEP);
let playerRecord = await ActivityQixiRecModel.record(serverId, activityId, playerData.roundIndex, roleId, {
todayIndex: playerData.recordTodayIndex, gameCode: '', time: new Date(), rewards: playerData.rewards, progress: 0, afterProgress: playerData.maxProgress, hasPass: true, isSkip: true
});
if(!playerRecord) return resResult(STATUS.ACTIVITY_QIXI_GAMECODE_NOT_FOUND);
playerData.updatePlayerRecord(playerRecord);
let rewards = stringToRewardParam(playerData.rewards);
let goods = await addItems(roleId, roleName, sid, rewards, ITEM_CHANGE_REASON.QIXI_REWARD)
return resResult(STATUS.SUCCESS, {
activityId,
todayPlayCnt: playerData.todayPlayCnt,
playCnt: playerData.playCnt,
freeCnt: playerData.freeCnt,
progress: playerData.progress,
goods
});
}
/**
* @description 购买次数
* @param {{ activityId: number, id: number, count: number}} msg
* @param {BackendSession} session
* @memberof QiXiHandler
*/
async buyCnt(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getPlayerQixiData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
// 可购买次数
if(playerData.buyCnt + count > playerData.maxBuyCnt) return resResult(STATUS.ACTIVITY_QIXI_BUY_COUNT_OVER);
// if(playerData.playCnt < playerData.freeCnt) return resResult(STATUS.ACTIVITY_QIXI_CANNOT_BUY);
// 扣材料
let costResult = await handleCost(roleId, sid, stringToConsumeParam(playerData.buyCost), ITEM_CHANGE_REASON.ACT_ENTERTAIN_BUY_COST);
if(!costResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
// 保存数据
let buildResult = await ActivityQixiRecModel.buyCnt(serverId, activityId, playerData.roundIndex, roleId, count);
// // 更新数据
playerData.updatePlayerRecord(buildResult);
return resResult(STATUS.SUCCESS, {
activityId,
maxBuyCnt: playerData.maxBuyCnt,
buyCnt: playerData.buyCnt
});
}
}
@@ -1,78 +1,79 @@
import { Application, BackendSession, HandlerService } from 'pinus';
import { genCode, resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerRebateDataShow, getPlayerRebateData } from '../../../services/activity/rebateService';
import { HistoryOrderModel } from '../../../db/HistoryOrder';
import { UserModel } from '../../../db/User';
export default function (app: Application) {
new HandlerService(app, {});
return new RebateHandler(app);
}
export class RebateHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let playerData = await getPlayerRebateDataShow(activityId, roleId, serverId, uid);
return resResult(STATUS.SUCCESS, {
playerData
})
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof RebateHandler
*/
async receiveReward(msg: { activityId: number, day: number }, session: BackendSession) {
const { activityId, day } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getPlayerRebateData(activityId, roleId, serverId, uid);
let item = playerData.findRebateByDay(day);
if(!item) return resResult(STATUS.WRONG_PARMS);
if(item.day > playerData.todayIndex) return resResult(STATUS.ACTIVITY_REBATE_DAY_NOT_REACH);
if(item.hasReceived) return resResult(STATUS.ACTIVITY_REBATE_HAS_RECEIVED);
// console.log('####', playerData.channelId, roleId, day)
await HistoryOrderModel.receive(playerData.channelId, roleId, day);
let rewardArray = stringToRewardParam(item.rewards);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.RECEIVE_REBATE);
return resResult(STATUS.SUCCESS, {
activityId, day,
hasReceived: true,
goods, addHeros
});
}
// debug接口,让自己能返利
async debugSetRebate(msg: { totalPay: number }, session: BackendSession) {
const { totalPay } = msg;
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
if(!user.channelId) {
user = await UserModel.findOneAndUpdate({ uid }, { $set: { channelId: genCode(10) } }, { new: true }).lean();
}
await HistoryOrderModel.deleteMany({ channelId: user.channelId });
await HistoryOrderModel.insertMany([{ channelId: user.channelId, totalPay }]);
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService } from 'pinus';
import { genCode, resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { getPlayerRebateDataShow, getPlayerRebateData } from '../../../services/activity/rebateService';
import { HistoryOrderModel } from '@db/HistoryOrder';
import { UserModel } from '@db/User';
export default function (app: Application) {
new HandlerService(app, {});
return new RebateHandler(app);
}
export class RebateHandler {
constructor(private app: Application) {
}
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const uid = session.get('userid');
let playerData = await getPlayerRebateDataShow(activityId, roleId, serverId, uid);
return resResult(STATUS.SUCCESS, {
playerData
})
}
/**
* @description 领取奖励
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof RebateHandler
*/
async receiveReward(msg: { activityId: number, day: number }, session: BackendSession) {
const { activityId, day } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
const uid = session.get('userid');
let playerData = await getPlayerRebateData(activityId, roleId, serverId, uid);
let item = playerData.findRebateByDay(day);
if(!item) return resResult(STATUS.WRONG_PARMS);
if(item.day > playerData.todayIndex) return resResult(STATUS.ACTIVITY_REBATE_DAY_NOT_REACH);
if(item.hasReceived) return resResult(STATUS.ACTIVITY_REBATE_HAS_RECEIVED);
// console.log('####', playerData.channelId, roleId, day)
await HistoryOrderModel.receive(playerData.channelId, roleId, day);
let rewardArray = stringToRewardParam(item.rewards);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.RECEIVE_REBATE);
return resResult(STATUS.SUCCESS, {
activityId, day,
hasReceived: true,
goods, addHeros
});
}
// debug接口,让自己能返利
async debugSetRebate(msg: { totalPay: number }, session: BackendSession) {
const { totalPay } = msg;
const uid = session.get('userid');
let user = await UserModel.findUserByUid(uid);
if(!user.channelId) {
user = await UserModel.findOneAndUpdate({ uid }, { $set: { channelId: genCode(10) } }, { new: true }).lean();
}
await HistoryOrderModel.deleteMany({ channelId: user.channelId });
await HistoryOrderModel.insertMany([{ channelId: user.channelId, totalPay }]);
return resResult(STATUS.SUCCESS);
}
}
@@ -1,75 +1,76 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRechargeMoneyData, getPlayerRechargeMoneyDataShow } from '../../../services/activity/rechargeMoneyService';
import { RechargeMoneyPool } from '../../../domain/activityField/rechargeMoneyField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityRechargeMoneyModel } from '../../../db/ActivityRechargeMoney';
import { addItems } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new RechargeMoneyHandler(app);
}
export class RechargeMoneyHandler {
constructor(private app: Application) {
}
/************************每日累计充值****************************/
/**
* @description 获取活动数据
* @param {BackendSession} session
* @memberof RechargeMoneyHandler
*/
async getRechargeMoneyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRechargeMoneyDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, {playerData});
}
/**
* @description 获取奖励
* @param {BackendSession} session
* @memberof RechargeMoneyHandler
*/
async pull(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.ticketCnt <= 0) {
return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
}
let item = playerData.pull();
if (!item) {
return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
}
let notGetRecord = playerData.recordArr[0];
// console.log('notGetRecord', JSON.stringify(notGetRecord));
await ActivityRechargeMoneyModel.addRecord(notGetRecord._id, item.id, `${item.gid}&${item.count}`);
let goods = await addItems(roleId, roleName, sid, [{ id: item.gid, count: item.count }], ITEM_CHANGE_REASON.RECHARGE_REWARD)
return resResult(STATUS.SUCCESS, {
param: { activityId },
item: item,
ticketCnt: playerData.ticketCnt,
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRechargeMoneyData, getPlayerRechargeMoneyDataShow } from '../../../services/activity/rechargeMoneyService';
import { RechargeMoneyPool } from '@domain/activityField/rechargeMoneyField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityRechargeMoneyModel } from '@db/ActivityRechargeMoney';
import { addItems } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new RechargeMoneyHandler(app);
}
export class RechargeMoneyHandler {
constructor(private app: Application) {
}
/************************每日累计充值****************************/
/**
* @description 获取活动数据
* @param {BackendSession} session
* @memberof RechargeMoneyHandler
*/
async getRechargeMoneyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRechargeMoneyDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, {playerData});
}
/**
* @description 获取奖励
* @param {BackendSession} session
* @memberof RechargeMoneyHandler
*/
async pull(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.ticketCnt <= 0) {
return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
}
let item = playerData.pull();
if (!item) {
return resResult(STATUS.ACTIVITY_RECHARGE_TICKET_NOT_ENOUGH);
}
let notGetRecord = playerData.recordArr[0];
// console.log('notGetRecord', JSON.stringify(notGetRecord));
await ActivityRechargeMoneyModel.addRecord(notGetRecord._id, item.id, `${item.gid}&${item.count}`);
let goods = await addItems(roleId, roleName, sid, [{ id: item.gid, count: item.count }], ITEM_CHANGE_REASON.RECHARGE_REWARD)
return resResult(STATUS.SUCCESS, {
param: { activityId },
item: item,
ticketCnt: playerData.ticketCnt,
});
}
}
@@ -1,91 +1,92 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRefreshShopData } from '../../../services/activity/refreshShopService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityRefreshShopModel } from '../../../db/ActivityRefreshShop';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new RefreshShopHandler(app);
}
export class RefreshShopHandler {
constructor(private app: Application) {
}
/************************通用的刷新商店(分页,可刷新,限制购买次数,支持rmb与资源兑换)****************************/
/**
* @description 获取商店数据
* @param {{ activityId:number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async getRefreshShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRefreshShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 购买
* @param {{ activityId: number, roundIndex: number, id: number, pageIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async buyGood(msg: { activityId: number, roundIndex: number, id: number, pageIndex: number, count: number }, session: BackendSession) {
const { activityId, roundIndex, id, pageIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let item = playerData.findItem(id, pageIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consumeArr = new Array<string>(count).fill(item.consume);
let consume = stringToConsumeParam(...consumeArr);
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
await ActivityRefreshShopModel.addRecord(activityId, roleId, roundIndex, pageIndex, id, count);
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, id },
item: item
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRefreshShopData } from '../../../services/activity/refreshShopService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ActivityRefreshShopModel } from '@db/ActivityRefreshShop';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new RefreshShopHandler(app);
}
export class RefreshShopHandler {
constructor(private app: Application) {
}
/************************通用的刷新商店(分页,可刷新,限制购买次数,支持rmb与资源兑换)****************************/
/**
* @description 获取商店数据
* @param {{ activityId:number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async getRefreshShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRefreshShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 购买
* @param {{ activityId: number, roundIndex: number, id: number, pageIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshShopHandler
*/
async buyGood(msg: { activityId: number, roundIndex: number, id: number, pageIndex: number, count: number }, session: BackendSession) {
const { activityId, roundIndex, id, pageIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshShopData(activityId, serverId, roleId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let item = playerData.findItem(id, pageIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_ID_ERROR);
}
if (item.countMax > 0 && item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consumeArr = new Array<string>(count).fill(item.consume);
let consume = stringToConsumeParam(...consumeArr);
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let rewardArray = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.BUY_REFRESH_SHOP);
await ActivityRefreshShopModel.addRecord(activityId, roleId, roundIndex, pageIndex, id, count);
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, id },
item: item
}));
}
}
@@ -1,123 +1,124 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRefreshTaskData } from '../../../services/activity/refreshTaskService';
import { RefreshTaskItem } from '../../../domain/activityField/refreshTaskField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityRefreshTaskModel } from '../../../db/ActivityRefreshTask';
import { ActivityRefreshTaskPointModel } from '../../../db/ActivityRefreshTaskPoint';
export default function (app: Application) {
new HandlerService(app, {});
return new RefreshTaskHandler(app);
}
export class RefreshTaskHandler {
constructor(private app: Application) {
}
/************************通用的刷新任务(分页,可刷新,限制领取次数)****************************/
/**
* @description 获取任务活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async getRefreshTaskActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取奖励
* @param {{ activityId: number, roundIndex: number, pageIndex: number,id: number, type: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async getReward(msg: { activityId: number, roundIndex: number, pageIndex: number, id: number, type: number }, session: BackendSession) {
const { activityId, roundIndex, pageIndex, id, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let dailyItemData: RefreshTaskItem = playerData.findItem(pageIndex, id, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (dailyItemData.totalCount < dailyItemData.condition) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (dailyItemData.receiveRewardCount) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityRefreshTaskModel.addReceiveRecord(serverId, activityId, roleId, roundIndex, pageIndex, id, dailyItemData.getRefTime(), 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_REWARD)
//获得点数
await ActivityRefreshTaskPointModel.addPoint(serverId, activityId, roleId, dailyItemData.point);
dailyItemData.receiveRewardCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, pageIndex, id, type },
item: dailyItemData,
totalPoint: playerData.totalPoint + dailyItemData.point,
}));
}
/**
* @description 兑换点数
* @param {{ activityId: number, roundIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async exchangePoint(msg: { activityId: number, roundIndex: number }, session: BackendSession) {
const { activityId, roundIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
if ((playerData.totalPoint - playerData.exchangePoint) < playerData.consumePoint) {//点数不够
return resResult(STATUS.ACTIVITY_NO_POINT);
}
await ActivityRefreshTaskPointModel.addReceiveRecord(serverId, activityId, roleId, playerData.consumePoint);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_EXCHANGE)
playerData.exchangePoint += playerData.consumePoint;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex },
item: { exchangePoint: playerData.exchangePoint },
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getPlayerRefreshTaskData } from '../../../services/activity/refreshTaskService';
import { RefreshTaskItem } from '@domain/activityField/refreshTaskField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityRefreshTaskModel } from '@db/ActivityRefreshTask';
import { ActivityRefreshTaskPointModel } from '@db/ActivityRefreshTaskPoint';
export default function (app: Application) {
new HandlerService(app, {});
return new RefreshTaskHandler(app);
}
export class RefreshTaskHandler {
constructor(private app: Application) {
}
/************************通用的刷新任务(分页,可刷新,限制领取次数)****************************/
/**
* @description 获取任务活动数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async getRefreshTaskActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取奖励
* @param {{ activityId: number, roundIndex: number, pageIndex: number,id: number, type: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async getReward(msg: { activityId: number, roundIndex: number, pageIndex: number, id: number, type: number }, session: BackendSession) {
const { activityId, roundIndex, pageIndex, id, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
let dailyItemData: RefreshTaskItem = playerData.findItem(pageIndex, id, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (dailyItemData.totalCount < dailyItemData.condition) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (dailyItemData.receiveRewardCount) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityRefreshTaskModel.addReceiveRecord(serverId, activityId, roleId, roundIndex, pageIndex, id, dailyItemData.getRefTime(), 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_REWARD)
//获得点数
await ActivityRefreshTaskPointModel.addPoint(serverId, activityId, roleId, dailyItemData.point);
dailyItemData.receiveRewardCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex, pageIndex, id, type },
item: dailyItemData,
totalPoint: playerData.totalPoint + dailyItemData.point,
}));
}
/**
* @description 兑换点数
* @param {{ activityId: number, roundIndex: number}} msg
* @param {BackendSession} session
* @memberof RefreshTaskHandler
*/
async exchangePoint(msg: { activityId: number, roundIndex: number }, session: BackendSession) {
const { activityId, roundIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerRefreshTaskData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.roundIndex != roundIndex) {
return resResult(STATUS.ACTIVITY_EXPIRE);
}
if ((playerData.totalPoint - playerData.exchangePoint) < playerData.consumePoint) {//点数不够
return resResult(STATUS.ACTIVITY_NO_POINT);
}
await ActivityRefreshTaskPointModel.addReceiveRecord(serverId, activityId, roleId, playerData.consumePoint);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.REFRESH_TASK_EXCHANGE)
playerData.exchangePoint += playerData.consumePoint;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, roundIndex },
item: { exchangePoint: playerData.exchangePoint },
}));
}
}
@@ -1,173 +1,174 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult, splitString } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { SelfServiceShopData } from '../../../domain/activityField/selfServiceShopField';
import { handleCost } from '../../../services/role/rewardService';
import { ActivitySelfServiceShopModel, ActivitySelfServiceShopModelType } from '../../../db/ActivitySelfServiceShop';
import { ActivitySelfServiceModel } from '../../../db/ActivitySelfService';
import { ActivitySelfServiceGoodsModel } from '../../../db/ActivitySelfServiceGoods';
import { ActivityModelType } from '../../../db/Activity';
import { addSelfServiceShopGiftReward, getSelfServiceShopActivityData, getPlayerActivityData } from '../../../services/activity/selfServiceShopActivityService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { random } from 'underscore';
import { getActivityById } from '../../../services/activity/activityService';
import { getRoleCreateTime, getServerCreateTime } from '../../../services/redisService';
export default function (app: Application) {
new HandlerService(app, {});
return new SelfServiceShopHandler(app);
}
export class SelfServiceShopHandler {
constructor(private app: Application) {
}
/************************自助商店、糜家商队****************************/
/**
* @description 获取自助商店数据
* @param {{ }} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async getSelfServiceShopActivity(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getSelfServiceShopActivityData(serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let playerGoods = await ActivitySelfServiceGoodsModel.findData(playerData.activityId, roleId, playerData.roundIndex, true);
return resResult(STATUS.SUCCESS, { playerData, playerGoods: playerGoods ? playerGoods : [] });
}
/**
* @description 购买礼包
* @param {{ activityId: number, roundIndex: number, index: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async buyGift(msg: { activityId: number, roundIndex: number, index: number }, session: BackendSession) {
const { activityId, roundIndex, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let activityData = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
let item = playerData.getItem(index);
if (item.countMax > 0) {//限制购买次数
let playerRecords: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.findDataByIndex(serverId, activityId, roleId, playerData.roundIndex, index);
if (playerRecords.length >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
}
let price = item.price;
if (price > 0) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_GIFT);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let result = await addSelfServiceShopGiftReward(roleId, roleName, sid, serverId, activityId, roundIndex, index, item);
return resResult(STATUS.SUCCESS, Object.assign(result, {}));
}
/**
* @description 操作礼包
* @param {{ data:Array<{activityId: number, roundIndex: number, index: number, cellIndex: number, rewardIndex: number}>}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async saveGood(msg: { data: Array<{ activityId: number, roundIndex: number, index: number, cellIndex: number, rewardIndex: number }> }, session: BackendSession) {
const { data } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
for (let obj of data) {
await ActivitySelfServiceGoodsModel.addGoods(obj.activityId, roleId, obj.roundIndex, obj.index, obj.cellIndex, obj.rewardIndex);
}
return resResult(STATUS.SUCCESS, { data });
}
/**
* @description 购买代币资源
* @param {{ activityId: number, roundIndex: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async buyRecources(msg: { activityId: number, roundIndex: number }, session: BackendSession) {
const { activityId, roundIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let activityData: ActivityModelType = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
let unitPrice = playerData.unitPrice;//购买价格
let unitCountMax = playerData.unitCountMax;//最大购买次数
let unitReward = playerData.unitReward;//购买获得资源
let playerSelfServerData = await ActivitySelfServiceModel.findData(serverId, activityId, roleId, roundIndex);
let buyCount = (playerSelfServerData && playerSelfServerData.unitBuyCount) ? playerSelfServerData.unitBuyCount : 0;
if (buyCount >= unitCountMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
//检查资源
let consume = stringToConsumeParam(unitPrice)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
await ActivitySelfServiceModel.addBuyRecord(serverId, activityId, roleId, roundIndex, 1);
let rewardArray = stringToRewardParam(unitReward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
return resResult(STATUS.SUCCESS, Object.assign(result, { unitBuyCount: buyCount + 1 }));
}
/**
* @description 获取关卡id
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async getWarId(msg: { activityId: number, }, session: BackendSession) {
const { activityId, } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerActivityData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.challengeCount >= playerData.count) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
let warIdArray = splitString(playerData.warid, '&')
let index = random(warIdArray.length - 1);
let warId = warIdArray[index];
return resResult(STATUS.SUCCESS, { warId });
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult, splitString } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { SelfServiceShopData } from '@domain/activityField/selfServiceShopField';
import { handleCost } from '../../../services/role/rewardService';
import { ActivitySelfServiceShopModel, ActivitySelfServiceShopModelType } from '@db/ActivitySelfServiceShop';
import { ActivitySelfServiceModel } from '@db/ActivitySelfService';
import { ActivitySelfServiceGoodsModel } from '@db/ActivitySelfServiceGoods';
import { ActivityModelType } from '@db/Activity';
import { addSelfServiceShopGiftReward, getSelfServiceShopActivityData, getPlayerActivityData } from '../../../services/activity/selfServiceShopActivityService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { random } from 'underscore';
import { getActivityById } from '../../../services/activity/activityService';
import { getRoleCreateTime, getServerCreateTime } from '../../../services/redisService';
export default function (app: Application) {
new HandlerService(app, {});
return new SelfServiceShopHandler(app);
}
export class SelfServiceShopHandler {
constructor(private app: Application) {
}
/************************自助商店、糜家商队****************************/
/**
* @description 获取自助商店数据
* @param {{ }} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async getSelfServiceShopActivity(msg: {}, session: BackendSession) {
const { } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getSelfServiceShopActivityData(serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let playerGoods = await ActivitySelfServiceGoodsModel.findData(playerData.activityId, roleId, playerData.roundIndex, true);
return resResult(STATUS.SUCCESS, { playerData, playerGoods: playerGoods ? playerGoods : [] });
}
/**
* @description 购买礼包
* @param {{ activityId: number, roundIndex: number, index: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async buyGift(msg: { activityId: number, roundIndex: number, index: number }, session: BackendSession) {
const { activityId, roundIndex, index } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let activityData = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
let item = playerData.getItem(index);
if (item.countMax > 0) {//限制购买次数
let playerRecords: ActivitySelfServiceShopModelType[] = await ActivitySelfServiceShopModel.findDataByIndex(serverId, activityId, roleId, playerData.roundIndex, index);
if (playerRecords.length >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
}
let price = item.price;
if (price > 0) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
//检查资源
let consume = stringToConsumeParam(item.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_GIFT);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let result = await addSelfServiceShopGiftReward(roleId, roleName, sid, serverId, activityId, roundIndex, index, item);
return resResult(STATUS.SUCCESS, Object.assign(result, {}));
}
/**
* @description 操作礼包
* @param {{ data:Array<{activityId: number, roundIndex: number, index: number, cellIndex: number, rewardIndex: number}>}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async saveGood(msg: { data: Array<{ activityId: number, roundIndex: number, index: number, cellIndex: number, rewardIndex: number }> }, session: BackendSession) {
const { data } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
for (let obj of data) {
await ActivitySelfServiceGoodsModel.addGoods(obj.activityId, roleId, obj.roundIndex, obj.index, obj.cellIndex, obj.rewardIndex);
}
return resResult(STATUS.SUCCESS, { data });
}
/**
* @description 购买代币资源
* @param {{ activityId: number, roundIndex: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async buyRecources(msg: { activityId: number, roundIndex: number }, session: BackendSession) {
const { activityId, roundIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let activityData: ActivityModelType = await getActivityById(activityId);
let createTime = await getRoleCreateTime(roleId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new SelfServiceShopData(activityData, createTime, serverTime);
let unitPrice = playerData.unitPrice;//购买价格
let unitCountMax = playerData.unitCountMax;//最大购买次数
let unitReward = playerData.unitReward;//购买获得资源
let playerSelfServerData = await ActivitySelfServiceModel.findData(serverId, activityId, roleId, roundIndex);
let buyCount = (playerSelfServerData && playerSelfServerData.unitBuyCount) ? playerSelfServerData.unitBuyCount : 0;
if (buyCount >= unitCountMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
//检查资源
let consume = stringToConsumeParam(unitPrice)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
await ActivitySelfServiceModel.addBuyRecord(serverId, activityId, roleId, roundIndex, 1);
let rewardArray = stringToRewardParam(unitReward)
let result = await addReward(roleId, roleName, sid, serverId, rewardArray, ITEM_CHANGE_REASON.SELF_SERVICE_SHOP_BUY_RESOURCE);
return resResult(STATUS.SUCCESS, Object.assign(result, { unitBuyCount: buyCount + 1 }));
}
/**
* @description 获取关卡id
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof SelfServiceShopHandler
*/
async getWarId(msg: { activityId: number, }, session: BackendSession) {
const { activityId, } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerActivityData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.challengeCount >= playerData.count) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
let warIdArray = splitString(playerData.warid, '&')
let index = random(warIdArray.length - 1);
let warId = warIdArray[index];
return resResult(STATUS.SUCCESS, { warId });
}
}
@@ -1,221 +1,222 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { ActivityGrowthModel } from '../../../db/ActivityGrowth';
import { ActivityDailyGiftsModel } from '../../../db/ActivityDailyGifts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '../../../db/ActivityDailyChallenges';
import { ActivityGrowthPointModel } from '../../../db/ActivityGrowthPoint';
import { getPlayerSevenDaysData, getPlayerSevenDaysGrowthData, getPlayerSevenDaysDailyChallengesData, getPlayerSevenDaysDailyGiftsData } from '../../../services/activity/sevenDaysService';
import { SevenDaysGrowthItem, SevenDaysPointRewardItem, SevenDaysDailyItem, SevenDaysDailyGiftItem } from '../../../domain/activityField/sevenDaysField';
export default function (app: Application) {
new HandlerService(app, {});
return new SevenDaysHandler(app);
}
export class SevenDaysHandler {
constructor(private app: Application) {
}
/**
* @description 获取七天乐活动总的数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getSevenDaysActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerSevenDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/************************成长任务****************************/
/**
* @description 获取成长任务每天完成的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getGrowthCellReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let growthItemData: SevenDaysGrowthItem = playerData.growth.findGrowthItem(dayIndex, cellIndex, type);
if (!growthItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!growthItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
growthItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: growthItemData,
}));
}
/**
* @description 成长任务每天奖章兑换奖励
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getGrowthDayReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pointItemData: SevenDaysPointRewardItem = playerData.growth.findPointItem(id);
if (!pointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.growth.getTotalPoint() < pointItemData.progress) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (pointItemData.getPointReward) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
pointItemData.getPointReward = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: pointItemData,
}));
}
/************************今日挑战****************************/
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getDailyChallengeReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: SevenDaysDailyItem = playerData.dailyChallenge.findDailyChallengesItem(dayIndex, cellIndex, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!dailyItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
dailyItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: dailyItemData,
}));
}
/************************每日特惠礼包****************************/
/**
* @description 购买每日特惠礼包
* @param {{ activityId: number, dayIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async buyDailyGiftsCell(msg: { activityId: number, dayIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: SevenDaysDailyGiftItem = playerData.dailyGift.findDailyGiftsItem(dayIndex, cellIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.canBuy()) {//最大次数
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (dayIndex > playerData.today()) {//还未开启
return resResult(STATUS.ACTIVITY_UNOPENED);
}
//货币是否足够
let consumeData = dailyItemData.consumeRes();
let consumeType = consumeData.type;//购买类型
if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表,元宝、金币、体力
let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
dailyItemData.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex },
item: dailyItemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, ACTIVITY_RESOURCES_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { handleCost } from '../../../services/role/rewardService';
import { ActivityGrowthModel } from '@db/ActivityGrowth';
import { ActivityDailyGiftsModel } from '@db/ActivityDailyGifts';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityDailyChallengesModel } from '@db/ActivityDailyChallenges';
import { ActivityGrowthPointModel } from '@db/ActivityGrowthPoint';
import { getPlayerSevenDaysData, getPlayerSevenDaysGrowthData, getPlayerSevenDaysDailyChallengesData, getPlayerSevenDaysDailyGiftsData } from '../../../services/activity/sevenDaysService';
import { SevenDaysGrowthItem, SevenDaysPointRewardItem, SevenDaysDailyItem, SevenDaysDailyGiftItem } from '@domain/activityField/sevenDaysField';
export default function (app: Application) {
new HandlerService(app, {});
return new SevenDaysHandler(app);
}
export class SevenDaysHandler {
constructor(private app: Application) {
}
/**
* @description 获取七天乐活动总的数据
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getSevenDaysActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerSevenDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/************************成长任务****************************/
/**
* @description 获取成长任务每天完成的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getGrowthCellReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let growthItemData: SevenDaysGrowthItem = playerData.growth.findGrowthItem(dayIndex, cellIndex, type);
if (!growthItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!growthItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!growthItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(growthItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_REWARD)
growthItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: growthItemData,
}));
}
/**
* @description 成长任务每天奖章兑换奖励
* @param {{ activityId: number, id: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getGrowthDayReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysGrowthData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let pointItemData: SevenDaysPointRewardItem = playerData.growth.findPointItem(id);
if (!pointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.growth.getTotalPoint() < pointItemData.progress) {
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (pointItemData.getPointReward) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityGrowthPointModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(pointItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.GROWTH_DAY_EXCHANGE)
pointItemData.getPointReward = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: pointItemData,
}));
}
/************************今日挑战****************************/
/**
* @description 获取今日挑战的单个奖励
* @param {{ activityId: number, dayIndex: number, cellIndex: number, type: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async getDailyChallengeReward(msg: { activityId: number, dayIndex: number, cellIndex: number, type: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex, type } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysDailyChallengesData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: SevenDaysDailyItem = playerData.dailyChallenge.findDailyChallengesItem(dayIndex, cellIndex, type);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.isComplete()) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (!dailyItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityDailyChallengesModel.addCellRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.DAILY_CHALLENGE_REWARD)
dailyItemData.receiveRewardCount = 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex, type },
item: dailyItemData,
}));
}
/************************每日特惠礼包****************************/
/**
* @description 购买每日特惠礼包
* @param {{ activityId: number, dayIndex: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof SevenDaysHandler
*/
async buyDailyGiftsCell(msg: { activityId: number, dayIndex: number, cellIndex: number }, session: BackendSession) {
const { activityId, dayIndex, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSevenDaysDailyGiftsData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let dailyItemData: SevenDaysDailyGiftItem = playerData.dailyGift.findDailyGiftsItem(dayIndex, cellIndex);
if (!dailyItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!dailyItemData.canBuy()) {//最大次数
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
if (dayIndex > playerData.today()) {//还未开启
return resResult(STATUS.ACTIVITY_UNOPENED);
}
//货币是否足够
let consumeData = dailyItemData.consumeRes();
let consumeType = consumeData.type;//购买类型
if (consumeType == ACTIVITY_RESOURCES_TYPE.GOODS) {//物品表,元宝、金币、体力
let result = await handleCost(roleId, sid, [{ id: consumeData.id, count: consumeData.count }], ITEM_CHANGE_REASON.BUY_DAILY_GIFTS);
if (!result) return resResult(STATUS.ACTIVITY_RES_NOT_ENOUGH);
} else if (consumeType == ACTIVITY_RESOURCES_TYPE.RMB) {//RMB购买
return resResult(STATUS.ACTIVITY_NEED_PAY);
}
await ActivityDailyGiftsModel.buyRecord(serverId, activityId, roleId, dayIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(dailyItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.BUY_DAILY_GIFTS)
dailyItemData.buyCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex, cellIndex },
item: dailyItemData,
}));
}
}
@@ -1,112 +1,113 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, ACTIVITY_TYPE, SERVER_OPEN_TIME, ITEM_CHANGE_REASON, } from '../../../consts';
import { canBuyVip, getPlayerSignInData } from '../../../services/activity/signInService';
import { handleCost } from '../../../services/role/rewardService';
import { SignInItem } from '../../../domain/activityField/signInField';
import { ActivitySignInModel } from '../../../db/ActivitySignIn';
import moment = require('moment');
import { RoleModel } from '../../../db/Role';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new SignInHandler(app);
}
export class SignInHandler {
constructor(private app: Application) {
}
/************************签到活动****************************/
/**
* @description 获取普通签到活动数据
* @param {BackendSession} session
* @param {{ activityId: number}} msg
* @memberof SignInHandler
*/
async getSignInActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let curDate = moment(new Date()).valueOf();
let playerData = await getPlayerSignInData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (curDate < playerData.beginTime || curDate > playerData.endTime) {//未开启
return resResult(STATUS.ACTIVITY_CLOSED);
}
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到获得奖励
* @param {{ activityId: number, dayIndex: number}} msg
* @param {BackendSession} session
* @memberof SignInHandler
*/
async getSignInReward(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSignInData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (!playerData.canShow()) {//未开启
return resResult(STATUS.ACTIVITY_CLOSED);
}
if (dayIndex > playerData.todayIndex) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
let isDelay = false;//补签
if(dayIndex < playerData.todayIndex) {
isDelay = true;
}
let roundIndex = playerData.roundIndex;
//高级签到开启条件
let { lv } = await RoleModel.findByRoleId(roleId);
if (playerData.type == ACTIVITY_TYPE.SIGN_IN_VIP) {
if (!canBuyVip(lv))
return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
if (!playerData.isVip) {
return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
}
}
if(playerData.price > 0 && !playerData.isVip) return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
let signinItemData: SignInItem = playerData.findDayItem(dayIndex);
if (!signinItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!signinItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (isDelay) {
let consume = stringToConsumeParam(playerData.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.REPAIRE_SIGNIN);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
await ActivitySignInModel.addSignInRecord(activityId, roleId, roundIndex, dayIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(signinItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.SIGNIN)
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex },
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, ACTIVITY_TYPE, SERVER_OPEN_TIME, ITEM_CHANGE_REASON, } from '../../../consts';
import { canBuyVip, getPlayerSignInData } from '../../../services/activity/signInService';
import { handleCost } from '../../../services/role/rewardService';
import { SignInItem } from '@domain/activityField/signInField';
import { ActivitySignInModel } from '@db/ActivitySignIn';
import moment = require('moment');
import { RoleModel } from '@db/Role';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new SignInHandler(app);
}
export class SignInHandler {
constructor(private app: Application) {
}
/************************签到活动****************************/
/**
* @description 获取普通签到活动数据
* @param {BackendSession} session
* @param {{ activityId: number}} msg
* @memberof SignInHandler
*/
async getSignInActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let curDate = moment(new Date()).valueOf();
let playerData = await getPlayerSignInData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (curDate < playerData.beginTime || curDate > playerData.endTime) {//未开启
return resResult(STATUS.ACTIVITY_CLOSED);
}
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到获得奖励
* @param {{ activityId: number, dayIndex: number}} msg
* @param {BackendSession} session
* @memberof SignInHandler
*/
async getSignInReward(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerSignInData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (!playerData.canShow()) {//未开启
return resResult(STATUS.ACTIVITY_CLOSED);
}
if (dayIndex > playerData.todayIndex) {
return resResult(STATUS.ACTIVITY_DAY_INDEX_OVER);
}
let isDelay = false;//补签
if(dayIndex < playerData.todayIndex) {
isDelay = true;
}
let roundIndex = playerData.roundIndex;
//高级签到开启条件
let { lv } = await RoleModel.findByRoleId(roleId);
if (playerData.type == ACTIVITY_TYPE.SIGN_IN_VIP) {
if (!canBuyVip(lv))
return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
if (!playerData.isVip) {
return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
}
}
if(playerData.price > 0 && !playerData.isVip) return resResult(STATUS.ACTIVITY_SIGNIN_VIP_CONDITION);
let signinItemData: SignInItem = playerData.findDayItem(dayIndex);
if (!signinItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!signinItemData.canReceive()) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (isDelay) {
let consume = stringToConsumeParam(playerData.consume)
let consumeResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.REPAIRE_SIGNIN);
if (!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
}
await ActivitySignInModel.addSignInRecord(activityId, roleId, roundIndex, dayIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(signinItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.SIGNIN)
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, dayIndex },
}));
}
}
@@ -1,87 +1,88 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getTaskPassData, getTaskPassDataShow } from '../../../services/activity/taskPassService';
import { ActivityTaskPassModel, ReceivedReward } from '../../../db/ActivityTaskPass';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { nowSeconds } from '../../../pubUtils/timeUtil';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ItemInter } from '../../../pubUtils/interface';
import { isNumber, pick } from 'underscore';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new TaskPassHandler(app);
}
export class TaskPassHandler {
constructor(private app: Application) {
}
/************************战令系统****************************/
// 获得战令活动数据
public async getTaskPassData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getTaskPassDataShow(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
// (一键)领取
public async receiveItems(msg: { activityId: number, pageIndex: number, lv: number }, session: BackendSession) {
const { activityId, pageIndex, lv = 0 } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getTaskPassData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items = playerData.receiveItems(pageIndex, lv);
if(!items) return resResult(STATUS.ACTIVITY_ITEM_CANNOT_RECEIVE);
let records: ReceivedReward[] = [], rewards: RewardParam[] = [];
for(let item of items) {
records.push({ pageIndex: item.pageIndex, lv: item.lv, receiveTime: nowSeconds() });
rewards.push(...stringToRewardParam(item.reward));
}
await ActivityTaskPassModel.receiveItems(serverId, activityId, roleId, playerData.roundIndex, records);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_TASK_PASS);
return resResult(STATUS.SUCCESS, { items, ...result });
}
// 加速
public async speedUp(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getTaskPassData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let cost: ItemInter[] = [];
let consumeArr = stringToConsumeParam(playerData.spdUp.cost);
for(let consume of consumeArr) {
cost.push({ ...consume, count: consume.count * count });
}
let consumeResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TASK_PASS_SPD_UP);
if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let addPoint = playerData.spdUp.point * count;
await ActivityTaskPassModel.addPoint(serverId, activityId, roleId, playerData.roundIndex, addPoint, count);
let result = playerData.addPoint(addPoint, count);
return resResult(STATUS.SUCCESS, result);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getTaskPassData, getTaskPassDataShow } from '../../../services/activity/taskPassService';
import { ActivityTaskPassModel, ReceivedReward } from '@db/ActivityTaskPass';
import { RewardParam } from '@domain/activityField/rewardField';
import { nowSeconds } from '@pubUtils/timeUtil';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { ItemInter } from '@pubUtils/interface';
import { isNumber, pick } from 'underscore';
import { handleCost } from '../../../services/role/rewardService';
export default function (app: Application) {
new HandlerService(app, {});
return new TaskPassHandler(app);
}
export class TaskPassHandler {
constructor(private app: Application) {
}
/************************战令系统****************************/
// 获得战令活动数据
public async getTaskPassData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getTaskPassDataShow(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, { playerData });
}
// (一键)领取
public async receiveItems(msg: { activityId: number, pageIndex: number, lv: number }, session: BackendSession) {
const { activityId, pageIndex, lv = 0 } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getTaskPassData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let items = playerData.receiveItems(pageIndex, lv);
if(!items) return resResult(STATUS.ACTIVITY_ITEM_CANNOT_RECEIVE);
let records: ReceivedReward[] = [], rewards: RewardParam[] = [];
for(let item of items) {
records.push({ pageIndex: item.pageIndex, lv: item.lv, receiveTime: nowSeconds() });
rewards.push(...stringToRewardParam(item.reward));
}
await ActivityTaskPassModel.receiveItems(serverId, activityId, roleId, playerData.roundIndex, records);
let result = await addReward(roleId, roleName, sid, serverId, rewards, ITEM_CHANGE_REASON.ACT_TASK_PASS);
return resResult(STATUS.SUCCESS, { items, ...result });
}
// 加速
public async speedUp(msg: { activityId: number, count: number }, session: BackendSession) {
const { activityId, count } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getTaskPassData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let cost: ItemInter[] = [];
let consumeArr = stringToConsumeParam(playerData.spdUp.cost);
for(let consume of consumeArr) {
cost.push({ ...consume, count: consume.count * count });
}
let consumeResult = await handleCost(roleId, sid, cost, ITEM_CHANGE_REASON.ACT_TASK_PASS_SPD_UP);
if(!consumeResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let addPoint = playerData.spdUp.point * count;
await ActivityTaskPassModel.addPoint(serverId, activityId, roleId, playerData.roundIndex, addPoint, count);
let result = playerData.addPoint(addPoint, count);
return resResult(STATUS.SUCCESS, result);
}
}
@@ -1,142 +1,143 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS, ACTIVITY_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { getPlayerThirtyDaysData } from '../../../services/activity/thirtyDaysService';
import { ThirtyDaysData, ThirtyDaysItem, ThirtyDaysPointItem } from '../../../domain/activityField/thirtyDaysField';
import { ActivityThirtyDaysModel } from '../../../db/ActivityThirtyDays';
import { ActivityThirtyDaysPointRewardModel } from '../../../db/ActivityThirtyDaysPointReward';
import { ActivityModel, ActivityModelType } from '../../../db/Activity';
import { ServerlistModel } from '../../../db/Serverlist';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new ThirtyDaysHandler(app);
}
export class ThirtyDaysHandler {
constructor(private app: Application) {
}
/************************30天大目标****************************/
/**
* @description 获取30目标活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_THIRTY_DAYS_END);
return resResult(STATUS.SUCCESS, { playerData, todayIndex: playerData.todayIndex });
}
/**
* @description 获取30天完成任务的奖励
* @param {{ activityId: number, pageIndex: number, cellIndex: number,tab: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysCellReward(msg: { activityId: number, pageIndex: number, cellIndex: number, tab: number }, session: BackendSession) {
const { activityId, pageIndex, cellIndex, tab } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (tab > 1) {
let item = playerData.findThirtyDaysItem(pageIndex, cellIndex, tab - 1)
if (!item.isReceive) {
return resResult(STATUS.ACTIVITY_PRE_UNCOMPLETE);
}
}
let thirtyDaysItemData: ThirtyDaysItem = playerData.findThirtyDaysItem(pageIndex, cellIndex, tab);
if (!thirtyDaysItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!thirtyDaysItemData.isComplete) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (thirtyDaysItemData.isReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (0 < playerData.todayIndex && playerData.todayIndex <= playerData.days) {//时间正常范围内
} else if (playerData.todayIndex > playerData.days) {//活动已经过期
// console.log('过期奖励')
let expiredItems: Array<ThirtyDaysPointItem> = playerData.needMark();
let cells = expiredItems.map(obj => obj.cellIndex)
await ActivityThirtyDaysPointRewardModel.setExpired(activityId, roleId, cells);
} else {//活动未到开启时间
return resResult(STATUS.ACTIVITY_TIME_ERROR);
}
await ActivityThirtyDaysModel.addRecord(serverId, activityId, roleId, pageIndex, cellIndex, tab);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(thirtyDaysItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_TASK)
thirtyDaysItemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, cellIndex },
item: thirtyDaysItemData,
}));
}
/**
* @description 点数兑换奖励
* @param {{ activityId: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysPointReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let thirtyDaysPointItemData: ThirtyDaysPointItem = playerData.findThirtyDaysPointItem(cellIndex);
if (!thirtyDaysPointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.totalPoint < thirtyDaysPointItemData.consumePoint) {//点数不足
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (thirtyDaysPointItemData.isReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityThirtyDaysPointRewardModel.addRecord(activityId, roleId, cellIndex);
let reward = thirtyDaysPointItemData.reward
if (thirtyDaysPointItemData.isExpired && thirtyDaysPointItemData.expiredReward && thirtyDaysPointItemData.expiredReward != '') {//过期奖励
reward = thirtyDaysPointItemData.expiredReward;
}
let rewardParamArr: Array<RewardParam> = stringToRewardParam(reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_EXCHANGE)
thirtyDaysPointItemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: thirtyDaysPointItemData,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS, ACTIVITY_TYPE, ITEM_CHANGE_REASON } from '../../../consts';
import { getPlayerThirtyDaysData } from '../../../services/activity/thirtyDaysService';
import { ThirtyDaysData, ThirtyDaysItem, ThirtyDaysPointItem } from '@domain/activityField/thirtyDaysField';
import { ActivityThirtyDaysModel } from '@db/ActivityThirtyDays';
import { ActivityThirtyDaysPointRewardModel } from '@db/ActivityThirtyDaysPointReward';
import { ActivityModel, ActivityModelType } from '@db/Activity';
import { ServerlistModel } from '@db/Serverlist';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
export default function (app: Application) {
new HandlerService(app, {});
return new ThirtyDaysHandler(app);
}
export class ThirtyDaysHandler {
constructor(private app: Application) {
}
/************************30天大目标****************************/
/**
* @description 获取30目标活动数据
* @param {{ }} msg
* @param {{ activityId: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_THIRTY_DAYS_END);
return resResult(STATUS.SUCCESS, { playerData, todayIndex: playerData.todayIndex });
}
/**
* @description 获取30天完成任务的奖励
* @param {{ activityId: number, pageIndex: number, cellIndex: number,tab: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysCellReward(msg: { activityId: number, pageIndex: number, cellIndex: number, tab: number }, session: BackendSession) {
const { activityId, pageIndex, cellIndex, tab } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (tab > 1) {
let item = playerData.findThirtyDaysItem(pageIndex, cellIndex, tab - 1)
if (!item.isReceive) {
return resResult(STATUS.ACTIVITY_PRE_UNCOMPLETE);
}
}
let thirtyDaysItemData: ThirtyDaysItem = playerData.findThirtyDaysItem(pageIndex, cellIndex, tab);
if (!thirtyDaysItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (!thirtyDaysItemData.isComplete) {//未完成任务
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (thirtyDaysItemData.isReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
if (0 < playerData.todayIndex && playerData.todayIndex <= playerData.days) {//时间正常范围内
} else if (playerData.todayIndex > playerData.days) {//活动已经过期
// console.log('过期奖励')
let expiredItems: Array<ThirtyDaysPointItem> = playerData.needMark();
let cells = expiredItems.map(obj => obj.cellIndex)
await ActivityThirtyDaysPointRewardModel.setExpired(activityId, roleId, cells);
} else {//活动未到开启时间
return resResult(STATUS.ACTIVITY_TIME_ERROR);
}
await ActivityThirtyDaysModel.addRecord(serverId, activityId, roleId, pageIndex, cellIndex, tab);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(thirtyDaysItemData.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_TASK)
thirtyDaysItemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, pageIndex, cellIndex },
item: thirtyDaysItemData,
}));
}
/**
* @description 点数兑换奖励
* @param {{ activityId: number, cellIndex: number}} msg
* @param {BackendSession} session
* @memberof ThirtyDaysHandler
*/
async getThirtyDaysPointReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerThirtyDaysData(activityId, serverId, roleId)
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let thirtyDaysPointItemData: ThirtyDaysPointItem = playerData.findThirtyDaysPointItem(cellIndex);
if (!thirtyDaysPointItemData) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.totalPoint < thirtyDaysPointItemData.consumePoint) {//点数不足
return resResult(STATUS.ACTIVITY_NO_POINT);
}
if (thirtyDaysPointItemData.isReceive) {//已经领取过
return resResult(STATUS.ACTIVITY_REWARDED);
}
await ActivityThirtyDaysPointRewardModel.addRecord(activityId, roleId, cellIndex);
let reward = thirtyDaysPointItemData.reward
if (thirtyDaysPointItemData.isExpired && thirtyDaysPointItemData.expiredReward && thirtyDaysPointItemData.expiredReward != '') {//过期奖励
reward = thirtyDaysPointItemData.expiredReward;
}
let rewardParamArr: Array<RewardParam> = stringToRewardParam(reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.THIRTHDAY_EXCHANGE)
thirtyDaysPointItemData.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: thirtyDaysPointItemData,
}));
}
}
@@ -1,100 +1,101 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { DEBUG_MAGIC_WORD, getRedisKeyByRankType, HERO_SELECT, ITEM_CHANGE_REASON, RANK_TYPE, ROLE_SELECT, STATUS } from '../../../consts';
import { pick } from 'underscore';
import { getTimeLimitRankData, getTimeLimitRankDataShow, sendRankMail, takeSnapshot } from '../../../services/activity/timeLimitRankService';
import { getRankInHandler, Rank } from '../../../services/rankService';
import { getActivityById } from '../../../services/activity/activityService';
import { TimeLimitRankData } from '../../../domain/activityField/timeLimitRankField';
import { getServerCreateTime, hasKey } from '../../../services/redisService';
import { KeyName } from '../../../domain/rank';
export default function (app: Application) {
new HandlerService(app, {});
return new TimeLimitRankHandler(app);
}
export class TimeLimitRankHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getTimeLimitRankData(msg: { activityId: number }, session: BackendSession) {
const serverId = session.get('serverId');
const { activityId } = msg;
let playerData = await getTimeLimitRankDataShow(activityId, serverId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 获得排行榜
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getRank(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getTimeLimitRankData(activityId, serverId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let type = playerData.rankType;
let redisKey = getRedisKeyByRankType(type, true);
let keyName = new KeyName(redisKey, { serverId, activityId });
if(!(await hasKey(keyName.getName()))) {
redisKey = getRedisKeyByRankType(type);
}
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let result = await getRankInHandler(redisKey, type, { serverId, activityId: playerData.activityId }, session);
if(!result) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, {
...pick(playerData, ['activityId', 'tabName', 'beginTime', 'endTime', 'rankEndTime', 'rankType', 'rankRewards']),
...result
});
}
async debugSendMail(msg: { magicWord: string, activityId: number }, session: BackendSession) {
let serverId = session.get('serverId');
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let playerData = await getTimeLimitRankData(activityId, serverId);
await sendRankMail(playerData, serverId);
return resResult(STATUS.SUCCESS);
}
async debugTakeSnapshot(msg: { magicWord: string, activityId: number }, session: BackendSession) {
let serverId = session.get('serverId');
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let activityData = await getActivityById(activityId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new TimeLimitRankData(activityData, 0, serverTime);
if(!playerData.needSnapshot) return resResult(STATUS.WRONG_PARMS);
await takeSnapshot(playerData, serverId);
return resResult(STATUS.SUCCESS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { DEBUG_MAGIC_WORD, getRedisKeyByRankType, HERO_SELECT, ITEM_CHANGE_REASON, RANK_TYPE, ROLE_SELECT, STATUS } from '../../../consts';
import { pick } from 'underscore';
import { getTimeLimitRankData, getTimeLimitRankDataShow, sendRankMail, takeSnapshot } from '../../../services/activity/timeLimitRankService';
import { getRankInHandler, Rank } from '../../../services/rankService';
import { getActivityById } from '../../../services/activity/activityService';
import { TimeLimitRankData } from '@domain/activityField/timeLimitRankField';
import { getServerCreateTime, hasKey } from '../../../services/redisService';
import { KeyName } from '@domain/rank';
export default function (app: Application) {
new HandlerService(app, {});
return new TimeLimitRankHandler(app);
}
export class TimeLimitRankHandler {
constructor(private app: Application) {
}
/************************幸运转盘****************************/
/**
* @description 幸运转盘活动
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getTimeLimitRankData(msg: { activityId: number }, session: BackendSession) {
const serverId = session.get('serverId');
const { activityId } = msg;
let playerData = await getTimeLimitRankDataShow(activityId, serverId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
return resResult(STATUS.SUCCESS, { playerData });
}
/**
* @description 获得排行榜
* @param {{ activityId: number, }} msg
* @param {BackendSession} session
* @memberof TimeLimitRankHandler
*/
async getRank(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getTimeLimitRankData(activityId, serverId);
if (!playerData) {
return resResult(STATUS.ACTIVITY_MISSING);
}
let type = playerData.rankType;
let redisKey = getRedisKeyByRankType(type, true);
let keyName = new KeyName(redisKey, { serverId, activityId });
if(!(await hasKey(keyName.getName()))) {
redisKey = getRedisKeyByRankType(type);
}
if (!redisKey) return resResult(STATUS.WRONG_PARMS);
let result = await getRankInHandler(redisKey, type, { serverId, activityId: playerData.activityId }, session);
if(!result) return resResult(STATUS.WRONG_PARMS);
return resResult(STATUS.SUCCESS, {
...pick(playerData, ['activityId', 'tabName', 'beginTime', 'endTime', 'rankEndTime', 'rankType', 'rankRewards']),
...result
});
}
async debugSendMail(msg: { magicWord: string, activityId: number }, session: BackendSession) {
let serverId = session.get('serverId');
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let playerData = await getTimeLimitRankData(activityId, serverId);
await sendRankMail(playerData, serverId);
return resResult(STATUS.SUCCESS);
}
async debugTakeSnapshot(msg: { magicWord: string, activityId: number }, session: BackendSession) {
let serverId = session.get('serverId');
const { magicWord, activityId } = msg;
if (magicWord !== DEBUG_MAGIC_WORD) {
return resResult(STATUS.TOKEN_ERR);
}
let activityData = await getActivityById(activityId);
let serverTime = await getServerCreateTime(serverId);
let playerData = new TimeLimitRankData(activityData, 0, serverTime);
if(!playerData.needSnapshot) return resResult(STATUS.WRONG_PARMS);
await takeSnapshot(playerData, serverId);
return resResult(STATUS.SUCCESS);
}
}
@@ -1,232 +1,233 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerTreasureHuntData, getPlayerTreasureHuntShopData, getPlayerTreasureHuntTaskData, getPlayerTreasureHuntTreasureShopData, getPlayerTreasureHuntChallengeData, getPlayerTreasureHuntFirstPageData } from '../../../services/activity/treasureHuntService';
import { ActivityTreasureHuntShopModel } from '../../../db/ActivityTreasureHuntShop';
import { ActivityTreasureHuntTaskModel } from '../../../db/ActivityTreasureHuntTask';
import { handleCost } from '../../../services/role/rewardService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityTreasureHuntTreasureShopModel } from '../../../db/ActivityTreasureHuntTreasureShop';
import { ActivityTreasureHuntFirstPageModel } from '../../../db/ActivityTreasureHuntFirstPage';
import { CheckMeterial } from '../../../services/role/checkMaterial';
import { ActivityTreasureHuntChallengeModel } from '../../../db/ActivityTreasureHuntChallenge';
export default function (app: Application) {
new HandlerService(app, {});
return new TreasureHuntHandler(app);
}
export class TreasureHuntHandler {
constructor(private app: Application) {
}
/************************寻宝骑兵活动****************************/
/**
* 每日物资:商店
寻宝备战:完成任务获得奖励,(奖品达到一定数量后开启 “寻宝大冒险”)
寻宝大冒险:完成战棋关卡获得奖励
天子宝库:物品兑换奖励
* @description 获取寻宝骑兵活动的数据
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getTreasureHuntActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerTreasureHuntData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 寻宝骑兵获取首页的奖励
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getFirstPageReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntFirstPageData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.firstPage.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
//添加领取记录
await ActivityTreasureHuntFirstPageModel.receiveReward(serverId, activityId, roleId, playerData.roundIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.firstPage.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_FIRST_PAGE_REWARD)
playerData.firstPage.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId },
item: playerData.firstPage,
}));
}
/**
* @description 寻宝骑兵购买每日商店中的商品
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async buyGoods(msg: { activityId: number, cellIndex: number, count: number }, session: BackendSession) {
const { activityId, cellIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntShopData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.shop.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY, {});
}
if (item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT, {});
}
let consumeStr = item.getConsume(count);
let consume = stringToConsumeParam(...consumeStr);
let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY);
if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
//添加购买记录
await ActivityTreasureHuntShopModel.buyShopRecord(activityId, roleId, playerData.roundIndex, playerData.todayIndex, cellIndex, count);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY)
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
/**
* @description 寻宝骑兵获取寻宝备战的任务奖励
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getTaskReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntTaskData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.tasks.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.condition > item.totalCount) {
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED, {});
}
if (item.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED, {});
}
//添加购买记录
await ActivityTreasureHuntTaskModel.receiveReward(serverId, activityId, roleId, playerData.roundIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_TASK_REWARD)
item.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
/**
* @description 寻宝骑兵寻宝大冒险挑战
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async challenge(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntChallengeData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let challengeData = playerData.challenge;
//消耗资源
let consumeStr = challengeData.consume;
let consume = stringToConsumeParam(consumeStr)
let check = new CheckMeterial(roleId);
let isEnough = await check.decrease(consume);
if (!isEnough) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let warId = playerData.challenge.resultWarId;
if(!warId) {
warId = playerData.challenge.randomGK();
await ActivityTreasureHuntChallengeModel.setWarId(serverId, activityId, roleId, playerData.roundIndex, warId);
}
return resResult(STATUS.SUCCESS, Object.assign({ warId }, {
param: { activityId },
}));
}
/**
* @description 寻宝骑兵购买天子宝库商店中的商品
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async buyTreasureShopGoods(msg: { activityId: number, cellIndex: number, count: number }, session: BackendSession) {
const { activityId, cellIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntTreasureShopData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.treasureShop.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT, {});
}
let consumeStrs = new Array<string>(count).fill(item.consume);
let consume = stringToConsumeParam(...consumeStrs);
let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY);
if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
//添加购买记录
await ActivityTreasureHuntTreasureShopModel.addRecord(activityId, roleId, playerData.roundIndex, cellIndex, count);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count}));
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY)
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerTreasureHuntData, getPlayerTreasureHuntShopData, getPlayerTreasureHuntTaskData, getPlayerTreasureHuntTreasureShopData, getPlayerTreasureHuntChallengeData, getPlayerTreasureHuntFirstPageData } from '../../../services/activity/treasureHuntService';
import { ActivityTreasureHuntShopModel } from '@db/ActivityTreasureHuntShop';
import { ActivityTreasureHuntTaskModel } from '@db/ActivityTreasureHuntTask';
import { handleCost } from '../../../services/role/rewardService';
import { addReward, stringToConsumeParam, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityTreasureHuntTreasureShopModel } from '@db/ActivityTreasureHuntTreasureShop';
import { ActivityTreasureHuntFirstPageModel } from '@db/ActivityTreasureHuntFirstPage';
import { CheckMeterial } from '../../../services/role/checkMaterial';
import { ActivityTreasureHuntChallengeModel } from '@db/ActivityTreasureHuntChallenge';
export default function (app: Application) {
new HandlerService(app, {});
return new TreasureHuntHandler(app);
}
export class TreasureHuntHandler {
constructor(private app: Application) {
}
/************************寻宝骑兵活动****************************/
/**
* 每日物资:商店
寻宝备战:完成任务获得奖励,(奖品达到一定数量后开启 “寻宝大冒险”)
寻宝大冒险:完成战棋关卡获得奖励
天子宝库:物品兑换奖励
* @description 获取寻宝骑兵活动的数据
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getTreasureHuntActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerTreasureHuntData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 寻宝骑兵获取首页的奖励
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getFirstPageReward(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntFirstPageData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if (playerData.firstPage.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED);
}
//添加领取记录
await ActivityTreasureHuntFirstPageModel.receiveReward(serverId, activityId, roleId, playerData.roundIndex);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(playerData.firstPage.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_FIRST_PAGE_REWARD)
playerData.firstPage.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId },
item: playerData.firstPage,
}));
}
/**
* @description 寻宝骑兵购买每日商店中的商品
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async buyGoods(msg: { activityId: number, cellIndex: number, count: number }, session: BackendSession) {
const { activityId, cellIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntShopData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.shop.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.price > 0) {
return resResult(STATUS.ACTIVITY_NEED_PAY, {});
}
if (item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT, {});
}
let consumeStr = item.getConsume(count);
let consume = stringToConsumeParam(...consumeStr);
let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY);
if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
//添加购买记录
await ActivityTreasureHuntShopModel.buyShopRecord(activityId, roleId, playerData.roundIndex, playerData.todayIndex, cellIndex, count);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count }));
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SHOP_BUY)
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
/**
* @description 寻宝骑兵获取寻宝备战的任务奖励
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async getTaskReward(msg: { activityId: number, cellIndex: number }, session: BackendSession) {
const { activityId, cellIndex } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntTaskData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.tasks.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.condition > item.totalCount) {
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED, {});
}
if (item.isReceive) {
return resResult(STATUS.ACTIVITY_REWARDED, {});
}
//添加购买记录
await ActivityTreasureHuntTaskModel.receiveReward(serverId, activityId, roleId, playerData.roundIndex, cellIndex, 1);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_TASK_REWARD)
item.isReceive = true;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
/**
* @description 寻宝骑兵寻宝大冒险挑战
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async challenge(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntChallengeData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let challengeData = playerData.challenge;
//消耗资源
let consumeStr = challengeData.consume;
let consume = stringToConsumeParam(consumeStr)
let check = new CheckMeterial(roleId);
let isEnough = await check.decrease(consume);
if (!isEnough) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
let warId = playerData.challenge.resultWarId;
if(!warId) {
warId = playerData.challenge.randomGK();
await ActivityTreasureHuntChallengeModel.setWarId(serverId, activityId, roleId, playerData.roundIndex, warId);
}
return resResult(STATUS.SUCCESS, Object.assign({ warId }, {
param: { activityId },
}));
}
/**
* @description 寻宝骑兵购买天子宝库商店中的商品
* @param {BackendSession} session
* @memberof TreasureHuntHandler
*/
async buyTreasureShopGoods(msg: { activityId: number, cellIndex: number, count: number }, session: BackendSession) {
const { activityId, cellIndex, count = 1 } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerTreasureHuntTreasureShopData(activityId, serverId, roleId,);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item = playerData.treasureShop.getItem(cellIndex);
if (!item) {
return resResult(STATUS.ACTIVITY_MISSING, {});
}
if (item.buyCount + count > item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT, {});
}
let consumeStrs = new Array<string>(count).fill(item.consume);
let consume = stringToConsumeParam(...consumeStrs);
let resourceResult = await handleCost(roleId, sid, consume, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY);
if (!resourceResult) return resResult(STATUS.ROLE_MATERIAL_NOT_ENOUGH);
//添加购买记录
await ActivityTreasureHuntTreasureShopModel.addRecord(activityId, roleId, playerData.roundIndex, cellIndex, count);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward).map(cur => ({...cur, count: cur.count * count}));
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.TREASURE_HUNT_SP_SHOP_BUY)
item.buyCount += count;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, cellIndex },
item: item,
}));
}
}
@@ -1,111 +1,112 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerVipRechargeMoneyData, } from '../../../services/activity/vipRechargeMoneyService';
import { VipRechargeMoneyItem } from '../../../domain/activityField/vipRechargeMoneyField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '../../../domain/activityField/rewardField';
import { ActivityVipRechargeMoneyModel } from '../../../db/ActivityVipRechargeMoney';
import { UserOrderModel } from '../../../db/UserOrder';
import { dicRMB } from '../../../pubUtils/dictionary/DicRMB';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new VipRechargeMoneyHandler(app);
}
export class VipRechargeMoneyHandler {
constructor(private app: Application) {
}
/************************vip累计充值奖励****************************/
/**
* @description 获取活动数据
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getVipRechargeMoneyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerVipRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取奖励
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getVipRechargeMoneyReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerVipRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item: VipRechargeMoneyItem = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.totalRMB < item.condition) {
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (item.receiveCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
await ActivityVipRechargeMoneyModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.VIP_RECHARGE_MONEY)
item.receiveCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: item
}));
}
/**
* @description 获取订单记录
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getOrderList(msg: { begin: number, count: number }, session: BackendSession) {
const { begin, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
if (begin > 0 && count > 0) {
let orders = await UserOrderModel.findOrderList(serverId, roleId, begin - 1, count)
for (let order of orders) {
let productInfo = dicRMB.get(order.productID)
if (productInfo) {
order['message'] = productInfo.message;
}
order['time'] = moment(order.createdAt).valueOf();
delete order.createdAt;
delete order.productID;
delete order._id;
}
return resResult(STATUS.SUCCESS, { orders });
}
return resResult(STATUS.WRONG_PARMS);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS, } from '../../../consts';
import { getPlayerVipRechargeMoneyData, } from '../../../services/activity/vipRechargeMoneyService';
import { VipRechargeMoneyItem } from '@domain/activityField/vipRechargeMoneyField';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
import { RewardParam } from '@domain/activityField/rewardField';
import { ActivityVipRechargeMoneyModel } from '@db/ActivityVipRechargeMoney';
import { UserOrderModel } from '@db/UserOrder';
import { dicRMB } from '@pubUtils/dictionary/DicRMB';
import moment = require('moment');
export default function (app: Application) {
new HandlerService(app, {});
return new VipRechargeMoneyHandler(app);
}
export class VipRechargeMoneyHandler {
constructor(private app: Application) {
}
/************************vip累计充值奖励****************************/
/**
* @description 获取活动数据
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getVipRechargeMoneyActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerVipRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 获取奖励
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getVipRechargeMoneyReward(msg: { activityId: number, id: number }, session: BackendSession) {
const { activityId, id } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
let playerData = await getPlayerVipRechargeMoneyData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
let item: VipRechargeMoneyItem = playerData.findItem(id);
if (!item) {
return resResult(STATUS.ACTIVITY_DATA_ERROR);
}
if (playerData.totalRMB < item.condition) {
return resResult(STATUS.ACTIVITY_TASK_UNCOMPLETED);
}
if (item.receiveCount >= item.countMax) {
return resResult(STATUS.ACTIVITY_MAX_COUNT);
}
await ActivityVipRechargeMoneyModel.addRecord(serverId, activityId, roleId, id);
let rewardParamArr: Array<RewardParam> = stringToRewardParam(item.reward);
let result = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.VIP_RECHARGE_MONEY)
item.receiveCount += 1;
return resResult(STATUS.SUCCESS, Object.assign(result, {
param: { activityId, id },
item: item
}));
}
/**
* @description 获取订单记录
* @param {BackendSession} session
* @memberof VipRechargeMoneyHandler
*/
async getOrderList(msg: { begin: number, count: number }, session: BackendSession) {
const { begin, count } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
const sid = session.get('sid');
const roleName = session.get('roleName');
if (begin > 0 && count > 0) {
let orders = await UserOrderModel.findOrderList(serverId, roleId, begin - 1, count)
for (let order of orders) {
let productInfo = dicRMB.get(order.productID)
if (productInfo) {
order['message'] = productInfo.message;
}
order['time'] = moment(order.createdAt).valueOf();
delete order.createdAt;
delete order.productID;
delete order._id;
}
return resResult(STATUS.SUCCESS, { orders });
}
return resResult(STATUS.WRONG_PARMS);
}
}
@@ -1,68 +1,69 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getWeeklyFundDataShow, getWeeklyFundData } from '../../../services/activity/weeklyFundService';
import { ActivityWeeklyFundModel } from '../../../db/ActivityWeeklyFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
export default function (app: Application) {
new HandlerService(app, {});
return new WeeklyFundHandler(app);
}
export class WeeklyFundHandler {
constructor(private app: Application) {
}
/************************周基金****************************/
/**
* @description 获取数据
* @param {BackendSession} session
* @memberof WeeklyFundHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getWeeklyFundDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到
* @param {BackendSession} session
* @memberof WeeklyFundHandler
*/
async sign(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getWeeklyFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(!playerData.hasBought) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_NOT_BOUGHT);
let signReward = playerData.findSignReward(dayIndex);
if(!signReward) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_NOT_FOUND);
if(signReward.hasReceived) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_HAS_SIGN);
if(signReward.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_LOCK);
let record = await ActivityWeeklyFundModel.sign(serverId, activityId, roleId, dayIndex, playerData.todayIndex);
if(!record) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_HAS_SIGN);
let rewardParamArr = stringToRewardParam(signReward.reward);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.ACT_WEEKLY_FUND_SIGN);
return resResult(STATUS.SUCCESS, {
activityId, dayIndex, goods, addHeros
});
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { ITEM_CHANGE_REASON, STATUS } from '../../../consts';
import { getWeeklyFundDataShow, getWeeklyFundData } from '../../../services/activity/weeklyFundService';
import { ActivityWeeklyFundModel } from '@db/ActivityWeeklyFund';
import { addReward, stringToRewardParam } from '../../../services/activity/giftPackageService';
export default function (app: Application) {
new HandlerService(app, {});
return new WeeklyFundHandler(app);
}
export class WeeklyFundHandler {
constructor(private app: Application) {
}
/************************周基金****************************/
/**
* @description 获取数据
* @param {BackendSession} session
* @memberof WeeklyFundHandler
*/
async getData(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getWeeklyFundDataShow(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
/**
* @description 签到
* @param {BackendSession} session
* @memberof WeeklyFundHandler
*/
async sign(msg: { activityId: number, dayIndex: number }, session: BackendSession) {
const { activityId, dayIndex } = msg;
const roleId = session.get('roleId');
const roleName = session.get('roleName');
const sid = session.get('sid');
const serverId = session.get('serverId');
let playerData = await getWeeklyFundData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
if(!playerData.hasBought) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_NOT_BOUGHT);
let signReward = playerData.findSignReward(dayIndex);
if(!signReward) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_NOT_FOUND);
if(signReward.hasReceived) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_HAS_SIGN);
if(signReward.dayIndex > playerData.todayIndex) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_LOCK);
let record = await ActivityWeeklyFundModel.sign(serverId, activityId, roleId, dayIndex, playerData.todayIndex);
if(!record) return resResult(STATUS.ACTIVITY_WEEKLY_FUND_HAS_SIGN);
let rewardParamArr = stringToRewardParam(signReward.reward);
let { goods, addHeros } = await addReward(roleId, roleName, sid, serverId, rewardParamArr, ITEM_CHANGE_REASON.ACT_WEEKLY_FUND_SIGN);
return resResult(STATUS.SUCCESS, {
activityId, dayIndex, goods, addHeros
});
}
}
@@ -1,33 +1,34 @@
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '../../../pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerYuanbaoShopData } from '../../../services/activity/yuanbaoService';
export default function (app: Application) {
new HandlerService(app, {});
return new YuanbaoShopHandler(app);
}
export class YuanbaoShopHandler {
constructor(private app: Application) {
}
/************************元宝商店****************************/
/**
* @description 获取商店活动数据
* @param {BackendSession} session
* @memberof YuanbaoShopHandler
*/
async getShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerYuanbaoShopData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
}
import { Application, BackendSession, HandlerService, } from 'pinus';
import { resResult } from '@pubUtils/util';
import { STATUS } from '../../../consts';
import { getPlayerYuanbaoShopData } from '../../../services/activity/yuanbaoService';
export default function (app: Application) {
new HandlerService(app, {});
return new YuanbaoShopHandler(app);
}
export class YuanbaoShopHandler {
constructor(private app: Application) {
}
/************************元宝商店****************************/
/**
* @description 获取商店活动数据
* @param {BackendSession} session
* @memberof YuanbaoShopHandler
*/
async getShopActivity(msg: { activityId: number }, session: BackendSession) {
const { activityId } = msg;
const roleId = session.get('roleId');
const serverId = session.get('serverId');
let playerData = await getPlayerYuanbaoShopData(activityId, serverId, roleId);
if (!playerData) return resResult(STATUS.ACTIVITY_MISSING);
return resResult(STATUS.SUCCESS, playerData);
}
}