public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var isSudoer = _telegramService.IsFromSudo;
await _telegramService.DeleteSenderMessageAsync();
if (!isSudoer)
{
Log.Debug("Only sudo can do Sync Kata!");
return;
}
await _telegramService.AppendTextAsync("Sedang mengsinkronkan Word Filter");
await _wordFilterService.UpdateWordListsCache();
await _telegramService.AppendTextAsync("Selesai mengsinkronkan.");
await _telegramService.DeleteAsync(delay : 3000);
}
public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var chatId = _telegramService.ChatId;
if (!await _telegramService.CheckUserPermission())
{
Log.Warning("This command only for sudo!");
return;
}
await _telegramService.AppendTextAsync("Memulai Job RSS..");
_rssFeedService.UnRegisterRssFeedByChatId(chatId);
var rssSettings = await _rssService.GetRssSettingsAsync(chatId);
var rssCount = rssSettings.Count();
foreach (var rssSetting in rssSettings)
{
var urlFeed = rssSetting.UrlFeed;
_rssFeedService.RegisterUrlFeed(chatId, urlFeed);
}
await _telegramService.AppendTextAsync($"Sebanyak {rssCount} RSS berhasil dimulai");
}
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 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);
}
}
public static async Task DeleteForceSubsChannelAsync(this TelegramService telegramService)
{
await telegramService.DeleteSenderMessageAsync();
if (!await telegramService.CheckFromAdminOrAnonymous())
{
return;
}
var fSubsService = telegramService.GetRequiredService <ForceSubsService>();
var subscriptions = await fSubsService.GetSubsAsync(telegramService.ChatId);
var inlineKeyboard = new List <IEnumerable <InlineKeyboardButton> >();
if (subscriptions.Count == 0)
{
await telegramService.AppendTextAsync(
sendText : "Tidak ada subscription di Grup ini",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1)
);
return;
}
var htmlMessage = HtmlMessage.Empty
.BoldBr("Daftar Subscription")
.TextBr("Pilih Channel untuk dihapus: ");
subscriptions.ForEach(
subscription => {
inlineKeyboard.Add(
new InlineKeyboardButton[]
{
InlineKeyboardButton.WithCallbackData(subscription.ChannelTitle, "fsub delete " + subscription.ChannelId)
}
);
}
);
inlineKeyboard.Add(
new InlineKeyboardButton[]
{
InlineKeyboardButton.WithCallbackData("❌ Batal", "delete-message current-message")
}
);
await telegramService.AppendTextAsync(
sendText : htmlMessage.ToString(),
replyMarkup : inlineKeyboard.ToButtonMarkup(),
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true,
preventDuplicateSend : true
);
}
public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var fromId = _telegramService.FromId;
var chatId = _telegramService.ChatId;
var messageTexts = _telegramService.MessageTextParts;
var reasonBan = messageTexts.ElementAtOrDefault(1) ?? "Import from Bot";
if (!_telegramService.IsFromSudo)
{
await _telegramService.DeleteSenderMessageAsync();
}
var repMessage = _telegramService.ReplyToMessage;
if (repMessage.Type != MessageType.Document)
{
await _telegramService.SendTextMessageAsync("Reply persan dokument untuk Import Global Ban. Biasanya berkas .xsv atau .json");
}
var document = repMessage.Document;
var documentFileName = document.FileName;
await _telegramService.AppendTextAsync("Mengambil berkas..");
var fileName = await _telegramService.DownloadFileAsync("import_gban");
await _telegramService.AppendTextAsync($"Menguraikan berkas {documentFileName}");
var import = await _globalBanService.ImportFile
(
fileName,
new GlobalBanItem()
{
ReasonBan = reasonBan,
BannedBy = fromId,
BannedFrom = chatId
}
);
if (import > 0)
{
await _telegramService.AppendTextAsync($"Sebanyak {import} item berhasil ditambahkan");
}
else
{
await _telegramService.AppendTextAsync($"Semua data sudah ditambahkan");
}
}
public static async Task NoUsernameKickMemberAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
if (telegramService.IsPrivateGroup)
{
await telegramService.SendTextMessageAsync(
"Perintah ini hanya tersedia untuk Grup Publik",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
return;
}
if (!await telegramService.CheckFromAdminOrAnonymous())
{
await telegramService.DeleteSenderMessageAsync();
return;
}
var wTelegramApiService = telegramService.GetRequiredService <WTelegramApiService>();
var chatTitleLink = telegramService.Chat.GetChatNameLink();
var participant = await wTelegramApiService.GetAllParticipants(chatId, disableCache : true);
var allUsers = participant.users.Select(pair => pair.Value).ToList();
var noUsernameUsers = allUsers.Where(user => user.username == null).ToList();
var htmlMessage = HtmlMessage.Empty
.Bold("No Username Kick Member").Br()
.Bold("Chat: ").TextBr(chatTitleLink)
.Bold("Total: ").CodeBr(allUsers.Count.ToString())
.Bold("No Username: "******"Proses selesai.",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
}
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 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 msg = _telegramService.MessageOrEdited;
var keyboard = new InlineKeyboardMarkup(
InlineKeyboardButton.WithCallbackData("Ping", "PONG")
);
await _telegramService.AppendTextAsync("ℹ️ Pong!!").ConfigureAwait(false);
var isSudoer = msg.From.Id.IsSudoer();
if (msg.Chat.Type == ChatType.Private && isSudoer)
{
// await "\n<b>Engine info.</b>".AppendTextAsync();
await _telegramService.AppendTextAsync("🎛 <b>Engine info.</b>").ConfigureAwait(false);
// var getWebHookInfo = await _chatProcessor.Client.GetWebhookInfoAsync(cancellationToken);
var getWebHookInfo = await _telegramService.Client.GetWebhookInfoAsync(cancellationToken)
.ConfigureAwait(false);
if (getWebHookInfo.Url.IsNullOrEmpty())
{
// sendText += "\n\n<i>Bot run in Poll mode.</i>";
await _telegramService.AppendTextAsync("\n<i>Bot run in Poll mode.</i>", keyboard).ConfigureAwait(false);
}
else
{
var hookInfo = "\n<i>Bot run in Webhook mode.</i>" +
$"\nUrl WebHook: {getWebHookInfo.Url}" +
$"\nUrl Custom Cert: {getWebHookInfo.HasCustomCertificate}" +
$"\nAllowed Updates: {getWebHookInfo.AllowedUpdates}" +
$"\nPending Count: {getWebHookInfo.PendingUpdateCount}" +
$"\nMaxConnection: {getWebHookInfo.MaxConnections}" +
$"\nLast Error: {getWebHookInfo.LastErrorDate}" +
$"\nError Message: {getWebHookInfo.LastErrorMessage}";
await _telegramService.AppendTextAsync(hookInfo, keyboard)
.ConfigureAwait(false);
}
}
// await sendText.AppendTextAsync(keyboard);
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
var msg = context.Update.Message;
var isSudoer = _telegramService.IsSudoer();
if (isSudoer)
{
var partedMsg = msg.Text.Split(" ");
var param1 = partedMsg.ValueOfIndex(1);
Log.Debug($"RssCtl Param1: {param1}");
await _telegramService.AppendTextAsync("Access Granted")
.ConfigureAwait(false);
switch (param1)
{
case "start":
await _telegramService.AppendTextAsync("Starting RSS Service")
.ConfigureAwait(false);
RssScheduler.InitScheduler();
await _telegramService.AppendTextAsync("Start successfully.")
.ConfigureAwait(false);
break;
case "stop":
await _telegramService.AppendTextAsync("Stopping RSS Service")
.ConfigureAwait(false);
Tools.Hangfire.DeleteAllJobs();
await _telegramService.AppendTextAsync("Stop successfully.")
.ConfigureAwait(false);
break;
}
}
}
public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var chatId = _telegramService.ChatId;
if (!await _telegramService.CheckUserPermission())
{
Log.Warning("This command only for sudo!");
return;
}
await _telegramService.AppendTextAsync("Mematikan Job RSS..");
var jobCount = _rssFeedService.UnRegisterRssFeedByChatId(chatId);
await _telegramService.AppendTextAsync($"Sebanyak {jobCount} RSS berhasil dimatikan.");
}
public static async Task GetSubsListChannelAsync(this TelegramService telegramService)
{
var fSubsService = telegramService.GetRequiredService <ForceSubsService>();
var subscriptions = await fSubsService.GetSubsAsync(telegramService.ChatId);
if (subscriptions.Count == 0)
{
await telegramService.AppendTextAsync(
sendText : "Tidak ada subscription di Grup ini",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true,
preventDuplicateSend : true
);
return;
}
var htmlMessage = HtmlMessage.Empty
.BoldBr("Daftar Subscription")
.Bold("Jumlah: ").TextBr(subscriptions.Count.ToString());
var inlineKeyboard = new List <IEnumerable <InlineKeyboardButton> >();
subscriptions.ForEach(
subscription => {
inlineKeyboard.Add(
new InlineKeyboardButton[]
{
InlineKeyboardButton.WithUrl(subscription.ChannelTitle, subscription.InviteLink)
}
);
}
);
await telegramService.SendTextMessageAsync(
sendText : htmlMessage.ToString(),
replyMarkup : inlineKeyboard.ToButtonMarkup(),
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
preventDuplicateSend : true,
includeSenderMessage : true
);
}
public static async Task SaveShalatTimeCityAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
var userId = telegramService.FromId;
var inputCity = telegramService.MessageOrEditedText.GetTextWithoutCmd();
if (!await telegramService.CheckUserPermission())
{
await telegramService.SendTextMessageAsync(
sendText : "Untuk waktu Shalat, hanya Admin yang dapat mengatur Kota untuk obrolan ini, " +
"namun kamu bisa mengaturnya di Japri untukmu sendiri.",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
includeSenderMessage : true
);
return;
}
if (inputCity.IsNullOrEmpty())
{
await telegramService.SendTextMessageAsync(
sendText : "Silahkan tulis nama kota yang ingin dicari",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
includeSenderMessage : true
);
return;
}
var fathimahApiService = telegramService.GetRequiredService <FathimahApiService>();
var cities = await fathimahApiService.GetAllCityAsync();
var filteredCity = cities.Kota
.Where(
kota =>
kota.Nama.Contains(inputCity, StringComparison.CurrentCultureIgnoreCase) ||
kota.Id.ToString() == inputCity
)
.ToList();
var filteredCityCount = filteredCity.Count;
var filteredCityStr = filteredCity
.Select(
(
kota,
index
) => $"{index + 1}. <code>{kota.Id}</code> <code>{kota.Nama}</code>"
)
.JoinStr("\n");
var findResult = filteredCity.Count switch
{
0 => "Kota yang di masukkan tidak di temukan, silakan cari kota lain",
> 1 => $"Ditemukan sebanyak {filteredCityCount} kota, silakan pilih salah satu" +
$"\n{filteredCityStr}",
_ => null
};
if (findResult != null)
{
await telegramService.SendTextMessageAsync(
sendText : findResult,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
includeSenderMessage : true
);
return;
}
var shalatTimeService = telegramService.GetRequiredService <ShalatTimeService>();
var shalatTimeNotifyService = telegramService.GetRequiredService <ShalatTimeNotifyService>();
var firstCity = filteredCity.FirstOrDefault();
await telegramService.AppendTextAsync($"<b>Kota/Kab ID: </b><code>{firstCity.Id}</code>");
await telegramService.AppendTextAsync($"<b>Nama: </b><code>{firstCity.Nama}</code>");
if (await shalatTimeService.IsExistAsync(chatId, firstCity.Nama))
{
await telegramService.AppendTextAsync(
sendText : "Sepertinya kota ini sudah ditambahkan",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5)
);
return;
}
await telegramService.AppendTextAsync("Sedang menyimpan data kota");
await shalatTimeService.SaveCityAsync(
new ShalatTime()
{
ChatId = chatId,
UserId = userId,
CityId = firstCity.Id,
CityName = firstCity.Nama,
EnableNotification = true,
CreatedAt = DateTime.UtcNow,
UpdatedAt = DateTime.UtcNow
}
);
shalatTimeNotifyService.RegisterJobShalatTime(chatId);
await telegramService.AppendTextAsync(
sendText : "Kota berhasil disimpan",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
includeSenderMessage : true
);
}
public static async Task AddForceSubsChannelAsync(this TelegramService telegramService)
{
if (!await telegramService.CheckFromAdminOrAnonymous())
{
await telegramService.DeleteSenderMessageAsync();
return;
}
var fSubsService = telegramService.GetRequiredService <ForceSubsService>();
var chatService = telegramService.GetRequiredService <ChatService>();
var channelId = telegramService.GetCommandParamAt <long>(0);
if (channelId == 0)
{
await telegramService.SendTextMessageAsync(
sendText : "Silakan masukkan ID Channel yang ingin ditambahkan",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
return;
}
await telegramService.AppendTextAsync("<b>Force Subscription</b>");
await telegramService.AppendTextAsync($"Channel ID: {channelId}");
try
{
await telegramService.AppendTextAsync("Sedang memeriksa..");
var chat = await chatService.GetChatAsync(channelId);
if (chat.Type != ChatType.Channel)
{
await telegramService.AppendTextAsync("ID diatas bukan sebuah Channel", reappendText : true);
return;
}
await telegramService.AppendTextAsync($"Title: {chat.Title}", reappendText : true);
var fSubData = new ForceSubscription()
{
ChatId = telegramService.ChatId,
UserId = telegramService.FromId,
ChannelId = channelId,
ChannelTitle = chat.Title,
InviteLink = chat.InviteLink,
};
var save = await fSubsService.SaveSubsAsync(fSubData);
var saveMessage = save == 1 ? "Sudah disimpan" : "Berhasil disimpan";
await telegramService.AppendTextAsync(
sendText : saveMessage,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
}
catch (Exception e)
{
var errorMessage = e.Message switch
{
{} a when a.Contains("not found") => $"Channel tidak ditemukan",
_ => "Terjadi kesalahan ketika menyimpan data"
};
await telegramService.AppendTextAsync(
errorMessage,
reappendText : true,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
}
}
public static async Task AddRssUrlAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
var fromId = telegramService.FromId;
var checkUserPermission = await telegramService.CheckUserPermission();
if (!checkUserPermission)
{
Log.Warning("Modify RSS only for admin or private chat!");
await telegramService.DeleteSenderMessageAsync();
return;
}
var rssUrl = telegramService.GetCommandParamAt <string>(0);
if (rssUrl.IsNullOrEmpty())
{
await telegramService.SendTextMessageAsync("Apa url Feednya?");
return;
}
rssUrl = rssUrl.TryFixRssUrl();
await telegramService.AppendTextAsync($"URL: {rssUrl}");
if (!rssUrl.CheckUrlValid())
{
await telegramService.AppendTextAsync("Url tersebut sepertinya tidak valid");
return;
}
await telegramService.AppendTextAsync($"Memeriksa RSS Feed");
var isValid = await rssUrl.IsValidUrlFeed();
if (!isValid)
{
var baseUrl = rssUrl.GetBaseUrl();
await telegramService.AppendTextAsync("Mencari kemungkinan RSS Feed yang valid");
var foundUrl = await baseUrl.FindUrlFeed();
Log.Debug("Found URL Feed: {FoundUrl}", foundUrl);
if (foundUrl.IsNotNullOrEmpty())
{
await telegramService.AppendTextAsync("Menemukan: " + foundUrl);
rssUrl = foundUrl;
}
else
{
var notFoundRss = $"Kami tidak dapat memvalidasi {rssUrl} adalah Link RSS yang valid, " +
$"dan mencoba mencari di {baseUrl} tetap tidak dapat menemukan.";
await telegramService.EditMessageTextAsync(notFoundRss);
return;
}
}
var rssService = telegramService.GetRequiredService <RssService>();
var rssFeedService = telegramService.GetRequiredService <RssFeedService>();
var isFeedExist = await rssService.IsRssExist(chatId, rssUrl);
Log.Information("Is Url Exist: {IsFeedExist}", isFeedExist);
if (!isFeedExist)
{
await telegramService.AppendTextAsync($"Sedang menyimpan..");
var data = new Dictionary <string, object>()
{
{ "url_feed", rssUrl },
{ "chat_id", chatId },
{ "from_id", fromId }
};
await rssService.SaveRssSettingAsync(data);
await telegramService.AppendTextAsync("Memastikan Scheduler sudah berjalan");
rssFeedService.RegisterUrlFeed(chatId, rssUrl);
await telegramService.AppendTextAsync($"Tautan berhasil di simpan");
}
else
{
await telegramService.AppendTextAsync($"Tautan sudah di simpan");
}
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
var kickTargets = new List <User>();
var msg = context.Update.Message;
Message repMsg = null;
var fromId = msg.From.Id;
// var idTargets = new List<int>();
kickTargets.Add(msg.From);
if (msg.ReplyToMessage != null)
{
repMsg = msg.ReplyToMessage;
// idTarget = repMsg.From.id;
kickTargets.Add(repMsg.From);
if (repMsg.NewChatMembers != null)
{
kickTargets.Clear();
var userTargets = repMsg.NewChatMembers;
kickTargets.AddRange(userTargets);
// foreach (var target in userTargets)
// {
// idTargets.Add(target.Id);
// }
}
}
await _telegramService.DeleteAsync(msg.MessageId)
.ConfigureAwait(false);
var isAdmin = await _telegramService.IsAdminGroup()
.ConfigureAwait(false);
if (kickTargets[0].Id != msg.From.Id && isAdmin)
{
var isKicked = false;
foreach (var target in kickTargets)
{
var idTarget = target.Id;
var sendText = string.Empty;
// await _chatProcessor.AppendTextAsync($"Sedang menendang {idTarget}");
isKicked = await _telegramService.KickMemberAsync(target)
.ConfigureAwait(false);
await _telegramService.UnbanMemberAsync(target)
.ConfigureAwait(false);
if (isKicked)
{
sendText = $"{target} berhasil di tendank ";
sendText += idTarget == fromId ? $"oleh Self-kick" : $".";
}
else
{
sendText = $"Gagal menendang {idTarget}";
}
await _telegramService.AppendTextAsync(sendText)
.ConfigureAwait(false);
}
if (isKicked)
{
await _telegramService.AppendTextAsync($"Sebanyak {kickTargets.Count} berhasil di tendang.")
.ConfigureAwait(false);
}
else
{
await _telegramService.AppendTextAsync("Gagal menendang bbrp anggota")
.ConfigureAwait(false);
}
}
else if (kickTargets[0].Id == fromId)
{
var idTarget = kickTargets[0];
var isKicked = false;
// await _chatProcessor.AppendTextAsync($"Sedang menendang {idTarget}");
isKicked = await _telegramService.KickMemberAsync(idTarget)
.ConfigureAwait(false);
if (isKicked)
{
var sendText = $"{idTarget} berhasil di tendang ";
sendText += idTarget.Id == fromId ? $"oleh Self-kick" : $".";
await _telegramService.AppendTextAsync(sendText)
.ConfigureAwait(false);
}
else
{
var sendTexts = $"Tendang {idTarget} gagal.";
await _telegramService.SendTextAsync(sendTexts)
.ConfigureAwait(false);
}
}
else
{
await _telegramService.SendTextAsync("Hanya admin yang bisa mengeksekusi")
.ConfigureAwait(false);
}
}
public static async Task InactiveKickMemberAsync(this TelegramService telegramService)
{
if (!await telegramService.CheckFromAdminOrAnonymous())
{
await telegramService.SendTextMessageAsync(
"Kamu tidak mempunyai akses ke fitur ini.",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
return;
}
var wTelegramApiService = telegramService.GetRequiredService <WTelegramApiService>();
var chatId = telegramService.ChatId;
var param1 = telegramService.GetCommandParam(0);
if (param1.IsNullOrEmpty())
{
await telegramService.SendTextMessageAsync(
"Tentukan berapa lama durasi tidak aktif, misal 3d.",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(10),
includeSenderMessage : true
);
return;
}
try
{
var timeOffset = param1.ToTimeSpan();
if (timeOffset < TimeSpan.FromDays(1))
{
await telegramService.SendTextMessageAsync(
"Terlalu banyak Anggota yang bakal ditendang, silakan tentukan waktu yang lebih lama, misal 3d.",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(10),
includeSenderMessage : true
);
return;
}
var channelsChannelParticipants = await wTelegramApiService.GetAllParticipants(chatId, disableCache : true);
var allParticipants = channelsChannelParticipants.users;
var inactiveParticipants = allParticipants.Values
.Where(
user =>
user.LastSeenAgo > timeOffset &&
user.bot_info_version == 0
)
.ToList();
var htmlMessage = HtmlMessage.Empty
.Bold("Inactive Kick Member").Br()
.Bold("Total: ").CodeBr(allParticipants.Count.ToString())
.Bold("Inactive: ").CodeBr(inactiveParticipants.Count.ToString());
await telegramService.AppendTextAsync(htmlMessage.ToString());
await inactiveParticipants.AsyncParallelForEach(
maxDegreeOfParallelism : 20,
body : async user => {
await telegramService.KickMemberAsync(user.ID, unban: true);
}
);
await telegramService.AppendTextAsync(
"Selesai.",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
}
catch (Exception exception)
{
await telegramService.SendTextMessageAsync(
"Suatu kesalah telah terjadi." +
"\nError: " +
exception.Message
);
Log.Error(
exception,
"Error Inactive Kick Member at {ChatId}",
chatId
);
}
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args)
{
await _telegramService.AddUpdateContext(context);
var param1 = _telegramService.MessageTextParts.ValueOfIndex(1);
var param2 = _telegramService.MessageTextParts.ValueOfIndex(2);
var chatId = _telegramService.ChatId;
var chatType = _telegramService.Message.Chat.Type;
var fromId = _telegramService.FromId;
var msg = _telegramService.Message;
var msgId = msg.MessageId;
if (!_telegramService.IsFromSudo)
{
Log.Warning("Test only for Sudo!");
return;
}
Log.Information("Adding easy caching..");
await _easyCachingProvider.SetAsync(msgId.ToString(), msg, TimeSpan.FromMinutes(1));
Log.Information("Test started..");
await _telegramService.AppendTextAsync("Sedang mengetes sesuatu");
if (param1.IsNullOrEmpty())
{
await _telegramService.AppendTextAsync("No Test Param");
return;
}
await _telegramService.AppendTextAsync($"Flags: {param1}");
switch (param1)
{
case "ex-keyboard":
await ExtractReplyMarkup();
break;
// case "mk-remove-all":
// MonkeyCacheRemoveAll();
// break;
// case "mk-remove-expires":
// MonkeyCacheRemoveExpires();
// break;
// case "mk-view-all":
// MonkeyCacheViewAll();
// break;
// case "mk-save-current":
// MonkeyCacheSaveCurrent();
// break;
case "ml-nlp":
MachineLearningProcessNlp();
break;
case "ml-predict":
await MachineLearningPredict();
break;
case "nsfw-detect":
await NsfwDetect();
break;
case "ldb-save-current":
await LiteDbSaveCurrent();
break;
case "sysinfo":
await GetSysInfo();
break;
case "uniqid-gen":
var id = StringUtil.GenerateUniqueId(param2.ToInt());
await _telegramService.AppendTextAsync($"UniqueID: {id}");
break;
case "wh-check":
await WebhookCheck();
break;
case "dl-gen":
var directLink = await DirectLinkParser(param2);
await _telegramService.AppendTextAsync($"DL: {directLink}");
break;
case "parse-bl":
var url = "https://raw.githubusercontent.com/mhhakim/pihole-blocklist/master/p**n.txt";
var listUrl = await _blockListService.ParseList(url);
var msgText = $"{listUrl.Name}" +
$"\n{listUrl.Source}" +
$"\n{listUrl.LastUpdate}" +
$"\n{listUrl.DomainCount}";
await _telegramService.AppendTextAsync($"{msgText}");
break;
default:
await _telegramService.AppendTextAsync($"Feature '{param1}' is not available.");
Log.Warning("Feature '{0}' is not available", param1);
break;
}
await _telegramService.AppendTextAsync("Complete");
}
public static async Task AddGlobalBanUserAsync(this TelegramService telegramService)
{
long userId;
string reason;
var message = telegramService.Message;
var chatId = telegramService.ChatId;
var fromId = telegramService.FromId;
var partedText = telegramService.MessageTextParts;
var param0 = partedText.ElementAtOrDefault(0) ?? "";
var param1 = partedText.ElementAtOrDefault(1) ?? "";
await telegramService.DeleteSenderMessageAsync();
if (!telegramService.IsFromSudo)
{
return;
}
if (telegramService.ReplyToMessage != null)
{
var replyToMessage = telegramService.ReplyToMessage;
userId = replyToMessage.From.Id;
reason = message.Text;
if (replyToMessage.ForwardFrom != null)
{
userId = replyToMessage.ForwardFrom.Id;
}
if (reason.IsNotNullOrEmpty())
{
reason = partedText.Skip(1).JoinStr(" ").Trim();
}
}
else
{
if (param1.IsNullOrEmpty())
{
await telegramService.SendTextMessageAsync(
sendText : "Balas seseorang yang mau di ban",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
return;
}
userId = param1.ToInt64();
reason = message.Text;
if (reason.IsNotNullOrEmpty())
{
reason = partedText.Skip(2).JoinStr(" ").Trim();
}
}
Log.Information("Execute Global Ban");
await telegramService.AppendTextAsync($"<b>Global Ban</b>", replyToMsgId : 0);
await telegramService.AppendTextAsync($"Telegram UserId: <code>{userId}</code>");
if (await telegramService.CheckFromAdmin(userId))
{
await telegramService.AppendTextAsync($"Tidak dapat melakukan Global Ban kepada Admin");
return;
}
reason = reason.IsNullOrEmpty() ? "General SpamBot" : reason;
var banData = new GlobalBanItem()
{
UserId = userId,
BannedBy = fromId,
BannedFrom = chatId,
ReasonBan = reason
};
var globalBanService = telegramService.GetRequiredService <GlobalBanService>();
var eventLogService = telegramService.GetRequiredService <EventLogService>();
var isGlobalBanned = await globalBanService.IsExist(userId);
if (isGlobalBanned)
{
await telegramService.AppendTextAsync(
sendText : "Pengguna sudah di ban",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(2),
includeSenderMessage : true
);
return;
}
if (telegramService.ReplyToMessage?.ForwardFrom == null)
{
var messageId = telegramService.ReplyToMessage?.MessageId ?? -1;
if (telegramService.ReplyToMessage == null)
{
messageId = -1;
}
else
{
await telegramService.KickMemberAsync(userId, untilDate : DateTime.Now.AddSeconds(30));// Kick and Unban after 8 hours
}
var messageLog = HtmlMessage.Empty
.TextBr("Global Ban di tambahkan baru")
.Bold("UserId: ").CodeBr(userId.ToString());
await Task.WhenAll(
eventLogService.SendEventLogAsync(
chatId: chatId,
message: message,
text: messageLog.ToString(),
forwardMessageId: messageId,
deleteForwardedMessage: true,
messageFlag: MessageFlag.GBan
)
);
}
var save = await globalBanService.SaveBanAsync(banData);
await telegramService.AppendTextAsync($"Alasan: {reason}");
Log.Information("SaveBan: {Save}", save);
await globalBanService.UpdateCache(userId);
await telegramService.AppendTextAsync(
sendText : "Pengguna berhasil di tambahkan",
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(2),
includeSenderMessage : true
);
}
public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var chatId = _telegramService.ChatId;
var fromId = _telegramService.FromId;
var messageTextParts = _telegramService.MessageTextParts;
var word = messageTextParts.ElementAtOrDefault(1) ?? string.Empty;
var paramOption = messageTextParts.ElementAtOrDefault(2) ?? string.Empty;
var isGlobalBlock = false;
var isSudoer = _telegramService.IsFromSudo;
if (!isSudoer)
{
await _telegramService.DeleteSenderMessageAsync();
Log.Information("Currently add Kata is limited only Sudo");
return;
}
if (word.IsValidUrl())
{
word = word.ParseUrl().Path;
}
var where = new Dictionary <string, object>()
{
{ "word", word }
};
if (paramOption.IsContains("-"))
{
if (paramOption.IsContains("g"))// Global
{
isGlobalBlock = true;
await _telegramService.AppendTextAsync("Kata ini akan di blokir Global!");
}
}
if (!paramOption.IsContains("g"))
{
@where.Add("chat_id", chatId);
}
if (!word.IsNotNullOrEmpty())
{
await _telegramService.SendTextMessageAsync("Apa kata yg mau di blok?");
}
else
{
var isExist = await _wordFilterService.IsExistAsync(@where);
if (isExist)
{
await _telegramService.AppendTextAsync("Kata sudah di tambahkan");
}
else
{
await _telegramService.AppendTextAsync("Sedang menambahkan kata");
await _wordFilterService.SaveWordAsync(new WordFilter()
{
Word = word,
ChatId = chatId,
IsGlobal = isGlobalBlock,
FromId = fromId,
CreatedAt = DateTime.Now
});
await _telegramService.AppendTextAsync("Kata berhasil di tambahkan");
await _wordFilterService.UpdateWordListsCache();
}
}
await _telegramService.DeleteAsync(delay : 3000);
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
_rssService = new RssService(_telegramService.Message);
var chatId = _telegramService.Message.Chat.Id;
var url = _telegramService.Message.Text.GetTextWithoutCmd();
if (url != null)
{
await _telegramService.AppendTextAsync($"URL: {url}");
if (url.CheckUrlValid())
{
await _telegramService.AppendTextAsync($"Sedang mengecek apakah berisi RSS");
var isValid = await url.IsValidUrlFeed();
if (!isValid)
{
await _telegramService.AppendTextAsync("Sedang mencari kemungkinan tautan RSS yang valid");
var foundUrl = await url.GetBaseUrl().FindUrlFeed();
Log.Information($"Found URL Feed: {foundUrl}");
if (foundUrl != "")
{
url = foundUrl;
}
else
{
var notfoundRss = $"Kami tidak dapat memvalidasi {url} adalah Link RSS yang valid, " +
$"dan mencoba mencari di {url.GetBaseUrl()} tetap tidak dapat menemukan.";
await _telegramService.EditAsync(notfoundRss);
return;
}
}
var isFeedExist = await _rssService.IsExistRssAsync(url);
Log.Information($"Is Url Exist: {isFeedExist}");
if (!isFeedExist)
{
await _telegramService.AppendTextAsync($"Sedang menyimpan..");
var data = new Dictionary <string, object>()
{
{ "url_feed", url },
{ "chat_id", _telegramService.Message.Chat.Id },
{ "from_id", _telegramService.Message.From.Id }
};
await _rssService.SaveRssSettingAsync(data);
await _telegramService.AppendTextAsync("Memastikan Scheduler sudah berjalan");
chatId.RegisterScheduler();
await _telegramService.AppendTextAsync($"Tautan berhasil di simpan");
}
else
{
await _telegramService.AppendTextAsync($"Tautan sudah di simpan");
}
}
else
{
await _telegramService.AppendTextAsync("Url tersebut sepertinya tidak valid");
}
}
else
{
await _telegramService.SendTextAsync("Apa url Feednya?");
}
}
public override async Task HandleAsync(IUpdateContext context, UpdateDelegate next, string[] args,
CancellationToken cancellationToken)
{
_telegramService = new TelegramService(context);
_wordFilterService = new WordFilterService(context.Update.Message);
var msg = context.Update.Message;
var cleanedMsg = msg.Text.GetTextWithoutCmd();
var partedMsg = cleanedMsg.Split(" ");
var paramOption = partedMsg.ValueOfIndex(1) ?? "";
var word = partedMsg.ValueOfIndex(0);
var isGlobalBlock = false;
var isSudoer = _telegramService.IsSudoer();
var isAdmin = await _telegramService.IsAdminGroup()
.ConfigureAwait(false);
if (!isSudoer && !isAdmin)
{
return;
}
if (word.IsValidUrl())
{
word = word.ParseUrl().Path;
}
var where = new Dictionary <string, object>()
{
{ "word", word }
};
if (paramOption.IsContains("-"))
{
if (paramOption.IsContains("g") && isSudoer) // Global
{
isGlobalBlock = true;
await _telegramService.AppendTextAsync("Kata ini akan di blokir Global!")
.ConfigureAwait(false);
}
if (paramOption.IsContains("d"))
{
}
if (paramOption.IsContains("c"))
{
}
}
if (!paramOption.IsContains("g"))
{
@where.Add("chat_id", msg.Chat.Id);
}
if (!isSudoer)
{
await _telegramService.AppendTextAsync("Hanya Sudoer yang dapat memblokir Kata mode Group-wide!")
.ConfigureAwait(false);
}
if (word.IsNotNullOrEmpty())
{
await _telegramService.AppendTextAsync("Sedang menambahkan kata")
.ConfigureAwait(false);
var isExist = await _wordFilterService.IsExistAsync(@where)
.ConfigureAwait(false);
if (!isExist)
{
var save = await _wordFilterService.SaveWordAsync(word, isGlobalBlock)
.ConfigureAwait(false);
await _telegramService.AppendTextAsync("Kata berhasil di tambahkan")
.ConfigureAwait(false);
}
else
{
await _telegramService.AppendTextAsync("Kata sudah di tambahkan")
.ConfigureAwait(false);
}
}
else
{
await _telegramService.SendTextAsync("Apa kata yg mau di blok?")
.ConfigureAwait(false);
}
await _telegramService.DeleteAsync(delay : 3000)
.ConfigureAwait(false);
}
public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var msg = _telegramService.Message;
var msgId = msg.MessageId;
var chatId = _telegramService.ChatId;
var fromId = _telegramService.FromId;
var dateDate = DateTime.UtcNow.ToString("yyyy-MM-dd");
if (!await _telegramService.CheckUserPermission())
{
var send = "Maaf, hanya Admin yang dapat mengimport daftar RSS";
await _telegramService.SendTextMessageAsync(send);
return;
}
await _telegramService.AppendTextAsync("Sedang mempersiapkan");
var filePath = $"{chatId}/rss-feed_{dateDate}_{msgId}";
filePath = await _telegramService.DownloadFileAsync(filePath);
await _telegramService.AppendTextAsync("Sedang membuka berkas");
var rssLists = await File.ReadAllLinesAsync(filePath);
foreach (var rssList in rssLists)
{
Log.Information("Importing {RssList}", rssList);
var data = new Dictionary <string, object>()
{
{ "url_feed", rssList },
{ "chat_id", chatId },
{ "from_id", fromId }
};
await _rssService.SaveRssSettingAsync(data);
}
await _telegramService.AppendTextAsync($"Memeriksa RSS duplikat");
var dedupe = await _rssService.DeleteDuplicateAsync();
await _telegramService.AppendTextAsync("Memastikan RSS Scheduler berjalan");
_rssFeedService.ReRegisterRssFeedByChatId(chatId);
var importCount = rssLists.Length;
if (dedupe != importCount)
{
var diff = importCount - dedupe;
await _telegramService.AppendTextAsync($"{diff} RSS berhasil di import");
}
else
{
await _telegramService.AppendTextAsync($"RSS telah di import");
}
}
public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
await _telegramService.DeleteSenderMessageAsync();
if (!await _telegramService.CheckFromAdminOrAnonymous())
{
return;
}
var kickTargets = new List <User>();
var msg = _telegramService.Message;
var fromId = _telegramService.FromId;
kickTargets.Add(msg.From);
if (msg.ReplyToMessage != null)
{
kickTargets.Clear();
var repMsg = msg.ReplyToMessage;
kickTargets.Add(repMsg.From);
if (repMsg.NewChatMembers != null)
{
kickTargets.AddRange(repMsg.NewChatMembers);
}
}
var containFromId = kickTargets.Where
(
(
user,
i
) => user.Id == fromId
).Any();
if (!containFromId)
{
Log.Warning("No privilege for execute this command!");
return;
}
var sbKickResult = new StringBuilder($"Sedang menendang {kickTargets.Count} pengguna..");
sbKickResult.AppendLine();
foreach (var userId in kickTargets.Select(kickTarget => kickTarget.Id))
{
var isKicked = await _telegramService.KickMemberAsync(userId, true);
if (isKicked)
{
sbKickResult.Append($"{userId} berhasil di tendang ");
sbKickResult.AppendLine(userId == fromId ? $"oleh Self-kick" : "");
}
else
{
sbKickResult.AppendLine($"Gagal menendang {userId}");
}
}
await _telegramService.AppendTextAsync(sbKickResult.ToTrimmedString());
}
