public void ExecuteQuery(CallbackQuery callback)
{
using (var conn = new SqliteConnection("Data Source=" + filename))
{
conn.Open();
using (SqliteTransaction transaction = conn.BeginTransaction())
{
using (SqliteCommand command = conn.CreateCommand())
{
callback(command);
}
transaction.Commit();
}
conn.Close();
}
}
public static GMessage Parse(this CallbackQuery query, TelegramBotClient owner)
{
var queryData = CallbackData.Parse(query.Data);
if (queryData.IsParseError)
{
return(new NotValidDataMessage(query, owner));
}
if (nucleoData.ContainsKey(queryData.Code))
{
return(GMessage.InitializeMesage(nucleoData[queryData.Code], query, owner));
}
else
{
return(new MissingInfoForBuildMessage(queryData.Code, query, owner));
}
}
public override async Task Execute(CallbackQuery callbackQuery, TelegramBotClient bot)
{
string[] data = callbackQuery.Data.Split("|");
long sensorID;
if ((data.Length > 1) && long.TryParse(data[1], out sensorID))
{
TempDTO sensorTemp = await sensorTempReader.GetTempBySensor(sensorID);
await bot.AnswerCallbackQueryAsync(callbackQueryId : callbackQuery.Id, text : $"Selected sensor with ID: {sensorID}");
await bot.SendTextMessageAsync(chatId : callbackQuery.Message.Chat.Id, text : $"Sensor \"{sensorTemp.Name}\": {Math.Round(sensorTemp.Temperature, 1)}°C");
}
else
{
await bot.SendTextMessageAsync(chatId : callbackQuery.Message.Chat.Id, text : "Wrong command. SensorID is not found");
}
}
public override async void Execute(TelegramBotClient botClient, System.Object message)
{
CallbackQuery _message = message as CallbackQuery;
try
{
if (IsBan.Ban(botClient, message))
{
InlineKeyboardMarkup answer = InlineButton.GetChat();
await botClient.EditMessageTextAsync(_message.From.Id, _message.Message.MessageId, "Чаты: ",
Telegram.Bot.Types.Enums.ParseMode.Html, replyMarkup : answer);
}
}
catch (System.Exception ex)
{
Log.Logging(ex);
}
}
private async Task HandleCallback(CallbackQuery query)
{
var msg = _mapper.Map <Message>(query);
await _commandsService.ExecuteCommand(msg, OnAnyResult, OnAnyResult);
async Task OnAnyResult(IResult res)
{
await _botClient.AnswerCallbackQueryAsync(query.Id);
await _botClient.EditMessageTextAsync(new ChatId(query.From.Id), query.Message.MessageId, res.Message);
if (res.Keyboard.IsInline)
{
await _botClient.EditMessageReplyMarkupAsync(new ChatId(query.From.Id), query.Message.MessageId,
KeyboardConverter.FromCoreToTg(res.Keyboard) as InlineKeyboardMarkup);
}
}
}
public override bool Validate(Model.User currentUser, CallbackQuery cquery = null, Message message = null)
{
if (cquery != null)
{
return(false);
}
if (message.Type == MessageType.Text && AskAction.BaseTextValidation(cquery, message))
{
return(Uri.IsWellFormedUriString(message.Text, UriKind.Absolute));
}
else if (message.Type == MessageType.Photo)
{
return(true);
}
return(false);
}
public static void GameQuery(CallbackQuery query, string[] args)
{
var temp = args[1].Split('|');
var gameId = temp[0];
var playerId = temp[1];
var playerChoice = temp[2];
var game = Bot.GetGameByGuid(gameId);
if (game != null)
{
game.HandleQuery(query, temp);
}
else
{
// should not happen
}
}
public async Task OnMeet(ApplicationContext context, CallbackQuery query, TelegramBotClient client)
{
long userId = Convert.ToInt64(query.Data.Split('-')[1]);
User user = await UserDB.GetUserByChatId(context, query.From.Id);
StringBuilder builder = new StringBuilder();
TelegramInlineKeyboard inline = new TelegramInlineKeyboard();
inline
.AddTextRow("Отклонить", "Принять")
.AddCallbackRow($"decline-{query.From.Id}", $"accept-{query.From.Id}");
builder.AppendLine("Вам назначена встреча от:");
builder.AppendLine($"{user.FirstName} {user.LastName}");
await client.SendTextMessageAsync(userId, builder.ToString(), ParseMode.Markdown,
replyMarkup : inline.Markup);
}
public async Task HandleAsync(IUpdateContext context, UpdateDelegate next, CancellationToken cancellationToken)
{
CallbackQuery cq = context.Update.CallbackQuery;
await context.Bot.Client.SendTextMessageAsync(
cq.Message.Chat,
context.Items["History"].ToString() + " and last item = " + context.Items["State"].ToString(),
replyMarkup : new InlineKeyboardMarkup(
new InlineKeyboardButton[]
{
InlineKeyboardButton.WithCallbackData("menu2", "menu2::"),
InlineKeyboardButton.WithCallbackData("back", "back::")
}
),
cancellationToken : cancellationToken
);
}
public async void Execute(TelegramBotClient botClient, System.Object message, Dictionary <System.Int32, IItemCategory> itemCategories, DataBaseContext baseContext)
{
CallbackQuery _message = message as CallbackQuery;
User users = baseContext._User.Where(p => p.ID == _message.From.Id).FirstOrDefault();
users.Work = 1919;
baseContext.SaveChanges();
try
{
await botClient.EditMessageTextAsync(_message.From.Id, _message.Message.MessageId, "Меню: ", replyMarkup : inlineButton.Travels);
}
catch (System.Exception ex)
{
System.Console.WriteLine("Travels : ICommand: " + ex);
}
}
private static async Task BotOnCallbackQueryReceived(CallbackQuery callbackQuery)
{
await Bot.AnswerCallbackQueryAsync(
callbackQuery.Id,
$"Congrats!"
);
var lo = float.Parse(callbackQuery.Data.Split(',')[0]);
var ln = float.Parse(callbackQuery.Data.Split(',')[1]);
await Bot.SendLocationAsync(
callbackQuery.Message.Chat.Id, lo, ln);
await Bot.EditMessageTextAsync(
callbackQuery.Message.Chat.Id,
callbackQuery.Message.MessageId,
$"Your free promocode to get the food is: *DeveloperWeek2020*. Go ahead and tell at the end location ! 🥙 😀",
parseMode : ParseMode.Markdown);
}
private void ExecuteQuery(CallbackQuery query, TelegramBotClient client)
{
client.AnswerCallbackQueryAsync(query.Id, "Success!");
using (SqlConnection connection = Bot.GetDBConnection())
{
connection.Open();
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.Connection = connection;
sqlCommand.CommandText = $"INSERT INTO Commands (ChatId, Command) VALUES ({query.Message.Chat.Id}, '{query.Data}')";
sqlCommand.ExecuteNonQuery();
connection.Close();
}
client.SendTextMessageAsync(query.Message.Chat.Id, "Ok! What do you want to search?");
}
public Task Handle(CallbackQuery callbackQuery)
{
/*
* Get message id from callback and store it
*
* Callback data to KeyValue pairs
* \/
* V
* Get certain handler depending on CallbackQueryActionType
* Delegate handling to specific handler
*
*/
CallbackQueryData callbackQueryData = null;
ISpecificCallbackQueryHandler handler = null;
try
{
StoreMessageId(callbackQuery);
callbackQueryData = CallbackDataFormatter.DeserializeCallbackQueryData(callbackQuery.Data);
callbackQueryData.CallbackQueryId = callbackQuery.Id;
handler = _queryHandlerProvider.GetHandler(callbackQueryData.CallbackQueryActionType);
return(handler.Handle(callbackQueryData));
}
catch (Exception e)
{
var callbackQueryId = callbackQuery.Id;
var user = callbackQuery.From;
var messageId = callbackQuery.Message?.MessageId;
var messageText = callbackQuery.Message?.Text;
_logger.LogError(TelegramLogEvents.CallbackQueryHandlerError, e,
"Telegram callbackQueryId: {callbackQueryId}. " +
"Telegram user: {user}. " +
"Callback query message id: {messageId}. " +
"Message text: {messageText}" +
"callbackQueryData: {callbackQueryData}. " +
"handler: {handler}. ",
callbackQueryId, user, messageId, messageText, callbackQueryData, handler);
throw;
}
}
private async Task ProcessCallbackError(CallbackQuery callbackQuery, Exception ex)
{
var messageForUser = string.Empty;
var messageForBotOwner = string.Empty;
var userId = callbackQuery.From.Id;
var player = ex is UserNotFoundException ? null : await _playerRepository.GetAsync(userId);
if (ex is UserNotFoundException)
{
_logger.Error($"User with id {userId} not found. Name: {callbackQuery.From.FirstName} {callbackQuery.From.LastName}");
messageForUser = "******";
messageForBotOwner = $"Пользователь {callbackQuery.From.FirstName} {callbackQuery.From.LastName} не найден";
}
if (ex is TotalsRowNotFoundExeption)
{
_logger.Error("\"Всего\" row not found in excel-file");
messageForUser = "******"Всего\" в excel-файле.";
messageForBotOwner = $"Не найдена строка \"Всего\" в excel-файле. Пользователь - {player.Name}";
}
if (ex is OperationCanceledException)
{
_logger.Error($"Operation {callbackQuery.Data} cancelled for user {player.Name}.");
messageForUser = "******";
messageForBotOwner = $"Операция обработки ответа отменена для пользователя {player.Name}";
}
if (ex is ArgumentOutOfRangeException)
{
_logger.Error($"Unexpected response for user {player.Name}: {((ArgumentOutOfRangeException)ex).ParamName}");
messageForUser = "******";
messageForBotOwner = $"Непредвиденный вариант ответа для пользователя {player.Name}";
}
if (messageForUser == string.Empty)
{
_logger.Error(ex, "Unexpected error");
messageForUser = "******";
messageForBotOwner = $"Ошибка у пользователя {player.Name}: {ex.Message}";
}
await NotifyAboutError(callbackQuery.Message.Chat.Id, messageForUser, messageForBotOwner);
}
public static void RequestGif(CallbackQuery q)
{
Bot.Api.DeleteMessageAsync(q.From.Id, q.Message.MessageId);
var choice = q.Data.Split('|')[1].Split(' ')[0];
if (choice == "submit")
{
using (var db = new WWContext())
{
var p = db.Players.FirstOrDefault(x => x.TelegramId == q.From.Id);
if (p != null)
{
var json = p?.CustomGifSet;
if ((p.DonationLevel ?? 0) < 10)
{
Bot.Send("You have not unlocked a custom GIF pack. Please use /donate", q.From.Id);
return;
}
var data = JsonConvert.DeserializeObject <CustomGifData>(json);
if (data.Approved != null)
{
Bot.Send($"Your current GIF pack has already been {(data.Approved == true ? "" : "dis")}approved! You can't submit it again without any changes!", q.From.Id, customMenu: GetGifMenu(data));
return;
}
if (new[] { data.CultWins, data.LoversWin, data.NoWinner, data.SerialKillerWins, data.SKKilled, data.StartChaosGame, data.StartGame, data.TannerWin, data.VillagerDieImage, data.VillagersWin, data.WolfWin, data.WolvesWin, data.ArsonistWins, data.BurnToDeath }.All(x => string.IsNullOrEmpty(x)))
{
Bot.Send($"Please set at least one GIF before you submit your pack!", q.From.Id, customMenu: GetGifMenu(data));
return;
}
data.Submitted = true;
p.CustomGifSet = JsonConvert.SerializeObject(data);
db.SaveChanges();
}
}
var menu = new Menu(2);
menu.Buttons.Add(new InlineKeyboardCallbackButton("Review", "reviewgifs|" + q.From.Id));
menu.Buttons.Add(new InlineKeyboardCallbackButton("Dismiss", $"dismiss|" + q.From.Id));
menu.Buttons.Add(new InlineKeyboardCallbackButton("Approved: SFW", "approvesfw|" + q.From.Id));
menu.Buttons.Add(new InlineKeyboardCallbackButton("Approved: NSFW", "approvensfw|" + q.From.Id));
Bot.Send($"User {q.From.Id} - {(q.From.Username == null ? q.From.FirstName : $"@{q.From.Username}")} - has submitted a gif pack for approval", Settings.AdminChatId, customMenu: menu.CreateMarkupFromMenu());
Bot.Send("Your pack has been submitted for approval to the admins. Please wait while we review.",
q.From.Id);
return;
}
public override async Task <IChatState> HandleCallbackQuery(CallbackQuery callbackQuery)
{
IChatState nextState = null;
var httpCheckSettingsRepository = ServiceProvider.GetRequiredService <IHttpCheckSettingsRepository>();
var action = callbackQuery.Data.Split("::").FirstOrDefault();
switch (action)
{
case "remove":
await httpCheckSettingsRepository.Remove(Guid.Parse(callbackQuery.Data.Substring(callbackQuery.Data.IndexOf("::") + 2)), CancellationToken.None);
nextState = this;
break;
}
await base.HandleCallbackQuery(callbackQuery);
return(nextState ?? new UndefinedChatState(Chat, TelegramBotClient, ServiceProvider));
}
private Menu MarkSessionLive(CallbackQuery callback)
{
Menu menu;
var sessionId = SessionIdFromCallbackData(callback.data);
var session = GetSessionById(sessionId);
if (session == null)
{
menu = new NoMatchingSessionMenu(sessionId);
}
else
{
session.MarkLive();
_database.SaveSession(session);
menu = new SessionCompleteLiveMenu();
}
return(menu);
}
public async void Execute(TelegramBotClient botClient, System.Object message, Dictionary <System.Int32, IItemCategory> itemCategories, DataBaseContext baseContext)
{
CallbackQuery _message = message as CallbackQuery;
Message mes = message as Message;
User users = baseContext._User.Where(p => p.ID == _message.From.Id).FirstOrDefault();
System.Console.WriteLine("\n\n" + users.Work / 100);
itemCategories[users.Work / 100].ChangeFirstCat(message, baseContext);
try
{
await botClient.EditMessageTextAsync(_message.From.Id, _message.Message.MessageId, "Заголовок: ", replyMarkup : inlineButton.BackToCategory);
}
catch (System.Exception ex)
{
System.Console.WriteLine("ChangeFirst : ICommand: " + ex);
}
}
public override void Execute(CallbackQuery callbackQuery)
{
dynamic response = JsonConvert.DeserializeObject(callbackQuery.Data);
int id = response.id;
var med = SessionManager.Current.Carrinho.AdicionarMedicamento(id);
if (med != null)
{
Bot.AnswerCallbackQueryAsync(
callbackQuery.Id,
$"Medicamento {med.Nome} foi adicionado ao carrinho.");
Bot.SendTextMessageAsync(
callbackQuery.Message.Chat.Id,
$"Medicamento {med.Nome} foi adicionado ao carrinho." + "\n\n" +
"Use o comando /pedido para finalizar a compra.");
}
}
public async Task CallbackQuery(CallbackQuery callbackQuery)
{
try
{
var userId = callbackQuery.From.Id;
if (!_checker.AllowUser(userId))
{
return;
}
await OnMessage(callbackQuery.Message, callbackQuery.Data, callbackQuery.From);
_checker.UserQueryProcessed(userId);
}
catch (Exception ex)
{
_logService.Write("CallbackQuery", ex, null);
}
}
public async Task HandleCallBackQuery(CallbackQuery callbackQuery)
{
var message = callbackQuery.Message;
if (!await IsUserAdmin(_client, callbackQuery.Message, callbackQuery.From))
{
var userMention = $"[{callbackQuery.From.FirstName} {callbackQuery.From.LastName}](tg://user?id={callbackQuery.From.Id})";
await _client.SendTextMessageAsync(message.Chat.Id, $"{userMention} Only admins can use this command.", ParseMode.Markdown);
return;
}
var chatConfig = await _chatConfigurationService.GetConfigurationByChatId(message.Chat.Id);
var enumTypeString = callbackQuery.Data.Split(".")[0];
if (enumTypeString == nameof(SupportedLanguages))
{
var languageSelectedString = callbackQuery.Data.Split(".")[1];
var languageSelected = Enum.GetValues(typeof(SupportedLanguages)).Cast <SupportedLanguages>().First(v => v.ToString() == languageSelectedString);
chatConfig.SelectedLanguage = languageSelected;
await _client.SendTextMessageAsync(message.Chat.Id, $"Language updated: {languageSelected.GetDescription()}");
}
else
{
var algorithmSelectedString = callbackQuery.Data.Split(".")[1];
var algorithmSelected = Enum.GetValues(typeof(GrammarAlgorithms)).Cast <GrammarAlgorithms>().First(v => v.ToString() == algorithmSelectedString);
chatConfig.GrammarAlgorithm = algorithmSelected;
await _client.SendTextMessageAsync(message.Chat.Id, $"Algorithm updated: {algorithmSelected.GetDescription()}");
}
await _chatConfigurationService.Update(chatConfig);
// Fire and forget
_ = _client.DeleteMessageAsync(callbackQuery.Message.Chat.Id, callbackQuery.Message.MessageId);
}
public async Task OnAnsweringOnSurvey(ApplicationContext context, CallbackQuery query, TelegramBotClient client)
{
int mark = Convert.ToInt32(query.Data.Split('-')[1]);
int questionId = Convert.ToInt32(query.Data.Split('-')[2]);
var chatID = query.From.Id;
Answer answer = new Answer();
answer.AnswerMark = mark;
answer.TelegramId = chatID;
answer.QuestionId = questionId;
context.Answers.Add(answer);
context.SaveChanges();
TelegramInlineKeyboard inlineKeyboard = new TelegramInlineKeyboard();
await client.EditMessageTextAsync(chatID, query.Message.MessageId,
"Спасибо за ваш ответ!\nВы можете продолжить ваши действия");
User user = context.Users.FirstOrDefault(n => n.TelegramId == chatID);
await UserDB.ChangeUserAction(context, chatID, Actions.AdminMode);
}
public static void GroupLang(CallbackQuery call, string[] args)
{
var chatid = long.Parse(args[1].Split('|')[0]);
var grp = Groups.FirstOrDefault(x => x.Id == chatid);
if (args[1].Split('|')[1] == "abort")
{
Bot.AnswerCallback(call, "Aborted.");
Bot.Edit(call.Message, "Aborted.");
return;
}
var lang = Language.All.FirstOrDefault(x => x.Name == args[1].Split('|')[1]) ?? Language.English;
grp.Language = lang;
SQL.ChangeGroup(grp);
Bot.AnswerCallback(call, "Language set: " + lang.Name);
Bot.Edit(call.Message, Methods.GetString(lang, "LanguageSet") + " " + lang.Name);
}
private Menu DeleteSession(CallbackQuery callback)
{
Menu menu;
var sessionId = SessionIdFromCallbackData(callback.data);
var session = GetSessionById(sessionId);
if (session == null)
{
menu = new NoMatchingSessionMenu(sessionId);
}
else
{
_sessions.Remove(session);
_database.RemoveSession(session);
menu = new DeleteSessionConfirmedMenu();
}
return(menu);
}
private async Task OnCallbackQuery(CallbackQuery callbackQuery)
{
try
{
await _callbackQueryHandler.HandleCallbackQueryAsync(callbackQuery);
}
catch (UnsupportedCommand exception)
{
Log.Error(exception, "Got a CallbackQuery with unsupported command");
}
catch (UnsupportedMenuItem exception)
{
Log.Error(exception, "Got a CallbackQuery with unsupported item");
}
catch (MessageIsNotModifiedException exception)
{
Log.Error(exception, "Got a MessageIsNotModifiedException when tried to process CallbackQuery");
}
}
protected override Response Run(CallbackQuery message, Account account, Dictionary <string, string> values)
{
int boardId = int.Parse(values["id"]);
Console.WriteLine(boardId);
try
{
var board = account.Controller.GetBoard(boardId);
var text = $@"Board: {board.Name}
Owner: {board.Owner?.Username}
{account.Controller.GetStatAboutBoard(board)}";
return(new Response().EditTextMessage(account.ChatId, message.Message.MessageId, text, ManageBoard(board)));
}
catch (Exception e)
{
Console.WriteLine(e);
return(new Response().TextMessage(account.ChatId, "No such board"));
}
}
public void SeeAll(int userId, TelegramBotClient botClient, CallbackQuery callback)
{
botClient.SendTextMessageAsync(callback.Message.Chat.Id, "Список ваших сохр. сайтов:");
var number = 0;
foreach (var s in GetSites())
{
if (s.UserId == userId)
{
number++;
botClient.SendTextMessageAsync(callback.Message.Chat.Id, $"{number}: {s.Name}");
}
}
botClient.SendTextMessageAsync(callback.Message.Chat.Id, "Пароль к какому сайту вы хотите увидеть?");
var sitesearch = new SiteSearch(botClient, GetSites());
var site = sitesearch.GetSite();
botClient.SendTextMessageAsync(callback.Message.Chat.Id, $"{site.Name} {site.Password} {site.Url}");
}
internal override async Task Execute(CallbackQuery message, TelegramBotClient client, UserInfo userInformation)
{
if (message.Data != null)
{
Registration_State_Machine.RegistrationState.DecipherRegistartionResult(message.Data,
out long pupilChatId, out bool resultRegistration);
var user = await BalDbController.GetUserInformationAsync(pupilChatId);
if (user.IsRegistred == true) //-V3080
{
return;
}
Registration_State_Machine.RegistrationState registration =
new Registration_State_Machine.RegistrationState(client, userInformation)
{
StateRegistration = Registration_State_Machine.RegistrationStateMachine
.WaitingForConfirmation
};
string messageCreator = resultRegistration == true
? $"Користувач chatId: {pupilChatId} [{user.NameUser}](tg://user?id={pupilChatId}) додан до системи"
: $"Користувачеві chatId: {pupilChatId} [{user.NameUser}](tg://user?id={pupilChatId}) відмовлено";
await client.SendTextMessageAsync(chatId : AppSettings.ChatIdCreator, text : messageCreator,
parseMode : ParseMode.Markdown);
string messageAdmin = resultRegistration
? $"Користувач: [{user.NameUser}](tg://user?id={pupilChatId}) додан до системи"
: $"Користувачеві: [{user.NameUser}](tg://user?id={pupilChatId}) відмовлено";
await client.SendTextMessageAsync(chatId : userInformation.ChatId,
text : messageAdmin, ParseMode.Markdown);
await registration.HandleStateRegistrationAsync(new Message()
{
Text = resultRegistration.ToString(),
Chat = new Chat()
{
Id = pupilChatId
}
});
}
}
protected override void OnCallbackQuery(CallbackQuery query)
{
var cbargs = query?.Data.Split(' ');
switch (cbargs[0])
{
case "month":
var month = new Month((MonthName)Enum.Parse(typeof(MonthName), cbargs[2]), uint.Parse(cbargs[1]));
var mkeyboard = new InlineKeyboardMarkup
{
InlineKeyboard = Calendar.New(month)
};
Api.EditMessageReplyMarkup <Message>(new EditMessageReplyMarkup
{
ChatId = query.Message.Chat.Id,
MessageId = query.Message.MessageId,
ReplyMarkup = mkeyboard
});
break;
case "year":
var ykeyboard = new InlineKeyboardMarkup
{
InlineKeyboard = Calendar.New(uint.Parse(cbargs[1]))
};
Api.EditMessageReplyMarkup <Message>(new EditMessageReplyMarkup
{
ChatId = query.Message.Chat.Id,
MessageId = query.Message.MessageId,
ReplyMarkup = ykeyboard
});
break;
default:
Api.AnswerCallbackQuery(new AnswerCallbackQueryArgs
{
CallbackQueryId = query.Id,
Text = query.Data,
ShowAlert = true
});
break;
}
}
public async Task HandleCallbackQBlacklistMenu(CallbackQuery query, Service service)
{
var userSettings = await _dbWorker.FindUserSettingsAsync(query.From);
if (userSettings == null)
{
return;
}
var labels = await Methods.GetLabelsList(service);
var labelInfos = labels
.Where(l => (l.Type != "system") || CatergoriesLabels.List.Any(cl => cl.LabelId == l.Id))
.Select(l => new LabelInfo {
Name = CatergoriesLabels.ReturnLabelName(l.Id) ?? l.Name, LabelId = l.Id
});
await
_botActions.UpdateSettingsMenu(query.From, query.Message.MessageId, SettingsKeyboardState.BlackListMenu, SelectedOption.None, userSettings, null, labelInfos);
}
public async void Execute(TelegramBotClient botClient, System.Object message, System.Object paris, DataBaseContext baseContext)
{
CallbackQuery _message = message as CallbackQuery;
try
{
await botClient.EditMessageTextAsync
(
_message.From.Id,
_message.Message.MessageId,
"Меню: ",
replyMarkup : inlineButton.StartSettingsFour
);
}
catch (System.Exception ex)
{
System.Console.WriteLine("Exception: BackToSettingsFour : ICommandSettings - " + ex);
}
}
