bring the implementation to 1.0.3 spec

Author: stevehu

builders/src/lib.rs

@@ -272,7 +272,7 @@ mod unit_tests {
                 .entries
                 .iter()
                 .any(|entry| entry.get(&call_task_name.to_string()).map_or(false, |task| {
-                    if let TaskDefinition::Call(call_task) = task {
+                    if let TaskDefinition::Call(CallTaskDefinition::Function(call_task)) = task {
                         call_task.call == call_function_name && call_task.with == Some(call_task_with.clone())
                     } else {
                         false
@@ -282,6 +282,7 @@ mod unit_tests {
             call_task_name,
             call_function_name,
             call_task_with);
+
         assert!(
             workflow.do_
                 .entries

builders/src/services/task.rs

@@ -257,23 +257,27 @@ impl CalltaskDefinitionBuilder {
 
     /// Initializes a new CallTaskDefinitionBuilder
     pub fn new(function: &str) -> Self{
-        Self { task: CallTaskDefinition::new(function, None, None) }
+        Self { task: CallTaskDefinition::new_function(function, None, None) }
     }
 
     /// Adds a new argument to call the function with
     pub fn with(&mut self, name: &str, value: Value) -> &mut Self{
-        if self.task.with.is_none(){
-            self.task.with = Some(HashMap::new());
-        }
-        if let Some(with) = &mut self.task.with {
-            with.insert(name.to_string(), value);
+        if let CallTaskDefinition::Function(ref mut task) = self.task{
+            if task.with.is_none(){
+                task.with = Some(HashMap::new());
+            }
+            if let Some(with) = &mut task.with {
+                with.insert(name.to_string(), value);
+            }
         }
         self
     }
 
     /// Sets the arguments to call the function with
     pub fn with_arguments(&mut self, arguments: HashMap<String, Value>) -> &mut Self{
-        self.task.with = Some(arguments);
+        if let CallTaskDefinition::Function(ref mut task) = self.task{
+            task.with = Some(arguments);
+        }
         self
     }
 
@@ -282,13 +286,13 @@ impl TaskDefinitionBuilderBase for CalltaskDefinitionBuilder{
 
     /// Configures the task to build to run only if the specified condition matches
     fn if_(&mut self, condition: &str) -> &mut Self{
-        self.task.common.if_ = Some(condition.to_string());
+        self.task.common_mut().if_ = Some(condition.to_string());
         self
     }
 
     /// Sets the task's timeout
     fn with_timeout_reference(&mut self, reference: &str) -> &mut Self{
-        self.task.common.timeout = Some(OneOfTimeoutDefinitionOrReference::Reference(reference.to_string()));
+        self.task.common_mut().timeout = Some(OneOfTimeoutDefinitionOrReference::Reference(reference.to_string()));
         self
     }
 
@@ -298,7 +302,7 @@ impl TaskDefinitionBuilderBase for CalltaskDefinitionBuilder{
         let mut builder = TimeoutDefinitionBuilder::new();
         setup(&mut builder);
         let timeout = builder.build();
-        self.task.common.timeout = Some(OneOfTimeoutDefinitionOrReference::Timeout(timeout));
+        self.task.common_mut().timeout = Some(OneOfTimeoutDefinitionOrReference::Timeout(timeout));
         self
     }
 
@@ -307,7 +311,7 @@ impl TaskDefinitionBuilderBase for CalltaskDefinitionBuilder{
     where F: FnOnce(&mut InputDataModelDefinitionBuilder){
         let mut builder = InputDataModelDefinitionBuilder::new();
         setup(&mut builder);
-        self.task.common.input = Some(builder.build());
+        self.task.common_mut().input = Some(builder.build());
         self
     }
 
@@ -316,7 +320,7 @@ impl TaskDefinitionBuilderBase for CalltaskDefinitionBuilder{
     where F: FnOnce(&mut OutputDataModelDefinitionBuilder){
         let mut builder = OutputDataModelDefinitionBuilder::new();
         setup(&mut builder);
-        self.task.common.output = Some(builder.build());
+        self.task.common_mut().output = Some(builder.build());
         self
     }
 
@@ -325,16 +329,17 @@ impl TaskDefinitionBuilderBase for CalltaskDefinitionBuilder{
     where F: FnOnce(&mut OutputDataModelDefinitionBuilder){
         let mut builder = OutputDataModelDefinitionBuilder::new();
         setup(&mut builder);
-        self.task.common.export = Some(builder.build());
+        self.task.common_mut().export = Some(builder.build());
         self
     }
 
     /// Configures the task to build to then execute the specified flow directive
     fn then(&mut self, directive: &str) -> &mut Self{
-        self.task.common.then = Some(directive.to_string());
+        self.task.common_mut().then = Some(directive.to_string());
         self
     }
 
+
     /// Builds the configures CallTaskDefinition
     fn build(self) -> TaskDefinition{
         TaskDefinition::Call(self.task)

core/src/lib.rs

@@ -7,6 +7,9 @@ mod unit_tests {
     use crate::models::workflow::*;
     use crate::models::task::*;
     use crate::models::map::*;
+    use crate::models::resource::*;
+    use crate::models::retry::*;
+    use crate::models::authentication::*;
     use serde_json::json;
 
     #[test]
@@ -16,9 +19,11 @@ mod unit_tests {
         let version = "1.0.0";
         let title = Some("fake-title".to_string());
         let summary = Some("fake-summary".to_string());
-        let document = WorkflowDefinitionMetadata::new(namespace, name, version, title.clone(), summary.clone(), None);
-        let mut call_task = CallTaskDefinition::new("http", None, Some(true));
-        call_task.common.then = Some("continue".to_string());
+        let document = WorkflowDefinitionMetadata::new(namespace, name, version, title.clone(), summary.clone(), None, None);
+        let mut call_task = CallTaskDefinition::new_function("http", None, Some(true));
+        if let CallTaskDefinition::Function(ref mut f) = call_task {
+             f.common.then = Some("continue".to_string());
+        }
         let do_task = DoTaskDefinition::new(Map::from(vec![("set".to_string(), TaskDefinition::Wait(WaitTaskDefinition::new(OneOfDurationOrIso8601Expression::Duration(Duration::from_milliseconds(200)))))]));
         let mut workflow = WorkflowDefinition::new(document);
         workflow.do_ = Map::new();
@@ -209,7 +214,7 @@ mod unit_tests {
         let mut do_tasks = Map::new();
         do_tasks.add(
             "task1".to_string(),
-            TaskDefinition::Call(CallTaskDefinition::new("someFunction", None, None)),
+            TaskDefinition::Call(CallTaskDefinition::new_function("someFunction", None, None)),
         );
 
         let for_task = ForTaskDefinition::new(for_loop, do_tasks, None);
@@ -384,8 +389,7 @@ mod unit_tests {
                 "version": "0.1.0"
             },
             "use": {
-                "extensions": [
-                    {
+                "extensions": {
                     "mockService": {
                         "extend": "call",
                         "when": "($task.with.endpoint != null and ($task.with.endpoint | startswith(\"https://mocked.service.com\"))) or ($task.with.endpoint.uri != null and ($task.with.endpoint.uri | startswith(\"https://mocked.service.com\")))",
@@ -409,8 +413,8 @@ mod unit_tests {
                         ]
                     }
                 }
-                ]
             },
+
             "do": [
                 {
                     "callHttp": {

core/src/models/authentication.rs

@@ -364,4 +364,14 @@ impl AuthenticationSchemeDefinition for OpenIDConnectSchemeDefinition{
     fn scheme(&self) -> &str {
         AuthenticationScheme::OIDC
     }
+}
+
+/// Represents an authentication policy definition or a reference to one
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum OneOfAuthenticationPolicyDefinitionOrReference {
+    /// Inline authentication policy definition
+    Definition(AuthenticationPolicyDefinition),
+    /// Reference to an authentication policy
+    Reference(String),
 }

core/src/models/error.rs

@@ -5,10 +5,15 @@ use serde_json::Value;
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct ErrorDefinition{
 
+    /// Gets/sets the name of the error to use, if any
+    #[serde(rename = "use", skip_serializing_if = "Option::is_none")]
+    pub use_: Option<String>,
+
     /// Gets/sets an uri that reference the type of the described error
     #[serde(rename = "type")]
     pub type_: String,
 
+
     /// Gets/sets a short, human-readable summary of the error type.It SHOULD NOT change from occurrence to occurrence of the error, except for purposes of localization
     #[serde(rename = "title")]
     pub title: String,
@@ -31,6 +36,7 @@ impl ErrorDefinition{
     /// Initializes a new ErrorDefinition
     pub fn new(type_: &str, title: &str, status: Value, detail: Option<String>, instance: Option<String>) -> Self{
         Self { 
+            use_: None,
             type_: type_.to_string(), 
             title: title.to_string(),
             status, 

core/src/models/event.rs

@@ -6,7 +6,12 @@ use std::collections::HashMap;
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct EventConsumptionStrategyDefinition{
 
+    /// Gets/sets the name of the defined strategy to use, if any
+    #[serde(rename = "use", skip_serializing_if = "Option::is_none")]
+    pub use_: Option<String>,
+
     /// Gets/sets a list containing all the events that must be consumed, if any
+
     #[serde(rename = "all", skip_serializing_if = "Option::is_none")]
     pub all: Option<Vec<EventFilterDefinition>>,
 

core/src/models/input.rs

@@ -6,6 +6,10 @@ use crate::models::schema::*;
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct InputDataModelDefinition{
 
+    /// Gets/sets the name of the input data model to use, if any
+    #[serde(rename = "use", skip_serializing_if = "Option::is_none")]
+    pub use_: Option<String>,
+
     /// Gets/sets the schema, if any, that defines and describes the input data of a workflow or task
     #[serde(rename = "schema", skip_serializing_if = "Option::is_none")]
     pub schema : Option<SchemaDefinition>,

core/src/models/output.rs

@@ -6,11 +6,15 @@ use crate::models::schema::*;
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct OutputDataModelDefinition{
 
-        /// Gets/sets the schema, if any, that defines and describes the output data of a workflow or task
+    /// Gets/sets the name of the output data model to use, if any
+    #[serde(rename = "use", skip_serializing_if = "Option::is_none")]
+    pub use_: Option<String>,
+
+    /// Gets/sets the schema, if any, that defines and describes the output data of a workflow or task
     #[serde(rename = "schema", skip_serializing_if = "Option::is_none")]
     pub schema: Option<SchemaDefinition>,
 
-       /// Gets/sets a runtime expression, if any, used to output specific data to the scope data
+    /// Gets/sets a runtime expression, if any, used to output specific data to the scope data
     #[serde(rename = "as", skip_serializing_if = "Option::is_none")]
     pub as_: Option<Value>
 

core/src/models/resource.rs

@@ -5,6 +5,10 @@ use crate::models::authentication::*;
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct ExternalResourceDefinition{
 
+    /// Gets/sets the name of the external resource to use, if any
+    #[serde(rename = "use", skip_serializing_if = "Option::is_none")]
+    pub use_: Option<String>,
+
     /// Gets/sets the external resource's name, if any
     #[serde(rename = "name", skip_serializing_if = "Option::is_none")]
     pub name: Option<String>,
@@ -15,6 +19,7 @@ pub struct ExternalResourceDefinition{
 
 }
 
+
 /// Represents the definition of an endpoint
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct EndpointDefinition{

core/src/models/retry.rs

@@ -5,10 +5,15 @@ use crate::models::duration::*;
 #[derive(Debug, Default, Clone, PartialEq, Serialize, Deserialize)]
 pub struct RetryPolicyDefinition{
 
+    /// Gets/sets the name of the retry policy to use, if any
+    #[serde(rename = "use", skip_serializing_if = "Option::is_none")]
+    pub use_: Option<String>,
+
     /// Gets/sets a runtime expression used to determine whether or not to retry running the task, in a given context
     #[serde(rename = "when", skip_serializing_if = "Option::is_none")]
     pub when: Option<String>,
 
+
     /// Gets/sets a runtime expression used to determine whether or not to retry running the task, in a given context
     #[serde(rename = "exceptWhen", skip_serializing_if = "Option::is_none")]
     pub except_when: Option<String>,