gear-orders/orders.py

import logging
import datetime
import asyncio

from db.constants import TIMELINE_ORDER_CONFIRMED, TIMELINE_ORDER_NOT_PUNISHED, TIMELINE_ORDER_PUNISHED
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, timeline_event_put
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 { "reason": "Cannot issue order without mastodon username" }

      orders_info = generate_order(orders_pool)

      if 'orders' not in orders_info:
          logger.info(f"{orders_pool} - {orders_info['reason']}")
          await order_telegram_post_none(session, orders_pool)
          return { "reason": orders_info['reason'] }

      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" : order_status_put(
          orders_pool,
          orders_pool.user,
          m_status['id'],
          created_at,
          due_at,
          orders_str
        ),
        "mastodon_status": m_status
      }

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}')
        return { "reason": "No punishment pool"}

    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']
    )

    return {
        "order_status": order_status_put(
            punishment_pool,
            order_status.user,
            punishment_status['id'],
            punishment_status['created_at'],
            None,
            punishment_str,
            punishment_for=order_status
        ),
        "mastodon_status": punishment_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))
                    timeline_event_put(
                        TIMELINE_ORDER_CONFIRMED,
                        f'Order confirmed - {order_status.text.split("\n")[0]}',
                        order_status.user,
                        order_status.pool,
                        order_status,
                        extra={
                            "mastodon_status_url": d['url']
                        }
                    )
                    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)

                    issue_result = await punishment_issue(session, order_status)

                    if 'order_status' in issue_result:
                        punishment_status = issue_result['order_status']
                        timeline_event_put(
                            TIMELINE_ORDER_PUNISHED,
                            f'Order punished - {punishment_status.text.split("\n")[0]}',
                            punishment_status.user,
                            punishment_status.pool,
                            punishment_status,
                            extra={
                                "mastodon_status_url": issue_result['mastodon_status']['url']
                            }
                        )
                    elif 'reason' in issue_result:
                        timeline_event_put(
                            TIMELINE_ORDER_NOT_PUNISHED,
                            f'Order not punished - {issue_result['reason']}',
                            order_status.user,
                            order_status.pool,
                            order_status
                        )