private async Task <IResult> SetTime(long chatId, string time, ConsumerType consumerType)
{
var splittedTime = time.Split(':');
if (splittedTime.Length != 2)
{
return(new FailedResult("Укажите время в формате часы:минуты (например, 11:30)"));
}
try
{
var cronTime = new CronTime(splittedTime[1], splittedTime[0]);
var job = await _context.CronJobs.FirstOrDefaultAsync(x => x.ChatId == chatId);
if (job is null)
{
await _context.CronJobs.AddAsync(new CronJob(chatId.ToString(), chatId, 0, string.Empty,
cronTime, consumerType, CronType.Schedule));
}
else
{
job.SetCronTime(cronTime);
}
await _context.SaveChangesAsync();
return(new SuccessfulResult($"Время успешно установлено на {time}"));
}
catch (Exception e)
{
return(new FailedResult(e.Message));
}
}
public async Task <AwardMessage> CreateAwardMessage(
ulong originalMessageId,
ulong originalChannelId,
ulong awardedMessageId,
ulong awardChannelId,
ulong userId,
uint awardCount)
{
var awardMessage = new AwardMessage
{
OriginalMessageId = originalMessageId,
OriginalChannelId = originalChannelId,
UserId = userId,
AwardedMessageId = awardedMessageId,
AwardChannelId = awardChannelId,
AwardCount = awardCount,
DateTime = DateTime.UtcNow
};
await _dbContext.AddAsync(awardMessage);
await _dbContext.SaveChangesAsync();
return(awardMessage);
}
public async Task <ulong> ClaimDailyScoreAsync(ulong userID)
{
DateTime now = DateTime.UtcNow;
await using (var transaction = await dbContext.Database.BeginTransactionAsync())
{
var user = await FindOrCreateUser(userID);
// FIXME: Can combine the two cases to be more similar, i.e. handle no streak and never claimed equally
// FIXME: Make base score multiplier configurable
const ulong BASE_SCORE_MULTIPLIER = 100;
if (user.LastDailyClaimed == null)
{
// First time claim
user.LastDailyClaimed = now;
user.Score = BASE_SCORE_MULTIPLIER;
user.CurrentDailyStreak = 1;
}
else
{
// Check whether last claim was yesterday or earlier
if (now.Date == user.LastDailyClaimed?.Date)
{
throw new ScoreAlreadyClaimedException();
}
// Calculate additional points based on streak
if (now.Date.Subtract(user.LastDailyClaimed.Value.Date).TotalDays <= 1)
{
// Streak going
++user.CurrentDailyStreak;
}
else
{
// Streak reset
user.CurrentDailyStreak = 1;
}
// Update score based on streak
user.Score += (ulong)Math.Floor(1 + Math.Log2(user.CurrentDailyStreak)) * BASE_SCORE_MULTIPLIER;
user.LastDailyClaimed = now;
}
// Optimistic concurrency: If score was updated in the meantime (i.e. already claimed) transaction fails
await dbContext.SaveChangesAsync();
await transaction.CommitAsync();
return(user.CurrentDailyStreak);
}
}
public async Task <string> GenerateInitializeCommandContext(ulong serverId, ulong channelId)
{
if (_context.Leaderboards.Any(x => x.ServerId == serverId.ToString()))
{
return("Seems like a leaderboard is already setup on this server");
}
var leaderboard = new Leaderboard {
ServerId = serverId.ToString(), ChannelId = channelId.ToString()
};
_context.Leaderboards.Add(leaderboard);
await _context.SaveChangesAsync();
return("Initialized leaderboard for this server. Users can join by using the `join` command.");
}
public static async Task SetDefaultValueDbContextAsync()
{
using BotDbContext db = CreateMemoryDbContext();
db.TelegramUsers.Add(new TelegramUser {
Id = 123456789, UserName = "******"
});
db.TelegramUsers.Add(new TelegramUser {
Id = 987654321, UserName = "******"
});
Guid clientId1 = Guid.NewGuid();
Guid clientId2 = Guid.NewGuid();
Guid clientId3 = Guid.NewGuid();
db.AzureApps.Add(new AzureApp {
Id = clientId1, Email = "*****@*****.**", Secrets = string.Empty, TelegramUserId = 123456789, Name = "App1"
});
db.AzureApps.Add(new AzureApp {
Id = clientId2, Email = "*****@*****.**", Secrets = string.Empty, TelegramUserId = 123456789, Name = "App2"
});
db.AzureApps.Add(new AzureApp {
Id = clientId3, Email = "*****@*****.**", Secrets = string.Empty, TelegramUserId = 987654321, Name = "App3"
});
db.AppAuths.Add(new AppAuth {
Name = "Auth1", RefreshToken = string.Empty, Scope = DefaultGraphApi.Scope, AzureAppId = clientId1
});
db.AppAuths.Add(new AppAuth {
Name = "Auth3", RefreshToken = string.Empty, Scope = "", AzureAppId = clientId3
});
await db.SaveChangesAsync();
await db.DisposeAsync();
}
public static async Task SetApiResultDbContextAsync()
{
using BotDbContext db = CreateMemoryDbContext();
db.TelegramUsers.Add(new TelegramUser {
Id = 123456789, UserName = "******"
});
db.TelegramUsers.Add(new TelegramUser {
Id = 987654321, UserName = "******"
});
db.ApiResults.Add(new ApiResult {
Result = "123", TelegramUserId = 123456789
});
db.ApiResults.Add(new ApiResult {
Result = "123987456", TelegramUserId = 123456789
});
db.ApiResults.Add(new ApiResult {
Result = "987654321", TelegramUserId = 987654321
});
await db.SaveChangesAsync();
await db.DisposeAsync();
}
public async Task Invoke(SocketUserMessage msg)
{
var blacklisted = new List <string>();
if (msg.MentionedChannels.Count > 0)
{
foreach (var channel in msg.MentionedChannels)
{
if (!await _context.BlacklistedChannels.AnyAsync(x =>
x.GuildId == channel.Guild.Id && x.ChannelId == channel.Id))
{
var blacklistedChannel = new BlacklistedChannel
{
GuildId = channel.Guild.Id,
ChannelId = channel.Id
};
await _context.BlacklistedChannels.AddAsync(blacklistedChannel);
blacklisted.Add(channel.Name);
}
}
await _context.SaveChangesAsync();
var successResponse =
$"Added channels: {string.Join(", ", blacklisted)} to blacklist";
await msg.Channel.SendMessageAsync(successResponse);
}
else
{
await msg.Channel.SendMessageAsync("Please mention one or more channels");
}
}
private async Task <IResult> SetScheduleMailing(BotUser user, bool isSchedule)
{
if (user.NarfuGroup == 0)
{
return(new FailedResult(DefaultErrors.GroupNotSet));
}
user.SetHasSchedule(!isSchedule);
await _db.SaveChangesAsync();
return(new SuccessfulResult
{
Message = Success,
Keyboard = DefaultKeyboards.GetMailingKeyboard(user)
});
}
private async Task SendRemindsFromArray(Remind[] reminds)
{
if (!reminds.Any())
{
return;
}
foreach (var remind in reminds)
{
var message = $"Напоминаю:\n{remind.Text}";
var sender = _senders.FirstOrDefault(x => x.ConsumerType == remind.ConsumerType);
if (sender is null)
{
throw new ArgumentNullException($"sender for '{remind.ConsumerType}' not found", nameof(sender));
}
await sender.Send(remind.ChatId, message);
_db.Reminds.Remove(remind);
}
if (_db.ChangeTracker.HasChanges())
{
await _db.SaveChangesAsync();
}
}
private async Task OnDisconnectCommand(Provider.MessageEventArgs e, string command, string args)
{
var conversation = e.Message.OriginConversation;
if (string.IsNullOrEmpty(args))
{
await conversation.SendMessage(
$"{BotPrefix}Использование:\n/disconnect <connectionId>\n\nГде <connectionId> - ID сопряжения. Узнать его можно, введя /list");
return;
}
try
{
var connectionId = long.Parse(args);
var connection = _db.Connections
.Include(c => c.LeftConversation)
.Include(c => c.RightConversation)
.SingleOrDefault(c => c.ConnectionId == connectionId);
if (connection == null)
{
throw new ArgumentException("Connection does not exists");
}
if (!connection.LeftConversation.Equals(conversation) &&
!connection.RightConversation.Equals(conversation))
{
throw new ArgumentException("Connection does not valid for this chat");
}
var otherConversation = connection.LeftConversation.Equals(conversation)
? connection.RightConversation
: connection.LeftConversation;
_db.Connections.Remove(connection);
await _db.SaveChangesAsync();
await Task.WhenAll(
conversation.SendMessage($"{BotPrefix}Чат {otherConversation} отключён"),
otherConversation.SendMessage($"{BotPrefix} Чат {conversation} отключён")
);
}
catch (Exception ex) when(ex is ArgumentException || ex is FormatException)
{
await conversation.SendMessage($"{BotPrefix}Сопряжение с таким ID не найдено");
}
}
public async Task CreateWithCredentials(LeaderboardParticipant participant, StravaOauthResponse oauthResponse)
{
_dbContext.Participants.Add(participant);
var credentials = _dbContext.Credentials.FirstOrDefault(x => x.StravaId == participant.StravaId);
if (credentials == null)
{
_dbContext.Credentials.Add(new StravaCredential(participant.StravaId, oauthResponse.AccessToken, oauthResponse.RefreshToken));
}
else
{
credentials.UpdateWithNewTokens(oauthResponse);
_dbContext.Credentials.Update(credentials);
}
await _dbContext.SaveChangesAsync();
}
private async Task SaveMessage(Message message, ServicesContext serviceContext, BotDbContext dbContext)
{
var messageParts = message.Text.Split(' ');
var client = serviceContext.TelegramBotService.Client;
if (messageParts.Length >= 2)
{
var originMessage = message.ReplyToMessage;
if (originMessage == null)
{
await client.SendTextMessageAsync
(
message.Chat.Id,
"Reply to a message >.> baka.",
replyToMessageId : message.MessageId
);
}
else
{
var table = dbContext.AdminSavedMessages;
var existingEntry = table.Where(savedMessage => savedMessage.ChatId == message.Chat.Id && savedMessage.MessageTag == messageParts[1]).FirstOrDefault();
if (existingEntry != null)
{
await client.SendTextMessageAsync
(
message.Chat.Id,
"Updated message ^-^",
replyToMessageId : message.MessageId
);
existingEntry.ChatId = message.Chat.Id;
existingEntry.MessageId = originMessage.MessageId;
}
else
{
await client.SendTextMessageAsync
(
message.Chat.Id,
"Saved message ^-^",
replyToMessageId : message.MessageId
);
table.Add(new AdminSavedMessages(messageParts[1], message.Chat.Id, originMessage.MessageId));
}
await dbContext.SaveChangesAsync();
}
}
else
{
await client.SendTextMessageAsync
(
message.Chat.Id,
"Invalid request >_<",
replyToMessageId : message.MessageId
);
}
}
/// <inheritdoc />
public async Task <bool> InsertRecordAsync(BotDataModel botDataModel)
{
// Add new record to the database
await _botDbContext.BotData.AddAsync(botDataModel);
// Save changes
return(await _botDbContext.SaveChangesAsync() > 0);
}
private async Task RemoveJob(long chatId)
{
var job = _context.CronJobs.FirstOrDefaultAsync(x => x.ConsumerType == ConsumerType.Vkontakte &&
x.ChatId == chatId);
if (job != null)
{
_context.Remove(job);
await _context.SaveChangesAsync();
}
}
public async Task <IResult> Execute(Message msg, BotUser user)
{
user = _db.Entry(user).Entity;
user.SetErrorNotification(!user.IsErrorsEnabled);
await _db.SaveChangesAsync();
return(new SuccessfulResult
{
Message = user.IsErrorsEnabled ? "Ошибки включены" : "Ошибки отключены"
});
}
public async Task AddAdmin(SocketRole role)
{
var adminRole = new AdminRole
{
GuildId = role.Guild.Id,
RoleId = role.Id,
RoleName = role.Name
};
await _context.AdminRoles.AddAsync(adminRole);
await _context.SaveChangesAsync();
}
public override async Task Execute(Update update, TelegramBotClient client)
{
var userId = GetUserId(update);
var chatId = GetChatId(update);
var messageId = GetMessageId(update);
if (StateMachine.GetCurrentStep(userId) == 0)
{
var revenueButton = Bot.MakeInlineButton($"{new Emoji(0x1F4C8)} В доходи", "revenue");
var expenseButton = Bot.MakeInlineButton($"{new Emoji(0x1F4C9)} До витрат", "expense");
await client.SendTextMessageAsync(chatId, "Куди саме додати категорію?", replyMarkup : Bot.MakeInlineKeyboard(revenueButton, expenseButton));
StateMachine.NextStep(userId);
return;
}
if (StateMachine.GetCurrentStep(userId) == 1)
{
if (update.CallbackQuery.Data == "revenue")
{
AddCategory(userId, "", CategoryType.Revenue);
}
if (update.CallbackQuery.Data == "expense")
{
AddCategory(userId, "", CategoryType.Expense);
}
await client.EditMessageTextAsync(chatId, messageId, "Введіть назву категорії");
StateMachine.NextStep(userId);
return;
}
if (StateMachine.GetCurrentStep(userId) == 2)
{
var category = _userCategories.Single(r => r.UserId == userId);
category.Name = update.Message.Text;
if (_dbContext.ContainsCategory(userId, category.Name, category.CategoryType))
{
await client.SendTextMessageAsync(chatId, "Упс... така категорія вже існує, спробуйте ввести щось інше");
return;
}
_dbContext.Categories.Add(category);
await _dbContext.SaveChangesAsync();
var answer = $"{new Emoji(0x2705)} Категорію <u><b>{category.Name}</b></u> додано";
answer += category.CategoryType == CategoryType.Expense ? " до витрат" : " в доходи";
await client.SendTextMessageAsync(chatId, answer, ParseMode.Html);
_userCategories.Remove(category);
StateMachine.FinishCurrentCommand(userId);
}
}
public async Task OsuSet(
[Name("Username")] string username,
[Name("Default game mode")] int gameMode = 0
)
{
var user = _context.OsuUsers.SingleOrDefault(u => u.DiscordId == Context.User.Id);
if (user is null)
{
_context.Add(new OsuUser(Context.User.Id, username, gameMode));
await _context.SaveChangesAsync();
await ReplyAsync("User registered!");
return;
}
user.OsuUsername = username;
user.DefaultGameMode = gameMode;
await _context.SaveChangesAsync();
await ReplyAsync("User updated!");
}
private async Task GrantPermission(string discordUserId, Permission permission, BotDbContext dbContext, IDMChannel channel)
{
var user = await dbContext.Users.FirstOrDefaultAsync(u => u.DiscordUserId == discordUserId);
user.UserPermissions.Add(new UserPermissions()
{
PermissionId = permission.Id, UserId = user.Id, User = user, Permission = permission
});
dbContext.Update(user);
await dbContext.SaveChangesAsync();
await channel.SendMessageAsync("Granted Permission");
}
public static async Task AddUserToDbAsync(string userId)
{
if (!await IsUserInDbAsync(userId)) //check
{
var id = LogEventIdProvider.GetEventIdByType(LoggingEvent.UserDbAction);
using (var dbContext = new BotDbContext(_config))
{
var user = new User()
{
DiscordUserId = userId
};
await dbContext.Users.AddAsync(user);
await dbContext.SaveChangesAsync();
var defaultUserRole = await dbContext.Roles.FirstOrDefaultAsync(r => r.Description == "Default-User");
if (defaultUserRole == null)
{
defaultUserRole = new Role()
{
Description = "Default-User"
};
await dbContext.Roles.AddAsync(defaultUserRole);
}
var userRole = new UserRoles()
{
User = user, Role = defaultUserRole, RoleId = defaultUserRole.Id
};
user.Roles.Add(userRole);
dbContext.Users.Update(user);
await dbContext.SaveChangesAsync();
logger.LogInformation(id, LogMessageBuilder.Build(id, $"Added User {userId} to database"));
}
}
}
public static async Task <int> AddUnknownNationsAsPendingAsync(List <string> newNations, bool sourceDumps)
{
int counter = 0;
using (var context = new BotDbContext(_config))
{
var status = await context.NationStatuses.FirstOrDefaultAsync(n => n.Name == "pending");
if (status == null)
{
status = new NationStatus()
{
Name = "pending"
};
await context.NationStatuses.AddAsync(status);
await context.SaveChangesAsync();
}
foreach (string nationName in newNations)
{
if (await context.Nations.FirstOrDefaultAsync(n => n.Name == nationName) == null)
{
var time = sourceDumps ? TimeZoneInfo.ConvertTimeToUtc(DumpDataService.LastDumpUpdateTimeUtc, TimeZoneInfo.Local) : DateTime.UtcNow;
await context.Nations.AddAsync(new Nation()
{
Name = nationName, StatusTime = time, Status = status, StatusId = status.Id
});
await context.SaveChangesAsync();
counter++;
}
}
}
return(counter);
}
private async Task <Chat> GetChatById(long chatId)
{
var chat = await _context.Chats.FirstOrDefaultAsync(ch => ch.ChatId == chatId);
if (chat != null)
{
return(chat);
}
chat = new Chat(chatId);
_context.Chats.Add(chat);
await _context.SaveChangesAsync();
return(chat);
}
public static async Task SetNationStatusToAsync(Nation nation, string statusName)
{
using (var dbContext = new BotDbContext(_config))
{
var current = nation.Status;
var status = await dbContext.NationStatuses.FirstOrDefaultAsync(n => n.Name == statusName);
if (status == null)
{
status = new NationStatus()
{
Name = statusName
};
await dbContext.NationStatuses.AddAsync(status);
await dbContext.SaveChangesAsync();
}
nation.Status = status;
nation.StatusId = status.Id;
nation.StatusTime = DateTime.UtcNow;
dbContext.Nations.Update(nation);
await dbContext.SaveChangesAsync();
}
}
public async Task <StravaCredential> RefreshCredentialsForParticipant(LeaderboardParticipant participant)
{
StravaOauthResponse authResponse = null;
StravaCredential credential;
try
{
credential = await GetCredentialsForParticipant(participant);
authResponse = await _stravaApiService.RefreshAccessTokenAsync(credential.RefreshToken)
.ConfigureAwait(false);
}
catch (Exception e)
{
_logger.LogError(e, $"Failed to refresh access token for {participant.DiscordUserId}");
throw new StravaException(StravaException.StravaErrorType.RefreshFailed);
}
credential.UpdateWithNewTokens(authResponse);
_dbContext.Credentials.Update(credential);
await _dbContext.SaveChangesAsync();
return(credential);
}
private async Task <IResult> SetGroup(string group, BotUser user)
{
if (!int.TryParse(group, out var intGroup))
{
return(new FailedResult("Укажите корректный номер группы."));
}
var isExists = _narfu.Students.IsCorrectGroup(intGroup);
if (!isExists)
{
return(new FailedResult($"Группа с номером {intGroup} не найдена."));
}
var groupName = _narfu.Students.GetGroupByRealId(intGroup).Name;
user.SetNarfuGroup(intGroup);
await _db.SaveChangesAsync();
return(new SuccessfulResult
{
Message = $"Группа успешно установлена на {intGroup} ({groupName})"
});
}
public static async Task SetOneValueDbContextAsync(Guid clientId)
{
using BotDbContext db = CreateMemoryDbContext();
db.TelegramUsers.Add(new TelegramUser {
Id = 123456789, UserName = "******"
});
db.AzureApps.Add(new AzureApp {
Id = clientId, Email = "*****@*****.**", Secrets = string.Empty, TelegramUserId = 123456789
});
db.AppAuths.Add(new AppAuth {
Name = "test", RefreshToken = string.Empty, Scope = DefaultGraphApi.Scope, AzureAppId = clientId
});
await db.SaveChangesAsync();
}
public static async Task RemoveUserFromDbAsync(string userId)
{
using (var dbContext = new BotDbContext(_config))
{
var user = await dbContext.Users.FirstOrDefaultAsync(u => u.DiscordUserId == userId);
if (user != null)
{
var id = LogEventIdProvider.GetEventIdByType(LoggingEvent.UserDbAction);
dbContext.Remove(user);
await dbContext.SaveChangesAsync();
logger.LogInformation(id, LogMessageBuilder.Build(id, $"Removed User {userId} from database"));
}
}
}
public async Task PrefixSet([Name("Prefix")] string prefix)
{
var config = _dbContext.Configurations.SingleOrDefault(c => c.GuildId == Context.Guild.Id);
if (config is null)
{
_dbContext.Add(new ServerConfiguration(Context.Guild.Id, prefix));
}
else
{
config.Prefix = prefix;
}
await _dbContext.SaveChangesAsync();
await ReplyAsync("Prefix set!");
}
public async Task CheckAndRemoveUserGroups()
{
var users = await _context.BotUsers.ToArrayAsync();
foreach (var user in users)
{
if (_narfuApi.Students.IsCorrectGroup(user.NarfuGroup))
{
continue;
}
user.SetNarfuGroup(0);
user.SetHasSchedule(false);
}
await _context.SaveChangesAsync();
}
private async Task ClearSavedMessage(Message message, ServicesContext serviceContext, BotDbContext dbContext)
{
var messageParts = message.Text.Split(' ');
var client = serviceContext.TelegramBotService.Client;
var table = dbContext.AdminSavedMessages;
IQueryable <AdminSavedMessages> results;
if (messageParts.Length >= 2)
{
results = table.Where(savedMessage => savedMessage.ChatId == message.Chat.Id && savedMessage.MessageTag == messageParts[1]);
}
else
{
results = table.Where(savedMessage => savedMessage.ChatId == message.Chat.Id);
}
table.RemoveRange(results);
await dbContext.SaveChangesAsync();
}
