wip es search predicates

_sql/actions_and_analytics/storyteller_studio/list_users_with_studio_access.sql

@@ -6,3 +6,8 @@
 select username from users where maybe_feature_flags  like '%studio%';
 
 select username from users where can_access_studio = true;
+
+-- Who signed up recently and has access?
+select username, maybe_source
+from users where can_access_studio = true
+and created_at > NOW() - interval 20 minute;

crates/lib/elasticsearch_schema/src/searches/search_media_files.rs

@@ -1,6 +1,10 @@
+use std::collections::HashSet;
 use once_cell::sync::Lazy;
 use serde_json::{json, Value};
-
+use enums::by_table::media_files::media_file_class::MediaFileClass;
+use enums::by_table::media_files::media_file_engine_category::MediaFileEngineCategory;
+use enums::by_table::media_files::media_file_type::MediaFileType;
+use errors::AnyhowResult;
 
 static JSON_QUERY : Lazy<Value> = Lazy::new(|| {
   const QUERY_TEMPLATE : &str = include_str!("../../../../../_elasticsearch/searches/media_files/search.json");
@@ -8,45 +12,121 @@ static JSON_QUERY : Lazy<Value> = Lazy::new(|| {
   let json : Value = serde_json::from_str(QUERY_TEMPLATE)
       .expect("json should parse");
 
-  // Replace this with an empty list so that we can attach predicates later.
-  let json= jsonpath_lib::replace_with(json, "$.query.bool.must[0].bool.must", &mut |_| {
-    //Some(json!([]))
-    None
-  }).expect("json node should delete");
-
   json
 });
 
+pub struct SearchArgs {
+  pub maybe_media_classes: Option<HashSet<MediaFileClass>>,
+  pub maybe_media_types: Option<HashSet<MediaFileType>>,
+  pub maybe_engine_categories: Option<HashSet<MediaFileEngineCategory>>,
+}
 
-pub fn search() {
+pub fn search_media_files(args: SearchArgs) -> AnyhowResult<()> {
+
+}
+
+fn build_query(args: SearchArgs) -> AnyhowResult<Value> {
   let query = JSON_QUERY.clone();
 
-  println!("{}", query);
+  let query = jsonpath_lib::replace_with(query, "$.query.bool.must[0].bool.must", &mut |_| {
+    let mut predicates = vec![
+      must_be_not_deleted(),
+    ];
 
-  let mut must_node = jsonpath_lib::select(
-    &query,
-    "$.query.bool.must[0].bool.must").expect("json node should exist");
-
-  println!("{:?}", must_node);
-
-  let new_node = json!({
-    "match": {
-      "media_file_id": "1234"
+    if let Some(media_classes) = &args.maybe_media_classes {
+      predicates.push(media_classes_predicate(media_classes));
     }
-  });
 
-  must_node.push(&new_node);
+    if let Some(media_types) = &args.maybe_media_types {
+      predicates.push(media_types_predicate(media_types));
+    }
 
-  println!("{:?}", must_node);
+    if let Some(engine_categories) = &args.maybe_engine_categories {
+      predicates.push(engine_categories_predicate(engine_categories));
+    }
 
-  println!("{}", query);
+    Some(json!(predicates))
+  })?;
+
+  println!("QUERY: {}", query);
+
+  Ok(query)
+}
+
+fn must_be_not_deleted() -> Value {
+  json!({
+    "term": {
+      "is_deleted": false,
+    }
+  })
+}
+
+fn media_classes_predicate(media_classes: &HashSet<MediaFileClass>) -> Value {
+  let predicates : Vec<Value> = media_classes.iter()
+      .map(|media_type| {
+        json!({
+          "term": {
+            "media_class": media_type.to_str(),
+          }
+        })
+      })
+      .collect();
+
+  json!({
+    "bool": {
+      "should": predicates,
+    }
+  })
+}
+
+fn media_types_predicate(media_types: &HashSet<MediaFileType>) -> Value {
+  let predicates : Vec<Value> = media_types.iter()
+      .map(|media_type| {
+        json!({
+          "term": {
+            "media_type": media_type.to_str(),
+          }
+        })
+      })
+      .collect();
+
+  json!({
+    "bool": {
+      "should": predicates,
+    }
+  })
+}
+
+fn engine_categories_predicate(engine_categories: &HashSet<MediaFileEngineCategory>) -> Value {
+  let predicates : Vec<Value> = engine_categories.iter()
+      .map(|engine_category| {
+        json!({
+          "term": {
+            "maybe_engine_category": engine_category.to_str(),
+          }
+        })
+      })
+      .collect();
+
+  json!({
+    "bool": {
+      "should": predicates,
+    }
+  })
 }
 
 #[cfg(test)]
 mod tests {
+  use crate::searches::search_media_files::SearchArgs;
+
   #[test]
   fn test() {
-    super::search();
+    super::search_media_files(SearchArgs {
+      maybe_media_classes: None,
+      maybe_media_types: None,
+      maybe_engine_categories: None,
+    }).expect("should function");
+
     assert_eq!(1, 2);
   }
 }

crates/service/plugins/users/src/endpoints/create_account_handler.rs

@@ -263,10 +263,10 @@ pub async fn create_account_handler(
     })?;
 
   // NB: Enroll new users in studio for a while.
-  enroll_in_studio(&new_user_data.user_token, &ip_address, &mysql_pool).await
-    .map_err(|e| {
-      warn!("error enrolling in studio: {:?}", e);
-    }).ok();
+  //enroll_in_studio(&new_user_data.user_token, &ip_address, &mysql_pool).await
+  //  .map_err(|e| {
+  //    warn!("error enrolling in studio: {:?}", e);
+  //  }).ok();
 
   let session_token = UserSessionToken::new_from_str(&session_token);