src/code_migrations.rs

   1 // This is for db migrations that require code
   2 use diesel::{
   3   sql_types::{Nullable, Text},
   4   *,
   5 };
   6 use lemmy_db::{
   7   comment::Comment,
   8   community::{Community, CommunityForm},
   9   naive_now,
  10   post::Post,
  11   private_message::PrivateMessage,
  12   user::{UserForm, User_},
  13   Crud,
  14 };
  15 use lemmy_utils::{
  16   apub::{generate_actor_keypair, get_apub_protocol_string, make_apub_endpoint, EndpointType},
  17   settings::Settings,
  18   LemmyError,
  19 };
  20 use log::info;
  21
  22 pub fn run_advanced_migrations(conn: &PgConnection) -> Result<(), LemmyError> {
  23   user_updates_2020_04_02(&conn)?;
  24   community_updates_2020_04_02(&conn)?;
  25   post_updates_2020_04_03(&conn)?;
  26   comment_updates_2020_04_03(&conn)?;
  27   private_message_updates_2020_05_05(&conn)?;
  28   post_thumbnail_url_updates_2020_07_27(&conn)?;
  29
  30   Ok(())
  31 }
  32
  33 fn user_updates_2020_04_02(conn: &PgConnection) -> Result<(), LemmyError> {
  34   use lemmy_db::schema::user_::dsl::*;
  35
  36   info!("Running user_updates_2020_04_02");
  37
  38   // Update the actor_id, private_key, and public_key, last_refreshed_at
  39   let incorrect_users = user_
  40     .filter(actor_id.like("changeme_%"))
  41     .filter(local.eq(true))
  42     .load::<User_>(conn)?;
  43
  44   sql_query("alter table user_ disable trigger refresh_user").execute(conn)?;
  45
  46   for cuser in &incorrect_users {
  47     let keypair = generate_actor_keypair()?;
  48
  49     let form = UserForm {
  50       name: cuser.name.to_owned(),
  51       email: Some(cuser.email.to_owned()),
  52       matrix_user_id: cuser.matrix_user_id.to_owned(),
  53       avatar: Some(cuser.avatar.to_owned()),
  54       banner: Some(cuser.banner.to_owned()),
  55       password_encrypted: cuser.password_encrypted.to_owned(),
  56       preferred_username: cuser.preferred_username.to_owned(),
  57       updated: None,
  58       admin: cuser.admin,
  59       banned: cuser.banned,
  60       show_nsfw: cuser.show_nsfw,
  61       theme: cuser.theme.to_owned(),
  62       default_sort_type: cuser.default_sort_type,
  63       default_listing_type: cuser.default_listing_type,
  64       lang: cuser.lang.to_owned(),
  65       show_avatars: cuser.show_avatars,
  66       send_notifications_to_email: cuser.send_notifications_to_email,
  67       actor_id: Some(make_apub_endpoint(EndpointType::User, &cuser.name).to_string()),
  68       bio: cuser.bio.to_owned(),
  69       local: cuser.local,
  70       private_key: Some(keypair.private_key),
  71       public_key: Some(keypair.public_key),
  72       last_refreshed_at: Some(naive_now()),
  73     };
  74
  75     User_::update(&conn, cuser.id, &form)?;
  76   }
  77
  78   sql_query("alter table user_ enable trigger refresh_user").execute(conn)?;
  79
  80   info!("{} user rows updated.", incorrect_users.len());
  81
  82   Ok(())
  83 }
  84
  85 fn community_updates_2020_04_02(conn: &PgConnection) -> Result<(), LemmyError> {
  86   use lemmy_db::schema::community::dsl::*;
  87
  88   info!("Running community_updates_2020_04_02");
  89
  90   // Update the actor_id, private_key, and public_key, last_refreshed_at
  91   let incorrect_communities = community
  92     .filter(actor_id.like("changeme_%"))
  93     .filter(local.eq(true))
  94     .load::<Community>(conn)?;
  95
  96   sql_query("alter table community disable trigger refresh_community").execute(conn)?;
  97
  98   for ccommunity in &incorrect_communities {
  99     let keypair = generate_actor_keypair()?;
 100
 101     let form = CommunityForm {
 102       name: ccommunity.name.to_owned(),
 103       title: ccommunity.title.to_owned(),
 104       description: ccommunity.description.to_owned(),
 105       category_id: ccommunity.category_id,
 106       creator_id: ccommunity.creator_id,
 107       removed: None,
 108       deleted: None,
 109       nsfw: ccommunity.nsfw,
 110       updated: None,
 111       actor_id: Some(make_apub_endpoint(EndpointType::Community, &ccommunity.name).to_string()),
 112       local: ccommunity.local,
 113       private_key: Some(keypair.private_key),
 114       public_key: Some(keypair.public_key),
 115       last_refreshed_at: Some(naive_now()),
 116       published: None,
 117       icon: Some(ccommunity.icon.to_owned()),
 118       banner: Some(ccommunity.banner.to_owned()),
 119     };
 120
 121     Community::update(&conn, ccommunity.id, &form)?;
 122   }
 123
 124   sql_query("alter table community enable trigger refresh_community").execute(conn)?;
 125
 126   info!("{} community rows updated.", incorrect_communities.len());
 127
 128   Ok(())
 129 }
 130
 131 fn post_updates_2020_04_03(conn: &PgConnection) -> Result<(), LemmyError> {
 132   use lemmy_db::schema::post::dsl::*;
 133
 134   info!("Running post_updates_2020_04_03");
 135
 136   // Update the ap_id
 137   let incorrect_posts = post
 138     .filter(ap_id.eq("changeme_%"))
 139     .filter(local.eq(true))
 140     .load::<Post>(conn)?;
 141
 142   sql_query("alter table post disable trigger refresh_post").execute(conn)?;
 143
 144   for cpost in &incorrect_posts {
 145     let apub_id = make_apub_endpoint(EndpointType::Post, &cpost.id.to_string()).to_string();
 146     Post::update_ap_id(&conn, cpost.id, apub_id)?;
 147   }
 148
 149   info!("{} post rows updated.", incorrect_posts.len());
 150
 151   sql_query("alter table post enable trigger refresh_post").execute(conn)?;
 152
 153   Ok(())
 154 }
 155
 156 fn comment_updates_2020_04_03(conn: &PgConnection) -> Result<(), LemmyError> {
 157   use lemmy_db::schema::comment::dsl::*;
 158
 159   info!("Running comment_updates_2020_04_03");
 160
 161   // Update the ap_id
 162   let incorrect_comments = comment
 163     .filter(ap_id.eq("changeme_%"))
 164     .filter(local.eq(true))
 165     .load::<Comment>(conn)?;
 166
 167   sql_query("alter table comment disable trigger refresh_comment").execute(conn)?;
 168
 169   for ccomment in &incorrect_comments {
 170     let apub_id = make_apub_endpoint(EndpointType::Comment, &ccomment.id.to_string()).to_string();
 171     Comment::update_ap_id(&conn, ccomment.id, apub_id)?;
 172   }
 173
 174   sql_query("alter table comment enable trigger refresh_comment").execute(conn)?;
 175
 176   info!("{} comment rows updated.", incorrect_comments.len());
 177
 178   Ok(())
 179 }
 180
 181 fn private_message_updates_2020_05_05(conn: &PgConnection) -> Result<(), LemmyError> {
 182   use lemmy_db::schema::private_message::dsl::*;
 183
 184   info!("Running private_message_updates_2020_05_05");
 185
 186   // Update the ap_id
 187   let incorrect_pms = private_message
 188     .filter(ap_id.eq("changeme_%"))
 189     .filter(local.eq(true))
 190     .load::<PrivateMessage>(conn)?;
 191
 192   for cpm in &incorrect_pms {
 193     let apub_id = make_apub_endpoint(EndpointType::PrivateMessage, &cpm.id.to_string()).to_string();
 194     PrivateMessage::update_ap_id(&conn, cpm.id, apub_id)?;
 195   }
 196
 197   info!("{} private message rows updated.", incorrect_pms.len());
 198
 199   Ok(())
 200 }
 201
 202 fn post_thumbnail_url_updates_2020_07_27(conn: &PgConnection) -> Result<(), LemmyError> {
 203   use lemmy_db::schema::post::dsl::*;
 204
 205   info!("Running post_thumbnail_url_updates_2020_07_27");
 206
 207   let domain_prefix = format!(
 208     "{}://{}/pictrs/image/",
 209     get_apub_protocol_string(),
 210     Settings::get().hostname
 211   );
 212
 213   let incorrect_thumbnails = post.filter(thumbnail_url.not_like("http%"));
 214
 215   // Prepend the rows with the update
 216   let res = diesel::update(incorrect_thumbnails)
 217     .set(
 218       thumbnail_url.eq(
 219         domain_prefix
 220           .into_sql::<Nullable<Text>>()
 221           .concat(thumbnail_url),
 222       ),
 223     )
 224     .get_results::<Post>(conn)?;
 225
 226   info!("{} Post thumbnail_url rows updated.", res.len());
 227
 228   Ok(())
 229 }