Merge pull request industrial-optimization-group#545 from giomara-larraga/GDM-SCOREbands

GDM SCOREbands

Author: giomara-larraga

desdeo/api/config.toml

@@ -15,8 +15,8 @@ test_user_dm2_password = "dm2"
 [auth-debug]
 authjwt_secret_key = "36b96a23d24cebdeadce6d98fa53356111e6f3e85b8144d7273dcba230b9eb18"
 authjwt_algorithm = "HS256"
-authjwt_access_token_expires = 15 # in minutes
-authjwt_refresh_token_expires = 30 # in minutes
+authjwt_access_token_expires = 480 # in minutes (8 hours, extended for dev/testing)
+authjwt_refresh_token_expires = 480 # in minutes (8 hours, extended for dev/testing)
 cors_origins = [
     "http://localhost",
     "http://localhost:8000",

desdeo/api/db_init_gdm.py

@@ -0,0 +1,114 @@
+"""This module initializes the database."""
+
+import warnings
+
+import numpy as np
+from sqlalchemy_utils import database_exists
+from sqlmodel import Session, SQLModel
+
+from desdeo.api.config import SettingsConfig
+from desdeo.api.db import engine
+from desdeo.api.models import (
+    ProblemDB,
+    User,
+    UserRole,
+    
+)
+from desdeo.api.models.gdm.gdm_aggregate import Group
+from desdeo.api.routers.user_authentication import get_password_hash
+from desdeo.problem.testproblems import river_pollution_problem_discrete
+
+problems = [river_pollution_problem_discrete(five_objective_variant=False)]
+
+num_analysts = 1
+num_dms = 2
+
+usernames_analyst = [f"analyst{i + 1}" for i in range(num_analysts)]
+usernames_dm = [f"dm{i + 1}" for i in range(num_dms)]
+
+user_owner = User(
+    id="1",
+    username=usernames_analyst[0],
+    password_hash=get_password_hash("12345"),
+    role=UserRole.analyst,
+    group="test",
+)
+
+id_user = 1
+if __name__ == "__main__":
+    if SettingsConfig.debug:
+        # debug stuff
+
+        print("Creating database tables.")
+        if not database_exists(engine.url):
+            SQLModel.metadata.create_all(engine)
+        else:
+            warnings.warn("Database already exists. Clearing it.", stacklevel=1)
+            # Drop all tables
+            SQLModel.metadata.reflect(bind=engine)
+            SQLModel.metadata.drop_all(bind=engine)
+            SQLModel.metadata.create_all(engine)
+        print("Database tables created.")
+
+        with Session(engine) as session:
+            for user in usernames_analyst:
+                user_analyst = User(
+                    id=str(id_user),
+                    username=user,
+                    password_hash=get_password_hash(
+                        "12345"
+                    ),
+                    role=UserRole.analyst,
+                    group="test",
+                    group_ids=[1],
+                )
+                session.add(user_analyst)
+                session.commit()
+                session.refresh(user_analyst)
+                id_user += 1
+
+            for user in usernames_dm:
+                user_dm = User(
+                    id=str(id_user),
+                    username=user,
+                    password_hash=get_password_hash(
+                        "12345"
+                    ),
+                    role=UserRole.dm,
+                    group="test",
+                    group_ids=[1],
+                )
+                session.add(user_dm)
+                session.commit()
+                session.refresh(user_dm)
+                id_user += 1
+
+            rng = np.random.default_rng(seed=42)
+
+            for problem in problems:
+                #Add the problem to the analyst1
+                problem_db = ProblemDB.from_problem(problem, user_owner)
+                session.add(problem_db)
+                session.commit()
+                session.refresh(problem_db)
+
+            # Create a group for GDM testing
+            group_name = "tingalinga"
+            group = Group(
+                name=group_name,
+                owner_id=1,
+                user_ids=[2,3],
+                problem_id=1,
+            )
+
+            group.model_rebuild()
+            
+            
+            session.add(group)
+            session.commit()
+            session.refresh(group)
+            session.close()
+
+    else:
+        # deployment stuff
+        pass

desdeo/api/routers/gdm/gdm_aggregate.py

@@ -198,18 +198,17 @@ async def websocket_endpoint(
         await websocket.close()
         return
 
-    # We don't need the session here any more, so we can just close it.
-    # I believe this releases connections to the pool
-    session.close()
-
     # Get the group manager object from the manager of group managers
-    group_manager = await manager.get_group_manager(group_id=group_id, method=method)
+    group_manager = await manager.get_group_manager(group_id=group_id, method=method, db_session=session)
     if group_manager is None:
+        session.close()
         await websocket.send_text(f"Unknown method: {method}")
         await websocket.close()
         return
 
-    await group_manager.connect(user.id, websocket)
+    await group_manager.connect(user.id, websocket, db_session=session)
+    # Session is only needed for manager initialization/connection bookkeeping.
+    session.close()
     logger.info(f"Group ID {group_id} manager's active connections {group_manager.sockets}")
     logger.info(f"Existing GroupManagers: {manager.group_managers}")
     while True:

desdeo/api/routers/problem.py

@@ -15,6 +15,7 @@
     ProblemDB,
     ProblemInfo,
     ProblemInfoSmall,
+    Group,
     ProblemMetaDataDB,
     ProblemMetaDataGetRequest,
     ProblemSelectSolverRequest,
@@ -84,7 +85,21 @@ def get_problems(
     """
     if user.role in (UserRole.analyst, UserRole.admin):
         return list(db_session.exec(select(ProblemDB)).all())
-    return user.problems
+
+    problems_by_id: dict[int, ProblemDB] = {problem.id: problem for problem in user.problems}
+
+    groups = db_session.exec(select(Group)).all()
+    visible_group_problem_ids = {
+        group.problem_id
+        for group in groups
+        if user.id == group.owner_id or user.id in (group.user_ids or [])
+    }
+    if visible_group_problem_ids:
+        group_problems = db_session.exec(select(ProblemDB).where(ProblemDB.id.in_(visible_group_problem_ids))).all()
+        for problem in group_problems:
+            problems_by_id[problem.id] = problem
+
+    return list(problems_by_id.values())
 
 
 @router.get("/all_info")
@@ -103,7 +118,21 @@ def get_problems_info(
     """
     if user.role in (UserRole.analyst, UserRole.admin):
         return list(db_session.exec(select(ProblemDB)).all())
-    return user.problems
+
+    problems_by_id: dict[int, ProblemDB] = {problem.id: problem for problem in user.problems}
+
+    groups = db_session.exec(select(Group)).all()
+    visible_group_problem_ids = {
+        group.problem_id
+        for group in groups
+        if user.id == group.owner_id or user.id in (group.user_ids or [])
+    }
+    if visible_group_problem_ids:
+        group_problems = db_session.exec(select(ProblemDB).where(ProblemDB.id.in_(visible_group_problem_ids))).all()
+        for problem in group_problems:
+            problems_by_id[problem.id] = problem
+
+    return list(problems_by_id.values())
 
 
 @router.get("/{problem_id}")

desdeo/api/routers/utils.py

@@ -14,6 +14,7 @@
 from desdeo.api.db import get_session
 from desdeo.api.models import (
     ENautilusStepRequest,
+    Group,
     InteractiveSessionDB,
     NautilusNavigatorInitRequest,
     NautilusNavigatorNavigateRequest,
@@ -48,12 +49,26 @@ def fetch_problem_with_role_check(user: User, problem_id: int, session: Session)
     """
     if user.role in (UserRole.analyst, UserRole.admin):
         statement = select(ProblemDB).where(ProblemDB.id == problem_id)
-    else:
-        statement = select(ProblemDB).where(
-            ProblemDB.user_id == user.id,
-            ProblemDB.id == problem_id,
-        )
-    return session.exec(statement).first()
+        return session.exec(statement).first()
+
+    # Primary access path for non-analyst/admin users: own problems.
+    statement = select(ProblemDB).where(
+        ProblemDB.user_id == user.id,
+        ProblemDB.id == problem_id,
+    )
+    own_problem = session.exec(statement).first()
+    if own_problem is not None:
+        return own_problem
+
+    # Secondary access path: problems attached to groups where the user is owner/member.
+    group_statement = select(Group).where(Group.problem_id == problem_id)
+    groups = session.exec(group_statement).all()
+    for group in groups:
+        user_ids = group.user_ids or []
+        if user.id == group.owner_id or user.id in user_ids:
+            return session.exec(select(ProblemDB).where(ProblemDB.id == problem_id)).first()
+
+    return None
 
 
 def fetch_interactive_session_with_role_check(user: User, session_id: int, session: Session) -> InteractiveSessionDB:

webui/.gitignore

@@ -19,3 +19,6 @@ Thumbs.db
 # Vite
 vite.config.js.timestamp-*
 vite.config.ts.timestamp-*
+
+# Auth 
+.auth

webui/package.json

@@ -18,8 +18,9 @@
     "storybook": "storybook dev -p 6006",
     "build-storybook": "storybook build",
     "generate:client": "orval",
-    "svelte-check": "svelte-check"
-  },
+    "svelte-check": "svelte-check",
+    "dev:gdm-score": "playwright test --project=setup --project=gdm-score --headed",
+    "auth:setup": "npx ts-node tests/auth.setup.ts"  },
   "dependencies": {
     "@cortex-js/compute-engine": "^0.30.2",
     "@faker-js/faker": "^10.0.0",

webui/playwright.config.ts

@@ -5,5 +5,26 @@ export default defineConfig({
 		command: 'npm run build && npm run preview',
 		port: 4173
 	},
-	testDir: 'e2e'
+	testDir: '.',
+	testMatch: ['e2e/**/*.test.ts', 'tests/**/*.spec.ts'],
+	use: {
+		launchOptions: {
+			args: ['--start-maximized']
+		}
+	},
+	projects: [
+		{
+			name: 'setup',
+			testMatch: 'tests/auth.setup.ts'
+		},
+		{
+			name: 'gdm-score',
+			testMatch: 'tests/**/*.spec.ts',
+			dependencies: ['setup']
+		},
+		{
+			name: 'e2e',
+			testMatch: 'e2e/**/*.test.ts'
+		}
+	]
 });