NEXT

src/generation_service.rs

@@ -8,12 +8,14 @@ use crate::{
     store::{Store, WorkspaceRecord},
 };
 use chrono::{Duration, Utc};
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
 use uuid::Uuid;
-#[derive(Debug, Clone, Deserialize)]
+#[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct Draft {
     pub revision: i64,
+    #[serde(default)]
+    pub shared_revision: Option<i64>,
     pub variables: Vec<Variable>,
     pub rules: Vec<Rule>,
     #[serde(default)]
@@ -32,6 +34,7 @@ async fn prepare(db: &Store, actor: Uuid, workspace: Uuid, draft: &Draft) -> Res
         .prepare(workspace, draft.revision, actor, Permission::EditSchedules)
         .await?;
     let directory = db.directory(workspace).await?;
+    crate::store::account_people(&mut record.document, &directory)?;
     let members = directory.iter().map(|u| u.id).collect();
     let now = Utc::now();
     let mut expanded = generation::expand(
@@ -61,13 +64,7 @@ async fn prepare(db: &Store, actor: Uuid, workspace: Uuid, draft: &Draft) -> Res
         .collect();
     for user in &directory {
         if used.contains(&user.id) && expanded.document.person(user.id).is_none() {
-            expanded.document.people.push(Person {
-                id: user.id,
-                user_id: Some(user.id),
-                display_name: user.display_name.clone(),
-                email: None,
-                country: Some(user.country.clone()),
-            });
+            expanded.document.people.push(user.person.clone());
         }
     }
     if expanded.issues.is_empty() {
@@ -122,7 +119,11 @@ async fn prepare(db: &Store, actor: Uuid, workspace: Uuid, draft: &Draft) -> Res
         draft.route_position
     ]))
     .to_string();
-    let report = json!({"review_id":review,"changes":expanded.changes,"cancelled_requests":cancelled,"result":result,"trace":expanded.trace,"issues":issues});
+    let publication_changes = crate::store::publication_changes(
+        &expanded.document,
+        db.published_document(workspace).await?.as_ref(),
+    )?;
+    let report = json!({"shared_revision":draft.shared_revision,"publication_changes":publication_changes,"review_id":review,"changes":expanded.changes,"cancelled_requests":cancelled,"result":result,"trace":expanded.trace,"issues":issues});
     record.document = expanded.document;
     Ok(Prepared {
         report,
@@ -161,3 +162,104 @@ pub async fn apply(db: &Store, actor: Uuid, workspace: Uuid, draft: Draft) -> Re
     .await?;
     Ok(json!({"ok":true}))
 }
+
+#[derive(Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct Transfer {
+    pub revision: i64,
+    pub shared_revision: i64,
+    #[serde(default)]
+    pub text: String,
+    #[serde(default)]
+    pub review_id: Option<String>,
+}
+async fn transfer_base(
+    db: &Store,
+    actor: Uuid,
+    workspace: Uuid,
+    request: &Transfer,
+) -> Result<(WorkspaceRecord, Draft)> {
+    let record = db
+        .prepare(
+            workspace,
+            request.revision,
+            actor,
+            Permission::EditSchedules,
+        )
+        .await?;
+    let shared = db.shared_draft(workspace).await?;
+    ensure(
+        shared["revision"].as_i64() == Some(request.shared_revision),
+        crate::i18n::text("err_shared_draft_stale"),
+    )?;
+    let mut draft: Draft = if shared["payload"].is_null() {
+        Draft {
+            revision: record.revision,
+            shared_revision: Some(request.shared_revision),
+            variables: record.document.generation.variables.clone(),
+            rules: record.document.generation.rules.clone(),
+            route_position: record.document.generation.route_position,
+            review_id: None,
+        }
+    } else {
+        serde_json::from_value(shared["payload"].clone())?
+    };
+    draft.revision = record.revision;
+    draft.shared_revision = Some(request.shared_revision);
+    Ok((record, draft))
+}
+pub async fn export_config(
+    db: &Store,
+    actor: Uuid,
+    workspace: Uuid,
+    request: Transfer,
+) -> Result<Value> {
+    let (record, draft) = transfer_base(db, actor, workspace, &request).await?;
+    Ok(
+        json!({"text":crate::portable::format_config(&crate::portable::export(&record.document,&draft)?)}),
+    )
+}
+pub async fn import_config(
+    db: &Store,
+    actor: Uuid,
+    workspace: Uuid,
+    request: Transfer,
+    apply: bool,
+) -> Result<Value> {
+    let (record, base) = transfer_base(db, actor, workspace, &request).await?;
+    let (draft, inputs) =
+        crate::portable::import(workspace, &record.document, &base, &request.text)?;
+    let prepared = prepare(db, actor, workspace, &draft).await?;
+    let review = generation::stable_id(&json!([
+        prepared.review,
+        request.shared_revision,
+        request.text
+    ]))
+    .to_string();
+    if apply {
+        ensure(
+            prepared.issues.is_empty(),
+            crate::i18n::text("transfer_fix_errors"),
+        )?;
+        ensure(
+            request.review_id.as_deref() == Some(review.as_str()),
+            crate::i18n::text("err_the_preview_is_stale_check_the_updated_impact_be_85cacd"),
+        )?;
+        return db
+            .save_shared_draft(
+                workspace,
+                actor,
+                request.shared_revision,
+                serde_json::to_value(draft)?,
+            )
+            .await;
+    }
+    let contacts: Vec<_> = prepared
+        .record
+        .document
+        .people
+        .iter()
+        .filter(|p| record.document.person(p.id).is_none() && p.user_id.is_none())
+        .collect();
+    Ok(json!({"review_id":review,"inputs":inputs,"contacts":contacts,"preview":prepared.report}))
+}