sync worked

backend/src/api/routes/migration.py

@@ -48,7 +48,7 @@ async def get_dashboards(
 # @POST:    Starts the migration task and returns the task ID.
 # @PARAM:   selection (DashboardSelection) - The dashboards to migrate.
 # @RETURN:  Dict - {"task_id": str, "message": str}
-@router.post("/execute")
+@router.post("/migration/execute")
 async def execute_migration(
     selection: DashboardSelection,
     config_manager=Depends(get_config_manager),
@@ -85,22 +85,20 @@ async def execute_migration(
 
 # [DEF:get_migration_settings:Function]
 # @PURPOSE: Get current migration Cron string explicitly.
-@router.get("/settings", response_model=Dict[str, str])
+@router.get("/migration/settings", response_model=Dict[str, str])
 async def get_migration_settings(
     config_manager=Depends(get_config_manager),
     _ = Depends(has_permission("plugin:migration", "READ"))
 ):
     with belief_scope("get_migration_settings"):
-        # For simplicity in MVP, assuming cron expression is stored in config
-        # default to a valid cron if not set.
         config = config_manager.get_config()
-        cron = config.get("migration_sync_cron", "0 2 * * *")
+        cron = config.settings.migration_sync_cron
         return {"cron": cron}
 # [/DEF:get_migration_settings:Function]
 
 # [DEF:update_migration_settings:Function]
 # @PURPOSE: Update migration Cron string.
-@router.put("/settings", response_model=Dict[str, str])
+@router.put("/migration/settings", response_model=Dict[str, str])
 async def update_migration_settings(
     payload: Dict[str, str],
     config_manager=Depends(get_config_manager),
@@ -111,20 +109,17 @@ async def update_migration_settings(
             raise HTTPException(status_code=400, detail="Missing 'cron' field in payload")
         
         cron_expr = payload["cron"]
-        # Basic validation could go here
         
-        # In a real system, you'd save this to config and restart the scheduler.
-        # Here we just blindly patch the in-memory or file config for the MVP.
-        current_cfg = config_manager.get_config()
-        current_cfg["migration_sync_cron"] = cron_expr
-        config_manager.save_config(current_cfg)
+        config = config_manager.get_config()
+        config.settings.migration_sync_cron = cron_expr
+        config_manager.save_config(config)
         
         return {"cron": cron_expr, "status": "updated"}
 # [/DEF:update_migration_settings:Function]
 
 # [DEF:get_resource_mappings:Function]
 # @PURPOSE: Fetch all synchronized object mappings from the database.
-@router.get("/mappings-data", response_model=List[Dict[str, Any]])
+@router.get("/migration/mappings-data", response_model=List[Dict[str, Any]])
 async def get_resource_mappings(
     skip: int = Query(0, ge=0),
     limit: int = Query(100, ge=1, le=1000),
@@ -147,4 +142,62 @@ async def get_resource_mappings(
         return result
 # [/DEF:get_resource_mappings:Function]
 
+# [DEF:trigger_sync_now:Function]
+# @PURPOSE: Triggers an immediate ID synchronization for all environments.
+# @PRE:     At least one environment must be configured.
+# @POST:    Environment rows are ensured in DB; sync_environment is called for each.
+@router.post("/migration/sync-now", response_model=Dict[str, Any])
+async def trigger_sync_now(
+    config_manager=Depends(get_config_manager),
+    db: Session = Depends(get_db),
+    _ = Depends(has_permission("plugin:migration", "EXECUTE"))
+):
+    with belief_scope("trigger_sync_now"):
+        from ...core.logger import logger
+        from ...models.mapping import Environment as EnvironmentModel
+        
+        config = config_manager.get_config()
+        environments = config.environments
+        
+        if not environments:
+            raise HTTPException(status_code=400, detail="No environments configured")
+        
+        # Ensure each environment exists in DB (upsert) to satisfy FK constraints
+        for env in environments:
+            existing = db.query(EnvironmentModel).filter_by(id=env.id).first()
+            if not existing:
+                db_env = EnvironmentModel(
+                    id=env.id,
+                    name=env.name,
+                    url=env.url,
+                    credentials_id=env.id,  # Use env.id as credentials reference
+                )
+                db.add(db_env)
+                logger.info(f"[trigger_sync_now][Action] Created environment row for {env.id}")
+            else:
+                existing.name = env.name
+                existing.url = env.url
+        db.commit()
+        
+        service = IdMappingService(db)
+        results = {"synced": [], "failed": []}
+        
+        for env in environments:
+            try:
+                client = SupersetClient(env)
+                service.sync_environment(env.id, client)
+                results["synced"].append(env.id)
+                logger.info(f"[trigger_sync_now][Action] Synced environment {env.id}")
+            except Exception as e:
+                results["failed"].append({"env_id": env.id, "error": str(e)})
+                logger.error(f"[trigger_sync_now][Error] Failed to sync {env.id}: {e}")
+        
+        return {
+            "status": "completed",
+            "synced_count": len(results["synced"]),
+            "failed_count": len(results["failed"]),
+            "details": results
+        }
+# [/DEF:trigger_sync_now:Function]
+
 # [/DEF:backend.src.api.routes.migration:Module]