Programming Jan/Feb 2021

import math

def figure_out_base_sixty(number: int) -> (int, int):
    """Figure out the next number up if I have more than 59 seconds or minutes."""
    if number > 59:
        return math.floor(number/60), number % 60
    else:
        return 0, number

def sum_timestamps(timestamps: list) -> str:
    """Accept a list of timestamps (in the format of MM:SS or HH:MM:SS) and return a timestamp that is the sum of all
    given times.

    :param timestamps: A list of timestamps.
    :type timestamps: list
    :returns: Timestamp sum of all times in the list.
    """
    split_time = [timestamp.split(':') for timestamp in timestamps]
    hours = []
    minutes = []
    seconds = []
    for timestamp in split_time:
        if len(timestamp) == 2:
            minutes.append(int(timestamp[0]))
            seconds.append(int(timestamp[1]))
        else:
            hours.append((int(timestamp[0])))
            minutes.append(int(timestamp[1]))
            seconds.append(int(timestamp[2]))
    total_hours_step_1 = sum(hours)
    total_minutes_step_1 = sum(minutes)
    total_seconds_step_1 = sum(seconds)
    minutes_to_add, total_seconds_final = figure_out_base_sixty(total_seconds_step_1)
    total_minutes_step2 = total_minutes_step_1 + minutes_to_add
    if total_minutes_step2 > 59 or hours:
        calculated_hours, total_minutes = figure_out_base_sixty(total_minutes_step2)
        final_hours = calculated_hours + total_hours_step_1
        return f"{final_hours}:{total_minutes:02d}:{total_seconds_final:02d}"
    else:
        total_minutes = total_minutes_step2
        return f"{total_minutes}:{total_seconds_final:02d}"

{
"value1": "the name of your game",
"value2": "the player's Steam name",
"value3": "the turn number"
}

{
"gameName": "the name of your game",
"userName": "the user's Steam username",
"round": the round number (int),
"civName": "the name of your civilization",
"leaderName": "the name of your civ leader (and for some of them the attribute)"
}

from flask import Flask, request, Response, jsonify
import json
import logging

import matrix_bot

app = Flask(__name__)
flask_matrix_bot = matrix_bot.MatrixBot()
most_recent_games = dict()
logging.basicConfig(level=logging.DEBUG, format='%(levelname)s- %(asctime)s - %(message)s')

try:
    with open('most_recent_games.json', 'r') as file:
        most_recent_games = json.load(file)
        logging.debug("JSON file loaded.")
except FileNotFoundError:
    logging.warning("Prior JSON file not found. If this is your first run, this is OK.")

def player_name_to_matrix_name(player_name: str) -> str:
    if player_name == "One Oh Eight":
        return "Dan"
    elif player_name == "TheDJOtaku":
        return "Eric"
    elif player_name == "Wedge":
        return "David"
    else:
        return player_name

@app.route('/webhook', methods=['POST'])
def respond():
    logging.debug(f'JSON from Play By Cloud: {request.json}')
    game_name = request.json.get('value1')
    player_name = player_name_to_matrix_name(request.json.get('value2'))
    turn_number = request.json.get('value3')
    if game_name in most_recent_games.keys():
        if most_recent_games[game_name]['player_name'] != player_name:
            logging.debug("Game exists, but this is not a duplicate")
            message = f"Hey, {player_name}, it's your turn in {game_name}. The game is on turn {turn_number}"
            flask_matrix_bot.main(message)
            most_recent_games[game_name] = {'player_name': player_name, 'turn_number': turn_number}
        else:
            logging.debug("Game exists and this is a duplicate entry.")
    else:
        most_recent_games[game_name] = {'player_name': player_name, 'turn_number': turn_number}
        logging.debug("New game.")
        message = f"Hey, {player_name}, it's your turn in {game_name}. The game is on turn {turn_number}"
        flask_matrix_bot.main(message)
    with open('most_recent_games.json', 'w') as file:
        json.dump(most_recent_games, file)
    return Response(status=200)

@app.route('/pydt', methods=['POST'])
def respond_pydt():
    logging.debug(f'JSON from PYDT: {request.json}')
    game_name = request.json.get('gameName')
    player_name = player_name_to_matrix_name(request.json.get('userName'))
    turn_number = request.json.get('round')
    civ_name = request.json.get('civName')
    leader_name = request.json.get('leaderName')
    message = f"Hey, {player_name}, {leader_name} is waiting for you to command {civ_name} in {game_name}. " \
              f"The game is on turn {turn_number}"
    flask_matrix_bot.main(message)
    most_recent_games[game_name] = {'player_name': player_name, 'turn_number': turn_number}
    with open('most_recent_games.json', 'w') as file:
        json.dump(most_recent_games, file)
    return Response(status=200)

@app.route('/recent_games', methods=['GET'])
def return_recent_games():
    return jsonify(most_recent_games)

"""Provide ability to listen for commands from Matrix."""

import asyncio
import json
import logging
from nio import AsyncClient
import requests

# testing
# URL = "http://localhost:5000/recent_games"
# production
URL = "<YOUR SERVER URL>"

logging.basicConfig(level=logging.INFO, format='%(levelname)s - %(asctime)s - %(message)s')

class ListenerMatrixBot:
    """A bot to send alerts about the game to Matrix"""
    def __init__(self):
        try:
            with open('matrix.conf') as file:
                self.config = json.load(file)
                logging.debug("Listener Matrix Config loaded.")
                file.close()
        except FileNotFoundError:
            logging.warning(f"Settings not found.")

    async def login(self):
        client = AsyncClient(self.config.get('server'), self.config.get('username'))
        response = await client.login(password=self.config.get("password"))
        logging.info(f"Listener Login response: {response}")
        logging.debug(f"Listener Room would be: {self.config.get('room')}")
        return client

    @staticmethod
    def get_current_games():
        """Get the list of games from the recent games endpoint.

        :returns: A dictionary of the games, next player, and turn number.
        """
        response = requests.get(URL)
        return dict(response.json())

    def format_current_games(self):
        """Format the list of current games for display in Matrix server."""
        return_text = "Here is a list of the games currently known about on the server:\n"
        response_dictionary = self.get_current_games()
        for key in response_dictionary:
            game = key
            player = response_dictionary[key].get('player_name')
            turn_number = response_dictionary[key].get('turn_number')
            return_text += f"{game} awaiting turn {turn_number} by {player}\n"
            logging.debug(return_text)
        return return_text

    def format_blame_games(self, player_name: str) -> str:
        number_of_games = 0
        return_text = ""
        response_dictionary = self.get_current_games()
        for key in response_dictionary:
            game = key
            turn_number = response_dictionary[key].get('turn_number')
            if response_dictionary[key].get('player_name') == player_name:
                return_text += f"{game} awaiting turn {turn_number} by {player_name}\n"
                number_of_games += 1
        if number_of_games > 0:
            return f"There are {number_of_games} games waiting for {player_name} to take their turn:\n" + return_text
        else:
            return f"There aren't any games waiting for {player_name}. Great job!"

    async def main(self):
        my_client = await self.login()
        with open('next_batch', 'r') as next_batch_token:
            my_client.next_batch = next_batch_token.read()
        while True:
            sync_response = await my_client.sync(30000)
            with open('next_batch', 'w') as next_batch_token:
                next_batch_token.write(sync_response.next_batch)
            if len(sync_response.rooms.join) > 0:
                joins = sync_response.rooms.join
                for room_id in joins:
                    for event in joins[room_id].timeline.events:
                        if hasattr(event, 'body'):
                            if event.body.startswith("!Civ_Bot current games"):
                                data_to_send = self.format_current_games()
                                logging.debug(data_to_send)
                                content = {"body": data_to_send, "msgtype": "m.text"}
                                await my_client.room_send(room_id, 'm.room.message', content)
                            elif event.body.startswith("!Civ_Bot help"):
                                data_to_send = ("""Current Commands:
                            !Civ_Bot help - this message
                            !Civ_Bot current games - the list of games Civ_Bot currently knows about.
                            !Civ_Bot blame <Matrix Username> - list of games waiting on that person.""")
                                content = {"body": data_to_send, "msgtype": "m.text"}
                                await my_client.room_send(room_id, 'm.room.message', content)
                            elif event.body.startswith("!Civ_Bot blame"):
                                player = event.body.lstrip("!Civ_Bot blame ")
                                data_to_send = self.format_blame_games(player)
                                logging.debug(data_to_send)
                                content = {"body": data_to_send, "msgtype": "m.text"}
                                await my_client.room_send(room_id, 'm.room.message', content)

my_matrix_bot = ListenerMatrixBot()
asyncio.run(my_matrix_bot.main())