add member through screener

src/membership/mock.rs

@@ -21,7 +21,7 @@ impl_outer_origin! {
 // For testing the module, we construct most of a mock runtime. This means
 // first constructing a configuration type (`Test`) which `impl`s each of the
 // configuration traits of modules we want to use.
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Clone, Eq, PartialEq, Debug)]
 pub struct Test;
 impl system::Trait for Test {
     type Origin = Origin;

src/membership/registry.rs

@@ -68,7 +68,7 @@ struct CheckedUserInfo {
 }
 
 //#[cfg_attr(feature = "std", derive(Serialize, Deserialize, Debug))]
-#[derive(Encode, Decode)]
+#[derive(Encode, Decode, Debug, PartialEq)]
 pub enum EntryMethod<T: Trait> {
     Paid(T::PaidTermId),
     Screening(T::AccountId),
@@ -138,6 +138,8 @@ decl_storage! {
         /// Is the platform is accepting new members or not
         pub NewMembershipsAllowed get(new_memberships_allowed) : bool = true;
 
+        pub ScreeningAuthority get(screening_authority) : Option<T::AccountId>;
+
         // User Input Validation parameters - do these really need to be state variables
         // I don't see a need to adjust these in future?
         pub MinHandleLength get(min_handle_length) : u32 = DEFAULT_MIN_HANDLE_LENGTH;
@@ -250,6 +252,37 @@ decl_module! {
                 Self::_change_member_handle(member_id, handle)?;
             }
         }
+
+        pub fn add_screened_member(origin, new_member: T::AccountId, user_info: UserInfo) {
+            // ensure sender is screening authority
+            let sender = ensure_signed(origin)?;
+
+            if let Some(screening_authority) = Self::screening_authority() {
+                ensure!(sender == screening_authority, "not screener");
+            } else {
+                // no screening authority defined. Cannot accept this request
+                return Err("no screening authority defined");
+            }
+
+            // make sure we are accepting new memberships
+            ensure!(Self::new_memberships_allowed(), "new members not allowed");
+
+            // ensure key not associated with an existing membership
+            Self::ensure_not_member(&new_member)?;
+
+            let user_info = Self::check_user_registration_info(user_info)?;
+
+            // ensure handle is not already registered
+            Self::ensure_unique_handle(&user_info.handle)?;
+
+            let member_id = Self::insert_new_screened_member(sender, &new_member, &user_info);
+
+            Self::deposit_event(RawEvent::MemberRegistered(member_id, new_member.clone()));
+        }
+
+        pub fn set_screening_authority(authority: T::AccountId) {
+            <ScreeningAuthority<T>>::put(authority);
+        }
     }
 }
 
@@ -347,6 +380,30 @@ impl<T: Trait> Module<T> {
         new_member_id
     }
 
+    fn insert_new_screened_member(authority: T::AccountId, who: &T::AccountId, user_info: &CheckedUserInfo) -> T::MemberId {
+        let new_member_id = Self::next_member_id();
+
+        let profile: Profile<T> = Profile {
+            id: new_member_id,
+            handle: user_info.handle.clone(),
+            avatar_uri: user_info.avatar_uri.clone(),
+            about: user_info.about.clone(),
+            registered_at_block: <system::Module<T>>::block_number(),
+            registered_at_time: <timestamp::Module<T>>::now(),
+            entry: EntryMethod::Screening(authority),
+            suspended: false,
+            subscription: None,
+        };
+
+        <MemberIdByAccountId<T>>::insert(who.clone(), new_member_id);
+        <AccountIdByMemberId<T>>::insert(new_member_id, who.clone());
+        <MemberProfile<T>>::insert(new_member_id, profile);
+        <Handles<T>>::insert(user_info.handle.clone(), new_member_id);
+        <NextMemberId<T>>::mutate(|n| { *n += T::MemberId::sa(1); });
+
+        new_member_id
+    }
+
     fn _change_member_about_text (id: T::MemberId, text: &Vec<u8>) -> dispatch::Result {
         let mut profile = Self::ensure_profile(id)?;
         let text = Self::validate_text(text);

src/membership/tests.rs

@@ -184,3 +184,23 @@ fn update_profile() {
     });
 }
 
+#[test]
+fn add_screened_member() {
+    with_externalities(&mut ExtBuilder::default().build(), ||
+    {
+        let screening_authority = 5;
+        <registry::ScreeningAuthority<Test>>::put(&screening_authority);
+
+        assert_ok!(Membership::add_screened_member(Origin::signed(screening_authority), ALICE_ACCOUNT_ID, get_alice_info()));
+
+        let member_id = assert_ok_unwrap(Membership::member_id_by_account_id(&ALICE_ACCOUNT_ID), "member id not assigned");
+
+        let profile = assert_ok_unwrap(Membership::member_profile(&member_id), "member profile created");
+
+        assert_eq!(Some(profile.handle), get_alice_info().handle);
+        assert_eq!(Some(profile.avatar_uri), get_alice_info().avatar_uri);
+        assert_eq!(Some(profile.about), get_alice_info().about);
+        assert_eq!(registry::EntryMethod::Screening(screening_authority), profile.entry);
+
+    });
+}