public async Task <Nation> GetRecruitableNationAsync(EventId id, bool isAPI)
{
bool found = false;
Nation result = null;
do
{
var nation = await NationManager.GetNationByStatusNameAsync("pending");
if (nation != null)
{
found = await IsNationRecruitableAsync(nation, id);
if (found)
{
result = nation;
}
else
{
if (IsReceivingRecruitableNations && !isAPI)
{
currentRNStatus.SkippedCount++;
}
}
}
else
{
_logger.LogCritical(id, "Picked nation was null !");
break;
}
} while (!found);
return(result);
}
private async Task <bool> IsNationRecruitableAsync(Nation nation, EventId id)
{
if (nation != null)
{
var criteriaFit = await DoesNationFitCriteriaAsync(nation.Name);
if (criteriaFit)
{
var apiResponse = await WouldReceiveTelegramAsync(nation, id);
if (apiResponse == 0)
{
_logger.LogDebug(id, LogMessageBuilder.Build(id, $"{nation.Name} - No receive."));
}
else if (apiResponse == 1)
{
return(true);
}
else
{
_logger.LogWarning(id, LogMessageBuilder.Build(id, $"Recruitable nation check: {nation.Name} failed."));
await NationManager.SetNationStatusToAsync(nation, "failed");
return(false);
}
}
else
{
_logger.LogDebug(id, LogMessageBuilder.Build(id, $"{nation.Name} does not fit criteria and is therefore skipped."));
}
}
await NationManager.SetNationStatusToAsync(nation, "skipped");
return(false);
}
public async IAsyncEnumerable <Nation> GetRecruitableNationsAsync(int number, bool isAPI, EventId id)
{
_logger.LogInformation(id, LogMessageBuilder.Build(id, $"{number} recruitable nations requested"));
var pendingCount = NationManager.GetNationCountByStatusName("pending");
_logger.LogInformation(id, LogMessageBuilder.Build(id, $"Pending: {pendingCount}"));
if (number > pendingCount)
{
number = pendingCount;
}
for (int i = 0; i < number; i++)
{
if (currentRNStatus != null && currentRNStatus.CurrentCount > currentRNStatus.FinalCount)
{
break;
}
if (IsReceivingRecruitableNations && !isAPI)
{
currentRNStatus.CurrentCount++;
}
var nation = await GetRecruitableNationAsync(id, isAPI);
if (nation == null)
{
break;
}
yield return(nation);
}
}
public async Task UpdateRecruitmentStatsAsync()
{
try
{
_logger.LogInformation(_defaulEventId, LogMessageBuilder.Build(_defaulEventId, "Updating Recruitment Stats"));
var today = DateTime.Today.Date;
var sent = NationManager.GetNationsByStatusName("send").Select(n => n.Name).ToList();
var manual = NationManager.GetNationsByStatusName("reserved_manual").Select(n => n.Name).ToList();
var region = await _dumpDataService.GetRegionAsync(BaseApiService.ToID(_config.NationStatesRegionName));
var apiRecruited = region.NATIONS.Where(n => sent.Any(s => n.NAME == s)).Select(n => n.NAME).ToList();
var manualRecruited = region.NATIONS.Where(n => manual.Any(m => n.NAME == m)).Select(n => n.NAME).ToList();
RStatDbUpdate();
ApiRecruited = apiRecruited.Count;
ApiRatio = Math.Round((100 * ApiRecruited / (sent.Count + ApiFailed + 0.0)), 2);
ManualReserved = manual.Count;
ManualRecruited = manualRecruited.Count;
ManualRatio = Math.Round((100 * ManualRecruited / (manual.Count + 0.0)), 2);
_logger.LogInformation(_defaulEventId, LogMessageBuilder.Build(_defaulEventId, "Recruitment Stats Updated"));
}
catch (Exception ex)
{
_logger.LogCritical(_defaulEventId, ex, LogMessageBuilder.Build(_defaulEventId, "A critical error occured."));
}
}
private void RStatDbUpdate()
{
ApiSent = NationManager.GetNationsByStatusName("send").Count;
ApiPending = NationManager.GetNationsByStatusName("pending").Count;
ApiSkipped = NationManager.GetNationsByStatusName("skipped").Count;
ApiFailed = NationManager.GetNationsByStatusName("failed").Count;
}
public CustomerController()
{
_customerMan = new CustomerManager();
_nationMan = new NationManager();
_stateMan = new StateManager();
}
public VendorController()
{
_vendorMan = new VendorManager();
_nationMan = new NationManager();
_stateMan = new StateManager();
}
public void UpdateMyPlayer(int viewID)
{
photonView.RPC("SendPlayerRPC", PhotonTargets.All,
LocalPlayer.pp,
viewID,
NationManager.myNation,
TanksData.FindTankData(NationManager.ReturnStartTank(NationManager.myNation)).maxHp,
NationManager.ReturnStartTank(NationManager.myNation),
true); //Player gracza wysyłamy jeśli target ma go na liście graczy
}
private async Task EnsurePoolFilledAsync()
{
var id = LogEventIdProvider.GetEventIdByType(LoggingEvent.EnsurePoolFilled);
List <REGION> regionsToRecruitFrom = await GetRegionToRecruitFromAsync(id);
while (IsRecruiting)
{
bool fillingUp = false;
int counter = 0;
int pendingCount = NationManager.GetNationCountByStatusName("pending");
while (pendingCount < _config.MinimumRecruitmentPoolSize)
{
if (!fillingUp)
{
fillingUp = true;
_logger.LogInformation(id, LogMessageBuilder.Build(id, $"Filling up pending pool now from {pendingCount} to {_config.MinimumRecruitmentPoolSize}"));
}
PoolStatus = "Filling up with random nations";
var regionId = _rnd.Next(regionsToRecruitFrom.Count);
var region = regionsToRecruitFrom.ElementAt(regionId);
string nationName;
do
{
var nationId = _rnd.Next(region.NATIONNAMES.Count);
nationName = region.NATIONNAMES.ElementAt(nationId);
}while (await NationManager.IsNationPendingSkippedSendOrFailedAsync(nationName) || await IsNationRecruitableAsync(new Nation()
{
Name = nationName, StatusTime = DateTime.UtcNow
}, id));
var nation = await NationManager.GetNationAsync(nationName);
if (nation != null)
{
await NationManager.SetNationStatusToAsync(nation, "pending");
}
else
{
await NationManager.AddUnknownNationsAsPendingAsync(new List <string>() { nationName }, true);
}
counter++;
pendingCount = NationManager.GetNationCountByStatusName("pending");
_logger.LogDebug(id, LogMessageBuilder.Build(id, $"Added nation '{nationName}' to pending. Now at {pendingCount} from minimum {_config.MinimumRecruitmentPoolSize}."));
}
if (fillingUp)
{
_logger.LogInformation(id, LogMessageBuilder.Build(id, $"Filled up pending pool to minimum. (Added {counter} nations to pending.)"));
PoolStatus = "Waiting for new nations";
}
await Task.Delay(1800000); //30 min
}
}
public async Task <List <Nation> > GetRecruitableNationsAsync(int number, bool isAPI)
{
List <Nation> returnNations = new List <Nation>();
var id = LogEventIdProvider.GetEventIdByType(LoggingEvent.GetRecruitableNations);
try
{
_logger.LogDebug(id, LogMessageBuilder.Build(id, $"{number} recruitable nations requested"));
List <Nation> pendingNations = new List <Nation>();
if (pendingNations.Count == 0)
{
pendingNations = NationManager.GetNationsByStatusName("pending");
}
while (returnNations.Count < number)
{
var picked = pendingNations.Take(1);
var nation = picked.Count() > 0 ? picked.ToArray()[0] : null;
if (nation != null)
{
if (await IsNationRecruitableAsync(nation, id))
{
returnNations.Add(nation);
if (IsReceivingRecruitableNations && !isAPI)
{
currentRNStatus.CurrentCount++;
}
}
pendingNations.Remove(nation);
returnNations = returnNations.Distinct().ToList();
}
else
{
if (pendingNations.Count == 0)
{
_logger.LogCritical(id, "No more nations in pending pool !");
return(returnNations);
}
else
{
_logger.LogCritical(id, "Picked nation was null !");
}
}
}
}
catch (Exception ex)
{
_logger.LogError(id, ex, LogMessageBuilder.Build(id, "An error occured."));
}
return(returnNations);
}
private async Task <bool> IsNationRecruitableAsync(Nation nation, EventId id)
{
if (nation != null)
{
var result = await IsNationRecruitableAsync(nation.Name, id);
if (!result)
{
await NationManager.SetNationStatusToAsync(nation, "skipped");
}
return(result);
}
return(false);
}
private async Task AddNationToPendingAsync(EventId id, List <string> nationNames, bool isSourceDumps)
{
List <string> nationsToAdd = new List <string>();
foreach (var res in nationNames)
{
if (await DoesNationFitCriteriaAsync(res))
{
nationsToAdd.Add(res);
}
}
var counter = await NationManager.AddUnknownNationsAsPendingAsync(nationsToAdd, isSourceDumps);
if (counter > 0)
{
_logger.LogInformation(id, LogMessageBuilder.Build(id, $"{counter} nations added to pending"));
}
}
public JsonResult Get_Nations_By_Customer_Id(int customer_Id)
{
List <NationInfo> Nations = new List <NationInfo>();
NationManager nMan = new NationManager();
PaginationInfo pager = new PaginationInfo();
pager.IsPagingRequired = false;
try
{
Nations = nMan.Get_Nations_By_Customer_Id(customer_Id, ref pager);
}
catch (Exception ex)
{
Logger.Error("Enquiry Controller - Get_Nations_By_Customer_Id " + ex.ToString());
}
return(Json(Nations, JsonRequestBehavior.AllowGet));
}
public async Task RunAsync()
{
_logger.LogInformation($"--- DiscordBotService started ---");
NationManager.Initialize(_config);
UserManager.Initialize(_config);
DiscordClient = new DiscordSocketClient();
commandService = new CommandService(new CommandServiceConfig
{
SeparatorChar = _config.SeperatorChar,
DefaultRunMode = RunMode.Async,
CaseSensitiveCommands = false
});
SetUpDiscordEvents();
await commandService.AddModulesAsync(Assembly.GetEntryAssembly(), Program.ServiceProvider);
await DiscordClient.LoginAsync(TokenType.Bot, _config.DiscordBotLoginToken);
await DiscordClient.StartAsync();
IsRunning = true;
}
public UserController(
IUserService user,
IAdressesService adressesService,
IPostalcodeService postalcodeService,
ITeamService teamService,
INationService nationService,
IPlayerSkillService playskillService,
IPlayerService playerService,
IStadiumService stadiumService,
ICoachService coachService,
ICoachSkillService coachSkillService)
{
_usermanager = (UserManager)user;
_adressmanager = (AdressManager)adressesService;
_postalcodeManager = (PostalcodeManager)postalcodeService;
_teamManager = (TeamManager)teamService;
_nationManager = (NationManager)nationService;
_playerskillManager = (PlayerSkillManager)playskillService;
_playerManager = (PlayerManager)playerService;
_stadiumManager = (StadiumManager)stadiumService;
_coachManager = (CoachManager)coachService;
_coachSkillManager = (CoachSkillManager)coachSkillService;
}
/// <summary>
/// Saving new Team to database
/// </summary>
/// <param name="user"></param>
/// <param name="teamManager"></param>
/// <param name="stadiumManager"></param>
/// <param name="playerManager"></param>
/// <param name="playerSkillManager"></param>
/// <param name="nationManager"></param>
/// <param name="coachManager"></param>
/// <param name="coachSkillManager"></param>
/// <returns></returns>
public static Team CreateFinishedTeam(
User user,
TeamManager teamManager,
StadiumManager stadiumManager,
PlayerManager playerManager,
PlayerSkillManager playerSkillManager,
NationManager nationManager
// CoachManager coachManager,
//CoachSkillManager coachSkillManager
)
{
Team team = CreateTeam(user);
// coachSkillManager.Add(team.Coach.CoachSkill);
//coachSkillManager.Save();
// coachManager.Add(team.Coach);
//coachManager.Save();
stadiumManager.Add(team.Stadium);
stadiumManager.Save();
teamManager.Add(team);
teamManager.Save();
team.Players = PlayerMethod.CreatePlayers().ToList();
foreach (Player player in team.Players)
{
nationManager.Add(player.Nation);
nationManager.Save();
playerSkillManager.Add(player.PlayerSkill);
playerSkillManager.Save();
playerManager.Add(player);
playerManager.Save();
}
teamManager.Save();
return(team);
}
public NationController(INationService nation)
{
_nationManager = (NationManager)nation;
}
private async Task RecruitAsync()
{
List <Nation> pendingNations = new List <Nation>();
while (IsRecruiting && _config.EnableRecruitment)
{
try
{
if (pendingNations.Count == 0)
{
if (NationManager.GetNationCountByStatusName("pending") == 0)
{
_logger.LogWarning("Delaying API recruitment for 15 minutes due to lack of recruitable nations");
RecruitmentStatus = "Throttled: lack of nations";
await Task.Delay(900000);
}
pendingNations = NationManager.GetNationsByStatusName("reserved_api");
if (pendingNations.Count < 10)
{
var numberToRequest = 10 - pendingNations.Count;
await foreach (var resNation in GetRecruitableNationsAsync(numberToRequest, true, _defaulEventId))
{
pendingNations.Add(resNation);
}
if (pendingNations.Count < numberToRequest)
{
RecruitmentStatus = "Throttled: lack of of nations";
_logger.LogWarning("Didn't received enough recruitable nations");
}
else
{
RecruitmentStatus = "Fully operational";
}
foreach (var pendingNation in pendingNations)
{
await NationManager.SetNationStatusToAsync(pendingNation, "reserved_api");
}
}
}
var picked = pendingNations.Take(1);
var nation = picked.Count() > 0 ? picked.ToArray()[0] : null;
if (nation != null)
{
if (await _apiService.IsNationStatesApiActionReadyAsync(NationStatesApiRequestType.SendRecruitmentTelegram, true))
{
if (await IsNationRecruitableAsync(nation, _defaulEventId))
{
if (await _apiService.SendRecruitmentTelegramAsync(nation.Name))
{
await NationManager.SetNationStatusToAsync(nation, "send");
_logger.LogInformation(_defaulEventId, LogMessageBuilder.Build(_defaulEventId, $"Telegram to {nation.Name} queued successfully."));
}
else
{
_logger.LogWarning(_defaulEventId, LogMessageBuilder.Build(_defaulEventId, $"Sending of a Telegram to {nation.Name} failed."));
await NationManager.SetNationStatusToAsync(nation, "failed");
}
}
pendingNations.Remove(nation);
}
}
else
{
_logger.LogCritical(_defaulEventId, LogMessageBuilder.Build(_defaulEventId, "No nation to recruit found."));
}
}
catch (Exception ex)
{
_logger.LogError(_defaulEventId, ex, LogMessageBuilder.Build(_defaulEventId, "An error occured."));
}
await Task.Delay(60000);
}
if (!_config.EnableRecruitment)
{
_logger.LogWarning(_defaulEventId, "Recruitment disabled.");
}
}
private async void UpdateRecruitmentStatsAsync()
{
while (IsRecruiting)
{
try
{
_logger.LogInformation(defaulEventId, LogMessageBuilder.Build(defaulEventId, "Updating Recruitment Stats"));
var today = DateTime.Today.Date;
var sent = NationManager.GetNationsByStatusName("send").Select(n => n.Name).ToList();
var manual = NationManager.GetNationsByStatusName("reserved_manual").Select(n => n.Name).ToList();
var region = await _dumpDataService.GetRegionAsync(BaseApiService.ToID(_config.NationStatesRegionName));
var apiRecruited = region.NATIONS.Where(n => sent.Any(s => n.NAME == s)).Select(n => n.NAME).ToList();
var manualRecruited = region.NATIONS.Where(n => manual.Any(m => n.NAME == m)).Select(n => n.NAME).ToList();
RStatDbUpdate();
ApiRecruited = apiRecruited.Count;
ApiRatio = Math.Round((100 * ApiRecruited / (sent.Count + ApiFailed + 0.0)), 2);
ManualReserved = manual.Count;
ManualRecruited = manualRecruited.Count;
ManualRatio = Math.Round((100 * ManualRecruited / (manual.Count + 0.0)), 2);
await WriteRecruited(today, apiRecruited, manualRecruited.AsQueryable());
var rt = await GetRecruitedOn(today);
RecruitedTodayA = rt[0];
RecruitedTodayM = rt[1];
var ry = await GetRecruitedOn(today.AddDays(-1));
RecruitedYesterdayA = ry[0];
RecruitedYesterdayM = ry[1];
var lastMonday = (today - new TimeSpan((int)today.DayOfWeek, 0, 0, 0)).AddDays(1);
var rlw = await GetRecruitedBetween(lastMonday - TimeSpan.FromDays(7), lastMonday);
RecruitedLastWeekA = rlw[0];
RecruitedLastWeekM = rlw[1];
RecruitedLastWeekAvgDA = Math.Round(RecruitedLastWeekA / 7.0, 2);
RecruitedLastWeekAvgDM = Math.Round(RecruitedLastWeekM / 7.0, 2);
var firstDayLastMonth = new DateTime(today.Year, today.Month, 1).AddMonths(-1);
var daysInLastMonth = DateTime.DaysInMonth(firstDayLastMonth.Year, firstDayLastMonth.Month);
var rlm = await GetRecruitedBetween(firstDayLastMonth, firstDayLastMonth.AddMonths(1).AddDays(-1));
RecruitedLastMonthA = rlm[0];
RecruitedLastMonthM = rlm[1];
RecruitedLastMonthAvgDA = Math.Round(RecruitedLastMonthA / (daysInLastMonth + 0.0), 2);
RecruitedLastMonthAvgDM = Math.Round(RecruitedLastMonthM / (daysInLastMonth + 0.0), 2);
_logger.LogInformation(defaulEventId, LogMessageBuilder.Build(defaulEventId, "Recruitment Stats Updated"));
}
catch (Exception ex)
{
_logger.LogCritical(defaulEventId, ex, LogMessageBuilder.Build(defaulEventId, "A critical error occured."));
}
await Task.Delay(TimeSpan.FromHours(4));
}
}
public async Task DoGetRecruitableNationsAsync([Remainder, Summary("Number of nations to be returned")] int number)
{
//await ReplyAsync("The /rn command needed to be disabled because of major issues with the manual recruitment system. Drehtisch will fix those issue asap. Sorry :(");
Console.ResetColor();
var id = LogEventIdProvider.GetEventIdByType(LoggingEvent.RNCommand);
List <Nation> returnNations = new List <Nation>();
try
{
if (await _permManager.IsAllowedAsync(PermissionType.ManageRecruitment, Context.User))
{
if (!_recruitmentService.IsReceivingRecruitableNations)
{
try
{
if (number <= 120)
{
var currentRN = new RNStatus
{
IssuedBy = Context.User.Username,
FinalCount = number,
StartedAt = DateTimeOffset.UtcNow,
AvgTimePerFoundNation = TimeSpan.FromSeconds(2)
};
var channel = await Context.User.GetOrCreateDMChannelAsync();
_recruitmentService.StartReceiveRecruitableNations(currentRN);
await ReplyAsync($"{_actionQueued}{Environment.NewLine}{Environment.NewLine}You can request the status of this command using /rns. Finish expected in approx. (mm:ss): {currentRN.ExpectedIn():mm\\:ss}");
StringBuilder builder = new StringBuilder();
var counter = 0;
await foreach (var nation in _recruitmentService.GetRecruitableNationsAsync(number, false, id))
{
counter++;
builder.Append($"{nation.Name}, ");
if (counter % 8 == 0)
{
await channel.SendMessageAsync(builder.ToString());
builder.Clear();
_logger.LogInformation(id, LogMessageBuilder.Build(id, $"Dispatched {counter}/{number} nations to {Context.User.Username}"));
}
await NationManager.SetNationStatusToAsync(nation, "reserved_manual");
}
if (builder.Length > 0)
{
await channel.SendMessageAsync(builder.ToString());
_logger.LogInformation(id, LogMessageBuilder.Build(id, $"Dispatched {counter}/{number} nations to {Context.User.Username}"));
}
if (counter < number)
{
await ReplyAsync($"Something went wrong didn't received as much nations as requested.");
}
}
else
{
await ReplyAsync($"{number} exceeds the maximum of 120 Nations (15 Telegrams a 8 recipients) to be returned.");
}
}
finally
{
_recruitmentService.StopReceiveRecruitableNations();
}
}
else
{
await ReplyAsync($"There is already a /rn command running. Try again later.");
}
}
else
{
await ReplyAsync(AppSettings._permissionDeniedResponse);
}
}
catch (Exception ex)
{
_logger.LogCritical(id, ex, LogMessageBuilder.Build(id, "A critical error occured"));
await ReplyAsync($"Something went wrong. Sorry :( ");
}
}
public async Task DoGetRecruitableNations([Remainder, Summary("Number of nations to be returned")] int number)
{
var id = LogEventIdProvider.GetEventIdByType(LoggingEvent.RNCommand);
List <Nation> returnNations = new List <Nation>();
try
{
if (await _permManager.IsAllowedAsync(PermissionType.ManageRecruitment, Context.User))
{
if (!_recruitmentService.IsReceivingRecruitableNations)
{
if (number <= 120)
{
var currentRN = new RNStatus
{
IssuedBy = Context.User.Username,
FinalCount = number,
StartedAt = DateTimeOffset.UtcNow,
AvgTimePerFoundNation = TimeSpan.FromSeconds(2)
};
_recruitmentService.StartReceiveRecruitableNations(currentRN);
await ReplyAsync($"{actionQueued}{Environment.NewLine}{Environment.NewLine}You can request the status of this command using /rns. Finish expected in approx. (mm:ss): {currentRN.ExpectedIn().ToString(@"mm\:ss")}");
_logger.LogInformation(id, LogMessageBuilder.Build(id, $"{number} recruitable nations requested."));
returnNations = await _recruitmentService.GetRecruitableNationsAsync(number, false);
foreach (var nation in returnNations)
{
await NationManager.SetNationStatusToAsync(nation, "reserved_manual");
}
StringBuilder builder = new StringBuilder();
builder.AppendLine("-----");
var firstReplyStart = $"<@{Context.User.Id}> Your action just finished.{Environment.NewLine}Changed status of {returnNations.Count} nations from 'pending' to 'reserved_manual'.{Environment.NewLine}Recruitable Nations are (each segment for 1 telegram):{Environment.NewLine}";
int replyCount = (number / 40) + (number % 40 != 0 ? 1 : 0);
int currentReply = 1;
for (int i = 1; i <= returnNations.Count; i++)
{
var nation = returnNations[i - 1];
if (i % 8 == 0)
{
builder.AppendLine($"{nation.Name}");
builder.AppendLine("-----");
}
else
{
builder.Append($"{nation.Name}, ");
}
if (i % 40 == 0)
{
if (i / 40 == 1)
{
await ReplyAsync($"{firstReplyStart} Reply {currentReply}/{replyCount}{Environment.NewLine}{builder.ToString()}");
}
else
{
await ReplyAsync($"Reply {currentReply}/{replyCount}{Environment.NewLine}{builder.ToString()}");
}
builder.Clear();
currentReply++;
}
}
if (returnNations.Count < 40)
{
await ReplyAsync($"{firstReplyStart}{builder.ToString()}");
}
else
{
if (number % 40 != 0)
{
await ReplyAsync($"Reply {currentReply}/{replyCount}{Environment.NewLine}{builder.ToString()}");
}
}
if (returnNations.Count < number)
{
await ReplyAsync($"{Environment.NewLine}- - - - -{Environment.NewLine}WARNING: No more nations in pending nations pool.");
}
}
else
{
await ReplyAsync($"{number} exceeds the maximum of 120 Nations (15 Telegrams a 8 recipients) to be returned.");
}
}
else
{
await ReplyAsync($"There is already a /rn command running. Try again later.");
}
}
else
{
await ReplyAsync(AppSettings.PERMISSION_DENIED_RESPONSE);
}
}
catch (Exception ex)
{
_logger.LogCritical(id, ex, LogMessageBuilder.Build(id, "An critical error occured"));
await ReplyAsync($"Something went wrong :( ");
foreach (var nation in returnNations)
{
await NationManager.SetNationStatusToAsync(nation, "pending");
}
}
finally
{
_recruitmentService.StopReceiveRecruitableNations();
}
}
