Merge pull request #2352 from conectado/drop-thread-archival-status

Drop archival status from forum thread

runtime-modules/forum/src/benchmarking.rs

@@ -794,7 +794,6 @@ benchmarks! {
             category_id,
             title_hash: T::calculate_hash(&title),
             author_id: forum_user_id.saturated_into(),
-            archived: false,
             poll: poll.clone(),
             cleanup_pay_off: T::ThreadDeposit::get(),
             number_of_posts: 1,
@@ -860,81 +859,6 @@ benchmarks! {
         );
     }
 
-    update_thread_archival_status_lead {
-        let i in 1 .. (T::MaxCategoryDepth::get() + 1) as u32;
-
-        let forum_user_id = 0;
-        let caller_id =
-            insert_a_leader::<T>(forum_user_id);
-        let text = vec![1u8].repeat(MAX_BYTES as usize);
-
-        // Generate categories tree
-        let (category_id, _) = generate_categories_tree::<T>(caller_id.clone(), i, None);
-
-        // Create thread
-        let thread_id = create_new_thread::<T>(caller_id.clone(), forum_user_id.saturated_into(), category_id, text.clone(), text.clone(), None);
-        let mut thread = Module::<T>::thread_by_id(category_id, thread_id);
-        let new_archival_status = true;
-
-    }: update_thread_archival_status(RawOrigin::Signed(caller_id), PrivilegedActor::Lead, category_id, thread_id, new_archival_status)
-    verify {
-        thread.archived = new_archival_status;
-
-        assert_eq!(Module::<T>::thread_by_id(category_id, thread_id), thread);
-
-        assert_last_event::<T>(
-            RawEvent::ThreadUpdated(
-                thread_id,
-                new_archival_status,
-                PrivilegedActor::Lead,
-                category_id
-            ).into()
-        );
-    }
-
-    update_thread_archival_status_moderator {
-        let i in 1 .. (T::MaxCategoryDepth::get() + 1) as u32;
-
-        let forum_user_id = 0;
-        let caller_id =
-            insert_a_leader::<T>(forum_user_id);
-        let text = vec![1u8].repeat(MAX_BYTES as usize);
-
-        // Generate categories tree
-        let (category_id, _) = generate_categories_tree::<T>(caller_id.clone(), i, None);
-
-        // Create thread
-        let thread_id = create_new_thread::<T>(caller_id.clone(), forum_user_id.saturated_into(), category_id, text.clone(), text.clone(), None);
-        let mut thread = Module::<T>::thread_by_id(category_id, thread_id);
-        let new_archival_status = true;
-
-        let moderator_id = ModeratorId::<T>::from(forum_user_id.try_into().unwrap());
-
-        // Set up category membership of moderator.
-        Module::<T>::update_category_membership_of_moderator(
-            RawOrigin::Signed(caller_id.clone()).into(),
-            moderator_id,
-            category_id,
-            true,
-        )
-        .unwrap();
-
-    }: update_thread_archival_status(RawOrigin::Signed(caller_id), PrivilegedActor::Moderator(moderator_id), category_id, thread_id, new_archival_status)
-    verify {
-        thread.archived = new_archival_status;
-
-        assert_eq!(Module::<T>::thread_by_id(category_id, thread_id), thread);
-
-        assert_last_event::<T>(
-            RawEvent::ThreadUpdated(
-                thread_id,
-                new_archival_status,
-                PrivilegedActor::Moderator(moderator_id),
-                category_id
-            ).into()
-        );
-    }
-
     delete_thread {
         let i in 1 .. (T::MaxCategoryDepth::get() + 1) as u32;
         let hide = false;
@@ -1818,22 +1742,6 @@ mod tests {
         });
     }
 
-    #[test]
-    fn test_update_thread_archival_status_lead() {
-        with_test_externalities(|| {
-            assert_ok!(test_benchmark_update_thread_archival_status_lead::<Runtime>());
-        });
-    }
-
-    #[test]
-    fn test_update_thread_archival_status_moderator() {
-        with_test_externalities(|| {
-            assert_ok!(test_benchmark_update_thread_archival_status_moderator::<
-                Runtime,
-            >());
-        });
-    }
-
     #[test]
     fn test_delete_thread() {
         with_test_externalities(|| {

runtime-modules/forum/src/lib.rs

@@ -65,14 +65,12 @@ pub trait WeightInfo {
     fn delete_category_moderator(i: u32) -> Weight;
     fn create_thread(j: u32, k: u32, i: u32) -> Weight;
     fn edit_thread_title(i: u32, j: u32) -> Weight;
-    fn update_thread_archival_status_lead(i: u32) -> Weight;
-    fn update_thread_archival_status_moderator(i: u32) -> Weight;
     fn delete_thread(i: u32) -> Weight;
     fn move_thread_to_category_lead(i: u32) -> Weight;
     fn move_thread_to_category_moderator(i: u32) -> Weight;
     fn vote_on_poll(i: u32, j: u32) -> Weight;
     fn moderate_thread_lead(i: u32, k: u32) -> Weight;
-    fn moderate_thread_moderator(i: u32, j: u32, k: u32) -> Weight;
+    fn moderate_thread_moderator(i: u32, k: u32) -> Weight;
     fn add_post(i: u32, j: u32) -> Weight;
     fn react_post(i: u32) -> Weight;
     fn edit_post_text(i: u32, j: u32) -> Weight;
@@ -242,9 +240,6 @@ pub struct Thread<ForumUserId, CategoryId, Moment, Hash, Balance> {
     /// Author of post.
     pub author_id: ForumUserId,
 
-    /// Whether thread is archived.
-    pub archived: bool,
-
     /// poll description.
     pub poll: Option<Poll<Moment, Hash>>,
 
@@ -340,9 +335,6 @@ decl_error! {
         /// Thread not being updated.
         ThreadNotBeingUpdated,
 
-        /// Thread is immutable, i.e. archived.
-        ThreadImmutable,
-
         /// Not enough balance to create thread
         InsufficientBalanceForThreadCreation,
 
@@ -805,7 +797,6 @@ decl_module! {
                 category_id,
                 title_hash: T::calculate_hash(&title),
                 author_id: forum_user_id,
-                archived: false,
                 poll: poll.clone(),
                 cleanup_pay_off: T::ThreadDeposit::get(),
                 number_of_posts: 0,
@@ -890,53 +881,6 @@ decl_module! {
             Ok(())
         }
 
-        /// Update thread archival status
-        ///
-        /// <weight>
-        ///
-        /// ## Weight
-        /// `O (W)` where:
-        /// - `W` is the category depth
-        /// - DB:
-        ///    - O(W)
-        /// # </weight>
-        #[weight = WeightInfoForum::<T>::update_thread_archival_status_lead(
-            T::MaxCategoryDepth::get() as u32,
-        ).max(WeightInfoForum::<T>::update_thread_archival_status_moderator(
-            T::MaxCategoryDepth::get() as u32,
-        ))]
-        fn update_thread_archival_status(origin, actor: PrivilegedActor<T>, category_id: T::CategoryId, thread_id: T::ThreadId, new_archival_status: bool) -> DispatchResult {
-            // Ensure data migration is done
-            Self::ensure_data_migration_done()?;
-
-            let account_id = ensure_signed(origin)?;
-
-            // Ensure actor can update category
-            let (_, thread) = Self::ensure_can_update_thread_archival_status(account_id, &actor, &category_id, &thread_id)?;
-
-            // No change, invalid transaction
-            if new_archival_status == thread.archived {
-                return Err(Error::<T>::ThreadNotBeingUpdated.into());
-            }
-
-            //
-            // == MUTATION SAFE ==
-            //
-
-            // Mutate thread, and set possible new change parameters
-            <ThreadById<T>>::mutate(thread.category_id, thread_id, |c| c.archived = new_archival_status);
-
-            // Generate event
-            Self::deposit_event(RawEvent::ThreadUpdated(
-                    thread_id,
-                    new_archival_status,
-                    actor,
-                    category_id
-                ));
-
-            Ok(())
-        }
-
         /// Delete thread
         ///
         /// <weight>
@@ -1121,7 +1065,6 @@ decl_module! {
         ).max(
             WeightInfoForum::<T>::moderate_thread_moderator(
                 T::MaxCategoryDepth::get() as u32,
-                0,
                 rationale.len().saturated_into(),
             )
         )]
@@ -1692,33 +1635,12 @@ impl<T: Trait> Module<T> {
         // Make sure thread exists
         let thread = Self::ensure_thread_exists(category_id, thread_id)?;
 
-        if thread.archived {
-            return Err(Error::<T>::ThreadImmutable);
-        }
-
         // and corresponding category is mutable
         let category = Self::ensure_category_is_mutable(category_id)?;
 
         Ok((category, thread))
     }
 
-    fn ensure_can_update_thread_archival_status(
-        account_id: T::AccountId,
-        actor: &PrivilegedActor<T>,
-        category_id: &T::CategoryId,
-        thread_id: &T::ThreadId,
-    ) -> Result<(Category<T::CategoryId, T::ThreadId, T::Hash>, ThreadOf<T>), Error<T>> {
-        // Check actor's role
-        Self::ensure_actor_role(&account_id, actor)?;
-
-        let (category, thread) = Self::ensure_thread_is_mutable(category_id, thread_id)?;
-
-        // Ensure actor can delete category
-        Self::ensure_can_moderate_category_path(actor, category_id)?;
-
-        Ok((category, thread))
-    }
-
     fn ensure_thread_exists(
         category_id: &T::CategoryId,
         thread_id: &T::ThreadId,

runtime-modules/forum/src/mock.rs

@@ -447,12 +447,6 @@ impl WeightInfo for () {
     fn edit_thread_title(_: u32, _: u32) -> Weight {
         0
     }
-    fn update_thread_archival_status_lead(_: u32) -> Weight {
-        0
-    }
-    fn update_thread_archival_status_moderator(_: u32) -> Weight {
-        0
-    }
     fn delete_thread(_: u32) -> Weight {
         0
     }
@@ -468,7 +462,7 @@ impl WeightInfo for () {
     fn moderate_thread_lead(_: u32, _: u32) -> Weight {
         0
     }
-    fn moderate_thread_moderator(_: u32, _: u32, _: u32) -> Weight {
+    fn moderate_thread_moderator(_: u32, _: u32) -> Weight {
         0
     }
     fn add_post(_: u32, _: u32) -> Weight {
@@ -876,37 +870,6 @@ pub fn move_thread_mock(
     }
 }
 
-pub fn update_thread_archival_status_mock(
-    origin: OriginType,
-    actor: PrivilegedActor<Runtime>,
-    category_id: <Runtime as Trait>::CategoryId,
-    thread_id: <Runtime as Trait>::ThreadId,
-    new_archival_status: bool,
-    result: DispatchResult,
-) {
-    assert_eq!(
-        TestForumModule::update_thread_archival_status(
-            mock_origin(origin),
-            actor.clone(),
-            category_id,
-            thread_id,
-            new_archival_status
-        ),
-        result
-    );
-    if result.is_ok() {
-        assert_eq!(
-            System::events().last().unwrap().event,
-            TestEvent::forum_mod(RawEvent::ThreadUpdated(
-                thread_id,
-                new_archival_status,
-                actor,
-                category_id
-            ))
-        );
-    }
-}
-
 pub fn create_post_mock(
     origin: OriginType,
     account_id: <Runtime as frame_system::Trait>::AccountId,

runtime-modules/forum/src/tests.rs

@@ -798,274 +798,6 @@ fn edit_thread_title() {
 /*
  ** update_category
  */
-#[test]
-// test if category updator is forum lead
-fn update_thread_archival_status_origin() {
-    let origins = [FORUM_LEAD_ORIGIN, NOT_FORUM_LEAD_ORIGIN];
-    let results = vec![Ok(()), Err(Error::<Runtime>::OriginNotForumLead.into())];
-
-    for index in 0..origins.len() {
-        let forum_lead = FORUM_LEAD_ORIGIN_ID;
-        let origin = OriginType::Signed(forum_lead);
-        let initial_balance = 10_000_000;
-        with_test_externalities(|| {
-            balances::Module::<Runtime>::make_free_balance_be(&forum_lead, initial_balance);
-
-            let category_id = create_category_mock(
-                origin,
-                None,
-                good_category_title(),
-                good_category_description(),
-                Ok(()),
-            );
-
-            let thread_id = create_thread_mock(
-                origins[0].clone(),
-                forum_lead,
-                forum_lead,
-                category_id,
-                good_thread_title(),
-                good_thread_text(),
-                None,
-                Ok(()),
-            );
-            update_thread_archival_status_mock(
-                origins[index].clone(),
-                PrivilegedActor::Lead,
-                category_id,
-                thread_id,
-                true,
-                results[index],
-            );
-        });
-    }
-}
-
-#[test]
-// test case for new setting actually not update thread status
-fn update_thread_archival_status_no_change() {
-    let forum_lead = FORUM_LEAD_ORIGIN_ID;
-    let origin = OriginType::Signed(forum_lead);
-    let initial_balance = 10_000_000;
-    with_test_externalities(|| {
-        balances::Module::<Runtime>::make_free_balance_be(&forum_lead, initial_balance);
-
-        let category_id = create_category_mock(
-            origin.clone(),
-            None,
-            good_category_title(),
-            good_category_description(),
-            Ok(()),
-        );
-        let thread_id = create_thread_mock(
-            origin.clone(),
-            forum_lead,
-            forum_lead,
-            category_id,
-            good_thread_title(),
-            good_thread_text(),
-            None,
-            Ok(()),
-        );
-        update_thread_archival_status_mock(
-            origin,
-            PrivilegedActor::Lead,
-            category_id,
-            thread_id,
-            false,
-            Err(Error::<Runtime>::ThreadNotBeingUpdated.into()),
-        );
-    });
-}
-
-#[test]
-// test case for editing nonexistent thread
-fn update_thread_archival_status_thread_exists() {
-    let forum_lead = FORUM_LEAD_ORIGIN_ID;
-    let origin = OriginType::Signed(forum_lead);
-    let initial_balance = 10_000_000;
-    with_test_externalities(|| {
-        balances::Module::<Runtime>::make_free_balance_be(&forum_lead, initial_balance);
-
-        let category_id = create_category_mock(
-            origin.clone(),
-            None,
-            good_category_title(),
-            good_category_description(),
-            Ok(()),
-        );
-        let thread_id = create_thread_mock(
-            origin.clone(),
-            forum_lead,
-            forum_lead,
-            category_id,
-            good_thread_title(),
-            good_thread_text(),
-            None,
-            Ok(()),
-        );
-        update_thread_archival_status_mock(
-            origin.clone(),
-            PrivilegedActor::Lead,
-            category_id,
-            thread_id,
-            true,
-            Ok(()),
-        );
-        update_thread_archival_status_mock(
-            origin.clone(),
-            PrivilegedActor::Lead,
-            category_id,
-            thread_id + 1,
-            true,
-            Err(Error::<Runtime>::ThreadDoesNotExist.into()),
-        );
-    });
-}
-
-#[test]
-// test if moderator can archive thread
-fn update_thread_archival_status_moderator() {
-    let moderators = [FORUM_MODERATOR_ORIGIN_ID];
-    let origins = [FORUM_MODERATOR_ORIGIN];
-
-    let forum_lead = FORUM_LEAD_ORIGIN_ID;
-    let origin = OriginType::Signed(forum_lead);
-    let initial_balance = 10_000_000;
-    with_test_externalities(|| {
-        balances::Module::<Runtime>::make_free_balance_be(&forum_lead, initial_balance);
-
-        let category_id = create_category_mock(
-            origin.clone(),
-            None,
-            good_category_title(),
-            good_category_description(),
-            Ok(()),
-        );
-        let thread_id = create_thread_mock(
-            origin.clone(),
-            forum_lead,
-            forum_lead,
-            category_id,
-            good_thread_title(),
-            good_thread_text(),
-            None,
-            Ok(()),
-        );
-
-        // unprivileged moderator will fail to update category
-        update_thread_archival_status_mock(
-            origins[0].clone(),
-            PrivilegedActor::Moderator(moderators[0]),
-            category_id,
-            thread_id,
-            true,
-            Err(Error::<Runtime>::ModeratorCantUpdateCategory.into()),
-        );
-
-        // give permision to moderate category itself
-        update_category_membership_of_moderator_mock(
-            origin.clone(),
-            moderators[0],
-            category_id,
-            true,
-            Ok(()),
-        );
-
-        // moderator associated with category will succeed
-        update_thread_archival_status_mock(
-            origins[0].clone(),
-            PrivilegedActor::Moderator(moderators[0]),
-            category_id,
-            thread_id,
-            true,
-            Ok(()),
-        );
-    });
-}
-
-#[test]
-// test if moderator can archive thread
-fn update_thread_archival_status_lock_works() {
-    let forum_lead = FORUM_LEAD_ORIGIN_ID;
-    let origin = OriginType::Signed(forum_lead);
-    let initial_balance = 10_000_000;
-    with_test_externalities(|| {
-        balances::Module::<Runtime>::make_free_balance_be(&forum_lead, initial_balance);
-
-        let category_id = create_category_mock(
-            origin.clone(),
-            None,
-            good_category_title(),
-            good_category_description(),
-            Ok(()),
-        );
-
-        let thread_id = create_thread_mock(
-            origin.clone(),
-            forum_lead,
-            forum_lead,
-            category_id,
-            good_thread_title(),
-            good_thread_text(),
-            None,
-            Ok(()),
-        );
-
-        let post_id = create_post_mock(
-            origin.clone(),
-            forum_lead,
-            forum_lead,
-            category_id,
-            thread_id,
-            good_post_text(),
-            true,
-            Ok(()),
-        );
-
-        update_thread_archival_status_mock(
-            origin.clone(),
-            PrivilegedActor::Lead,
-            category_id,
-            thread_id,
-            true,
-            Ok(()),
-        );
-
-        // can't add more posts to thread inside category
-        create_post_mock(
-            origin.clone(),
-            forum_lead,
-            forum_lead,
-            category_id,
-            thread_id,
-            good_post_text(),
-            true,
-            Err(Error::<Runtime>::ThreadImmutable.into()),
-        );
-
-        // can't update post
-        edit_post_text_mock(
-            origin.clone(),
-            forum_lead,
-            category_id,
-            thread_id,
-            post_id,
-            good_post_new_text(),
-            Err(Error::<Runtime>::ThreadImmutable.into()),
-        );
-
-        // can't update thread
-        edit_thread_title_mock(
-            origin.clone(),
-            forum_lead,
-            category_id,
-            thread_id,
-            good_thread_new_title(),
-            Err(Error::<Runtime>::ThreadImmutable.into()),
-        );
-    });
-}
 
 #[test]
 // test if thread creator can delete thread

runtime/src/weights/forum.rs

@@ -9,172 +9,156 @@ pub struct WeightInfo;
 impl forum::WeightInfo for WeightInfo {
     fn create_category(i: u32, j: u32, k: u32) -> Weight {
         (0 as Weight)
-            .saturating_add((214_529_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((98_000 as Weight).saturating_mul(j as Weight))
-            .saturating_add((134_000 as Weight).saturating_mul(k as Weight))
+            .saturating_add((244_424_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((108_000 as Weight).saturating_mul(j as Weight))
+            .saturating_add((149_000 as Weight).saturating_mul(k as Weight))
             .saturating_add(DbWeight::get().reads(5 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(3 as Weight))
     }
     fn update_category_membership_of_moderator_new() -> Weight {
-        (297_135_000 as Weight)
+        (318_667_000 as Weight)
             .saturating_add(DbWeight::get().reads(4 as Weight))
             .saturating_add(DbWeight::get().writes(2 as Weight))
     }
     fn update_category_membership_of_moderator_old() -> Weight {
-        (315_520_000 as Weight)
+        (340_448_000 as Weight)
             .saturating_add(DbWeight::get().reads(5 as Weight))
             .saturating_add(DbWeight::get().writes(2 as Weight))
     }
     fn update_category_archival_status_lead(i: u32) -> Weight {
-        (177_097_000 as Weight)
-            .saturating_add((57_774_000 as Weight).saturating_mul(i as Weight))
+        (191_321_000 as Weight)
+            .saturating_add((62_117_000 as Weight).saturating_mul(i as Weight))
             .saturating_add(DbWeight::get().reads(3 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(1 as Weight))
     }
     fn update_category_archival_status_moderator(i: u32) -> Weight {
-        (195_602_000 as Weight)
-            .saturating_add((57_023_000 as Weight).saturating_mul(i as Weight))
+        (213_940_000 as Weight)
+            .saturating_add((58_413_000 as Weight).saturating_mul(i as Weight))
             .saturating_add(DbWeight::get().reads(3 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(1 as Weight))
     }
     fn delete_category_lead(i: u32) -> Weight {
-        (142_929_000 as Weight)
-            .saturating_add((68_133_000 as Weight).saturating_mul(i as Weight))
+        (152_811_000 as Weight)
+            .saturating_add((70_445_000 as Weight).saturating_mul(i as Weight))
             .saturating_add(DbWeight::get().reads(4 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(2 as Weight))
     }
     fn delete_category_moderator(i: u32) -> Weight {
-        (184_678_000 as Weight)
-            .saturating_add((63_220_000 as Weight).saturating_mul(i as Weight))
+        (168_140_000 as Weight)
+            .saturating_add((72_252_000 as Weight).saturating_mul(i as Weight))
             .saturating_add(DbWeight::get().reads(3 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(3 as Weight))
     }
     // WARNING! Some components were not used: ["z"]
     fn create_thread(j: u32, k: u32, i: u32) -> Weight {
-        (1_763_250_000 as Weight)
-            .saturating_add((122_000 as Weight).saturating_mul(j as Weight))
-            .saturating_add((171_000 as Weight).saturating_mul(k as Weight))
+        (1_988_301_000 as Weight)
+            .saturating_add((144_000 as Weight).saturating_mul(j as Weight))
+            .saturating_add((190_000 as Weight).saturating_mul(k as Weight))
             .saturating_add(DbWeight::get().reads(7 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(7 as Weight))
     }
     fn edit_thread_title(i: u32, j: u32) -> Weight {
-        (161_572_000 as Weight)
-            .saturating_add((72_014_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((127_000 as Weight).saturating_mul(j as Weight))
+        (249_076_000 as Weight)
+            .saturating_add((65_112_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((145_000 as Weight).saturating_mul(j as Weight))
             .saturating_add(DbWeight::get().reads(3 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(1 as Weight))
     }
-    fn update_thread_archival_status_lead(i: u32) -> Weight {
-        (212_838_000 as Weight)
-            .saturating_add((116_257_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add(DbWeight::get().reads(4 as Weight))
-            .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
-            .saturating_add(DbWeight::get().writes(1 as Weight))
-    }
-    fn update_thread_archival_status_moderator(i: u32) -> Weight {
-        (237_385_000 as Weight)
-            .saturating_add((114_127_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add(DbWeight::get().reads(4 as Weight))
-            .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
-            .saturating_add(DbWeight::get().writes(1 as Weight))
-    }
     fn delete_thread(i: u32) -> Weight {
-        (592_486_000 as Weight)
-            .saturating_add((57_770_000 as Weight).saturating_mul(i as Weight))
+        (745_492_000 as Weight)
+            .saturating_add((61_494_000 as Weight).saturating_mul(i as Weight))
             .saturating_add(DbWeight::get().reads(5 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
-            .saturating_add(DbWeight::get().writes(4 as Weight))
+            .saturating_add(DbWeight::get().writes(102 as Weight))
     }
     fn move_thread_to_category_lead(i: u32) -> Weight {
-        (365_000_000 as Weight)
-            .saturating_add((100_941_000 as Weight).saturating_mul(i as Weight))
+        (392_377_000 as Weight)
+            .saturating_add((107_424_000 as Weight).saturating_mul(i as Weight))
             .saturating_add(DbWeight::get().reads(5 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(4 as Weight))
     }
     fn move_thread_to_category_moderator(i: u32) -> Weight {
-        (400_012_000 as Weight)
-            .saturating_add((101_980_000 as Weight).saturating_mul(i as Weight))
+        (429_980_000 as Weight)
+            .saturating_add((107_333_000 as Weight).saturating_mul(i as Weight))
             .saturating_add(DbWeight::get().reads(6 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(4 as Weight))
     }
     fn vote_on_poll(i: u32, j: u32) -> Weight {
-        (311_689_000 as Weight)
-            .saturating_add((57_977_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((18_453_000 as Weight).saturating_mul(j as Weight))
-            .saturating_add(DbWeight::get().reads(4 as Weight))
+        (331_092_000 as Weight)
+            .saturating_add((64_865_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((20_909_000 as Weight).saturating_mul(j as Weight))
+            .saturating_add(DbWeight::get().reads(5 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
-            .saturating_add(DbWeight::get().writes(1 as Weight))
+            .saturating_add(DbWeight::get().writes(2 as Weight))
     }
-    // WARNING! Some components were not used: ["j"]
     fn moderate_thread_lead(i: u32, k: u32) -> Weight {
-        (533_448_000 as Weight)
-            .saturating_add((57_859_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((129_000 as Weight).saturating_mul(k as Weight))
+        (570_691_000 as Weight)
+            .saturating_add((63_690_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((142_000 as Weight).saturating_mul(k as Weight))
             .saturating_add(DbWeight::get().reads(5 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(3 as Weight))
     }
-    fn moderate_thread_moderator(i: u32, j: u32, k: u32) -> Weight {
-        (343_909_000 as Weight)
-            .saturating_add((63_466_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((6_334_000 as Weight).saturating_mul(j as Weight))
-            .saturating_add((131_000 as Weight).saturating_mul(k as Weight))
+    fn moderate_thread_moderator(i: u32, k: u32) -> Weight {
+        (555_260_000 as Weight)
+            .saturating_add((65_443_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((143_000 as Weight).saturating_mul(k as Weight))
             .saturating_add(DbWeight::get().reads(5 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(3 as Weight))
     }
     fn add_post(i: u32, j: u32) -> Weight {
-        (584_267_000 as Weight)
-            .saturating_add((54_076_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((128_000 as Weight).saturating_mul(j as Weight))
+        (628_419_000 as Weight)
+            .saturating_add((59_569_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((145_000 as Weight).saturating_mul(j as Weight))
             .saturating_add(DbWeight::get().reads(6 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(5 as Weight))
     }
     fn react_post(i: u32) -> Weight {
-        (299_480_000 as Weight)
-            .saturating_add((57_223_000 as Weight).saturating_mul(i as Weight))
+        (330_603_000 as Weight)
+            .saturating_add((61_553_000 as Weight).saturating_mul(i as Weight))
             .saturating_add(DbWeight::get().reads(3 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
     }
     fn edit_post_text(i: u32, j: u32) -> Weight {
-        (387_494_000 as Weight)
-            .saturating_add((70_340_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((126_000 as Weight).saturating_mul(j as Weight))
+        (477_603_000 as Weight)
+            .saturating_add((63_656_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((145_000 as Weight).saturating_mul(j as Weight))
             .saturating_add(DbWeight::get().reads(4 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(1 as Weight))
     }
     fn moderate_post_lead(i: u32, j: u32) -> Weight {
-        (1_094_423_000 as Weight)
-            .saturating_add((103_781_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((121_000 as Weight).saturating_mul(j as Weight))
+        (1_061_737_000 as Weight)
+            .saturating_add((125_999_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((142_000 as Weight).saturating_mul(j as Weight))
             .saturating_add(DbWeight::get().reads(6 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(3 as Weight))
     }
     fn moderate_post_moderator(i: u32, j: u32) -> Weight {
-        (863_056_000 as Weight)
-            .saturating_add((134_282_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((126_000 as Weight).saturating_mul(j as Weight))
+        (992_903_000 as Weight)
+            .saturating_add((134_194_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((145_000 as Weight).saturating_mul(j as Weight))
             .saturating_add(DbWeight::get().reads(6 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().writes(3 as Weight))
     }
     fn delete_posts(i: u32, j: u32, k: u32) -> Weight {
         (0 as Weight)
-            .saturating_add((1_007_340_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((113_000 as Weight).saturating_mul(j as Weight))
-            .saturating_add((1_418_940_000 as Weight).saturating_mul(k as Weight))
+            .saturating_add((30_679_118_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((27_000 as Weight).saturating_mul(j as Weight))
+            .saturating_add((1_545_369_000 as Weight).saturating_mul(k as Weight))
             .saturating_add(DbWeight::get().reads(5 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(k as Weight)))
@@ -182,18 +166,18 @@ impl forum::WeightInfo for WeightInfo {
             .saturating_add(DbWeight::get().writes((1 as Weight).saturating_mul(k as Weight)))
     }
     fn set_stickied_threads_lead(i: u32, j: u32) -> Weight {
-        (219_049_000 as Weight)
-            .saturating_add((59_817_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((204_099_000 as Weight).saturating_mul(j as Weight))
+        (0 as Weight)
+            .saturating_add((103_175_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((232_740_000 as Weight).saturating_mul(j as Weight))
             .saturating_add(DbWeight::get().reads(3 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(j as Weight)))
             .saturating_add(DbWeight::get().writes(1 as Weight))
     }
     fn set_stickied_threads_moderator(i: u32, j: u32) -> Weight {
-        (281_825_000 as Weight)
-            .saturating_add((47_851_000 as Weight).saturating_mul(i as Weight))
-            .saturating_add((203_487_000 as Weight).saturating_mul(j as Weight))
+        (20_591_000 as Weight)
+            .saturating_add((72_609_000 as Weight).saturating_mul(i as Weight))
+            .saturating_add((233_007_000 as Weight).saturating_mul(j as Weight))
             .saturating_add(DbWeight::get().reads(3 as Weight))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(i as Weight)))
             .saturating_add(DbWeight::get().reads((1 as Weight).saturating_mul(j as Weight)))