288 lines
10 KiB
Kotlin
288 lines
10 KiB
Kotlin
package dev.inmo.plaguposter.triggers.timer
|
|
|
|
import com.soywiz.klock.DateFormat
|
|
import com.soywiz.klock.DateTime
|
|
import com.soywiz.klock.DateTimeTz
|
|
import com.soywiz.klock.Month
|
|
import com.soywiz.klock.Year
|
|
import dev.inmo.micro_utils.coroutines.runCatchingSafely
|
|
import dev.inmo.micro_utils.repos.unset
|
|
import dev.inmo.plaguposter.common.SuccessfulSymbol
|
|
import dev.inmo.plaguposter.common.UnsuccessfulSymbol
|
|
import dev.inmo.plaguposter.posts.models.PostId
|
|
import dev.inmo.tgbotapi.extensions.api.answers.answer
|
|
import dev.inmo.tgbotapi.extensions.api.delete
|
|
import dev.inmo.tgbotapi.extensions.api.edit.edit
|
|
import dev.inmo.tgbotapi.extensions.behaviour_builder.BehaviourContext
|
|
import dev.inmo.tgbotapi.extensions.behaviour_builder.triggers_handling.onMessageDataCallbackQuery
|
|
import dev.inmo.tgbotapi.extensions.utils.types.buttons.dataButton
|
|
import dev.inmo.tgbotapi.extensions.utils.types.buttons.inlineKeyboard
|
|
import dev.inmo.tgbotapi.extensions.utils.withContentOrNull
|
|
import dev.inmo.tgbotapi.types.buttons.InlineKeyboardMarkup
|
|
import dev.inmo.tgbotapi.utils.bold
|
|
import dev.inmo.tgbotapi.utils.buildEntities
|
|
import dev.inmo.tgbotapi.utils.row
|
|
|
|
object ButtonsBuilder {
|
|
private const val changeTimeData = "timer_time_hint"
|
|
private const val changeDateData = "timer_date_hint"
|
|
private const val changeHoursDataPrefix = "timer_h"
|
|
private const val changeMinutesDataPrefix = "timer_m"
|
|
private const val changeDayDataPrefix = "timer_d"
|
|
private const val changeMonthDataPrefix = "timer_M"
|
|
private const val changeYearDataPrefix = "timer_y"
|
|
private const val changeDateDataPrefix = "timer_s"
|
|
private const val cancelDateData = "timer_c"
|
|
private const val deleteDateDataPrefix = "timer_r"
|
|
val datePrintFormat = DateFormat("HH:mm, dd.MM.yyyy, zzz")
|
|
|
|
fun buildTimerButtons(
|
|
postId: PostId,
|
|
dateTime: DateTimeTz,
|
|
exists: Boolean
|
|
) = inlineKeyboard {
|
|
val unixMillis = dateTime.utc.unixMillisLong
|
|
row {
|
|
dataButton("Time (hh:mm):", changeTimeData)
|
|
dataButton(dateTime.hours.toString(), "$changeHoursDataPrefix $postId $unixMillis")
|
|
dataButton(dateTime.minutes.toString(), "$changeMinutesDataPrefix $postId $unixMillis")
|
|
}
|
|
row {
|
|
dataButton("Date (dd.mm.yyyy):", changeDateData)
|
|
dataButton("${dateTime.dayOfMonth}", "$changeDayDataPrefix $postId $unixMillis")
|
|
dataButton("${dateTime.month1}", "$changeMonthDataPrefix $postId $unixMillis")
|
|
dataButton("${dateTime.yearInt}", "$changeYearDataPrefix $postId $unixMillis")
|
|
}
|
|
|
|
row {
|
|
if (exists) {
|
|
dataButton("\uD83D\uDDD1", "$deleteDateDataPrefix $postId")
|
|
}
|
|
dataButton(UnsuccessfulSymbol, cancelDateData)
|
|
dataButton(SuccessfulSymbol, "$changeDateDataPrefix $postId $unixMillis")
|
|
}
|
|
}
|
|
|
|
fun buildTimerTextSources(
|
|
currentDateTime: DateTime,
|
|
previousTime: DateTime?
|
|
) = buildEntities {
|
|
previousTime ?.let {
|
|
+ "Previous timer time: " + bold(it.local.toString(datePrintFormat)) + "\n"
|
|
}
|
|
+"Currently editing time: " + bold(currentDateTime.local.toString(datePrintFormat))
|
|
}
|
|
|
|
suspend fun BehaviourContext.includeKeyboardHandling(
|
|
timersRepo: TimersRepo,
|
|
onSavePublishingTime: suspend (PostId, DateTime) -> Boolean
|
|
) {
|
|
fun buildKeyboard(
|
|
prefix: String,
|
|
postId: PostId,
|
|
values: Iterable<Int>,
|
|
min: DateTime = nearestAvailableTimerTime(),
|
|
dateConverter: (Int) -> DateTimeTz
|
|
): InlineKeyboardMarkup {
|
|
return inlineKeyboard {
|
|
values.chunked(6).forEach {
|
|
row {
|
|
it.forEach {
|
|
dataButton(it.toString(), "$prefix $postId ${dateConverter(it).utc.unixMillisLong.coerceAtLeast(min.unixMillisLong)}")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
suspend fun buildStandardDataCallbackQuery(
|
|
name: String,
|
|
prefix: String,
|
|
possibleValues: (DateTimeTz) -> Iterable<Int>,
|
|
dateTimeConverter: (Int, DateTimeTz) -> DateTimeTz
|
|
) {
|
|
val setPrefix = "${prefix}s"
|
|
onMessageDataCallbackQuery(Regex("$prefix .+")) {
|
|
val (_, rawPostId, rawDateTimeMillis) = it.data.split(" ")
|
|
val currentMillis = rawDateTimeMillis.toLongOrNull() ?: return@onMessageDataCallbackQuery
|
|
val currentDateTime = DateTime(currentMillis)
|
|
val currentDateTimeLocal = DateTime(currentMillis).local
|
|
val postId = PostId(rawPostId)
|
|
val previousTime = timersRepo.get(postId)
|
|
|
|
edit (
|
|
it.message.withContentOrNull() ?: return@onMessageDataCallbackQuery,
|
|
replyMarkup = buildKeyboard(
|
|
setPrefix,
|
|
postId,
|
|
possibleValues(currentDateTimeLocal)
|
|
) {
|
|
dateTimeConverter(it, currentDateTimeLocal)
|
|
}
|
|
) {
|
|
+buildTimerTextSources(currentDateTime, previousTime) + "\n"
|
|
+"You are about to edit $name"
|
|
}
|
|
}
|
|
|
|
onMessageDataCallbackQuery(Regex("$setPrefix .+")) {
|
|
val (_, rawPostId, rawDateTimeMillis) = it.data.split(" ")
|
|
|
|
val currentMillis = rawDateTimeMillis.toLongOrNull() ?: return@onMessageDataCallbackQuery
|
|
val currentDateTime = DateTime(currentMillis)
|
|
val postId = PostId(rawPostId)
|
|
val previousTime = timersRepo.get(postId)
|
|
edit(
|
|
it.message.withContentOrNull() ?: return@onMessageDataCallbackQuery,
|
|
replyMarkup = buildTimerButtons(
|
|
postId,
|
|
currentDateTime.local,
|
|
timersRepo.contains(postId)
|
|
)
|
|
) {
|
|
+buildTimerTextSources(currentDateTime, previousTime)
|
|
}
|
|
}
|
|
}
|
|
|
|
fun DateTimeTz.dateEq(other: DateTimeTz) = yearInt == other.yearInt && month0 == other.month0 && dayOfMonth == other.dayOfMonth
|
|
|
|
buildStandardDataCallbackQuery(
|
|
"hour",
|
|
changeHoursDataPrefix,
|
|
{
|
|
val now = nearestAvailableTimerTime().local
|
|
|
|
if (now.dateEq(it)) {
|
|
now.hours .. 23
|
|
} else {
|
|
0 .. 23
|
|
}
|
|
}
|
|
) { newValue, oldDateTime ->
|
|
DateTimeTz.local(
|
|
oldDateTime.local.copyDayOfMonth(hours = newValue),
|
|
oldDateTime.offset
|
|
)
|
|
}
|
|
|
|
buildStandardDataCallbackQuery(
|
|
"minute",
|
|
changeMinutesDataPrefix,
|
|
{
|
|
val now = nearestAvailableTimerTime().local
|
|
|
|
if (now.dateEq(it) && now.hours >= it.hours) {
|
|
now.minutes until 60
|
|
} else {
|
|
0 until 60
|
|
}
|
|
}
|
|
) { newValue, oldDateTime ->
|
|
DateTimeTz.local(
|
|
oldDateTime.local.copyDayOfMonth(minutes = newValue),
|
|
oldDateTime.offset
|
|
)
|
|
}
|
|
|
|
buildStandardDataCallbackQuery(
|
|
"day",
|
|
changeDayDataPrefix,
|
|
{
|
|
val now = nearestAvailableTimerTime().local
|
|
|
|
if (now.yearInt == it.yearInt && now.month0 == it.month0) {
|
|
now.dayOfMonth .. it.month.days(it.year)
|
|
} else {
|
|
1 .. it.month.days(it.year)
|
|
}
|
|
}
|
|
) { newValue, oldDateTime ->
|
|
DateTimeTz.local(
|
|
oldDateTime.local.copyDayOfMonth(dayOfMonth = newValue),
|
|
oldDateTime.offset
|
|
)
|
|
}
|
|
|
|
buildStandardDataCallbackQuery(
|
|
"month",
|
|
changeMonthDataPrefix,
|
|
{
|
|
val now = nearestAvailableTimerTime().local
|
|
|
|
if (now.year == it.year) {
|
|
now.month1 .. 12
|
|
} else {
|
|
1 .. 12
|
|
}
|
|
}
|
|
) { newValue, oldDateTime ->
|
|
DateTimeTz.local(
|
|
oldDateTime.local.copyDayOfMonth(month = Month(newValue)),
|
|
oldDateTime.offset
|
|
)
|
|
}
|
|
|
|
buildStandardDataCallbackQuery(
|
|
"year",
|
|
changeYearDataPrefix,
|
|
{
|
|
val now = nearestAvailableTimerTime().local
|
|
(now.year.year .. (now.year.year + 5))
|
|
}
|
|
) { newValue, oldDateTime ->
|
|
DateTimeTz.local(
|
|
oldDateTime.local.copyDayOfMonth(year = Year(newValue)),
|
|
oldDateTime.offset
|
|
)
|
|
}
|
|
|
|
onMessageDataCallbackQuery(changeTimeData) {
|
|
answer(it, "Use the buttons to the right to set post publishing time (hh:mm)", showAlert = true)
|
|
}
|
|
|
|
onMessageDataCallbackQuery(changeDateData) {
|
|
answer(it, "Use the buttons to the right to set post publishing date (dd.MM.yyyy)", showAlert = true)
|
|
}
|
|
|
|
onMessageDataCallbackQuery(Regex("$changeDateDataPrefix .*")) {
|
|
val (_, rawPostId, rawDateTimeMillis) = it.data.split(" ")
|
|
val currentMillis = rawDateTimeMillis.toLongOrNull() ?: return@onMessageDataCallbackQuery
|
|
val currentDateTime = DateTime(currentMillis)
|
|
val postId = PostId(rawPostId)
|
|
|
|
val success = runCatchingSafely {
|
|
onSavePublishingTime(postId, currentDateTime)
|
|
}.getOrElse { false }
|
|
|
|
answer(
|
|
it,
|
|
if (success) "Successfully set timer" else "Unable to set timer"
|
|
)
|
|
|
|
it.message.delete(this)
|
|
}
|
|
|
|
onMessageDataCallbackQuery(Regex("$deleteDateDataPrefix .*")) {
|
|
val (_, rawPostId) = it.data.split(" ")
|
|
val postId = PostId(rawPostId)
|
|
|
|
val success = runCatchingSafely {
|
|
timersRepo.unset(postId)
|
|
true
|
|
}.getOrElse { false }
|
|
|
|
answer(
|
|
it,
|
|
if (success) "Successfully unset timer" else "Unable to unset timer"
|
|
)
|
|
|
|
it.message.delete(this)
|
|
}
|
|
|
|
onMessageDataCallbackQuery(cancelDateData) {
|
|
delete(it.message)
|
|
}
|
|
}
|
|
}
|