pllist/internal/telegram/item/callbacks.go

package item

import (
	"context"
	"errors"

	"github.com/mymmrac/telego"
	th "github.com/mymmrac/telego/telegohandler"

	"git.entityseven.com/rilaxik/pllist/internal/domain"
	"git.entityseven.com/rilaxik/pllist/internal/service"
	"git.entityseven.com/rilaxik/pllist/internal/telegram/shared"
)

func (h *Handler) listCallback(ctx *th.Context, query telego.CallbackQuery) error {
	listID, err := shared.CallbackID(query.Data, shared.ActionListOpen)
	if err != nil {
		return err
	}
	return h.ShowList(ctx, shared.UserFrom(ctx).ID,
		shared.QueryChatID(query), shared.QueryMessageID(query), listID)
}

func (h *Handler) pageCallback(ctx *th.Context, query telego.CallbackQuery) error {
	listID, page, err := parsePage(query.Data)
	if err != nil {
		return err
	}
	return h.ShowItems(ctx, shared.UserFrom(ctx).ID,
		shared.QueryChatID(query), shared.QueryMessageID(query), listID, page)
}

func (h *Handler) manageCallback(ctx *th.Context, query telego.CallbackQuery) error {
	listID, err := shared.CallbackID(query.Data, callbackManage)
	if err != nil {
		return err
	}
	return h.ShowItems(ctx, shared.UserFrom(ctx).ID,
		shared.QueryChatID(query), shared.QueryMessageID(query), listID, 1)
}

func (h *Handler) addCallback(ctx *th.Context, query telego.CallbackQuery) error {
	listID, err := shared.CallbackID(query.Data, callbackAdd)
	if err != nil {
		return err
	}
	user := shared.UserFrom(ctx)
	if _, err := h.access.Authorize(ctx, user.ID, listID, domain.ActionAddItem); err != nil {
		return err
	}
	h.pending.Set(user.TelegramID, service.Pending{
		Action: service.PendingCreateItem,
		ListID: listID,
	})
	return h.sender.Send(ctx, shared.QueryChatID(query), addItemPrompt, nil)
}

func (h *Handler) itemCallback(ctx *th.Context, query telego.CallbackQuery) error {
	itemID, err := shared.CallbackID(query.Data, callbackItem)
	if err != nil {
		return err
	}
	return h.showItem(ctx, shared.UserFrom(ctx).ID,
		shared.QueryChatID(query), shared.QueryMessageID(query), itemID)
}

func (h *Handler) editTitleCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.promptItemEdit(ctx, query, callbackEditTitle, service.PendingRenameItem, renameItemPrompt)
}

func (h *Handler) editNoteCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.promptItemEdit(ctx, query, callbackEditNote, service.PendingEditItemNote, notePrompt)
}

func (h *Handler) editQuantityCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.promptItemEdit(ctx, query, callbackEditQuantity, service.PendingEditItemQuantity, quantityPrompt)
}

func (h *Handler) promptItemEdit(
	ctx *th.Context,
	query telego.CallbackQuery,
	callbackAction shared.CallbackAction,
	action service.PendingAction,
	prompt string,
) error {
	itemID, err := shared.CallbackID(query.Data, callbackAction)
	if err != nil {
		return err
	}
	user := shared.UserFrom(ctx)
	if _, err := h.items.Authorize(ctx, user.ID, itemID, domain.ActionEditItem); err != nil {
		return err
	}
	h.pending.Set(user.TelegramID, service.Pending{
		Action: action,
		ItemID: itemID,
	})
	return h.sender.Send(ctx, shared.QueryChatID(query), prompt, nil)
}

func (h *Handler) clearNoteCallback(ctx *th.Context, query telego.CallbackQuery) error {
	itemID, err := shared.CallbackID(query.Data, callbackClearNote)
	if err != nil {
		return err
	}
	user := shared.UserFrom(ctx)
	if err := h.items.SetNote(ctx, user.ID, itemID, ""); err != nil {
		return err
	}
	return h.showItem(ctx, user.ID,
		shared.QueryChatID(query), shared.QueryMessageID(query), itemID)
}

func (h *Handler) lowUrgencyCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.setUrgency(ctx, query, callbackUrgencyLow, domain.UrgencyLow)
}

func (h *Handler) normalUrgencyCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.setUrgency(ctx, query, callbackUrgencyNorm, domain.UrgencyNormal)
}

func (h *Handler) highUrgencyCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.setUrgency(ctx, query, callbackUrgencyHigh, domain.UrgencyHigh)
}

func (h *Handler) setUrgency(
	ctx *th.Context, query telego.CallbackQuery, action shared.CallbackAction, urgency domain.Urgency,
) error {
	itemID, err := shared.CallbackID(query.Data, action)
	if err != nil {
		return err
	}
	user := shared.UserFrom(ctx)
	if err := h.items.SetUrgency(ctx, user.ID, itemID, urgency); err != nil {
		return err
	}
	return h.showItem(ctx, user.ID,
		shared.QueryChatID(query), shared.QueryMessageID(query), itemID)
}

func (h *Handler) doneCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.mutateItem(ctx, query, callbackDone, h.items.SetDone)
}

func (h *Handler) reopenCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.mutateItem(ctx, query, callbackReopen, h.items.Reopen)
}

func (h *Handler) reserveCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.mutateItem(ctx, query, callbackReserve, h.items.Reserve)
}

func (h *Handler) releaseCallback(ctx *th.Context, query telego.CallbackQuery) error {
	return h.mutateItem(ctx, query, callbackRelease, h.items.Release)
}

func (h *Handler) mutateItem(
	ctx *th.Context,
	query telego.CallbackQuery,
	action shared.CallbackAction,
	mutate func(context.Context, int64, int64) error,
) error {
	itemID, err := shared.CallbackID(query.Data, action)
	if err != nil {
		return err
	}
	user := shared.UserFrom(ctx)
	if err := mutate(ctx, user.ID, itemID); err != nil && !errors.Is(err, domain.ErrConflict) {
		return err
	}
	return h.showItem(ctx, user.ID,
		shared.QueryChatID(query), shared.QueryMessageID(query), itemID)
}

func (h *Handler) deleteCallback(ctx *th.Context, query telego.CallbackQuery) error {
	itemID, err := shared.CallbackID(query.Data, callbackDelete)
	if err != nil {
		return err
	}
	user := shared.UserFrom(ctx)
	if _, err := h.items.Authorize(ctx, user.ID, itemID, domain.ActionDeleteItem); err != nil {
		return err
	}
	return h.sender.EditOrSend(ctx, shared.QueryChatID(query), shared.QueryMessageID(query),
		deleteItemText, deleteItemKeyboard(itemID))
}

func (h *Handler) deleteYesCallback(ctx *th.Context, query telego.CallbackQuery) error {
	itemID, err := shared.CallbackID(query.Data, callbackDeleteYes)
	if err != nil {
		return err
	}
	user := shared.UserFrom(ctx)
	itemAccess, err := h.items.Authorize(ctx, user.ID, itemID, domain.ActionDeleteItem)
	if err != nil {
		return err
	}
	if err := h.items.Delete(ctx, user.ID, itemID); err != nil {
		return err
	}
	return h.ShowItems(ctx, user.ID,
		shared.QueryChatID(query), shared.QueryMessageID(query), itemAccess.Item.ListID, 1)
}