public void Execute(Message message)
{
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
if (!Utils.BotTools.IsUserOperator(message.From.Id) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
if (message.ReplyToMessage == null)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = CacheData.GetTranslation("en", "command_pin_missingMessage")
});
return;
}
Manager.BotClient.PinChatMessageAsync(message.Chat.Id, message.ReplyToMessage.MessageId);
}
public void Execute(Message message)
{
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
if (!Utils.BotTools.IsUserOperator(message.From.Id) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
bool canRestrictMembers = false;
bool canDeleteMessages = false;
bool canPinMessages = false;
string text = CacheData.SysConfigs
.Single(x => x.SysConfigId == "CommandCheckKoText").Value;
var me = Manager.BotClient.GetChatMemberAsync(message.Chat.Id, Manager.MyId).Result;
if (me.CanRestrictMembers != null)
{
canRestrictMembers = (bool)me.CanRestrictMembers;
}
if (me.CanDeleteMessages != null)
{
canDeleteMessages = (bool)me.CanDeleteMessages;
}
if (me.CanPinMessages != null)
{
canPinMessages = (bool)me.CanPinMessages;
}
if (canRestrictMembers && canDeleteMessages)
{
text = CacheData.SysConfigs.Single(x => x.SysConfigId == "CommandCheckOkText").Value;
}
text = text.Replace("{{has_ban_users}}", canRestrictMembers ? "{{true}}" : "{{false}}");
text = text.Replace("{{has_delete_messages}}", canDeleteMessages ? "{{true}}" : "{{false}}");
text = text.Replace("{{has_pin_messages}}", canPinMessages ? "{{true}}" : "{{false}}");
text = Utils.Parsers.VariablesParser(text); // TODO select group's settings language
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = text
});
}
public void Execute(Message message)
{
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
if (!Utils.BotTools.IsUserOperator(message.From.Id) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
int userId = 0;
if (message.ReplyToMessage != null)
{
userId = message.ReplyToMessage.From.Id;
}
else if (message.Text.Contains(" "))
{
int.TryParse(message.Text.Split(" ")[1], out userId);
}
if (userId == 0)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = CacheData.GetTranslation("en", "command_unmute_missingMessage")
});
return;
}
Manager.BotClient.RestrictChatMemberAsync(
message.Chat.Id,
userId,
new ChatPermissions()
{
CanSendMessages = true,
CanAddWebPagePreviews = true,
CanChangeInfo = true,
CanInviteUsers = true,
CanPinMessages = true,
CanSendMediaMessages = true,
CanSendOtherMessages = true,
CanSendPolls = true
});
}
private static void CloseGroups(List <Models.Group.NightSchedule> nightSchedules)
{
foreach (Models.Group.NightSchedule nightSchedule in nightSchedules)
{
if (CacheData.NightSchedules[nightSchedule.GroupId].State != Models.Group.NightSchedule.Status.Programmed)
{
continue;
}
if (_firstCycle)
{
TimeSpan diffStartDate = DateTime.UtcNow - nightSchedule.UtcStartDate.Value;
if (diffStartDate.Days > 0)
{
CacheData.NightSchedules[nightSchedule.GroupId].UtcStartDate =
CacheData.NightSchedules[nightSchedule.GroupId].UtcStartDate.Value
.AddDays(diffStartDate.Days);
continue;
}
}
if (nightSchedule.UtcStartDate.Value <= DateTime.UtcNow)
{
CacheData.NightSchedules[nightSchedule.GroupId].State = Models.Group.NightSchedule.Status.Active;
long chatId = CacheData.Groups.Values
.Single(x => x.GroupId == nightSchedule.GroupId).TelegramChatId;
chatPermissionses[chatId] = Manager.BotClient.GetChatAsync(chatId).Result.Permissions;
Manager.BotClient.SetChatPermissionsAsync(chatId,
new ChatPermissions()
{
CanSendMessages = false,
CanAddWebPagePreviews = false,
CanChangeInfo = false,
CanInviteUsers = false,
CanPinMessages = false,
CanSendMediaMessages = false,
CanSendOtherMessages = false,
CanSendPolls = false
});
MessageQueueManager.EnqueueMessage(
new ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = new Chat()
{
Id = chatId, Type = ChatType.Supergroup
},
Text = $"The group is now closed as per Night Schedule settings."
});
CacheData.NightSchedules[nightSchedule.GroupId].UtcStartDate =
CacheData.NightSchedules[nightSchedule.GroupId].UtcStartDate.Value.AddDays(1);
}
}
}
public void Execute(Message message)
{
if (!Utils.BotTools.IsUserOperator(message.From.Id) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
string[] arguments = message.Text.Split(" ");
if (arguments.Length < 2)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "rwb_command_error_invalidsyntax")
});
return;
}
BusinessLogic.ButtonLogic buttonLogic = new BusinessLogic.ButtonLogic();
Models.SystemLog.ErrorCodes removed = buttonLogic.Remove(CacheData.Groups[message.Chat.Id].GroupId,
message.Text.Remove(0, arguments[0].Length + 1), -2);
if (removed == Models.SystemLog.ErrorCodes.Error)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "rwb_command_error_general")
});
return;
}
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
string successMsg = CacheData.GetTranslation("en", "rwb_command_success");
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = successMsg.Replace("{{wbName}}", arguments[1])
});
}
public void Execute(Message message)
{
if (!Utils.BotTools.IsUserOperator(message.From.Id, Models.Operator.Levels.Advanced))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "white_command_error_notoperator")
});
return;
}
int userToUnban;
if (message.ReplyToMessage == null)
{
if (message.Text.Split(" ")[1].StartsWith("@"))
{
if (!CacheData.Usernames.Keys.Contains(message.Text.Split(" ")[1].Remove(0, 1)))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "white_command_error_invalidUsername")
});
return;
}
userToUnban = CacheData.Usernames[message.Text.Split(" ")[1].Remove(0, 1)];
}
else
{
bool isValid = int.TryParse(message.Text.Split(" ")[1], out userToUnban);
if (!isValid)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "white_command_error_invalidUserId")
});
return;
}
}
}
else
{
userToUnban = message.ReplyToMessage.From.Id;
}
Utils.UserTools.RemoveUserFromBlacklist(message, userToUnban);
}
public void Execute(Message message)
{
if (!Utils.BotTools.IsUserOperator(message.From.Id, Models.Operator.Levels.Basic) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
string[] hasMessage = message.Text.Split(" ");
if (hasMessage.Length > 1)
{
bool result = Utils.ConfigTools.UpdateRulesText(message.Chat.Id, message.Text.Remove(0, hasMessage[0].Length + 1));
if (result)
{
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
}
return;
}
CommandMessage commandMessage = new CommandMessage()
{
Command = "SetRulesText",
Value = "",
Message = message,
Timestamp = DateTime.UtcNow
};
CommandQueueManager.EnqueueMessage(commandMessage);
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
ParseMode = ParseMode.Html,
Text = $"<b>[ADMIN] [r:{message.MessageId}]</b>\n"
+ CacheData.GetTranslation(
CacheData.Groups[message.Chat.Id].SettingsLanguage,
"command_setrules_instructions"),
ReplyMarkup = new ForceReplyMarkup()
{
Selective = true
}
});
}
public void Execute(Message message)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.SysConfigs
.Single(x => x.SysConfigId == "motd")
.Value
});
}
public void Execute(Message message)
{
if (!Utils.BotTools.IsUserOperator(message.From.Id, Models.Operator.Levels.Basic) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "feedback_command_error_notadmin")
});
return;
}
List <List <InlineKeyboardButton> > buttons = new List <List <InlineKeyboardButton> >();
buttons.Add(new List <InlineKeyboardButton>()
{
InlineKeyboardButton.WithCallbackData(
CacheData.GetTranslation("en", "feedback_type_suggestion"),
$"/feedback type:suggestion"
)
});
buttons.Add(new List <InlineKeyboardButton>()
{
InlineKeyboardButton.WithCallbackData(
CacheData.GetTranslation("en", "feedback_type_reportBug"),
$"/feedback type:reportBug"
)
});
buttons.Add(new List <InlineKeyboardButton>()
{
InlineKeyboardButton.WithCallbackData(
CacheData.GetTranslation("en", "feedback_type_reportUser"),
$"/feedback type:reportUser"
)
});
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
ParseMode = ParseMode.Markdown,
Text = "*[ADMIN]*\nSelect feedback type:",
ReplyMarkup = new InlineKeyboardMarkup(
buttons
)
});
}
public void Execute(Message message)
{
if (!Utils.BotTools.IsUserOperator(message.From.Id, Models.Operator.Levels.Basic) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
return;
}
string[] arguments = message.Text.Split(" ");
if (arguments.Length < 3)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "addbadword_command_error_missingargument")
});
return;
}
bool added = Filters.BadWordFilter.BanWord(
CacheData.Groups[message.Chat.Id].GroupId,
arguments[1].Trim(),
message.Text
.Substring(arguments[0].Length + arguments[1].Length + 1)
.Trim());
if (!added)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "addbadword_command_error")
});
return;
}
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "addbadword_command_success")
});
return;
}
private void requestNewValue(CallbackQuery callbackQuery,
string configurationParameterId)
{
Manager.BotClient.DeleteMessageAsync(callbackQuery.Message.Chat.Id, callbackQuery.Message.MessageId);
ConfigurationParameter conf = CacheData.GroupConfigs[callbackQuery.Message.Chat.Id]
.Where(x => x.ConfigurationParameterId == configurationParameterId)
.SingleOrDefault();
if (conf == null)
{
return;
}
switch (conf.Type)
{
case "string":
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = callbackQuery.Message.Chat,
ParseMode = ParseMode.Markdown,
Text = $"*[ADMIN] Settings [r:{callbackQuery.Message.MessageId}]*\nProvide new value:",
ReplyMarkup = new ForceReplyMarkup()
{
Selective = true
}
});
break;
case "language":
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = callbackQuery.Message.Chat,
ParseMode = ParseMode.Markdown,
Text = $"*[ADMIN] Settings [r:{callbackQuery.Message.MessageId}]*\nSelect language:",
ReplyMarkup = new InlineKeyboardMarkup(
buildLanguageSelectionMenu(callbackQuery.From.Id)
)
});
break;
default:
break;
}
}
public void Execute(Message message)
{
if (!Utils.BotTools.IsUserOperator(message.From.Id, Models.Operator.Levels.Basic) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
return;
}
if (message.ReplyToMessage != null)
{
if (!message.ReplyToMessage.Text.StartsWith("#"))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_addnote_command_onreply")
});
return;
}
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.ReplyToMessage.MessageId);
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
SaveNote(message.ReplyToMessage);
return;
}
if (!message.Text.Remove(0, 9).StartsWith("#"))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_addnote_command_starttag")
});
return;
}
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
SaveNote(message);
}
public void Execute(Message message)
{
if (!Utils.BotTools.IsUserOperator(message.From.Id, Models.Operator.Levels.Basic))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "feedback_command_error_notoperator")
});
return;
}
if (CacheData.ActiveSupport.Contains(message.Chat.Id))
{
CacheData.ActiveSupport.Remove(message.Chat.Id);
CacheData.CurrentChatAdmins.Remove(message.Chat.Id);
Manager.BotClient.SendTextMessageAsync(
chatId: message.Chat.Id,
parseMode: ParseMode.Markdown,
text: String.Format(
"Operator *{0}* ended the support session.",
message.From.Username)
);
MessageQueueManager.EnqueueLog(new ChatMessage()
{
ParseMode = ParseMode.Markdown,
Text = String.Format(
"*[Log]*" +
"\n\nSupport session ended by operator *{0}*" +
"\nChatId: `{1}`" +
"\nChat: `{2}`" +
"\nUserId: `{3}`" +
"\n\n*hash_code:* #UB{4}-{5}",
message.From.Username,
message.Chat.Id,
message.Chat.Title,
message.From.Id,
message.Chat.Id.ToString().Replace("-", ""),
Guid.NewGuid())
});
}
}
public void Execute(Message message)
{
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
string text = Utils.Parsers.VariablesParser(CacheData.SysConfigs
.Single(x => x.SysConfigId == "HelpMenu")
.Value);
if (ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
text += Environment.NewLine;
text += CacheData.SysConfigs
.Single(x => x.SysConfigId == "HelpMenuAdmin")
.Value;
}
if (BotTools.IsUserOperator(message.From.Id))
{
text += Environment.NewLine;
text += CacheData.SysConfigs
.Single(x => x.SysConfigId == "HelpMenuOperatorBase")
.Value;
if (BotTools.IsUserOperator(message.From.Id, Models.Operator.Levels.Advanced))
{
text += Environment.NewLine;
text += CacheData.SysConfigs
.Single(x => x.SysConfigId == "HelpMenuOperatorAdv")
.Value;
}
}
text += Environment.NewLine;
text += Environment.NewLine;
text += "* usernames are saved in cache and never stored on database or file. The cache is cleared at every reboot or update.";
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Html,
Text = text
});
}
public void Execute(Message message)
{
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
if (!Utils.BotTools.IsUserOperator(message.From.Id, Models.Operator.Levels.Super))
{
return;
}
string[] data = message.Text.Split(" ");
if (data.Length >= 2)
{
handleRequest(data, message);
return;
}
List <InlineKeyboardButton> confirmationButton = new List <InlineKeyboardButton>();
confirmationButton.Add(InlineKeyboardButton.WithUrl("Start with command", "http://t.me/LinuxPixelHubBot?start=motd"));
confirmationButton.Add(InlineKeyboardButton.WithCallbackData(
CacheData.GetTranslation("en", "captcha_iamhuman", true),
$"/test1 " + message.From.Id
));
confirmationButton.Add(InlineKeyboardButton.WithCallbackData(
"RM",
$"/test1 rm"
));
confirmationButton.Add(InlineKeyboardButton.WithCallbackData(
"Switch invalid command" + (CacheData.AnswerInvalidCommand ? " ✅" : " ❌"),
$"/test1 switchinvalidcommand"
));
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = "*[ADMIN]*\nSelect a test",
ReplyMarkup = new InlineKeyboardMarkup(
confirmationButton
)
});
}
private void SetOpenTime(Message message, string time)
{
string groupId = CacheData.Groups[message.Chat.Id].GroupId;
DateTime endTime = new DateTime(
DateTime.UtcNow.Year, DateTime.UtcNow.Month, DateTime.UtcNow.Day,
Convert.ToInt32(time.Split(":")[0]), Convert.ToInt32(time.Split(":")[1]), 0);
if (endTime < DateTime.UtcNow)
{
endTime = endTime.AddDays(1);
}
if (CacheData.NightSchedules.ContainsKey(groupId))
{
if (CacheData.NightSchedules[groupId].UtcStartDate.HasValue)
{
if (CacheData.NightSchedules[groupId].UtcStartDate.Value.Hour == endTime.Hour)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = "Opening and closing time matches the same hour. Please select a different time.",
PostSentAction = Models.ChatMessage.PostSentActions.Destroy,
AutoDestroyTimeInSeconds = 5
});
return;
}
}
nsl.Update(groupId, CacheData.NightSchedules[groupId].State,
CacheData.NightSchedules[groupId].UtcStartDate, endTime, -2);
}
else
{
nsl.Add(groupId, Models.Group.NightSchedule.Status.Deactivated,
null, endTime, -2);
}
CacheData.NightSchedules[groupId] = nsl.GetByChat(groupId);
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
SendKeyboard(message.ReplyToMessage, "close");
}
public void Execute(Message message)
{
if (CacheData.Operators
.SingleOrDefault(x => x.TelegramUserId == message.From.Id &&
x.Level == Models.Operator.Levels.Super) == null)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
Manager.BotClient.SendTextMessageAsync(
chatId: CacheData.ControlChatId,
parseMode: ParseMode.Markdown,
text: String.Format(
"*[Report]*\n" +
"⚠️ Non operator tried to use /reloadtranslations\n" +
"\n*Chat:* {0}" +
"\n*ChatId:* {1}" +
"\n*UserId:* {2}" +
"\n\n*hash_code:* #UB{3}-{4}",
message.Chat.Title,
message.Chat.Id,
message.From.Id,
message.Chat.Id.ToString().Replace("-", ""),
Guid.NewGuid())
);
return;
}
Program.InitializeTranslations();
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "done", true)
});
}
public void Execute(Message message)
{
if (CacheData.Operators
.SingleOrDefault(x => x.TelegramUserId == message.From.Id &&
x.Level >= Models.Operator.Levels.Basic) == null &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
string[] hasMessage = message.Text.Split(" ");
if (hasMessage.Length == 2)
{
if (hasMessage[1] == "close")
{
ToggleGate(message, false);
}
else if (hasMessage[1] == "open")
{
ToggleGate(message, true);
}
else
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_gate_command_argument")
});
}
return;
}
}
public void Execute(Message message)
{
if (!Utils.BotTools.IsUserOperator(message.From.Id) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
string command = message.Text.Split(" ")[0].Remove(0, 1);
if (command.Contains("@"))
{
if (!String.Equals(command.Split("@")[1],
Manager.Username, StringComparison.CurrentCultureIgnoreCase))
{
return;
}
command = command.Split("@")[0];
}
message.Text = message.Text.Remove(0, command.Length + 2);
string messageHeader = CacheData.GetTranslation("en", "command_announce_header");
string parsedMessage = messageHeader + "\n" + message.Text;
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Html,
Text = parsedMessage,
PostSentAction = Models.ChatMessage.PostSentActions.Pin
});
}
public void Execute(CallbackQuery callbackQuery)
{
Message message = callbackQuery.Message;
if (CacheData.Operators
.SingleOrDefault(x => x.TelegramUserId == callbackQuery.From.Id &&
x.Level >= Models.Operator.Levels.Basic) == null &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, callbackQuery.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
string[] parameters = callbackQuery.Data.Split(" ");
switch (parameters[1])
{
case "prevPage":
case "nextPage":
SendKeyboard(message, parameters[3], Convert.ToInt32(parameters[2]));
break;
case "open":
SetOpenTime(message, parameters[2]);
break;
case "close":
SetCloseTime(message, parameters[2]);
break;
case "cancel":
Manager.BotClient.DeleteMessageAsync(callbackQuery.Message.Chat.Id,
callbackQuery.Message.MessageId);
break;
}
}
public void Execute(Message message)
{
if (CacheData.Operators
.SingleOrDefault(x => x.TelegramUserId == message.From.Id &&
x.Level >= Models.Operator.Levels.Basic) == null &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
SendKeyboard(message, "open");
}
public void Execute(Message message)
{
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
if (CacheData.Operators
.SingleOrDefault(x => x.TelegramUserId == message.From.Id &&
x.Level >= Models.Operator.Levels.Advanced) == null)
{
return;
}
Process proc = Process.GetCurrentProcess();
float usedRam = (proc.WorkingSet64 / 1024f) / 1024f;
string SQLStatus = "*Offline* ⚠";
if (SQLOnline())
{
SQLStatus = "Online";
}
string env = "production";
#if DEBUG
env = "🛠 *BETA* 🛠";
#endif
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = $"*Version*: {Utils.BotTools.CurrentVersion()}\n" +
$"Instance *started*: {proc.StartTime}\n" +
$"Used *RAM* is {Math.Round(usedRam, 2)}MB\n" +
$"Used *CPU* is {Math.Round(GetCpuUsageForProcess().Result, 2)}%\n" +
$"*Database* status is {SQLStatus}\n" +
$"*Environment* is {env}\n" +
$"*Messages since start:* {CacheData.HandledMessages}\n" +
$"*Blacklist count:* {CacheData.BannedUsers.Count()}"
});
}
public void Execute(Message message)
{
if (CacheData.Operators
.SingleOrDefault(x => x.TelegramUserId == message.From.Id &&
x.Level == Models.Operator.Levels.Super) == null)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
if (message.ReplyToMessage == null)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = "This command works only as reply to an exsisting message"
});
return;
}
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
ParseMode = ParseMode.Markdown,
Text = Utils.Parsers.VariablesParser(message.ReplyToMessage.Text, message)
});
}
public void Execute(Message message)
{
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
if (!Utils.BotTools.IsUserOperator(message.From.Id) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
List <InlineKeyboardButton> confirmationButton = new List <InlineKeyboardButton>();
confirmationButton.Add(InlineKeyboardButton.WithCallbackData(
CacheData.GetTranslation("en", "yes", true),
$"/Leave yes"
));
confirmationButton.Add(InlineKeyboardButton.WithCallbackData(
CacheData.GetTranslation("en", "no", true),
$"/Leave no"
));
Manager.BotClient.SendTextMessageAsync(
chatId: message.Chat.Id,
parseMode: ParseMode.Markdown,
text: "*[ADMIN]*\nAre you sure you want to leave?",
replyMarkup: new InlineKeyboardMarkup(
confirmationButton
)
);
}
public static void ToggleGate(Message message, bool newStatus)
{
Models.Group.ConfigurationParameter config = CacheData.GroupConfigs[message.Chat.Id]
.Where(x => x.ConfigurationParameterId == "Gate")
.SingleOrDefault();
if (config == null)
{
return;
}
CacheData.GroupConfigs[message.Chat.Id]
[CacheData.GroupConfigs[message.Chat.Id]
.IndexOf(config)]
.Value = newStatus ? "true" : "false";
Manager.BotClient.SetChatPermissionsAsync(message.Chat.Id,
new ChatPermissions()
{
CanSendMessages = newStatus,
CanAddWebPagePreviews = newStatus,
CanChangeInfo = newStatus,
CanInviteUsers = newStatus,
CanPinMessages = newStatus,
CanSendMediaMessages = newStatus,
CanSendOtherMessages = newStatus,
CanSendPolls = newStatus
});
string status = newStatus ? "open" : "closed";
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = $"The group is now {status}"
});
}
public void Execute(CallbackQuery callbackQuery)
{
if (!Utils.BotTools.IsUserOperator(callbackQuery.From.Id, Models.Operator.Levels.Basic) &&
!Utils.ChatTools.IsUserAdmin(callbackQuery.Message.Chat.Id, callbackQuery.From.Id))
{
return;
}
Manager.BotClient.DeleteMessageAsync(callbackQuery.Message.Chat.Id, callbackQuery.Message.MessageId);
string data = callbackQuery.Data.Replace("/feedback ", "");
string type = data.Split(':')[1];
CommandMessage commandMessage = new CommandMessage()
{
Command = "Feedback",
Value = type,
Message = callbackQuery.Message,
Timestamp = DateTime.UtcNow
};
CommandQueueManager.EnqueueMessage(commandMessage);
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = callbackQuery.Message.Chat,
ReplyToMessageId = callbackQuery.Message.ReplyToMessage.MessageId,
ParseMode = ParseMode.Markdown,
Text = $"*[ADMIN] [r:{callbackQuery.Message.MessageId}]*\nProvide feedback text:",
ReplyMarkup = new ForceReplyMarkup()
{
Selective = true
}
});
}
public void Execute(Message message)
{
if (!Utils.BotTools.IsUserOperator(message.From.Id) &&
!Utils.ChatTools.IsUserAdmin(message.Chat.Id, message.From.Id))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ReplyToMessageId = message.MessageId,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
return;
}
string btnList = "This is the list of welcome buttons:";
BusinessLogic.ButtonLogic buttonLogic = new BusinessLogic.ButtonLogic();
foreach (Button btn in buttonLogic
.GetByChat(CacheData.Groups[message.Chat.Id]
.GroupId))
{
btnList += Environment.NewLine;
btnList += "* " + btn.Name + " -> " + btn.Content;
}
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = btnList,
DisableWebPagePreview = true
});
}
public void Execute(Message message)
{
Manager.BotClient.DeleteMessageAsync(message.Chat.Id, message.MessageId);
if (!Utils.BotTools.IsUserOperator(message.From.Id, Models.Operator.Levels.Advanced))
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "error_not_auth_command")
});
Manager.BotClient.SendTextMessageAsync(
chatId: CacheData.ControlChatId,
parseMode: ParseMode.Markdown,
text: String.Format(
"User *{0}:{1}* tried to use command Disable!",
message.From.Id,
message.From.Username)
);
return;
}
long chatId = 0;
string[] data = message.Text.Split(" ");
if (data.Length >= 2)
{
bool isInt = long.TryParse(data[1], out chatId);
if (!isInt)
{
Manager.BotClient.SendTextMessageAsync(
chatId: message.Chat.Id,
parseMode: ParseMode.Markdown,
text: "The provided chatId is not a number.\n"
+ "**Syntax:**\n/disable (current group)\n/disable {chatId}"
);
return;
}
}
else
{
chatId = message.Chat.Id;
}
CacheData.Groups[message.Chat.Id].State = Models.Group.TelegramGroup.Status.Inactive;
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "command_disable_successful")
});
Manager.BotClient.SendTextMessageAsync(
chatId: CacheData.ControlChatId,
parseMode: ParseMode.Markdown,
text: String.Format(
"Operator *{0}* has disabled group {1}:{2}",
message.From.Id,
message.Chat.Id, message.Chat.Title)
);
}
private void SaveNote(Message message)
{
if (message.Text.StartsWith("/setnote") ||
message.Text.StartsWith("/addnote"))
{
message.Text = message.Text.Remove(0, 9);
}
Regex reg = new Regex("#[A-z0-9]+", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
MatchCollection matchedTags = reg.Matches(message.Text);
if (matchedTags.Count == 0)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "addnote_command_error_starttag")
});
return;
}
string tagCollection = "";
foreach (Match match in matchedTags)
{
tagCollection += match.Value;
}
message.Text += Environment.NewLine;
message.Text += Environment.NewLine;
message.Text += "The text of this note is set by the group administrator.";
Models.Group.Note newNote = noteLogic.Add(CacheData.Groups.Values.Single(x => x.TelegramChatId == message.Chat.Id).GroupId,
tagCollection, message.Text, -2);
if (newNote == null)
{
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "addnote_command_error_generic")
});
return;
}
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = CacheData.GetTranslation("en", "addnote_command_success"),
AutoDestroyTimeInSeconds = 5,
PostSentAction = Models.ChatMessage.PostSentActions.Destroy
});
MessageQueueManager.EnqueueMessage(
new Models.ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = newNote.Message
});
}
public void Execute(Message message)
{
DateTime last;
lastReport.TryGetValue(message.Chat.Id, out last);
if (last != null)
{
if ((DateTime.UtcNow - last).TotalSeconds < 30)
{
return;
}
}
string author = message.From.Username == null
? message.From.FirstName + " " + message.From.LastName
: "@" + message.From.Username;
string logMessage = String.Format(
"*[Report]*\n" +
"A user has reported a message\n" +
"⚠ do not open links you don't know ⚠\n" +
"\nChat: `{0}`" +
"\nAuthor: `{1}`" +
"\nUserId: `{2}`" +
"\nOriginal message link: https://t.me/c/{4}/{3}\n" +
"\n\n*hash_code:* #UB{4}-{5}",
message.Chat.Title,
author,
message.From.Id,
message.MessageId,
message.Chat.Id.ToString().Replace("-", ""),
Guid.NewGuid());
MessageQueueManager.EnqueueLog(new ChatMessage()
{
ParseMode = ParseMode.Markdown,
Text = logMessage
});
if (!String.IsNullOrEmpty(message.Chat.Username))
{
MessageQueueManager.EnqueueMessage(
new ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
Text = "The Operators have been advised about your call.\n" +
"Wait of any of them to join your group."
});
}
else
{
MessageQueueManager.EnqueueMessage(
new ChatMessage()
{
Timestamp = DateTime.UtcNow,
Chat = message.Chat,
ParseMode = ParseMode.Markdown,
Text = "The Operators have been advised of your report but your group is private.\n" +
"Please join our [support group](https://t.me/unifiedban_group)."
});
}
}