4 rasberry pi wifi upload script

.env.example

@@ -0,0 +1,4 @@
+WIFI_PASSWORD =
+DISCORD_WEBHOOK = 
+DEVICE_ID = 
+NETWORK_NAME = 

.flake8

@@ -1,6 +1,6 @@
 [flake8]
 
-max-line-length = 140
+max-line-length = 180
 
 # Exclude certain file patterns from checking
 exclude = 

.gitignore

@@ -30,4 +30,5 @@ Thumbs.db
 
 data/
 .ecu_data
-512311_xk3jq6ao_config.json
+512311_xk3jq6ao_config.json
+512311__config.json

data_uploader/box_client/box_client.py

@@ -0,0 +1,146 @@
+import requests
+import jwt
+import time
+import json
+import os
+import secrets
+from cryptography.hazmat.primitives.serialization import load_pem_private_key
+from cryptography.hazmat.backends import default_backend
+
+TOKEN_URL = os.getenv("TOKEN_URL")
+UPLOAD_URL = os.getenv("UPLOAD_URL")
+USER_INFO_URL = os.getenv("USER_INFO_URL")
+ROOT_FILE_PATH = os.getenv("ROOT_FILE_PATH")
+
+
+class Client:
+
+    def __init__(self, client_id: str, client_secret: str, enterprise_id: str, key_id: str, private_key: str, password: str, folder_path: str, folder_id: int):
+        self.client_id = client_id
+        self.client_secret = client_secret
+        self.enterprise_id = enterprise_id
+        self.key_id = key_id
+        self.private_key = private_key
+        self.password = password
+        self.folder_path = folder_path
+        self.folder_id = folder_id
+
+    def retrieve_access_token(self) -> str:
+        key_id = self.key_id
+        private_key = self.private_key
+        password = self.password
+
+        key = load_pem_private_key(
+            data=private_key.encode('utf8'),
+            password=password.encode('utf8'),
+            backend=default_backend()
+        )
+
+        claims = {
+            'iss': self.client_id,
+            'sub': self.enterprise_id,
+            'box_sub_type': 'enterprise',
+            'aud': TOKEN_URL,
+            'jti': secrets.token_hex(64),
+            'exp': int(time.time()) + 60
+        }
+
+        assertion = jwt.encode(
+            claims,
+            key,
+            algorithm='RS512',
+            headers={
+                'kid': key_id
+            }
+        )
+
+        params = {
+            'grant_type': 'urn:ietf:params:oauth:grant-type:jwt-bearer',
+            'assertion': assertion,
+            'client_id': self.client_id,
+            'client_secret': self.client_secret
+        }
+
+        try:
+            response = requests.post(TOKEN_URL, data=params)
+
+            if response.status_code == 200:
+
+                access_token = response.json().get("access_token")
+
+                return access_token
+
+        except requests.exceptions.RequestException as error:
+            print(f'Request Exception: {error}')
+        else:
+            print(f"Error: {response.status_code}")
+            print(response.text)
+            return None
+
+    def send_files(self, filenames: list) -> bool:
+        access_token = self.retrieve_access_token()
+
+        for filename in filenames:
+
+            file_name = os.path.basename(filename)
+
+            headers = {
+                "Authorization": f"Bearer {access_token}",
+            }
+
+            with open(filename, 'rb') as file_to_upload:
+
+                files = {
+                    'file': (filename, file_to_upload),
+                    'attributes': (None, json.dumps({'parent': {'id': str(self.folder_id)}, 'name': file_name}), 'application/json'),
+                }
+
+                try:
+                    response = requests.post(UPLOAD_URL, headers=headers, files=files)
+
+                    if response.status_code == 201:
+                        continue
+                    else:
+                        print(f"Error: {response.status_code}")
+                        print(response.json())
+                        return False
+
+                except requests.exceptions.RequestException as error:
+                    print(f'Request Exception: {error}')
+                    return False
+
+        return True
+
+    def get_user_info(self):
+
+        headers = {
+            "Authorization": f"Bearer {self.retrieve_access_token()}",
+        }
+
+        try:
+            response = requests.get(USER_INFO_URL, headers=headers)
+
+            if response.status_code == 200:
+                return response.json()
+            else:
+                print(f"Error: {response.status_code}")
+                print(response.json())
+                return False
+        except requests.exceptions.RequestException as error:
+            print(f'Request Exception: {error}')
+            return False
+
+    def discover_files(self) -> list:
+
+        list_of_files = []
+
+        if os.path.exists(self.folder_path) and os.path.isdir(self.folder_path):
+            files = os.listdir(self.folder_path)
+
+            for file in files:
+                list_of_files.append(ROOT_FILE_PATH + file)
+                print(file)
+
+            return list_of_files
+
+        return None

data_uploader/discord_client/messages.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class Messages(str, Enum):
+    MONGO_SUCCESS_MESSAGE = "Docuemnts inserted Successfully"
+    MONGO_ERROR_MESSAGE = "An error occurred while trying to connect to MongoDB: {e}"
+    MONGO_CLOSE_MESSAGE = "MongoDB connection closed."
+    BOX_SUCCESS_MESSAGE = "Files uploaded successfully"
+    BOX_ERROR_MESSAGE = "Error occurred while trying to upload files to Box"
+    WIFI_SUCCESS_MESSAGE = "Connected to network successfully"
+    WIFI_ERROR_MESSAGE = "Error occurred while trying to connect to network"

data_uploader/handler.py

@@ -0,0 +1,64 @@
+from data_uploader.box_client.box_client import Client as BoxClient
+from data_uploader.discord_client.discord_client import Client as DiscordClient
+from data_uploader.discord_client.messages import Messages as discord_messages
+from data_uploader.mongo_client.mongo_client import Client as MongoClient
+from data_uploader.wifi_client.wifi_client import Client as WifiClient
+
+
+import os
+from dotenv import load_dotenv
+import json
+
+
+config = json.load(
+    open('512311_xk3jq6ao_config.json')
+)
+
+
+class Handler:
+
+    def handler():
+
+        load_dotenv()
+        NETWORK_NAME = os.getenv('NETWORK_NAME')
+        WIFI_PASSWORD = os.getenv('NETWORK_PASSWORD')
+        WEBHOOK_URL = os.getenv('DISCORD_WEBHOOK')
+
+        wifi_client = WifiClient(NETWORK_NAME, WIFI_PASSWORD)
+        discord_client = DiscordClient(WEBHOOK_URL)
+        box_client = BoxClient(config['boxAppSettings']['clientID'], config['boxAppSettings']['clientSecret'], config['enterpriseID'], config['appAuth']['publicKeyID'],
+                               config['appAuth']['privateKey'], config['boxAppSettings']['appAuth']['passphrase'], config['file_path'], config['folder_id'])
+        mongo_client = MongoClient('cluster0', 'dfr_sensor_data')
+
+        files_for_upload = []
+
+        if wifi_client.connect_to_network():
+
+            discord_client.post_message(discord_messages.WIFI_SUCCESS_MESSAGE)
+
+            try:
+                files_for_upload = box_client.discover_files()
+                box_client.send_files(files_for_upload)
+
+                discord_client.post_message(discord_messages.BOX_SUCCESS_MESSAGE)
+
+                mongo_client.check_connection()
+                mongo_client.insert_documents(files_for_upload)
+                discord_client.post_message(discord_messages.MONGO_SUCCESS_MESSAGE)
+                mongo_client.close_connection()
+                discord_client.post_message(discord_messages.MONGO_CLOSE_MESSAGE)
+
+                discord_client.post_message("Documents inserted into MongoDB")
+            except Exception as e:
+                print.traceback(e)
+                discord_client.post_message(f"An error occurred: {e}")
+                return
+
+        discord_client.post_message(discord_messages.WIFI_ERROR_MESSAGE)
+
+        return None
+
+
+if __name__ == "__main__":
+    handler = Handler()
+    handler.handler()