public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
var msg = context.Update.Message;
_telegramService = new TelegramService(context);
_settingsService = new SettingsService(msg);
var sendText = "Under maintenance";
if (msg.Chat.Type != ChatType.Private)
{
if (msg.From.Id.IsSudoer())
{
var settings = await _settingsService.GetSettingByGroup();
await _settingsService.UpdateCache();
Log.Information(settings.ToJson());
// var rules = settings.Rows[0]["rules_text"].ToString();
var rules = settings.RulesText;
Log.Information(rules);
sendText = rules;
}
}
else
{
sendText = "Rules hanya untuk grup";
}
await _telegramService.SendTextAsync(sendText);
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
var configuration = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json")
.Build();
var seleniumConfigurations = new SeleniumConfiguration();
new ConfigureFromConfigurationOptions <SeleniumConfiguration>(
configuration.GetSection("SeleniumConfiguration"))
.Configure(seleniumConfigurations);
TelegramService ts = new TelegramService();
PrincipalService ps = new PrincipalService();
services.AddMvc().SetCompatibilityVersion(CompatibilityVersion.Version_2_1);
try
{
ts.EnviaMensagemParaOGrupo("App Iniciado");
// ps.SalvaJogosAmanha(2,false).GetAwaiter().GetResult();
ps.Iniciar(2, false).GetAwaiter().GetResult();
}
catch (Exception e)
{
GC.Collect();
Console.WriteLine("Erro: " + e.Message + " - " + e.StackTrace);
ps.Dispose();
ts.EnviaMensagemParaOGrupo("Erro App : " + e.Message);
}
}
public GetSettingsController(Microsoft.Extensions.Options.IOptionsMonitor <TelegramSettings> telegramSettings,
Services services)
{
_services = services;
_telegramService = services.TelegramService;
_telegramSettings = telegramSettings.CurrentValue;
}
public static async Task<bool> CheckGlobalBanAsync(this TelegramService telegramService,
User userTarget = null)
{
Log.Information("Starting check Global Ban");
var message = telegramService.MessageOrEdited;
var user = message.From;
// var settingService = new SettingsService(message);
var chatSettings = telegramService.CurrentSetting;
if (!chatSettings.EnableFedEs2)
{
Log.Information("Fed ES2 Ban is disabled in this Group!");
return false;
}
if (userTarget != null) user = userTarget;
var messageId = message.MessageId;
var isBan = await user.Id.CheckGBan()
.ConfigureAwait(false);
Log.Information($"IsBan: {isBan}");
if (isBan)
{
await telegramService.DeleteAsync(messageId)
.ConfigureAwait(false);
await telegramService.KickMemberAsync(user)
.ConfigureAwait(false);
await telegramService.UnbanMemberAsync(user)
.ConfigureAwait(false);
}
return isBan;
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
var msg = context.Update.Message;
if (msg.ReplyToMessage != null)
{
msg = msg.ReplyToMessage;
}
var userId = msg.From.Id;
var nameLink = msg.GetFromNameLink();
var sendText = $"{nameLink} berhasil menjadi admin";
var promote = await _telegramService.PromoteChatMemberAsync(userId)
.ConfigureAwait(false);
if (!promote.IsSuccess)
{
var errorCode = promote.ErrorCode;
var errorMessage = promote.ErrorMessage;
sendText = $"Promote {nameLink} gagal" +
$"\nPesan: {errorMessage}";
}
await _telegramService.SendTextAsync(sendText)
.ConfigureAwait(false);
}
public async Task MyIdShouldReturnId()
{
// Arrange
//
var telegramBotMock = new Mock <ITelegramBotClient>();
telegramBotMock.Setup(_ => _.SendTextMessageAsync(
It.IsAny <ChatId>(),
It.IsAny <string>(),
It.IsAny <ParseMode>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <int>(),
It.IsAny <IReplyMarkup>(),
It.IsAny <CancellationToken>()))
.ReturnsAsync(new Message())
.Verifiable();
var dcFactory = new DataConnectionFactory(_connectionSettings);
var telegramService = new TelegramService(
TestHelper.GetLoggerMock <TelegramService>().Object,
telegramBotMock.Object,
dcFactory);
_mockMessage.Text = "/myid";
var publicUserId = shortid.ShortId.Generate();
var yasUser = new YasUser {
TelegramId = 0, PublicId = publicUserId, UserName = "******"
};
await using var dc = dcFactory.Create();
{
dc.GetTable <YasUser>().DataContext.InsertWithIdentity(yasUser);
}
// Act
//
await telegramService.OnBotMessage(_mockMessage);
// Assert
//
telegramBotMock.Verify(_ => _.SendTextMessageAsync(
It.IsAny <ChatId>(), It.Is <string>(m => m.Equals($"{publicUserId}")),
It.IsAny <ParseMode>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <int>(),
It.IsAny <IReplyMarkup>(),
It.IsAny <CancellationToken>()));
long usersCount;
await using var dc2 = dcFactory.Create();
{
usersCount = await dc2.GetTable <YasUser>().CountAsync();
}
Assert.Equal(1, usersCount);
}
public static async Task AddSpellAsync(this TelegramService telegramService)
{
var spellService = telegramService.GetRequiredService <SpellService>();
var typo = telegramService.GetCommandParam(0);
var fix = telegramService.GetCommandParam(1);
var chatId = telegramService.ChatId;
var fromId = telegramService.FromId;
var spellData = new Spell()
{
Typo = typo,
Fix = fix,
ChatId = chatId,
FromId = fromId,
CreatedAt = DateTime.UtcNow
};
if (!spellData.Validate <AddSpellValidator, Spell>().IsValid)
{
await telegramService.SendTextMessageAsync(
sendText : "Sepertinya input Spell tidak valid" +
"\n<code>/add_spell {typo} {fix}</code>",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
includeSenderMessage : true
);
return;
}
var htmlMessage = HtmlMessage.Empty;
var saveSpell = await spellService.SaveSpell(
new Spell()
{
Typo = typo,
Fix = fix,
ChatId = chatId,
FromId = fromId,
CreatedAt = DateTime.UtcNow
}
);
if (saveSpell)
{
htmlMessage.TextBr("Spell berhasil disimpan")
.Bold("Typo: ").CodeBr(typo)
.Bold("Fix: ").CodeBr(fix);
}
else
{
htmlMessage.TextBr("Spell sudah disimpan");
}
await spellService.GetSpellAll(evictBefore : true);
await telegramService.AppendTextAsync(
sendText : htmlMessage.ToString(),
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
includeSenderMessage : true
);
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
_rssService = new RssService(_telegramService.Message);
var msg = _telegramService.Message;
var msgId = msg.MessageId;
var chatId = msg.Chat.Id;
var msgText = msg.Text;
var dateDate = DateTime.UtcNow.ToString("yyyy-MM-dd");
var isAdminOrPrivate = await _telegramService.IsAdminOrPrivateChat()
.ConfigureAwait(false);
if (!isAdminOrPrivate)
{
var send = "Maaf, hanya Admin yang dapat mengimport daftar RSS";
await _telegramService.SendTextAsync(send)
.ConfigureAwait(false);
return;
}
await _telegramService.AppendTextAsync("Sedang mempersiapkan")
.ConfigureAwait(false);
var filePath = $"{chatId}/rss-feed_{dateDate}_{msgId}.txt";
filePath = await _telegramService.DownloadFileAsync(filePath)
.ConfigureAwait(false);
await _telegramService.AppendTextAsync("Sedang membuka berkas")
.ConfigureAwait(false);
var rssLists = await File.ReadAllLinesAsync(filePath, cancellationToken)
.ConfigureAwait(false);
foreach (var rssList in rssLists)
{
Log.Information($"Importing {rssList}");
var data = new Dictionary <string, object>()
{
{ "url_feed", rssList },
{ "chat_id", _telegramService.Message.Chat.Id },
{ "from_id", _telegramService.Message.From.Id }
};
await _rssService.SaveRssSettingAsync(data)
.ConfigureAwait(false);
}
await _telegramService.AppendTextAsync($"Memeriksa RSS duplikat")
.ConfigureAwait(false);
await _rssService.DeleteDuplicateAsync()
.ConfigureAwait(false);
await _telegramService.AppendTextAsync($"{rssLists.Length} RSS berhasil di import")
.ConfigureAwait(false);
}
public static async Task <bool> OnCallbackPinMessageAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
if (!await telegramService.CheckFromAdminOrAnonymous())
{
await telegramService.AnswerCallbackQueryAsync("Kamu tidak memiliki izin untuk melakukan tidakan!", true);
return(true);
}
var messageId = telegramService.GetCallbackDataAt <int>(1);
var pinMode = telegramService.GetCallbackDataAt <string>(2);
var disableNotification = pinMode == "silent";
var client = telegramService.Client;
await client.UnpinChatMessageAsync(chatId, messageId);
await client.PinChatMessageAsync(
chatId : chatId,
messageId : messageId,
disableNotification : disableNotification
);
await telegramService.DeleteCurrentCallbackMessageAsync();
return(true);
}
public static async Task DeleteMessageManyAsync(
this TelegramService telegramService,
long customUserId = -1
)
{
var wTelegramService = telegramService.GetRequiredService <WTelegramApiService>();
var chatId = telegramService.ChatId;
var userId = customUserId == -1 ? telegramService.FromId : customUserId;
var messageId = telegramService.AnyMessage.MessageId;
var messageIds = await wTelegramService.GetMessagesIdByUserId(
chatId : chatId,
userId : userId,
lastMessageId : messageId
);
Log.Debug(
"Deleting {MessageIdsCount} Messages for UserId {UserId}",
messageIds.Count,
userId
);
await messageIds.AsyncParallelForEach(
maxDegreeOfParallelism : 8,
body : async id => {
await telegramService.DeleteAsync(id);
}
);
}
public static async Task <bool> IsAdminGroup(this TelegramService telegramService, int userId = -1)
{
var message = telegramService.MessageOrEdited;
var client = telegramService.Client;
var chatId = message.Chat.Id;
var fromId = message.From.Id;
var isAdmin = false;
if (IsPrivateChat(telegramService))
{
return(false);
}
if (userId >= 0)
{
fromId = userId;
}
var admins = await client.GetChatAdministratorsAsync(chatId)
.ConfigureAwait(false);
foreach (var admin in admins)
{
if (fromId == admin.User.Id)
{
isAdmin = true;
}
}
Log.Information($"UserId {fromId} IsAdmin: {isAdmin}");
return(isAdmin);
}
public static async Task <Message> SendMessageTextAsync(
this TelegramService telegramService,
MessageResponseDto messageResponseDto
)
{
var sendMessageText = await telegramService.SendTextMessageAsync(
sendText : messageResponseDto.MessageText,
replyMarkup : messageResponseDto.ReplyMarkup,
replyToMsgId : messageResponseDto.ReplyToMessageId.ToInt(),
disableWebPreview : messageResponseDto.DisableWebPreview
);
if (messageResponseDto.ScheduleDeleteAt == default)
{
return(sendMessageText);
}
var currentCommand = telegramService.GetCommand(withoutSlash: true);
var commandFlag = currentCommand.ToEnum(defaultValue: MessageFlag.General);
if (messageResponseDto.IncludeSenderForDelete)
{
telegramService.SaveSenderMessageToHistory(commandFlag, messageResponseDto.ScheduleDeleteAt);
}
telegramService.SaveSentMessageToHistory(commandFlag, messageResponseDto.ScheduleDeleteAt);
return(sendMessageText);
}
private static async Task ScanPhotoAsync(this TelegramService telegramService)
{
var message = telegramService.MessageOrEdited;
var chatId = message.Chat.Id;
var msgId = message.MessageId;
if (message.Photo != null)
{
Log.Information("");
var fileName = $"{chatId}/ocr-{msgId}.jpg";
Log.Information("Preparing photo");
var savedFile = await telegramService.DownloadFileAsync(fileName)
.ConfigureAwait(false);
// var ocr = await TesseractProvider.OcrSpace(savedFile)
// .ConfigureAwait(false);
var ocr = GoogleVision.ScanText(savedFile);
Log.Information("Scanning message..");
var isMustDelete = await IsMustDelete(ocr)
.ConfigureAwait(false);
Log.Information($"Message {message.MessageId} IsMustDelete: {isMustDelete}");
if (isMustDelete)
{
await telegramService.DeleteAsync(message.MessageId)
.ConfigureAwait(false);
}
savedFile.GetDirectory().RemoveFiles("ocr");
}
}
private static async Task ScanMessageAsync(this TelegramService telegramService)
{
var message = telegramService.MessageOrEdited;
var msgId = message.MessageId;
var text = message.Text ?? message.Caption;
if (!text.IsNullOrEmpty())
{
var isMustDelete = await IsMustDelete(text)
.ConfigureAwait(false);
Log.Information($"Message {msgId} IsMustDelete: {isMustDelete}");
if (isMustDelete)
{
await telegramService.DeleteAsync(message.MessageId)
.ConfigureAwait(false);
}
}
else
{
Log.Information("No message Text for scan.");
}
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
var msg = context.Update.Message;
var partsMsg = msg.Text.GetTextWithoutCmd().Split("|").ToArray();
var isSudoer = _telegramService.IsSudoer();
if (isSudoer)
{
var sendText = "Maaf, saya harus keluar";
if (partsMsg[1] != null)
{
sendText += $"\n{partsMsg[1]}";
}
var chatId = partsMsg[0].ToInt64();
Log.Information($"Target out: {chatId}");
await _telegramService.SendTextAsync(sendText, customChatId : chatId)
.ConfigureAwait(false);
await _telegramService.LeaveChat(chatId)
.ConfigureAwait(false);
}
else
{
await _telegramService.SendTextAsync("Kamu tidak punya hak akses.")
.ConfigureAwait(false);
}
}
public static async Task GetRssControlAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
var chatTitle = telegramService.ChatTitle;
await telegramService.DeleteSenderMessageAsync();
if (!await telegramService.CheckUserPermission())
{
return;
}
await telegramService.SendTextMessageAsync("Sedang mengambil RSS..", replyToMsgId : 0);
var buttonMarkup = await telegramService.RssService.GetButtonMarkup(chatId);
var messageText = buttonMarkup == null
? "Sepertinya tidak ada RSS di obrolan ini"
: $"RSS Control for {chatTitle}" +
"\nHalaman 1";
await telegramService.EditMessageTextAsync(
messageText,
buttonMarkup,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(10),
preventDuplicateSend : true
);
}
public async Task UnknownCommandShouldReturnUnknown()
{
// Arrange
//
var telegramBotMock = new Mock <ITelegramBotClient>();
telegramBotMock.Setup(_ => _.SendTextMessageAsync(
It.IsAny <ChatId>(),
It.IsAny <string>(),
It.IsAny <ParseMode>(),
It.IsAny <bool>(),
It.IsAny <bool>(),
It.IsAny <int>(),
It.IsAny <IReplyMarkup>(),
It.IsAny <CancellationToken>()))
.Verifiable();
var telegramService = new TelegramService(
TestHelper.GetLoggerMock <TelegramService>().Object,
telegramBotMock.Object,
new DataConnectionFactory(_connectionSettings));
_mockMessage.Text = "fake message";
// Act
//
await telegramService.OnBotMessage(_mockMessage);
// Assert
//
telegramBotMock.Verify(_ => _.SendTextMessageAsync(
It.IsAny <ChatId>(), It.Is <string>(m => m.Equals("Unknown command")),
ParseMode.Default, false, false, 0, null, default));
}
public static async Task RssPullAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
var checkUserPermission = await telegramService.CheckUserPermission();
if (!checkUserPermission)
{
Log.Warning("You must Admin or Private chat");
return;
}
var jobsService = telegramService.GetRequiredService <JobsService>();
Log.Information("Pulling RSS in {0}", chatId);
#pragma warning disable CS4014
Task.Run(
#pragma warning restore CS4014
async() => {
await telegramService.SendTextMessageAsync("Sedang menjalankan Trigger RSS Job..");
var reducedChatId = telegramService.ReducedChatId;
var recurringId = $"rss-{reducedChatId}";
jobsService.TriggerJobsByPrefix(recurringId);
await telegramService.EditMessageTextAsync(
sendText: "RSS Jobs untuk Obrolan ini berhasil dipicu, artikel baru akan segera masuk jika tersedia.",
scheduleDeleteAt: DateTime.UtcNow.AddMinutes(2),
includeSenderMessage: true
);
}
);
}
private static async Task AnswerInlineQueryAsync(
this TelegramService telegramService,
IEnumerable <InlineQueryResult> inlineQueryResults
)
{
var inlineQuery = telegramService.InlineQuery;
var inlineQueryId = inlineQuery.Id;
var reducedResult = inlineQueryResults.Take(50);
try
{
await telegramService.Client.AnswerInlineQueryAsync(
inlineQueryId : inlineQueryId,
results : reducedResult
);
}
catch (Exception exception)
{
Log.Error(
exception,
"Error when answering inline query: {Id}",
inlineQueryId
);
}
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
_settingsService = new SettingsService(context.Update.Message);
var message = _telegramService.Message;
await _telegramService.DeleteAsync(message.MessageId)
.ConfigureAwait(false);
var adminOrPrivate = await _telegramService.IsAdminOrPrivateChat()
.ConfigureAwait(false);
if (adminOrPrivate)
{
await _telegramService.SendTextAsync("Sedang mengambil pengaturan..")
.ConfigureAwait(false);
var settings = await _settingsService.GetSettingButtonByGroup()
.ConfigureAwait(false);
var btnMarkup = await settings.ToJson().JsonToButton(chunk: 2)
.ConfigureAwait(false);
Log.Debug($"Settings: {settings.Count}");
await _telegramService.EditAsync("Settings Toggles", btnMarkup)
.ConfigureAwait(false);
}
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
var isSudoer = _telegramService.IsSudoer();
if (!isSudoer)
{
return;
}
var param1 = _telegramService.Message.Text.Split(" ").ValueOfIndex(1);
switch (param1)
{
case "migrate":
await _telegramService.SendTextAsync("Migrating ")
.ConfigureAwait(false);
MigrationHelper.MigrateMysql();
MigrationHelper.MigrateSqlite();
await _telegramService.SendTextAsync("Migrate complete ")
.ConfigureAwait(false);
break;
}
}
public static async Task HitActivityAsync(this TelegramService telegramService)
{
Log.Information("Starting Hit Activity");
var message = telegramService.MessageOrEdited;
var botUser = await telegramService.GetMeAsync()
.ConfigureAwait(false);
var data = new Dictionary <string, object>()
{
{ "via_bot", botUser.Username },
{ "message_type", message.Type.ToString() },
{ "from_id", message.From.Id },
{ "from_first_name", message.From.FirstName },
{ "from_last_name", message.From.LastName },
{ "from_username", message.From.Username },
{ "from_lang_code", message.From.LanguageCode },
{ "chat_id", message.Chat.Id },
{ "chat_username", message.Chat.Username },
{ "chat_type", message.Chat.Type.ToString() },
{ "chat_title", message.Chat.Title },
};
var insertHit = await new Query("hit_activity")
.ExecForMysql()
.InsertAsync(data)
.ConfigureAwait(false);
Log.Information($"Insert Hit: {insertHit}");
}
public static async Task<bool> CheckCasBanAsync(this TelegramService telegramService)
{
bool isBan;
Log.Information("Starting check in Cas Ban");
var message = telegramService.MessageOrEdited;
var user = message.From;
// var settingService = new SettingsService(message);
var chatSettings = telegramService.CurrentSetting;
if (!chatSettings.EnableFedCasBan)
{
Log.Information("Fed Cas Ban is disabled in this Group!");
return false;
}
isBan = await user.IsCasBanAsync()
.ConfigureAwait(false);
Log.Information($"{user} is CAS ban: {isBan}");
if (isBan)
{
var sendText = $"{user} is banned in CAS!";
await telegramService.SendTextAsync(sendText)
.ConfigureAwait(false);
await telegramService.KickMemberAsync(user)
.ConfigureAwait(false);
await telegramService.UnbanMemberAsync(user)
.ConfigureAwait(false);
}
return isBan;
}
// GET: MainTest
public async Task <ActionResult> Index()
{
var req = Request.InputStream;
var responsString = new StreamReader(req).ReadToEnd();
var update = JsonConvert.DeserializeObject <update>(responsString);
var message = update.message;
var chat = update.message.chat;
long chatId = chat.id; //chat_Id
string userName = chat.username; //user_name
//get user by chatId if user has existed record in database
try
{
var user = db.Staffs.Where(s => s.chat_id == chatId.ToString()).FirstOrDefault();
if (user == null) //means user not found with this chatId
{
//find user by userName
user = db.Staffs.Where(s => s.userName == userName).FirstOrDefault();
if (user != null)//means user founded with username
{
//set chat Id into user record and save change
user.chat_id = chatId.ToString();
db.SaveChanges();
await API.SendTextMessageAsync(chatId, "شروع دریافت عکس");
var resultProfileUser = await getProfileImageAndSave((int)chatId, _token);
Stream stream = new MemoryStream(ImageArray);
await TelegramService.UploadImage(stream, chatId, "تقدیم به بهسیمایی عزیز");
}
else
{
//send message you are not authorized
}
}
else //mean user found with chatId
{
var resultProfileUser = await getProfileImageAndSave((int)chatId, _token);
Stream stream = new MemoryStream(ImageArray);
await TelegramService.UploadImage(stream, chatId, "تقدیم به بهسیمایی عزیز");
}
}
catch (Exception e)
{
await API.SendTextMessageAsync(chatId, e.Message + "\n" + e.StackTrace + "\n -inner--" + e.InnerException);
throw e;
}
//167344742
//var firstImage = userProfiles.Photos.First();
//var FileString = firstImage[0].FilePath;
//await API.SendPhotoAsync(167344742, userProfiles.Photos[0].First().FileId , "این تویی شیطون ؟");
return(View());
}
public static async Task DeleteCityAsync(this TelegramService telegramService)
{
if (!await telegramService.CheckUserPermission())
{
await telegramService.SendTextMessageAsync(
sendText : "Kamu tidak memiliki akses untuk menghapus tetapan Kota",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
includeSenderMessage : true
);
return;
}
var cityName = telegramService.MessageOrEditedText.GetTextWithoutCmd();
if (cityName.IsNullOrEmpty())
{
await telegramService.SendTextMessageAsync(
sendText : "Kota apa yang mau di hapus?",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
includeSenderMessage : true
);
return;
}
await telegramService.AppendTextAsync("Sedang menghapus Kota");
var chatId = telegramService.ChatId;
var shalatTome = telegramService.GetRequiredService <ShalatTimeService>();
var deleteItem = await shalatTome.DeleteCityAsync(chatId, cityName);
var deleteResult = deleteItem switch
{
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
var isSudoer = _telegramService.IsSudoer();
var isAdmin = await _telegramService.IsAdminGroup()
.ConfigureAwait(false);
if (isSudoer)
{
await _telegramService.DeleteAsync(_telegramService.Message.MessageId)
.ConfigureAwait(false);
await _telegramService.AppendTextAsync("Sedang mengsinkronkan Word Filter")
.ConfigureAwait(false);
await Sync.SyncWordToLocalAsync().ConfigureAwait(false);
await _telegramService.AppendTextAsync("Selesai mengsinkronkan.")
.ConfigureAwait(false);
await _telegramService.DeleteAsync(delay : 3000)
.ConfigureAwait(false);
}
}
private void CallAction()
{
//add ban action here,
String banMessage = "Releasing " + userAffected;
TelegramService.SendMessage(message.Chat.Id, ">insinuant que c'est implémenté");
}
public async Task HandleAsync(IUpdateContext context, UpdateDelegate next, CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
var msg = context.Update.Message;
Log.Information("Media received... ");
var fileId = msg.GetFileId();
var reducedFileId = msg.GetReducedFileId();
// var isBan = await _mediaFilterService.IsExistInCache("file_id", msg.GetReducedFileId());
var isBan = await _mediaFilterService.IsExist("file_id", fileId)
.ConfigureAwait(false);
if (isBan)
{
await _telegramService.DeleteAsync(msg.MessageId)
.ConfigureAwait(false);
}
Log.Information($"Media isBan: {isBan}");
if (BotSettings.HostingEnvironment.IsProduction())
{
await _mediaFilterService.UpdateCacheAsync()
.ConfigureAwait(false);
}
else
{
Log.Information($"Update cache skipped because local Env");
}
Log.Information("Media Filter complete.");
await next(context, cancellationToken).ConfigureAwait(false);
}
public CheckController(ILogger <CheckController> logger, Microsoft.Extensions.Options.IOptionsMonitor <TelegramSettings> telegramSettings,
Services services)
{
_logger = logger;
_telegramService = services.TelegramService;
TelegramSettings = telegramSettings.CurrentValue;
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
var msg = context.Update.Message;
var data = new Dictionary <string, object>()
{
{ "user_id", msg.From.Id },
{ "chat_id", msg.Chat.Id },
{ "is_afk", 1 }
};
var sendText = $"{msg.GetFromNameLink()} Sedang afk.";
if (msg.Text.GetTextWithoutCmd().IsNotNullOrEmpty())
{
var afkReason = msg.Text.GetTextWithoutCmd();
data.Add("afk_reason", afkReason);
sendText += $"\n<i>{afkReason}</i>";
}
await _telegramService.SendTextAsync(sendText)
.ConfigureAwait(false);
await _afkService.SaveAsync(data)
.ConfigureAwait(false);
await _afkService.UpdateCacheAsync()
.ConfigureAwait(false);
}
