public async Task <decimal> GetValueAsync()
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
return((await context.StockDefinitions.FindAsync(Ticker)).Current_Value);
}
}
public static async Task CmdSVID(SocketMessage msg, string[] args)
{
using (VooperContext context = new VooperContext(VoopAI.DBOptions))
{
User target = null;
if (msg.MentionedUsers.Count == 0)
{
target = context.Users.FirstOrDefault(u => u.discord_id == msg.Author.Id);
if (target == null)
{
await msg.Channel.SendMessageAsync("You do not have a web account!");
return;
}
}
else
{
target = context.Users.FirstOrDefault(u => u.discord_id == msg.MentionedUsers.First().Id);
if (target == null)
{
await msg.Channel.SendMessageAsync("They do not have a web account!");
return;
}
}
await msg.Channel.SendMessageAsync($"Their SVID is {target.Id}");
}
}
public async Task <List <ResultData> > GetResults()
{
List <ResultData> results = new List <ResultData>();
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
Dictionary <string, int> votecounts = new Dictionary <string, int>();
foreach (ElectionVote vote in context.ElectionVotes.AsQueryable().Where(x => x.Election_Id == Id && !x.Invalid))
{
if (!votecounts.ContainsKey(vote.Choice_Id))
{
votecounts.Add(vote.Choice_Id, 1);
}
else
{
votecounts[vote.Choice_Id] += 1;
}
}
foreach (KeyValuePair <string, int> result in votecounts)
{
User user = await context.Users.FindAsync(result.Key);
if (user != null)
{
results.Add(new ResultData(user, result.Value));
}
}
}
results.OrderByDescending(x => x.Votes);
return(results);
}
public async Task <bool> IsInGroup(User user)
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
return(await context.GroupMembers.AsQueryable().AnyAsync(x => x.Group_Id == Id && x.User_Id == user.Id));
}
}
public Oauth2Controller(
VooperContext context,
UserManager <User> userManager)
{
_userManager = userManager;
_context = context;
}
public bool HasPermission(Entity entity, string perm)
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
return(HasPermissionAsync(entity, perm).Result);
}
}
public async Task <bool> IsOwnerAsync(Entity entity)
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
Entity owner = await Entity.FindAsync(Owner_Id);
// While the owner is a group
while (owner is Group)
{
// Check if it matches
if (owner.Id == entity.Id)
{
return(true);
}
// Move up to next layer of ownership
owner = await Entity.FindAsync(((Group)owner).Owner_Id);
}
// At this point the owner must be a user
if (owner != null)
{
return(owner.Id == entity.Id);
}
return(false);
}
}
public async Task <Group> GetGroup()
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
return(await context.Groups.FindAsync(GroupId));
}
}
public async Task <int> GetMemberCount()
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
return(await context.GroupRoleMembers.AsQueryable().CountAsync(x => x.Role_Id == RoleId));
}
}
public async Task <bool> HasPermissionAsync(Entity entity, string perm)
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
if (await IsOwnerAsync(entity))
{
return(true);
}
// Get all role membership of the user in the group
var membership = context.GroupRoleMembers.AsQueryable().Where(x => x.Group_Id == Id && x.User_Id == entity.Id);
// Get role and check if it has permission for each membership
foreach (var m in membership)
{
if (await context.GroupRoles.AsQueryable().AnyAsync(x => x.RoleId == m.Role_Id && x.Permissions.Contains(perm.ToLower())))
{
return(true);
}
}
// Default to no permissions
return(false);
}
}
public static async Task ReactionAdded(Cacheable <IUserMessage, ulong> message, ISocketMessageChannel channel, SocketReaction reaction)
{
if (reaction.Emote.Name == "commend")
{
IUserMessage msg = (IUserMessage)channel.GetMessageAsync(message.Id).Result;
IUser author = msg.Author;
if (author.IsBot)
{
return;
}
IUser sender = reaction.User.Value;
using (VooperContext context = new VooperContext(VoopAI.DBOptions))
{
User senderData = context.Users.FirstOrDefault(u => u.discord_id == sender.Id);
if (senderData == null || author.Id == sender.Id || senderData.discord_last_commend_hour == DateTime.Now.Hour)
{
await msg.RemoveReactionAsync(reaction.Emote, sender);
}
else
{
await AddCommend(author, sender, message.Id);
}
}
}
}
private async Task LoadRoles()
{
spleenRole = server.Roles.FirstOrDefault(x => x.Name == "Spleen Rank");
crabRole = server.Roles.FirstOrDefault(x => x.Name == "Crab Rank");
gatyRole = server.Roles.FirstOrDefault(x => x.Name == "Gaty Rank");
corgiRole = server.Roles.FirstOrDefault(x => x.Name == "Corgi Rank");
oofRole = server.Roles.FirstOrDefault(x => x.Name == "Oof Rank");
patreonCitizen = server.Roles.FirstOrDefault(x => x.Name == "Patreon Citizen");
patreonSoldier = server.Roles.FirstOrDefault(x => x.Name == "Patreon Soldier");
patreonLoyalist = server.Roles.FirstOrDefault(x => x.Name == "Patreon Loyalist");
patreonHero = server.Roles.FirstOrDefault(x => x.Name == "Patreon Hero");
patreonMadlad = server.Roles.FirstOrDefault(x => x.Name == "Patreon Madlad");
youtubeCitizen = server.Roles.FirstOrDefault(x => x.Id == 754387925742911600);
using (VooperContext context = new VooperContext(DBOptions))
{
/*
* foreach(District district in govContext.Districts)
* {
* if (!server.Roles.Any(x => x.Name == district.Name + " District"))
* {
* await server.CreateRoleAsync(district.Name + " District", GuildPermissions.None, null, false, RequestOptions.Default);
* }
* }
*/
foreach (District d in context.Districts)
{
districtRoles.Add(d.Name + " District", server.Roles.FirstOrDefault(x => x.Name == d.Name + " District"));
}
}
}
public async Task <Entity> GetOwner()
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
return(await Entity.FindAsync(Owner_Id));
}
}
public async Task Migrate()
{
using (NerdcraftContext nc = new NerdcraftContext(NCDBOptions))
using (VooperContext c = new VooperContext(DBOptions))
{
foreach (District d in c.Districts)
{
if (!(await c.Groups.AsQueryable().AnyAsync(x => x.Id == d.Group_Id)))
{
Group group = new Group()
{
Description = "The district of " + d.Name,
District_Id = d.Name,
Api_Key = Guid.NewGuid().ToString(),
Group_Category = "District",
Open = true,
Owner_Id = d.Senator,
Name = d.Name,
Id = d.Group_Id
};
c.Groups.Add(group);
await c.SaveChangesAsync();
}
}
}
}
public async void DoSalary()
{
using (VooperContext context = new VooperContext(DBOptions))
{
Console.WriteLine("Doing salary job");
var groupRoles = context.GroupRoles;
foreach (var rank in context.GroupRoles.AsQueryable().Where(x => x.Salary > 0m))
{
Group group = await rank.GetGroup();
if (group == null)
{
context.GroupRoles.Remove(rank);
await context.SaveChangesAsync();
}
else
{
foreach (var user in await rank.GetUsers())
{
await new TransactionRequest(group.Id, user.Id, rank.Salary, $"{group.Name} salary for {rank.Name}", ApplicableTax.Payroll, false).Execute();
}
}
}
Console.WriteLine("Finished salary job");
}
}
public static async Task CmdMessages(SocketMessage msg, string[] args)
{
if (msg.MentionedUsers.Count < 1)
{
await SendMessage((SocketTextChannel)msg.Channel, "Please specify a name.");
return;
}
SocketUser target = msg.MentionedUsers.First();
using (VooperContext context = new VooperContext(VoopAI.DBOptions))
{
User userData = context.Users.FirstOrDefault(u => u.discord_id == target.Id);
if (userData != null)
{
await SendMessage((SocketTextChannel)msg.Channel, "The user " + target.Username + " has sent " + userData.discord_message_count + " messages on record.");
}
else
{
await SendMessage((SocketTextChannel)msg.Channel, "Please make a web account for message tracking.");
}
}
}
public void UpdateGovRanks()
{
using (VooperContext context = new VooperContext(DBOptions))
{
var senateRole = server.Roles.FirstOrDefault(x => x.Name == "Senator");
// Remove old senators
foreach (var duser in server.Users.Where(x => x.Roles.Any(x => x.Id == senateRole.Id)))
{
User user = context.Users.FirstOrDefault(x => x.discord_id == duser.Id);
if (!context.Districts.AsQueryable().Any(x => x.Senator == user.Id))
{
duser.RemoveRoleAsync(senateRole);
}
}
// Add new senators
foreach (User user in District.GetAllSenatorsAsync(context).Result)
{
var duser = server.Users.FirstOrDefault(x => x.Id == user.discord_id);
if (duser != null && !duser.Roles.Contains(senateRole))
{
duser.AddRoleAsync(senateRole);
}
}
}
Console.WriteLine("Updated gov ranks!");
}
/// <summary>
/// Sets the owner of this group to the specified new owner
/// </summary>
public async Task SetOwnerAsync(Entity newOwner)
{
// Change locally
this.Owner_Id = newOwner.Id;
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
// Change in DB
Group dummy = new Group {
Id = this.Id, Owner_Id = newOwner.Id
};
context.Groups.Attach(dummy);
// Set to update owner field
context.Entry(dummy).Property(x => x.Owner_Id).IsModified = true;
await context.SaveChangesAsync();
}
// Set top owner to new owner
Entity topOwner = await Entity.FindAsync(newOwner.Id);
// Scale up to top owner
while (topOwner is Group)
{
topOwner = await((Group)topOwner).GetOwner();
}
// By this point the top owner should be a user
// Add that user to this group
await AddMember((User)topOwner);
}
public async Task <bool> HasPermission(User user, string permission)
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
if (await IsOwnerAsync(user))
{
return(true);
}
if (!(await IsInGroup(user)))
{
return(false);
}
foreach (GroupRole role in GetRolesForPerm(permission))
{
if (await context.GroupRoleMembers.AsQueryable().AnyAsync(x => x.Role_Id == role.RoleId && user.Id == x.User_Id))
{
return(true);
}
}
return(false);
}
}
public static async Task RunQueue(VooperContext context)
{
if (transactionQueue.IsEmpty)
{
return;
}
TransactionRequest request;
bool dequeued = transactionQueue.TryDequeue(out request);
if (!dequeued)
{
return;
}
TaskResult result = await DoTransaction(request, context);
request.SetResult(result);
string success = "SUCC";
if (!result.Succeeded)
{
success = "FAIL";
}
Console.WriteLine($"[{success}] Processed {request.Detail} for {request.Amount}.");
// Notify SignalR
string json = JsonConvert.SerializeObject(request);
await TransactionHub.Current.Clients.All.SendAsync("NotifyTransaction", json);
}
public IEnumerable <GroupRole> GetRoleList()
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
return(context.GroupRoles.AsQueryable().Where(x => x.GroupId == Id).ToList());
}
}
public IEnumerable <GroupMember> GetMemberList()
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
return(context.GroupMembers.AsQueryable().Where(x => x.Group_Id == Id));
}
}
public async Task ClearRoles()
{
using (VooperContext context = new VooperContext(VooperContext.DBOptions))
{
context.GroupRoles.RemoveRange(context.GroupRoles.AsQueryable().Where(x => x.GroupId == Id));
await context.SaveChangesAsync();
}
}
public EntityController(
VooperContext context,
UserManager <User> userManager,
IMapper mapper)
{
_userManager = userManager;
_context = context;
_mapper = mapper;
}
public void PollElections()
{
using (VooperContext context = new VooperContext(DBOptions))
{
foreach (Election election in context.Elections.AsQueryable().Where(x => x.Active))
{
if (DateTime.UtcNow > election.End_Date)
{
// End the election
if (election.Type.ToLower() == "senate")
{
var results = election.GetResults().Result;
User winner = results[0].Candidate;
election.Active = false;
election.Winner_Id = winner.Id;
context.Elections.Update(election);
context.SaveChanges();
District district = context.Districts.Find(election.District);
district.Senator = winner.Id;
Group group = context.Groups.Find(district.Group_Id);
group.Owner_Id = winner.Id;
context.Groups.Update(group);
context.Districts.Update(district);
context.SaveChanges();
SocketGuildUser dUser = server.GetUser((ulong)winner.discord_id);
if (dUser != null)
{
dUser.AddRoleAsync(server.Roles.FirstOrDefault(x => x.Name == "Senator"));
}
EmbedBuilder embed = new EmbedBuilder()
{
Color = new Color(0, 100, 255),
Title = $"**{winner.UserName}** wins Senate Election!"
}
.WithAuthor(dUser)
.WithCurrentTimestamp();
embed.AddField("News Outlet", "VoopAI Auto News");
embed.AddField("Author", "VoopAI The Bot");
embed.AddField("Content", $"Congratulations to {winner.UserName} on winning the {election.District} elections! They won with {results[0].Votes} votes to become the new Senator. " +
$"Please check other news outlets for more details!");
VoopAI.newsChannel.SendMessageAsync(embed: embed.Build());
}
}
}
}
}
public void OnAuthorization(AuthorizationFilterContext context)
{
if (context.HttpContext.User == null)
{
Fail(context);
return;
}
var cl = context.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier);
if (cl == null)
{
Fail(context);
return;
}
string userId = cl.Value;
using (VooperContext c = new VooperContext(VoopAI.DBOptions))
{
Console.WriteLine("Test");
User user = c.Users.Find(userId);
if (user == null)
{
Fail(context);
}
SocketGuildUser discordUser = null;
discordUser = VoopAI.server.Users.FirstOrDefault(u => u.Id == user.discord_id);
if (discordUser == null)
{
Fail(context);
}
string[] claims = _claim.Value.Split(',');
bool allowed = false;
foreach (string claim in claims)
{
if (discordUser.Roles.Any(r => r.Name.ToLower() == claim.ToLower()))
{
allowed = true;
}
}
if (!allowed)
{
Fail(context);
}
}
}
public static async Task Eco(SocketMessage msg)
{
string[] split = msg.Content.Split(' ');
if (split.Length < 2)
{
await SendMessage((SocketTextChannel)msg.Channel, "Please specify a subcommand!");
return;
}
using (VooperContext context = new VooperContext(VoopAI.DBOptions))
{
if (split[1].ToLower() == "cap")
{
decimal users = await context.Users.AsQueryable().Select(x => x.Credits).Where(x => x > 0.0m).SumAsync();
decimal groups = await context.Groups.AsQueryable().Where(x => x.Id != EconomyManager.VooperiaID).Select(x => x.Credits).Where(x => x > 0.0m).SumAsync();
decimal gov = (await context.Groups.FindAsync(EconomyManager.VooperiaID)).Credits;
EmbedBuilder embed = new EmbedBuilder()
{
Color = new Color(0, 100, 255),
Title = $":moneybag: Eco Cap"
}
.WithAuthor(VoopAI.discordClient.CurrentUser)
.WithCurrentTimestamp();
var total = users + groups + gov;
var userP = Math.Round((users / total) * 100);
var groupP = Math.Round((groups / total) * 100);
var govP = Math.Round((gov / total) * 100);
embed.AddField("Users", $"¢{Math.Round(users)} ({userP}%)");
embed.AddField("Groups", $"¢{Math.Round(groups)} ({groupP}%)");
embed.AddField("Vooperia", $"¢{Math.Round(gov)} ({govP}%)");
embed.AddField("Total", $"¢{Math.Round(total)}");
await msg.Channel.SendMessageAsync(embed : embed.Build());
return;
}
if (split[1].ToLower() == "volume")
{
decimal bal = await context.Transactions.AsQueryable().Select(x => x.Credits).SumAsync();
await SendMessage((SocketTextChannel)msg.Channel, $"The Vooperian trade volume is ¢{Math.Round(bal, 2)}");
return;
}
}
}
public static async Task <StockOffer> GetLowestSellOffer(string ticker, VooperContext context)
{
StockOffer lowest = await context.StockOffers
.AsQueryable()
.Where(s => s.Ticker == ticker && s.Order_Type == "SELL")
.OrderBy(s => s.Target)
.FirstOrDefaultAsync();
return(lowest);
}
public static async Task <StockOffer> GetHighestBuyOffer(string ticker, VooperContext context)
{
StockOffer highest = await context.StockOffers
.AsQueryable()
.Where(s => s.Ticker == ticker && s.Order_Type == "BUY")
.OrderByDescending(s => s.Target)
.FirstOrDefaultAsync();
return(highest);
}
public float GetWeight(VooperContext context)
{
// One week - Time passed
float timeDecay = 604800f - (float)DateTime.UtcNow.Subtract(TimePosted).TotalSeconds;
// Lowest is 1
timeDecay = Math.Max(1, timeDecay) / 100000f;
return(GetLikes(context) * timeDecay);
}
