gear-orders/orders.py

import logging
import datetime
import asyncio

from util import make_session
from generate import generate_order, generate_punishment
from db.queries import order_status_by_id, order_status_put, order_status_confirm
from mastodon import Mastodon
from telegram.telegram import Telegram
from settings import ENV
from util import timezone

logger = logging.getLogger(__name__)

async def order_mastodon_post(session, orders_pool, orders_str, repeats, due_at):
    user = orders_pool.user

    post = "Here are today's orders for @%s -\n\n" % user.mastodon_account()
    post += orders_str + "\n\n"
    if repeats > 1:
        post += f"These are the same orders from the last {repeats} days\n\n"
    post += "Proof of compliance is due by " + due_at.strftime("%I:%M %p") + "\n\n"

    if ENV == 'dev':
        post += "⚠️ DEV"
    elif user.mastodon_attn_list:
        post += f"ATTN - {user.mastodon_attn_list}\n"

    m = Mastodon(session)
    return await m.statusPost(post)

async def order_telegram_post(session, orders_pool, orders_str, repeats, due_at, m_url):
    post = "Here are your orders -\n\n"
    post += orders_str + "\n\n"
    if repeats > 1:
        post += f"These are the same orders from the last {repeats} days\n\n"
    post += "Proof of compliance is due by " + due_at.strftime("%I:%M %p") + "\n\n"
    post += m_url
    if ENV == 'dev':
        post += "\n⚠️ DEV"

    t = Telegram(session)
    await t.message_send(orders_pool.user.telegram_chat_id, post)

async def order_telegram_post_need_mastodon(session, orders_pool):
    post = "Cannot issue an order without a mastodon username"
    if ENV == 'dev':
        post += "\n⚠️ DEV"

    t = Telegram(session)
    await t.message_send(orders_pool.user.telegram_chat_id, post)

async def order_telegram_post_none(session, orders_pool):
    post = "No orders for today"
    if ENV == 'dev':
        post += "\n⚠️ DEV"

    t = Telegram(session)
    await t.message_send(orders_pool.user.telegram_chat_id, post)

async def order_issue(orders_pool):
    async with make_session() as session:
      if orders_pool.user.mastodon_username is None:
          logger.info('Cannot issue order without mastodon username')
          await order_telegram_post_need_mastodon(session, orders_pool)
          return

      orders_info = generate_order(orders_pool)

      if 'orders' not in orders_info:
          logger.info("No orders for today")
          await order_telegram_post_none(session, orders_pool)
          return

      orders_str = "\n".join(orders_info['orders'])
      
      created_at = datetime.datetime.now(tz=timezone())
      if orders_pool.confirm_delay is not None:
        due_at = created_at + datetime.timedelta(hours=orders_pool.confirm_delay)

      repeats_count = orders_info.get('count', 0)

      m_status = await order_mastodon_post(
          session,
          orders_pool,
          orders_str,
          repeats_count,
          due_at
          )

      await order_telegram_post(
          session,
          orders_pool,
          orders_str,
          repeats_count,
          due_at,
          m_status['url']
          )

      return order_status_put(
          orders_pool,
          orders_pool.user,
          m_status['id'],
          created_at,
          due_at,
          orders_str
          )

async def punishment_mastodon_post(session, orders_pool, punishment_str, reply_id=None):
    user = orders_pool.user

    post = "@%s has failed to post proof of compliance. Here is the punishment -\n\n" % user.mastodon_account()
    post += punishment_str + "\n\n"
    
    if ENV == 'dev':
        post += "⚠️ DEV"
    elif user.mastodon_attn_list:
        post += f"ATTN - {user.mastodon_attn_list}\n"

    m = Mastodon(session)
    return await m.statusPost(
        post, 
        in_reply_to_id=reply_id
    )

async def punishment_telegram_post(session, orders_pool, punishment_str, m_url):
    post = "You failed to show proof of compliance. Here is your punishment -\n\n"
    post += punishment_str + "\n\n"
    post += m_url
    if ENV == 'dev':
        post += "\n\n⚠️ DEV"

    t = Telegram(session)
    await t.message_send(orders_pool.user.telegram_chat_id, post)

async def punishment_issue(session, order_status):
    if order_status.pool is None or order_status.pool.punishment_pool is None:
        logger.info(f'Unable to issue a punishment for {order_status.id}, no punishment pool for order pool {order_status.pool.name}')
        # TODO: No punishment mastodon/telegram posts
        return

    punishment_pool = order_status.pool.punishment_pool

    punishment = generate_punishment(punishment_pool)
    punishment_str = "\n".join(punishment['orders'])

    punishment_status = await punishment_mastodon_post(
        session,
        punishment_pool,
        punishment_str,
        order_status.mastodon_id,
    )

    await punishment_telegram_post(
        session,
        punishment_pool,
        punishment_str,
        punishment_status['url']
    )

    order_status_put(
        punishment_pool,
        order_status.user,
        punishment_status['id'],
        punishment_status['created_at'],
        None,
        punishment_str,
        punishment_for=order_status
    )

order_check_lock = asyncio.Lock()
async def order_check(order_status_id):
    async with order_check_lock:
        async with make_session() as session:
            order_status = order_status_by_id(order_status_id)

            if order_status.punishment.count() > 0:
                logger.info(f'Punishment already issued for {order_status.id}')
                return

            m = Mastodon(session)
            context = await m.statusContext(order_status.mastodon_id)

            confirmed_at = None
            for d in context['descendants']:
                if (
                    d['in_reply_to_id'] == order_status.mastodon_id and
                    d['account']['acct'] == order_status.user.mastodon_account() and
                    len(d['media_attachments']) > 0
                ):
                    confirmed_at = d['created_at']
                    order_status_confirm(order_status.id, confirmed_at)
                    logger.info('Confirmed order %s' % (order_status.id))
                    break
                
            if confirmed_at is None:
                logger.info('Order %s remains unconfirmed' % (order_status.id))

                due_at = datetime.datetime.fromisoformat(order_status.due_at)
                if(due_at < datetime.datetime.now(datetime.UTC)):
                    logger.info('Time to issue a punishment for %s' % order_status.id)

                    await punishment_issue(session, order_status)