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 async Task <bool> ExecuteToggleAsync()
{
Log.Information("Processing Setting Callback.");
var chatId = _callbackQuery.Message.Chat.Id;
var fromId = _callbackQuery.From.Id;
var msgId = _callbackQuery.Message.MessageId;
if (!await _telegramService.CheckFromAdminOrAnonymous())
{
Log.Information("He is not admin.");
return(false);
}
var callbackData = _callbackQuery.Data;
var partedData = callbackData.Split(" ");
var callbackParam = partedData.ValueOfIndex(1);
var partedParam = callbackParam.Split("_");
var valueParamStr = partedParam.ValueOfIndex(0);
var keyParamStr = callbackParam.Replace(valueParamStr, "");
var currentVal = valueParamStr.ToBoolInt();
Log.Information("Param : {KeyParamStr}", keyParamStr);
Log.Information("CurrentVal : {CurrentVal}", currentVal);
var columnTarget = "enable" + keyParamStr;
var newValue = currentVal == 0 ? 1 : 0;
Log.Information(
"Column: {ColumnTarget}, Value: {CurrentVal}, NewValue: {NewValue}",
columnTarget,
currentVal,
newValue
);
var data = new Dictionary <string, object>()
{
["chat_id"] = chatId,
[columnTarget] = newValue
};
await _settingsService.SaveSettingsAsync(data);
var settingBtn = await _settingsService.GetSettingButtonByGroup(chatId);
var btnMarkup = await settingBtn.ToJson().JsonToButton(chunk: 2);
Log.Debug("Settings: {Count}", settingBtn.Count);
_telegramService.SentMessageId = msgId;
var editText = $"Settings Toggles" +
$"\nParam: {columnTarget} to {newValue}";
await _telegramService.EditMessageCallback(editText, btnMarkup);
await _settingsService.UpdateCacheAsync(chatId);
return(true);
}
public static async Task PinMessageAsync(this TelegramService telegramService)
{
var client = telegramService.Client;
var message = telegramService.MessageOrEdited;
var chatId = telegramService.ChatId;
await telegramService.DeleteSenderMessageAsync();
if (!await telegramService.CheckFromAdminOrAnonymous())
{
Log.Warning("Pin message only for Admin on Current Chat");
return;
}
if (message.ReplyToMessage == null)
{
// var messageId = message.ReplyToMessage.MessageId;
//
// await client.UnpinChatMessageAsync(chatId, messageId);
// await client.PinChatMessageAsync(chatId, messageId);
await telegramService.SendTextMessageAsync(
sendText : "Balas pesan yang akan di pin",
replyToMsgId : message.MessageId,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
preventDuplicateSend : true
);
return;
}
var replyToMessage = telegramService.ReplyToMessage;
var replyToMessageId = replyToMessage.MessageId;
var inlineKeyboard = new InlineKeyboardMarkup(
new[]
{
new[]
{
InlineKeyboardButton.WithCallbackData("🔔 Beri tahu", $"pin-message {replyToMessageId} notify"),
InlineKeyboardButton.WithCallbackData("🔕 Senyap", $"pin-message {replyToMessageId} silent")
},
new[]
{
InlineKeyboardButton.WithCallbackData("❌ Tutup", $"delete-message current-message")
}
}
);
const string sendText = "Apakah Anda ingin beri tahu Anggota saat menyematkan pesan ini?";
await telegramService.SendTextMessageAsync(
sendText,
replyToMsgId : message.MessageId,
replyMarkup : inlineKeyboard,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
preventDuplicateSend : true
);
}
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 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 override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var msg = _telegramService.Message;
var chatId = _telegramService.ChatId;
if (!await _telegramService.CheckFromAdminOrAnonymous())
{
return;
}
if (msg.ReplyToMessage == null)
{
await _telegramService.SendTextMessageAsync("Balas sebuah gambar, video, atau dokumen yang akan di jadikan Welcome media");
return;
}
var repMsg = msg.ReplyToMessage;
var mediaFileId = repMsg.GetFileId();
if (mediaFileId.IsNotNullOrEmpty())
{
var mediaType = repMsg.Type;
await _telegramService.SendTextMessageAsync("Sedang menyimpan Welcome Media..");
Log.Information("MediaId: {MediaFileId}", mediaFileId);
await _settingsService.UpdateCell(chatId, "welcome_media", mediaFileId);
await _settingsService.UpdateCell(chatId, "welcome_media_type", mediaType);
Log.Information("Save media success..");
await _telegramService.EditMessageTextAsync
(
"Welcome Media berhasil di simpan." +
"\nKetik /welcome untuk melihat perubahan"
);
}
else
{
await _telegramService.SendTextMessageAsync("Media tidak terdeteksi di pesan yg di reply tersebut.");
}
}
public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var msg = _telegramService.Message;
if (msg.ReplyToMessage == null)
{
var sendText = "ℹ️ <b>Balas</b> pesan yang mau di laporkan" +
"\n\n<b>Catatan:</b> GReport (Global Report) akan melaporkan pengguna ke Tim @WinTenDev " +
"dan memanggil admin di Grup ini.";
await _telegramService.SendTextMessageAsync(sendText);
}
else
{
var chatTitle = msg.Chat.Title;
var chatId = msg.Chat.Id;
var from = msg.From;
var reason = msg.Text.GetTextWithoutCmd();
var repMsg = msg.ReplyToMessage;
var repFrom = repMsg.From;
var msgBuild = new StringBuilder();
msgBuild.AppendLine("‼️ <b>Global Report</b>");
msgBuild.AppendLine($"<b>ChatTitle:</b> {chatTitle}");
msgBuild.AppendLine($"<b>ChatID:</b> {chatId}");
msgBuild.AppendLine($"<b>Reporter:</b> {@from}");
msgBuild.AppendLine($"<b>Reported:</b> {repFrom}");
msgBuild.AppendLine($"<b>Reason:</b> {reason}");
msgBuild.AppendLine($"\nTerima kasih sudah melaporkan!");
var mentionAdmin = await _telegramService.GetMentionAdminsStr();
if (!await _telegramService.CheckFromAdminOrAnonymous())
{
msgBuild.AppendLine(mentionAdmin);
}
var sendText = msgBuild.ToTrimmedString();
await _telegramService.ForwardMessageAsync(repMsg.MessageId);
await _telegramService.SendTextMessageAsync(sendText);
}
}
public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var msg = _telegramService.Message;
var chatId = _telegramService.ChatId;
if (!await _telegramService.CheckFromAdminOrAnonymous())
{
return;
}
var columnTarget = $"welcome_message";
var data = msg.CloneText().GetTextWithoutCmd();
if (msg.ReplyToMessage != null)
{
data = msg.ReplyToMessage.CloneText();
}
if (data.IsNullOrEmpty())
{
await _telegramService.SendTextMessageAsync($"Silakan masukan konfigurasi Pesan yang akan di terapkan");
return;
}
await _telegramService.SendTextMessageAsync($"Sedang menyimpan Welcome Message..");
await _settingsService.UpdateCell(
chatId,
columnTarget,
data
);
await _telegramService.EditMessageTextAsync
(
$"Welcome Button berhasil di simpan!" +
$"\nKetik /welcome untuk melihat perubahan"
);
Log.Information("Success save welcome Message on {ChatId}.", chatId);
}
public static async Task <bool> OnCallbackForceSubAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
Log.Information("Receiving Ping callback");
if (!await telegramService.CheckFromAdminOrAnonymous())
{
await telegramService.AnswerCallbackQueryAsync("Kamu tidak memiliki izin untuk melakukan tidakan!", true);
return(true);
}
var fSubsService = telegramService.GetRequiredService <ForceSubsService>();
var callbackAction = telegramService.GetCallbackDataAt <string>(1);
var channelId = telegramService.GetCallbackDataAt <long>(2);
await fSubsService.DeleteSubsAsync(chatId, channelId);
await telegramService.EditMessageCallback("Channel berhasil dihapus dari daftar subs!");
return(true);
}
public static async Task <AntiSpamResult> AntiSpamCheckAsync(this TelegramService telegramService)
{
var fromId = telegramService.FromId;
var chatId = telegramService.ChatId;
var defaultResult = new AntiSpamResult
{
UserId = fromId,
MessageResult = string.Empty,
IsAnyBanned = false,
IsEs2Banned = false,
IsCasBanned = false,
IsSpamWatched = false
};
if (telegramService.IsPrivateChat ||
telegramService.MessageOrEdited == null ||
telegramService.CheckFromAnonymous() ||
telegramService.CheckSenderChannel())
{
return(defaultResult);
}
if (await telegramService.CheckFromAdminOrAnonymous())
{
return(defaultResult);
}
var message = telegramService.MessageOrEdited;
var antiSpamResult = await telegramService.AntiSpamService.CheckSpam(chatId, fromId);
if (antiSpamResult == null)
{
return(null);
}
var messageBan = antiSpamResult.MessageResult;
if (!antiSpamResult.IsAnyBanned)
{
return(antiSpamResult);
}
await Task.WhenAll(
telegramService.KickMemberAsync(
userId: fromId,
unban: false,
untilDate: DateTime.Now.AddMinutes(1)
),
telegramService.SendTextMessageAsync(
sendText: messageBan,
replyToMsgId: 0,
disableWebPreview: true,
scheduleDeleteAt: DateTime.UtcNow.AddDays(1),
preventDuplicateSend: true,
messageFlag: MessageFlag.GBan
),
telegramService.EventLogService.SendEventLogAsync(
text: messageBan,
chatId: chatId,
message: message,
messageFlag: MessageFlag.GBan,
forwardMessageId: message.MessageId,
deleteForwardedMessage: true
)
);
await telegramService.DeleteMessageManyAsync();
return(antiSpamResult);
}
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 <bool> ScanMessageAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
try
{
if (telegramService.IsGlobalIgnored())
{
return(false);
}
var message = telegramService.MessageOrEdited;
var eventLogService = telegramService.GetRequiredService <EventLogService>();
var wordFilterService = telegramService.GetRequiredService <WordFilterService>();
if (message == null)
{
return(false);
}
var messageId = message.MessageId;
var chatSettings = await telegramService.GetChatSetting();
if (!chatSettings.EnableWordFilterGroupWide)
{
Log.Debug("Word Filter on {ChatId} is disabled!", chatId);
return(false);
}
if (await telegramService.CheckFromAdminOrAnonymous())
{
Log.Debug("Scan Message disabled for Administrator. ChatId: {ChatId}", chatId);
return(false);
}
var textToScan = telegramService.MessageOrEdited.CloneText(true);
var scanMedia = await telegramService.ScanMediaAsync();
textToScan += "\n\n" + scanMedia;
if (telegramService.IsFromSudo &&
(
textToScan.StartsWith("/dkata") ||
textToScan.StartsWith("/delkata") ||
textToScan.StartsWith("/kata")))
{
Log.Debug("Seem User will modify Kata!");
return(false);
}
var result = await wordFilterService.IsMustDelete(textToScan);
var isShouldDelete = result.IsSuccess;
if (isShouldDelete)
{
Log.Information("Starting scan image if available..");
}
Log.Information(
"Message {MsgId} IsMustDelete: {IsMustDelete}",
messageId,
isShouldDelete
);
if (!isShouldDelete)
{
return(false);
}
Log.Debug(
"Scan Message at ChatId: {ChatId}. Result: {@V}",
chatId,
result
);
var note = "Pesan dihapus karena terdeteksi filter Kata." +
$"\n{result.Notes}";
await eventLogService.SendEventLogAsync(
chatId : chatId,
message : message,
text : note,
messageFlag : MessageFlag.BadWord,
forwardMessageId : messageId,
deleteForwardedMessage : true
);
await telegramService.DeleteAsync(messageId);
return(true);
}
catch (Exception exception)
{
Log.Error(
exception,
"Error occured when Scan Message at ChatId {ChatId}",
chatId
);
return(false);
}
}
public override async Task HandleAsync(
IUpdateContext context,
UpdateDelegate next,
string[] args
)
{
await _telegramService.AddUpdateContext(context);
var deleteAt = DateTime.UtcNow.AddMinutes(5);
var chatId = _telegramService.ChatId;
var fromId = _telegramService.FromId;
var message = _telegramService.MessageOrEdited;
if (_telegramService.IsPrivateChat)
{
await _telegramService.DeleteSenderMessageAsync();
return;
}
if (!await _telegramService.CheckFromAdminOrAnonymous())
{
await _telegramService.DeleteSenderMessageAsync();
Log.Debug("Only admin can set rules at ChatId: {ChatId}", chatId);
return;
}
_telegramService.SaveSenderMessageToHistory(MessageFlag.Rules, deleteAt);
if (_telegramService.ReplyToMessage == null)
{
await _telegramService.SendTextMessageAsync("Balas sebuah pesan untuk disimpan sebagai Rules");
_telegramService.SaveSentMessageToHistory(MessageFlag.Rules, deleteAt);
return;
}
var text = message.CloneText();
var rules = await _rulesService.SaveRuleAsync(
new Rule
{
ChatId = chatId,
FromId = fromId,
RuleText = text,
IsActive = true,
CreatedAt = DateTime.UtcNow,
UpdatedAt = DateTime.UtcNow
}
);
Log.Debug(
"Save rules for ChatId {ChatId} result: {Rules}",
chatId,
rules
);
await _telegramService.SendTextMessageAsync("Rules berhasil disimpan");
_telegramService.SaveSentMessageToHistory(MessageFlag.Rules, deleteAt);
}
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());
}
public static async Task <FloodCheckResult> FloodCheckAsync(this TelegramService telegramService)
{
var channelOrEditedPost = telegramService.ChannelOrEditedPost;
var from = telegramService.From;
var chat = telegramService.Chat;
var update = telegramService.Update;
var messageDate = telegramService.MessageDate;
var defaultFloodCheck = new FloodCheckResult();
if (channelOrEditedPost != null ||
telegramService.InlineQuery != null ||
telegramService.ChosenInlineResult != null ||
chat == null)
{
return(defaultFloodCheck);
}
var chatSettings = await telegramService.GetChatSetting();
if (!chatSettings.EnableFloodCheck)
{
Log.Debug("Flood check disabled for ChatId {ChatId}", chat.Id);
return(defaultFloodCheck);
}
var floodCheckResult = telegramService.FloodCheckService.RunFloodCheck
(
new HitActivity()
{
Guid = Guid.NewGuid().ToString(),
MessageDate = messageDate,
UpdateType = update.Type,
ChatId = chat.Id,
ChatTitle = chat.Title,
ChatUsername = chat.Username,
ChatType = chat.Type,
FromId = from.Id,
FromUsername = from.Username,
FromLangCode = from.LanguageCode,
FromFirstName = from.FirstName,
FromLastName = from.LastName,
Timestamp = DateTime.Now
}
);
if (!floodCheckResult.IsFlood)
{
return(floodCheckResult);
}
if (!telegramService.IsGroupChat ||
telegramService.CheckSenderChannel() ||
await telegramService.CheckFromAdminOrAnonymous())
{
return(defaultFloodCheck);
}
var muteUntilDate = TimeSpan.FromMinutes(floodCheckResult.FloodRate * 5.33).ToDateTime();
var muteUntilStr = muteUntilDate.ToDetailDateTimeString();
await telegramService.RestrictMemberAsync(from.Id, until : muteUntilDate);
var nameLink = from.GetNameLink();
var text = $"Hai {nameLink}, sepertinya Anda melakukan Flooding!" +
$"\nAnda di mute hingga {muteUntilStr} di Obrolan ini";
await telegramService.SendTextMessageAsync(
text,
replyToMsgId : 0,
scheduleDeleteAt : muteUntilDate.ToUniversalTime(),
messageFlag : MessageFlag.FloodWarn
);
telegramService.ChatService
.DeleteMessageHistory(
history =>
history.MessageFlag == MessageFlag.FloodWarn &&
history.ChatId == chat.Id
)
.InBackground();
return(floodCheckResult);
}
public static async Task RestrictMemberAsync(this TelegramService telegramService)
{
try
{
string muteAnswer;
var command = telegramService.GetCommand(withoutSlash: true);
var textParts = telegramService.MessageTextParts.Skip(1);
var duration = textParts.ElementAtOrDefault(0);
if (!await telegramService.CheckFromAdminOrAnonymous())
{
await telegramService.DeleteSenderMessageAsync();
return;
}
if (telegramService.ReplyToMessage == null)
{
muteAnswer = "Silakan reply pesan yang ingin di mute";
}
else if (duration == null)
{
muteAnswer = "Mau di Mute berapa lama?";
}
else
{
var muteDuration = duration.ToTimeSpan();
if (muteDuration < TimeSpan.FromSeconds(30))
{
muteAnswer = $"Durasi Mute minimal adalah 30 detik.\nContoh: <code>/mute 30s</code>";
}
else
{
var isUnMute = command == "unmute";
var replyFrom = telegramService.ReplyToMessage.From;
var fromNameLink = replyFrom.GetNameLink();
var userId = telegramService.ReplyToMessage.From !.Id;
var muteUntil = muteDuration.ToDateTime();
var result = await telegramService.RestrictMemberAsync(
userId,
isUnMute,
muteUntil
);
if (result.IsSuccess)
{
if (muteDuration > TimeSpan.FromDays(366))
{
muteAnswer = $"{fromNameLink} telah di mute Selamanya!";
}
else
{
var untilDateStr = muteUntil.ToDetailDateTimeString();
muteAnswer = $"{fromNameLink} berhasil di mute." +
$"\nMute berakhir sampai dengan {untilDateStr}";
}
}
else
{
muteAnswer = $"Gagal ketika mengMute {fromNameLink}" +
$"\n{result.Exception.Message}";
}
}
}
await telegramService.SendTextMessageAsync(
muteAnswer,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(5),
includeSenderMessage : true
);
}
catch (Exception exception)
{
await telegramService.SendTextMessageAsync(
$"Gagal ketika Mute pengguna. " +
$"\n{exception.Message}"
);
}
}
public static async Task InsightStatusMemberAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
var wTelegramApiService = telegramService.GetRequiredService <WTelegramApiService>();
if (!await telegramService.CheckFromAdminOrAnonymous())
{
await telegramService.DeleteSenderMessageAsync();
return;
}
if (telegramService.IsPrivateGroup)
{
var isProbeHere = await wTelegramApiService.IsProbeHereAsync(chatId);
if (!isProbeHere)
{
var probeInfo = await wTelegramApiService.GetMeAsync();
var userId = probeInfo.full_user.id;
var userName = probeInfo.users.FirstOrDefault(user => user.Key == userId).Value;
var htmlMessage = HtmlMessage.Empty
.Text("Karena ini bukan Grup Publik, ZiziBot membutuhkan Probe sebagai pembantu ZiziBot dalam menjalankan fitur tertentu.")
.Text("Adapun Probe untuk ZiziBot adalah ")
.User(userId, userName.GetFullName()).Text(". ")
.Text("Silakan tambahkan Pengguna ini ke Grup Anda.");
await telegramService.SendTextMessageAsync(
sendText : htmlMessage.ToString(),
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
return;
}
}
await telegramService.SendTextMessageAsync("Sedang mengambil informasi..");
try
{
var chatLink = telegramService.Chat.GetChatLink();
var chatTitle = telegramService.Chat.GetChatTitle();
var participant = await wTelegramApiService.GetAllParticipants(chatId, disableCache : true);
var allParticipants = participant.participants;
var allUsers = participant.users.Select(pair => pair.Value).ToList();
var groupByStatus = allUsers.GroupBy(user => user.status?.GetType()).Where(users => users.Key != null);
var noUsernameUsers = allUsers.Where(user => user.username == null).ToListOrEmpty();
var lastRecently = groupByStatus.FirstOrDefault(users => users.Key == typeof(UserStatusRecently)).ToListOrEmpty();
var lastActiveWeek = groupByStatus.FirstOrDefault(users => users.Key == typeof(UserStatusLastWeek)).ToListOrEmpty();
var lastActiveMonth = groupByStatus.FirstOrDefault(users => users.Key == typeof(UserStatusLastMonth)).ToListOrEmpty();
var lastActiveOnline = groupByStatus.FirstOrDefault(users => users.Key == typeof(UserStatusOnline)).ToListOrEmpty();
var lastActiveOffline = groupByStatus.FirstOrDefault(users => users.Key == typeof(UserStatusOffline)).ToListOrEmpty();
var deletedUsers = allUsers.Where(user => !user.IsActive).ToListOrEmpty();
var bannedUsers = allParticipants.OfType <ChannelParticipantBanned>().ToListOrEmpty();
var allBots = allUsers.Where(user => user.bot_info_version != 0).ToList();
var htmlMessage = HtmlMessage.Empty
.Bold("Status Member").Br()
.Bold("Chat: ").Url(chatLink, chatTitle).Br()
.Bold("Id: ").CodeBr(chatId.ToString())
.Bold("Total: ").CodeBr(allUsers.Count.ToString())
.Bold("No Username: "******"Recent Offline: ").CodeBr(lastActiveOffline.Count.ToString())
.Bold("Recent Online: ").CodeBr(lastActiveOnline.Count.ToString())
.Bold("Active recent: ").CodeBr(lastRecently.Count.ToString())
.Bold("Last week: ").CodeBr(lastActiveWeek.Count.ToString())
.Bold("Last month: ").CodeBr(lastActiveMonth.Count().ToString())
.Bold("Deleted accounts: ").CodeBr(deletedUsers.CountOrZero().ToString())
.Bold("Bots: ").CodeBr(allBots.Count.ToString())
.Bold("Banned: ").CodeBr(bannedUsers.Count.ToString());
await telegramService.EditMessageTextAsync(
sendText : htmlMessage.ToString(),
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(10),
includeSenderMessage : true
);
}
catch (Exception exception)
{
await telegramService.EditMessageTextAsync(
sendText : "Suatu kesalahan telah terjadi. Silahkan coba lagi nanti.\n" + exception.Message,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(1),
includeSenderMessage : true
);
}
}
public static async Task SaveWelcomeSettingsAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
var message = telegramService.MessageOrEdited;
var command = telegramService.GetCommand();
var key = command.Remove(0, 5);
if (telegramService.IsPrivateChat)
{
await telegramService.SendTextMessageAsync("Atur pesan Welcome hanya untuk grup saja");
return;
}
if (!await telegramService.CheckFromAdminOrAnonymous())
{
return;
}
var columnTarget = new Dictionary <string, string>()
{
{ "welcome_btn", "welcome_button" },
{ "welcome_doc", "welcome_document" },
{ "welcome_msg", "welcome_message" }
}.FirstOrDefault(pair => pair.Key == key).Value;
var featureName = columnTarget.Titleize();
await telegramService.SendTextMessageAsync($"Sedang menyimpan {featureName}..");
if (key == "welcome_doc")
{
if (telegramService.ReplyToMessage == null)
{
await telegramService.EditMessageTextAsync("Silakan balas file yang ingin di simpan");
return;
}
var mediaFileId = telegramService.ReplyToMessage.GetFileId();
var mediaType = telegramService.ReplyToMessage.Type;
await telegramService.SettingsService.UpdateCell(
chatId : chatId,
key : "welcome_media",
value : mediaFileId
);
await telegramService.SettingsService.UpdateCell(
chatId : chatId,
key : "welcome_media_type",
value : mediaType
);
}
else
{
var welcomeData = message.CloneText(key == "welcome_btn").GetTextWithoutCmd();
if (welcomeData.IsNullOrEmpty())
{
await telegramService.EditMessageTextAsync(
new MessageResponseDto()
{
MessageText = $"Silakan tentukan data untuk {featureName} " +
"atau balas sebuah pesan yang diinginkan.",
ScheduleDeleteAt = DateTime.UtcNow.AddMinutes(1),
IncludeSenderForDelete = true
}
);
return;
}
await telegramService.SettingsService.UpdateCell(
chatId : chatId,
key : columnTarget,
value : welcomeData
);
}
await telegramService.EditMessageTextAsync(
new MessageResponseDto()
{
MessageText = $"<b>{featureName}</b> berhasil di simpan!" +
$"\nKetik <code>/welcome</code> untuk melihat perubahan",
ScheduleDeleteAt = DateTime.UtcNow.AddMinutes(1),
IncludeSenderForDelete = true
}
);
}
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 static async Task GetWelcomeSettingsAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
var chatTitle = telegramService.ChatTitle;
telegramService.DeleteSenderMessageAsync().InBackground();
if (!await telegramService.CheckFromAdminOrAnonymous())
{
return;
}
var settings = await telegramService.SettingsService.GetSettingsByGroup(chatId);
var welcomeMessage = settings.WelcomeMessage;
var welcomeButton = settings.WelcomeButton;
var welcomeMedia = settings.WelcomeMedia;
var welcomeMediaType = settings.WelcomeMediaType;
var sendText = $"⚙ Konfigurasi Welcome di <b>{chatTitle}</b>\n\n";
if (welcomeMessage.IsNullOrEmpty())
{
var defaultWelcome = "Hai {allNewMember}" +
"\nSelamat datang di kontrakan {chatTitle}" +
"\nKamu adalah anggota ke-{memberCount}";
sendText += "Tidak ada konfigurasi pesan welcome, pesan default akan di terapkan" +
$"\n\n<code>{defaultWelcome}</code>";
}
else
{
sendText += $"{welcomeMessage}";
}
sendText += "\n\n<b>Raw Button:</b>" +
$"\n<code>{welcomeButton}</code>";
var keyboardMarkup = welcomeButton.ToButtonMarkup(validateButton: true);
if (welcomeMedia.IsNotNullOrEmpty() &&
welcomeMediaType > 0)
{
await telegramService.SendMediaAsync(
fileId : welcomeMedia,
mediaType : welcomeMediaType,
caption : sendText,
replyMarkup : keyboardMarkup,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(3),
preventDuplicateSend : true
);
}
else
{
await telegramService.SendTextMessageAsync(
sendText : sendText,
replyMarkup : keyboardMarkup,
replyToMsgId : 0,
scheduleDeleteAt : DateTime.UtcNow.AddMinutes(3),
preventDuplicateSend : true
);
}
}
public static async Task <bool> OnCallbackGlobalBanAsync(this TelegramService telegramService)
{
var chatId = telegramService.ChatId;
var fromId = telegramService.FromId;
var chatUsername = telegramService.Chat.Username;
var message = telegramService.CallbackMessage;
var callbackDatas = telegramService.CallbackQueryDatas;
if (!await telegramService.CheckFromAdminOrAnonymous())
{
Log.Debug(
"UserId: {UserId} is not admin at ChatId: {ChatId}",
fromId,
chatId
);
return(false);
}
var globalBanService = telegramService.GetRequiredService <GlobalBanService>();
var eventLogService = telegramService.GetRequiredService <EventLogService>();
var action = telegramService.GetCallbackDataAt <string>(1);
var userId = telegramService.GetCallbackDataAt <long>(2);
var replyToMessageId = telegramService.ReplyToMessage?.MessageId ?? -1;
var answerCallback = string.Empty;
var messageLog = HtmlMessage.Empty
.TextBr("Global Ban di tambahkan baru")
.Bold("Ban By: ").CodeBr(fromId.ToString())
.Bold("UserId: ").CodeBr(userId.ToString());
switch (action)
{
case "add":
await globalBanService.SaveBanAsync(
new GlobalBanItem
{
UserId = userId,
ReasonBan = "@" + chatUsername,
BannedBy = fromId,
BannedFrom = chatId,
CreatedAt = DateTime.UtcNow
}
);
await globalBanService.UpdateCache(userId);
await telegramService.KickMemberAsync(userId, untilDate : DateTime.Now.AddSeconds(30));
await eventLogService.SendEventLogAsync(
chatId : chatId,
message : message,
text : messageLog.ToString(),
forwardMessageId : replyToMessageId,
deleteForwardedMessage : true,
messageFlag : MessageFlag.GBan
);
telegramService.DeleteMessageManyAsync(customUserId: userId).InBackground();
answerCallback = "Berhasil Memblokir Pengguna!";
break;
case "del":
await globalBanService.DeleteBanAsync(userId);
await globalBanService.UpdateCache(userId);
answerCallback = "Terima kasih atas konfirmasinya!";
break;
}
await telegramService.AnswerCallbackQueryAsync(answerCallback, true);
await telegramService.DeleteCurrentCallbackMessageAsync();
return(true);
}
