Initial commit

APIManager.py

@@ -0,0 +1,57 @@
+import requests  # to get/download the data from the api
+import json  # parse the api data
+
+"""
+Class APIManager
+
+Gestisce la comunicazione HTTP con le API che forniscono i dati per le newsletter
+"""
+
+class APIManager:
+
+    """
+
+        Metodo: getNews
+
+        Invia una richiesta GET tramite la libreria requests alle API trovate online
+
+        - Costruisce il dizionario con i parametri della richiesta (header + querystring)
+        - Invia la richiesta con metodo GET all'url delle API (trovato online su rapidapi.com)
+        - decodifica la risposta json in un Dizionario e restituisce i campi d'interesse (titolo, corpo, url) della news
+
+    """
+
+
+    def getNews(self, category):
+
+        url = "https://contextualwebsearch-websearch-v1.p.rapidapi.com/api/search/NewsSearchAPI"  # url of the api
+
+        # I parametri che andiamo a fornire alle API per la nostra richiesta.
+        # Questi sono da trovare nella documentazione delle API
+
+        querystring = {
+            "q": f"{category}",  # query to follow, topic to get the  about
+            "pageNumber": "1",  # no of pages cna be change
+            "pageSize": "1",  # size of the page should limit to paragraphs
+            "autoCorrect": "true",  # spelling checker
+            "fromPublishedDate": "null",  # date init
+            "toPublishedDate": "null"  # date end
+        }
+
+        headers = {
+            'x-rapidapi-key': "20c7edee10msh9b13ee9a5b2a529p1d3da9jsnbed33a1d0b94",  # sending header
+            'x-rapidapi-host': "contextualwebsearch-websearch-v1.p.rapidapi.com"  # hosting sender
+        }
+
+        # creating requests
+        response = requests.request("GET", url, headers=headers, params=querystring)
+
+        responseText = response.text  # leggiamo la risposta in JSON che ci ha dato il server (si trova nel campo text)
+        data = json.loads(responseText)  # fornattiamo il JSON in un dizionario Python
+
+        # Estrai i dati dal dizionario data e ritorna i singoli campi
+        title = data['value'][0]['title']
+        body = data['value'][0]['body']
+        url = data['value'][0]['url']
+
+        return title, body, url

Database.py

@@ -0,0 +1,289 @@
+import pandas as pd
+import os
+
+class DatabaseManager:
+
+    """
+        Metodo: checkDatabaseExists
+
+        Controlla se nella cartella dello script esistono i file csv che contengono i dati del software relativi agli utenti e le iscrizioni.
+        Se questi non esistono:
+        - Crea una cartella ./data
+        - Crea due Dataframe da Pandas che conterranno i dati relativi a utenti e iscrizioni.
+        - Salva i dataframe in due file .csv distinti all'interno della cartella ./data
+    """
+
+
+    def checkDatabaseExists(self):
+        # check if data folder exists in root folder, either creates it
+        if not os.path.exists("./data"):
+            print("Creating data folder...")
+            os.mkdir("data")
+
+        # database files
+        files = ["users.csv", 'subscriptions.csv'] #Dichiara una lista di stringhe con i nomi dei fila che vuole utilizzare
+        for file in files:
+            # check if files exists, else create them
+            if not os.path.exists(f"./data/{file}"):
+                print(f"{file} Not Exists")
+                print(f"Creating {file}...")
+
+                if 'users' in file:
+                    #Crea il database con pandas e lo salva nel file users.csv
+                    # init the dataframe
+                    df = pd.DataFrame({
+                        "name": [],
+                        "username": [],
+                        "password": [],
+                    })
+
+                    # save the dataframe to users
+                    df.to_csv("./data/users.csv", index=False)
+
+                elif 'subscriptions' in file:
+                    # init the dataframe
+                    df = pd.DataFrame({
+                        "username": [],
+                        "email": [],
+                        "business": [],
+                        "finance": [],
+                        "computer": [],
+                        "games": [],
+                        "entertainment": [],
+                        "music": [],
+                        "currentAffairs": [],
+                        "health": [],
+                        "lifestyle": [],
+                        "sports": [],
+                        "culture": [],
+                        "religion": [],
+                    })
+                    # save the dataframe
+                    df.to_csv("./data/subscriptions.csv", index=False)
+
+
+    '''
+    Metodo: getUsersDF
+
+    - Chiama il metodo checkDatabaseExists
+    - Legge e restituisce il dataframe con i dati relativi agli utenti
+    
+    '''
+    def getUsersDF(self):
+        self.checkDatabaseExists()
+        df = pd.read_csv("./data/users.csv")
+        return df
+
+
+
+    '''
+       Metodo: getSubscriptionsDF
+
+       - Chiama il metodo checkDatabaseExists
+       - Legge e restituisce il dataframe con i dati relativi alle iscrizioni
+
+    '''
+    def getSubscriptionsDF(self):
+        self.checkDatabaseExists()
+        df = pd.read_csv("./data/subscriptions.csv")
+        return df
+
+
+    '''
+       Metodo: pintSubscriptions
+        
+       Stampa la tabella delle iscrizioni 
+        
+       - Chiama il metodo getSubscriptionsDF
+       - Stampa il risultato
+
+    '''
+
+    def printSubscriptions(self):
+        print(self.getSubscriptionsDF())
+
+    '''
+           Metodo: removeUser
+           Param: username
+           
+           - Controlla se username è contenuto nella tabella users.csv 
+           - Elimina il record relativo a username in entrambe le tabelle
+           - Salva le modifiche effettuate
+
+    '''
+
+
+    def removeUser(self, uname):
+        dfSub = self.getSubscriptionsDF()
+        dfUsers = self.getUsersDF()
+        # if user found
+        if dfSub['username'].str.contains(uname).any():  # if username exists in any record
+            print("Username found in database")
+
+            # drop the row from users.csv and subscriptions.csv
+
+            # Rimuove la riga dalla tabella dfSub che contiene 'uname' nel campo username. Con inplace = True modifico la tabella senza creare una copia
+            dfSub.drop(dfSub[dfSub['username'] == uname].index, inplace=True)
+            # Rimuove la riga dalla tabella dfUsers che contiene 'uname' nel campo username. Con inplace = True modifico la tabella senza creare una copia
+            dfUsers.drop(dfUsers[dfUsers['username'] == uname].index, inplace=True)
+
+            # save the new csv
+            dfSub.to_csv("./data/subscriptions.csv", index=False)
+            dfUsers.to_csv("./data/users.csv", index=False)
+
+            print(f"'{uname}' removed sucessfully")
+        else:  # if user not found
+            print("username not found")
+
+    '''
+          Metodo: getSubscriptionsFor
+          Param: username
+
+          - Ritorna il record del Dataframe che contiene il nome utente indicato e quindi tutte le sue iscrizioni
+
+    '''
+
+    def getSubscriptionsFor(self,uname):
+        df = self.getSubscriptionsDF()
+        data = df[df['username'] == uname]
+        return  data #Ritorna il record del Dataframe che contiene il nome utente indicato e quindi tutte le sue iscrizioni
+
+
+    '''
+          Metodo: getSubscriptionsCategories
+          
+
+          - Restituisce le colonne della tabella delle iscrizioni a partire dalla terza
+
+    '''
+
+    def getSubscriptionsCategories(self):
+        return self.getSubscriptionsDF().columns[2:]
+
+    '''
+         Metodo: subscribeUserToCategory
+         
+         - Inserisce il carattere 'y' nella colonna indicata dal parametro category
+         - Salva il dataframe nell'apposito file.
+         
+    
+    '''
+
+    def subscribeUserToCategory(self,uname,category):
+        df = self.getSubscriptionsDF() #ottiene il Df delle iscrizioni
+         #Recupera il recordo con i dati dell'utente
+        df.loc[df.username == uname, category] = 'y'# inserisce 'y' alla colonna della categoria indicata nel record dell'utente indicato
+        print(df)
+        self.__saveSubscriptionsDF(df)  # Chiama la funzione per salvare il file (to_csv)
+        print(f"{uname} successfully subscribed  to {category}")
+
+    '''
+            Metodo: unsubscribeUserToCategory
+
+            - Inserisce il carattere 'n' nella colonna indicata dal parametro category
+            - Salva il dataframe nell'apposito file.
+
+
+     '''
+
+    def unsubscribeUserToCategory(self, uname, category):
+        df = self.getSubscriptionsDF()
+        df.loc[df.username == uname, category] = 'n' # inserisce 'n' alla colonna della categoria indicata nel record dell'utente indicato
+        self.__saveSubscriptionsDF(df)
+        print("Unsubscribed successfully")
+
+    def __saveSubscriptionsDF(self,df):
+        df.to_csv("./data/subscriptions.csv", index=False)
+
+    def __saveUsersDF(self,df):
+        df.to_csv("./data/users.csv", index=False)
+
+    '''
+          Metodo: subscribeToAll
+
+          - Inserisce il carattere 'n' in tutte le colonne della riga che si riferisce all'utente indicato
+          - Salva il dataframe nell'apposito file.
+
+
+    '''
+
+    def unsubscribeToAll(self, uname):
+        df = self.getSubscriptionsDF() #Ottiene il dataframe delle iscrizioni
+        row = df.loc[df.username == uname] #Prende il riferimento alla riga contenente i dati dell'utente
+
+        for category in self.getSubscriptionsCategories(): #Per ogni colonna della tabella
+            row[category] = 'n'  #Inserisce il carattere 'n' nelle colonna di quella specifica riga
+
+        self.__saveSubscriptionsDF(df) #Salva
+
+
+    '''
+          Metodo: userExists
+          Param: uname
+            
+          - Controlla se il nome utente inserito è contenuto in almeno un record della tabella 
+
+    '''
+
+    def userExists(self,uname):
+        df = self.getUsersDF()
+        return df['username'].str.contains(uname).any() #any() serve a capire se esiste almeno un elemento qualsiasi dove la condizione di contains() è verificata
+
+    '''
+            Metodo: uregUser
+            Param: uname , name, email, password
+
+            - Controlla se il nome utente inserito è contenuto in almeno un record della tabella 
+            - Crea I dizionari relativi alla tabella utente e a quella iscrizioni 
+            - Imposta i valori iniziali
+            - Inserisce in append i due record con i dati dell'utente e le sue iscrizioni 
+            - Salva i due file csv
+
+    '''
+
+    def regUser(self, uname,name, email,password):
+
+        if not self.userExists(uname):
+
+            #Crea il dizionario che rappresenta il record con i dati dell'utente (andrà nella tabella DFUsers)
+            udata = {
+                "username": uname,
+                "name": name,
+                "password": password,
+            }
+
+           #Crea il dizionario che rappresenta il record con i dati delle iscrizioni (andrà nella tabella DFSubscriptions)
+            sdata = {
+                "username": uname,
+                "email": email,
+                "business": 'n',
+                "finance": 'n',
+                "computer": 'n',
+                "games": 'n',
+                "entertainment": 'n',
+                "music": 'n',
+                "currentAffairs": 'n',
+                "health": 'n',
+                "lifestyle": 'n',
+                "sports": 'n',
+                "culture": 'n',
+                "religion": 'n',
+            }
+
+            dfUsers = self.getUsersDF() # Prende un riferimento alla tabella DFUsers
+            dfSub = self.getSubscriptionsDF()  # Prende un riferimento alla tabella DFSubscriptions
+
+            #Inserisce con il metodo append (all'ultimo elemento) il record con i dati dell'utente nella tabella DFUsers
+            dfUsers = dfUsers.append(udata, ignore_index=True)
+            self.__saveUsersDF(dfUsers) #salva
+
+            #Inserisce con il metodo append (all'ultimo elemento) il record con i dati delle iscrizioni  nella tabella DFSub
+            dfSub = dfSub.append(sdata, ignore_index=True)
+            self.__saveSubscriptionsDF(dfSub) #salva
+
+            # output if everything completes
+            print("You are successfully registed but not Subscribed to any list. Please login to your account to select any subscription.")
+        else:
+            print("Username already exists")
+
+