Add db to send notification one time

.gitignore

@@ -131,3 +131,4 @@ dmypy.json
 
 # Ignore config
 conf/kimsufi.yaml
+db.sqlite

config/kimsufi.sample.yaml

@@ -1,9 +1,31 @@
-config:
+main:
-  - main:
+  api_url: https://www.ovh.com/engine/api/dedicated/server/availabilities?country=FR
-    - api_url: https://www.ovh.com/engine/api/dedicated/server/availabilities?country=FR
+  id_server:
-    - id_server:
+    - 1801sk14
-      - 160sk2
+    - 1801sk15
-      - 160sk3
+  datacenter:
-  - notifications:
+    - fra
-      - email:
+    - gra
-        - host: domain.tld
+    - sbg
+    - rbx
+log:
+  level: INFO
+  path: log/tracker.log
+notifications:
+  email:
+    user: me%40domain.tld
+    password: pwd
+    host: mdomain.tld
+    port: 587
+    from: me@domain.tld
+    secure: True
+    to: me@domain.tld
+    mode: starttls
+  xmpp:
+    user: notifier
+    password: pwd
+    host: xmpp.domain.tld
+    port: 5223
+    to: me@xmpp.domain.tld
+    secure: True
+db: db.sqlite

config/refToName.yml

@@ -0,0 +1,12 @@
+1801sk12: KS-1
+1801sk13: KS-2
+1801sk14: KS-3
+1801sk15: KS-4
+1801sk16: KS-5
+1801sk17: KS-6
+1801sk18: KS-7
+1801sk19: KS-8
+1801sk20: KS-9
+1801sk21: KS-10
+1801sk22: KS-11
+1801sk23: KS-12

src/core.py

@@ -2,8 +2,9 @@
 # coding: utf-8
 # -*- coding: utf-8 -*-
 
+import os
 import requests
-import pprint
+from src.db import DB
 from src.logs import Logger
 from src.notifications import Notifications
 from src.settings import Settings
@@ -15,6 +16,12 @@ class OVHTracker:
         self.logger = Logger(
             self.settings["log"]["level"], self.settings["log"]["path"]
         )
+        if os.path.isfile(self.settings["db"]):
+            self.logger.info("DB already created")
+        else:
+            self.logger.warning("DB not created")
+            DB(self.settings["db"], self.settings).create()
+        self.db = DB(self.settings["db"], self.settings)
         self.logger.info("App loaded")
         self.main()
 
@@ -40,13 +47,43 @@ class OVHTracker:
                         for wantedDatacenter in self.settings["main"]["datacenter"]:
                             if wantedDatacenter in dc["datacenter"]:
                                 if dc["availability"] not in ("unavailable", "unknown"):
+                                    if (
+                                        self.db.isServerExist(
+                                            wantedServer, wantedDatacenter
+                                        )
+                                        is False
+                                    ):
+                                        self.db.insertServer(
+                                            wantedServer, wantedDatacenter
+                                        )
+                                    self.db.updateAvailable(
+                                        wantedServer, wantedDatacenter, 1
+                                    )
+
                                     self.logger.info(
                                         "{} is available in {}".format(
                                             wantedServer, wantedDatacenter
                                         )
                                     )
-                                    self.notify(wantedServer)
+                                    if self.db.isNotified(
+                                        wantedServer, wantedDatacenter
+                                    ):
+                                        self.logger.info("Already notified")
+                                    else:
+                                        self.notify(wantedServer, wantedDatacenter)
+                                    self.db.updateNotified(
+                                        wantedServer, wantedDatacenter, 1
+                                    )
+                                else:
+                                    if self.db.isServerExist(
+                                        wantedServer, wantedDatacenter
+                                    ):
+                                        self.db.updateAvailable(
+                                            wantedServer, wantedDatacenter, 0
+                                        )
+                                        self.db.updateNotified(
+                                            wantedServer, wantedDatacenter, 0
+                                        )
 
-    def notify(self, server):
+    def notify(self, server, datacenter):
-        self.notification = Notifications(self.settings)
+        Notifications(self.settings).run(server, datacenter)
-        return True

src/db.py

@@ -0,0 +1,84 @@
+#!/usr/bin/env python3
+# coding: utf-8
+# -*- coding: utf-8 -*-
+
+import sqlite3
+
+from sqlite3 import Error
+from src.logs import Logger
+
+
+class DB:
+    def __init__(self, db, config):
+        self.logger = Logger(config["log"]["level"], config["log"]["path"])
+        try:
+            self.connection = sqlite3.connect(db)
+        except Error as e:
+            self.logger.error("Can't connect to {}. Error : {}".format(db, e))
+
+    def create(self):
+        cursor = self.connection.cursor()
+        cursor.execute(
+            """CREATE TABLE IF NOT EXISTS server (
+            name VARCHAR(10) NOT NULL,
+            datacenter VARCHAR(10) NOT NULL,
+            available int(1) NOT NULL,
+            notified int(1) NOT NULL
+            );"""
+        )
+        self.connection.commit()
+
+    def insertServer(self, server, datacenter):
+        data = (server, datacenter)
+        cursor = self.connection.cursor()
+        cursor.execute(
+            """INSERT INTO server (name, datacenter, available, notified)
+                VALUES (?,?,0,0)""",
+            data,
+        )
+        self.connection.commit()
+
+    def updateAvailable(self, server, datacenter, status):
+        data = (status, server, datacenter)
+        cursor = self.connection.cursor()
+        cursor.execute(
+            """UPDATE server
+            SET available = ?
+            WHERE name = ? AND datacenter = ?""",
+            data,
+        )
+        self.connection.commit()
+
+    def updateNotified(self, server, datacenter, notified):
+        data = (notified, server, datacenter)
+        cursor = self.connection.cursor()
+        cursor.execute(
+            """UPDATE server
+            SET notified = ?
+            WHERE name = ? AND datacenter = ?""",
+            data,
+        )
+        self.connection.commit()
+
+    def isServerExist(self, server, datacenter):
+        data = (server, datacenter)
+        cursor = self.connection.cursor()
+        cursor.execute(
+            "SELECT name FROM server WHERE name = ? AND datacenter = ?", data
+        )
+        if len(cursor.fetchall()) == 0:
+            return False
+        else:
+            return True
+
+    def isNotified(self, server, datacenter):
+        data = (server, datacenter)
+        cursor = self.connection.cursor()
+        cursor.execute(
+            "SELECT name FROM server WHERE name = ? AND datacenter = ? AND notified = 1",
+            data,
+        )
+        if len(cursor.fetchall()) == 0:
+            return False
+        else:
+            return True

src/notifications.py

@@ -3,62 +3,81 @@
 # -*- coding: utf-8 -*-
 
 import apprise
-import pprint
 
 from src.logs import Logger
+from src.settings import Settings
 
 
 class Notifications:
     def __init__(self, config):
-        self.logger = Logger(
+        self.logger = Logger(config["log"]["level"], config["log"]["path"])
-            config["log"]["level"], config["log"]["path"]
-        )
         self.config = config["notifications"]
         self.apprise = apprise.Apprise()
         self.allowedNotifyChannel = ["email", "discord", "matrix", "xmpp"]
         self._notifyChannel = {
-            "email": self._addEmail(),
+            "email": self._addEmail,
-            "discord": self._addDiscord(),
+            "discord": self._addDiscord,
-            "xmpp": self._addXmpp(),
+            "xmpp": self._addXmpp,
-            "matrix": self._addMatrix(),
+            "matrix": self._addMatrix,
         }
         self.setNotificationsChannel()
 
     def setNotificationsChannel(self):
-        pprint.pprint(self)
         for key, val in self.config.items():
             if key not in self.allowedNotifyChannel:
                 self.logger.error(
                     "{} is not possible".format(self.allowedNotifyChannel)
                 )
             else:
-                pprint.pprint(key)
-                pprint.pprint(self._notifyChannel)
                 self._notifyChannel[key]()
         return True
 
+    def run(self, server, datacenter):
+        refOfServer = Settings().get("config/refToName.yml")
+        self.apprise.notify(
+            body="{} is available {}".format(refOfServer[server], datacenter),
+            title="{} is available \o/".format(refOfServer[server], datacenter),
+            notify_type=apprise.NotifyType.INFO,
+        )
+
     def _addEmail(self):
-        self.logger.info("debug")
         if self.config["email"]["secure"] is True:
             mailto = "mailtos"
+            mode = self.config["email"]["mode"]
         else:
             mailto = "mailto"
+            mode = ""
         self.apprise.add(
-            "{}://{}:{}@{}:{}?from={}&name=OVHTracker".format(
+            "{}://{}:{}@{}:{}?from={}&name=OVHTracker&to={}?mode={}".format(
                 mailto,
                 self.config["email"]["user"],
                 self.config["email"]["password"],
                 self.config["email"]["host"],
                 self.config["email"]["port"],
-                self.config["email"]["from"]
+                self.config["email"]["from"],
+                self.config["email"]["to"],
+                mode,
+            )
+        )
+
+    def _addXmpp(self):
+        if self.config["xmpp"]["secure"] is True:
+            xmpp = "xmpps"
+        else:
+            xmpp = "xmpp"
+        self.apprise.add(
+            "{}://{}:{}@{}:{}?to={}".format(
+                xmpp,
+                self.config["xmpp"]["user"],
+                self.config["xmpp"]["password"],
+                self.config["xmpp"]["host"],
+                self.config["xmpp"]["port"],
+                self.config["xmpp"]["to"],
             )
         )
 
     def _addDiscord(self):
         return True
 
-    def _addXmpp(self):
-        return True
-
     def _addMatrix(self):
         return True