/// <summary>
/// 审核比赛报名队伍资格
/// </summary>
/// <param name="currentUser">忽略</param>
/// <param name="request">Request.GameTeam.Entities</param>
/// <returns>Response.EmptyEntity</returns>
public Response Execute(string request)
{
var req = JsonConvert.DeserializeObject <Request <GameTeam> >(request);
var team = req.Entities.FirstOrDefault();
team.AuditDate = DateTime.Now;
team.SetRowModified();
var cmd = CommandHelper.CreateSave(req.Entities);
cmd.OnlyFields = new List <TableFieldPair> {
new TableFieldPair {
Table = "GameTeam", Fields = "AuditRemark,State,AuditDate,AuditorId"
}
};
var result = DbContext.GetInstance().Execute(cmd);
try
{
var state = GameTeamState.find(team.State.GetId());
var game = GameHelper.GetGame(team.GameId.GetId());
var msg = string.Format("您参加[{0}]比赛的申请被{1}。{2}",
team.TeamName, state.Name, game.Cost > 0 &&
!team.IsPayCost ? "请及时支付报名费。" : string.Empty);
JPushHelper.SendNotify(MasterType.GAME.Id, game.Id, msg, new List <string> {
team.TeamUserId
});
}
catch (Exception)
{
}
return(result);
}
/// <summary>
/// 单淘汰，按人抽签
/// </summary>
/// <param name="request">Request.GameOrder.Entities</param>
/// <returns>Response.EmptyEntity</returns>
public Response Execute(string request)
{
var req = JsonConvert.DeserializeObject <Request <GameOrder> >(request);
var order = GameHelper.GetGameOrder(req.Filter.Id);
if (order.State != GameOrderState.NOTSTART.Id)
{
return(ResultHelper.Fail("比赛已经开始，不能再进行抽签。"));
}
var memberList = GetGameTeamList(order);
if (memberList.IsNullOrEmpty())
{
return(ResultHelper.Fail("无参赛人员，不能进行抽签。"));
}
//参照2名算法
order.KnockoutCount = 2;
order.SetKnockOutAB(GameHelper.GetGame(order.GameId).IsKnockOutAB);
//获取1，2名位置列表
var posListAll = KnockoutDrawHelper.CalRankPosAndSort(order.KnockoutTotal, order.KnockoutCount, 1);
var posListTwo = KnockoutDrawHelper.CalRankPosAndSort(order.KnockoutTotal, order.KnockoutCount, 2);
posListAll.AddRange(posListTwo);
//初始化所有位置
order.PositionList = new List <GamePosition>();
for (int i = 0; i < order.KnockoutTotal; i++)
{
order.PositionList.Add(new GamePosition {
Index = i
});
}
//取小值循环
int count = Math.Min(posListAll.Count, memberList.Count);
for (int i = 0; i < count; i++)
{
order.PositionList[posListAll[i]].UserId = memberList[i].Id.Link(memberList[i].TeamName);
if (i < posListAll.Count / 2)
{
order.PositionList[posListAll[i]].IsSeed = true;
}
memberList[i].IsEnterPos = true;
}
//检查轮空或者抢号
CheckByeOrKnock(order, posListAll, memberList);
//检查相同单位
GetGamePositionList.CheckSameCorpTeamId(order);
var resultOrder = ResultHelper.Success(new List <EntityBase> {
order
});
return(resultOrder);
}
/// <summary>
/// 第二轮淘汰赛，获取按人抽签位置列表
/// </summary>
/// <param name="request">Request.GameOrder.Entities</param>
/// <returns>Response.EmptyEntity</returns>
public Response Execute(string request)
{
var req = JsonConvert.DeserializeObject <Request <GameOrder> >(request);
var firstOrder = GameHelper.GetGameOrder(req.Filter.Id);
firstOrder.CalAllPosition = req.Filter.CalAllPosition;
firstOrder.SeedList = req.Filter.SeedList;
firstOrder.KnockOutAB = req.Filter.KnockOutAB.IsNotNullOrEmpty() ? req.Filter.KnockOutAB : KnockOutAB.A;
//设置AB选项
var game = GameHelper.GetGame(firstOrder.GameId);
firstOrder.SetKnockOutAB(game.IsKnockOutAB);
//第一次检查小组赛是否结束，是否已计算排名或已经抽过签（AB组分开验证）
if (!firstOrder.CalAllPosition)
{
var cmdValidate = CommandHelper.CreateProcedure(FetchType.Execute, "sp_CheckGameGroupState");
cmdValidate.Params.Add("@gameId", firstOrder.GameId);
cmdValidate.Params.Add("@knockOutAB", firstOrder.KnockOutAB);
cmdValidate.CreateParamMsg();
var resultVal = DbContext.GetInstance().Execute(cmdValidate);
//验证失败，返回错误信息
if (!resultVal.IsSuccess)
{
return(resultVal);
}
}
if (firstOrder.CalAllPosition)
{
SetPositionListTwo(firstOrder, false);
CheckSameCorpTeamId(firstOrder);
//第二次返回所有名次
firstOrder.MemberList = GetGroupKnockUserList(firstOrder, firstOrder.BeginRankAB, firstOrder.EndRankAB);
}
else
{
SetPositionListFirst(firstOrder);
//第一次仅返回第一名
firstOrder.MemberList = GetGroupKnockUserList(firstOrder, firstOrder.BeginRankAB, firstOrder.BeginRankAB);
}
var resultOrder = ResultHelper.Success(new List <EntityBase> {
firstOrder
});
return(resultOrder);
}
/// <summary>
/// 反审核比赛报名队伍
/// </summary>
/// <param name="currentUser">忽略</param>
/// <param name="request">Request.GameTeam.Entities</param>
/// <returns>Response.EmptyEntity</returns>
public Response Execute(string request)
{
var req = JsonConvert.DeserializeObject <Request <GameTeam> >(request);
var team = req.Entities.FirstOrDefault();
team.State = GameTeamState.PROCESSING.Id;
team.AuditorId = null;
team.AuditDate = null;
team.AuditRemark = null;
team.SetRowModified();
var cmd = CommandHelper.CreateSave(req.Entities);
cmd.OnlyFields = new List <TableFieldPair> {
new TableFieldPair {
Table = "GameTeam", Fields = "AuditRemark,State,AuditDate,AuditorId"
}
};
var result = DbContext.GetInstance().Execute(cmd);
try
{
var state = GameTeamState.find(team.State.GetId());
var game = GameHelper.GetGame(team.GameId.GetId());
var msg = string.Format("您参加[{0}]比赛的申请被退回，可修改后再提交。", team.TeamName);
JPushHelper.SendNotify(MasterType.GAME.Id, game.Id, msg, new List <string> {
team.CreatorId.GetId()
});
}
catch (Exception)
{
}
return(result);
}
/// <summary>
/// 获取比赛大轮次表
/// </summary>
/// <param name="currentUser">忽略</param>
/// <param name="request">Request.Game.Filter</param>
/// <returns>Response.GameOrder</returns>
public Response Execute(string request)
{
var req = JsonConvert.DeserializeObject <Request <Game> >(request);
var cmd = CommandHelper.CreateProcedure <GameOrder>(text: "sp_GetGameOrderList");
cmd.Params.Add(CommandHelper.CreateParam("@GameId", req.Filter.Id));
var result = DbContext.GetInstance().Execute(cmd);
result.SetRowCount();
result.Tag = GameHelper.GetGame(req.Filter.Id).State;
var first = result.FirstEntity <GameOrder>();
if (first != null)
{
if (first.KnockoutOption == KnockoutOption.ROUND.Id)
{
first.GroupList = GameHelper.GetOrderGroupList(first.Id);
}
}
return(result);
}
private static Response Excute(List <GameGroup> gplist)
{
if (gplist.IsNullOrEmpty())
{
return(ResultHelper.Fail("无数据。"));
}
//检查比赛状态，比赛准备才允许小组抽签
var firstGroup = gplist.First();
var game = GameHelper.GetGame(firstGroup.GameId);
if (game.State != GameState.PREPARE.Id)
{
return(ResultHelper.Fail("比赛准备才能进行小组抽签。"));
}
bool isRoundThenKnock = game.KnockoutOption == KnockoutOption.ROUND_KNOCKOUT.Id;
//先循环后淘汰，验证组成员
if (isRoundThenKnock)
{
var firstOrder = GameHelper.GetGameOrder(firstGroup.OrderId);
//根据OrderNo排序
foreach (var group in gplist)
{
//验证小组人数不足出线人数
if (group.MemberList.Count < firstOrder.KnockoutCountAB)
{
return(ResultHelper.Fail(string.Format("{0}人数不足要求出线人数{1}个，无法保存。", group.Name, firstOrder.KnockoutCount)));
}
group.MemberList = group.MemberList.OrderBy(p => p.OrderNo).ToList();
}
}
var memberEntities = new List <EntityBase>();
var loopEntities = new List <EntityBase>();
foreach (var group in gplist)
{
if (group.MemberList.IsNotNullOrEmpty())
{
//先循环后淘汰，创建组成员
if (isRoundThenKnock)
{
CreateOneGroupMembers(memberEntities, group);
}
//创建组循环赛
CreateOneGroupLoops(loopEntities, group);
}
}
//合并数据
var entities = new List <EntityBase>();
//先循环后淘汰，保存组成员
if (isRoundThenKnock && memberEntities.IsNotNullOrEmpty())
{
entities.AddRange(memberEntities);
}
if (loopEntities.IsNotNullOrEmpty())
{
entities.AddRange(loopEntities);
}
var cmdSave = CommandHelper.CreateSave(entities);
//删除原来生成的小组赛轮次表，后面重新生成
var cmdDelete = CommandHelper.CreateProcedure(FetchType.Execute, "sp_DeleteGameGroup");
cmdDelete.Params.Add("@GameId", gplist.First().GameId);
cmdDelete.Params.Add("@GroupIdString", GetGroupIdString(gplist));
cmdSave.PreCommands.Add(cmdDelete);
return(DbContext.GetInstance().Execute(cmdSave));
}
/// <summary>
/// 定义首轮，并自动创建剩下轮次，可以形成拓扑图(小组赛不创建，创建淘汰赛轮次的所有比赛，附加赛)
/// </summary>
/// <param name="request">Request.GameOrder.Entities</param>
/// <returns>Response.EmptyEntity</returns>
public Response Execute(User currentUser, string request)
{
var req = JsonConvert.DeserializeObject <Request <GameOrder> >(request);
var firstOrder = req.FirstEntity();
if (firstOrder.RowState == RowState.Added)
{
firstOrder.SetNewId();
firstOrder.SetCreateDate();
firstOrder.State = GameOrderState.NOTSTART.Id;
}
var entities = new List <EntityBase> {
firstOrder
};
var game = GameHelper.GetGame(firstOrder.GameId);
//设置第一轮KnockoutOption
firstOrder.IsTeam = game.IsTeam;
firstOrder.KnockoutOption = game.KnockoutOption == KnockoutOption.ROUND_KNOCKOUT.Id ? KnockoutOption.ROUND.Id : game.KnockoutOption;
if (game.KnockoutOption == KnockoutOption.ROUND.Id)
{
//单循环赛
var filter = new GetGameTeamListFilter {
GameId = game.Id, PageIndex = 1, PageSize = 10000
};
var teamList = GameHelper.GetGameTeamList(filter).Entities.ToList <EntityBase, GameTeam>();
if (teamList.Count < 2)
{
return(ResultHelper.Fail("至少2支参赛队才能建立单循环赛！"));
}
CreateSingleRound(firstOrder, entities, game, teamList);
}
else
{
//单淘汰赛，先循环后淘汰赛
//设置AB模式选项
firstOrder.SetKnockOutAB(game.IsKnockOutAB);
//验证数据
var valResult = Validate(game, firstOrder);
if (!valResult.IsSuccess)
{
return(ResultHelper.Fail(valResult.Message));
}
//设置第一轮数据
int orderNo = 1;//大轮次序号，从1开始
firstOrder.OrderNo = orderNo;
firstOrder.Name = string.Format(firstOrder.KnockoutOption == KnockoutOption.ROUND.Id ? "小组赛" : "1/{1}决赛", firstOrder.OrderNo, firstOrder.GroupCount);
//创建轮次，正常比赛，附加赛，合并数据
var loopEntities = new List <EntityBase>();
var groupEntities = new List <EntityBase>();
var extraEntities = new List <EntityBase>();
CreateMoreOrderAndLoop(req, entities, firstOrder, game, orderNo, loopEntities, groupEntities);
//初始化轮次计分模式
entities.ForEach(p => (p as GameOrder).TeamScoreMode = TeamScoreMode.STANDARD.Id);
if (firstOrder.TopNumber > 0)
{
//决出名次验证
if (entities.Count < Math.Log(firstOrder.TopNumber, 2))
{
return(ResultHelper.Fail("决出名次大于轮次可决出名次。"));
}
CreateExtraGame(game, entities, firstOrder.TopNumber, extraEntities);
}
MergeData(entities, loopEntities, groupEntities, extraEntities);
}
//创建保存命令，并加入删除之前数据命令
var cmdDelete = CommandHelper.CreateProcedure(FetchType.Execute, "sp_DeleteGameAllDetail");
cmdDelete.Params.Add("@gameId", firstOrder.GameId);
var cmdSave = CommandHelper.CreateSave(entities);
cmdSave.PreCommands.Add(cmdDelete);
return(DbContext.GetInstance().Execute(cmdSave));
}
/// <summary>
/// 第二轮淘汰赛，保存按人抽签
/// </summary>
/// <param name="request">Request.GameOrder.Entities</param>
/// <returns>Response.EmptyEntity</returns>
public Response Execute(string request)
{
var req = JsonConvert.DeserializeObject <Request <GameOrder> >(request);
var temp = req.FirstEntity();
//验证数据
var valResult = Validate(temp);
if (!valResult.IsSuccess)
{
return(valResult);
}
var firstOrder = GameHelper.GetGameOrder(req.Entities.First().Id);
//设置新的位置列表
firstOrder.PositionList = temp.PositionList;
//缓存KnockOutAB,保存之前再恢复
string tempKnockOutAB = firstOrder.KnockOutAB;
firstOrder.KnockOutAB = temp.KnockOutAB.IsNotNullOrEmpty() ? temp.KnockOutAB : KnockOutAB.A;
//设置AB选项
var game = GameHelper.GetGame(firstOrder.GameId);
firstOrder.SetKnockOutAB(game.IsKnockOutAB);
var entities = new List <EntityBase>();
//获取第二轮淘汰比赛所有场次（非附加赛）
List <GameLoop> loopList = null;
//获取第二轮编号（用于小组循环后淘汰）
var actualNextOrderId = temp.KnockOutAB == KnockOutAB.B ? firstOrder.NextOrderBId : firstOrder.NextOrderId;
if (firstOrder.KnockoutOption == KnockoutOption.ROUND.Id)
{
//小组循环后淘汰，设置本轮次结束，并获取下轮次比赛
firstOrder.State = GameOrderState.FINISH.Id;
firstOrder.SetRowModified();
entities.Add(firstOrder);
//获取第二轮比赛
loopList = GameHelper.GetOrderLoopListNoExtra(actualNextOrderId);
}
else
{
//单淘汰，获取第一轮比赛
var cmd = CommandHelper.CreateText <GameLoop>();
cmd.Text = "SELECT * FROM GameLoop WHERE GameId=@gameId AND OrderId=@orderId AND IsExtra=0 AND ISNULL(KnockLoopId,'')='' ORDER BY OrderNo";
cmd.Params.Add("@gameId", firstOrder.GameId);
cmd.Params.Add("@orderId", firstOrder.Id);
loopList = DbContext.GetInstance().Execute(cmd).Entities.ToList <EntityBase, GameLoop>();
}
//将相邻位置球员进入对应场次比赛
SetEnterKnockPos(firstOrder, entities, loopList);
var cmdSave = CommandHelper.CreateSave(entities);
//保存之前删除原来抢位赛（单淘汰为第一轮，小组循环后为第二轮）
var cmdDelete = CommandHelper.CreateText(FetchType.Execute, "DELETE FROM GameLoop WHERE GameId=@gameId AND OrderId=@orderId AND ISNULL(KnockLoopId,'')!=''");
cmdDelete.Params.Add("@gameId", firstOrder.GameId);
cmdDelete.Params.Add("@orderId", firstOrder.KnockoutOption == KnockoutOption.ROUND.Id ? actualNextOrderId : firstOrder.Id);
cmdSave.PreCommands = new List <Command> {
cmdDelete
};
//保存前恢复firstOrder.KnockOutAB原数据（小组赛第一轮为空）
firstOrder.KnockOutAB = tempKnockOutAB;
return(DbContext.GetInstance().Execute(cmdSave));
}
/// <summary>
/// 更新比赛状态
/// </summary>
/// <param name="currentUser">忽略</param>
/// <param name="request">Request.Game</param>
/// <returns>Response.EmptyEntity</returns>
public Response Execute(string request)
{
var req = JsonConvert.DeserializeObject <Request <Game> >(request);
var game = req.Entities.FirstOrDefault();
//进行中的比赛不能取消
var dbGame = GameHelper.GetGame(game.Id);
if (game.State.GetId() == GameState.CANCEL.Id && dbGame.State.GetId() == GameState.PROCESSING.Id)
{
return(ResultHelper.Fail("进行中的比赛不能取消"));
}
//状态更新
var cmd = CommandHelper.CreateProcedure(FetchType.Execute, "sp_SetGameState");
cmd.Params.Add("@gameId", game.Id);
cmd.Params.Add("@state", game.State.GetId());
cmd.CreateParamMsg();
var result = DbContext.GetInstance().Execute(cmd);
///////////////////////////////////////////////////////////////////////
if (result.IsSuccess)//假如是赛事正常结束状态,则更新选中团体模板的使用数量
{
bool flag = false;
if (result.OutParams.Count <= 0)
{
flag = true;
}
else
{
string outValue = result.OutParams[0].value.ToString();
if (string.IsNullOrEmpty(outValue))
{
flag = true;
}
}
if (game.State == GameState.FINISH.Id) //比赛结束时 015005 ,更改模板使用次数
{
if (flag) //假如输出参数有值,则表示不能结束比赛,不更新模板次数
{
var cmd2 = CommandHelper.CreateText <Game>(FetchType.Fetch, "SELECT TeamMode FROM Game WHERE Id=@gameId");
cmd2.Params.Add("@gameId", game.Id);
var res2 = DbContext.GetInstance().Execute(cmd2);
string templetId = (res2.Entities[0] as Game).TeamMode;//模板ID
if (!string.IsNullOrEmpty(templetId))
{
GameLoopTempletHelper.UpdateTempletUseCount(templetId, "");
}
}
}
///////////////////////////////////////////////////////////////////////////////////////
try
{
if (flag)//根据返回输出参数判断,是否能更改状态,不空为不能更改
{
var state = GameState.Find(game.State.GetId());
var msg = string.Format("您参加的[{0}] 比赛[{1}]。", game.Name, state.Name);
JPushHelper.SendNotify(MasterType.GAME.Id, game.Id, msg, GameHelper.GetAllUserIdList(game.Id));
}
}
catch (Exception)
{
}
}
return(result);
}
/// <summary>
/// 参赛队伍报名
/// </summary>
/// <param name="currentUser">忽略</param>
/// <param name="request">Request.GameTeam</param>
/// <returns>Response.EmptyEntity</returns>
public Response Execute(User currentUser, string request)
{
var req = JsonConvert.DeserializeObject <Request <GameTeam> >(request);
var team = req.Entities.FirstOrDefault();
//////////////////团体对阵时增加对阵模板上场人数与队员人数比较/////////////////////
if (team.IsTeam)
{
bool flag = GameLoopTempletHelper.IsJoinGame(team.GameId, team.TeamUserId);
if (!flag)
{
return(ResultHelper.Fail("参赛队伍人数少于团体对阵模板最少人数"));
}
}
////////////////////////////////////////////////////////////////////
team.AuditorId = team.AuditorId.GetId();
team.CreatorId = team.CreatorId.GetId();
team.GameId = team.GameId.GetId();
team.State = team.State.GetId();
team.CompanyId = team.CompanyId.GetId();
if (team.TeamName.IsNullOrEmpty())
{
team.TeamName = team.TeamUserName;
}
if (string.IsNullOrEmpty(team.NationalId))
{
team.NationalId = "flag_china@2x";//默认是中国
}
var entities = new List <EntityBase> {
team
};
if (team.RowState == RowState.Added)
{
team.SetNewId();
team.SetCreateDate();
if (team.CreatorId.IsNullOrEmpty())
{
team.CreatorId = currentUser.Id;
}
//如果没有设置头像，则使用当前创建者的头像
SetHeadUrl(team.CreatorId, team);
}
var resultCheck = Validate(team, team.CreatorId.GetId());//待加入存在未支付消费的验证
if (!resultCheck.IsSuccess)
{
return(ResultHelper.Fail(resultCheck.Message));
}
team.ModifyHeadIcon();
var result = DbContext.GetInstance().Execute(CommandHelper.CreateSave(entities));
try
{
var game = GameHelper.GetGame(team.GameId);
var msg = string.Format("有参赛人员[{0}]报名，请及时审核资格。", team.TeamName);
JPushHelper.SendNotify(MasterType.GAME.Id, game.Id, msg, new List <string> {
game.CreatorId
});
}
catch (Exception)
{
}
return(result);
}
