public PointsReactionHandler(PointsService pointsService, DiscordSocketClient client,
ReactionSettings reactionSettings)
{
PointsService = pointsService;
Client = client;
ReactionSettings = reactionSettings;
}
public SpicyReactionImagesModule(ImagesService imagesService, UserBdsmTraitsService userBdsmTraits,
PointsService pointsService)
{
ImagesService = imagesService;
UserBdsmTraits = userBdsmTraits;
PointsService = pointsService;
}
public PointsModule(CommandSender sender, IHttpClientFactory httpClientFactory, IConfiguration configuration, PointsService pointsService)
{
_sender = sender;
_httpClientFactory = httpClientFactory;
_configuration = configuration;
_pointsService = pointsService;
}
public void ProcessRequest(HttpContext context)
{
PointsService ds = new PointsService();
string username = context.User.Identity.Name;
bool Done = ds.IsUserDoneDaily(username);
string ret;
if (Done)
{
ret = "{\"Done\": true}";
}
else
{
ret = "{\"Done\": false}";
}
context.Response.ContentType = "application/json";
List <string> trustedHosts = new List <string>();
//Add new hosts below if need cors (notice that cors header allow only one domain name)
trustedHosts.Add("absmanager.cn-abs.com");
trustedHosts.Add("deallab.cn-abs.com");
string sender = context.Request.UrlReferrer == null ? "" : context.Request.UrlReferrer.Host;
if (trustedHosts.Contains(sender))
{
context.Response.AddHeader("Access-Control-Allow-Origin", "https://" + sender);
}
context.Response.AddHeader("Access-Control-Allow-Credentials", "true");
context.Response.Write(ret);
}
public PointsModule(PointsService pointsService, ReactionSettings reactionSettings, GraphPaintingService graphPaintingService, PointsGraphPaintingStrategy graphPaintingStrategy, UsersService usersService)
{
PointsService = pointsService;
ReactionSettings = reactionSettings;
GraphPaintingService = graphPaintingService;
GraphPaintingStrategy = graphPaintingStrategy;
UsersService = usersService;
}
public PointsController(
ILogger <PointsController> logger,
PointsService pointsService,
UserManager <ApplicationUser> userManager)
{
_logger = logger;
_pointsService = pointsService;
_userManager = userManager;
}
public MapsController(
ILogger <HomeController> logger,
PointsService pointsService,
DistancesService distanceService,
MapsService mapService,
UserManager <ApplicationUser> userManager)
{
_logger = logger;
_pointsService = pointsService;
_distanceService = distanceService;
_mapService = mapService;
_userManager = userManager;
}
public async Task GetLeaderboardAsync([Name("uživatel")] IUser user = null)
{
if (user == null)
{
await GetLeaderboardAsync(0);
return;
}
var pos = await PointsService.GetUserPositionAsync(user);
await GetLeaderboardAsync(pos);
}
public async Task GetGraphAsync()
{
await using var _ = await DisposableReaction.CreateAsync(Context.Message, ReactionSettings.Loading, Context.Client.CurrentUser);
var results = new Dictionary <string, IReadOnlyList <GraphItem> >
{
{ "Body", await PointsService.GetUsersTotalPointsAsync() }
};
using var file = new TemporaryFile("png");
using var graph = await GraphPaintingService.DrawAsync(Context.Guild, GraphPaintingStrategy, results);
graph.Write(file.Path, ImageMagick.MagickFormat.Png);
await ReplyFileAsync(file.Path);
}
public async Task GetPointsAsync([Name("uživatel")] IUser member = null)
{
if (member == null)
{
member = Context.User;
}
if (member.IsBot)
{
await ReplyAsync($"Nelze zobrazit body pro bota {Format.Sanitize(await UsersService.GetDisplayNameAsync(member))} (botům se body nepočítají).");
return;
}
using var points = await PointsService.GetPointsAsync(member);
await ReplyFileAsync(points.Path);
}
static void Main(string[] args)
{
PointsService service = new PointsService();
var items = service.GetAllPoints();
foreach (var y in items)
{
Console.WriteLine(y.StudentNumber + " "
+ y.NumberOfPoints);
}
service.AddPointsToStudent("2018-00044-BN-0", 10);
service.AddPointsToStudent("2015-00066-BN-0", 5);
foreach (var y in items)
{
Console.WriteLine(y.StudentNumber + " "
+ y.NumberOfPoints);
}
}
public async Task GetWeeklyLeaderboardAsync(EnumArg.TimeSpan span, [Name("uživatel")] IUser user = null)
{
var from = span switch
{
EnumArg.TimeSpan.Today => DateTime.Today,
EnumArg.TimeSpan.Week => DateTime.Today.AddDays(-6),
EnumArg.TimeSpan.Month => DateTime.Today.AddMonths(-1).AddDays(1),
_ => throw new NotImplementedException()
};
if (user == null)
{
await GetLeaderboardAsync(0, from);
return;
}
var pos = await PointsService.GetUserPositionAsync(user);
await GetLeaderboardAsync(pos, from);
}
public async Task GetLeaderboardAsync(int start, DateTime?from = null)
{
var count = await PointsService.GetUserCountAsync();
if (start < 1)
{
start = 1;
}
if (start >= count)
{
start = count - 1;
}
start -= start % BoardPageLimit;
var board = await PointsService.GetLeaderboardAsync(start, BoardPageLimit, from);
var embed = new PointsEmbed().WithBoard(
board, Context.Client.CurrentUser, count, start, BoardPageLimit, from);
var message = await ReplyAsync(embed : embed.Build());
await message.AddReactionsAsync(ReactionSettings.PaginationReactions);
}
public int GetPoints(string studentNumber)
{
PointsService service = new PointsService();
return(service.GetPointsByStudentNumber(studentNumber));
}
public UserController(TournamentServiceDbContext context, PointsService pointsService, UserService userService)
{
_pointsService = pointsService;
_userService = userService;
}
public PointsController(FantasyCon context)
{
rs = new PointsService(context);
}
public async Task SynchronizeKisPointsAsync()
{
var message = await PointsService.SynchronizeKisPointsAsync(Context.User);
await ReplyAsync(message);
}
public async Task <bool> HandleReactionAddedAsync(IUserMessage message, IEmote reaction, IUser user)
{
var embed = message.Embeds.FirstOrDefault();
if (embed == null || embed.Author == null || embed.Footer == null)
{
return(false); // Embed checks
}
if (!ReactionSettings.PaginationReactions.Any(emote => emote.IsEqual(reaction)))
{
return(false); // Reaction check.
}
if (message.ReferencedMessage == null)
{
return(false);
}
if (!embed.TryParseMetadata <PointsEmbedMetadata>(out var metadata))
{
return(false); // Not a points board embed.
}
var count = await PointsService.GetUserCountAsync();
if (count == 0)
{
return(false);
}
int newStart = metadata.Start;
if (reaction.IsEqual(ReactionSettings.MoveToFirst))
{
newStart = 0;
}
else if (reaction.IsEqual(ReactionSettings.MoveToLast))
{
newStart = count - 1;
}
else if (reaction.IsEqual(ReactionSettings.MoveToNext))
{
newStart += BoardPageLimit;
}
else if (reaction.IsEqual(ReactionSettings.MoveToPrevious))
{
newStart -= BoardPageLimit;
}
if (newStart >= count)
{
newStart = count - 1;
}
else if (newStart < 0)
{
newStart = 0;
}
newStart -= newStart % BoardPageLimit;
var context = new CommandContext(Client, message.ReferencedMessage);
if (newStart != metadata.Start)
{
var board = await PointsService.GetLeaderboardAsync(newStart, BoardPageLimit, metadata.DateFrom);
var newEmbed = new PointsEmbed()
.WithBoard(board, context.Client.CurrentUser, count, newStart, BoardPageLimit, metadata.DateFrom)
.Build();
await message.ModifyAsync(msg => msg.Embed = newEmbed);
}
if (!context.IsPrivate) // DMs have blocked removing reactions.
{
await message.RemoveReactionAsync(reaction, user);
}
return(true);
}
public TournamentController(UserService userService, TournamentService tournamentService, PointsService pointsService)
{
_userService = userService;
_tournamentService = tournamentService;
_pointsService = pointsService;
}
