public EpgpModule(
IPriorityReportingService priorityReportingService,
IQueryService queryService,
IEpgpService epgpService,
IAuditService auditService,
IEpgpCalculator epgpCalculator,
IEpgpConfigurationService epgpConfigurationService,
IPageService pageService,
IDocumentationService documentationService,
IEmoteService emoteService,
IAliasService aliasService,
IItemService itemService,
IRaidService raidService,
IAdministrationService administrationService,
BuzzBotDbContext dbContext, IUserService userService, IMapper mapper, IDecayProcessor decayProcessor)
{
_priorityReportingService = priorityReportingService;
_queryService = queryService;
_epgpService = epgpService;
_auditService = auditService;
_epgpCalculator = epgpCalculator;
_epgpConfigurationService = epgpConfigurationService;
_pageService = pageService;
_documentationService = documentationService;
_emoteService = emoteService;
_aliasService = aliasService;
_itemService = itemService;
_raidService = raidService;
_administrationService = administrationService;
_dbContext = dbContext;
_userService = userService;
_mapper = mapper;
_decayProcessor = decayProcessor;
}
private async Task RunDecay()
{
await using (var context = new BuzzBotDbContext(_configuration))
{
var lastDecay = context.EpgpTransactions.AsQueryable().OrderByDescending(t => t.TransactionDateTime)
.FirstOrDefault(t => t.TransactionType == TransactionType.EpDecay);
_lastDecayDateTime = lastDecay?.TransactionDateTime ?? DateTime.MinValue;
}
while (!_cts.IsCancellationRequested)
{
await Task.Delay(TimeSpan.FromHours(6));
var config = _epgpConfigurationService.GetConfiguration();
if (DateTime.Now.DayOfWeek != config.DecayDayOfWeek)
{
continue;
}
if (DateTime.UtcNow - _lastDecayDateTime < TimeSpan.FromHours(24))
{
continue;
}
Decay(config);
_lastDecayDateTime = DateTime.UtcNow;
}
}
public ItemResolver(ItemMapperResolver mapperResolver, BuzzBotDbContext dbContext, IQueryService queryService, IAliasService aliasService)
{
_dbContext = dbContext;
_queryService = queryService;
_aliasService = aliasService;
_itemMappers = mapperResolver();
}
public ItemService(IQueryService queryService, BuzzBotDbContext dbContext, IItemResolver itemResolver, IPageService pageService, IAliasService aliasService)
{
_queryService = queryService;
_dbContext = dbContext;
_itemResolver = itemResolver;
_pageService = pageService;
_aliasService = aliasService;
}
public async Task Characters(IGuildUser user)
{
List <EpgpAlias> aliases;
await using (var dbContext = new BuzzBotDbContext(_configuration))
{
var guildUser = dbContext.GuildUsers.Include(gu => gu.Aliases).FirstOrDefault(usr => usr.Id == user.Id);
if (guildUser == null)
{
await ReplyAsync("No record of that user exists.");
return;
}
aliases = guildUser.Aliases;
if (!aliases.Any())
{
await ReplyAsync("No aliases found for that user.");
return;
}
if (!aliases.Any(a => a.IsActive))
{
var primary = aliases.FirstOrDefault(a => a.IsPrimary);
if (primary != null)
{
primary.IsActive = true;
}
await dbContext.SaveChangesAsync();
}
}
var pageBuilder = new PageFormatBuilder()
.AddColumn("Alias")
.AddColumn("Is Primary?")
.AddColumn("Is Active?")
.AddColumn("EP")
.AddColumn("GP")
.AddColumn("PR");
foreach (var alias in aliases)
{
pageBuilder.AddRow(new[]
{
alias.Name,
alias.IsPrimary ? "Yes" : "No",
alias.IsActive ? "Yes" : "No",
alias.EffortPoints.ToString(),
alias.GearPoints.ToString(),
((double)alias.EffortPoints / alias.GearPoints).ToString("F2")
});
}
await _pageService.SendPages(Context.Channel, pageBuilder.Build());
}
private void PostTransaction(EpgpAlias alias, EpgpTransaction transaction, BuzzBotDbContext dbContext)
{
dbContext.EpgpTransactions.Add(transaction);
var currency = transaction.TransactionType.GetAttributeOfType <CurrencyAttribute>().Currency;
switch (currency)
{
case Currency.Ep:
alias.EffortPoints += transaction.Value;
break;
case Currency.Gp:
alias.GearPoints += transaction.Value;
break;
}
}
public EpgpService(IEpgpConfigurationService configurationService,
IEpgpCalculator epgpCalculator,
IRaidRepository raidRepository,
IAliasEventAlerter aliasEventAlerter,
IAliasService aliasService,
BuzzBotDbContext dbContext,
IEpgpTransactionFactory epgpTransactionFactory)
{
_configurationService = configurationService;
_epgpCalculator = epgpCalculator;
_raidRepository = raidRepository;
_aliasEventAlerter = aliasEventAlerter;
_aliasService = aliasService;
_dbContext = dbContext;
_epgpTransactionFactory = epgpTransactionFactory;
aliasEventAlerter.AliasAdded += AliasAdded;
}
public RaidService(
DiscordSocketClient client,
IRaidMonitorFactory raidMonitorFactory,
IAliasEventAlerter aliasEventAlerter,
IEmoteService emoteService,
IEpgpCalculator epgpCalculator,
IUserService userService,
IAliasService aliasService,
IRaidRepository raidRepository,
IMapper mapper,
BuzzBotDbContext dbContext)
{
_client = client;
_emoteService = emoteService;
_epgpCalculator = epgpCalculator;
_userService = userService;
_aliasService = aliasService;
_raidRepository = raidRepository;
_mapper = mapper;
_dbContext = dbContext;
_raidMonitorFactory = raidMonitorFactory;
_aliasEventAlerter = aliasEventAlerter;
}
protected TierTokenItemMapper(BuzzBotDbContext dbContext)
{
DbContext = dbContext;
}
public UserService(IAliasService aliasService, BuzzBotDbContext dbContext)
{
_aliasService = aliasService;
_dbContext = dbContext;
}
public PriorityReportingService(BuzzBotDbContext dbContext, IPageService pageService)
{
_dbContext = dbContext;
_pageService = pageService;
}
public BankService(BuzzBotDbContext dbContext)
{
_dbContext = dbContext;
}
public AliasService(BuzzBotDbContext dbContext, IAliasEventAlerter eventAlerter)
{
_dbContext = dbContext;
_eventAlerter = eventAlerter;
}
public DataModule(BuzzBotDbContext dbContext, IPageService pageService, IDocumentationService documentationService)
{
_dbContext = dbContext;
_pageService = pageService;
_documentationService = documentationService;
}
private async Task PollItemDataAsync()
{
while (!_cts.IsCancellationRequested)
{
var httpTimeout = CancellationTokenSource.CreateLinkedTokenSource(_cts.Token, new CancellationTokenSource(TimeSpan.FromSeconds(5)).Token);
OverviewResponseViewModel itemData;
try
{
itemData = await _nexusHubClient.GetItemOverview($"{Server}-{Faction}", httpTimeout.Token);
}
catch (TaskCanceledException)
{
await Task.Delay(TimeSpan.FromMinutes(1));
continue;
}
if (itemData != null)
{
await using var context = new BuzzBotDbContext(_configuration);
var server = context.Servers.Include(s => s.Factions).ThenInclude(f => f.ItemData)
.FirstOrDefault(s => s.Id == Server);
if (server == null)
{
server = new Server()
{
Id = Server, Factions = new List <Faction>()
};
context.Servers.Add(server);
await context.SaveChangesAsync(_cts.Token);
}
var faction = server.Factions.FirstOrDefault(f => f.Id == $"{Server}-{Faction}");
if (faction == null)
{
faction = new Faction {
Id = $"{Server}-{Faction}", ServerId = server.Id, ItemData = new List <LiveItemData>()
};
server.Factions.Add(faction);
context.Factions.Add(faction);
await context.SaveChangesAsync(_cts.Token);
}
foreach (var item in itemData.Data)
{
if (context.Items.Find(item.ItemId) == null)
{
continue;
}
var existingItem = faction.ItemData.FirstOrDefault(f => f.ItemId == item.ItemId);
if (existingItem == null)
{
existingItem = new LiveItemData {
FactionId = faction.Id, ItemId = item.ItemId
};
faction.ItemData.Add(existingItem);
context.LiveItemData.Add(existingItem);
}
existingItem.HistoricalValue = item.HistoricalValue ?? 0;
existingItem.MarketValue = item.MarketValue ?? 0;
existingItem.MinimumBuyout = item.MinimumBuyout ?? 0;
existingItem.NumberOfAuctions = item.NumberAuctions ?? 0;
existingItem.Quantity = item.Quantity ?? 0;
}
await context.SaveChangesAsync(_cts.Token);
}
await Task.Delay(TimeSpan.FromHours(1), _cts.Token);
}
}
public RaidFactory(IEpgpConfigurationService configurationService, BuzzBotDbContext buzzBotDbContext)
{
_configurationService = configurationService;
_buzzBotDbContext = buzzBotDbContext;
}
public AhnQirajTempleItemMapper(BuzzBotDbContext dbContext) : base(dbContext)
{
}
public AuditService(IPageService pageService, BuzzBotDbContext dbContext)
{
_pageService = pageService;
_dbContext = dbContext;
}
private List <AliasDecayData> GetAliasData(BuzzBotDbContext dbContext, EpgpConfiguration config)
{
//Get all EPGP characters in system
var aliases = dbContext.Aliases.ToList();
//If bot is not configured to "use earned decay", short circuit the method
if (config.UseEarnedGpDecay != 1)
{
return(aliases.Select(a =>
new AliasDecayData()
{
Alias = a,
GpDecayPercent = config.GpDecayPercentage
}).ToList());
}
//Get all raid data from the previous 7 days
var raids = dbContext.Raids
.Include(r => r.Participants)
.ThenInclude(p => p.Alias)
.ToList();
var previousWeeksRaids = raids.Where(r => (DateTime.UtcNow - r.EndTime) < TimeSpan.FromDays(7))
.ToList();
//If no raid data is found, short circuit the method
if (!previousWeeksRaids.Any())
{
return(aliases.Select(a =>
new AliasDecayData()
{
Alias = a,
GpDecayPercent = config.GpDecayPercentage
}).ToList());
}
//Aggregate all unique participants from the week's raids
var participants =
previousWeeksRaids
.SelectMany(r => r.Participants)
.Select(p => p.Alias.UserId)
.Distinct()
.ToList();
//If no participants are found, short circuit the method
if (!participants.Any())
{
return(aliases.Select(a =>
new AliasDecayData()
{
Alias = a,
GpDecayPercent = config.GpDecayPercentage
}).ToList());
}
var returnList = new List <AliasDecayData>();
//Iterate all aliases
foreach (var alias in aliases)
{
var returnVal = new AliasDecayData
{
Alias = alias,
GpDecayPercent = config.GpDecayPercentage - config.EarnedGpDecayValue
};
//If an alias is non-primary (alt) or did not participate in a raid, award minimum GP decay
if (!alias.IsPrimary || !participants.Contains(alias.UserId))
{
returnList.Add(returnVal);
continue;
}
//Otherwise, award maximum GP decay
returnVal.GpDecayPercent += config.EarnedGpDecayValue;
returnList.Add(returnVal);
}
return(returnList);
}
