create_inner

Author: epompeii

lib/api_run/src/run.rs

@@ -50,7 +50,7 @@ async fn post_inner(
 ) -> Result<JsonReport, HttpError> {
     let query_project = match (auth_user.as_ref(), json_run.project.as_ref()) {
         (Some(auth_user), Some(project)) => {
-            QueryProject::get_or_create(log, context, auth_user, project)
+            QueryProject::get_or_create_from_project(log, context, auth_user, project)
                 .await
                 .map_err(|e| forbidden_error(e.to_string()))?
         },

lib/bencher_schema/src/model/organization/mod.rs

@@ -54,7 +54,7 @@ impl QueryOrganization {
     fn_get_id!(organization, OrganizationId, OrganizationUuid);
     fn_get_uuid!(organization, OrganizationId, OrganizationUuid);
 
-    pub async fn get_or_create(
+    pub async fn get_or_create_from_user(
         context: &ApiContext,
         auth_user: &AuthUser,
     ) -> Result<Self, HttpError> {
@@ -72,22 +72,30 @@ impl QueryOrganization {
         Self::create(context, auth_user, json_organization).await
     }
 
+    pub async fn get_or_create_from_context(
+        context: &ApiContext,
+        project_name: &ResourceName,
+        project_slug: &Slug,
+    ) -> Result<Self, HttpError> {
+        if let Ok(query_organization) =
+            Self::from_resource_id(conn_lock!(context), &project_slug.clone().into())
+        {
+            return Ok(query_organization);
+        }
+
+        let json_organization = JsonNewOrganization {
+            name: project_name.clone(),
+            slug: Some(project_slug.clone()),
+        };
+        Self::create_inner(context, json_organization).await
+    }
+
     pub async fn create(
         context: &ApiContext,
         auth_user: &AuthUser,
         json_organization: JsonNewOrganization,
     ) -> Result<Self, HttpError> {
-        // Create the organization
-        let insert_organization =
-            InsertOrganization::from_json(conn_lock!(context), json_organization)?;
-        diesel::insert_into(schema::organization::table)
-            .values(&insert_organization)
-            .execute(conn_lock!(context))
-            .map_err(resource_conflict_err!(Organization, insert_organization))?;
-        let query_organization = schema::organization::table
-            .filter(schema::organization::uuid.eq(&insert_organization.uuid))
-            .first::<QueryOrganization>(conn_lock!(context))
-            .map_err(resource_not_found_err!(Organization, insert_organization))?;
+        let query_organization = Self::create_inner(context, json_organization).await?;
 
         let timestamp = DateTime::now();
         // Connect the user to the organization as a `Leader`
@@ -106,6 +114,22 @@ impl QueryOrganization {
         Ok(query_organization)
     }
 
+    async fn create_inner(
+        context: &ApiContext,
+        json_organization: JsonNewOrganization,
+    ) -> Result<Self, HttpError> {
+        let insert_organization =
+            InsertOrganization::from_json(conn_lock!(context), json_organization)?;
+        diesel::insert_into(schema::organization::table)
+            .values(&insert_organization)
+            .execute(conn_lock!(context))
+            .map_err(resource_conflict_err!(Organization, insert_organization))?;
+        schema::organization::table
+            .filter(schema::organization::uuid.eq(&insert_organization.uuid))
+            .first::<QueryOrganization>(conn_lock!(context))
+            .map_err(resource_not_found_err!(Organization, insert_organization))
+    }
+
     pub fn is_allowed_resource_id(
         conn: &mut DbConnection,
         rbac: &Rbac,

lib/bencher_schema/src/model/project/mod.rs

@@ -89,7 +89,7 @@ impl QueryProject {
             .map_err(resource_not_found_err!(Project, slug.clone()))
     }
 
-    pub async fn get_or_create(
+    pub async fn get_or_create_from_project(
         log: &Logger,
         context: &ApiContext,
         auth_user: &AuthUser,
@@ -110,7 +110,8 @@ impl QueryProject {
             ResourceIdKind::Slug(slug) => slug,
         };
 
-        let query_organization = QueryOrganization::get_or_create(context, auth_user).await?;
+        let query_organization =
+            QueryOrganization::get_or_create_from_user(context, auth_user).await?;
         let json_project = JsonNewProject {
             name: slug.clone().into(),
             slug: Some(slug.clone()),
@@ -131,7 +132,8 @@ impl QueryProject {
             return Ok(query_project);
         }
 
-        let query_organization = QueryOrganization::get_or_create(context, auth_user).await?;
+        let query_organization =
+            QueryOrganization::get_or_create_from_user(context, auth_user).await?;
         let name = Self::unique_name(context, &query_organization, project_name).await?;
         let json_project = JsonNewProject {
             name,
@@ -226,29 +228,18 @@ impl QueryProject {
         query_organization: &QueryOrganization,
         json_project: JsonNewProject,
     ) -> Result<Self, HttpError> {
-        let insert_project =
-            InsertProject::from_json(conn_lock!(context), query_organization, json_project)?;
-
         // Check to see if user has permission to create a project within the organization
         context
             .rbac
             .is_allowed_organization(
                 auth_user,
                 bencher_rbac::organization::Permission::Create,
-                &insert_project,
+                query_organization,
             )
             .map_err(forbidden_error)?;
 
-        diesel::insert_into(project_table::table)
-            .values(&insert_project)
-            .execute(conn_lock!(context))
-            .map_err(resource_conflict_err!(Project, &insert_project))?;
-        let query_project = Self::from_uuid(
-            conn_lock!(context),
-            query_organization.id,
-            insert_project.uuid,
-        )?;
-        slog::debug!(log, "Created project: {query_project:?}");
+        let query_project =
+            Self::create_inner(log, context, query_organization, json_project).await?;
 
         let timestamp = DateTime::now();
         // Connect the user to the project as a `Maintainer`
@@ -265,6 +256,28 @@ impl QueryProject {
             .map_err(resource_conflict_err!(ProjectRole, insert_proj_role))?;
         slog::debug!(log, "Added project role: {insert_proj_role:?}");
 
+        Ok(query_project)
+    }
+
+    async fn create_inner(
+        log: &Logger,
+        context: &ApiContext,
+        query_organization: &QueryOrganization,
+        json_project: JsonNewProject,
+    ) -> Result<Self, HttpError> {
+        let insert_project =
+            InsertProject::from_json(conn_lock!(context), query_organization, json_project)?;
+        diesel::insert_into(project_table::table)
+            .values(&insert_project)
+            .execute(conn_lock!(context))
+            .map_err(resource_conflict_err!(Project, &insert_project))?;
+        let query_project = Self::from_uuid(
+            conn_lock!(context),
+            query_organization.id,
+            insert_project.uuid,
+        )?;
+        slog::debug!(log, "Created project: {query_project:?}");
+
         #[cfg(feature = "plus")]
         context.update_index(log, &query_project).await;