feat: create operator and impl system for content

Author: drew-harris

server/src/handlers/webhook_handler.rs

@@ -1,6 +1,13 @@
+use std::str::FromStr;
+
 use actix_web::{web, HttpResponse};
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
+use uuid::Uuid;
+
+use crate::{errors::ServiceError, operators::webhook_operator::publish_content};
+
+use super::chunk_handler::ChunkReqPayload;
 
 #[derive(Serialize, Deserialize)]
 struct WebhookRespose {
@@ -18,12 +25,28 @@ pub enum Operation {
     ScheduledEnd,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct ContentValue {
+    id: String,
+    name: String,
+    model_id: String,
+    data: Value,
+}
+
+impl Into<ChunkReqPayload> for ContentValue {
+    fn into(self) -> ChunkReqPayload {
+        todo!();
+    }
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 #[serde(rename_all = "camelCase")]
 pub struct WebhookRequest {
     model_name: String,
-    new_value: Value,
-    previous_value: Value,
+    new_value: ContentValue,
+    // This is usually always there just being safe
+    previous_value: Option<ContentValue>,
     operation: Operation,
 }
 
@@ -39,12 +62,35 @@ pub async fn builder_webhook(
     payload: web::Json<WebhookRequest>,
     query: web::Query<WebhookQueryParams>,
 ) -> Result<HttpResponse, actix_web::Error> {
+    // Ensure that the trieve_key and trieve_dataset are valid
+    if query.trieve_key.is_empty() || query.trieve_dataset.is_empty() {
+        return Err(ServiceError::BadRequest(
+            "trieve_key and trieve_dataset are required".to_string(),
+        )
+        .into());
+    }
+
     let payload = payload.into_inner();
     let query = query.into_inner();
+    let dataset_id = uuid::Uuid::from_str(query.trieve_dataset.as_str()).map_err(|_| {
+        ServiceError::BadRequest(format!("Invalid dataset id: {}", query.trieve_dataset))
+    })?;
+
+    // TODO: Ensure user has proper perms
 
     log::info!("Webhook received: {:?}", payload);
     log::info!("Query params: {:?}", query);
 
+    match payload.operation {
+        Operation::Publish => {
+            publish_content(dataset_id, payload.new_value).await?;
+        }
+
+        _ => {
+            return Err(ServiceError::BadRequest("Operation not supported".to_string()).into());
+        }
+    }
+
     Ok(HttpResponse::Ok().json(WebhookRespose {
         message: "Webhook received".to_string(),
     }))

server/src/operators/mod.rs

@@ -19,3 +19,4 @@ pub mod stripe_operator;
 pub mod topic_operator;
 pub mod typo_operator;
 pub mod user_operator;
+pub mod webhook_operator;

server/src/operators/webhook_operator.rs

@@ -0,0 +1,11 @@
+use crate::{
+    errors::ServiceError,
+    handlers::{chunk_handler::ChunkReqPayload, webhook_handler::ContentValue},
+};
+
+pub async fn publish_content<T: Into<ChunkReqPayload>>(
+    dataset: uuid::Uuid,
+    value: T,
+) -> Result<(), ServiceError> {
+    todo!();
+}