fix: workspace settings usage for change reason validation

crates/context_aware_config/src/api/audit_log/handlers.rs

@@ -1,7 +1,7 @@
 use actix_web::{get, web::Json, Scope};
 use chrono::{Duration, Utc};
 use diesel::{BoolExpressionMethods, ExpressionMethods, QueryDsl, RunQueryDsl};
-use service_utils::service::types::{DbConnection, SchemaName};
+use service_utils::service::types::{DbConnection, WorkspaceContext};
 use superposition_derives::authorized;
 use superposition_types::{
     api::audit_log::AuditQueryFilters,
@@ -17,10 +17,10 @@ pub fn endpoints() -> Scope {
 #[authorized]
 #[get("")]
 async fn list_handler(
+    workspace_context: WorkspaceContext,
     filters: superposition_query::Query<AuditQueryFilters>,
     pagination_params: superposition_query::Query<PaginationParams>,
     db_conn: DbConnection,
-    schema_name: SchemaName,
 ) -> superposition::Result<Json<PaginatedResponse<EventLog>>> {
     let now = Utc::now();
     let from_date = filters.from_date.unwrap_or(now - Duration::days(7));
@@ -33,7 +33,9 @@ async fn list_handler(
     let DbConnection(mut conn) = db_conn;
 
     let query_builder = |filters: &AuditQueryFilters| {
-        let mut builder = event_log::event_log.schema_name(&schema_name).into_boxed();
+        let mut builder = event_log::event_log
+            .schema_name(&workspace_context.schema_name)
+            .into_boxed();
         if let Some(tables) = filters.table.clone() {
             builder = builder.filter(event_log::table_name.eq_any(tables.0));
         }

crates/context_aware_config/src/api/config/handlers.rs

@@ -16,7 +16,7 @@ use itertools::Itertools;
 use serde_json::{json, Map, Value};
 #[cfg(feature = "high-performance-mode")]
 use service_utils::service::types::{AppHeader, AppState};
-use service_utils::service::types::{DbConnection, SchemaName, WorkspaceContext};
+use service_utils::service::types::{DbConnection, WorkspaceContext};
 use superposition_derives::authorized;
 #[cfg(feature = "high-performance-mode")]
 use superposition_macros::response_error;
@@ -278,7 +278,7 @@ async fn reduce_config_key(
     dimension_schema_map: &HashMap<String, DimensionInfo>,
     default_config: Map<String, Value>,
     is_approve: bool,
-    schema_name: &SchemaName,
+    workspace_context: &WorkspaceContext,
 ) -> superposition::Result<Config> {
     let default_config_val =
         default_config
@@ -339,12 +339,22 @@ async fn reduce_config_key(
             ) => {
                 if *to_be_deleted {
                     if is_approve {
-                        let _ = context::delete(cid.clone(), user, conn, schema_name);
+                        let _ = context::delete(
+                            cid.clone(),
+                            user,
+                            conn,
+                            &workspace_context.schema_name,
+                        );
                     }
                     og_contexts.retain(|x| x.id != *cid);
                 } else {
                     if is_approve {
-                        let _ = context::delete(cid.clone(), user, conn, schema_name);
+                        let _ = context::delete(
+                            cid.clone(),
+                            user,
+                            conn,
+                            &workspace_context.schema_name,
+                        );
                         if let Ok(put_req) = construct_new_payload(request_payload) {
                             let description = match put_req.description.clone() {
                                 Some(val) => val,
@@ -353,16 +363,17 @@ async fn reduce_config_key(
                                         put_req.context.clone().into_inner().into(),
                                     ),
                                     conn,
-                                    schema_name,
+                                    &workspace_context.schema_name,
                                 )?,
                             };
+
                             let _ = context::upsert(
                                 put_req,
                                 description,
                                 conn,
                                 false,
                                 user,
-                                schema_name,
+                                workspace_context,
                                 false,
                             );
                         }
@@ -417,10 +428,10 @@ async fn reduce_config_key(
 #[authorized]
 #[put("/reduce")]
 async fn reduce_handler(
+    workspace_context: WorkspaceContext,
     req: HttpRequest,
     user: User,
     db_conn: DbConnection,
-    schema_name: SchemaName,
 ) -> superposition::Result<HttpResponse> {
     let DbConnection(mut conn) = db_conn;
     let is_approve = req
@@ -429,8 +440,9 @@ async fn reduce_handler(
         .and_then(|value| value.to_str().ok().and_then(|s| s.parse::<bool>().ok()))
         .unwrap_or(false);
 
-    let dimensions_info_map = fetch_dimensions_info_map(&mut conn, &schema_name)?;
-    let mut config = generate_cac(&mut conn, &schema_name)?;
+    let dimensions_info_map =
+        fetch_dimensions_info_map(&mut conn, &workspace_context.schema_name)?;
+    let mut config = generate_cac(&mut conn, &workspace_context.schema_name)?;
     let default_config = (config.default_configs).clone();
     for (key, _) in default_config {
         let contexts = config.contexts;
@@ -445,11 +457,11 @@ async fn reduce_handler(
             &dimensions_info_map,
             default_config.clone(),
             is_approve,
-            &schema_name,
+            &workspace_context,
         )
         .await?;
         if is_approve {
-            config = generate_cac(&mut conn, &schema_name)?;
+            config = generate_cac(&mut conn, &workspace_context.schema_name)?;
         }
     }
 
@@ -459,10 +471,7 @@ async fn reduce_handler(
 #[cfg(feature = "high-performance-mode")]
 #[authorized]
 #[get("/fast")]
-async fn get_fast_handler(
-    schema_name: SchemaName,
-    state: Data<AppState>,
-) -> superposition::Result<HttpResponse> {
+async fn get_fast_handler(state: Data<AppState>) -> superposition::Result<HttpResponse> {
     use fred::interfaces::MetricsInterface;
 
     log::debug!("Started redis fetch");
@@ -573,8 +582,7 @@ async fn get_handler(
     }
 
     let query_filters = query_filters.into_inner();
-    let mut version =
-        get_config_version(&query_filters.version, &workspace_context, &mut conn)?;
+    let mut version = get_config_version(&query_filters.version, &workspace_context)?;
 
     let mut config = generate_config_from_version(
         &mut version,
@@ -629,7 +637,7 @@ async fn resolve_handler(
     }
 
     let mut config_version =
-        get_config_version(&query_filters.version, &workspace_context, &mut conn)?;
+        get_config_version(&query_filters.version, &workspace_context)?;
     let mut config = generate_config_from_version(
         &mut config_version,
         &mut conn,
@@ -656,28 +664,28 @@ async fn resolve_handler(
 #[authorized]
 #[get("/versions")]
 async fn list_version_handler(
+    workspace_context: WorkspaceContext,
     db_conn: DbConnection,
     filters: Query<PaginationParams>,
-    schema_name: SchemaName,
 ) -> superposition::Result<Json<PaginatedResponse<ConfigVersionListItem>>> {
     let DbConnection(mut conn) = db_conn;
 
     if let Some(true) = filters.all {
         let config_versions = config_versions::config_versions
-            .schema_name(&schema_name)
+            .schema_name(&workspace_context.schema_name)
             .select(ConfigVersionListItem::as_select())
             .get_results(&mut conn)?;
         return Ok(Json(PaginatedResponse::all(config_versions)));
     }
 
     let n_version: i64 = config_versions::config_versions
         .count()
-        .schema_name(&schema_name)
+        .schema_name(&workspace_context.schema_name)
         .get_result(&mut conn)?;
 
     let limit = filters.count.unwrap_or(10);
     let mut builder = config_versions::config_versions
-        .schema_name(&schema_name)
+        .schema_name(&workspace_context.schema_name)
         .into_boxed()
         .order(config_versions::created_at.desc())
         .limit(limit);
@@ -699,14 +707,14 @@ async fn list_version_handler(
 #[authorized]
 #[get("/version/{version}")]
 async fn get_version_handler(
+    workspace_context: WorkspaceContext,
     db_conn: DbConnection,
     version: Path<i64>,
-    schema_name: SchemaName,
 ) -> superposition::Result<Json<ConfigVersion>> {
     let DbConnection(mut conn) = db_conn;
 
     let config_version = config_versions::config_versions
-        .schema_name(&schema_name)
+        .schema_name(&workspace_context.schema_name)
         .find(version.into_inner())
         .get_result::<ConfigVersion>(&mut conn)?;
 

crates/context_aware_config/src/api/config/helpers.rs

@@ -7,16 +7,15 @@ use actix_web::{
 };
 use cac_client::{eval_cac, eval_cac_with_reasoning};
 use chrono::{DateTime, Timelike, Utc};
-use diesel::{dsl::max, BoolExpressionMethods, ExpressionMethods, QueryDsl, RunQueryDsl};
+use diesel::{dsl::max, ExpressionMethods, QueryDsl, RunQueryDsl};
 use serde_json::{Map, Value};
 use service_utils::service::types::{AppHeader, SchemaName, WorkspaceContext};
 use superposition_macros::{bad_argument, db_error, unexpected_error};
 use superposition_types::{
     api::config::{ContextPayload, MergeStrategy, ResolveConfigQuery},
     custom_query::{DimensionQuery, QueryMap},
-    database::{
-        schema::{config_versions::dsl as config_versions, event_log::dsl as event_log},
-        superposition_schema::superposition::workspaces,
+    database::schema::{
+        config_versions::dsl as config_versions, event_log::dsl as event_log,
     },
     result as superposition, Config, DBConnection,
 };
@@ -35,39 +34,12 @@ pub fn apply_prefix_filter_to_config(
     Ok(config)
 }
 
-fn get_config_version_from_workspace(
-    workspace_context: &WorkspaceContext,
-    conn: &mut DBConnection,
-) -> Option<i64> {
-    match workspaces::dsl::workspaces
-        .select(workspaces::config_version)
-        .filter(
-            workspaces::organisation_id
-                .eq(&workspace_context.organisation_id.0)
-                .and(workspaces::workspace_name.eq(&workspace_context.workspace_id.0)),
-        )
-        .get_result::<Option<i64>>(conn)
-    {
-        Ok(version) => version,
-        Err(e) => {
-            log::error!(
-                "Failed to get config_version for org_id: {}, workspace_name: {} — {:?}",
-                workspace_context.organisation_id.0,
-                workspace_context.workspace_id.0,
-                e
-            );
-            None
-        }
-    }
-}
-
 pub fn get_config_version(
     version: &Option<String>,
     workspace_context: &WorkspaceContext,
-    conn: &mut DBConnection,
 ) -> superposition::Result<Option<i64>> {
     version.as_ref().map_or_else(
-        || Ok(get_config_version_from_workspace(workspace_context, conn)),
+        || Ok(workspace_context.settings.config_version),
         |version| {
             if *version == *"latest" {
                 log::trace!("latest config request");