Closes #48

classes/pyroclient.py

@@ -1,5 +1,8 @@
+import logging
+from datetime import datetime, timedelta
 from typing import List, Union
 
+from aiohttp import ClientSession
 from apscheduler.triggers.cron import CronTrigger
 from libbot.pyrogram.classes import PyroClient as LibPyroClient
 from pymongo import ASCENDING, GEOSPHERE, TEXT
@@ -7,18 +10,32 @@ from pyrogram.types import User
 
 from classes.location import Location
 from classes.pyrouser import PyroUser
+from classes.updater import Updater
 from modules.database_api import col_locations
 from modules.reminder import remind
 
+logger = logging.getLogger(__name__)
+
 
 class PyroClient(LibPyroClient):
     def __init__(self, **kwargs):
+        self.__version__ = (0, 1, 2)
+
         super().__init__(**kwargs)
+
+        self.updater = Updater(ClientSession())
+        self.contexts = []
+
         if self.scheduler is not None:
             self.scheduler.add_job(
                 remind, CronTrigger.from_crontab("* * * * *"), args=(self,)
             )
-        self.contexts = []
+            if self.config["update_checker"]:
+                self.scheduler.add_job(
+                    self.check_updates,
+                    CronTrigger.from_crontab("0 12 */3 * *"),
+                    next_run_time=datetime.now() + timedelta(seconds=10),
+                )
 
     async def start(self, **kwargs):
         await col_locations.create_index(
@@ -31,6 +48,10 @@ class PyroClient(LibPyroClient):
         await col_locations.create_index([("name", TEXT)], name="location_name")
         return await super().start(**kwargs)
 
+    async def stop(self, **kwargs):
+        await self.updater.client_session.close()
+        await super().stop(**kwargs)
+
     async def find_user(self, user: Union[int, User]) -> PyroUser:
         """Find User by it's ID or User object.
 
@@ -68,3 +89,24 @@ class PyroClient(LibPyroClient):
         return [
             await Location.get(record["id"]) async for record in col_locations.find({})
         ]
+
+    async def check_updates(self) -> None:
+        if await self.updater.check_updates(
+            self.__version__, self.config["strings"]["url_updater"]
+        ):
+            try:
+                release = await self.updater.get_latest_release(
+                    self.config["strings"]["url_updater"]
+                )
+            except Exception as exc:
+                logger.error("Could not fetch the latest version: %s", exc)
+                return
+
+            await self.send_message(
+                self.owner,
+                self._("update_available", "messages").format(
+                    version_current=f"v{'.'.join(str(subversion) for subversion in self.__version__)}",
+                    version_new=release["tag_name"],
+                    release_url=release["html_url"],
+                ),
+            )

classes/updater.py

@@ -0,0 +1,44 @@
+import logging
+from typing import Any, Dict, Tuple
+
+from aiohttp import ClientSession
+
+logger = logging.getLogger(__name__)
+
+
+class Updater:
+    def __init__(self, client_session: ClientSession) -> None:
+        self.client_session: ClientSession = client_session
+
+    async def check_updates(
+        self, version_current: Tuple[int, int, int], api_url: str
+    ) -> bool:
+        response = await self.client_session.get(api_url)
+
+        if response.status != 200:
+            return False
+
+        try:
+            version_latest = (await response.json())["tag_name"][1:].split(".")
+        except Exception as exc:
+            logger.error("Error parsing latest version: %s", exc)
+            return False
+
+        return any(
+            version_current[index] < int(subversion)
+            for index, subversion in enumerate(version_latest)
+        )
+
+    async def get_latest_release(self, api_url: str) -> Dict[str, Any]:
+        response = await self.client_session.get(api_url)
+
+        if response.status != 200:
+            raise RuntimeError(f"Could not fetch latest release: {response.status}")
+
+        try:
+            return await response.json()
+        except Exception as exc:
+            logger.error("Error parsing latest release: %s", exc)
+            raise RuntimeError(
+                f"Error parsing latest release: {response.status}"
+            ) from exc