Synchronisation Frontend DracolIA QA

Controllers/Controller_Database.py

@@ -0,0 +1,102 @@
+from flask import Blueprint, request, jsonify
+from Services.Service_User import Service_User
+from Services.Service_Chat import Service_Chat
+from Services.Service_Chat_Message import Service_Chat_Message
+from Exceptions.UserExistsException import UserExistsException
+from Exceptions.UserOrPasswordIncorrectException import UserOrPasswordIncorrectException
+
+signup_blueprint = Blueprint('signup', __name__)
+login_blueprint = Blueprint('login', __name__)
+user_chat_history_blueprint = Blueprint('user chat history', __name__)
+delete_chat_blueprint = Blueprint('delete chat', __name__)
+chat_message_blueprint = Blueprint('chat message', __name__)
+get_chat_blueprint = Blueprint('get chat', __name__)
+
+@signup_blueprint.route('/signup', methods=['POST'])
+def signup_user():
+    service_user = Service_User()
+
+    try:
+        username = request.json['username']
+        password = request.json['password']
+
+        message = service_user.signup_user(username, password)
+        return jsonify({'message': message}), 200
+
+    except UserExistsException as e:
+        return jsonify({'message': str(e)}), 409
+
+
+@login_blueprint.route('/login', methods=['POST'])
+def login_user():
+    service_user = Service_User()
+    
+    username = request.json['username']
+    password = request.json['password']
+    
+    try:
+        user_information = service_user.login_user(username, password)
+
+        if user_information['password_match']:
+            user_information['message'] = 'Connected successfully.'
+            user_information['state'] = True
+            return jsonify(user_information)
+        
+    except UserOrPasswordIncorrectException as e:
+        return jsonify({'message': str(e), 'state': False})
+    
+    
+@user_chat_history_blueprint.route('/chatHistory', methods=['GET'])
+def user_chat_history():
+    serviceChat = Service_Chat()
+    
+    user_id = request.json['user_id']
+    user_is_connected = request.json['user_is_connected']
+
+    try:
+        chat_history = serviceChat.get_all_user_chats(user_id, user_is_connected)
+        return jsonify(chat_history), 200
+    except Exception as e:
+        return jsonify({'message': "Error fetching chat history."}), 500
+    
+@delete_chat_blueprint.route('/deleteChat', methods=['POST'])
+def user_chat_history():
+    serviceChat = Service_Chat()
+    
+    user_id = request.json['user_id']
+    user_is_connected = request.json['user_is_connected']
+    chat_id = request.json['chat_id']
+
+    try:
+        serviceChat.delete_chat(chat_id, user_is_connected, user_id)
+        return jsonify({'message': "As success"}), 200
+    except Exception as e:
+        return jsonify({'message': "Error fetching chat history."}), 500
+
+@chat_message_blueprint.route('/chatMessage', methods=['GET'])
+def chat_message():
+    serviceChatMessage = Service_Chat_Message()
+    
+    user_id = request.json['user_id']
+    user_is_connected = request.json['user_is_connected']
+    chat_id = request.json['chat_id']
+    try:
+        chat = serviceChatMessage.get_chat_messages_by_chat_id_and_user_id(chat_id, user_is_connected, user_id)
+        return jsonify(chat), 200
+    except Exception as e:
+        return jsonify({'message': "Error fetching chat history."}), 500
+    
+
+@get_chat_blueprint.route('/getChat', methods=['GET'])
+def get_chat():
+    serviceChat = Service_Chat()
+    
+    user_id = request.json['user_id']
+    is_connected = request.json['user_is_connected']
+    chat_id = request.json['chat_id']
+
+    try:
+        chat = serviceChat.get_chat(chat_id, user_id, is_connected)
+        return jsonify(chat), 200
+    except Exception as e:
+        return jsonify({'message': "Error fetching chat history."}), 500

Controllers/Controller_IA.py

@@ -0,0 +1,23 @@
+from flask import Blueprint, request, jsonify
+from Services.Service_IA import Service_IA
+
+prediction_blueprint = Blueprint('prediction', __name__)
+
+@prediction_blueprint.route('/predict', methods=['POST'])
+def predict():
+
+    question = request.json['user_question']
+    user_id = request.json['user_id']
+    chat_id = request.json['chat_id']
+    user_is_connected = request.json['user_is_connected']
+    file_content = request.json['file_content']
+    have_file = request.json['have_file']
+    model = request.json['model_selected']
+
+    try:
+        ia = Service_IA()
+        predictions = ia.generate_responses(question, user_id, chat_id, user_is_connected, file_content, have_file, model)
+    except Exception as e:
+        return jsonify({'message': str(e)}), 500
+    
+    return jsonify(predictions)

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.12
+
+WORKDIR /code
+
+RUN chmod 777 /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY . .
+
+RUN pip install --no-cache-dir --upgrade -r ./requirements.txt
+
+CMD ["gunicorn", "-b", "0.0.0.0:7860", "main:app"]

Exceptions/ModelNotSelectedException.py

@@ -0,0 +1,2 @@
+class ModelNotSelectedException(Exception):
+    pass

Exceptions/UserExistsException.py

@@ -0,0 +1,2 @@
+class UserExistsException(Exception):
+    pass

Exceptions/UserNotConnectedException.py

@@ -0,0 +1,2 @@
+class UserNotConnectedException(Exception):
+    pass

Exceptions/UserOrPasswordIncorrectException.py

@@ -0,0 +1,2 @@
+class UserOrPasswordIncorrectException(Exception):
+    pass

Model/Database.py

@@ -0,0 +1,232 @@
+import sqlite3
+
+class Database:
+
+    db_name = "./database.db"
+
+    def __init__(self):
+        self.conn = sqlite3.connect(self.db_name)
+        self.cursor = self.conn.cursor()
+       
+        self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS users (
+                user_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+                username TEXT NOT NULL,
+                password TEXT NOT NULL
+            )
+            '''
+        )
+
+        self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS chat (
+                chat_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+                user_id INTEGER NOT NULL,
+                chat_title TEXT NOT NULL,
+                chat_file_content TEXT,
+                chat_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
+                chat_model TEXT NOT NULL,
+                FOREIGN KEY (user_id) REFERENCES users(user_id)
+            )
+            '''
+        )
+
+        self.cursor.execute('''
+            CREATE TABLE IF NOT EXISTS chat_message(
+                chat_id INTEGER NOT NULL,
+                chat_message_id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
+                chat_message TEXT NOT NULL,
+                chat_message_is_ia BOOLEAN NOT NULL,
+                chat_message_date TIMESTAMP DEFAULT CURRENT_TIMESTAMP NOT NULL,
+                FOREIGN KEY (chat_id) REFERENCES chat(chat_id)
+            )
+            '''
+        )
+
+
+
+    """
+    
+        USER TABLE REQUESTS
+
+    """
+    ### SELECT REQUESTS
+    def select_user_by_name(self, username):
+        self.cursor.execute('SELECT user_id, username, password FROM users WHERE username = ?', (username,))
+        return self.cursor.fetchone()
+
+    def select_user_by_id(self, user_id):
+        self.cursor.execute('SELECT user_id, username, password FROM users WHERE user_id = ?', (user_id,))
+        return self.cursor.fetchone()
+
+    ### DELETE REQUESTS
+    def delete_user_by_name(self, username):
+        self.cursor.execute('DELETE FROM users WHERE username = ?', (username,))
+        self.conn.commit()
+
+    def delete_user_by_id(self, user_id):
+        self.cursor.execute('DELETE FROM users WHERE user_id = ?', (user_id,))
+        self.conn.commit()
+
+    ### UPDATE REQUESTS
+    def update_user_username_by_id(self, user_id, username):
+        self.cursor.execute('UPDATE users SET username = ? WHERE user_id = ?', (username, user_id))
+        self.conn.commit()
+
+    def update_user_password_by_id(self, user_id, password):
+        self.cursor.execute('UPDATE users SET password = ? WHERE user_id = ?', (password, user_id))
+        self.conn.commit()
+
+    def update_user_password_by_name(self, username, password):
+        self.cursor.execute('UPDATE users SET password = ? WHERE username = ?', (password, username))
+        self.conn.commit()
+
+    def update_user_username_by_id(self, user_id, username):
+        self.cursor.execute('UPDATE users SET username = ? WHERE user_id = ?', (username, user_id))
+        self.conn.commit()
+
+    ### INSERT REQUESTS
+    def insert_user(self, username, password):
+        self.cursor.execute("INSERT INTO users (username, password) VALUES (?, ?)", (username, password))
+        self.conn.commit()
+
+    ### CUSTOM REQUESTS
+    def user_exists(self, username):
+        self.cursor.execute('SELECT user_id FROM users WHERE username = ?', (username,))
+        exists = self.cursor.fetchone() is not None
+        return exists
+
+
+
+
+    """
+    
+        Chat TABLE REQUESTS
+
+    """
+    ### SELECT REQUESTS
+    def select_chat_by_id(self, chat_id):
+        self.cursor.execute('SELECT chat_id, user_id, chat_title, chat_file_content, chat_date, chat_model FROM chat WHERE chat_id = ?', (chat_id,))
+        return self.cursor.fetchone()
+    
+    def select_chat_by_user_id(self, user_id):
+        self.cursor.execute('SELECT chat_id, user_id, chat_title, chat_file_content, chat_date, chat_model FROM chat WHERE user_id = ?', (user_id,))
+        return self.cursor.fetchall()
+    
+    def select_chat_by_title(self, chat_title):
+        self.cursor.execute('SELECT chat_id, user_id, chat_title, chat_file_content, chat_date, chat_model FROM chat WHERE chat_title = ?', (chat_title,))
+        return self.cursor.fetchone()
+    
+    ### DELETE REQUESTS
+    def delete_chat_by_id(self, chat_id):
+        self.cursor.execute('DELETE FROM chat WHERE chat_id = ?', (chat_id,))
+        self.conn.commit()
+
+    def delete_chat_by_user_id(self, user_id):
+        self.cursor.execute('DELETE FROM chat WHERE user_id = ?', (user_id,))
+        self.conn.commit()
+
+    def delete_chat_by_title(self, chat_title):
+        self.cursor.execute('DELETE FROM chat WHERE chat_title = ?', (chat_title,))
+        self.conn.commit()
+
+    ### UPDATE REQUESTS
+    def update_chat_title_by_id(self, chat_id, chat_title):
+        self.cursor.execute('UPDATE chat SET chat_title = ? WHERE chat_id = ?', (chat_title, chat_id))
+        self.conn.commit()
+    
+    def update_chat_title_by_user_id(self, user_id, chat_title):
+        self.cursor.execute('UPDATE chat SET chat_title = ? WHERE user_id = ?', (chat_title, user_id))
+        self.conn.commit()
+
+    def update_chat_title_by_title(self, chat_title, new_chat_title):
+        self.cursor.execute('UPDATE chat SET chat_title = ? WHERE chat_title = ?', (new_chat_title, chat_title))
+        self.conn.commit()
+
+    ### INSERT REQUESTS
+    def insert_chat(self, user_id, chat_title, chat_file_content, chat_model):
+        self.cursor.execute("INSERT INTO chat (user_id, chat_title, chat_file_content, chat_date, chat_model) VALUES (?, ?, ?, datetime('now'), ?) RETURNING chat_id", (user_id, chat_title, chat_file_content, chat_model))
+        chat_id = self.cursor.fetchone()[0]
+        self.conn.commit()
+        return chat_id
+    
+    ### CUSTOM REQUESTS
+    def select_chat_by_id_and_user_id(self, chat_id, user_id):
+        self.cursor.execute('SELECT chat_id, user_id, chat_title, chat_file_content, chat_date, chat_model FROM chat WHERE chat_id = ? AND user_id = ?', (chat_id, user_id))
+        return self.cursor.fetchone()
+    
+    def select_all_user_chats(self, user_id):
+        self.cursor.execute('SELECT chat_id, chat_title, chat_file_content, chat_date, chat_model FROM chat WHERE user_id = ?', (user_id,))
+        return self.cursor.fetchall()
+
+    def delete_chat_by_id_and_by_user_id(self, chat_id, user_id):
+        self.cursor.execute('DELETE FROM chat WHERE chat_id = ? AND user_id = ?', (chat_id, user_id))
+        self.conn.commit()
+    
+    def update_chat_file_content_by_id(self, chat_id, chat_file_content):
+        self.cursor.execute('UPDATE chat SET chat_file_content = ? WHERE chat_id = ?', (chat_file_content, chat_id))
+        self.conn.commit()
+
+
+
+    """
+    
+        chat_message TABLE REQUESTS
+
+    """
+    ### SELECT REQUESTS
+    def select_chat_message_by_chat_id(self, chat_id):
+        self.cursor.execute('SELECT chat_id, chat_message_id, chat_message, chat_message_is_ia, chat_message_date FROM chat_message WHERE chat_id = ?', (chat_id,))
+        return self.cursor.fetchall()
+    
+    def select_chat_message_by_chat_message_id(self, chat_message_id):
+        self.cursor.execute('SELECT chat_id, chat_message_id, chat_message, chat_message_is_ia, chat_message_date FROM chat_message WHERE chat_message_id = ?', (chat_message_id,))
+        return self.cursor.fetchone()
+    
+    def select_chat_message_by_chat_message(self, chat_message):
+        self.cursor.execute('SELECT chat_id, chat_message_id, chat_message, chat_message_is_ia, chat_message_date FROM chat_message WHERE chat_message = ?', (chat_message,))
+        return self.cursor.fetchone()
+    
+    ### DELETE REQUESTS
+    def delete_chat_message_by_chat_id(self, chat_id):
+        self.cursor.execute('DELETE FROM chat_message WHERE chat_id = ?', (chat_id,))
+        self.conn.commit()
+    
+    def delete_chat_message_by_chat_message_id(self, chat_message_id):
+        self.cursor.execute('DELETE FROM chat_message WHERE chat_message_id = ?', (chat_message_id,))
+        self.conn.commit()
+
+    def delete_chat_message_by_chat_message(self, chat_message):
+        self.cursor.execute('DELETE FROM chat_message WHERE chat_message = ?', (chat_message,))
+        self.conn.commit()
+
+    ### UPDATE REQUESTS
+    def update_chat_message_by_chat_message_id(self, chat_message_id, chat_message):
+        self.cursor.execute('UPDATE chat_message SET chat_message = ? WHERE chat_message_id = ?', (chat_message, chat_message_id))
+        self.conn.commit()
+    
+    def update_chat_message_by_chat_message(self, chat_message, new_chat_message):
+        self.cursor.execute('UPDATE chat_message SET chat_message = ? WHERE chat_message = ?', (new_chat_message, chat_message))
+        self.conn.commit()
+    
+    ### INSERT REQUESTS
+    def insert_chat_message(self, chat_id, chat_message, chat_message_is_ia):
+        self.cursor.execute('INSERT INTO chat_message (chat_id, chat_message, chat_message_is_ia) VALUES (?, ?, ?)', (chat_id, chat_message, chat_message_is_ia))
+        self.conn.commit()
+    
+    def select_chat_message_by_chat_id_and_user_id(self, chat_id, user_id):
+        self.cursor.execute('SELECT chat_message_id, chat_message, chat_message_is_ia, chat_message_date FROM chat_message JOIN chat ON chat_message.chat_id = chat.chat_id WHERE chat_message.chat_id = ? AND chat.user_id = ?', (chat_id, user_id))
+        return self.cursor.fetchall()
+
+    
+
+    def begin_transaction(self):
+        self.conn.execute('BEGIN')
+
+    def commit_transaction(self):
+        self.conn.commit()
+
+    def rollback_transaction(self):
+        self.conn.rollback()
+
+    def close(self):
+        self.conn.close()

Model/IA.py

@@ -0,0 +1,63 @@
+import os
+
+os.environ['TRANSFORMERS_CACHE'] = '/code/.cache/'
+
+from transformers import pipeline
+import torch
+from googletrans import Translator
+
+
+class IA:
+    def __init__(self, cache_dir="/code/.cache/"):
+
+        self.model_bert = pipeline("question-answering", model="DracolIA/BERT-Context-based-QA", cache_dir=cache_dir)
+
+        self.model_bigbird = pipeline("question-answering", model="DracolIA/BigBird-Roberta-Context-based-QA", cache_dir=cache_dir)
+
+        self.model_splinter = pipeline("question-answering", model="DracolIA/Splinter-Context-based-QA", cache_dir=cache_dir)
+
+        self.model_squeeze = pipeline("question-answering", model="DracolIA/SqueezeBert-Context-based-QA", cache_dir=cache_dir)
+
+
+    def generate_responses(self, question, file_content, have_file, selected_model):
+        print("file_content: ", file_content)
+        translator = Translator()
+        language = translator.detect(str(question)).lang.upper() # Verify the language of the prompt
+
+        if have_file:
+            context = str(file_content)
+        else:
+            context = str()
+
+        if selected_model.upper() == "BERT":
+            print("Choosen model: BERT")
+            model = self.model_bert
+
+        if selected_model.upper() == "BIGBIRD":
+            print("Choosen model: BIGBIRD")
+            model = self.model_bigbird
+
+        if selected_model.upper() == "ALBERT":
+            print("Choosen model: ALBERT")
+            model = self.model_albert
+
+        if selected_model.upper() == "SPLINTER":
+            print("Choosen model: SPLINTER")
+            model = self.model_splinter
+
+        if selected_model.upper() == "SQUEEZE":
+            print("Choosen model: SQUEEZE")
+            model = self.model_squeeze
+
+
+        if language != "EN":
+                question = translator.translate(str(question), src=language, dest="en").text # Translation of user text to english for the model
+        
+        answer = model(context = context, question = question)
+        if answer != "" or len(answer) != 0:
+            answer = answer["answer"]
+            if language != "EN":
+                answer = Translator().translate(str(answer), src="en", dest=language).text # Translation of model's te*xt to user's language
+                
+        print("====================> answer: ", answer)
+        return str(answer)

README.md

@@ -0,0 +1,8 @@
+---
+title: SAE Question Answering IA Back
+emoji: 🐳
+colorFrom: purple
+colorTo: blue
+sdk: docker
+app_port: 7860
+---

Services/Service_Chat.py

@@ -0,0 +1,103 @@
+from Model.Database import Database
+from Exceptions.UserNotConnectedException import UserNotConnectedException
+from Services.Service_Chat_Message import Service_Chat_Message
+
+class Service_Chat:
+    def __init__(self):
+        pass
+
+    def get_chat(self, chat_id, user_id, is_connected):
+        db = Database()
+
+        if is_connected == False:
+            raise UserNotConnectedException("User not connected")
+        
+        try:
+            chat = db.select_chat_by_id_and_user_id(chat_id, user_id)
+            db.close()
+        except Exception as e:
+            db.close()
+            raise e
+        
+        print(chat)
+        return chat
+    
+    def create_chat(self, user_id, chat_title, chat_file_content, is_connected, model):
+        db = Database()
+
+        if is_connected == False:
+            raise UserNotConnectedException("User not connected")
+        
+        try:
+            db.begin_transaction()
+            chat_id = db.insert_chat(user_id, chat_title, chat_file_content, model)
+            db.commit_transaction() 
+        except Exception as e:
+            db.rollback_transaction() 
+        finally:
+            db.close()
+        
+        return chat_id
+    
+    def update_chat_file_content(self, user_id, chat_id, chat_file_content, is_connected):
+        db = Database()
+
+        if is_connected == False:
+            raise UserNotConnectedException("User not connected")
+        
+        try:
+            old_content = db.select_chat_by_id(chat_id)
+
+            if old_content[3] != chat_file_content:
+                chat_file_content = old_content[3] + " " + chat_file_content
+                db.update_chat_file_content_by_id(chat_id, chat_file_content)
+
+            db.close()
+        except Exception as e:
+            db.close()
+            raise e
+    
+    def delete_chat(self, chat_id, is_connected, user_id):
+        db = Database()
+        serviceChatMessage = Service_Chat_Message()
+
+        if is_connected == False:
+            raise UserNotConnectedException("User not connected")
+        
+        try:
+            serviceChatMessage.delete_chat_message(chat_id, is_connected)
+            db.delete_chat_by_id_and_by_user_id(chat_id, user_id)
+            db.close()
+        except Exception as e:
+            db.close()
+            raise e
+        
+    def get_all_user_chats(self, user_id, is_connected):
+        datas={}
+
+        db = Database()
+    
+        if is_connected == False:
+            raise UserNotConnectedException("User not connected")
+
+        try:
+            chats = db.select_all_user_chats(user_id)
+
+            for chat in chats:
+                data = {
+                    'chat_id': chat[0],
+                    'chat_title': chat[1],
+                    'chat_file_content': chat[2],
+                    'chat_date': chat[3],
+                    'chat_model': chat[4]
+                }
+
+                datas.update({chat[0]: data})
+
+            db.close()
+        except Exception as e:
+            db.close()
+            raise e
+        
+        return datas
+

Services/Service_Chat_Message.py

@@ -0,0 +1,87 @@
+from Model.Database import Database
+from Exceptions.UserNotConnectedException import UserNotConnectedException
+from datetime import datetime
+
+class Service_Chat_Message:
+    def __init__(self):
+        pass
+
+    def get_chat_messages(self, chat_id, user_is_connected):
+        db = Database()
+
+        if user_is_connected == False:
+            raise UserNotConnectedException("User not connected")    
+        
+        try:
+            messages = db.select_chat_message_by_chat_id(chat_id)
+            db.close()
+        except Exception as e:
+            db.close()
+            raise e
+        
+        return messages
+
+    def delete_chat_message(self, chat_id, user_is_connected):
+        db = Database()
+
+        if user_is_connected == False:
+            raise UserNotConnectedException("User not connected")  
+
+        try:
+            db.delete_chat_message_by_chat_id(chat_id)
+            db.close()  
+        except Exception as e:
+            db.close()
+            raise e
+
+    def add_user_chat_message(self, chat_id, chat_message, user_is_connected):
+        db = Database()
+
+        if user_is_connected == False:
+            raise UserNotConnectedException("User not connected")    
+        
+        try:
+            db.insert_chat_message(chat_id, chat_message, 0)
+            db.close()
+        except Exception as e:
+            db.close()
+            raise e
+
+    def add_ia_chat_message(self, chat_id, chat_message):
+        db = Database()
+
+        try:
+            db.insert_chat_message(chat_id, chat_message, 1)
+            db.close()
+        except Exception as e:
+            db.close()
+            raise e
+        
+    def get_chat_messages_by_chat_id_and_user_id(self, chat_id, user_is_connected, user_id):
+        data=[]
+
+        db = Database()
+
+        if user_is_connected == False:
+            raise UserNotConnectedException("User not connected")  
+          
+        try:
+            messages = db.select_chat_message_by_chat_id_and_user_id(chat_id, user_id)
+
+            for message in messages:
+                data.append({
+                    'chat_message_id': message[0],
+                    'chat_message': message[1],
+                    'chat_message_is_ia': message[2],
+                    'chat_message_date': message[3]
+                })
+
+            data = sorted(data, key=lambda x: datetime.strptime(x["chat_message_date"], "%Y-%m-%d %H:%M:%S"), reverse=False)
+
+            db.close()
+
+        except Exception as e:
+            db.close()
+            raise e
+
+        return data

Services/Service_IA.py

@@ -0,0 +1,50 @@
+from Model.IA import IA
+from Services.Service_Chat import Service_Chat
+from Services.Service_Chat_Message import Service_Chat_Message
+from Exceptions.UserNotConnectedException import UserNotConnectedException
+from Exceptions.ModelNotSelectedException import ModelNotSelectedException
+
+class Service_IA:
+    def __init__(self):
+        pass
+
+    def generate_responses(self, user_question, user_id, chat_id, user_is_connected, file_content, have_file, model):
+        try:
+            if user_is_connected == False:
+                raise UserNotConnectedException("User not connected")    
+
+            serviceChat = Service_Chat()
+            serviceChatMessage = Service_Chat_Message()
+            ia = IA()
+            
+            ia_response_json = {}
+            ia_response_json["chat_id"] = chat_id
+            ia_response_json["user_question"] = user_question
+
+            ia_response = ia.generate_responses(user_question, file_content, have_file, model)
+            ia_response_json["ia_response"] = ia_response
+
+            if chat_id == None:
+                chat_title = self.title_chat(user_question)
+                new_chat_id = serviceChat.create_chat(user_id, chat_title, file_content, user_is_connected, model)
+                ia_response_json["chat_id"] = new_chat_id
+                ia_response_json["chat_title"] = chat_title
+                chat_id = new_chat_id
+            else:
+                serviceChat.update_chat_file_content(user_id, chat_id, file_content, user_is_connected)
+                print("serviceChat.update_chat_file_content in Service_IA.py")
+
+            serviceChatMessage.add_user_chat_message(chat_id, user_question, user_is_connected)
+            serviceChatMessage.add_ia_chat_message(chat_id, str(ia_response))
+        except Exception as e:
+            raise e
+
+        return ia_response_json
+
+
+    def title_chat(self, chat_title):
+        chat_title = chat_title[:19]
+        chat_title += "..."
+        return chat_title
+    
+

Services/Service_User.py

@@ -0,0 +1,62 @@
+from Model.Database import Database
+from Exceptions.UserExistsException import UserExistsException
+from Exceptions.UserOrPasswordIncorrectException import UserOrPasswordIncorrectException
+import bcrypt
+
+class Service_User:
+
+    def __init__(self):
+        pass
+
+    ### Signup user
+    def signup_user(self, username, password):
+        db = Database()
+
+        if db.user_exists(username):
+            db.close()
+            raise UserExistsException("User already exists")
+
+        try:
+            hashed_password = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt())
+
+            db.insert_user(username, str(hashed_password))
+            db.close()
+        except Exception as e:
+            db.close()
+            raise e
+        
+        return "Account created successfully"
+
+    ### Login user
+    def login_user(self, username, password):
+        db = Database()
+        user_info = db.select_user_by_name(username)
+        
+        if user_info is None:
+            db.close()
+            raise UserOrPasswordIncorrectException("User or Password incorrect.")
+
+        try:
+            hashed_password_from_db = user_info[2]
+
+            if hashed_password_from_db.startswith("b'") and hashed_password_from_db.endswith("'"):
+                hashed_password_from_db = hashed_password_from_db[2:-1].encode('utf-8')
+            elif isinstance(hashed_password_from_db, str):
+                hashed_password_from_db = hashed_password_from_db.encode('utf-8')
+
+            password_match = bcrypt.checkpw(password.encode('utf-8'), hashed_password_from_db)
+
+            db.close()
+        except Exception as e:
+            db.close()
+            raise e
+        
+        if password_match == False:
+            raise UserOrPasswordIncorrectException("User or Password incorrect.")
+        
+        return {
+            'user_id': user_info[0],
+            'user_name': user_info[1],
+            'user_is_connected': True,
+            'password_match': password_match
+        }

main.py

@@ -0,0 +1,16 @@
+from flask import Flask
+from Controllers.Controller_IA import prediction_blueprint
+from Controllers.Controller_Database import signup_blueprint, login_blueprint, user_chat_history_blueprint, delete_chat_blueprint, chat_message_blueprint, get_chat_blueprint    
+from Model.IA import IA
+
+app = Flask(__name__)
+
+ia = IA()
+
+app.register_blueprint(prediction_blueprint)
+app.register_blueprint(signup_blueprint)
+app.register_blueprint(login_blueprint)
+app.register_blueprint(user_chat_history_blueprint)
+app.register_blueprint(delete_chat_blueprint)
+app.register_blueprint(chat_message_blueprint)
+app.register_blueprint(get_chat_blueprint)

requirements.txt

@@ -0,0 +1,6 @@
+flask
+bcrypt
+transformers
+torch
+gunicorn
+googletrans-py