private async Task<InlineKeyboardMarkup> PrepareKeyboardAsync(Identified<Tobacco> tobacco)
{
const byte defaultCount = 5;
var buttons = new List<IEnumerable<InlineKeyboardButton>>();
var dbUser = UserContextProvider.DatabaseUser;
var orderId = await cacheProvider
.UserLevel<CurrentOrder>()
.GetAsync();
if (orderId.HasValue)
{
var orderSomeGramsFormat = await TranslationsResolver
.ResolveAsync(TelegramTranslationKeys.OrderSomeGrams);
var innerButtons = new List<InlineKeyboardButton>();
for (var i = defaultCount; i < defaultCount * 4 + 1; i *= 2)
{
innerButtons.Add(new InlineKeyboardButton
{
Text = string.Format(orderSomeGramsFormat, i),
CallbackData =
$"/{nameof(AddToOrderCommand).ExtractCommandName()} {orderId} {nameof(Tobacco)} {tobacco.Index} {i}"
});
}
buttons.Add(innerButtons);
}
if (dbUser.State > TelegramUserStates.Default)
{
var (key, command) = tobacco.Entity.Photos.Any()
? (TelegramTranslationKeys.DeletePhotos, nameof(DeleteTobaccoPhotosCommand))
: (TelegramTranslationKeys.SetPhotos, nameof(AskForTobaccoPhotosCommand));
var (deleteTranslation, secondTranslation) = await TranslationsResolver
.ResolveAsync(
TelegramTranslationKeys.Delete,
key
);
buttons.AddRange(new[]
{
new[]
{
new InlineKeyboardButton
{
Text = deleteTranslation,
CallbackData = $"/{nameof(DeleteTobaccoCommand).ExtractCommandName()} {tobacco.Index}"
}
},
new[]
{
new InlineKeyboardButton
{
Text = secondTranslation,
CallbackData =
$"/{command.ExtractCommandName()} {tobacco.Entity.Id}"
}
}
});
}
return new InlineKeyboardMarkup(buttons);
}
protected override async Task <InlineKeyboardButton[]> ProcessAsync()
{
var(statusCache, currentOrderCache) =
(cacheProvider.UserLevel <UserTemporaryStatus>(),
cacheProvider.UserLevel <CurrentOrder>());
await statusCache.SetAsync(UserTemporaryStatus.InOrder);
var cachedOrderId = await currentOrderCache.GetAsync();
if (cachedOrderId.HasValue)
{
return new[]
{
new InlineKeyboardButton
{
Text = await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.ViewCurrentOrder),
CallbackData = $"/{nameof(GetOrderCommand).ExtractCommandName()} {cachedOrderId}"
//todo
}
}
}
;
var order = new Order();
hookrRepository.Context.Orders.Add(order);
await hookrRepository.SaveChangesAsync();
await currentOrderCache.SetAsync(order.Id);
return(Array.Empty <InlineKeyboardButton>());
}
protected override async Task <Message> SendResponseAsync(ICurrentTelegramUserClient client, Tobacco[] response)
=> await client
.SendTextMessageAsync(response.Any()
?response
.AggregateListString("/{0} {1} - {2}",
x => x.Name,
x => x.Price)
: await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.NoTobaccos));
private async Task <InlineKeyboardMarkup> PrepareKeyboardAsync(Identified <Hookah> hookah)
{
const byte defaultCount = 1;
var buttons = new List <IEnumerable <InlineKeyboardButton> >();
var dbUser = UserContextProvider.DatabaseUser;
var orderId = await cacheProvider
.UserLevel <CurrentOrder>()
.GetAsync();
if (orderId.HasValue)
{
buttons.Add(new[]
{
new InlineKeyboardButton
{
Text = await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.OrderSomething),
CallbackData =
$"/{nameof(AddToOrderCommand).ExtractCommandName()} {orderId} {nameof(Hookah)} {hookah.Index} {defaultCount}"
}
});
}
if (dbUser.State > TelegramUserStates.Default)
{
var(key, command) = hookah.Entity.Photos.Any()
? (TelegramTranslationKeys.DeletePhotos, nameof(DeleteHookahPhotosCommand))
: (TelegramTranslationKeys.SetPhotos, nameof(AskForHookahPhotosCommand));
var(deleteTranslation, secondTranslation) = await TranslationsResolver
.ResolveAsync(
TelegramTranslationKeys.Delete,
key
);
buttons.AddRange(new[]
{
new[]
{
new InlineKeyboardButton
{
Text = deleteTranslation,
CallbackData = $"/{nameof(DeleteHookahCommand).ExtractCommandName()} {hookah.Index}"
}
},
new[]
{
new InlineKeyboardButton
{
Text = secondTranslation,
CallbackData =
$"/{command.ExtractCommandName()} {hookah.Entity.Id}"
},
}
});
}
return(new InlineKeyboardMarkup(buttons));
}
protected override async Task <Message> SendResponseAsync(ICurrentTelegramUserClient client)
=> await client
.SendTextMessageAsync(await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.Welcome),
replyMarkup : new ReplyKeyboardMarkup
{
OneTimeKeyboard = true,
ResizeKeyboard = true,
Keyboard = Array.Empty <IEnumerable <KeyboardButton> >()
});
private async Task <IEnumerable <InlineKeyboardButton> > GetServiceButtonsAsync(Order order)
{
switch (order.State)
{
case OrderStates.Confirmed:
{
var(approveTranslated, rejectTranslated) =
await TranslationsResolver
.ResolveAsync(TelegramTranslationKeys.Approve, TelegramTranslationKeys.Reject);
return(new[]
{
new InlineKeyboardButton
{
Text = approveTranslated,
CallbackData = $"/{nameof(ApproveOrderCommand).ExtractCommandName()} {order.Id}"
},
new InlineKeyboardButton
{
Text = rejectTranslated,
CallbackData = $"/{nameof(RejectOrderCommand).ExtractCommandName()} {order.Id}"
},
});
}
case OrderStates.Approved:
return(new[]
{
new InlineKeyboardButton
{
Text = await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.Process),
CallbackData = $"/{nameof(ProcessOrderCommand).ExtractCommandName()} {order.Id}"
},
});
case OrderStates.Processing:
return(new[]
{
new InlineKeyboardButton
{
Text = await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.Finish),
CallbackData = $"/{nameof(FinishOrderCommand).ExtractCommandName()} {order.Id}"
},
});
case OrderStates.Constructing:
case OrderStates.Rejected:
case OrderStates.Finished:
return(Array.Empty <InlineKeyboardButton>());
case OrderStates.Unknown:
default:
throw new ArgumentOutOfRangeException(nameof(order.State), order.State, null);
}
}
protected override async Task <Message> SendResponseAsync(ICurrentTelegramUserClient client,
Order response)
{
var buttons = new List <IEnumerable <InlineKeyboardButton> >();
var firstLayerButtons = new List <InlineKeyboardButton>();
var builder = new StringBuilder();
if (response.OrderedHookahs.Any() || response.OrderedTobaccos.Any())
{
builder.Append(StringifyResponse(response));
if (response.State == OrderStates.Constructing)
{
firstLayerButtons.Add(new InlineKeyboardButton
{
Text = await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.Confirm),
CallbackData = $"/{nameof(ConfirmOrderCommand).ExtractCommandName()} {response.Id}"
});
}
}
else
{
builder.Append("seems like there is no any data in order");
}
builder.Append($"\n\nStatus: *{response.State}*");
if (response.State == OrderStates.Constructing)
{
firstLayerButtons.Add(new InlineKeyboardButton
{
Text = await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.Delete),
CallbackData = $"/{nameof(DeleteOrderCommand).ExtractCommandName()} {response.Id}"
});
}
buttons.Add(firstLayerButtons);
if (UserContextProvider.DatabaseUser.State > TelegramUserStates.Default)
{
buttons.Add(await GetServiceButtonsAsync(response));
}
return(await client
.SendTextMessageAsync(builder.ToString(),
ParseMode.MarkdownV2,
replyMarkup : new InlineKeyboardMarkup(buttons)));
}
private async Task ValidateOrderAsync(Order order, TelegramUser user)
{
if (order == null)
{
throw new InsufficientAccessRightsException("Order not exist or you have no access.");
}
if (order.IsDeleted)
{
throw new OrderAlreadyDeletedException(await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.OrderAlreadyDeleted));
}
switch (user.State)
{
/*case TelegramUserStates.Dev:
* return;*/
case TelegramUserStates.Default when order.CreatedById != user.Id:
throw new InsufficientAccessRightsException("Seems like you have no access :(");
}
await CustomOrderAsyncValidator(order, user);
}
protected override async Task<Message> SendResponseAsync(ICurrentTelegramUserClient client,
Identified<Tobacco> response)
{
var (content, keyboard) = await (
TranslationsResolver.ResolveAsync(TelegramTranslationKeys.GetTobaccoResult, response.Entity.Name,
response.Entity.Price),
PrepareKeyboardAsync(response)
).CombineAsync();
if (response.Entity.Photos.Any())
{
await client.SendMediaGroupAsync(
response.Entity.Photos
.Select(x => new InputMediaPhoto(new InputMedia(x.TelegramFileId)))
);
}
return await client
.SendTextMessageAsync(
content,
replyMarkup: keyboard);
}
protected override async Task <Message> SendResponseAsync(ICurrentTelegramUserClient client, Order response) => await client .SendTextMessageAsync(await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.OrderHasBeenFinished, response.Id));
protected override Task <Message> SendResponseAsync(ICurrentTelegramUserClient client) => client .SendTextMessageAsync(() => TranslationsResolver.ResolveAsync(TelegramTranslationKeys.HookahRemoveSuccess));
protected override async Task <Message> SendResponseAsync(ICurrentTelegramUserClient client, Order response)
=> await client.SendTextMessageAsync(
await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.ConfirmOrderSuccess, response.Id));
protected override async Task <Message> SendResponseAsync(ICurrentTelegramUserClient client)
=> await client.SendTextMessageAsync(
await TranslationsResolver
.ResolveAsync(TelegramTranslationKeys.AddPhotoSuccess)
);
protected override async Task <Message> SendResponseAsync(ICurrentTelegramUserClient client) => await client .SendTextMessageAsync(await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.DeleteCommandSuccess, typeof(TEntity).Name));
protected override async Task <Message> SendResponseAsync(ICurrentTelegramUserClient client)
=> await client
.SendTextMessageAsync(
await TranslationsResolver.ResolveAsync(TelegramTranslationKeys.UserStateRegistrationSuccess,
StateToSet.ToString().ToLower())
);
