public static string GetResourceUrl(ServerRegion region, ApiResource resource)
{
string apiBaseUrl = GetApiBaseUrl(region);
string resourceUrl = string.Format(apiResource[resource], regionString[region]);
return apiBaseUrl + resourceUrl;
}
public static async Task SetRegionAsync(ServerRegion region)
{
Region = region;
await SaveThemeInSettingsAsync(Region);
}
public GameObject Create(string name, ServerRegion region)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(name));
}
GameObject newButton = GameObject.Instantiate(DetailsPrefab, DetailsPrefab.transform.position, DetailsPrefab.transform.rotation) as GameObject;
newButton.SetActive(true);
//Make it a child
newButton.transform.parent = RootDetailsObject.transform;
//Shift it down so buttons don't overlap
newButton.transform.position = new Vector3(newButton.transform.position.x, newButton.transform.position.y + buttonCount * SpaceInbetweenButtons, newButton.transform.position.z);
GameServerDetailsDispatcher detailsDispatcher = newButton.GetComponent <GameServerDetailsDispatcher>();
if (detailsDispatcher == null)
{
throw new InvalidOperationException($"The {nameof(DetailsPrefab)} should contain a {nameof(GameServerDetailsDispatcher)} component.");
}
detailsDispatcher.Dispatch(name, region);
buttonCount++;
return(newButton);
}
public SimpleGameServerDetailsModel(string name, IPAddress address, int port, ServerRegion region)
{
Name = name;
serverIPBytes = address.GetAddressBytes();
ServerPort = port;
Region = region;
}
public void Dispatch(string name, ServerRegion region)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentException("Value cannot be null or empty.", nameof(name));
}
OnServerDetailsChanged?.Invoke($"{name} - Server Region: {region}");
}
public static string GetCurrentGameUrl(ServerRegion region, int summonerId)
{
var apiBaseUrl = GetApiBaseUrl(region);
var platformId = platformIdString[region];
var resourceUri = string.Format(apiResource[ApiResource.CurrentGame], platformId, summonerId);
return apiBaseUrl + resourceUri;
}
private static async Task <ServerRegion> LoadRegionFromSettingsAsync()
{
ServerRegion cacheRegion = ServerRegion.PCNA;
string regionName = await ApplicationData.Current.LocalSettings.ReadAsync <string>(SettingsKey);
if (!string.IsNullOrEmpty(regionName))
{
Enum.TryParse(regionName, out cacheRegion);
}
return(cacheRegion);
}
/// <summary>
/// SetValues
/// </summary>
/// <param name="serverid"></param>
private void SetInitialValues(Guid serverid)
{
this.miningServer = this.RepositoryFactory.ServerRepository.Find(x => x.ServerID == serverid);
this.miningRegion = this.miningServer.ServerRegion;
this.miningType = this.miningServer.MinerType;
this.txtServerName.Text = this.miningServer.ServerName;
this.txtServerDesc.Text = this.miningServer.ServerDescription;
this.txtServerAddress.Text = this.miningServer.ServerAddress;
this.txtServerPort.Text = this.miningServer.ServerPort.Value.ToString();
this.drpMinnerType.Items.Add(new RadListDataItem(this.miningType.MinerDescription, this.miningType));
this.drpMinnerType.Items.Add(new RadListDataItem(this.miningType.MinerDescription, this.miningType));
}
public static string GetServer(NodeType nodeType, ServerRegion serverRegion)
{
switch (nodeType)
{
case NodeType.SECURE:
return("https://securenodes." + GetServerRegion(serverRegion) + ".zensystem.io");
case NodeType.SUPER:
return("https://supernodes." + GetServerRegion(serverRegion) + ".zensystem.io");
default:
throw new Exception("Node server type not found");
}
}
public static string GetServerRegion(ServerRegion serverRegion)
{
switch (serverRegion)
{
case ServerRegion.EU:
return("eu");
case ServerRegion.NA:
return("na");
case ServerRegion.NONE:
default:
return(string.Empty);
}
}
/// <summary>
/// SetValues
/// </summary>
/// <param name="serverid"></param>
private MiningServer UpdateServer()
{
if (this.miningServer.IsNull())
{
this.miningServer = this.RepositoryFactory.ServerRepository.Find(x => x.ServerID == this.Serverid);
}
this.miningRegion = this.miningServer.ServerRegion;
this.miningType = this.miningServer.MinerType;
this.miningServer.ServerName = this.txtServerName.Text;
this.miningServer.ServerDescription = this.txtServerDesc.Text;
this.miningServer.ServerAddress = this.txtServerAddress.Text;
this.miningServer.ServerPort = int.Parse(this.txtServerPort.Text);
return(this.miningServer);
}
public static string GetServer(NodeType nodeType, ServerRegion serverRegion, int?serverNumber)
{
var region = GetServerRegion(serverRegion);
var number = GetServerNumber(serverRegion, serverNumber);
switch (nodeType)
{
case NodeType.SECURE:
return("https://securenodes" + number + "." + region + ".zensystem.io");
case NodeType.SUPER:
return("https://supernodes" + number + "." + region + ".zensystem.io");
default:
throw new Exception("Node server type not found");
}
}
public static string GetServerNumber(ServerRegion serverRegion, int?serverNumber)
{
if (!serverNumber.HasValue)
{
return(string.Empty);
}
switch (serverRegion)
{
case ServerRegion.EU:
return(serverNumber < 7 && serverNumber > 0? serverNumber.ToString() : string.Empty);
case ServerRegion.NA:
return(serverNumber < 5 && serverNumber > 0 ? serverNumber.ToString() : string.Empty);
default:
return(string.Empty);
}
}
private static string GetQueryJson(NodeType nodetype, ServerRegion serverregion, int?servernumber, string querystring)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
using (var wc = new WebClient())
{
if (serverregion != ServerRegion.NONE && servernumber != null)
{
return(wc.DownloadString(APIServer.GetServer(nodetype, serverregion, servernumber) + querystring));
}
else if (serverregion != ServerRegion.NONE)
{
return(wc.DownloadString(APIServer.GetServer(nodetype, serverregion) + querystring));
}
else
{
return(wc.DownloadString(APIServer.GetServer(nodetype) + querystring));
}
}
}
public static ServerController FindForLobby(Lobby lobby)
{
//Params
ServerRegion region = lobby.region;
if (region != ServerRegion.UNKNOWN)
{
var regionServers = Servers.Find(m => m.Inited && m.InitData.regions.Contains((ServerCommon.ServerRegion)region)).OrderBy(m => m.Instances.Count);
if (!regionServers.Any())
{
lobby.region = ServerRegion.UNKNOWN;
}
else
{
return(regionServers.FirstOrDefault(m => m.Instances.Count < m.InitData.serverCount));
}
}
return(Servers.Find(m => m.Inited && m.Instances.Count < m.InitData.serverCount).OrderBy(m => m.Instances.Count).FirstOrDefault());
}
public static Matchmake CreateMatchmake(User user, Mod[] mods, ServerRegion region = ServerRegion.UNKNOWN)
{
//loop through each mod
foreach (var mod in mods)
{
//if the user does not have a MMR for it
if (user.profile.mmr == null)
{
user.profile.mmr = new Dictionary <string, int>();
}
if (!user.profile.mmr.ContainsKey(mod.name))
{
//Assign base
user.profile.mmr.Add(mod.name, BaseMmr);
}
}
Mongo.Users.Save(user);
var matchmake = new Matchmake()
{
id = Utils.RandomString(17),
Users = new List <User>(TEAM_PLAYERS)
{
user
},
Mods = mods.Select(x => x.name).ToArray(),
Region = region,
Ratings = user.profile.mmr.Where(x => mods.Any(y => x.Key == y.name)).ToDictionary(x => x.Key, x => x.Value),
TryCount = 1
};
log.InfoFormat("User {0} started matchmaking.", user.profile.name);
//add to the queue
lock (inMatchmaking)
{
inMatchmaking.Add(matchmake);
}
return(matchmake);
}
/* API Call: /api/chal/open
* Expected return: {"chalOpenCount":[{"server":"ts1.eu","count":3},{"server":"ts1.na","count":18},{"server":"ts2.eu","count":16},{"server":"ts2.na","count":17},{"server":"ts3.eu","count":1},{"server":"ts3.na","count":9},{"server":"ts4.eu","count":2},{"server":"ts4.na","count":6}]}
*/
public static HorizenNodeAPIDataModels.ServerOpenChallenges GetServerOpenChallenges(NodeType nodetype, int?servernumber, ServerRegion serverregion)
{
return(JsonConvert.DeserializeObject <HorizenNodeAPIDataModels.ServerOpenChallenges>(GetQueryJson(nodetype, serverregion, servernumber, APIPublicCallUrlParts.ServerOpenChallenges)));
}
public Region GetRegion(ServerRegion id)
{
return(this.GetRegion((int)id));
}
public BNetClient(ServerRegion region = ServerRegion.US)
{
_serverUrl = $"{region.ToString().ToLower()}.version.battle.net";
}
public static string GetApiBaseUrl(ServerRegion region)
{
string apiBaseUrl = string.Format(Properties.Resources.api_url, regionString[region]);
return apiBaseUrl;
}
private static async Task SaveThemeInSettingsAsync(ServerRegion region)
{
await ApplicationData.Current.LocalSettings.SaveAsync(SettingsKey, region.ToString());
}
/* API Call: /api/srvlist
* Expected return: {"serverregion":"na","serverregions":[["na","North America"],["eu","Europe"]],"servers":["ts2.na","ts1.na","ts3.na","ts4.na","ts1.eu","ts2.eu","ts3.eu","ts4.eu"]}
*/
public static HorizenNodeAPIDataModels.ServerList GetServerList(NodeType nodetype, int?servernumber, ServerRegion serverregion = ServerRegion.NONE)
{
return(JsonConvert.DeserializeObject <HorizenNodeAPIDataModels.ServerList>(GetQueryJson(nodetype, serverregion, servernumber, APIPublicCallUrlParts.ServerList)));
}
/* Path: /api/nodes/my/earnings?key=<apikey>
* Optional Parameters: &nid=<nodeid> return only for specified node. e.g. &nid=435
* Return: array of nodes with their associated earnings to date along with a record count and summary data that include the total zen earned to date and the current price of Zen in USD. Data is associated with the node email address linked to the API key.
* Expected return: {"records":2,"rows":[{"nid":9,"fqdn":"zen1.secnodes.com","zen":"484.41397152","added":"2017-10-16T19:24:11.000Z"},{"nid":12,"fqdn":"zen102.secnodes.com","zen":"5.22053245","added":"2017-10-16T19:25:06.000Z"}],"summary":{"totalzen":489.63450397,"zenusd":17.18517909073966}}
*/
public static HorizenNodeAPIDataModels.MyEarnings GetMyEarnings(APIKey apikey, int?servernumber, int nodeid = 0, string category = null, ServerRegion serverregion = ServerRegion.NONE)
{
return(JsonConvert.DeserializeObject <HorizenNodeAPIDataModels.MyEarnings>(GetQueryJson(apikey.APINodeType, serverregion, servernumber, APINonPagedCallUrlParts.MyEarnings(apikey, nodeid, category))));
}
/* API Call: /api/node/<node_id>/certstatus
* Expected return: {"valid":true,"msg":"Hostname zzz.f4240.in matches CN zzz.f4240.in","certinfo":{"subject":{"CN":"zzz.f4240.in"},"issuer":{"C":"US","O":"Let's Encrypt","CN":"Let's Encrypt Authority X3"}},"checked":"2018-05-31T21:21:56.987Z","trynext":false}
*/
public static HorizenNodeAPIDataModels.NodeCertStatus GetNodeCertStatus(NodeType nodetype, int nodeid, int?servernumber, ServerRegion serverregion = ServerRegion.NONE)
{
return(JsonConvert.DeserializeObject <HorizenNodeAPIDataModels.NodeCertStatus>(GetQueryJson(nodetype, serverregion, servernumber, APIPublicCallUrlParts.NodeCertStatus(nodeid))));
}
public static async Task InitializeAsync()
{
Region = await LoadRegionFromSettingsAsync();
}
/* Path: /api/nodes/my/downtimes?key=<apikey>&page=<pageservernumber>&rows=<rowcount>
* Optional Parameters: &nid=<nodeid> return only for specified node. e.g. &nid=435, &status=<status> where <status> is 'o' for open or 'c' for closed. e.g. &status=o
* Return: Downtimes for all nodes associated with the API key.
* Expected return: {"page":1,"total":79,"rowsperpage":"10","records":781,"rows":[{"id":120679,"fqdn":"zen1.secnodes.com","home":"ts1-testnet.na","curserver":"ts1-testnet.na","start":"2018-06-12T06:06:20.000Z","check":"2018-06-12T06:19:14.000Z","end":"2018-06-12T06:19:29.000Z","duration":789000,"dtype":"sys","nid":9}]}
*/
public static HorizenNodeAPIDataModels.MyDowntimes GetMyDowntimes(APIKey apikey, int pageservernumber, int rowcount, int?servernumber, int nodeid = 0, string category = null, DowntimeStatus downtimestatus = DowntimeStatus.NONE, ServerRegion serverregion = ServerRegion.NONE)
{
return(JsonConvert.DeserializeObject <HorizenNodeAPIDataModels.MyDowntimes>(GetQueryJson(apikey.APINodeType, serverregion, servernumber, APIPagedCallUrlParts.MyDowntimes(apikey, pageservernumber, rowcount, nodeid, downtimestatus, category))));
}
public async void SwitchRegion(ServerRegion region)
{
BossNotificationService.DisableAllBossNotifications();
await RegionSelectorService.SetRegionAsync(region);
}
