Initial Commit

Server/ServerLog.py

@@ -0,0 +1,126 @@
+from datetime import datetime
+
+import Session
+import User
+from DBConn import DBConn, get_unix_timestamp
+
+
+class ServerLog:
+    """Class for holding a server log entry from the database"""
+    def __init__(self, log_id: int = None):
+        self.__log_id = log_id
+        self.__session_ref = None
+        self.__log_action_dir = None
+        self.__log_action = None
+        self.__log_client_ip = None
+        self.__log_date = None
+        self.__is_valid = False
+
+        self.__session: Session.Session or None = None
+        self.__user: User.User or None = None
+
+        # if a log id is provided load the record from the database
+        if self.__log_id:
+            self.__load_server_log()
+
+    def __load_server_log(self) -> None:
+        """Private method for loading a server log from the database with its id"""
+        db_connection = DBConn()
+        server_log_details = db_connection.do_select("server_logs", "row", "*", "log_id = :log_id",
+                                                     [
+                                                         {
+                                                             "field": "log_id",
+                                                             "value": self.__log_id
+                                                         }
+                                                     ])
+        if server_log_details is not None and len(server_log_details) > 0:
+            self.__log_id = server_log_details['log_id']
+            self.__session_ref = server_log_details['session_ref']
+            self.__log_action_dir = server_log_details['log_action_dir']
+            self.__log_action = server_log_details['log_action']
+            self.__log_client_ip = server_log_details['log_client_ip']
+            self.__log_date = server_log_details['log_date']
+            self.__is_valid = True
+
+    def server_log_is_valid(self) -> bool:
+        """Method to check if a valid server log has been loaded from the database"""
+        return self.__is_valid
+
+    def get_log_action_dir(self) -> str:
+        """Method to get the logs direction variable"""
+        return self.__log_action_dir
+
+    def get_log_action(self) -> str:
+        """Method to get the log action variable"""
+        return self.__log_action
+
+    def get_log_action_with_dir(self) -> str:
+        """Method to return both the log direction and action as a string"""
+        return f"{self.get_log_action_dir()} {self.get_log_action()}"
+
+    def output_log_line(self, output_format_string: str, date_format_string: str = "%d/%m/%y %H:%M") -> str:
+        """Method for writing the log as a string in the format given"""
+        date_time_string = datetime.utcfromtimestamp(self.__log_date).strftime(date_format_string)
+
+        # Check if the log has a user and get the user name, otherwise it was an out of session action
+        if self.get_user():
+            username = self.get_user().username
+        else:
+            username = "N/A"
+
+        log_string = output_format_string.format(
+            date_time_string,
+            username,
+            self.__log_client_ip,
+            self.__log_action_dir,
+            self.__log_action[0: 40]
+        )
+
+        return log_string
+
+    def get_session(self) -> Session.Session or None:
+        """Method for getting the session object to use in the session variable"""
+        if self.__session_ref and self.__session_ref != "":
+            if not self.__session:
+                self.__session = Session.Session(self.__session_ref, None)
+                self.__session.load_session()
+            return self.__session
+        else:
+            return None
+
+    def get_user(self) -> User.User or None:
+        """Method for getting the user object for the user variable"""
+        if self.__session_ref and self.__session_ref != "":
+            if self.get_session():
+                # Preload the user into the object if not loaded beforehand
+                if not self.__user:
+                    self.__user = self.__session.get_user()
+                return self.__user
+            else:
+                return None
+        else:
+            return None
+
+    def create_server_log(self, session_ref: str, direction: str, action: str or bytes, ip: str) -> bool:
+        """Method for saving the current server log action to the database"""
+        result = False
+        if not self.__is_valid:
+            if len(direction) > 0 and len(action) > 0 and len(ip) > 0:
+                db_connection = DBConn()
+
+                # Force any byte strings into normal strings before putting it into the DB
+                try:
+                    action = action.decode()
+                except (UnicodeDecodeError, AttributeError):
+                    pass
+
+                if db_connection.do_insert("server_logs",
+                                           [{"field": "session_ref", "value": session_ref},
+                                            {"field": "log_action_dir", "value": direction},
+                                            {"field": "log_action", "value": action},
+                                            {"field": "log_client_ip", "value": ip},
+                                            {"field": "log_date", "value": get_unix_timestamp()}]):
+                    self.__load_server_log()
+                    result = True
+
+        return result