Upload 25 files

app/__init__.py

@@ -0,0 +1,24 @@
+from flask import Flask
+from flask_sqlalchemy import SQLAlchemy
+from flask_bcrypt import Bcrypt
+from flask_jwt_extended import JWTManager
+
+db = SQLAlchemy()
+bcrypt = Bcrypt()
+jwt = JWTManager()
+
+def create_app():
+    app = Flask(__name__)
+    app.config.from_object('app.config.Config')
+
+    db.init_app(app)
+    bcrypt.init_app(app)
+    jwt.init_app(app)
+
+    from app.routes import auth, chat, admin, profile
+    app.register_blueprint(auth.bp)
+    app.register_blueprint(chat.bp)
+    app.register_blueprint(admin.bp)
+    app.register_blueprint(profile.bp)
+
+    return app

app/config.py

@@ -0,0 +1,7 @@
+class Config:
+    SECRET_KEY = 'Hala_Madrid'
+    JWT_SECRET_KEY = 'Hala_Madrid'
+    SQLALCHEMY_DATABASE_URI = 'mysql+pymysql://root:@localhost/loimaroc'
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+    PERSIST_DIR = "chroma_storage"
+    EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"

app/decorators.py

@@ -0,0 +1,16 @@
+from functools import wraps
+from flask_jwt_extended import verify_jwt_in_request, get_jwt
+from flask import jsonify
+
+def roles_required(*roles):
+    def wrapper(fn):
+        @wraps(fn)
+        def decorator(*args, **kwargs):
+            verify_jwt_in_request()
+            claims = get_jwt()
+            user_roles = claims.get("roles", [])
+            if not any(role in roles for role in user_roles):
+                return jsonify(msg="Forbidden: insufficient permissions"), 403
+            return fn(*args, **kwargs)
+        return decorator
+    return wrapper

app/models.py

@@ -0,0 +1,30 @@
+from app import db
+from datetime import datetime
+
+user_roles = db.Table('user_role',
+    db.Column('user_id', db.Integer, db.ForeignKey('users.id')),
+    db.Column('role_id', db.Integer, db.ForeignKey('role.id'))
+)
+
+class User(db.Model):
+    __tablename__ = 'users'
+    id = db.Column(db.Integer, primary_key=True)
+    first_name = db.Column(db.String(150))
+    last_name = db.Column(db.String(150))
+    email = db.Column(db.String(255), unique=True, nullable=False)
+    password = db.Column(db.String(255), nullable=False)
+    roles = db.relationship('Role', secondary=user_roles, backref='users')
+
+class Role(db.Model):
+    id = db.Column(db.Integer, primary_key=True)
+    name = db.Column(db.String(50), unique=True, nullable=False)
+
+class Question(db.Model):
+    __tablename__ = 'questions'
+    id = db.Column(db.Integer, primary_key=True)
+    user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
+    content = db.Column(db.Text, nullable=False)
+    date = db.Column(db.DateTime, default=datetime.utcnow)
+    status = db.Column(db.String(20), default='pending')
+    updated_at = db.Column(db.DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    user = db.relationship('User', backref=db.backref('questions', lazy=True))

app/routes/admin.py

@@ -0,0 +1,14 @@
+from flask import Blueprint, jsonify
+from app.models import User
+from app.decorators import roles_required
+
+bp = Blueprint('admin', __name__, url_prefix='/admin')
+
+@bp.route('/users', methods=['GET'])
+@roles_required('admin')
+def all_users():
+    users = User.query.all()
+    return jsonify([
+        {"id": u.id, "email": u.email, "roles": [r.name for r in u.roles]}
+        for u in users
+    ])

app/routes/auth.py

@@ -0,0 +1,57 @@
+from flask import Blueprint, request, jsonify
+from app.models import db, User, Role
+from flask_bcrypt import generate_password_hash
+from app import db, bcrypt
+from flask_jwt_extended import create_access_token
+from datetime import timedelta
+bp = Blueprint('auth', __name__, url_prefix='/auth')
+
+@bp.route('/register', methods=['POST'])
+def register():
+    data = request.get_json()
+
+    email = data.get('email')
+    password = data.get('password')
+    first_name = data.get('first_name')
+    last_name = data.get('last_name')
+
+    if not email or not password:
+        return jsonify({"error": "Missing email or password"}), 400
+
+    if User.query.filter_by(email=email).first():
+        return jsonify({"error": "User already exists"}), 409
+
+    hashed_password = generate_password_hash(password).decode('utf-8')
+    user = User(email=email, password=hashed_password, first_name=first_name, last_name=last_name)
+
+    # ROLE LOGIC
+    if email == '[email protected]':
+        role = Role.query.filter_by(name='admin').first()
+    elif email == '[email protected]':
+        role = Role.query.filter_by(name='expert').first()
+    else:
+        role = Role.query.filter_by(name='client').first()
+
+    if not role:
+        return jsonify({"error": f"Role not found in DB"}), 500
+
+    user.roles.append(role)
+    db.session.add(user)
+    db.session.commit()
+
+    return jsonify({"message": "User registered successfully"}), 201
+@bp.route('/login', methods=['POST'])
+def login():
+    data = request.get_json()
+    email = data.get('email')
+    password = data.get('password')
+
+    if not email or not password:
+        return jsonify({"error": "Email and password are required"}), 400
+
+    user = User.query.filter_by(email=email).first()
+    if not user or not bcrypt.check_password_hash(user.password, password):
+        return jsonify({"error": "Invalid credentials"}), 401
+
+    access_token = create_access_token(identity=str(user.id), expires_delta=timedelta(days=1))
+    return jsonify({"access_token": access_token}), 200

app/routes/chat.py

@@ -0,0 +1,48 @@
+from flask import Blueprint, request, jsonify
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from app.services.chatbot import ask
+from app.models import Question, db
+from datetime import datetime
+
+bp = Blueprint('chat', __name__, url_prefix='/chat')
+
+@bp.route('/ask', methods=['POST'])
+@jwt_required()
+def ask_question():
+    user_id = str(get_jwt_identity())
+    data = request.get_json()
+    question_text = data.get('question')
+
+    if not question_text:
+        return jsonify({'error': 'Missing question'}), 400
+
+    question = Question(
+        user_id=user_id,
+        content=question_text,
+        status='pending'
+    )
+    db.session.add(question)
+    db.session.commit()
+
+    try:
+        k = int(data.get("k", 6))  # if k is missing, fallback to 6
+        results = ask(question_text, k=k)
+        question.status = 'answered'
+    except Exception as e:
+        results = []
+        question.status = 'error'
+
+    question.updated_at = datetime.utcnow()
+    db.session.commit()
+
+    return jsonify({
+        "question": {
+            "id": question.id,
+            "user_id": question.user_id,
+            "content": question.content,
+            "date": question.date.isoformat(),
+            "status": question.status,
+            "updated_at": question.updated_at.isoformat()
+        },
+        "results": results
+    }), 200

app/routes/profile.py

@@ -0,0 +1,15 @@
+from flask import Blueprint, jsonify
+from flask_jwt_extended import jwt_required, get_jwt_identity
+from app.models import User
+
+bp = Blueprint('profile', __name__, url_prefix='/profile')
+
+@bp.route('/', methods=['GET'])
+@jwt_required()
+def profile():
+    user = User.query.get(get_jwt_identity())
+    return jsonify(
+        email=user.email,
+        name=f"{user.first_name} {user.last_name}",
+        roles=[r.name for r in user.roles]
+    )

app/scripts/load_documents.py

@@ -0,0 +1,70 @@
+import os
+import pandas as pd
+from langchain.docstore.document import Document
+from langchain_community.vectorstores import Chroma
+from langchain_community.embeddings import HuggingFaceEmbeddings
+
+# Configurations
+DATA_DIR = "data"
+PERSIST_DIR = "chroma_storage"
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+
+def parse_pages(pages_str):
+    if pd.isna(pages_str):
+        return []
+    try:
+        pages = eval(str(pages_str))
+        return pages if isinstance(pages, list) else [pages]
+    except:
+        try:
+            return [int(p.strip()) for p in str(pages_str).split(",") if p.strip().isdigit()]
+        except:
+            return []
+
+def load_csv(filepath: str) -> list:
+    df = pd.read_csv(filepath)
+    df.columns = [c.strip().lower() for c in df.columns]
+
+    documents = []
+    for _, row in df.iterrows():
+        text = row.get('contenu', '')
+        if pd.isna(text) or not str(text).strip():
+            continue
+
+        meta = {
+            'doc': (
+                row.get('doc').strip()
+                if pd.notna(row.get('doc')) and str(row.get('doc')).strip()
+                else os.path.splitext(os.path.basename(filepath))[0]
+            ),
+            'titre': row.get('titre', ''),
+            'chapitre': row.get('chapitre', ''),
+            'article': row.get('article', ''),
+            'sous_titre1': row.get('sous_titre1', ''),
+            'sous_titre2': row.get('sous_titre2', ''),
+            'sous_titre3': row.get('sous_titre3', ''),
+            'pages': ", ".join(map(str, parse_pages(row.get('pages', ''))))  # <- stringify to avoid Chroma error
+        }
+
+        documents.append(Document(page_content=str(text).strip(), metadata=meta))
+
+    print(f"📄 Loaded: {os.path.basename(filepath)} → {len(documents)} documents")
+    return documents
+
+def process_files():
+    all_docs = []
+    for file in os.listdir(DATA_DIR):
+        if file.endswith(".csv"):
+            full_path = os.path.join(DATA_DIR, file)
+            all_docs.extend(load_csv(full_path))
+
+    print(f"📊 Total: {len(all_docs)} full documents")
+
+    embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL)
+    db = Chroma.from_documents(all_docs, embedding=embeddings, persist_directory=PERSIST_DIR)
+    db.persist()
+
+    print(f"✅ Done! Stored in {PERSIST_DIR}")
+
+if __name__ == "__main__":
+    process_files()

app/services/auth_utils.py

@@ -0,0 +1,7 @@
+from app import bcrypt
+
+def hash_password(password):
+    return bcrypt.generate_password_hash(password).decode('utf-8')
+
+def check_password(hashed, password):
+    return bcrypt.check_password_hash(hashed, password)

app/services/chatbot.py

@@ -0,0 +1,25 @@
+# app/services/chatbot.py
+from langchain_chroma import Chroma
+from langchain_huggingface import HuggingFaceEmbeddings
+from app.config import Config
+
+PERSIST_DIR = Config.PERSIST_DIR
+EMBEDDING_MODEL = Config.EMBEDDING_MODEL
+
+embeddings = HuggingFaceEmbeddings(model_name=EMBEDDING_MODEL)
+db = Chroma(persist_directory=PERSIST_DIR, embedding_function=embeddings)
+
+def ask(query, k=6):
+    results = db.similarity_search_with_score(query, k=k)
+    response = []
+    for doc, score in results:
+        meta = doc.metadata
+        response.append({
+            "titre": meta.get("titre", ""),
+            "chapitre": meta.get("chapitre", ""),
+            "article": meta.get("article", ""),
+            "contenu": doc.page_content,
+            "doc": meta.get("doc", ""),
+            "pages": meta.get("pages", []) if isinstance(meta.get("pages"), list) else [meta.get("pages")] if meta.get("pages") else []
+        })
+    return response