585 lines
20 KiB
C#
585 lines
20 KiB
C#
using System.Linq;
|
|
using Common;
|
|
using CommonDomain.BaseModel;
|
|
using CommonInfrastructure;
|
|
using Microsoft.AspNetCore.Authorization;
|
|
using Microsoft.AspNetCore.Mvc;
|
|
using UserApi;
|
|
using UserDomain;
|
|
using UserDomain.Entity;
|
|
using UserService;
|
|
using UserService.Response;
|
|
using UserService.Param;
|
|
using UserService.Tasks;
|
|
using UserService.Tasks.Param;
|
|
using UserService.User;
|
|
using UserService.BattleOrder;
|
|
using UserService.GameConfigs;
|
|
|
|
namespace UserApi.Hall
|
|
{
|
|
[ApiController, Route("api/[controller]")]
|
|
[Authorize]
|
|
|
|
public class HallController : BaseController
|
|
{
|
|
private readonly IUserService _userService;
|
|
private readonly ITaskService _taskService;
|
|
private readonly IBattleOrderService _battleOrderService;
|
|
private readonly IActivityConfigService _activityConfigService;
|
|
|
|
public HallController(IUserService userService, ITaskService taskService, IBattleOrderService battleOrderService, IActivityConfigService activityConfigService)
|
|
{
|
|
_userService = userService;
|
|
_taskService = taskService;
|
|
_battleOrderService = battleOrderService;
|
|
_activityConfigService = activityConfigService;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 存入保险箱
|
|
/// </summary>
|
|
[HttpGet("SaveSafeBox")]
|
|
public async Task<BaseResponse<string>> SaveSafeBox(int gold)
|
|
{
|
|
var res = await _userService.SaveSafeBox(gold, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 取出保险箱
|
|
/// </summary>
|
|
[HttpGet("GetSafeBox")]
|
|
public async Task<BaseResponse<string>> GetSafeBox(long gold, string password)
|
|
{
|
|
var res = await _userService.GetSafeBox(gold, password, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置保险箱密码
|
|
/// </summary>
|
|
[HttpGet("SetSafeBoxPassword")]
|
|
public async Task<BaseResponse<string>> SetSafeBoxPassword(string password)
|
|
{
|
|
var res = await _userService.SetSafeBoxPassword(password, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 重设保险箱密码 - 通过短信验证码重置
|
|
/// </summary>
|
|
[HttpGet("ResetSafeBoxPassword")]
|
|
public async Task<BaseResponse<string>> ResetSafeBoxPassword(string password, string code)
|
|
{
|
|
var res = await _userService.ResetSafeBoxPassword(password, code, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 领取救济金
|
|
/// </summary>
|
|
[HttpGet("GetRelief")]
|
|
public async Task<BaseResponse<string>> GetRelief()
|
|
{
|
|
var res = await _userService.GetReliefGold(loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 合成碎片
|
|
/// </summary>
|
|
[HttpGet("SynthesisFragment")]
|
|
public async Task<BaseResponse<BaseProductCount>> SynthesisFragment(string propNumber)
|
|
{
|
|
var res = await _userService.SyntheticFragments(propNumber, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<BaseProductCount>(res.model);
|
|
else
|
|
return this.ToFailResult<BaseProductCount>(res.msg);
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 购买道具
|
|
/// </summary>
|
|
[HttpGet("BuyProp")]
|
|
public async Task<BaseResponse<string>> BuyProp(string propNumber, int count = 1)
|
|
{
|
|
var res = await _userService.BuyProps(propNumber, count, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 使用VIP经验包
|
|
/// </summary>
|
|
[HttpGet("UseVipExp")]
|
|
public async Task<BaseResponse<string>> UseVipExp(int count = 1)
|
|
{
|
|
var res = await _userService.UseVipExp(count, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 购买金币
|
|
/// </summary>
|
|
[HttpGet("BuyGold")]
|
|
public async Task<BaseResponse<string>> BuyGold(string number, int count = 1)
|
|
{
|
|
var res = await _userService.BuyGold(number, count, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 购买钻石
|
|
/// </summary>
|
|
[HttpGet("BuyDiamond")]
|
|
public async Task<BaseResponse<string>> BuyDiamond(string number, int count = 1)
|
|
{
|
|
var res = await _userService.BuyDiamond(number, count, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.url);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 签到
|
|
/// </summary>
|
|
[HttpGet("SignIn")]
|
|
public async Task<BaseResponse<SignRewardResult>> SignIn()
|
|
{
|
|
var res = await _userService.Sign(loginUser);
|
|
if (res.isok)
|
|
return this.ToResult(res.result);
|
|
else
|
|
return this.ToFailResult<SignRewardResult>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取签到状态 - 返回当前签到进度与可领取状态
|
|
/// </summary>
|
|
[HttpGet("GetSignStatus")]
|
|
public async Task<BaseResponse<SignStatusResult>> GetSignStatus()
|
|
{
|
|
var res = await _userService.GetSignStatus(loginUser);
|
|
return this.ToResult(res);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 切换使用的炮台
|
|
/// </summary>
|
|
[HttpGet("ChangeCannon")]
|
|
public async Task<BaseResponse<string>> ChangeCannon(string number)
|
|
{
|
|
var res = await _userService.ChangeCannon(number, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 切换使用的翅膀
|
|
/// </summary>
|
|
[HttpGet("ChangeWing")]
|
|
public async Task<BaseResponse<string>> ChangeWing(string number)
|
|
{
|
|
var res = await _userService.ChangeWing(number, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 切换使用的战神
|
|
/// </summary>
|
|
[HttpGet("ChangeGodWar")]
|
|
public async Task<BaseResponse<string>> ChangeGodWar(string number)
|
|
{
|
|
var res = await _userService.ChangeGodWar(number, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 卸载当前使用的炮台并切换为默认基础炮台（不会删除已拥有的炮台）
|
|
/// </summary>
|
|
[HttpGet("UnloadCannon")]
|
|
public async Task<BaseResponse<string>> UnloadCannon(string number)
|
|
{
|
|
var res = await _userService.UnloadCannon(number, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 卸载当前使用的翅膀（不会删除已拥有的翅膀）
|
|
/// </summary>
|
|
[HttpGet("UnloadWing")]
|
|
public async Task<BaseResponse<string>> UnloadWing(string number)
|
|
{
|
|
var res = await _userService.UnloadWing(number, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 卸载当前使用的战神（不会删除已拥有的战神）
|
|
/// </summary>
|
|
[HttpGet("UnloadGodWar")]
|
|
public async Task<BaseResponse<string>> UnloadGodWar(string number)
|
|
{
|
|
var res = await _userService.UnloadGodWar(number, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<string>(res.msg);
|
|
else
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 领取Vip每日礼包
|
|
/// </summary>
|
|
[HttpGet("GetVipDayGift")]
|
|
public async Task<BaseResponse<GiftResponse>> GetVipDayGift()
|
|
{
|
|
var res = await _userService.GetVipDayGift(loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<GiftResponse>(res.model);
|
|
else
|
|
return this.ToFailResult<GiftResponse>(res.msg);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 领取Vip权益
|
|
/// </summary>
|
|
[HttpGet("GetVipGift")]
|
|
public async Task<BaseResponse<GiftResponse>> GetVipGift(int vipLevel)
|
|
{
|
|
var res = await _userService.GetVipGift(vipLevel, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult<GiftResponse>(res.model);
|
|
else
|
|
return this.ToFailResult<GiftResponse>(res.msg);
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 获取用户任务列表
|
|
/// </summary>
|
|
[HttpGet("GetUserTaskList")]
|
|
[Authorize]
|
|
public async Task<ListResponse<UserTaskDto>> GetUserTaskList(int taskType)
|
|
{
|
|
var result = await _taskService.GetUserTaskList(new GetUserTaskListParam() { TaskType = taskType }, loginUser.UserId);
|
|
var dtos = result.Select(MapToUserTaskDto).ToList();
|
|
return this.ToListResult(dtos);
|
|
}
|
|
|
|
private static UserTaskDto MapToUserTaskDto(UserTask entity)
|
|
{
|
|
if (entity == null) return new UserTaskDto();
|
|
return new UserTaskDto
|
|
{
|
|
Id = entity.Id ?? "",
|
|
UserId = entity.UserId ?? "",
|
|
Number = entity.Number ?? "",
|
|
Remark = entity.Remark ?? "",
|
|
TaskType = (int)entity.TaskType,
|
|
TaskEvent = (int)entity.TaskEvent,
|
|
TaskCount = entity.TaskCount,
|
|
Count = entity.Count,
|
|
IsFinish = entity.IsFinish,
|
|
OtherId = entity.OtherId ?? "",
|
|
IsGet = entity.IsGet,
|
|
TaskAddTime = entity.TaskAddTime,
|
|
TaskEndTime = entity.TaskEndTime,
|
|
TaskFinishTime = entity.TaskFinishTime,
|
|
Exp = entity.Exp
|
|
};
|
|
}
|
|
/// <summary>
|
|
/// 领取任务奖励
|
|
/// </summary>
|
|
[HttpGet("DistributeRewards")]
|
|
public async Task<BaseResponse<string>> DistributeRewards(string id)
|
|
{
|
|
var result = await _taskService.DistributeRewards(id, loginUser.UserId);
|
|
if (result.isok)
|
|
return this.ToResult(result.msg);
|
|
else
|
|
return this.ToFailResult<string>(result.msg);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取资产变动记录
|
|
/// </summary>
|
|
[HttpPost("GetUserRewardList")]
|
|
public async Task<PageResponse<UserRewardDto>> GetUserRewardList(GetUserRewardListParam param)
|
|
{
|
|
param.UserId = loginUser.UserId;
|
|
var res = await _userService.GetUserRewardList(param);
|
|
if(res.list==null || res.list.Count()==0)
|
|
return this.ToPageResult<UserRewardDto>(null, res.count);
|
|
var dtos = res.list.Select(MapToUserRewardDto).ToList();
|
|
return this.ToPageResult(dtos, res.count);
|
|
}
|
|
|
|
private static UserRewardDto MapToUserRewardDto(UserReward entity)
|
|
{
|
|
if (entity == null) return new UserRewardDto();
|
|
return new UserRewardDto
|
|
{
|
|
Id = entity.Id ?? "",
|
|
UserId = entity.UserId ?? "",
|
|
Type = entity.Type,
|
|
Source = (int)entity.Source,
|
|
CurrencyType = entity.CurrencyType,
|
|
BeforeCount = entity.BeforeCount,
|
|
ChangeCount = entity.ChangeCount,
|
|
AfterCount = entity.AfterCount,
|
|
OtherId = entity.OtherId ?? "",
|
|
OtherUserId = entity.OtherUserId ?? "",
|
|
Remark = entity.Remark ?? "",
|
|
RoomName = entity.RoomName ?? "",
|
|
RoomInfo = entity.RoomInfo ?? "",
|
|
Tax = entity.Tax,
|
|
CreateTime = entity.CreateTime
|
|
};
|
|
}
|
|
|
|
|
|
|
|
public class UserTaskDto
|
|
{
|
|
public string Id { get; set; }
|
|
public string UserId { get; set; }
|
|
public string Number { get; set; }
|
|
public string Remark { get; set; }
|
|
public int TaskType { get; set; }
|
|
public int TaskEvent { get; set; }
|
|
public int TaskCount { get; set; }
|
|
public double Count { get; set; }
|
|
public bool IsFinish { get; set; }
|
|
public string OtherId { get; set; }
|
|
public bool IsGet { get; set; }
|
|
public long TaskAddTime { get; set; }
|
|
public long TaskEndTime { get; set; }
|
|
public long TaskFinishTime { get; set; }
|
|
public long Exp { get; set; }
|
|
}
|
|
|
|
public class UserRewardDto
|
|
{
|
|
public string Id { get; set; }
|
|
public string UserId { get; set; }
|
|
public int Type { get; set; }
|
|
public int Source { get; set; }
|
|
public int CurrencyType { get; set; }
|
|
public long BeforeCount { get; set; }
|
|
public long ChangeCount { get; set; }
|
|
public long AfterCount { get; set; }
|
|
public string OtherId { get; set; }
|
|
public string OtherUserId { get; set; }
|
|
public string Remark { get; set; }
|
|
public string RoomName { get; set; }
|
|
public string RoomInfo { get; set; }
|
|
public int Tax { get; set; }
|
|
public long CreateTime { get; set; }
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 获取用户战令信息
|
|
/// </summary>
|
|
[HttpGet("GetBattleOrder")]
|
|
public async Task<BaseResponse<BattleOrderResponse>> GetBattleOrder()
|
|
{
|
|
var result = await _battleOrderService.GetUserBattleOrderWithConfigAsync(loginUser.UserId);
|
|
return this.ToResult(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取各等级奖励领取状态
|
|
/// </summary>
|
|
[HttpGet("GetBattleOrderLevelStatus")]
|
|
public async Task<BaseResponse<BattleOrderLevelStatusResponse>> GetBattleOrderLevelStatus()
|
|
{
|
|
var result = await _battleOrderService.GetLevelRewardStatusAsync(loginUser.UserId);
|
|
return this.ToResult(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 一键领取战令奖励
|
|
/// </summary>
|
|
[HttpGet("ReceiveAllBattleOrderRewards")]
|
|
public async Task<ListResponse<GiftConfig>> ReceiveAllBattleOrderRewards()
|
|
{
|
|
var result = await _battleOrderService.ReceiveAllRewardsAsync(loginUser.UserId);
|
|
if (result.success)
|
|
return this.ToListResult(result.rewards);
|
|
else
|
|
return this.ToListFailResult<GiftConfig>(result.message);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 领取指定等级战令奖励
|
|
/// </summary>
|
|
[HttpGet("ReceiveBattleOrderLevelReward")]
|
|
public async Task<ListResponse<GiftConfig>> ReceiveBattleOrderLevelReward( int level)
|
|
{
|
|
var result = await _battleOrderService.ReceiveLevelRewardAsync(loginUser.UserId, level);
|
|
if (result.success)
|
|
return this.ToListResult(result.rewards);
|
|
else
|
|
return this.ToListFailResult<GiftConfig>(result.message);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 购买战令等级
|
|
/// </summary>
|
|
[HttpGet("BuyBattleOrderLevel")]
|
|
public async Task<BaseResponse<BuyBattleOrderLevelResponse>> BuyBattleOrderLevel(int levelCount)
|
|
{
|
|
var result = await _battleOrderService.BuyLevelsAsync(loginUser.UserId, levelCount);
|
|
if (result.success)
|
|
return this.ToResult(new BuyBattleOrderLevelResponse
|
|
{
|
|
NewLevel = result.newLevel,
|
|
Cost = result.cost
|
|
});
|
|
else
|
|
return this.ToFailResult<BuyBattleOrderLevelResponse>(result.message);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 购买战令进阶
|
|
/// </summary>
|
|
[HttpGet("BuyBattleOrderAdvance")]
|
|
public async Task<BaseResponse<BuyBattleOrderAdvanceResponse>> BuyBattleOrderAdvance(int type)
|
|
{
|
|
var result = await _battleOrderService.BuyAdvanceAsync(loginUser.UserId, type);
|
|
if (result.success)
|
|
return this.ToResult(new BuyBattleOrderAdvanceResponse
|
|
{
|
|
Success = true,
|
|
Message = result.message,
|
|
PurchasedAdvances = result.purchasedAdvances
|
|
});
|
|
else
|
|
return this.ToFailResult<BuyBattleOrderAdvanceResponse>(result.message);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 一键领取所有任务奖励
|
|
/// </summary>
|
|
[HttpGet("ReceiveAllTaskRewards")]
|
|
public async Task<BaseResponse<object>> ReceiveAllTaskRewards()
|
|
{
|
|
var result = await _taskService.ReceiveAllTaskRewardsAsync(loginUser.UserId);
|
|
if (result.success)
|
|
return this.ToResult<object>(new { message = result.message, totalExp = result.totalExp });
|
|
else
|
|
return this.ToFailResult<object>(result.message);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 获取用户排行榜
|
|
/// </summary>
|
|
[HttpGet("GetRanking")]
|
|
public async Task<BaseResponse<RankingResponse>> GetRanking(int type = 1)
|
|
{
|
|
var config = await _activityConfigService.Get();
|
|
var rankingConfig = config?.RankingRewardConfig;
|
|
if (rankingConfig != null && rankingConfig.IsMaintaining)
|
|
{
|
|
return this.ToFailResult<RankingResponse>(
|
|
string.IsNullOrEmpty(rankingConfig.MaintainingMessage)
|
|
? "当前排行榜正在维护中，请稍后再试"
|
|
: rankingConfig.MaintainingMessage);
|
|
}
|
|
var result = await _userService.GetRanking(loginUser, type);
|
|
return this.ToResult(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// 使用大喇叭发送全服广播
|
|
/// </summary>
|
|
[HttpGet("SendBroadcast")]
|
|
public async Task<BaseResponse<string>> SendBroadcast(string message)
|
|
{
|
|
var res = await _userService.SendBroadcast(message, loginUser);
|
|
if (res.isok)
|
|
return this.ToResult(res.msg);
|
|
return this.ToFailResult<string>(res.msg);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// 获取象棋分区总数
|
|
/// </summary>
|
|
[AllowAnonymous]
|
|
[HttpGet("GetChessRoomPartitionCount")]
|
|
public async Task<BaseResponse<int>> GetChessRoomPartitionCount([FromServices] UserService.GameConfigs.IGameConfigService gameConfigService)
|
|
{
|
|
var config = await gameConfigService.Get();
|
|
if (config == null)
|
|
return this.ToFailResult<int>("配置不存在");
|
|
|
|
var total = config.RoomConfigs
|
|
.Where(r => r.GameType == CommonDomain.Enum.GameTypeEnum.中国象棋)
|
|
.Sum(r => r.RoomPartitionNum);
|
|
|
|
return this.ToResult(total);
|
|
}
|
|
}
|
|
}
|