Add all files

.gitignore

@@ -0,0 +1,8 @@
+.venv/
+.env
+__pycache__
+*.html
+*.log
+*.png
+jobs.json
+rival_regions_wrapper/

app/__init__.py

@@ -0,0 +1,76 @@
+"""Resource tracker"""
+
+import os
+import logging
+
+from dotenv import load_dotenv
+from apscheduler.schedulers.background import BackgroundScheduler
+
+from rival_regions_wrapper.rival_regions_wrapper import Client
+
+load_dotenv()
+
+SCHEDULER = BackgroundScheduler(
+    daemon=True,
+    job_defaults={'misfire_grace_time': 300},
+)
+SCHEDULER.start()
+
+# get logger
+LOGGER = logging.getLogger(__name__)
+LOGGER.setLevel(logging.INFO)
+SCHEDULER_LOGGER = logging.getLogger('apscheduler')
+SCHEDULER_LOGGER.setLevel(logging.DEBUG)
+
+# create file handler
+FILE_HANDLER = logging.FileHandler('output.log')
+FILE_HANDLER.setLevel(logging.DEBUG)
+
+# create console handler
+STREAM_HANDLER = logging.StreamHandler()
+STREAM_HANDLER.setLevel(logging.INFO)
+
+# create formatter and add it to the handlers
+FORMATTER = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+STREAM_HANDLER.setFormatter(FORMATTER)
+FILE_HANDLER.setFormatter(FORMATTER)
+
+# add the handlers to logger
+LOGGER.addHandler(STREAM_HANDLER)
+LOGGER.addHandler(FILE_HANDLER)
+SCHEDULER_LOGGER.addHandler(STREAM_HANDLER)
+SCHEDULER_LOGGER.addHandler(FILE_HANDLER)
+
+RR_WRAPPER = Client(show_window=os.environ['SHOW_WINDOW'].lower() == 'true')
+RR_WRAPPER.set_credentials({
+    'login_method': os.environ['LOGIN_METHOD'],
+    'username': os.environ['USERNAME'],
+    'password': os.environ['PASSWORD']
+})
+
+STATE_ID = os.environ['STATE_ID']
+CAPITAL_ID = os.environ['CAPITAL_ID']
+
+RESOURCE_IDS = {
+    0: 'gold',
+    3: 'oil',
+    4: 'ore',
+    11: 'uranium',
+    15: 'diamond',
+}
+
+RESOURCE_NAMES = {
+    'gold': 0,
+    'oil': 3,
+    'ore': 4,
+    'uranium': 11,
+    'diamond': 15,
+}
+
+RESOURCE_MAX = {
+    0: 2500,
+    3: 600,
+    4: 500,
+    11: 60,
+    15: 75,
+}

app/__main__.py

@@ -0,0 +1,38 @@
+"""Main application"""
+
+import time
+import sys
+
+from app import SCHEDULER, LOGGER, RESOURCE_NAMES, job_storage, jobs
+
+
+if __name__ == '__main__':
+    jobs.check_resources(RESOURCE_NAMES['gold'])
+    # jobs.refill_resource(RESOURCE_NAMES['gold'])
+    # sys.exit(0)
+
+    JOBS = job_storage.get_jobs()
+    for job in JOBS:
+        LOGGER.info(
+            'Track resource "%s" at "%s"',
+            job['resource_type'],
+            job['minutes'],
+        )
+        SCHEDULER.add_job(
+            jobs.check_resources,
+            'cron',
+            args=[
+                RESOURCE_NAMES[job['resource_type']],
+            ],
+            id=job['resource_type'],
+            replace_existing=True,
+            minute=job['minutes']
+        )
+
+    try:
+        while True:
+            time.sleep(100)
+    except KeyboardInterrupt:
+        LOGGER.info('Exiting application')
+        SCHEDULER.shutdown()
+        sys.exit(0)

app/api.py

@@ -0,0 +1,65 @@
+"""Main application"""
+
+import re
+
+from bs4 import BeautifulSoup
+
+from app import LOGGER, RR_WRAPPER, STATE_ID, CAPITAL_ID, RESOURCE_IDS
+
+
+def download_resources(resource_id):
+    """Download the resource list"""
+    # return read_resources()
+    response = RR_WRAPPER.get(
+        'listed/stateresources/{}/{}'.format(STATE_ID, RESOURCE_IDS[resource_id])
+    )
+    return parse_resources(response)
+
+def read_resources():
+    """Read resource file"""
+    with open('resources.html') as file:
+        return parse_resources(file)
+
+def parse_resources(html):
+    """Read the resources left"""
+    soup = BeautifulSoup(html, 'html.parser')
+    regions_tree = soup.find_all(class_='list_link')
+
+    regions = {}
+    for region_tree in regions_tree:
+        region_id = int(region_tree['user'])
+        columns = region_tree.find_all('td')
+        regions[region_id] = {
+            'region_name': re.sub('Factories: .*$', '', columns[1].text),
+            'explored': float(columns[2].string),
+            'maximum': int(float(columns[3].string)),
+            'deep_exploration': int(columns[4].string),
+            'limit_left': int(columns[5].string),
+        }
+    return regions
+
+def refill(resource_id):
+    """Main function"""
+    resource_name = RESOURCE_IDS[resource_id]
+    LOGGER.info('Start refill for %s', resource_name)
+
+    data = {
+        'tmp_gov': resource_id
+    }
+
+    RR_WRAPPER.post('parliament/donew/42/{}/0'.format(resource_id), data)
+    LOGGER.info('created exploration law for %s', resource_name)
+
+    response = RR_WRAPPER.get('parliament/index/{}'.format(CAPITAL_ID))
+    soup = BeautifulSoup(response, 'html.parser')
+    active_laws = soup.find('div', {'id': 'parliament_active_laws'})
+    exploration_laws = active_laws.findAll(
+        text='Resources exploration: state, {} resources'.format(resource_name)
+    )
+    LOGGER.info('Number of exploration laws: %s', len(exploration_laws))
+    for exploration_law in exploration_laws:
+        action = exploration_law.parent.parent['action']
+        LOGGER.info('vote for law: %s', action)
+        action = action.replace('law', 'votelaw')
+        response = RR_WRAPPER.post('{}/pro'.format(action))
+        LOGGER.info('Response: %s', response)

app/app.py

@@ -0,0 +1,69 @@
+"""General function module"""
+
+import random
+from datetime import datetime, timedelta
+
+from app import LOGGER, SCHEDULER, RESOURCE_IDS, RESOURCE_MAX, jobs, api
+
+
+def check_resources(resource_id):
+    """Check resources and refill if necessary"""
+    regions = api.download_resources(resource_id)
+    LOGGER.info('Check resource %s', RESOURCE_IDS[resource_id])
+    print_resources(regions, resource_id)
+    refill_percentage = 25
+    if need_refill(regions, refill_percentage):
+        max_seconds = max_refill_seconds(regions, refill_percentage, 900)
+        random_seconds = random.randint(0, max_seconds)
+        random_time_delta = timedelta(seconds=random_seconds)
+        scheduled_date = datetime.now() + random_time_delta
+        job_id = 'refill_{}'.format(resource_id)
+        LOGGER.info(
+            'Refill resource %s at %s (%s minutes)', RESOURCE_IDS[resource_id],
+            scheduled_date, round(random_time_delta.seconds / 60)
+        )
+        SCHEDULER.add_job(
+            jobs.refill_resource,
+            'date',
+            args=[resource_id],
+            id=job_id,
+            run_date=scheduled_date,
+            replace_existing=True
+        )
+
+def print_resources(regions, resource_id):
+    """print resources"""
+    if regions:
+        print('region                        expl max   D left    c %    t %')
+        for region in regions.values():
+            region['explored_percentage'] = 100 / region['maximum'] * region['explored']
+            region['total_left'] = region['explored'] + region['limit_left']
+            region['total_percentage'] = 100 / RESOURCE_MAX[resource_id] * region['total_left']
+            print('{:25}: {:7.2f}{:4}{:4}{:5}{:7.2f}{:7.2f}'.format(
+                region['region_name'],
+                region['explored'],
+                region['maximum'],
+                region['deep_exploration'],
+                region['limit_left'],
+                region['explored_percentage'],
+                region['total_percentage'],
+            ))
+    else:
+        LOGGER.error('no region to print data')
+
+def need_refill(regions, limit):
+    """Check if refill is needed"""
+    for region in regions.values():
+        percentage = 100 / region['maximum'] * region['explored']
+        if percentage < limit and region['limit_left']:
+            return True
+    return False
+
+def max_refill_seconds(regions, limit, max_time):
+    """Give random seconds for next refill"""
+    lowest_percentage = limit
+    for region in regions.values():
+        percentage = 100 / region['maximum'] * region['explored']
+        if percentage < lowest_percentage:
+            lowest_percentage = percentage
+    return int(max_time / limit * lowest_percentage)

app/job_storage.py

@@ -0,0 +1,20 @@
+"""read resource jobs"""
+
+import sys
+import json
+
+from app import LOGGER
+
+
+def get_jobs():
+    """Read jobs"""
+    LOGGER.info('Read stored jobs')
+    try:
+        with open('jobs.json', 'r') as jobs_file:
+            jobs = json.load(jobs_file)
+            LOGGER.info('found "%s" job(s) in job storage', len(jobs))
+            return jobs
+    except FileNotFoundError:
+        LOGGER.error('job storage file "jobs.json" not found')
+        sys.exit(1)
+    return []

app/jobs.py

@@ -0,0 +1,12 @@
+"""Jobs for scheduler module"""
+
+from app import app, api
+
+
+def check_resources(resource_id):
+    """Check resources and refill if necessary"""
+    app.check_resources(resource_id)
+
+def refill_resource(resource_id):
+    """Execute refill job"""
+    api.refill(resource_id)

example.env

@@ -0,0 +1,8 @@
+# google, facebook, vk
+LOGIN_METHOD=PLACEHOLDER
+USERNAME=PLACEHOLDER
+PASSWORD=PLACEHOLDER
+SHOW_WINDOW=PLACEHOLDER
+
+STATE_ID=PLACEHOLDER
+CAPITAL_ID=PLACEHOLDER

example.jobs.json

@@ -0,0 +1,6 @@
+[
+    {
+        "resource_type": "gold",
+        "minutes": "0,15,30,45"
+    }
+]