private void 启动ToolStripMenuItem_Click(object sender, EventArgs e)
{
isweb = false;
gw = new GateWay(isweb);
gw.Proportion = Convert.ToInt32(toolStripTextBox3.Text);
gw.EventMylog += Gw_EventMylog;
if (gw.Run("127.0.0.1", Convert.ToInt32(toolStripTextBox1.Text),int.Parse(toolStripTextBox2.Text)))
{
toolStripStatusLabel1.Text = "服务启动成功，端口"+ (toolStripTextBox1.Text) + "。";
timer1.Start();
}
}
public async Task <IActionResult> GetMatches(
int offset = 0,
int pageSize = 100,
GameMode gameMode = GameMode.Undefined,
GateWay gateWay = GateWay.Undefined)
{
if (pageSize > 100)
{
pageSize = 100;
}
var matches = await _matchRepository.Load(gateWay, gameMode, offset, pageSize);
var count = await _matchRepository.Count(gateWay, gameMode);
return(Ok(new { matches, count }));
}
public Task <List <Matchup> > Load(
GateWay gateWay = GateWay.Undefined,
GameMode gameMode = GameMode.Undefined,
int offset = 0,
int pageSize = 100)
{
var mongoCollection = CreateCollection <Matchup>();
return(mongoCollection
.Find(m => (gameMode == GameMode.Undefined || m.GameMode == gameMode) &&
(gateWay == GateWay.Undefined || m.GateWay == gateWay))
.SortByDescending(s => s.Id)
.Skip(offset)
.Limit(pageSize)
.ToListAsync());
}
/// <summary>
///
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ActionResult Create(string id)
{
try {
if (ViewBag.Error != null)
{
ViewBag.Error = "";
}
Solicitante usuario = Usuario();
if (usuario == null)
{
return(RedirectToAction("Login", "Solicitante"));
}
GateWay gateway = new GateWay();
gateway.Token = Request.Cookies["token"]["valor"];
ViewBag.nombreUsuario = usuario.NombreCompleto;
var servicios = gateway.PeticionGet <IEnumerable <Servicio> >("", "servicios/collection");
if (servicios.State == "FAIL")
{
return(View("~/Views/Shared/_Error.cshtml"));
}
servicios.Data = servicios.Data.OrderBy(servi => servi.NombreServicios);
var estado = new MensajeRetorno <IEnumerable <Estado> >();
if (id == null)
{
estado = gateway.PeticionGet <IEnumerable <Estado> >(servicios.Data.First().Id.ToString(), "estados/collection");
}
else
{
estado = gateway.PeticionGet <IEnumerable <Estado> >(id, "estados/collection");
}
if (estado.State == "FAIL")
{
return(View("~/Views/Shared/_Error.cshtml"));
}
ViewBag.estados = estado.Data.OrderBy(est => est.Posicion).ToList();
ViewBag.selectServicio = id == null?servicios.Data.First() : servicios.Data.Where(ser => ser.Id.ToString() == id).FirstOrDefault();
ViewBag.servicios = servicios.Data;
ViewBag.solicitante = usuario;
return(View());
}
catch
{
return(View("~/Views/Shared/_Error.cshtml"));
}
}
public BattleTagIdCombined(List <PlayerId> battleTags,
GateWay gateWay,
GameMode gameMode,
int season,
Race?playerRaceIfSingle)
{
BattleTags = battleTags;
GateWay = gateWay;
GameMode = gameMode;
Season = season;
Race = playerRaceIfSingle;
Id = $"{season}_{string.Join("_", battleTags.OrderBy(t => t.BattleTag).Select(b => $"{b.BattleTag}@{(int)gateWay}"))}_{gameMode}";
if (playerRaceIfSingle != null)
{
Id += $"_{playerRaceIfSingle}";
}
}
private async Task PopulateLeagueInfo(List <Rank> ranks, int season, GateWay gateWay, GameMode gameMode)
{
var leagues = (await _rankRepository.LoadLeagueConstellation(season))
.Where(l => l.Gateway == gateWay && l.GameMode == gameMode)
.SelectMany(l => l.Leagues)
.ToDictionary(l => l.Id);
foreach (var rank in ranks)
{
if (leagues.TryGetValue(rank.League, out var league))
{
rank.LeagueName = league.Name;
rank.LeagueDivision = league.Division;
rank.LeagueOrder = league.Order;
}
}
}
public async Task <List <PlayerGameModeStatPerGateway> > LoadPlayerStatsWithRanks(
string battleTag,
GateWay gateWay,
int season)
{
var player = await _playerRepository.LoadGameModeStatPerGateway(battleTag, gateWay, season);
var leaguesOfPlayer = await _rankRepository.LoadPlayerOfLeague(battleTag, season);
var allLeagues = await _rankRepository.LoadLeagueConstellation(season);
foreach (var rank in leaguesOfPlayer)
{
PopulateLeague(player, allLeagues, rank);
}
return(player);
}
public async Task <IActionResult> GetOnGoingMatches(
int offset = 0,
int pageSize = 100,
GameMode gameMode = GameMode.Undefined,
GateWay gateWay = GateWay.Undefined)
{
if (pageSize > 200)
{
pageSize = 200;
}
var matches = await _matchRepository.LoadOnGoingMatches(gameMode, gateWay, offset, pageSize);
var count = await _matchRepository.CountOnGoingMatches(gameMode, gateWay);
PlayersObfuscator.ObfuscatePlayersForFFA(matches.ToArray());
return(Ok(new { matches, count }));
}
public async Task <IActionResult> GetRaceStats(
[FromRoute] string battleTag,
GateWay gateWay,
int season)
{
var wins = await _playerRepository.LoadRaceStatPerGateway(battleTag, gateWay, season);
var ordered = wins.OrderBy(s => s.Race).ToList();
var firstPick = ordered.FirstOrDefault();
if (firstPick?.Race != Race.RnD)
{
return(Ok(ordered));
}
ordered.Remove(firstPick);
ordered.Add(firstPick);
return(Ok(ordered));
}
public async Task <IActionResult> GetMatchesPerPlayer(
string playerId,
int season,
string opponentId = null,
GameMode gameMode = GameMode.Undefined,
GateWay gateWay = GateWay.Undefined,
int offset = 0,
int pageSize = 100)
{
if (pageSize > 100)
{
pageSize = 100;
}
var matches = await _matchRepository.LoadFor(playerId, opponentId, gateWay, gameMode, pageSize, offset, season);
var count = await _matchRepository.CountFor(playerId, opponentId, gateWay, gameMode, season);
return(Ok(new { matches, count }));
}
public async Task <List <PlayerGameModeStatPerGateway> > LoadPlayerStatsWithRanks(
string battleTag,
GateWay gateWay,
int season)
{
var playerGameModeStats = await _playerRepository.LoadGameModeStatPerGateway(battleTag, gateWay, season);
var leaguesOfPlayer = await _rankRepository.LoadPlayerOfLeague(battleTag, season);
var allLeagues = await _rankRepository.LoadLeagueConstellation(season);
foreach (var rank in leaguesOfPlayer)
{
PopulateLeague(playerGameModeStats, allLeagues, rank);
}
PopulateQuantiles(playerGameModeStats, season);
return(playerGameModeStats.OrderByDescending(r => r.RankingPoints).ToList());
}
public ActionResult Logout()
{
try
{
string token = HttpContext.Request.Cookies["token"]["valor"];
Response.Cookies.Remove("token");
GateWay gateway = new GateWay();
gateway.Token = token;
MensajeRetorno <string> returnVal = gateway.PeticionPost <Object, string>(null, "solicitantes/logout");
if (returnVal.State == "FAIL" || returnVal.State == null)
{
ViewBag.Error = returnVal.Message;
}
return(Redirect("Login"));
}
catch
{
return(View("~/Views/Shared/_Error.cshtml"));
}
}
public async Task <IActionResult> GetOnGoingMatches(
int offset = 0,
int pageSize = 100,
GameMode gameMode = GameMode.Undefined,
GateWay gateWay = GateWay.Undefined,
string map = "Overall")
{
if (pageSize > 200)
{
pageSize = 200;
}
var matches = await _matchRepository.LoadOnGoingMatches(gameMode, gateWay, offset, pageSize, map);
var count = await _matchRepository.CountOnGoingMatches(gameMode, gateWay, map);
await _matchQueryHandler.PopulatePlayerInfos(matches);
PlayersObfuscator.ObfuscatePlayersForFFA(matches.ToArray());
return(Ok(new { matches, count }));
}
public async Task <List <Matchup> > LoadFor(
string playerId,
string opponentId = null,
GateWay gateWay = GateWay.Undefined,
GameMode gameMode = GameMode.Undefined,
Race playerRace = Race.Total,
Race opponentRace = Race.Total,
int pageSize = 100,
int offset = 0,
int season = 1)
{
var mongoCollection = CreateCollection <Matchup>();
var textSearchOpts = new TextSearchOptions();
if (string.IsNullOrEmpty(opponentId))
{
return(await mongoCollection
.Find(m => Builders <Matchup> .Filter.Text($"\"{playerId}\"", textSearchOpts).Inject() &&
(gameMode == GameMode.Undefined || m.GameMode == gameMode) &&
(gateWay == GateWay.Undefined || m.GateWay == gateWay) &&
(playerRace == Race.Total || m.Teams.Any(team => team.Players[0].Race == playerRace && playerId == team.Players[0].BattleTag)) &&
(opponentRace == Race.Total || m.Teams.Any(team => team.Players[0].Race == opponentRace && playerId != team.Players[0].BattleTag)) &&
(m.Season == season))
.SortByDescending(s => s.Id)
.Skip(offset)
.Limit(pageSize)
.ToListAsync());
}
return(await mongoCollection
.Find(m =>
Builders <Matchup> .Filter.Text($"\"{playerId}\" \"{opponentId}\"", textSearchOpts).Inject() &&
(gameMode == GameMode.Undefined || m.GameMode == gameMode) &&
(gateWay == GateWay.Undefined || m.GateWay == gateWay) &&
(m.Season == season))
.SortByDescending(s => s.Id)
.Skip(offset)
.Limit(pageSize)
.ToListAsync());
}
public float?GetQuantileForPlayer(List <PlayerId> playerIds, GateWay gateWay, GameMode gameMode, Race?race, int season)
{
if (!MmrRanksCacheBySeason.ContainsKey(season))
{
MmrRanksCacheBySeason[season] = new CachedData <List <MmrRank> >(() => FetchMmrRanks(season).GetAwaiter().GetResult(), TimeSpan.FromMinutes(5));
}
var seasonRanks = MmrRanksCacheBySeason[season].GetCachedData();
var gatewayGameModeRanks = seasonRanks.FirstOrDefault(x => x.Gateway == gateWay && x.GameMode == gameMode);
var rankKey = GetRankKey(playerIds, gameMode, race);
if (gatewayGameModeRanks.Ranks.ContainsKey(rankKey))
{
var foundRank = gatewayGameModeRanks.Ranks[rankKey];
var numberOfPlayersAfter = gatewayGameModeRanks.Ranks.Count - foundRank.Rank;
return(numberOfPlayersAfter / (float)gatewayGameModeRanks.Ranks.Count);
}
return(null);
}
public Rank(
List <string> playerIds,
int league,
int rankNumber,
int rankingPoints,
GateWay gateway,
GameMode gameMode,
int season)
{
Gateway = gateway;
League = league;
RankNumber = rankNumber;
RankingPoints = rankingPoints;
var btags = playerIds.Select(b => $"{b}@{(int) gateway}").OrderBy(t => t);
var createPlayerId = $"{season}_{string.Join("_", btags)}_{gameMode}";
PlayerId = createPlayerId;
GameMode = gameMode;
Season = season;
Player1Id = playerIds.FirstOrDefault();
Player2Id = playerIds.Skip(1).FirstOrDefault();
}
// GET: Solicitudes
public ActionResult Index()
{
try
{
GateWay gateway = new GateWay();
gateway.Token = Request.Cookies["token"]["valor"];
Solicitante usuario = Usuario();
ViewBag.nombreUsuario = usuario.NombreCompleto;
var result = gateway.PeticionGet <IEnumerable <Solicitudes> >(usuario.Id.ToString(), "Solicitudes/collection");
if (result.Data == null && result.State == "SUCCESS")
{
return(View(new List <Solicitudes>()));
}
else if (result.State == "FAIL")
{
return(View("~/Views/Shared/_Error.cshtml"));
}
return(View(result.Data.ToList()));
}
catch {
return(View("~/Views/Shared/_Error.cshtml"));
}
}
public static PlayerOverview Create(
List <PlayerId> playerIds,
GateWay gateWay,
GameMode gameMode,
int season,
Race?race)
{
var id = $"{season}_{string.Join("_", playerIds.OrderBy(t => t.BattleTag).Select(t => $"{t.BattleTag}@{(int)gateWay}"))}_{gameMode}";
if (race != null)
{
id += $"_{race}";
}
return(new PlayerOverview
{
Id = id,
PlayerIds = playerIds,
GateWay = gateWay,
GameMode = gameMode,
Season = season,
Race = race
});
}
public virtual TNestedInterface GetNestedInterface <TNestedInterface>()
where TNestedInterface : NestedInterfaceTest <TChildNestedInterface>, INestedInterfaceTest <TNestedInterface>, new()
{
return(GateWay <TNestedInterface> .GetNestedInterface());
}
private void gatewayButton_Click(object sender, RoutedEventArgs e)
{
Peer mainPeer = startPeer(overlayComboBox.Text, true);
Peer interdomainPeer = startPeer("interdomain.org", true);
GateWay gw = new GateWay((GWMachine)mainPeer.machine, (GWMachine)interdomainPeer.machine);
((GWMachine)mainPeer.machine).GateWay.InterdomainMessageProcessed += mainPeer.gateway_handleinterdomainmessage;
((GWMachine)interdomainPeer.machine).GateWay.InterdomainMessageProcessed += interdomainPeer.gateway_handleinterdomainmessage;
//gw.start();
}
public Task <PlayerRaceStatPerGateway> LoadRaceStatPerGateway(string battleTag, Race race, GateWay gateWay, int season)
{
return(LoadFirst <PlayerRaceStatPerGateway>($"{season}_{battleTag}_@{gateWay}_{race}"));
}
public Task <List <PlayerRaceStatPerGateway> > LoadRaceStatPerGateway(string battleTag, GateWay gateWay, int season)
{
return(LoadAll <PlayerRaceStatPerGateway>(t => t.Id.StartsWith($"{season}_{battleTag}_@{gateWay}")));
}
public async Task <List <Rank> > LoadPlayersOfLeague(int leagueId, int season, GateWay gateWay, GameMode gameMode)
{
var playerRanks = await _rankRepository.LoadPlayersOfLeague(leagueId, season, gateWay, gameMode);
await PopulatePlayerInfos(playerRanks);
return(playerRanks);
}
public async Task <IActionResult> GetCountryLadder([FromRoute] string countryCode, int season, GateWay gateWay = GateWay.Europe, GameMode gameMode = GameMode.GM_1v1)
{
var playersByCountry = await _rankQueryHandler.LoadPlayersOfCountry(countryCode, season, gateWay, gameMode);
if (playersByCountry == null)
{
return(NoContent());
}
return(Ok(playersByCountry));
}
public async Task <IActionResult> GetLadder([FromRoute] int leagueId, int season, GateWay gateWay = GateWay.Europe, GameMode gameMode = GameMode.GM_1v1)
{
var playersInLadder = await _rankQueryHandler.LoadPlayersOfLeague(leagueId, season, gateWay, gameMode);
if (playersInLadder == null)
{
return(NoContent());
}
foreach (var entityInLadder in playersInLadder)
{
foreach (var playerInLadder in entityInLadder.PlayersInfo)
{
playerInLadder.PlayerAkaData = _playerAkaProvider.GetPlayerAkaData(playerInLadder.BattleTag.ToLower());
}
}
return(Ok(playersInLadder));
}
public uint LogonOn(uint nCommand, byte[] aData, out byte[] vData)
{
uint nResult = (uint)REQUESTCODE.EXECUTE_FAIL;
vData = null;
m_dwErrCode = (uint)REQUESTCODE.EXECUTE_SUCCESS;
m_strErrMsg = "";
Logger.Trace("Request CMD=" + nCommand.ToString("x") + ",Length=" + (aData != null?aData.Length.ToString():"0"));
try
{
if (!m_bConnected)
{
if (m_gateWay == null)
{
m_gateWay = new GateWay();
}
if (!string.IsNullOrEmpty(m_Config.m_szServerIP))
{
if (!m_gateWay.Connect(m_Config.m_szServerIP, m_Config.m_nServerPort))
{
m_strErrMsg = "网络连接失败";
return((uint)REQUESTCODE.EXECUTE_FAIL);
}
}
Logger.Trace("UniCOM IsEncode:" + m_gateWay.IsEncode.ToString());
}
byte[] sendData = new byte[12 + aData.Length];
sendData[0] = (byte)m_dwFlag;
sendData[1] = (byte)(m_dwFlag >> 8);
sendData[2] = (byte)(m_dwFlag >> 16);
sendData[3] = (byte)(m_dwFlag >> 24);
sendData[4] = (byte)m_dwSessionID;
sendData[5] = (byte)(m_dwSessionID >> 8);
sendData[6] = (byte)(m_dwSessionID >> 16);
sendData[7] = (byte)(m_dwSessionID >> 24);
sendData[8] = (byte)m_dwStaSN;
sendData[9] = (byte)(m_dwStaSN >> 8);
sendData[10] = (byte)(m_dwStaSN >> 16);
sendData[11] = (byte)(m_dwStaSN >> 24);
Array.Copy(aData, 0, sendData, 12, aData.Length);
if (mutex != null)
{
mutex.WaitOne();
}
lock (m_gateWay)
{
for (int t = 0; t < m_RetryTime; t++)
{
vData = (byte[])(m_gateWay.Logon(nCommand, sendData, out nResult));
if (nResult == (uint)REQUESTCODE.EXECUTE_SUCCESS || vData != null)
{
break;
}
else
{
Logger.Trace("m_gateWay.Logon 失败重试");
if (!m_gateWay.IsConnect)
{
m_gateWay.Connect(m_Config.m_szServerIP, m_Config.m_nServerPort);
}
}
}
}
Logger.Trace("Return CMD=" + nCommand.ToString("x") + ",Return=" + ((REQUESTCODE)nResult).ToString() + ", ResultLength=" + (vData != null?vData.Length.ToString():"0"));
if (nResult == (uint)REQUESTCODE.EXECUTE_SUCCESS)
{
if (mutex != null)
{
mutex.ReleaseMutex();
}
return(nResult);
}
UNICOMMERR_UT vrErr;
UniStructCS.CUniStructCS uccs = new UniStructCS.CUniStructCS();
if (uccs.Import(out vrErr, vData) > 0)
{
Logger.Trace("Error>>");
Logger.Trace(vrErr);
m_dwErrCode = (uint)vrErr.dwErrorCode;
m_strErrMsg = vrErr.szErrorInfo;
if (m_dwErrCode == 0x2002001)
{
SessionID = 0;
}
}
vData = null;
}
catch (System.Runtime.InteropServices.COMException exception)
{
Close();
nResult = (uint)REQUESTCODE.EXECUTE_FAIL;
m_strErrMsg = exception.Message;
Logger.Trace("m_strErrMsg=" + m_strErrMsg);
}
catch (Exception exception)
{
Close();
nResult = (uint)REQUESTCODE.EXECUTE_FAIL;
m_strErrMsg = exception.Message;
Logger.Trace("m_strErrMsg=" + m_strErrMsg);
}
if (mutex != null)
{
mutex.ReleaseMutex();
}
return(nResult);
}
public async Task <IActionResult> GetLadder([FromRoute] int leagueId, int season, GateWay gateWay = GateWay.Europe, GameMode gameMode = GameMode.GM_1v1)
{
var playersInLadder = await _rankQueryHandler.LoadPlayersOfLeague(leagueId, season, gateWay, gameMode);
if (playersInLadder == null)
{
return(NoContent());
}
return(Ok(playersInLadder));
}
public Task <PlayerMmrRpTimeline> LoadPlayerMmrRpTimeline(string battleTag, Race race, GateWay gateWay, int season, GameMode gameMode)
{
return(LoadFirst <PlayerMmrRpTimeline>($"{season}_{battleTag}_@{gateWay}_{race}_{gameMode}"));
}
public async Task <List <Rank> > LoadPlayersOfCountry(string countryCode, int season, GateWay gateWay, GameMode gameMode)
{
var personalSettings = _personalSettingsProvider.getPersonalSettings();
var battleTags = personalSettings.Where(ps => (ps.CountryCode ?? ps.Location) == countryCode).Select(ps => ps.Id);
return(await JoinWith(rank => rank.Gateway == gateWay &&
rank.GameMode == gameMode &&
rank.Season == season &&
(battleTags.Contains(rank.Player1Id) || battleTags.Contains(rank.Player2Id))));
}
public Task <GamesPerDay> LoadGamesPerDay(DateTime date, GameMode gameMode, GateWay gateway)
{
return(LoadFirst <GamesPerDay>($"{gateway.ToString()}_{gameMode.ToString()}_{date:yyyy-MM-dd}"));
}
public Task <List <Rank> > SearchPlayerOfLeague(string searchFor, int season, GateWay gateWay, GameMode gameMode)
{
var search = searchFor.ToLower();
return(JoinWith(rank =>
rank.PlayerId.ToLower().Contains(search) &&
rank.Gateway == gateWay &&
(gameMode == GameMode.Undefined || rank.GameMode == gameMode) &&
rank.Season == season));
}
public IPaymentGateway Create(GateWay GateWayType)
{
return(factoryFactory(GateWayType));
}
