Function patch_settings

src/dashboard/code_diagnostics_api.rs:52–91

(
    State(state): State<DashboardState>,
    Json(patch): Json<Value>,
)

}

pub(crate) async fn patch_settings(
    State(state): State<DashboardState>,
    Json(patch): Json<Value>,
) -> ApiResult {
    let patch = serde_json::from_value::<SettingsPatch>(patch)
        .map_err(|err| bad_request(&format!("invalid code diagnostics settings patch: {err}")))?;
    let mut settings = state.code_diagnostics.read().await.snapshot().settings;
    if let Some(mode) = patch.idle_backfill {
        settings.idle_backfill = mode;
    }
    for (language, language_patch) in patch.languages {
        let language_settings = settings.languages.entry(language).or_default();
        if let Some(enabled) = language_patch.enabled {
            language_settings.enabled = enabled;
        }
        match language_patch.command_override {
            CommandOverridePatch::Missing => {}
            CommandOverridePatch::Null => {
                language_settings.command_override = None;
            }
            CommandOverridePatch::Value(command_override) => {
                language_settings.command_override = Some(command_override);
            }
        }
    }
    if let Some(custom_adapters) = patch.custom_adapters {
        settings.custom_adapters = custom_adapters;
    }
    save_settings(&state.dashboard_root, &settings)
        .await
        .map_err(|err| internal_error(&err))?;
    let mut adapters = crate::diagnostics::lsp::adapters::builtin_adapters();
    adapters.extend(settings.custom_adapters.clone());
    let mut broker = state.code_diagnostics.write().await;
    broker.update_adapters(adapters);
    broker.update_settings(settings);
    drop(broker);
    let snapshot = diagnostics_snapshot(&state).await?;
    Ok(Json(json!(snapshot)))
}

pub(crate) async fn refresh_all(State(state): State<DashboardState>) -> ApiResult {
    let languages = refreshable_languages(&state).await?;