Merge pull request #10 from eboody/create_many_delete_many

added create_many and delete_many

crates/libs/lib-core/src/model/agent.rs

@@ -124,6 +124,39 @@ mod tests {
  Ok(())
  }
 
+ #[serial]
+ #[tokio::test]
+ async fn test_create_many_ok() -> Result<()> {
+ // -- Setup & Fixtures
+ let mm = _dev_utils::init_test().await;
+ let ctx = Ctx::root_ctx();
+ let fx_name = "test_create_ok agent 01";
+
+ // -- Exec
+ let fx_agent_c = AgentForCreate {
+ name: fx_name.to_string(),
+ };
+ let fx_agent_c2 = AgentForCreate {
+ name: fx_name.to_string(),
+ };
+
+ let agent_ids =
+ AgentBmc::create_many(&ctx, &mm, vec![fx_agent_c, fx_agent_c2]).await?;
+
+ let agent_filter: AgentFilter = serde_json::from_value(json!(
+ {
+ "id": {"$in": agent_ids}
+ }
+ ))?;
+
+ let agents =
+ AgentBmc::list(&ctx, &mm, Some(vec![agent_filter]), None).await?;
+
+ assert_eq!(agents.len(), 2, "should have only retrieved 2 agents");
+
+ Ok(())
+ }
+
  #[serial]
  #[tokio::test]
  async fn test_update_ok() -> Result<()> {
@@ -177,6 +210,42 @@ mod tests {
 
  Ok(())
  }
+ #[serial]
+ #[tokio::test]
+ async fn test_delete_many_ok() -> Result<()> {
+ // -- Setup & Fixtures
+ let mm = _dev_utils::init_test().await;
+ let ctx = Ctx::root_ctx();
+ let fx_name = "test_create_ok agent 01";
+
+ // -- Exec
+ let fx_agent_c = AgentForCreate {
+ name: fx_name.to_string(),
+ };
+ let fx_agent_c2 = AgentForCreate {
+ name: fx_name.to_string(),
+ };
+
+ let agent_ids =
+ AgentBmc::create_many(&ctx, &mm, vec![fx_agent_c, fx_agent_c2]).await?;
+
+ let agent_filter: AgentFilter = serde_json::from_value(json!(
+ {
+ "id": {"$in": agent_ids}
+ }
+ ))?;
+
+ let agents =
+ AgentBmc::list(&ctx, &mm, Some(vec![agent_filter]), None).await?;
+
+ assert_eq!(agents.len(), 2, "should have only retrieved 2 agents");
+
+ let deleted = AgentBmc::delete_many(&ctx, &mm, agent_ids).await?;
+
+ assert_eq!(deleted, agents.len() as u64);
+
+ Ok(())
+ }
 
  #[serial]
  #[tokio::test]

crates/libs/lib-core/src/model/base/crud_fns.rs

@@ -42,6 +42,49 @@ where
  Ok(id)
 }
 
+pub async fn create_many<MC, E>(
+ ctx: &Ctx,
+ mm: &ModelManager,
+ data: Vec<E>,
+) -> Result<Vec<i64>>
+where
+ MC: DbBmc,
+ E: HasSeaFields,
+{
+ let user_id = ctx.user_id();
+ let mut ids = Vec::with_capacity(data.len());
+
+ // Prepare insert query
+ let mut query = Query::insert();
+
+ for item in data {
+ let mut fields = item.not_none_sea_fields();
+ prep_fields_for_create::<MC>(&mut fields, user_id);
+ let (columns, sea_values) = fields.for_sea_insert();
+
+ // Append values for each item
+ query
+ .into_table(MC::table_ref())
+ .columns(columns.clone())
+ .values(sea_values)?;
+ }
+
+ query.returning(Query::returning().columns([CommonIden::Id]));
+
+ // Execute query
+ let (sql, values) = query.build_sqlx(PostgresQueryBuilder);
+ let sqlx_query = sqlx::query_as_with::<_, (i64,), _>(&sql, values);
+
+ let rows = mm.dbx().fetch_all(sqlx_query).await?;
+
+ for row in rows {
+ let (id,): (i64,) = row;
+ ids.push(id);
+ }
+
+ Ok(ids)
+}
+
 pub async fn get<MC, E>(_ctx: &Ctx, mm: &ModelManager, id: i64) -> Result<E>
 where
  MC: DbBmc,
@@ -206,6 +249,40 @@ where
  }
 }
 
+pub async fn delete_many<MC>(
+ _ctx: &Ctx,
+ mm: &ModelManager,
+ ids: Vec<i64>,
+) -> Result<u64>
+where
+ MC: DbBmc,
+{
+ if ids.is_empty() {
+ return Ok(0);
+ }
+
+ // -- Build query
+ let mut query = Query::delete();
+ query
+ .from_table(MC::table_ref())
+ .and_where(Expr::col(CommonIden::Id).is_in(ids.clone()));
+
+ // -- Execute query
+ let (sql, values) = query.build_sqlx(PostgresQueryBuilder);
+ let sqlx_query = sqlx::query_with(&sql, values);
+ let result = mm.dbx().execute(sqlx_query).await?;
+
+ // -- Check result
+ if result as usize != ids.len() {
+ Err(Error::EntityNotFound {
+ entity: MC::TABLE,
+ id: 0, // Using 0 because multiple IDs could be not found, you may want to improve error handling here
+ })
+ } else {
+ Ok(result)
+ }
+}
+
 pub fn compute_list_options(
  list_options: Option<ListOptions>,
 ) -> Result<ListOptions> {

crates/libs/lib-core/src/model/base/macro_utils.rs

@@ -19,6 +19,14 @@ macro_rules! generate_common_bmc_fns {
  ) -> Result<i64> {
  base::create::<Self, _>(ctx, mm, entity_c).await
  }
+
+ pub async fn create_many(
+ ctx: &Ctx,
+ mm: &ModelManager,
+ entity_c: Vec<$for_create>,
+ ) -> Result<Vec<i64>> {
+ base::create_many::<Self, _>(ctx, mm, entity_c).await
+ }
  )?
 
  pub async fn get(
@@ -67,6 +75,14 @@ macro_rules! generate_common_bmc_fns {
  ) -> Result<()> {
  base::delete::<Self>(ctx, mm, id).await
  }
+
+ pub async fn delete_many(
+ ctx: &Ctx,
+ mm: &ModelManager,
+ ids: Vec<i64>,
+ ) -> Result<u64> {
+ base::delete_many::<Self>(ctx, mm, ids).await
+ }
  }
  };
 }