support staff only group import

Author: fiji-flo

scripts/upload.sh

@@ -1,3 +1,4 @@
 #!/bin/bash
 HOST=${HOST:-localhost:8085}
-curl -v -F "group=@/tmp/$1/g.tsv" -F "memberships=@/tmp/$1/m.tsv" -F "curators=@/tmp/$1/c.tsv" http://$HOST/import/group/full
+STAFF_ONLY=${2:-false}
+curl -v -F "group=@/tmp/$1/g.tsv" -F "memberships=@/tmp/$1/m.tsv" -F "curators=@/tmp/$1/c.tsv" http://$HOST/import/group/full?staff_only=${STAFF_ONLY}

src/db/internal/member.rs

@@ -409,20 +409,6 @@ pub fn get_memberships_expire_between(
         .map_err(Into::into)
 }
 
-pub fn get_curator_emails(connection: &PgConnection, group_id: i32) -> Result<Vec<String>, Error> {
-    use schema::memberships as m;
-    use schema::profiles as p;
-    use schema::roles as r;
-    m::table
-        .filter(m::group_id.eq(group_id))
-        .inner_join(r::table)
-        .filter(r::typ.eq_any(&[RoleType::Admin, RoleType::Curator]))
-        .inner_join(p::table.on(m::user_uuid.eq(p::user_uuid)))
-        .select(p::email)
-        .get_results::<String>(connection)
-        .map_err(Into::into)
-}
-
 pub fn get_member_emails_by_group_name(
     connection: &PgConnection,
     group_name: &str,
@@ -439,6 +425,20 @@ pub fn get_member_emails_by_group_name(
         .map_err(Into::into)
 }
 
+pub fn get_curator_emails(connection: &PgConnection, group_id: i32) -> Result<Vec<String>, Error> {
+    use schema::memberships as m;
+    use schema::profiles as p;
+    use schema::roles as r;
+    m::table
+        .filter(m::group_id.eq(group_id))
+        .inner_join(r::table.on(r::role_id.eq(m::role_id)))
+        .filter(r::typ.eq_any(&[RoleType::Admin, RoleType::Curator]))
+        .inner_join(p::table.on(m::user_uuid.eq(p::user_uuid)))
+        .select(p::email)
+        .get_results::<String>(connection)
+        .map_err(Into::into)
+}
+
 pub fn get_curator_emails_by_group_name(
     connection: &PgConnection,
     group_name: &str,
@@ -450,7 +450,7 @@ pub fn get_curator_emails_by_group_name(
     g::table
         .filter(g::name.eq(group_name))
         .inner_join(m::table)
-        .inner_join(r::table)
+        .inner_join(r::table.on(r::role_id.eq(m::role_id)))
         .filter(r::typ.eq_any(&[RoleType::Admin, RoleType::Curator]))
         .inner_join(p::table.on(m::user_uuid.eq(p::user_uuid)))
         .select(p::email)

src/db/operations/members.rs

@@ -300,6 +300,8 @@ pub fn get_curator_emails(
         &group_name,
         &user.user_uuid,
     ))?;
+    // let group = internal::group::get_group(&connection, group_name)?;
+    // internal::member::get_curator_emails(&connection, group.id)
 
     internal::member::get_curator_emails_by_group_name(&connection, group_name)
 }

src/import/api.rs

@@ -13,6 +13,7 @@ use csv::ReaderBuilder;
 use futures::StreamExt;
 use futures::TryFutureExt;
 use futures::TryStreamExt;
+use serde::Deserialize;
 use std::sync::Arc;
 
 #[derive(Debug, Default)]
@@ -22,11 +23,18 @@ struct GroupImportOption {
     pub curators: Option<Vec<MozilliansGroupCurator>>,
 }
 
+#[derive(Debug, Deserialize, Default)]
+struct GroupImportQuery {
+    staff_only: bool,
+}
+
 async fn full_group_import<T: AsyncCisClientTrait>(
     mut multipart: Multipart,
     pool: web::Data<Pool>,
     cis_client: web::Data<T>,
+    query: web::Query<GroupImportQuery>,
 ) -> Result<HttpResponse, ApiError> {
+    let GroupImportQuery { staff_only } = query.into_inner();
     let mut group_import = GroupImportOption {
         ..Default::default()
     };
@@ -87,6 +95,7 @@ async fn full_group_import<T: AsyncCisClientTrait>(
                 group,
                 curators,
                 memberships,
+                staff_only,
             };
             import(&pool, group_import, Arc::clone(&*cis_client)).await?
         }

src/import/ops.rs

@@ -41,6 +41,7 @@ pub struct GroupImport {
     pub group: MozilliansGroup,
     pub memberships: Vec<MozilliansGroupMembership>,
     pub curators: Vec<MozilliansGroupCurator>,
+    pub staff_only: bool,
 }
 
 pub fn import_group(connection: &PgConnection, moz_group: MozilliansGroup) -> Result<(), Error> {
@@ -115,13 +116,24 @@ async fn import_curator(
     connection: &PgConnection,
     group_name: &str,
     curator: MozilliansGroupCurator,
+    staff_only: bool,
     cis_client: Arc<impl AsyncCisClientTrait>,
 ) -> Result<(), Error> {
     let user_profile =
         get_user_profile(connection, &curator.auth0_user_id, cis_client.clone()).await?;
     let user = User {
         user_uuid: user_profile.user_uuid,
     };
+    if staff_only
+        && !user_profile
+            .profile
+            .staff_information
+            .staff
+            .value
+            .unwrap_or_default()
+    {
+        return Ok(());
+    }
     internal::admin::add_admin(&connection, group_name, &User::default(), &user)?;
     drop(connection);
     add_group_to_profile(cis_client, group_name.to_owned(), user_profile.profile).await?;
@@ -132,11 +144,20 @@ pub async fn import_curators(
     connection: &PgConnection,
     group_name: &str,
     moz_curators: Vec<MozilliansGroupCurator>,
+    staff_only: bool,
     cis_client: Arc<impl AsyncCisClientTrait>,
 ) -> Result<(), Error> {
     for curator in moz_curators {
         let user_id = curator.auth0_user_id.clone();
-        match import_curator(connection, group_name, curator, cis_client.clone()).await {
+        match import_curator(
+            connection,
+            group_name,
+            curator,
+            staff_only,
+            cis_client.clone(),
+        )
+        .await
+        {
             Ok(()) => {}
             Err(e) => warn!(
                 "unable to add curator {} for group {}: {}",
@@ -151,16 +172,29 @@ pub async fn import_member(
     connection: &PgConnection,
     group_name: &str,
     member: MozilliansGroupMembership,
+    staff_only: bool,
     cis_client: Arc<impl AsyncCisClientTrait>,
 ) -> Result<(), Error> {
     use schema::memberships as m;
-    let group = internal::group::get_group(connection, group_name)?;
-    let expiration = calc_expiration(member.expiration, member.updated_on);
+
     let user_profile =
         get_user_profile(connection, &member.auth0_user_id, cis_client.clone()).await?;
+    if staff_only
+        && !user_profile
+            .profile
+            .staff_information
+            .staff
+            .value
+            .unwrap_or_default()
+    {
+        return Ok(());
+    }
+
     let user = User {
         user_uuid: user_profile.user_uuid,
     };
+    let group = internal::group::get_group(connection, group_name)?;
+    let expiration = calc_expiration(member.expiration, member.updated_on);
     let role = internal::member::role_for(connection, &user.user_uuid, group_name)?;
     if role.is_some() {
         diesel::update(m::table)
@@ -202,6 +236,7 @@ pub async fn import_members(
     connection: &PgConnection,
     group_name: &str,
     moz_members: Vec<MozilliansGroupMembership>,
+    staff_only: bool,
     cis_client: Arc<impl AsyncCisClientTrait>,
 ) -> Result<(), Error> {
     use schema::groups as g;
@@ -213,7 +248,15 @@ pub async fn import_members(
             created = joined;
         }
         let user_id = member.auth0_user_id.clone();
-        match import_member(connection, group_name, member, cis_client.clone()).await {
+        match import_member(
+            connection,
+            group_name,
+            member,
+            staff_only,
+            cis_client.clone(),
+        )
+        .await
+        {
             Ok(()) => {}
             Err(e) => warn!(
                 "unable to add member {} for group {}: {}",
@@ -241,13 +284,15 @@ pub async fn import(
         &connection,
         &group_name,
         group_import.curators,
+        group_import.staff_only,
         cis_client.clone(),
     )
     .await?;
     import_members(
         &connection,
         &group_name,
         group_import.memberships,
+        group_import.staff_only,
         cis_client.clone(),
     )
     .await?;

tests/api/import.rs

@@ -48,7 +48,7 @@ fn group() -> Result<MozilliansGroup, Error> {
 }
 
 #[actix_rt::test]
-async fn create() -> Result<(), Error> {
+async fn import() -> Result<(), Error> {
     reset()?;
     let (service, cis_client) = test_app_and_cis().await;
     let cis_client = Arc::new(cis_client);
@@ -60,7 +60,14 @@ async fn create() -> Result<(), Error> {
     let members = members()?;
     let connection = get_pool().get()?;
     import_group(&connection, group)?;
-    import_curators(&connection, "import-test", curators, cis_client.clone()).await?;
+    import_curators(
+        &connection,
+        "import-test",
+        curators,
+        false,
+        cis_client.clone(),
+    )
+    .await?;
 
     let res = get(&mut app, "/groups/api/v1/groups", &creator).await;
     assert!(res.status().is_success());
@@ -113,7 +120,14 @@ async fn create() -> Result<(), Error> {
         Some(0)
     );
 
-    import_members(&connection, "import-test", members, cis_client.clone()).await?;
+    import_members(
+        &connection,
+        "import-test",
+        members,
+        false,
+        cis_client.clone(),
+    )
+    .await?;
 
     let res = get(
         &mut app,
@@ -151,3 +165,122 @@ async fn create() -> Result<(), Error> {
 
     Ok(())
 }
+
+#[actix_rt::test]
+async fn import_staff_only() -> Result<(), Error> {
+    reset()?;
+    let (service, cis_client) = test_app_and_cis().await;
+    let cis_client = Arc::new(cis_client);
+    let app = App::new().service(service);
+    let mut app = test::init_service(app).await;
+    let creator = Soa::from(&basic_user(1, true)).creator().aal_medium();
+    let group = group()?;
+    let curators = curators()?;
+    let members = members()?;
+    let connection = get_pool().get()?;
+    import_group(&connection, group)?;
+    import_curators(
+        &connection,
+        "import-test",
+        curators,
+        true,
+        cis_client.clone(),
+    )
+    .await?;
+
+    let res = get(&mut app, "/groups/api/v1/groups", &creator).await;
+    assert!(res.status().is_success());
+    assert_eq!(read_json(res).await["groups"][0]["name"], "import-test");
+
+    let res = get(
+        &mut app,
+        "/groups/api/v1/groups/import-test/details",
+        &creator,
+    )
+    .await;
+    assert!(res.status().is_success());
+    let j = read_json(res).await;
+    assert_eq!(j["group"]["terms"], true);
+    assert_eq!(
+        j["group"]["description"],
+        "import test group\n\n**Website:** [https://example.com/](https://example.com/)"
+    );
+
+    let res = get(
+        &mut app,
+        "/groups/api/v1/invitations/import-test/email",
+        &creator,
+    )
+    .await;
+    assert!(res.status().is_success());
+    assert_eq!(read_json(res).await["body"], "some \ninvitation email");
+
+    let res = get(
+        &mut app,
+        "/groups/api/v1/members/import-test?r=Curator",
+        &creator,
+    )
+    .await;
+    assert!(res.status().is_success());
+    assert_eq!(
+        read_json(res).await["members"].as_array().map(|a| a.len()),
+        Some(2)
+    );
+
+    let res = get(
+        &mut app,
+        "/groups/api/v1/members/import-test?r=Member",
+        &creator,
+    )
+    .await;
+    assert!(res.status().is_success());
+    assert_eq!(
+        read_json(res).await["members"].as_array().map(|a| a.len()),
+        Some(0)
+    );
+
+    import_members(
+        &connection,
+        "import-test",
+        members,
+        true,
+        cis_client.clone(),
+    )
+    .await?;
+
+    let res = get(
+        &mut app,
+        "/groups/api/v1/members/import-test?r=Curator",
+        &creator,
+    )
+    .await;
+    assert!(res.status().is_success());
+    assert_eq!(
+        read_json(res).await["members"].as_array().map(|a| a.len()),
+        Some(2)
+    );
+
+    let res = get(
+        &mut app,
+        "/groups/api/v1/members/import-test?r=Member",
+        &creator,
+    )
+    .await;
+    assert!(res.status().is_success());
+    assert_eq!(
+        read_json(res).await["members"].as_array().map(|a| a.len()),
+        Some(4)
+    );
+
+    let res = get(
+        &mut app,
+        "/groups/api/v1/groups/import-test/details",
+        &creator,
+    )
+    .await;
+    assert!(res.status().is_success());
+    let j = read_json(res).await;
+    assert_eq!(j["group"]["created"], "2019-10-24T17:56:21Z");
+
+    Ok(())
+}