slork/cron.py

import json
import requests
import sqlite3
import sys
import time
import settings
from pprint import pprint


def send_notification(maintainer, player, property, old_value, new_value):
    query = """SELECT discord FROM discord WHERE maintainer = ?;"""
    conn = sqlite3.connect(settings.db_path + '/slork.sqlite')
    conn.row_factory = sqlite3.Row
    cur = conn.cursor()
    cur.execute(query, (maintainer,))
    discord = cur.fetchone()['discord']
    query = """SELECT value FROM player
        WHERE maintainer = ?
        AND player = ?
        AND property = 'name';"""
    cur.execute(query, (maintainer, player))
    name = '?'
    val = cur.fetchone()
    if val:
        name = val['value']
    message = f"{name} [{player}] property '{property}' changed from {old_value} to {new_value}"
    message_json = {"content": message}
    response = requests.post(discord, json=message_json)
    if response.status_code in [200, 204]:
        print("Webhook executed")
    else:
        print("status code {}: {}".format(response.status_code, response.content.decode("utf-8")))
        if response.status_code == int(429):
            sys.exit(1)
    conn.close()

def update_value(maintainer, player, property, new_value):
    print(f"update_value({maintainer}, {player}, {property}, {new_value})")
    query = """INSERT OR REPLACE INTO player (maintainer, player, property, value)
        VALUES (?, ?, ?, ?)"""
    conn = sqlite3.connect(settings.db_path + '/slork.sqlite')
    conn.row_factory = sqlite3.Row
    cur = conn.cursor()
    cur.execute(query, (maintainer, player, property, new_value))
    conn.commit()
    conn.close()

def update_missing_value(maintainer, player, property, value):
    print(f"update_missing_value({maintainer}, {player}, {property}, {value})")
    query = """INSERT OR REPLACE INTO player (maintainer, player, property, value)
        VALUES (?, ?, ?, ?);"""
    conn = sqlite3.connect(settings.db_path + '/slork.sqlite')
    cur = conn.cursor()
    cur.execute(query, (maintainer, player, property, value))
    conn.commit()
    conn.close()

def cron():
    query_first = """SELECT player_properties.maintainer,
            maintainer.api, player_properties.player,
            player_properties.property
            FROM player_properties
            JOIN maintainer ON player_properties.maintainer = maintainer.maintainer;"""
    conn = sqlite3.connect(settings.db_path + '/slork.sqlite')
    conn.row_factory = sqlite3.Row
    cur = conn.cursor()
    cur.execute(query_first)

    for row in cur.fetchall():
        print(f"{row['maintainer']} - {row['api']} - {row['player']} - {row['property']}")
        url = f"https://api.torn.com/user/{row['player']}?selections=personalstats,basic&key={row['api']}"
        print(url)
        response = requests.get(url)
        player_json = None
        print(response.text[:10])
        if response and response.text:
            player_json = json.loads(response.text)
            # pprint(faction_json)
        if 'error' in player_json:
            pprint(faction_json)
            break

        # Check for changes
        properties = json.loads(row['property'])
        if 'name' not in properties:
            properties.append(name)
        pprint(properties)
        query_second = """SELECT player.value, properties.parent
            FROM player
            JOIN properties ON player.property = properties.property
            WHERE maintainer = ?
            AND player = ?
            AND player.property = ?;"""
        retrieved_properties = []
        for property in properties:
            pprint((row['maintainer'], row['player'], property,))
            cur.execute(query_second, (row['maintainer'], row['player'], property,))
            p_row = cur.fetchone()
            if not p_row:
                continue
            print(f"property: '{property}' parent: '{p_row['parent']}' -> value: '{p_row['value']}'")
            retrieved_properties.append(property)
            new_value = ''
            if (p_row['parent']):
                new_value = player_json[p_row['parent']][property]
            else:
                new_value = player_json[property]
            print(f"p_row['value']: {p_row['value']} != new_value: '{new_value}'")
            if str(p_row['value']) != str(new_value):
                send_notification(row['maintainer'], row['player'], property, p_row['value'], new_value)
                update_value(row['maintainer'], row['player'], property, new_value)
        new_properties = []
        print(f"len(properties): {len(properties)}")
        print(f"len(retrieved_properties): {len(retrieved_properties)}")
        for item in properties:
            if item not in retrieved_properties:
                new_properties.append(item)
        if len(new_properties) > 0:
            print(f"len(new_properties): {len(new_properties)}")
            for item in new_properties:
                query_third = """SELECT parent FROM properties where property = ?;"""
                cur.execute(query_third, (item,))
                parent = cur.fetchone()['parent']
                if (parent):
                    value = player_json[parent][item]
                else:
                    try:
                        value = player_json[item]
                    except KeyError:
                        query_fourth = """INSERT INTO properties (property, parent)
                            VALUES (?, 'personalstats')"""
                         cur.execute(query_fourth, (item,))
                print(f"item: {item} -> value: {value}")
                update_missing_value(row['maintainer'], row['player'], item, value)
        time.sleep(1)
    conn.close()

if __name__ == '__main__':
    cron()