Pass render purpose to render

src-tauri/src/http_request.rs

@@ -9,6 +9,7 @@ use std::time::Duration;
 
 use crate::render::render_http_request;
 use crate::response_err;
+use crate::template_callback::PluginTemplateCallback;
 use base64::Engine;
 use http::header::{ACCEPT, USER_AGENT};
 use http::{HeaderMap, HeaderName, HeaderValue};
@@ -37,11 +38,13 @@ pub async fn send_http_request<R: Runtime>(
     let workspace = get_workspace(window, &request.workspace_id)
         .await
         .expect("Failed to get Workspace");
+    let cb = &*window.app_handle().state::<PluginTemplateCallback>();
+    let cb = cb.for_send();
     let rendered_request = render_http_request(
-        window.app_handle(),
         &request,
         &workspace,
         environment.as_ref(),
+        &cb,
     )
     .await;
 

src-tauri/src/lib.rs

@@ -2006,11 +2006,12 @@ async fn handle_plugin_event<R: Runtime>(
                 None => None,
                 Some(id) => get_environment(&w, id.as_str()).await.ok(),
             };
+            let cb = &*app_handle.state::<PluginTemplateCallback>();
             let rendered_http_request = render_http_request(
-                app_handle,
                 &req.http_request,
                 &workspace,
                 environment.as_ref(),
+                cb,
             )
             .await;
             Some(InternalEventPayload::RenderHttpRequestResponse(

src-tauri/src/render.rs

@@ -52,13 +52,12 @@ pub async fn render_grpc_request<R: Runtime>(
     }
 }
 
-pub async fn render_http_request<R: Runtime>(
-    app_handle: &AppHandle<R>,
+pub async fn render_http_request(
     r: &HttpRequest,
     w: &Workspace,
     e: Option<&Environment>,
+    cb: &PluginTemplateCallback,
 ) -> HttpRequest {
-    let cb = &*app_handle.state::<PluginTemplateCallback>();
     let vars = &variables_from_environment(w, e, cb).await;
 
     let mut url_parameters = Vec::new();

src-tauri/src/template_callback.rs

@@ -1,15 +1,24 @@
 use std::collections::HashMap;
 use tauri::{AppHandle, Manager};
+use yaak_plugin_runtime::events::CallTemplateFunctionPurpose;
 use yaak_plugin_runtime::manager::PluginManager;
 use yaak_templates::TemplateCallback;
 
+#[derive(Clone)]
 pub struct PluginTemplateCallback {
     app_handle: AppHandle,
+    purpose: CallTemplateFunctionPurpose,
 }
 
 impl PluginTemplateCallback {
     pub fn new(app_handle: AppHandle) -> PluginTemplateCallback {
-        PluginTemplateCallback { app_handle }
+        PluginTemplateCallback { app_handle, purpose: CallTemplateFunctionPurpose::Preview }
+    }
+
+    pub fn for_send(&self) -> PluginTemplateCallback {
+        let mut v = self.clone();
+        v.purpose = CallTemplateFunctionPurpose::Send;
+        v
     }
 }
 
@@ -17,7 +26,7 @@ impl TemplateCallback for PluginTemplateCallback {
     async fn run(&self, fn_name: &str, args: HashMap<String, String>) -> Result<String, String> {
         let plugin_manager = self.app_handle.state::<PluginManager>();
         let resp = plugin_manager
-            .call_template_function(fn_name, args)
+            .call_template_function(fn_name, args, self.purpose.clone())
             .await
             .map_err(|e| e.to_string())?;
         Ok(resp.unwrap_or_default())