crates/api_crud/src/site/update.rs

   1 use crate::site::{application_question_check, site_default_post_listing_type_check};
   2 use actix_web::web::{Data, Json};
   3 use lemmy_api_common::{
   4   context::LemmyContext,
   5   site::{EditSite, SiteResponse},
   6   utils::{
   7     is_admin,
   8     local_site_rate_limit_to_rate_limit_config,
   9     local_user_view_from_jwt,
  10     sanitize_html_opt,
  11   },
  12 };
  13 use lemmy_db_schema::{
  14   source::{
  15     actor_language::SiteLanguage,
  16     federation_allowlist::FederationAllowList,
  17     federation_blocklist::FederationBlockList,
  18     local_site::{LocalSite, LocalSiteUpdateForm},
  19     local_site_rate_limit::{LocalSiteRateLimit, LocalSiteRateLimitUpdateForm},
  20     local_user::LocalUser,
  21     site::{Site, SiteUpdateForm},
  22     tagline::Tagline,
  23   },
  24   traits::Crud,
  25   utils::{diesel_option_overwrite, diesel_option_overwrite_to_url, naive_now},
  26   RegistrationMode,
  27 };
  28 use lemmy_db_views::structs::SiteView;
  29 use lemmy_utils::{
  30   error::{LemmyError, LemmyErrorExt, LemmyErrorType, LemmyResult},
  31   utils::{
  32     slurs::check_slurs_opt,
  33     validation::{
  34       build_and_check_regex,
  35       check_site_visibility_valid,
  36       is_valid_body_field,
  37       site_description_length_check,
  38       site_name_length_check,
  39     },
  40   },
  41 };
  42
  43 #[tracing::instrument(skip(context))]
  44 pub async fn update_site(
  45   data: Json<EditSite>,
  46   context: Data<LemmyContext>,
  47 ) -> Result<Json<SiteResponse>, LemmyError> {
  48   let local_user_view = local_user_view_from_jwt(&data.auth, &context).await?;
  49   let site_view = SiteView::read_local(&mut context.pool()).await?;
  50   let local_site = site_view.local_site;
  51   let site = site_view.site;
  52
  53   // Make sure user is an admin; other types of users should not update site data...
  54   is_admin(&local_user_view)?;
  55
  56   validate_update_payload(&local_site, &data)?;
  57
  58   if let Some(discussion_languages) = data.discussion_languages.clone() {
  59     SiteLanguage::update(&mut context.pool(), discussion_languages.clone(), &site).await?;
  60   }
  61
  62   let name = sanitize_html_opt(&data.name);
  63   let sidebar = sanitize_html_opt(&data.sidebar);
  64   let description = sanitize_html_opt(&data.description);
  65
  66   let site_form = SiteUpdateForm::builder()
  67     .name(name)
  68     .sidebar(diesel_option_overwrite(sidebar))
  69     .description(diesel_option_overwrite(description))
  70     .icon(diesel_option_overwrite_to_url(&data.icon)?)
  71     .banner(diesel_option_overwrite_to_url(&data.banner)?)
  72     .updated(Some(Some(naive_now())))
  73     .build();
  74
  75   Site::update(&mut context.pool(), site.id, &site_form)
  76     .await
  77     // Ignore errors for all these, so as to not throw errors if no update occurs
  78     // Diesel will throw an error for empty update forms
  79     .ok();
  80
  81   let application_question = sanitize_html_opt(&data.application_question);
  82   let default_theme = sanitize_html_opt(&data.default_theme);
  83   let legal_information = sanitize_html_opt(&data.legal_information);
  84
  85   let local_site_form = LocalSiteUpdateForm::builder()
  86     .enable_downvotes(data.enable_downvotes)
  87     .registration_mode(data.registration_mode)
  88     .enable_nsfw(data.enable_nsfw)
  89     .community_creation_admin_only(data.community_creation_admin_only)
  90     .require_email_verification(data.require_email_verification)
  91     .application_question(diesel_option_overwrite(application_question))
  92     .private_instance(data.private_instance)
  93     .default_theme(default_theme)
  94     .default_post_listing_type(data.default_post_listing_type)
  95     .legal_information(diesel_option_overwrite(legal_information))
  96     .application_email_admins(data.application_email_admins)
  97     .hide_modlog_mod_names(data.hide_modlog_mod_names)
  98     .updated(Some(Some(naive_now())))
  99     .slur_filter_regex(diesel_option_overwrite(data.slur_filter_regex.clone()))
 100     .actor_name_max_length(data.actor_name_max_length)
 101     .federation_enabled(data.federation_enabled)
 102     .captcha_enabled(data.captcha_enabled)
 103     .captcha_difficulty(data.captcha_difficulty.clone())
 104     .reports_email_admins(data.reports_email_admins)
 105     .build();
 106
 107   let update_local_site = LocalSite::update(&mut context.pool(), &local_site_form)
 108     .await
 109     .ok();
 110
 111   let local_site_rate_limit_form = LocalSiteRateLimitUpdateForm::builder()
 112     .message(data.rate_limit_message)
 113     .message_per_second(data.rate_limit_message_per_second)
 114     .post(data.rate_limit_post)
 115     .post_per_second(data.rate_limit_post_per_second)
 116     .register(data.rate_limit_register)
 117     .register_per_second(data.rate_limit_register_per_second)
 118     .image(data.rate_limit_image)
 119     .image_per_second(data.rate_limit_image_per_second)
 120     .comment(data.rate_limit_comment)
 121     .comment_per_second(data.rate_limit_comment_per_second)
 122     .search(data.rate_limit_search)
 123     .search_per_second(data.rate_limit_search_per_second)
 124     .build();
 125
 126   LocalSiteRateLimit::update(&mut context.pool(), &local_site_rate_limit_form)
 127     .await
 128     .ok();
 129
 130   // Replace the blocked and allowed instances
 131   let allowed = data.allowed_instances.clone();
 132   FederationAllowList::replace(&mut context.pool(), allowed).await?;
 133   let blocked = data.blocked_instances.clone();
 134   FederationBlockList::replace(&mut context.pool(), blocked).await?;
 135
 136   // TODO can't think of a better way to do this.
 137   // If the server suddenly requires email verification, or required applications, no old users
 138   // will be able to log in. It really only wants this to be a requirement for NEW signups.
 139   // So if it was set from false, to true, you need to update all current users columns to be verified.
 140
 141   let old_require_application =
 142     local_site.registration_mode == RegistrationMode::RequireApplication;
 143   let new_require_application = update_local_site
 144     .as_ref()
 145     .map(|ols| ols.registration_mode == RegistrationMode::RequireApplication)
 146     .unwrap_or(false);
 147   if !old_require_application && new_require_application {
 148     LocalUser::set_all_users_registration_applications_accepted(&mut context.pool())
 149       .await
 150       .with_lemmy_type(LemmyErrorType::CouldntSetAllRegistrationsAccepted)?;
 151   }
 152
 153   let new_require_email_verification = update_local_site
 154     .as_ref()
 155     .map(|ols| ols.require_email_verification)
 156     .unwrap_or(false);
 157   if !local_site.require_email_verification && new_require_email_verification {
 158     LocalUser::set_all_users_email_verified(&mut context.pool())
 159       .await
 160       .with_lemmy_type(LemmyErrorType::CouldntSetAllEmailVerified)?;
 161   }
 162
 163   let new_taglines = data.taglines.clone();
 164   let taglines = Tagline::replace(&mut context.pool(), local_site.id, new_taglines).await?;
 165
 166   let site_view = SiteView::read_local(&mut context.pool()).await?;
 167
 168   let rate_limit_config =
 169     local_site_rate_limit_to_rate_limit_config(&site_view.local_site_rate_limit);
 170   context
 171     .settings_updated_channel()
 172     .send(rate_limit_config)
 173     .await?;
 174
 175   Ok(Json(SiteResponse {
 176     site_view,
 177     taglines,
 178   }))
 179 }
 180
 181 fn validate_update_payload(local_site: &LocalSite, edit_site: &EditSite) -> LemmyResult<()> {
 182   // Check that the slur regex compiles, and return the regex if valid...
 183   // Prioritize using new slur regex from the request; if not provided, use the existing regex.
 184   let slur_regex = build_and_check_regex(
 185     &edit_site
 186       .slur_filter_regex
 187       .as_deref()
 188       .or(local_site.slur_filter_regex.as_deref()),
 189   )?;
 190
 191   if let Some(name) = &edit_site.name {
 192     // The name doesn't need to be updated, but if provided it cannot be blanked out...
 193     site_name_length_check(name)?;
 194     check_slurs_opt(&edit_site.name, &slur_regex)?;
 195   }
 196
 197   if let Some(desc) = &edit_site.description {
 198     site_description_length_check(desc)?;
 199     check_slurs_opt(&edit_site.description, &slur_regex)?;
 200   }
 201
 202   site_default_post_listing_type_check(&edit_site.default_post_listing_type)?;
 203
 204   check_site_visibility_valid(
 205     local_site.private_instance,
 206     local_site.federation_enabled,
 207     &edit_site.private_instance,
 208     &edit_site.federation_enabled,
 209   )?;
 210
 211   // Ensure that the sidebar has fewer than the max num characters...
 212   is_valid_body_field(&edit_site.sidebar, false)?;
 213
 214   application_question_check(
 215     &local_site.application_question,
 216     &edit_site.application_question,
 217     edit_site
 218       .registration_mode
 219       .unwrap_or(local_site.registration_mode),
 220   )
 221 }
 222
 223 #[cfg(test)]
 224 mod tests {
 225   #![allow(clippy::unwrap_used)]
 226   #![allow(clippy::indexing_slicing)]
 227
 228   use crate::site::update::validate_update_payload;
 229   use lemmy_api_common::site::EditSite;
 230   use lemmy_db_schema::{source::local_site::LocalSite, ListingType, RegistrationMode};
 231   use lemmy_utils::error::LemmyErrorType;
 232
 233   #[test]
 234   fn test_validate_invalid_update_payload() {
 235     let invalid_payloads = [
 236       (
 237         "EditSite name matches LocalSite slur filter",
 238         LemmyErrorType::Slurs,
 239         &generate_local_site(
 240           Some(String::from("(foo|bar)")),
 241           true,
 242           false,
 243           None::<String>,
 244           RegistrationMode::Open,
 245         ),
 246         &generate_edit_site(
 247           Some(String::from("foo site_name")),
 248           None::<String>,
 249           None::<String>,
 250           None::<ListingType>,
 251           None::<String>,
 252           None::<bool>,
 253           None::<bool>,
 254           None::<String>,
 255           None::<RegistrationMode>,
 256         ),
 257       ),
 258       (
 259         "EditSite name matches new slur filter",
 260         LemmyErrorType::Slurs,
 261         &generate_local_site(
 262           Some(String::from("(foo|bar)")),
 263           true,
 264           false,
 265           None::<String>,
 266           RegistrationMode::Open,
 267         ),
 268         &generate_edit_site(
 269           Some(String::from("zeta site_name")),
 270           None::<String>,
 271           None::<String>,
 272           None::<ListingType>,
 273           Some(String::from("(zeta|alpha)")),
 274           None::<bool>,
 275           None::<bool>,
 276           None::<String>,
 277           None::<RegistrationMode>,
 278         ),
 279       ),
 280       (
 281         "EditSite listing type is Subscribed, which is invalid",
 282         LemmyErrorType::InvalidDefaultPostListingType,
 283         &generate_local_site(
 284           None::<String>,
 285           true,
 286           false,
 287           None::<String>,
 288           RegistrationMode::Open,
 289         ),
 290         &generate_edit_site(
 291           Some(String::from("site_name")),
 292           None::<String>,
 293           None::<String>,
 294           Some(ListingType::Subscribed),
 295           None::<String>,
 296           None::<bool>,
 297           None::<bool>,
 298           None::<String>,
 299           None::<RegistrationMode>,
 300         ),
 301       ),
 302       (
 303         "EditSite is both private and federated",
 304         LemmyErrorType::CantEnablePrivateInstanceAndFederationTogether,
 305         &generate_local_site(
 306           None::<String>,
 307           true,
 308           false,
 309           None::<String>,
 310           RegistrationMode::Open,
 311         ),
 312         &generate_edit_site(
 313           Some(String::from("site_name")),
 314           None::<String>,
 315           None::<String>,
 316           None::<ListingType>,
 317           None::<String>,
 318           Some(true),
 319           Some(true),
 320           None::<String>,
 321           None::<RegistrationMode>,
 322         ),
 323       ),
 324       (
 325         "LocalSite is private, but EditSite also makes it federated",
 326         LemmyErrorType::CantEnablePrivateInstanceAndFederationTogether,
 327         &generate_local_site(
 328           None::<String>,
 329           true,
 330           false,
 331           None::<String>,
 332           RegistrationMode::Open,
 333         ),
 334         &generate_edit_site(
 335           Some(String::from("site_name")),
 336           None::<String>,
 337           None::<String>,
 338           None::<ListingType>,
 339           None::<String>,
 340           None::<bool>,
 341           Some(true),
 342           None::<String>,
 343           None::<RegistrationMode>,
 344         ),
 345       ),
 346       (
 347         "EditSite requires application, but neither it nor LocalSite has an application question",
 348         LemmyErrorType::ApplicationQuestionRequired,
 349         &generate_local_site(
 350           None::<String>,
 351           true,
 352           false,
 353           None::<String>,
 354           RegistrationMode::Open,
 355         ),
 356         &generate_edit_site(
 357           Some(String::from("site_name")),
 358           None::<String>,
 359           None::<String>,
 360           None::<ListingType>,
 361           None::<String>,
 362           None::<bool>,
 363           None::<bool>,
 364           None::<String>,
 365           Some(RegistrationMode::RequireApplication),
 366         ),
 367       ),
 368     ];
 369
 370     invalid_payloads.iter().enumerate().for_each(
 371       |(
 372          idx,
 373          &(reason, ref expected_err, local_site, edit_site),
 374        )| {
 375         match validate_update_payload(local_site, edit_site) {
 376           Ok(_) => {
 377             panic!(
 378               "Got Ok, but validation should have failed with error: {} for reason: {}. invalid_payloads.nth({})",
 379               expected_err, reason, idx
 380             )
 381           }
 382           Err(error) => {
 383             assert!(
 384               error.error_type.eq(&expected_err.clone()),
 385               "Got Err {:?}, but should have failed with message: {} for reason: {}. invalid_payloads.nth({})",
 386               error.error_type,
 387               expected_err,
 388               reason,
 389               idx
 390             )
 391           }
 392         }
 393       },
 394     );
 395   }
 396
 397   #[test]
 398   fn test_validate_valid_update_payload() {
 399     let valid_payloads = [
 400       (
 401         "No changes between LocalSite and EditSite",
 402         &generate_local_site(
 403           None::<String>,
 404           true,
 405           false,
 406           None::<String>,
 407           RegistrationMode::Open,
 408         ),
 409         &generate_edit_site(
 410           None::<String>,
 411           None::<String>,
 412           None::<String>,
 413           None::<ListingType>,
 414           None::<String>,
 415           None::<bool>,
 416           None::<bool>,
 417           None::<String>,
 418           None::<RegistrationMode>,
 419         ),
 420       ),
 421       (
 422         "EditSite allows clearing and changing values",
 423         &generate_local_site(
 424           None::<String>,
 425           true,
 426           false,
 427           None::<String>,
 428           RegistrationMode::Open,
 429         ),
 430         &generate_edit_site(
 431           Some(String::from("site_name")),
 432           Some(String::new()),
 433           Some(String::new()),
 434           Some(ListingType::All),
 435           Some(String::new()),
 436           Some(false),
 437           Some(true),
 438           Some(String::new()),
 439           Some(RegistrationMode::Open),
 440         ),
 441       ),
 442       (
 443         "EditSite name passes slur filter regex",
 444         &generate_local_site(
 445           Some(String::from("(foo|bar)")),
 446           true,
 447           false,
 448           None::<String>,
 449           RegistrationMode::Open,
 450         ),
 451         &generate_edit_site(
 452           Some(String::from("foo site_name")),
 453           None::<String>,
 454           None::<String>,
 455           None::<ListingType>,
 456           Some(String::new()),
 457           None::<bool>,
 458           None::<bool>,
 459           None::<String>,
 460           None::<RegistrationMode>,
 461         ),
 462       ),
 463       (
 464         "LocalSite has application question and EditSite now requires applications,",
 465         &generate_local_site(
 466           None::<String>,
 467           true,
 468           false,
 469           Some(String::from("question")),
 470           RegistrationMode::Open,
 471         ),
 472         &generate_edit_site(
 473           Some(String::from("site_name")),
 474           None::<String>,
 475           None::<String>,
 476           None::<ListingType>,
 477           None::<String>,
 478           None::<bool>,
 479           None::<bool>,
 480           None::<String>,
 481           Some(RegistrationMode::RequireApplication),
 482         ),
 483       ),
 484     ];
 485
 486     valid_payloads
 487       .iter()
 488       .enumerate()
 489       .for_each(|(idx, &(reason, local_site, edit_site))| {
 490         assert!(
 491           validate_update_payload(local_site, edit_site).is_ok(),
 492           "Got Err, but should have got Ok for reason: {}. valid_payloads.nth({})",
 493           reason,
 494           idx
 495         );
 496       })
 497   }
 498
 499   fn generate_local_site(
 500     site_slur_filter_regex: Option<String>,
 501     site_is_private: bool,
 502     site_is_federated: bool,
 503     site_application_question: Option<String>,
 504     site_registration_mode: RegistrationMode,
 505   ) -> LocalSite {
 506     LocalSite {
 507       id: Default::default(),
 508       site_id: Default::default(),
 509       site_setup: true,
 510       enable_downvotes: false,
 511       enable_nsfw: false,
 512       community_creation_admin_only: false,
 513       require_email_verification: false,
 514       application_question: site_application_question,
 515       private_instance: site_is_private,
 516       default_theme: String::new(),
 517       default_post_listing_type: ListingType::All,
 518       legal_information: None,
 519       hide_modlog_mod_names: false,
 520       application_email_admins: false,
 521       slur_filter_regex: site_slur_filter_regex,
 522       actor_name_max_length: 0,
 523       federation_enabled: site_is_federated,
 524       captcha_enabled: false,
 525       captcha_difficulty: String::new(),
 526       published: Default::default(),
 527       updated: None,
 528       registration_mode: site_registration_mode,
 529       reports_email_admins: false,
 530     }
 531   }
 532
 533   // Allow the test helper function to have too many arguments.
 534   // It's either this or generate the entire struct each time for testing.
 535   #[allow(clippy::too_many_arguments)]
 536   fn generate_edit_site(
 537     site_name: Option<String>,
 538     site_description: Option<String>,
 539     site_sidebar: Option<String>,
 540     site_listing_type: Option<ListingType>,
 541     site_slur_filter_regex: Option<String>,
 542     site_is_private: Option<bool>,
 543     site_is_federated: Option<bool>,
 544     site_application_question: Option<String>,
 545     site_registration_mode: Option<RegistrationMode>,
 546   ) -> EditSite {
 547     EditSite {
 548       name: site_name,
 549       sidebar: site_sidebar,
 550       description: site_description,
 551       icon: None,
 552       banner: None,
 553       enable_downvotes: None,
 554       enable_nsfw: None,
 555       community_creation_admin_only: None,
 556       require_email_verification: None,
 557       application_question: site_application_question,
 558       private_instance: site_is_private,
 559       default_theme: None,
 560       default_post_listing_type: site_listing_type,
 561       legal_information: None,
 562       application_email_admins: None,
 563       hide_modlog_mod_names: None,
 564       discussion_languages: None,
 565       slur_filter_regex: site_slur_filter_regex,
 566       actor_name_max_length: None,
 567       rate_limit_message: None,
 568       rate_limit_message_per_second: None,
 569       rate_limit_post: None,
 570       rate_limit_post_per_second: None,
 571       rate_limit_register: None,
 572       rate_limit_register_per_second: None,
 573       rate_limit_image: None,
 574       rate_limit_image_per_second: None,
 575       rate_limit_comment: None,
 576       rate_limit_comment_per_second: None,
 577       rate_limit_search: None,
 578       rate_limit_search_per_second: None,
 579       federation_enabled: site_is_federated,
 580       federation_debug: None,
 581       captcha_enabled: None,
 582       captcha_difficulty: None,
 583       allowed_instances: None,
 584       blocked_instances: None,
 585       taglines: None,
 586       registration_mode: site_registration_mode,
 587       reports_email_admins: None,
 588       auth: Default::default(),
 589     }
 590   }
 591 }