private string GetAliasString(EpgpAlias alias)
{
var emoteName = alias.Class.GetEmoteName();
var fullyQualifiedName = _emoteService.GetFullyQualifiedName(Context.Guild.Id, emoteName);
return($"{fullyQualifiedName} {alias.Name}");
}
public string GetAliasString(EpgpAlias alias, ulong serverId)
{
var emoteName = alias.Class.GetEmoteName();
var fullyQualifiedName = GetFullyQualifiedName(serverId, emoteName);
return($"{fullyQualifiedName} {alias.Name}");
}
public EpgpTransaction GetTransaction(EpgpAlias alias, int value, string memo, TransactionType transactionType)
{
var config = _configurationService.GetConfiguration();
var currencyType = transactionType.GetAttributeOfType <CurrencyAttribute>().Currency;
int change;
switch (currencyType)
{
case Currency.Ep:
change = alias.EffortPoints + value < config.EpMinimum ? config.EpMinimum - alias.EffortPoints : value;
break;
case Currency.Gp:
change = alias.GearPoints + value < config.GpMinimum ? config.GpMinimum - alias.GearPoints : value;
break;
default:
throw new ArgumentOutOfRangeException();
}
return(new EpgpTransaction
{
Id = Guid.NewGuid(),
AliasId = alias.Id,
Memo = memo,
TransactionDateTime = DateTime.UtcNow,
TransactionType = transactionType,
Value = change
});
}
public void Gp(EpgpAlias alias, Item item, string memo, int overrideGpValue = -1)
{
var gpValue = overrideGpValue == -1 ? _epgpCalculator.CalculateItem(item, alias.Class == Class.Hunter, false) : overrideGpValue;
var rounded = (int)Math.Round(gpValue, MidpointRounding.AwayFromZero);
var raid = _raidRepository.GetRaid();
if (raid == null)
{
Gp(alias, rounded, memo, TransactionType.GpFromGear);
return;
}
var transaction = _epgpTransactionFactory.GetTransaction(alias, (int)Math.Round(gpValue, MidpointRounding.AwayFromZero), memo, TransactionType.GpFromGear);
_dbContext.EpgpTransactions.Add(transaction);
alias.Transactions.Add(transaction);
alias.GearPoints += transaction.Value;
var raidData = _dbContext.Raids.Include(r => r.Loot).First(r => r.Id == raid.RaidObject.RaidId);
var raidItem = new RaidItem
{
Id = Guid.NewGuid(),
AwardedAliasId = alias.Id,
ItemId = item.Id,
RaidId = raidData.Id,
TransactionId = transaction.Id
};
_dbContext.RaidItems.Add(raidItem);
_dbContext.SaveChanges();
}
public async Task AddAlias(IGuildUser user, string aliasName, string className, int ep = 0, int gp = 0)
{
var config = _epgpConfigurationService.GetConfiguration();
if (ep < config.EpMinimum)
{
ep = config.EpMinimum;
}
if (gp < config.GpMinimum)
{
gp = config.GpMinimum;
}
if (!className.TryParseClass(out var userClass))
{
await ReplyAsync("Unable to parse class from provided class argument");
return;
}
var alias = new EpgpAlias
{
UserId = user.Id,
Class = userClass.ToDomainClass(),
EffortPoints = 0,
GearPoints = 0,
IsPrimary = false,
Name = aliasName,
Id = Guid.NewGuid()
};
_aliasService.AddAlias(alias);
_epgpService.Set(aliasName, ep, gp, "Alias initialized");
await ReplyAsync($"New alias add to {user.GetAliasName()}: \"{aliasName} : {userClass}\"");
}
private void AliasAdded(object?sender, EpgpAlias e)
{
var config = _configurationService.GetConfiguration();
var ep = config.EpMinimum;
var gp = config.GpMinimum;
Set(e.Name, ep, gp, "User initialization");
}
private async Task GiveItemGearPoints(EpgpAlias alias, Item item, bool isOffhand)
{
var gp = _epgpCalculator.CalculateItem(item, alias.Class == Class.Hunter, isOffhand);
var embed = CreateItemEmbed(item, gp);
var userString = alias.IsPrimary ? $"<@{alias.UserId}>" : _emoteService.GetAliasString(alias, Context.Guild.Id);
await ReplyAsync($"Assigning to {userString}", false, embed);
_epgpService.Gp(alias, item, $"[Claim] {item.Name}");
}
public async Task PrintLootHistory(IMessageChannel channel, EpgpAlias alias, bool asAdmin)
{
alias = _dbContext.Aliases
.Include(a => a.AwardedItems)
.ThenInclude(ri => ri.Transaction)
.Include(a => a.AwardedItems)
.ThenInclude(ri => ri.Item)
.Include(a => a.AwardedItems)
.ThenInclude(ri => ri.Raid)
.FirstOrDefault(a => a.Id == alias.Id);
if (alias == null)
{
await channel.SendMessageAsync("Unable to locate record of that user in the database.");
return;
}
if (!alias.AwardedItems.Any())
{
await channel.SendMessageAsync("There are no records of items being awarded to that user.");
return;
}
var pageBuilder = new PageFormatBuilder()
.AlternateRowColors()
.AddColumn("Item Name:")
.AddColumn("Raid")
.AddColumn("Time (UTC)")
.AddColumn("GP");
if (asAdmin)
{
pageBuilder.AddHiddenColumn("Transaction ID");
}
foreach (var raidItem in alias.AwardedItems.OrderByDescending(ai => ai.Transaction.TransactionDateTime))
{
var row = new List <string>()
{
raidItem.Item.Name,
raidItem.Raid.Name,
raidItem.Transaction.TransactionDateTime.ToString("g"),
raidItem.Transaction.Value.ToString()
};
if (asAdmin)
{
row.Add(raidItem.TransactionId.ToString("N"));
}
pageBuilder.AddRow(row.ToArray());
}
await _pageService.SendPages(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 async Task <Item> TryGetItem(string queryString, ICommandContext commandContext,
EpgpAlias targetAlias = null)
{
if (targetAlias == null)
{
var userId = commandContext.User.Id;
var aliases = _aliasService.GetActiveAliases(userId);
targetAlias = aliases.FirstOrDefault();
}
var item = await GetQueriedItem(queryString, commandContext);
if (item == null)
{
return(null);
}
return(await _itemResolver.ResolveItem(item, commandContext, targetAlias));
}
public async Task AddUser(IGuildUser user, int ep = 0, int gp = 0)
{
var config = _epgpConfigurationService.GetConfiguration();
if (ep < config.EpMinimum)
{
ep = config.EpMinimum;
}
if (gp < config.GpMinimum)
{
gp = config.GpMinimum;
}
var id = user.Id;
await _userService.TryAddUser(id, Context.Guild);
var userClass = user.GetClass();
if (userClass == WowClass.Unknown)
{
await ReplyAsync("Unable to infer class for specified user. No primary alias will be created");
return;
}
var alias = new EpgpAlias
{
UserId = id,
Class = userClass.ToDomainClass(),
EffortPoints = ep,
GearPoints = gp,
IsPrimary = true,
Name = user.GetAliasName(),
Id = Guid.NewGuid()
};
_aliasService.AddAlias(alias);
await ReplyAsync($"New user added with primary alias of \"{user.GetAliasName()} : {userClass}\"");
}
public virtual IEnumerable <Item> GetItems(Item item, ICommandContext commandContext, EpgpAlias targetAlias)
{
var candidateItems = MappedItemDictionary[item.Id];
foreach (var candidateItem in candidateItems)
{
if (!ClassDictionary.ContainsKey(candidateItem))
{
yield return(GetItem(candidateItem));
continue;
}
if (ClassDictionary[candidateItem] != targetAlias.Class)
{
continue;
}
yield return(GetItem(candidateItem));
}
}
public void RaiseAliasAdded(EpgpAlias addedAlias)
{
AliasAdded?.Invoke(this, addedAlias);
}
public void Gp(EpgpAlias alias, int value, string memo, TransactionType type = TransactionType.GpManual)
{
var transaction = _epgpTransactionFactory.GetTransaction(alias, value, memo, type);
PostTransaction(alias, transaction);
}
public void AddAlias(EpgpAlias alias)
{
_dbContext.Aliases.Add(alias);
_dbContext.SaveChanges();
_eventAlerter.RaiseAliasAdded(alias);
}
private string GetQueryString(Item item, EpgpAlias alias)
{
var receivedPreviously = alias.AwardedItems.Any(itm => itm.ItemId == item.Id);
return($"{item.Name} {(receivedPreviously ? "⚠️" : string.Empty)}");
}
private async Task <Item> QueryItem(List <Item> candidateItems, ICommandContext context, EpgpAlias targetAlias)
{
var index = await _queryService.SendOptionSelectQuery("Please select the item\n⚠️ - item has been claimed by this user previously\n", candidateItems,
item => GetQueryString(item, targetAlias), context.Channel, CancellationToken.None);
if (index == -1)
{
return(null);
}
return(candidateItems[index]);
}
public async Task <Item> ResolveItem(Item toResolve, ICommandContext context, EpgpAlias targetAlias)
{
foreach (var mapper in _itemMappers)
{
if (!mapper.ContainsMap(toResolve))
{
continue;
}
var items = mapper.GetItems(toResolve, context, targetAlias).ToList();
if (items.Count <= 1)
{
if (!items.Any())
{
await context.Channel.SendMessageAsync(
"Unable to find any items that were eligible to be assigned to that user");
}
return(items.FirstOrDefault());
}
return(await QueryItem(items, context, targetAlias));
}
return(toResolve);
}
