Merge branch 'content_directory_second_try' into update_class_permissions_extrinsic_fix

runtime-modules/content-directory/src/entity.rs

@@ -146,7 +146,7 @@ impl<
             // by an in-class index of a property.
             .ok_or(Error::<T>::UnknownEntityPropertyId)?
             .as_vec_property_value()
-            .map(|property_value_vec| property_value_vec.clone())
+            .cloned()
             // Ensure prop value under given class schema property id is vector
             .ok_or(Error::<T>::PropertyValueUnderGivenIndexIsNotAVector)
     }

runtime-modules/content-directory/src/helpers.rs

@@ -78,15 +78,12 @@ impl<'a, T: Trait> InputValuesForExistingProperties<'a, T> {
 /// Wrapper for existing `StoredPropertyValue` and its respective `Class` `Property`
 pub struct StoredValueForExistingProperty<'a, T: Trait>(
     &'a Property<T::ClassId>,
-    &'a StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
+    &'a StoredPropertyValueOf<T>,
 );
 
 impl<'a, T: Trait> StoredValueForExistingProperty<'a, T> {
     /// Create single instance of `StoredValueForExistingProperty` from provided `property` and `value`
-    pub fn new(
-        property: &'a Property<T::ClassId>,
-        value: &'a StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-    ) -> Self {
+    pub fn new(property: &'a Property<T::ClassId>, value: &'a StoredPropertyValueOf<T>) -> Self {
         Self(property, value)
     }
 
@@ -96,17 +93,12 @@ impl<'a, T: Trait> StoredValueForExistingProperty<'a, T> {
     }
 
     /// Retrieve `StoredPropertyValue` reference
-    pub fn get_value(&self) -> &StoredPropertyValue<T::Hash, T::EntityId, T::Nonce> {
+    pub fn get_value(&self) -> &StoredPropertyValueOf<T> {
         self.1
     }
 
     /// Retrieve `Property` and `StoredPropertyValue` references
-    pub fn unzip(
-        &self,
-    ) -> (
-        &Property<T::ClassId>,
-        &StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-    ) {
+    pub fn unzip(&self) -> (&Property<T::ClassId>, &StoredPropertyValueOf<T>) {
         (self.0, self.1)
     }
 
@@ -147,10 +139,7 @@ impl<'a, T: Trait> StoredValuesForExistingProperties<'a, T> {
     /// Create `StoredValuesForExistingProperties` helper structure from provided `property_values` and their corresponding `Class` properties.
     pub fn from(
         properties: &'a [Property<T::ClassId>],
-        property_values: &'a BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
+        property_values: &'a BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
     ) -> Result<Self, Error<T>> {
         let mut values_for_existing_properties = StoredValuesForExistingProperties::<T>::default();
 

runtime-modules/content-directory/src/lib.rs

@@ -161,6 +161,23 @@ use core::debug_assert;
 /// Type, used in diffrent numeric constraints representations
 pub type MaxNumber = u32;
 
+/// Type simplification
+pub type EntityOf<T> = Entity<
+    <T as Trait>::ClassId,
+    <T as ActorAuthenticator>::MemberId,
+    <T as system::Trait>::Hash,
+    <T as Trait>::EntityId,
+    <T as Trait>::Nonce,
+>;
+
+/// Type simplification
+pub type ClassOf<T> =
+    Class<<T as Trait>::EntityId, <T as Trait>::ClassId, <T as ActorAuthenticator>::CuratorGroupId>;
+
+/// Type simplification
+pub type StoredPropertyValueOf<T> =
+    StoredPropertyValue<<T as system::Trait>::Hash, <T as Trait>::EntityId, <T as Trait>::Nonce>;
+
 /// Module configuration trait for this Substrate module.
 pub trait Trait: system::Trait + ActorAuthenticator + Clone {
     /// The overarching event type.
@@ -260,10 +277,10 @@ decl_storage! {
     trait Store for Module<T: Trait> as ContentDirectory {
 
         /// Map, representing ClassId -> Class relation
-        pub ClassById get(fn class_by_id) config(): map hasher(blake2_128_concat) T::ClassId => Class<T::EntityId, T::ClassId, T::CuratorGroupId>;
+        pub ClassById get(fn class_by_id) config(): map hasher(blake2_128_concat) T::ClassId => ClassOf<T>;
 
         /// Map, representing EntityId -> Entity relation
-        pub EntityById get(fn entity_by_id) config(): map hasher(blake2_128_concat) T::EntityId => Entity<T::ClassId, T::MemberId, T::Hash, T::EntityId, T::Nonce>;
+        pub EntityById get(fn entity_by_id) config(): map hasher(blake2_128_concat) T::EntityId => EntityOf<T>;
 
         /// Map, representing  CuratorGroupId -> CuratorGroup relation
         pub CuratorGroupById get(fn curator_group_by_id) config(): map hasher(blake2_128_concat) T::CuratorGroupId => CuratorGroup<T>;
@@ -1616,7 +1633,6 @@ decl_module! {
 
             for (index, operation_type) in operations.into_iter().enumerate() {
                 let origin = T::Origin::from(raw_origin.clone());
-                let actor = actor.clone();
                 match operation_type {
                     OperationType::CreateEntity(create_entity_operation) => {
                         Self::create_entity(origin, create_entity_operation.class_id, actor)?;
@@ -1752,7 +1768,7 @@ impl<T: Trait> Module<T> {
     /// Convert all provided `InputPropertyValue`'s into `StoredPropertyValue`'s
     pub fn make_output_property_values(
         input_property_values: BTreeMap<PropertyId, InputPropertyValue<T>>,
-    ) -> BTreeMap<PropertyId, StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>> {
+    ) -> BTreeMap<PropertyId, StoredPropertyValueOf<T>> {
         input_property_values
             .into_iter()
             .map(|(property_id, property_value)| (property_id, property_value.into()))
@@ -1763,29 +1779,18 @@ impl<T: Trait> Module<T> {
     /// Returns updated `entity_property_values`
     fn make_updated_entity_property_values(
         schema: Schema,
-        entity_property_values: BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
-        output_property_values: &BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
-    ) -> BTreeMap<PropertyId, StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>> {
+        entity_property_values: BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
+        output_property_values: &BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
+    ) -> BTreeMap<PropertyId, StoredPropertyValueOf<T>> {
         // Concatenate existing `entity_property_values` with `property_values`, provided, when adding `Schema` support.
-        let updated_entity_property_values: BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        > = entity_property_values
-            .into_iter()
-            .chain(output_property_values.to_owned().into_iter())
-            .collect();
+        let updated_entity_property_values: BTreeMap<PropertyId, StoredPropertyValueOf<T>> =
+            entity_property_values
+                .into_iter()
+                .chain(output_property_values.to_owned().into_iter())
+                .collect();
 
         // Write all missing non required `Schema` `property_values` as `InputPropertyValue::default()`
-        let non_required_property_values: BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        > = schema
+        let non_required_property_values: BTreeMap<PropertyId, StoredPropertyValueOf<T>> = schema
             .get_properties()
             .iter()
             .filter_map(|property_id| {
@@ -1921,23 +1926,15 @@ impl<T: Trait> Module<T> {
     pub fn get_updated_inbound_rcs_delta(
         current_entity_id: T::EntityId,
         class_properties: Vec<Property<T::ClassId>>,
-        entity_property_values: BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
-        new_output_property_values: BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
+        entity_property_values: BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
+        new_output_property_values: BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
     ) -> Result<Option<ReferenceCounterSideEffects<T>>, Error<T>> {
         // Filter entity_property_values to get only those, which will be substituted with new_property_values
-        let entity_property_values_to_update: BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        > = entity_property_values
-            .into_iter()
-            .filter(|(entity_id, _)| new_output_property_values.contains_key(entity_id))
-            .collect();
+        let entity_property_values_to_update: BTreeMap<PropertyId, StoredPropertyValueOf<T>> =
+            entity_property_values
+                .into_iter()
+                .filter(|(entity_id, _)| new_output_property_values.contains_key(entity_id))
+                .collect();
 
         // Calculate entities reference counter side effects for update operation
 
@@ -2110,7 +2107,7 @@ impl<T: Trait> Module<T> {
     pub fn ensure_vec_property_value_hashes(
         class_id: T::ClassId,
         in_class_schema_property_id: PropertyId,
-        property_value_vector_updated: &StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
+        property_value_vector_updated: &StoredPropertyValueOf<T>,
         property_value_vector: VecStoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
     ) -> Result<(T::Hash, T::Hash), Error<T>> {
         // Compute new hash from unique property value and its respective property id
@@ -2150,9 +2147,7 @@ impl<T: Trait> Module<T> {
     }
 
     /// Returns the stored `Class` if exist, error otherwise.
-    fn ensure_class_exists(
-        class_id: T::ClassId,
-    ) -> Result<Class<T::EntityId, T::ClassId, T::CuratorGroupId>, Error<T>> {
+    fn ensure_class_exists(class_id: T::ClassId) -> Result<ClassOf<T>, Error<T>> {
         ensure!(
             <ClassById<T>>::contains_key(class_id),
             Error::<T>::ClassNotFound
@@ -2165,14 +2160,7 @@ impl<T: Trait> Module<T> {
         account_id: T::AccountId,
         entity_id: T::EntityId,
         actor: &Actor<T::CuratorGroupId, T::CuratorId, T::MemberId>,
-    ) -> Result<
-        (
-            Class<T::EntityId, T::ClassId, T::CuratorGroupId>,
-            Entity<T::ClassId, T::MemberId, T::Hash, T::EntityId, T::Nonce>,
-            EntityAccessLevel,
-        ),
-        Error<T>,
-    > {
+    ) -> Result<(ClassOf<T>, EntityOf<T>, EntityAccessLevel), Error<T>> {
         // Ensure Entity under given id exists, retrieve corresponding one
         let entity = Self::ensure_known_entity_id(entity_id)?;
 
@@ -2193,13 +2181,7 @@ impl<T: Trait> Module<T> {
     /// Ensure `Entity` under given `entity_id` exists, retrieve corresponding `Entity` & `Class`
     pub fn ensure_known_entity_and_class(
         entity_id: T::EntityId,
-    ) -> Result<
-        (
-            Entity<T::ClassId, T::MemberId, T::Hash, T::EntityId, T::Nonce>,
-            Class<T::EntityId, T::ClassId, T::CuratorGroupId>,
-        ),
-        Error<T>,
-    > {
+    ) -> Result<(EntityOf<T>, ClassOf<T>), Error<T>> {
         // Ensure Entity under given id exists, retrieve corresponding one
         let entity = Self::ensure_known_entity_id(entity_id)?;
 
@@ -2313,15 +2295,12 @@ impl<T: Trait> Module<T> {
     /// Returns updated `entity_property_values`, if update performed
     pub fn make_updated_property_value_references_with_same_owner_flag_set(
         unused_property_id_references_with_same_owner_flag_set: BTreeSet<PropertyId>,
-        entity_property_values: &BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
+        entity_property_values: &BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
         new_property_value_references_with_same_owner_flag_set: &BTreeMap<
             PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
+            StoredPropertyValueOf<T>,
         >,
-    ) -> Option<BTreeMap<PropertyId, StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>>> {
+    ) -> Option<BTreeMap<PropertyId, StoredPropertyValueOf<T>>> {
         // Used to check if update performed
         let mut entity_property_values_updated = entity_property_values.clone();
 
@@ -2378,11 +2357,8 @@ impl<T: Trait> Module<T> {
 
     /// Used to compute old unique hashes, that should be substituted with new ones.
     pub fn compute_old_unique_hashes(
-        new_output_property_values: &BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
-        entity_values: &BTreeMap<PropertyId, StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>>,
+        new_output_property_values: &BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
+        entity_values: &BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
     ) -> BTreeMap<PropertyId, T::Hash> {
         entity_values
             .iter()
@@ -2437,10 +2413,7 @@ impl<T: Trait> Module<T> {
 
     /// Ensure all provided `new_property_values` are already exist in `entity_property_values` map
     pub fn ensure_all_property_values_are_already_added(
-        entity_property_values: &BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
+        entity_property_values: &BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
         new_property_values: &BTreeMap<PropertyId, InputPropertyValue<T>>,
     ) -> Result<(), Error<T>> {
         ensure!(
@@ -2469,10 +2442,7 @@ impl<T: Trait> Module<T> {
     /// Filter `new_property_values` identical to `entity_property_values`.
     /// Return only `new_property_values`, that are not in `entity_property_values`
     pub fn try_filter_identical_property_values(
-        entity_property_values: &BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
+        entity_property_values: &BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
         new_property_values: BTreeMap<PropertyId, InputPropertyValue<T>>,
     ) -> BTreeMap<PropertyId, InputPropertyValue<T>> {
         new_property_values
@@ -2492,15 +2462,9 @@ impl<T: Trait> Module<T> {
     /// Update existing `entity_property_values` with `new_property_values`.
     /// if update performed, returns updated entity property values
     pub fn make_updated_property_values(
-        entity_property_values: &BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
-        new_output_property_values: &BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
-    ) -> Option<BTreeMap<PropertyId, StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>>> {
+        entity_property_values: &BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
+        new_output_property_values: &BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
+    ) -> Option<BTreeMap<PropertyId, StoredPropertyValueOf<T>>> {
         // Used to check if updated performed
         let mut entity_property_values_updated = entity_property_values.to_owned();
 
@@ -2525,7 +2489,7 @@ impl<T: Trait> Module<T> {
         mut property_value_vector: VecStoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
         index_in_property_vector: VecMaxLength,
         value: InputValue<T>,
-    ) -> StoredPropertyValue<T::Hash, T::EntityId, T::Nonce> {
+    ) -> StoredPropertyValueOf<T> {
         property_value_vector.insert_at(index_in_property_vector, value.into());
         StoredPropertyValue::Vector(property_value_vector)
     }
@@ -2535,7 +2499,7 @@ impl<T: Trait> Module<T> {
     pub fn remove_at_index_in_property_vector(
         mut property_value_vector: VecStoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
         index_in_property_vector: VecMaxLength,
-    ) -> StoredPropertyValue<T::Hash, T::EntityId, T::Nonce> {
+    ) -> StoredPropertyValueOf<T> {
         property_value_vector.remove_at(index_in_property_vector);
         StoredPropertyValue::Vector(property_value_vector)
     }
@@ -2544,7 +2508,7 @@ impl<T: Trait> Module<T> {
     /// Returns empty `VecStoredPropertyValue` wrapped in `StoredPropertyValue`
     pub fn clear_property_vector(
         mut property_value_vector: VecStoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-    ) -> StoredPropertyValue<T::Hash, T::EntityId, T::Nonce> {
+    ) -> StoredPropertyValueOf<T> {
         property_value_vector.clear();
         StoredPropertyValue::Vector(property_value_vector)
     }
@@ -2552,21 +2516,16 @@ impl<T: Trait> Module<T> {
     /// Insert `InputPropertyValue` into `entity_property_values` mapping at `in_class_schema_property_id`.
     /// Returns updated `entity_property_values`
     pub fn insert_at_in_class_schema_property_id(
-        mut entity_property_values: BTreeMap<
-            PropertyId,
-            StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-        >,
+        mut entity_property_values: BTreeMap<PropertyId, StoredPropertyValueOf<T>>,
         in_class_schema_property_id: PropertyId,
-        property_value: StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>,
-    ) -> BTreeMap<PropertyId, StoredPropertyValue<T::Hash, T::EntityId, T::Nonce>> {
+        property_value: StoredPropertyValueOf<T>,
+    ) -> BTreeMap<PropertyId, StoredPropertyValueOf<T>> {
         entity_property_values.insert(in_class_schema_property_id, property_value);
         entity_property_values
     }
 
     /// Ensure `Class` under given id exists, return corresponding one
-    pub fn ensure_known_class_id(
-        class_id: T::ClassId,
-    ) -> Result<Class<T::EntityId, T::ClassId, T::CuratorGroupId>, Error<T>> {
+    pub fn ensure_known_class_id(class_id: T::ClassId) -> Result<ClassOf<T>, Error<T>> {
         ensure!(
             <ClassById<T>>::contains_key(class_id),
             Error::<T>::ClassNotFound
@@ -2575,9 +2534,7 @@ impl<T: Trait> Module<T> {
     }
 
     /// Ensure `Entity` under given id exists, return corresponding one
-    pub fn ensure_known_entity_id(
-        entity_id: T::EntityId,
-    ) -> Result<Entity<T::ClassId, T::MemberId, T::Hash, T::EntityId, T::Nonce>, Error<T>> {
+    pub fn ensure_known_entity_id(entity_id: T::EntityId) -> Result<EntityOf<T>, Error<T>> {
         ensure!(
             <EntityById<T>>::contains_key(entity_id),
             Error::<T>::EntityNotFound

runtime-modules/content-directory/src/schema/convert.rs

@@ -1,7 +1,7 @@
 use super::*;
 use sp_runtime::traits::Hash;
 
-impl<T: Trait> From<InputPropertyValue<T>> for StoredPropertyValue<T::Hash, T::EntityId, T::Nonce> {
+impl<T: Trait> From<InputPropertyValue<T>> for StoredPropertyValueOf<T> {
     fn from(input_property_value: InputPropertyValue<T>) -> Self {
         match input_property_value {
             InputPropertyValue::Single(input_value) => {

runtime-modules/content-directory/src/schema/property.rs

@@ -471,7 +471,7 @@ impl<ClassId: Default + BaseArithmetic + Clone + Copy> Property<ClassId> {
             (
                 InputPropertyValue::Single(single_property_value),
                 PropertyType::Single(ref single_property_type),
-            ) => match (single_property_value, single_property_type.deref()) {
+            ) => matches!((single_property_value, single_property_type.deref()),
                 (InputValue::Bool(_), Type::Bool)
                 | (InputValue::Uint16(_), Type::Uint16)
                 | (InputValue::Uint32(_), Type::Uint32)
@@ -481,13 +481,11 @@ impl<ClassId: Default + BaseArithmetic + Clone + Copy> Property<ClassId> {
                 | (InputValue::Int64(_), Type::Int64)
                 | (InputValue::Text(_), Type::Text(_))
                 | (InputValue::TextToHash(_), Type::Hash(_))
-                | (InputValue::Reference(_), Type::Reference(_, _)) => true,
-                _ => false,
-            },
+                | (InputValue::Reference(_), Type::Reference(_, _))),
             (
                 InputPropertyValue::Vector(vec_value),
                 PropertyType::Vector(ref vec_property_type),
-            ) => match (vec_value, vec_property_type.get_vec_type()) {
+            ) => matches!((vec_value, vec_property_type.get_vec_type()),
                 (VecInputValue::Bool(_), Type::Bool)
                 | (VecInputValue::Uint16(_), Type::Uint16)
                 | (VecInputValue::Uint32(_), Type::Uint32)
@@ -497,9 +495,7 @@ impl<ClassId: Default + BaseArithmetic + Clone + Copy> Property<ClassId> {
                 | (VecInputValue::Int64(_), Type::Int64)
                 | (VecInputValue::Text(_), Type::Text(_))
                 | (VecInputValue::TextToHash(_), Type::Hash(_))
-                | (VecInputValue::Reference(_), Type::Reference(_, _)) => true,
-                _ => false,
-            },
+                | (VecInputValue::Reference(_), Type::Reference(_, _))),
             _ => false,
         }
     }
@@ -569,7 +565,7 @@ impl<ClassId: Default + BaseArithmetic + Clone + Copy> Property<ClassId> {
     pub fn ensure_referenced_entity_match_its_class<T: Trait>(
         entity_id: T::EntityId,
         class_id: T::ClassId,
-    ) -> Result<Entity<T::ClassId, T::MemberId, T::Hash, T::EntityId, T::Nonce>, Error<T>> {
+    ) -> Result<EntityOf<T>, Error<T>> {
         // Ensure Entity under given id exists
         let entity = Module::<T>::ensure_known_entity_id(entity_id)?;
 
@@ -582,7 +578,7 @@ impl<ClassId: Default + BaseArithmetic + Clone + Copy> Property<ClassId> {
 
     /// Ensure `Entity` can be referenced.
     pub fn ensure_entity_can_be_referenced<T: Trait>(
-        entity: Entity<T::ClassId, T::MemberId, T::Hash, T::EntityId, T::Nonce>,
+        entity: EntityOf<T>,
         same_controller_status: bool,
         current_entity_controller: &EntityController<T::MemberId>,
     ) -> Result<(), Error<T>> {