Bump version: 0.17.1 → 0.17.2

Type hinting. Class parameter defined lists where shared accross instances.
AutoPost medals
2019-12-13 19:32:29 +02:00 · 2019-12-13 19:30:43 +02:00 · 2019-12-03 15:22:35 +02:00 · 2019-12-03 09:52:53 +02:00 · 2019-12-03 09:44:14 +02:00 · 2019-12-03 09:43:55 +02:00
18 changed files with 1061 additions and 593 deletions
--- a/.github/ISSUE_TEMPLATE.md
+++ b/.github/ISSUE_TEMPLATE.md
@ -1,6 +1,6 @@
-* eRepublik script version:
-* Python version:
-* Operating System:
+*   eRepublik script version:
+*   Python version:
+*   Operating System:

 ### Description

@ -9,7 +9,7 @@ Tell us what happened, what went wrong, and what you expected to happen.

 ### What I Did

-```
+``` python
 Paste the command(s) you ran and the output.
 If there was a crash, please include the traceback here.
 ```
--- a/CONTRIBUTING.rst
+++ b/CONTRIBUTING.rst
@ -15,7 +15,7 @@ Types of Contributions
 Report Bugs
 ~~~~~~~~~~~

-Report bugs at https://github.com/eeriks/erepublik_script/issues.
+Report bugs at https://github.com/eeriks/erepublik/issues.

 If you are reporting a bug, please include:

@ -45,7 +45,7 @@ articles, and such.
 Submit Feedback
 ~~~~~~~~~~~~~~~

-The best way to send feedback is to file an issue at https://github.com/eeriks/erepublik_script/issues.
+The best way to send feedback is to file an issue at https://github.com/eeriks/erepublik/issues.

 If you are proposing a feature:

@ -62,7 +62,7 @@ Ready to contribute? Here's how to set up `erepublik` for local development.
 1. Fork the `erepublik_script` repo on GitHub.
 2. Clone your fork locally::

-    $ git clone git@github.com:your_name_here/erepublik_script.git
+    $ git clone git@github.com:your_name_here/erepublik.git

 3. Install your local copy into a virtualenv. Assuming you have virtualenvwrapper installed, this is how you set up your fork for local development::

--- a/HISTORY.rst
+++ b/HISTORY.rst
@ -3,6 +3,31 @@ History
 =======


+0.17.0 (2019-11-21)
+-------------------
+
+* 12th anniversary's endpoints added
+* Telegram message queue optimisation
+* WC end fighting energy bugfix
+* More strict fighting limiting before week change
+* Improved and fixed ground damage booster usage
+
+
+0.16.0 (2019-09-29)
+-------------------
+
+* Telegram notification integration
+* Improved serialization to JSON
+* When failing to do WAM because of not enough food - buy food
+* Buy food buys 48h worth instead of 24h energy
+
+
+0.15.3 (2019-08-24)
+-------------------
+
+* Update after eRepublik changed campaign apis
+
+
 0.15.0 (2019-07-30)
 -------------------

@ -15,6 +40,7 @@ History

 * Wall post comment endpoints updated with comment create endpoints.

+
 0.1.0 (2019-07-19)
 ------------------

--- a/README.rst
+++ b/README.rst
@ -6,8 +6,8 @@ eRepublik script
 .. image:: https://img.shields.io/pypi/v/erepublik.svg
        :target: https://pypi.python.org/pypi/erepublik

-.. image:: https://readthedocs.org/projects/erepublik_script/badge/?version=latest
-        :target: https://erepublik_script.readthedocs.io/en/latest/?badge=latest
+.. image:: https://readthedocs.org/projects/erepublik/badge/?version=latest
+        :target: https://erepublik.readthedocs.io/en/latest/?badge=latest
        :alt: Documentation Status


@ -15,7 +15,7 @@ Python package for automated eRepublik playing


 * Free software: MIT license
-* Documentation: https://erepublik.readthedocs.io.
+* Documentation: https://erepublik.readthedocs.io/en/latest/


 Features
--- a/config.json
+++ b/config.json
@ -33,4 +33,4 @@
 "travel_to_fight": true,
 "wam": true,
 "work": true
-}
+}
--- a/docs/conf.py
+++ b/docs/conf.py
@ -23,6 +23,7 @@ import sys
 sys.path.insert(0, os.path.abspath('..'))

 import erepublik
+import edx_theme

 # -- General configuration ---------------------------------------------

@ -32,7 +33,7 @@ import erepublik

 # Add any Sphinx extension module names here, as strings. They can be
 # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
-extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode']
+extensions = ['sphinx.ext.autodoc', 'sphinx.ext.viewcode', 'edx_theme']

 # Add any paths that contain templates here, relative to this directory.
 templates_path = ['_templates']
@ -84,7 +85,8 @@ todo_include_todos = False
 # The theme to use for HTML and HTML Help pages.  See the documentation for
 # a list of builtin themes.
 #
-html_theme = 'alabaster'
+html_theme = 'edx_theme'
+html_theme_path = [edx_theme.get_html_theme_path()]

 # Theme options are theme-specific and customize the look and feel of a
 # theme further.  For a list of options available for each theme, see the
@ -158,6 +160,3 @@ texinfo_documents = [
     'One line description of project.',
     'Miscellaneous'),
 ]
-
-
-
--- a/docs/installation.rst
+++ b/docs/installation.rst
@ -32,13 +32,13 @@ You can either clone the public repository:

 .. code-block:: console

-    $ git clone git://github.com/eeriks/erepublik_script
+    $ git clone git://github.com/eeriks/erepublik

 Or download the `tarball`_:

 .. code-block:: console

-    $ curl  -OL https://github.com/eeriks/erepublik_script/tarball/master
+    $ curl  -OL https://github.com/eeriks/erepublik/tarball/master

 Once you have a copy of the source, you can install it with:

@ -47,5 +47,5 @@ Once you have a copy of the source, you can install it with:
    $ python setup.py install


-.. _Github repo: https://github.com/eeriks/erepublik_script
-.. _tarball: https://github.com/eeriks/erepublik_script/tarball/master
+.. _Github repo: https://github.com/eeriks/erepublik
+.. _tarball: https://github.com/eeriks/erepublik/tarball/master
--- a/docs/make.bat
+++ b/docs/make.bat
@ -1,36 +1,36 @@
-@ECHO OFF
-
-pushd %~dp0
-
-REM Command file for Sphinx documentation
-
-if "%SPHINXBUILD%" == "" (
-	set SPHINXBUILD=python -msphinx
-)
-set SOURCEDIR=.
-set BUILDDIR=_build
-set SPHINXPROJ=erepublik_script
-
-if "%1" == "" goto help
-
-%SPHINXBUILD% >NUL 2>NUL
-if errorlevel 9009 (
-	echo.
-	echo.The Sphinx module was not found. Make sure you have Sphinx installed,
-	echo.then set the SPHINXBUILD environment variable to point to the full
-	echo.path of the 'sphinx-build' executable. Alternatively you may add the
-	echo.Sphinx directory to PATH.
-	echo.
-	echo.If you don't have Sphinx installed, grab it from
-	echo.http://sphinx-doc.org/
-	exit /b 1
-)
-
-%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-goto end
-
-:help
-%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
-
-:end
-popd
+@ECHO OFF
+
+pushd %~dp0
+
+REM Command file for Sphinx documentation
+
+if "%SPHINXBUILD%" == "" (
+	set SPHINXBUILD=python -msphinx
+)
+set SOURCEDIR=.
+set BUILDDIR=_build
+set SPHINXPROJ=erepublik
+
+if "%1" == "" goto help
+
+%SPHINXBUILD% >NUL 2>NUL
+if errorlevel 9009 (
+	echo.
+	echo.The Sphinx module was not found. Make sure you have Sphinx installed,
+	echo.then set the SPHINXBUILD environment variable to point to the full
+	echo.path of the 'sphinx-build' executable. Alternatively you may add the
+	echo.Sphinx directory to PATH.
+	echo.
+	echo.If you don't have Sphinx installed, grab it from
+	echo.http://sphinx-doc.org/
+	exit /b 1
+)
+
+%SPHINXBUILD% -M %1 %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+goto end
+
+:help
+%SPHINXBUILD% -M help %SOURCEDIR% %BUILDDIR% %SPHINXOPTS%
+
+:end
+popd
--- a/docs/usage.rst
+++ b/docs/usage.rst
@ -4,4 +4,7 @@ Usage

 To use eRepublik script in a project::

-    import erepublik
+    from erepublik import Citizen
+    player = Citizen('email@domain.com', 'password')
+    player.update_all()
+
--- a/erepublik/init.py
+++ b/erepublik/init.py
@ -4,7 +4,7 @@

 __author__ = """Eriks Karls"""
 __email__ = 'eriks@72.lv'
-__version__ = '0.15.3'
+__version__ = '0.17.2'

 from erepublik import classes, utils
 from erepublik.citizen import Citizen
--- a/erepublik/citizen.py
+++ b/erepublik/citizen.py
--- a/erepublik/classes.py
+++ b/erepublik/classes.py
@ -2,12 +2,13 @@ import datetime
 import decimal
 import hashlib
 import random
+import threading
 import time
 from collections import deque
 from json import JSONDecodeError, loads, JSONEncoder
-from typing import Any, Dict, List, Union, Mapping, Iterable
+from typing import Any, Dict, List, Union, Mapping, Iterable, Tuple

-from requests import Response, Session
+from requests import Response, Session, post

 from erepublik import utils

@ -17,7 +18,7 @@ class ErepublikException(Exception):
        super().__init__(message)


-class ErepublikNetworkException(Exception):
+class ErepublikNetworkException(ErepublikException):
    def __init__(self, message, request):
        super().__init__(message)
        self.request = request
@ -61,7 +62,7 @@ class MyCompanies:
                        production=0, base_production=0, wam_enabled=False, can_work_as_manager=False,
                        preset_own_work=0, already_worked=False, can_assign_employees=False, preset_works=0,
                        todays_works=0, holding_company_id=None, is_assigned_to_holding=False,
-                        cannot_work_as_manager_reason=False)
+                        cannot_work_as_manager_reason=False, industry_id=0)

        for c_id, company in companies.items():
            tmp = {}
@ -119,7 +120,10 @@ class MyCompanies:
        raw = []
        factory = []
        if holding_id in self.holdings:
-            for company_id in self.holdings.get(holding_id, {}).get('companies', []):
+            for company_id in sorted(self.holdings.get(holding_id, {}).get('companies', []),
+                                     key=lambda cid: (-self.companies[cid].get('is_raw'),  # True, False
+                                                      self.companies[cid].get('industry_id'),  # F W H A
+                                                      -self.companies[cid].get('quality'),)):  # 7, 6, .. 2, 1
                company = self.companies.get(company_id, {})
                wam_enabled = bool(company.get('wam_enabled', {}))
                already_worked = not company.get('already_worked', {})
@ -156,28 +160,33 @@ class MyCompanies:

        raise ErepublikException("Wrong function call")

+    # @property
+    # def __dict__(self):
+    #     ret = {}
+    #     for key in dir(self):
+    #         if not key.startswith('_'):
+    #             ret[key] = getattr(self, key)
+    #     return ret
+

 class SlowRequests(Session):
    last_time: datetime.datetime
    timeout = datetime.timedelta(milliseconds=500)
    uas = [
        # Chrome
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
-        'Chrome/73.0.3683.103 Safari/537.36',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
-        'Chrome/72.0.3626.13 Safari/537.36',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
-        'Chrome/71.0.3578.98 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/73.0.3683.103 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/72.0.3626.11 Safari/537.36',
-        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/71.0.3578.98 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/77.0.3865.90 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/76.0.3809.132 Safari/537.36',
+        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/75.0.3770.80 Safari/537.36',
        # FireFox
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:66.0) Gecko/20100101 Firefox/66.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:65.0) Gecko/20100101 Firefox/65.0',
-        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:64.0) Gecko/20100101 Firefox/64.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:66.0) Gecko/20100101 Firefox/66.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:65.0) Gecko/20100101 Firefox/65.0',
-        'Mozilla/5.0 (X11; Linux x86_64; rv:64.0) Gecko/20100101 Firefox/64.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:69.0) Gecko/20100101 Firefox/69.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:68.0) Gecko/20100101 Firefox/68.0',
+        'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:67.0) Gecko/20100101 Firefox/67.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:69.0) Gecko/20100101 Firefox/69.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:68.0) Gecko/20100101 Firefox/68.0',
+        'Mozilla/5.0 (X11; Linux x86_64; rv:67.0) Gecko/20100101 Firefox/67.0',
    ]
    debug = False

@ -192,7 +201,7 @@ class SlowRequests(Session):
    @property
    def __dict__(self):
        return dict(last_time=self.last_time, timeout=self.timeout, user_agent=self.headers['User-Agent'],
-                    request_log_name=self.request_log_name)
+                    request_log_name=self.request_log_name, debug=self.debug)

    def request(self, method, url, *args, **kwargs):
        self._slow_down_requests()
@ -211,7 +220,10 @@ class SlowRequests(Session):
    def _log_request(self, url, method, data=None, json=None, params=None, **kwargs):
        if self.debug:
            args = {}
-            args.update({'kwargs': kwargs})
+            kwargs.pop('allow_redirects', None)
+            if kwargs:
+                args.update({'kwargs': kwargs})
+
            if data:
                args.update({"data": data})

@ -235,10 +247,9 @@ class SlowRequests(Session):
                    self._log_request(hist_resp.request.url, "REDIRECT")
                    self._log_response(hist_resp.request.url, hist_resp, redirect=True)

-            # TODO: Must thoroughly check response writing on windows systems
            file_data = {
                "path": 'debug/requests',
-                "time": self.last_time.strftime('%Y-%m-%d_%H-%M-%S'),
+                "time": self.last_time.strftime('%Y/%m/%d/%H-%M-%S'),
                "name": utils.slugify(url[len(Citizen.url):]),
                "extra": "_REDIRECT" if redirect else ""
            }
@ -260,7 +271,7 @@ class Config:
    work = True
    train = True
    wam = False
-    auto_sell: List[str] = list()
+    auto_sell: List[str] = None
    auto_sell_all = False
    employees = False
    fight = False
@ -280,38 +291,44 @@ class Config:
    force_wam = False
    sort_battles_time = True
    force_travel = False
+    telegram = True
+    telegram_chat_id = 0
+    telegram_token = ""
+
+    def __init__(self):
+        self.auto_sell = []

    @property
    def wt(self):
        return self.work and self.train

-    def __dict__(self) -> Dict[str, Union[bool, str, List[str]]]:
-        return dict(
-            email=self.email,
-            password=self.password,
-            work=self.work,
-            train=self.train,
-            wam=self.wam,
-            auto_sell=self.auto_sell,
-            auto_sell_all=self.auto_sell_all,
-            employees=self.employees,
-            fight=self.fight,
-            air=self.air,
-            ground=self.ground,
-            all_in=self.all_in,
-            next_energy=self.next_energy,
-            boosters=self.boosters,
-            travel_to_fight=self.travel_to_fight,
-            epic_hunt=self.epic_hunt,
-            epic_hunt_ebs=self.epic_hunt_ebs,
-            rw_def_side=self.rw_def_side,
-            interactive=self.interactive,
-            continuous_fighting=self.continuous_fighting,
-            auto_buy_raw=self.auto_buy_raw,
-            force_wam=self.force_wam,
-            sort_battles_time=self.sort_battles_time,
-            force_travel=self.force_travel,
-        )
+    def reset(self):
+        self.work = True
+        self.train = True
+        self.wam = False
+        self.auto_sell = list()
+        self.auto_sell_all = False
+        self.employees = False
+        self.fight = False
+        self.air = False
+        self.ground = False
+        self.all_in = False
+        self.next_energy = False
+        self.boosters = False
+        self.travel_to_fight = False
+        self.always_travel = False
+        self.epic_hunt = False
+        self.epic_hunt_ebs = False
+        self.rw_def_side = False
+        self.interactive = True
+        self.continuous_fighting = False
+        self.auto_buy_raw = False
+        self.force_wam = False
+        self.sort_battles_time = True
+        self.force_travel = False
+        self.telegram = True
+        self.telegram_chat_id = 0
+        self.telegram_token = ""


 class Energy:
@ -332,7 +349,7 @@ class Energy:

    @property
    def food_fights(self):
-        return (self.recoverable + self.recovered) // 10
+        return self.available // 10

    @property
    def reference_time(self):
@ -344,7 +361,7 @@ class Energy:

    @property
    def is_recoverable_full(self):
-        return self.recoverable >= self.limit - self.interval
+        return self.recoverable >= self.limit - 5 * self.interval

    @property
    def is_recovered_full(self):
@ -358,24 +375,14 @@ class Energy:
    def available(self):
        return self.recovered + self.recoverable

-    @property
-    def __dict__(self):
-        return dict(
-            limit=self.limit,
-            interval=self.interval,
-            recoverable=self.recoverable,
-            recovered=self.recovered,
-            reference_time=self.reference_time
-        )

-
-class Details(object):
+class Details:
    xp = 0
    cc = 0
    pp = 0
    pin = None
    gold = 0
-    next_pp: List[int] = []
+    next_pp: List[int] = None
    citizen_id = 0
    citizenship = 0
    current_region = 0
@ -386,6 +393,9 @@ class Details(object):
    daily_task_reward = False
    mayhem_skills = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0, }

+    def __init__(self):
+        self.next_pp = []
+
    @property
    def xp_till_level_up(self):
        if self.xp >= 10000:
@ -423,7 +433,7 @@ class Politics:
    is_country_president: bool = False


-class House(object):
+class House:
    quality = None
    unactivated_count = 0
    active_untill = utils.good_timedelta(utils.now(), -datetime.timedelta(days=1))
@ -448,31 +458,34 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
        """
        self._req = SlowRequests()

-    def post(self, url: str, *args, **kwargs) -> Response:
-        return self._req.post(url, *args, **kwargs)
+    def post(self, url: str, data=None, json=None, **kwargs) -> Response:
+        return self._req.post(url, data, json, **kwargs)

    def get(self, url: str, **kwargs) -> Response:
        return self._req.get(url, **kwargs)

-    def _get_article_json(self, article_id: int) -> Response:
+    def _get_main_article_json(self, article_id: int) -> Response:
        return self.get("{}/main/articleJson/{}".format(self.url, article_id))

-    def _get_battlefield_choose_side(self, battle: int, side: int) -> Response:
+    def _get_military_battlefield_choose_side(self, battle: int, side: int) -> Response:
        return self.get("{}/military/battlefield-choose-side/{}/{}".format(self.url, battle, side))

+    def _get_military_show_weapons(self, battle: int) -> Response:
+        return self.get("{}/military/show-weapons".format(self.url), params={'_token': self.token, 'battleId': battle})
+
    def _get_candidate_party(self, party_slug: str) -> Response:
        return self.post("{}/candidate/{}".format(self.url, party_slug))

-    def _get_citizen_hovercard(self, citizen: int) -> Response:
+    def _get_main_citizen_hovercard(self, citizen: int) -> Response:
        return self.get("{}/main/citizen-hovercard/{}".format(self.url, citizen))

-    def _get_citizen_profile(self, player_id: int) -> Response:
+    def _get_main_citizen_profile_json(self, player_id: int) -> Response:
        return self.get("{}/main/citizen-profile-json/{}".format(self.url, player_id))

-    def _get_citizen_daily_assistant(self) -> Response:
+    def _get_main_citizen_daily_assistant(self) -> Response:
        return self.get("{}/main/citizenDailyAssistant".format(self.url))

-    def _get_city_data_residents(self, city: int, page: int = 1, params: Mapping[str, Any] = None) -> Response:
+    def _get_main_city_data_residents(self, city: int, page: int = 1, params: Mapping[str, Any] = None) -> Response:
        if params is None:
            params = {}
        return self.get("{}/main/city-data/{}/residents".format(self.url, city), params={"currentPage": page, **params})
@ -495,96 +508,98 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
    def _get_economy_my_market_offers(self) -> Response:
        return self.get("{}/economy/myMarketOffers".format(self.url))

-    def _get_job_data(self) -> Response:
+    def _get_main_job_data(self) -> Response:
        return self.get("{}/main/job-data".format(self.url))

-    def _get_leaderboards_damage_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
+    def _get_main_leaderboards_damage_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
        data = (country, weeks, mu)
        return self.get("{}/main/leaderboards-damage-aircraft-rankings/{}/{}/{}/0".format(self.url, *data))

-    def _get_leaderboards_damage_rankings(self, country: int, weeks: int = 0, mu: int = 0, div: int = 0) -> Response:
+    def _get_main_leaderboards_damage_rankings(self, country: int, weeks: int = 0, mu: int = 0,
+                                               div: int = 0) -> Response:
        data = (country, weeks, mu, div)
        return self.get("{}/main/leaderboards-damage-rankings/{}/{}/{}/{}".format(self.url, *data))

-    def _get_leaderboards_kills_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
+    def _get_main_leaderboards_kills_aircraft_rankings(self, country: int, weeks: int = 0, mu: int = 0) -> Response:
        data = (country, weeks, mu)
        return self.get("{}/main/leaderboards-kills-aircraft-rankings/{}/{}/{}/0".format(self.url, *data))

-    def _get_leaderboards_kills_rankings(self, country: int, weeks: int = 0, mu: int = 0, div: int = 0) -> Response:
+    def _get_main_leaderboards_kills_rankings(self, country: int, weeks: int = 0, mu: int = 0,
+                                              div: int = 0) -> Response:
        data = (country, weeks, mu, div)
        return self.get("{}/main/leaderboards-kills-rankings/{}/{}/{}/{}".format(self.url, *data))

    def _get_main(self) -> Response:
        return self.get(self.url)

-    def _get_messages(self, page: int = 1) -> Response:
+    def _get_main_messages_paginated(self, page: int = 1) -> Response:
        return self.get("{}/main/messages-paginated/{}".format(self.url, page))

    def _get_military_campaigns(self) -> Response:
        return self.get("{}/military/campaigns-new/".format(self.url))

+    def _get_military_campaigns_json_list(self) -> Response:
+        return self.get("{}/military/campaignsJson/list".format(self.url))
+
+    def _get_military_show_weapons(self, battle_id: int) -> Response:
+        params = {"_token": self.token, "battleId": battle_id}
+        return self.get("{}/military/show-weapons".format(self.url), params=params)
+
    def _get_military_unit_data(self, unit_id: int, **kwargs) -> Response:
        params = {"groupId": unit_id, "panel": "members", **kwargs}
        return self.get("{}/military/military-unit-data/".format(self.url), params=params)

-    def _get_money_donation_accept(self, donation_id: int) -> Response:
+    def _get_main_money_donation_accept(self, donation_id: int) -> Response:
        return self.get("{}/main/money-donation/accept/{}".format(self.url, donation_id), params={"_token": self.token})

-    def _get_money_donation_reject(self, donation_id: int) -> Response:
+    def _get_main_money_donation_reject(self, donation_id: int) -> Response:
        return self.get("{}/main/money-donation/reject/{}".format(self.url, donation_id), params={"_token": self.token})

-    def _get_notifications_ajax_community(self, page: int = 1) -> Response:
+    def _get_main_notifications_ajax_community(self, page: int = 1) -> Response:
        return self.get("{}/main/notificationsAjax/community/{}".format(self.url, page))

-    def _get_notifications_ajax_system(self, page: int = 1) -> Response:
+    def _get_main_notifications_ajax_system(self, page: int = 1) -> Response:
        return self.get("{}/main/notificationsAjax/system/{}".format(self.url, page))

-    def _get_notifications_ajax_report(self, page: int = 1) -> Response:
+    def _get_main_notifications_ajax_report(self, page: int = 1) -> Response:
        return self.get("{}/main/notificationsAjax/report/{}".format(self.url, page))

-    def _get_party_members(self, party: int) -> Response:
+    def _get_main_party_members(self, party: int) -> Response:
        return self.get("{}/main/party-members/{}".format(self.url, party))

-    def _get_rankings_parties(self, country: int) -> Response:
+    def _get_main_rankings_parties(self, country: int) -> Response:
        return self.get("{}/main/rankings-parties/1/{}".format(self.url, country))

-    def _get_training_grounds_json(self) -> Response:
+    def _get_main_training_grounds_json(self) -> Response:
        return self.get("{}/main/training-grounds-json".format(self.url))

-    def _get_weekly_challenge_data(self) -> Response:
+    def _get_main_weekly_challenge_data(self) -> Response:
        return self.get("{}/main/weekly-challenge-data".format(self.url))

    def _get_wars_show(self, war_id: int) -> Response:
        return self.get("{}/wars/show/{}".format(self.url, war_id))

-    def _post_activate_battle_effect(self, battle: int, kind: str, citizen_id: int) -> Response:
+    def _post_main_activate_battle_effect(self, battle: int, kind: str, citizen_id: int) -> Response:
        data = dict(battleId=battle, citizenId=citizen_id, type=kind, _token=self.token)
        return self.post("{}/main/fight-activateBattleEffect".format(self.url), data=data)

-    def _post_article_comments(self, article: int, page: int = 1) -> Response:
+    def _post_main_article_comments(self, article: int, page: int = 1) -> Response:
        data = dict(_token=self.token, articleId=article, page=page)
        if page:
            data.update({'page': page})
        return self.post("{}/main/articleComments".format(self.url), data=data)

-    def _post_article_comments_create(self, message: str, article: int, parent: int = 0) -> Response:
+    def _post_main_article_comments_create(self, message: str, article: int, parent: int = 0) -> Response:
        data = dict(_token=self.token, message=message, articleId=article)
        if parent:
            data.update({"parentId": parent})
        return self.post("{}/main/articleComments/create".format(self.url), data=data)

-    def _post_battle_console(self, battle: int, zone: int, round_id: int, division: int, page: int,
-                             damage: bool) -> Response:
-        data = dict(battleId=battle, zoneId=zone, action="battleStatistics", round=round_id, division=division,
-                    leftPage=page, rightPage=page, _token=self.token)
-        if damage:
-            data.update({"type": "damage"})
-        else:
-            data.update({"type": "kills"})
+    def _post_main_battlefield_travel(self, side_id: int, battle_id: int) -> Response:
+        data = dict(_token=self.token, sideCountryId=side_id, battleId=battle_id)
+        return self.post("{}/main/battlefieldTravel".format(self.url), data=data)

-        return self.post("{}/military/battle-console".format(self.url), data=data)
-
-    def _post_buy_gold_items(self, currency: str, item: str, amount: int) -> Response:
+    def _post_main_buy_gold_items(self, currency: str, item: str, amount: int) -> Response:
        data = dict(itemId=item, currency=currency, amount=amount, _token=self.token)
        return self.post("{}/main/buyGoldItems".format(self.url), data=data)

@ -592,7 +607,7 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
        data = dict(_token=self.token, presentation=presentation)
        return self.post("{}/candidate-for-congress".format(self.url), data=data)

-    def _post_citizen_add_remove_friend(self, citizen: int, add: bool) -> Response:
+    def _post_main_citizen_add_remove_friend(self, citizen: int, add: bool) -> Response:
        data = dict(_token=self.token, citizenId=citizen, url="//www.erepublik.com/en/main/citizen-addRemoveFriend")
        if add:
            data.update({"action": "addFriend"})
@ -600,18 +615,22 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
            data.update({"action": "removeFriend"})
        return self.post("{}/main/citizen-addRemoveFriend".format(self.url), data=data)

-    def _post_collect_anniversary_reward(self) -> Response:
+    def _post_main_collect_anniversary_reward(self) -> Response:
        return self.post("{}/main/collect-anniversary-reward".format(self.url), data={"_token": self.token})

-    def _post_country_donate(self, country: int, action: str, value: Union[int, float],
-                             quality: int = None) -> Response:
+    def _post_main_country_donate(self, country: int, action: str, value: Union[int, float],
+                                  quality: int = None) -> Response:
        json = dict(countryId=country, action=action, _token=self.token, value=value, quality=quality)
        return self.post("{}/main/country-donate".format(self.url), data=json,
                         headers={"Referer": "{}/country/economy/Latvia".format(self.url)})

-    def _post_daily_task_reward(self) -> Response:
+    def _post_main_daily_task_reward(self) -> Response:
        return self.post("{}/main/daily-tasks-reward".format(self.url), data=dict(_token=self.token))

+    def _post_main_donate_article(self, article_id: int, amount: int) -> Response:
+        data = dict(_token=self.token, articleId=article_id, amount=amount)
+        return self.post("{}/main/donate-article".format(self.url), data=data)
+
    def _post_delete_message(self, msg_id: list) -> Response:
        data = {"_token": self.token, "delete_message[]": msg_id}
        return self.post("{}/main/messages-delete".format(self.url), data)
@ -687,18 +706,18 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
                         data={"_token": self.token, "action_type": "resign"})

    def _post_economy_sell_company(self, factory: int, pin: int = None, sell: bool = True) -> Response:
-        url = "{}/economy/sell-company/{}".format(self.url, factory)
        data = dict(_token=self.token, pin="" if pin is None else pin)
        if sell:
            data.update({"sell": "sell"})
        else:
            data.update({"dissolve": factory})
-        return self.post(url, data=data, headers={"Referer": url})
+        return self.post("{}/economy/sell-company/{}".format(self.url, factory),
+                         data=data, headers={"Referer": self.url})

    def _post_economy_train(self, tg_ids: List[int]) -> Response:
        data: Dict[str, Union[int, str]] = {}
        if not tg_ids:
-            return self._get_training_grounds_json()
+            return self._get_main_training_grounds_json()
        else:
            for idx, tg_id in enumerate(tg_ids):
                data["grounds[%i][id]" % idx] = tg_id
@ -746,19 +765,23 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
        data = dict(_token=self.token, email=email, commit="Reset password")
        return self.post("{}/forgot-password".format(self.url), data=data)

-    def _post_fight_activate_booster(self, battle: int, quality: int, duration: int, kind: str) -> Response:
+    def _post_military_fight_activate_booster(self, battle: int, quality: int, duration: int, kind: str) -> Response:
        data = dict(type=kind, quality=quality, duration=duration, battleId=battle, _token=self.token)
        return self.post("{}/military/fight-activateBooster".format(self.url), data=data)

+    def _post_military_change_weapon(self, battle: int, battle_zone: int, weapon_level: int,) -> Response:
+        data = dict(battleId=battle, _token=self.token, battleZoneId=battle_zone, customizationLevel=weapon_level)
+        return self.post("{}/military/change-weapon".format(self.url), data=data)
+
    def _post_login(self, email: str, password: str) -> Response:
        data = dict(csrf_token=self.token, citizen_email=email, citizen_password=password, remember='on')
        return self.post("{}/login".format(self.url), data=data)

-    def _post_messages_alert(self, notification_ids: List[int]) -> Response:
+    def _post_main_messages_alert(self, notification_ids: List[int]) -> Response:
        data = {"_token": self.token, "delete_alerts[]": notification_ids, "deleteAllAlerts": "1", "delete": "Delete"}
        return self.post("{}/main/messages-alerts/1".format(self.url), data=data)

-    def _post_messages_compose(self, subject: str, body: str, citizens: List[int]) -> Response:
+    def _post_main_messages_compose(self, subject: str, body: str, citizens: List[int]) -> Response:
        url_pk = 0 if len(citizens) > 1 else str(citizens[0])
        data = dict(citizen_name=",".join([str(x) for x in citizens]),
                    citizen_subject=subject, _token=self.token, citizen_message=body)
@ -768,43 +791,52 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
        data = dict(battleId=battle_id, action=action, _token=self.token)
        if action == "battleStatistics":
            data.update(round=kwargs["round_id"], zoneId=kwargs["round_id"], leftPage=page, rightPage=page,
-                        division=kwargs["division"], type=kwargs.get("type", 'damage'),)
+                        division=kwargs["division"], type=kwargs.get("type", 'damage'), )
        elif action == "warList":
            data.update(page=page)
        return self.post("{}/military/battle-console".format(self.url), data=data)

+    def _post_military_change_weapon(self, battle_id: int, battle_zone_id: int, customization_level: int) -> Response:
+        data = dict(_token=self.token, battleZoneId=battle_zone_id, battleId=battle_id,
+                    customizationLevel=customization_level)
+        return self.post("{}/military/change-weapon".format(self.url), data=data)
+
    def _post_military_deploy_bomb(self, battle_id: int, bomb_id: int) -> Response:
        data = dict(battleId=battle_id, bombId=bomb_id, _token=self.token)
        return self.post("{}/military/deploy-bomb".format(self.url), data=data)

-    def _post_military_fight_air(self, battle_id: int, side_id: int) -> Response:
-        data = dict(sideId=side_id, battleId=battle_id, _token=self.token)
+    def _post_military_fight_air(self, battle_id: int, side_id: int, zone_id: int) -> Response:
+        data = dict(sideId=side_id, battleId=battle_id, _token=self.token, battleZoneId=zone_id)
        return self.post("{}/military/fight-shoooot/{}".format(self.url, battle_id), data=data)

-    def _post_military_fight_ground(self, battle_id: int, side_id: int) -> Response:
-        data = dict(sideId=side_id, battleId=battle_id, _token=self.token)
+    def _post_military_fight_ground(self, battle_id: int, side_id: int, zone_id: int) -> Response:
+        data = dict(sideId=side_id, battleId=battle_id, _token=self.token, battleZoneId=zone_id)
        return self.post("{}/military/fight-shooot/{}".format(self.url, battle_id), data=data)

    def _post_military_group_missions(self) -> Response:
        data = dict(action="check", _token=self.token)
        return self.post("{}/military/group-missions".format(self.url), data=data)

-    def _post_travel(self, check: str, **kwargs) -> Response:
+    def _post_main_travel(self, check: str, **kwargs) -> Response:
        data = dict(_token=self.token, check=check, **kwargs)
        return self.post("{}/main/travel".format(self.url), data=data)

-    def _post_travel_data(self, **kwargs) -> Response:
+    def _post_main_vote_article(self, article_id: int) -> Response:
+        data = dict(_token=self.token, articleId=article_id)
+        return self.post("{}/main/vote-article".format(self.url), data=data)
+
+    def _post_main_travel_data(self, **kwargs) -> Response:
        return self.post("{}/main/travelData".format(self.url), data=dict(_token=self.token, **kwargs))

    def _post_wars_attack_region(self, war_id: int, region_id: int, region_name: str) -> Response:
        data = {'_token': self.token, 'warId': war_id, 'regionName': region_name, 'regionNameConfirm': region_name}
        return self.post('{}/wars/attack-region/{}/{}'.format(self.url, war_id, region_id), data=data)

-    def _post_weekly_challenge_reward(self, reward_id: int) -> Response:
+    def _post_main_weekly_challenge_reward(self, reward_id: int) -> Response:
        data = dict(_token=self.token, rewardId=reward_id)
        return self.post("{}/main/weekly-challenge-collect-reward".format(self.url), data=data)

-    def _post_write_article(self, title: str, content: str, location: int, kind: int) -> Response:
+    def _post_main_write_article(self, title: str, content: str, location: int, kind: int) -> Response:
        data = dict(_token=self.token, article_name=title, article_body=content, article_location=location,
                    article_category=kind)
        return self.post("{}/main/write-article".format(self.url), data=data)
@ -812,95 +844,127 @@ Class for unifying eRepublik known endpoints and their required/optional paramet
    # Wall Posts
    # ## Country

-    def _post_country_comment_retrieve(self, post_id: int) -> Response:
+    def _post_main_country_comment_retrieve(self, post_id: int) -> Response:
        data = {"_token": self.token, "postId": post_id}
        return self.post("{}/main/country-comment/retrieve/json".format(self.url), data=data)

-    def _post_country_comment_create(self, post_id: int, comment_message: str) -> Response:
+    def _post_main_country_comment_create(self, post_id: int, comment_message: str) -> Response:
        data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
        return self.post("{}/main/country-comment/create/json".format(self.url), data=data)

-    def _post_country_post_create(self, body: str, post_as: int) -> Response:
+    def _post_main_country_post_create(self, body: str, post_as: int) -> Response:
        data = {"_token": self.token, "post_message": body, "post_as": post_as}
        return self.post("{}/main/country-post/create/json".format(self.url), data=data)

-    def _post_country_post_retrieve(self) -> Response:
+    def _post_main_country_post_retrieve(self) -> Response:
        data = {"_token": self.token, "page": 1, "switchedFrom": False}
        return self.post("{}/main/country-post/retrieve/json".format(self.url), data=data)

    # ## Military Unit

-    def _post_military_unit_comment_retrieve(self, post_id: int) -> Response:
+    def _post_main_military_unit_comment_retrieve(self, post_id: int) -> Response:
        data = {"_token": self.token, "postId": post_id}
        return self.post("{}/main/military-unit-comment/retrieve/json".format(self.url), data=data)

-    def _post_military_unit_comment_create(self, post_id: int, comment_message: str) -> Response:
+    def _post_main_military_unit_comment_create(self, post_id: int, comment_message: str) -> Response:
        data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
        return self.post("{}/main/military-unit-comment/create/json".format(self.url), data=data)

-    def _post_military_unit_post_create(self, body: str, post_as: int) -> Response:
+    def _post_main_military_unit_post_create(self, body: str, post_as: int) -> Response:
        data = {"_token": self.token, "post_message": body, "post_as": post_as}
        return self.post("{}/main/military-unit-post/create/json".format(self.url), data=data)

-    def _post_military_unit_post_retrieve(self) -> Response:
+    def _post_main_military_unit_post_retrieve(self) -> Response:
        data = {"_token": self.token, "page": 1, "switchedFrom": False}
        return self.post("{}/main/military-unit-post/retrieve/json".format(self.url), data=data)

    # ## Party

-    def _post_party_comment_retrieve(self, post_id: int) -> Response:
+    def _post_main_party_comment_retrieve(self, post_id: int) -> Response:
        data = {"_token": self.token, "postId": post_id}
        return self.post("{}/main/party-comment/retrieve/json".format(self.url), data=data)

-    def _post_party_comment_create(self, post_id: int, comment_message: str) -> Response:
+    def _post_main_party_comment_create(self, post_id: int, comment_message: str) -> Response:
        data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
        return self.post("{}/main/party-comment/create/json".format(self.url), data=data)

-    def _post_party_post_create(self, body: str) -> Response:
+    def _post_main_party_post_create(self, body: str) -> Response:
        data = {"_token": self.token, "post_message": body}
        return self.post("{}/main/party-post/create/json".format(self.url), data=data)

-    def _post_party_post_retrieve(self) -> Response:
+    def _post_main_party_post_retrieve(self) -> Response:
        data = {"_token": self.token, "page": 1, "switchedFrom": False}
        return self.post("{}/main/party-post/retrieve/json".format(self.url), data=data)

    # ## Friend's Wall

-    def _post_wall_comment_retrieve(self, post_id: int) -> Response:
+    def _post_main_wall_comment_retrieve(self, post_id: int) -> Response:
        data = {"_token": self.token, "postId": post_id}
        return self.post("{}/main/wall-comment/retrieve/json".format(self.url), data=data)

-    def _post_wall_comment_create(self, post_id: int, comment_message: str) -> Response:
+    def _post_main_wall_comment_create(self, post_id: int, comment_message: str) -> Response:
        data = {"_token": self.token, "postId": post_id, 'comment_message': comment_message}
        return self.post("{}/main/wall-comment/create/json".format(self.url), data=data)

-    def _post_wall_post_create(self, body: str) -> Response:
+    def _post_main_wall_post_create(self, body: str) -> Response:
        data = {"_token": self.token, "post_message": body}
        return self.post("{}/main/wall-post/create/json".format(self.url), data=data)

-    def _post_wall_post_retrieve(self) -> Response:
+    def _post_main_wall_post_automatic(self, **kwargs) -> Response:
+        kwargs.update(_token=self.token)
+        return self.post("{}/main/wall-post/create/json".format(self.url), data=kwargs)
+
+    def _post_main_wall_post_retrieve(self) -> Response:
        data = {"_token": self.token, "page": 1, "switchedFrom": False}
        return self.post("{}/main/wall-post/retrieve/json".format(self.url), data=data)

+    # 12th anniversary endpoints
+    def _get_anniversary_quest_data(self) -> Response:
+        return self.get("{}/main/anniversaryQuestData".format(self.url))
+
+    def _post_map_rewards_unlock(self, node_id: int) -> Response:
+        data = {'nodeId': node_id, '_token': self.token}
+        return self.post("{}/main/map-rewards-unlock".format(self.url), data=data)
+
+    def _post_map_rewards_speedup(self, node_id: int, currency_amount: int) -> Response:
+        data = {'nodeId': node_id, '_token': self.token, "currencyCost": currency_amount}
+        return self.post("{}/main/map-rewards-speedup".format(self.url), data=data)
+
+    def _post_map_rewards_claim(self, node_id: int) -> Response:
+        data = {'nodeId': node_id, '_token': self.token}
+        return self.post("{}/main/map-rewards-claim".format(self.url), data=data)
+
+    def _post_new_war(self, self_country_id: int, attack_country_id: int, debate: str = "") -> Response:
+        data = dict(requirments=1, _token=self.token, debate=debate,
+                    countryNameConfirm=utils.COUNTRY_LINK[attack_country_id])
+        return self.post("{}/{}/new-war".format(self.url, utils.COUNTRY_LINK[self_country_id]), data=data)
+
+    def _post_new_donation(self, country_id: int, amount: int, org_name: str, debate: str = "") -> Response:
+        data = dict(requirments=1, _token=self.token, debate=debate, currency=1, value=amount, commit='Propose',
+                    type_name=org_name)
+        return self.post("{}/{}/new-donation".format(self.url, utils.COUNTRY_LINK[country_id]), data=data)
+

 class Reporter:
-    __to_update: List[Dict[Any, Any]] = []
+    __to_update: List[Dict[Any, Any]] = None
    name: str = ""
    email: str = ""
    citizen_id: int = 0
    key: str = ""
    allowed: bool = False

+    @property
+    def __dict__(self):
+        return dict(name=self.name, email=self.email, citizen_id=self.citizen_id, key=self.key, allowed=self.allowed,
+                    queue=self.__to_update)
+
    def __init__(self):
        self._req = Session()
        self.url = "https://api.erep.lv"
        self._req.headers.update({"user-agent": "Bot reporter v2"})
+        self.__to_update = []
        self.__registered: bool = False

-    @property
-    def __dict__(self):
-        return dict(allowed=self.allowed, __to_update=self.__to_update)
-
    def do_init(self, name: str = "", email: str = "", citizen_id: int = 0):
        self.name: str = name
        self.email: str = email
@ -962,11 +1026,12 @@ class Reporter:

 class MyJSONEncoder(JSONEncoder):
    def default(self, o):
+        from erepublik.citizen import Citizen
        if isinstance(o, decimal.Decimal):
            return float("{:.02f}".format(o))
        elif isinstance(o, datetime.datetime):
            return dict(__type__='datetime', year=o.year, month=o.month, day=o.day, hour=o.hour, minute=o.minute,
-                        second=o.second, microsecond=o.microsecond)
+                        second=o.second, microsecond=o.microsecond, tzinfo=o.tzinfo.zone if o.tzinfo else None)
        elif isinstance(o, datetime.date):
            return dict(__type__='date', year=o.year, month=o.month, day=o.day)
        elif isinstance(o, datetime.timedelta):
@ -976,8 +1041,10 @@ class MyJSONEncoder(JSONEncoder):
            return dict(headers=o.headers.__dict__, url=o.url, text=o.text)
        elif hasattr(o, '__dict__'):
            return o.__dict__
-        elif isinstance(o, deque):
+        elif isinstance(o, (deque, set)):
            return list(o)
+        elif isinstance(o, Citizen):
+            return o.to_json()
        return super().default(o)


@ -997,30 +1064,39 @@ class BattleSide:
 class BattleDivision:
    end: datetime.datetime
    epic: bool
-    dom_pts: Dict[str, int] = None
-    wall: Dict[str, Union[int, float]] = None
+    dom_pts: Dict[str, int]
+    wall: Dict[str, Union[int, float]]
+    battle_zone_id: int
+    def_medal: Dict[str, int]
+    inv_medal: Dict[str, int]

    @property
    def div_end(self) -> bool:
        return utils.now() >= self.end

-    def __init__(self, end: datetime.datetime, epic: bool, inv_pts: int, def_pts: int, wall_for: int, wall_dom: float):
+    def __init__(
+        self, div_id: int, end: datetime.datetime, epic: bool, inv_pts: int, def_pts: int,
+        wall_for: int, wall_dom: float, def_medal: Tuple[int, int], inv_medal: Tuple[int, int]
+    ):
+        self.battle_zone_id = div_id
        self.end = end
        self.epic = epic
        self.dom_pts = dict({"inv": inv_pts, "def": def_pts})
        self.wall = dict({"for": wall_for, "dom": wall_dom})
+        self.def_medal = {"id": def_medal[0], "dmg": def_medal[1]}
+        self.inv_medal = {"id": inv_medal[0], "dmg": inv_medal[1]}


-class Battle(object):
-    id: int = 0
-    war_id: int = 0
-    zone_id: int = 0
-    is_rw: bool = False
-    is_dict_lib: bool = False
-    start: datetime.datetime = None
-    invader: BattleSide = None
-    defender: BattleSide = None
-    div: Dict[int, BattleDivision] = None
+class Battle:
+    id: int
+    war_id: int
+    zone_id: int
+    is_rw: bool
+    is_dict_lib: bool
+    start: datetime.datetime
+    invader: BattleSide
+    defender: BattleSide
+    div: Dict[int, BattleDivision]

    @property
    def is_air(self) -> bool:
@ -1051,11 +1127,18 @@ class Battle(object):
            else:
                end = utils.localize_dt(datetime.datetime.max - datetime.timedelta(days=1))

-            battle_div = BattleDivision(
-                end=end, epic=data.get('epic_type') in [1, 5],
-                inv_pts=data.get('dom_pts').get("inv"), def_pts=data.get('dom_pts').get("def"),
-                wall_for=data.get('wall').get("for"), wall_dom=data.get('wall').get("dom")
-            )
+            if not data['stats']['def']:
+                def_medal = (0, 0)
+            else:
+                def_medal = (data['stats']['def']['citizenId'], data['stats']['def']['damage'])
+            if not data['stats']['inv']:
+                inv_medal = (0, 0)
+            else:
+                inv_medal = (data['stats']['inv']['citizenId'], data['stats']['inv']['damage'])
+            battle_div = BattleDivision(end=end, epic=data.get('epic_type') in [1, 5], div_id=data.get('id'),
+                                        inv_pts=data.get('dom_pts').get("inv"), def_pts=data.get('dom_pts').get("def"),
+                                        wall_for=data.get('wall').get("for"), wall_dom=data.get('wall').get("dom"),
+                                        def_medal=def_medal, inv_medal=inv_medal)

            self.div.update({div: battle_div})

@ -1066,9 +1149,10 @@ class Battle(object):
            time_part = "{}".format(now - self.start)
        else:
            time_part = "- {}".format(self.start - now)
-        return "Battle {} | {:>21.21}:{:<21.21} | Round {:2} | Start {}".format(
-            self.id, utils.COUNTRIES[self.invader.id], utils.COUNTRIES[self.defender.id], self.zone_id, time_part
-        )
+        return f"Battle {self.id} | " \
+               f"{utils.COUNTRIES[self.invader.id]:>21.21}:{utils.COUNTRIES[self.defender.id]:<21.21} | " \
+               f"Round {self.zone_id:2} | " \
+               f"Time since start {time_part}"


 class EnergyToFight:
@ -1100,3 +1184,91 @@ class EnergyToFight:
        if 0 < new_energy < self.energy:
            self.energy = new_energy
        return self.energy
+
+
+class TelegramBot:
+    __initialized = False
+    __queue: List[str]
+    chat_id = 0
+    api_url = ""
+    player_name = ""
+    __thread_stopper: threading.Event
+    _last_time: datetime.datetime
+    _last_full_energy_report: datetime.datetime
+    _next_time: datetime.datetime
+    _threads: List[threading.Thread]
+
+    def __init__(self, stop_event: threading.Event = None):
+        self._threads = []
+        self.__queue = []
+        self.__thread_stopper = threading.Event() if stop_event is None else stop_event
+
+    def __dict__(self):
+        return dict(chat_id=self.chat_id, api_url=self.api_url, player=self.player_name, last_time=self._last_time,
+                    next_time=self._next_time, queue=self.__queue, initialized=self.__initialized,
+                    has_threads=bool(len(self._threads)))
+
+    def do_init(self, chat_id: int, token: str, player_name: str = ""):
+        self.chat_id = chat_id
+        self.api_url = "https://api.telegram.org/bot{}/sendMessage".format(token)
+        self.player_name = player_name
+        self.__initialized = True
+        self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-5))
+        self._last_full_energy_report = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-30))
+        if self.__queue:
+            self.send_message("\n\n––––––––––––––––––––––\n\n".join(self.__queue))
+
+    def send_message(self, message: str) -> bool:
+        self.__queue.append(message)
+        if not self.__initialized:
+            return True
+        self._threads = [t for t in self._threads if t.is_alive()]
+        self._next_time = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=1))
+        if not self._threads:
+            name = "telegram_{}send".format(f"{self.player_name}_" if self.player_name else "")
+            send_thread = threading.Thread(target=self.__send_messages, name=name)
+            send_thread.start()
+            self._threads.append(send_thread)
+
+        return True
+
+    def report_free_bhs(self, battles: List[Tuple[int, int, int, int, datetime.timedelta]]):
+        battle_links = []
+        for battle_id, side_id, against_id, damage, time_left in battles:
+            total_seconds = int(time_left.total_seconds())
+            time_start = ""
+            hours, remainder = divmod(total_seconds, 3600)
+            if hours:
+                time_start = f"{hours}h "
+            minutes, seconds = divmod(remainder, 60)
+            time_start += f"{minutes:02}m {seconds:02}s"
+            damage = "{:,}".format(damage).replace(',', ' ')
+            battle_links.append(f"*{damage}*dmg bh for [{utils.COUNTRIES[side_id]} vs {utils.COUNTRIES[against_id]}]"
+                                f"(https://www.erepublik.com/en/military/battlefield/{battle_id}) "
+                                f"_time since start {time_start}_")
+        self.send_message("Free BHs:\n" + "\n".join(battle_links))
+
+    def report_full_energy(self, available: int, limit: int, interval: int):
+        if (utils.now() - self._last_full_energy_report).total_seconds() >= 30 * 60:
+            self._last_full_energy_report = utils.now()
+            message = f"Full energy ({available}hp/{limit}hp +{interval}hp/6min)"
+            self.send_message(message)
+
+    def report_medal(self, msg):
+        self.send_message(f"New award: *{msg}*")
+
+    def __send_messages(self):
+        while self._next_time > utils.now():
+            if self.__thread_stopper.is_set():
+                break
+            self.__thread_stopper.wait(utils.get_sleep_seconds(self._next_time))
+
+        message = "\n\n––––––––––––––––––––––\n\n".join(self.__queue)
+        if self.player_name:
+            message = f"Player *{self.player_name}*\n" + message
+        response = post(self.api_url, json=dict(chat_id=self.chat_id, text=message, parse_mode="Markdown"))
+        self._last_time = utils.now()
+        if response.json().get('ok'):
+            self.__queue = []
+            return True
+        return False
--- a/erepublik/utils.py
+++ b/erepublik/utils.py
@ -13,11 +13,11 @@ from typing import Union, Any, List, NoReturn, Mapping
 import pytz
 import requests

-__all__ = ["FOOD_ENERGY", "COMMIT_ID", "COUNTRIES", "erep_tz",
+__all__ = ["FOOD_ENERGY", "COMMIT_ID", "COUNTRIES", "erep_tz", 'COUNTRY_LINK',
           "now", "localize_dt", "localize_timestamp", "good_timedelta", "eday_from_date", "date_from_eday",
           "get_sleep_seconds", "interactive_sleep", "silent_sleep",
           "write_silent_log", "write_interactive_log", "get_file", "write_file",
-           "send_email", "normalize_html_json", "process_error", ]
+           "send_email", "normalize_html_json", "process_error", 'report_promo', 'calculate_hit']

 FOOD_ENERGY = dict(q1=2, q2=4, q3=6, q4=8, q5=10, q6=12, q7=20)
 COMMIT_ID = "7b92e19"
@ -330,5 +330,45 @@ def slugify(value, allow_unicode=False) -> str:
        value = unicodedata.normalize('NFKC', value)
    else:
        value = unicodedata.normalize('NFKD', value).encode('ascii', 'ignore').decode('ascii')
-    value = re.sub(r'[^\w\s-]', '', value).strip().lower()
+    value = re.sub(r'[^\w\s-]', '_', value).strip().lower()
    return re.sub(r'[-\s]+', '-', value)
+
+
+def calculate_hit(strength: float, rang: int, tp: bool, elite: bool, ne: bool, booster: int = 0,
+                  weapon: int = 200) -> float:
+    base_dmg = 10 * (1 + strength / 400) * (1 + rang / 5) * (1 + weapon / 100)
+    dmg = int(base_dmg * 10 + 5) // 10
+
+    booster_multiplier = (100 + booster) / 100
+    booster_dmg = dmg * booster_multiplier
+    dmg = int(booster_dmg * 10 + 5) // 10
+
+    elite = 1.1 if elite else 1
+    elite_dmg = dmg * elite
+    dmg = int(elite_dmg)
+
+    legend = 1 if (not tp or rang < 70) else 1 + (rang - 69) / 10
+    legend_dmg = dmg * legend
+    dmg = int(legend_dmg)
+
+    return dmg * (1.1 if ne else 1)
+
+
+def ground_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False,
+                         booster: int = 0, weapon_power: int = 200) -> float:
+    r = requests.get(f"https://www.erepublik.com/en/main/citizen-profile-json/{citizen_id}").json()
+    rang = r['military']['militaryData']['ground']['rankNumber']
+    strength = r['military']['militaryData']['ground']['strength']
+    elite = r['citizenAttributes']['level'] > 100
+    if natural_enemy:
+        true_patriot = True
+
+    return calculate_hit(strength, rang, true_patriot, elite, natural_enemy, booster, weapon_power)
+
+
+def air_hit_dmg_value(citizen_id: int, natural_enemy: bool = False, true_patriot: bool = False, booster: int = 0,
+                      weapon_power: int = 0) -> float:
+    r = requests.get(f"https://www.erepublik.com/en/main/citizen-profile-json/{citizen_id}").json()
+    rang = r['military']['militaryData']['aircraft']['rankNumber']
+    elite = r['citizenAttributes']['level'] > 100
+    return calculate_hit(0, rang, true_patriot, elite, natural_enemy, booster, weapon_power)
--- a/requirements_dev.txt
+++ b/requirements_dev.txt
@ -5,11 +5,10 @@ watchdog==0.9.0
 flake8==3.7.8
 tox==3.13.2
 coverage==4.5.3
-Sphinx==2.1.2
-twine==1.13.0
-ipython==7.6.1
-PyInstaller==3.5
+Sphinx==2.2.0
+twine==2.0.0
+ipython
+PyInstaller
 pytz==2019.1
 requests==2.22.0
-pycryptodome==3.8.2
-python-slugify==2.0.1
+edx-sphinx-theme
--- a/setup.cfg
+++ b/setup.cfg
@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.15.3
+current_version = 0.17.2
 commit = True
 tag = True

--- a/setup.py
+++ b/setup.py
@ -11,11 +11,11 @@ with open('README.rst') as readme_file:
 with open('HISTORY.rst') as history_file:
    history = history_file.read()

-requirements = ['pytz==2019.1', 'requests==2.22.0']
+requirements = ['pytz>=2019.2', 'requests>=2.22']

-setup_requirements = [ ]
+setup_requirements = []

-test_requirements = [ ]
+test_requirements = []

 setup(
    author="Eriks Karls",
@ -41,7 +41,7 @@ setup(
    setup_requires=setup_requirements,
    test_suite='tests',
    tests_require=test_requirements,
-    url='https://github.com/eeriks/erepublik_script',
-    version='0.15.3',
+    url='https://github.com/eeriks/erepublik/',
+    version='0.17.2',
    zip_safe=False,
 )
--- a/tests/test_erepublik_script.py
+++ b/tests/test_erepublik_script.py
@ -5,30 +5,126 @@


 import unittest
-from click.testing import CliRunner

 from erepublik import Citizen
-from erepublik import cli


-class TestErepublik_script(unittest.TestCase):
+class TestErepublik(unittest.TestCase):
    """Tests for `erepublik` package."""

    def setUp(self):
        """Set up test fixtures, if any."""
+        self.citizen = Citizen("email", "password", False)
+        self.citizen.config.interactive = False

-    def tearDown(self):
-        """Tear down test fixtures, if any."""
+    def test_should_do_levelup(self):
+        self.citizen.energy.recovered = 1900
+        self.citizen.energy.recoverable = 2940
+        self.citizen.energy.interval = 30
+        self.citizen.energy.limit = 3000
+        self.citizen.details.xp = 14850
+        self.assertTrue(self.citizen.should_do_levelup)

-    def test_000_something(self):
-        """Test something."""
+        self.citizen.energy.recoverable = 1000
+        self.assertFalse(self.citizen.should_do_levelup)
+
+    def test_should_travel_to_fight(self):
+        self.citizen.config.always_travel = True
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.citizen.config.always_travel = False
+        self.assertFalse(self.citizen.should_travel_to_fight())
+
+        self.citizen.energy.recovered = 1900
+        self.citizen.energy.recoverable = 2940
+        self.citizen.energy.interval = 30
+        self.citizen.energy.limit = 3000
+        self.citizen.details.xp = 14850
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.citizen.details.xp = 15000
+        self.assertFalse(self.citizen.should_travel_to_fight())
+
+        self.citizen.energy.recovered = 3000
+        self.citizen.energy.recoverable = 2910
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.citizen.energy.recoverable = 2900
+        self.assertFalse(self.citizen.should_travel_to_fight())
+
+        # self.citizen.next_reachable_energy and self.citizen.config.next_energy
+        self.citizen.config.next_energy = True
+        self.citizen.energy.limit = 5000
+        self.citizen.details.next_pp = [5000, 5250, 5750, 6250, 6750]
+        self.citizen.details.pp = 4900
+        self.citizen.energy.recovered = 4000
+        self.citizen.energy.recoverable = 4510
+        self.assertEqual(self.citizen.next_reachable_energy, 850)
+        self.citizen.energy.recoverable = 4490
+        self.assertTrue(self.citizen.should_travel_to_fight())
+        self.assertEqual(self.citizen.next_reachable_energy, 350)
+        self.citizen.energy.recovered = 100
+        self.citizen.energy.recoverable = 150
+        self.assertFalse(self.citizen.should_travel_to_fight())
+        self.assertEqual(self.citizen.next_reachable_energy, 0)
+
+    def test_should_fight(self):
+        self.citizen.config.fight = False
+        self.assertEqual(self.citizen.should_fight(), 0)
+
+        self.citizen.config.fight = True
+
+        # Level up
+        self.citizen.energy.limit = 3000
+        self.citizen.details.xp = 24705
+        self.assertEqual(self.citizen.should_fight(), 0)
+
+        self.citizen.energy.recovered = 3000
+        self.citizen.energy.recoverable = 2950
+        self.citizen.energy.interval = 30
+        self.assertEqual(self.citizen.should_fight(), 900)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 900)
+        self.citizen.my_companies.ff_lockdown = 0
+
+        # Level up reachable
+        self.citizen.details.xp = 24400
+        self.assertEqual(self.citizen.should_fight(), 305)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 305)
+        self.citizen.my_companies.ff_lockdown = 0
+
+        self.citizen.details.xp = 21000
+        self.assertEqual(self.citizen.should_fight(), 75)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 75)
+        self.citizen.my_companies.ff_lockdown = 0
+        self.citizen.details.pp = 80
+
+        # All-in (type = all-in and full ff)
+        self.citizen.config.all_in = True
+        self.assertEqual(self.citizen.should_fight(), 595)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 435)
+        self.citizen.my_companies.ff_lockdown = 0
+
+        self.citizen.config.air = True
+        self.citizen.energy.recoverable = 1000
+        self.assertEqual(self.citizen.should_fight(), 400)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 240)
+        self.citizen.my_companies.ff_lockdown = 0
+        self.citizen.config.all_in = False
+
+        self.citizen.config.next_energy = True
+        self.citizen.energy.limit = 5000
+        self.citizen.details.next_pp = [100, 150, 250, 400, 500]
+        self.assertEqual(self.citizen.should_fight(), 320)
+        self.citizen.my_companies.ff_lockdown = 160
+        self.assertEqual(self.citizen.should_fight(), 160)
+        self.citizen.my_companies.ff_lockdown = 0
+        self.citizen.energy.limit = 3000
+        self.citizen.details.next_pp = [19250, 20000]
+        self.citizen.config.next_energy = False
+
+        # 1h worth of energy
+        self.citizen.energy.recoverable = 2910
+        self.assertEqual(self.citizen.should_fight(), 30)

-    def test_command_line_interface(self):
-        """Test the CLI."""
-        runner = CliRunner()
-        result = runner.invoke(cli.main)
-        assert result.exit_code == 0
-        assert 'erepublik.cli.main' in result.output
-        help_result = runner.invoke(cli.main, ['--help'])
-        assert help_result.exit_code == 0
-        assert '--help  Show this message and exit.' in help_result.output
--- a/tox.ini
+++ b/tox.ini
@ -1,10 +1,9 @@
 [tox]
-envlist =  py36, py37, flake8
+envlist =  py37, flake8

 [travis]
 python =
    3.7: py37
-    3.6: py36

 [testenv:flake8]
 basepython = python
Author	SHA1	Message	Date
Eriks Karls	b7f8182ef5	Bump version: 0.17.1 → 0.17.2	2019-12-13 19:32:29 +02:00
Eriks Karls	39093accd0	Type hinting. Class parameter defined lists where shared accross instances.	2019-12-13 19:30:43 +02:00
Eriks Karls	aba8c15fd3	AutoPost medals	2019-12-03 15:22:35 +02:00
Eriks Karls	f294506a2d	Updated wars list, added default weapon choosing (q7 - ground, bare hands - air)	2019-12-03 09:52:53 +02:00
Eriks Karls	fd56c6c389	By default sort battles by time	2019-12-03 09:44:14 +02:00
Eriks Karls	4f613ee5ac	remvoed unused variables	2019-12-03 09:43:55 +02:00
Eriks Karls	a7dd528597	Citizen get() and post() signature update, check if server isn't compaining about request flooding	2019-12-03 09:42:51 +02:00
Eriks Karls	24c755d414	code style	2019-12-03 09:41:07 +02:00
Eriks Karls	13b639dc5a	Bump version: 0.17.0 → 0.17.1	2019-11-21 14:04:49 +02:00
Eriks Karls	ec1141a46e	set serialization	2019-11-21 14:04:43 +02:00
Eriks Karls	77170433c2	Bump version: 0.16.1 → 0.17.0	2019-11-21 11:12:49 +02:00
Eriks Karls	4736f70203	History update	2019-11-21 11:12:43 +02:00
Eriks Karls	48a27997ac	Bump version: 0.16.0 → 0.16.1	2019-11-21 11:10:15 +02:00
Eriks Karls	90bec82630	12th anniversary minimal methods	2019-11-21 11:06:29 +02:00
Eriks Karls	aedfbf4465	12th anniversary endpoints	2019-11-21 10:42:55 +02:00
Eriks Karls	66f459c692	Inventory structure update	2019-10-30 19:42:05 +02:00
Eriks Karls	ef27960ff1	no message	2019-10-30 19:35:40 +02:00
Eriks Karls	c48af9a891	Thread stopping	2019-10-30 18:16:18 +02:00
Eriks Karls	1abfdb71ac	Code cleanup and serialization improvements	2019-10-30 16:55:33 +02:00
Eriks Karls	e060f67666	More inventory structure updates	2019-10-29 16:06:07 +02:00
Eriks Karls	06d8d1c0b5	Telegram threading queue has been messing with error reporting	2019-10-29 16:05:22 +02:00
Eriks Karls	adda8dcb54	Structure requests by year/month/date folders, to keep requests in cleaner format. The same medal kind (Maverick div BHs) can have different reward value - group them by kind-reward. Citizen.post bugfix (with no data and json arguments) TODO: Must check where post is called without data or json	2019-10-28 14:17:45 +02:00
Eriks Karls	c7f084436d	Inventory structure update	2019-10-18 18:18:39 +03:00
Eriks Karls	94a87091a4	Allow full energy reports once every half an hour	2019-10-17 19:15:17 +03:00
Eriks Karls	c0b97f112d	TelegramBot.send_message should always append to send queue	2019-10-16 15:10:38 +03:00
Eriks Karls	3d895bd085	Damage calculation	2019-10-16 15:09:28 +03:00
Eriks Karls	d548d1bbf1	Hit calculation can be static	2019-10-15 20:03:38 +03:00
Eriks Karls	b1eefcc662	CSRF Attack Detecked loop on POST requests.	2019-10-15 20:03:22 +03:00
Eriks Karls	41798c446c	Return successfully transfered item count	2019-10-15 11:28:56 +03:00
Eriks Karls	074da3adbe	Telegram reporter queue bug	2019-10-14 19:21:00 +03:00
Eriks Karls	6c9a9e920d	Delay telegram notification sending by appending multiple messages to queue and after minute of inactivity clear the queue by sending all messages	2019-10-14 13:44:31 +03:00
Eriks Karls	ffa2fc109c	Travel for fighting fixed	2019-10-14 13:14:30 +03:00
Eriks Karls	f7f4028f32	Revert "Travel for fighting" This reverts commit `07c8881092`.	2019-10-14 13:03:36 +03:00
Eriks Karls	e91705ce90	no message	2019-10-14 13:03:19 +03:00
Eriks Karls	ca65a1ffe1	iPython indexer infinite loop and crash	2019-10-14 12:54:59 +03:00
Eriks Karls	07c8881092	Travel for fighting	2019-10-13 23:50:45 +03:00
Eriks Karls	25e534f783	Always print should_fight message	2019-10-08 09:32:00 +03:00
Eriks Karls	daa071f0f5	RTD build image url fixed, setup.py typo	2019-10-08 09:31:09 +03:00
Eriks Karls	2f8120bd0d	Telegram formatting	2019-10-01 09:59:37 +03:00
Eriks Karls	6b2c073abe	Damage booster activisation update and bugfix	2019-10-01 09:59:22 +03:00
Eriks Karls	c298d66086	Don't allow to fight before WeekChange even if force_fight (levelup, 75pp etc)	2019-10-01 09:58:37 +03:00
Eriks Karls	bf971972bf	History update with version number	2019-09-29 09:47:15 +03:00
Eriks Karls	50f3d291ca	Bump version: 0.15.3 → 0.16.0	2019-09-29 09:45:46 +03:00
Eriks Karls	b03140f2b8	RTD build image url fixed, setup.py typo	2019-09-29 09:42:24 +03:00
Eriks Karls	fe9a118875	Telegram loop traceback formatting Fixed double code execution in Citizen.update_citizen_info(None) calling Citizen.update_citizen_info(html) and executing code twice.	2019-09-29 09:40:25 +03:00
Eriks Karls	17c73c79a7	Trying to find how and where Telegram spam happens	2019-09-28 16:03:31 +03:00
Eriks Karls	7533608316	Version updates	2019-09-27 13:51:09 +03:00
Eriks Karls	71a7f55338	Changes in eRepublik html	2019-09-27 11:50:51 +03:00
Eriks Karls	0ca0f49f92	bugfix	2019-09-27 11:20:00 +03:00
Eriks Karls	3f1b0018b2	Misplaced telegram queueing	2019-09-27 11:11:18 +03:00
Eriks Karls	2aaa4aad65	cleanup	2019-09-27 11:03:22 +03:00
Eriks Karls	b44a3a4b62	Init update	2019-09-27 11:03:02 +03:00
Eriks Karls	3a7dd9a6fa	Init update	2019-09-27 11:02:26 +03:00
Eriks Karls	630c7cbc76	Was trying to send messages before citizen has been initialized	2019-09-27 10:26:53 +03:00
Eriks Karls	1ee47dfdcf	Telegram integration	2019-09-26 15:53:21 +03:00
Eriks Karls	ab34135b73	Telegram integration	2019-09-26 15:44:21 +03:00
Eriks Karls	20bba4b9f9	Telegram integration	2019-09-26 15:42:16 +03:00
Eriks Karls	8db4ab1f0f	Company sorting for wam: Raw factories, food, weapon, house, air, q7...q1, Final factories, food, weapon, house, air, q7...q1	2019-09-25 09:38:27 +03:00
Eriks Karls	acbf1590d7	If not enough food for wam - buy food and wam	2019-09-25 09:36:42 +03:00
Eriks Karls	63dd2d4f77	Optimisation and test cleanup	2019-09-05 15:36:01 +03:00
Eriks Karls	896b1b2432	Bugfix, cleanup and optimisation	2019-09-05 15:01:54 +03:00
Eriks Karls	60543e02c8	Merge branch 'master' into tests * master: Update citizen.py Update citizen.py	2019-09-03 11:56:00 +03:00
Eriks Karls	b06e9a2933	Merge branch 'master' of github.com:eeriks/erepublik_script * 'master' of github.com:eeriks/erepublik_script: Update citizen.py Update citizen.py	2019-09-03 11:55:44 +03:00
Eriks Karls	4eb96d7f1e	Testing should travel and should fight	2019-09-03 11:55:34 +03:00
Ēriks Karls	c8a1d8c8e8	Update citizen.py If not employee find new job	2019-09-01 19:58:52 +03:00
Ēriks Karls	c85f0417f2	Update citizen.py Apply for work bugfix	2019-09-01 19:47:17 +03:00
Eriks Karls	7573f29950	Freshening up documentation	2019-08-28 17:16:46 +03:00
Eriks Karls	597d27117c	Donating money now return status true or false	2019-08-27 11:16:36 +03:00
Eriks Karls	95570b7c17	Article voting and endorsing	2019-08-27 11:03:08 +03:00
Eriks Karls	bc4ba671d6	Endpoint method names renamed to better represent urls	2019-08-27 11:02:52 +03:00
Eriks Karls	088219a60a	Endpoint method names renamed to better represent urls	2019-08-27 10:51:57 +03:00
Eriks Karls	53266b1c94	Merge branch 'master' of github.com:eeriks/erepublik_script	2019-08-27 10:17:34 +03:00
Eriks Karls	065a0ff3ec	bugfix	2019-08-27 10:13:37 +03:00
Eriks Karls	c8e90ca910	bugfix	2019-08-27 10:13:14 +03:00
Ēriks Karls	bbab84bf5b	Update utils.py	2019-08-26 22:42:06 +03:00
Eriks Karls	fff17469e0	More verbose Citizen class serialization	2019-08-26 10:06:18 +03:00
Eriks Karls	0d208a8d32	Add timezone to datetime serialization	2019-08-26 10:05:52 +03:00
Eriks Karls	86004eb81b	Don't serialize password nor email	2019-08-26 10:05:22 +03:00
Eriks Karls	7e05e35ebf	More verbose Object representation in json format	2019-08-26 09:47:04 +03:00
Eriks Karls	411b158487	Citizen.buy_food() now buys 48h worth of food When doing WAM and fialing because not enough food - buy food Integrated new RW side chooser	2019-08-26 09:32:12 +03:00