Evo Voice

CopyFlow

Make a copy of the flow

**Requires Authentication**
Requires any of the roles:	SystemAdministrator, Manager, Customer

The following routes are available for this service:
POST	/flows/{flowId}/copy

import Foundation
import ServiceStack

/**
* Make a copy of the flow
*/
// @Api(Description="Make a copy of the flow")
public class CopyFlow : IPost, Codable
{
    /**
    * The ID of the flow to copy
    */
    // @ApiMember(Description="The ID of the flow to copy")
    public var flowId:String

    required public init(){}
}

public class FlowInfo : EntityInfo
{
    /**
    * The name of this flow
    */
    // @ApiMember(Description="The name of this flow")
    public var name:String

    /**
    * The roles that this flow has
    */
    // @ApiMember(Description="The roles that this flow has")
    public var roles:[FlowRoles]

    /**
    * What this flow does
    */
    // @ApiMember(Description="What this flow does")
    public var Description:String

    /**
    * Any notes for this flow
    */
    // @ApiMember(Description="Any notes for this flow")
    public var notes:String

    /**
    * The ID of the account associated with the flow
    */
    // @ApiMember(Description="The ID of the account associated with the flow")
    public var accountId:String

    /**
    * The name of the account associated with the flow
    */
    // @ApiMember(Description="The name of the account associated with the flow")
    public var accountName:String

    /**
    * The ID of the customer this flow is associated with
    */
    // @ApiMember(Description="The ID of the customer this flow is associated with")
    public var customerId:String

    /**
    * The name of the customer this flow is associated with
    */
    // @ApiMember(Description="The name of the customer this flow is associated with")
    public var customerName:String

    /**
    * The breadcrumb to the flow for this endpoint
    */
    // @ApiMember(Description="The breadcrumb to the flow for this endpoint")
    public var customerBreadcrumb:[CustomerBreadcrumb]

    /**
    * The nodes in this flow
    */
    // @ApiMember(Description="The nodes in this flow")
    public var nodes:[FlowNode]

    /**
    * The flow's parameters
    */
    // @ApiMember(Description="The flow's parameters")
    public var parameters:[FlowParameter]

    /**
    * The flow's exits
    */
    // @ApiMember(Description="The flow's exits")
    public var exits:[FlowExit]

    /**
    * The UI data for the flow
    */
    // @ApiMember(Description="The UI data for the flow")
    public var ui:FlowUI

    /**
    * The list of tags for this flow
    */
    // @ApiMember(Description="The list of tags for this flow")
    public var tags:[Tag]

    /**
    * The number of nodes in this flow
    */
    // @ApiMember(Description="The number of nodes in this flow")
    public var nodeCount:Int

    required public init(){ super.init() }

    private enum CodingKeys : String, CodingKey {
        case name
        case roles
        case Description
        case notes
        case accountId
        case accountName
        case customerId
        case customerName
        case customerBreadcrumb
        case nodes
        case parameters
        case exits
        case ui
        case tags
        case nodeCount
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try container.decodeIfPresent(String.self, forKey: .name)
        roles = try container.decodeIfPresent([FlowRoles].self, forKey: .roles) ?? []
        Description = try container.decodeIfPresent(String.self, forKey: .Description)
        notes = try container.decodeIfPresent(String.self, forKey: .notes)
        accountId = try container.decodeIfPresent(String.self, forKey: .accountId)
        accountName = try container.decodeIfPresent(String.self, forKey: .accountName)
        customerId = try container.decodeIfPresent(String.self, forKey: .customerId)
        customerName = try container.decodeIfPresent(String.self, forKey: .customerName)
        customerBreadcrumb = try container.decodeIfPresent([CustomerBreadcrumb].self, forKey: .customerBreadcrumb) ?? []
        nodes = try container.decodeIfPresent([FlowNode].self, forKey: .nodes) ?? []
        parameters = try container.decodeIfPresent([FlowParameter].self, forKey: .parameters) ?? []
        exits = try container.decodeIfPresent([FlowExit].self, forKey: .exits) ?? []
        ui = try container.decodeIfPresent(FlowUI.self, forKey: .ui)
        tags = try container.decodeIfPresent([Tag].self, forKey: .tags) ?? []
        nodeCount = try container.decodeIfPresent(Int.self, forKey: .nodeCount)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if name != nil { try container.encode(name, forKey: .name) }
        if roles != nil { try container.encode(roles, forKey: .roles) }
        if Description != nil { try container.encode(Description, forKey: .Description) }
        if notes != nil { try container.encode(notes, forKey: .notes) }
        if accountId != nil { try container.encode(accountId, forKey: .accountId) }
        if accountName != nil { try container.encode(accountName, forKey: .accountName) }
        if customerId != nil { try container.encode(customerId, forKey: .customerId) }
        if customerName != nil { try container.encode(customerName, forKey: .customerName) }
        if customerBreadcrumb != nil { try container.encode(customerBreadcrumb, forKey: .customerBreadcrumb) }
        if nodes != nil { try container.encode(nodes, forKey: .nodes) }
        if parameters != nil { try container.encode(parameters, forKey: .parameters) }
        if exits != nil { try container.encode(exits, forKey: .exits) }
        if ui != nil { try container.encode(ui, forKey: .ui) }
        if tags != nil { try container.encode(tags, forKey: .tags) }
        if nodeCount != nil { try container.encode(nodeCount, forKey: .nodeCount) }
    }
}

public class EntityInfo : Codable
{
    /**
    * The ID of the object
    */
    // @ApiMember(Description="The ID of the object")
    public var id:String

    /**
    * The date the object was created
    */
    // @ApiMember(Description="The date the object was created")
    public var dateCreated:String

    /**
    * The date the object was last modified
    */
    // @ApiMember(Description="The date the object was last modified")
    public var dateLastModified:String

    /**
    * The user that created this object
    */
    // @ApiMember(Description="The user that created this object")
    public var createdBy:String

    /**
    * The user that last modified this object
    */
    // @ApiMember(Description="The user that last modified this object")
    public var lastModifiedBy:String

    required public init(){}
}

public enum FlowRoles : String, Codable
{
    case UI
    case Reference
    case PhoneNumberRouting
    case UserDialOut
    case FaxNumberRouting
}

public class CustomerBreadcrumb : Codable
{
    public var id:String
    public var name:String

    required public init(){}
}

public class FlowNode : Codable
{
    /**
    * The ID of this node. Must be unique within the flow but can be anything
    */
    // @ApiMember(Description="The ID of this node. Must be unique within the flow but can be anything")
    public var id:String

    /**
    * Is this the starting node for the flow. Only one node can have this set
    */
    // @ApiMember(Description="Is this the starting node for the flow. Only one node can have this set")
    public var isStartNode:Bool

    /**
    * The name of the node, descriptive to be used as a reminder in the GUI
    */
    // @ApiMember(Description="The name of the node, descriptive to be used as a reminder in the GUI")
    public var name:String

    /**
    * The specification for the node
    */
    // @ApiMember(Description="The specification for the node")
    public var spec:FlowNodeSpec

    /**
    * The UI data for the node
    */
    // @ApiMember(Description="The UI data for the node")
    public var ui:FlowNodeUI

    /**
    * The data for this node. These will be POST'd to the endpoint when it is called.
    */
    // @ApiMember(Description="The data for this node. These will be POST'd to the endpoint when it is called.")
    public var parameters:NodeParameterMap

    required public init(){}
}

public class FlowNodeSpec : Codable
{
    /**
    * The name of this node
    */
    // @ApiMember(Description="The name of this node")
    public var name:String

    /**
    * A description of this node
    */
    // @ApiMember(Description="A description of this node")
    public var Description:String

    /**
    * Icon class for this node (FontAwesome)
    */
    // @ApiMember(Description="Icon class for this node (FontAwesome)")
    public var iconClass:String

    /**
    * The type name for this node
    */
    // @ApiMember(Description="The type name for this node")
    public var typeName:String

    /**
    * The category this node should be grouped under
    */
    // @ApiMember(Description="The category this node should be grouped under")
    public var category:FlowNodeCategories

    /**
    * The URL where this node is located
    */
    // @ApiMember(Description="The URL where this node is located")
    public var url:String

    /**
    * The data type for this node
    */
    // @ApiMember(Description="The data type for this node")
    public var dataType:DataType

    /**
    * URL for documentation for this node
    */
    // @ApiMember(Description="URL for documentation for this node")
    public var documentationUrl:String

    /**
    * The channels that this node is restricted to
    */
    // @ApiMember(Description="The channels that this node is restricted to")
    public var restrictToChannels:[FlowChannels]

    required public init(){}
}

public enum FlowNodeCategories : String, Codable
{
    case General
    case Voice
    case Logic
    case DateAndTime
    case Audio
    case Messaging
    case Assistant
    case Flows
    case Fax
    case Network
    case Cookies
    case CallCenter
    case Intelligence
}

public class DataType : Codable
{
    public var typeName:String
    public var fields:[DataField]

    required public init(){}
}

public class DataField : Codable
{
    public var id:String
    public var name:String
    public var type:ValueTypes
    public var uiHint:UIHints
    public var uiTab:String
    public var isAsync:Bool
    public var disableBinding:Bool
    public var structType:DataType
    public var listType:DataType
    public var Description:String
    public var possibleValues:[String]
    public var isOutput:Bool
    public var customFieldValuesUrl:String
    public var defaultValue:Value
    public var transitionNameFormat:String
    public var uniqueness:DataFieldUniqueness
    public var voiceOnly:Bool
    public var conditionalVisibilityField:String
    public var conditionalVisibilityValue:String
    public var noEvalTemplate:Bool
    public var userMode:UserDataFieldModes
    public var anyValueType:Bool

    required public init(){}
}

public enum ValueTypes : String, Codable
{
    case NotSpecified
    case String
    case Boolean
    case Number
    case List
    case Struct
    case Transition
    case Custom
    case Date
    case AudioFile
    case TimeZoneId
    case PhoneNumber
    case User
    case Endpoint
    case Time
    case File
    case FaxNumber
    case EmailAccount
    case Customer
    case Flow
    case Team
    case FlowReference
    case Integration
    case Assistant
}

public enum UIHints : String, Codable
{
    case None
    case LargeText
    case InlineForm
    case Password
    case InlineStruct
}

public class Value : Codable
{
    public var boolValue:Bool?
    public var stringValue:String
    public var numberValue:Double?
    public var listValue:[Struct]
    public var structValue:Struct

    required public init(){}
}

public class Struct : List<String:Value>
{
    required public init(){ super.init() }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
    }
}

public enum DataFieldUniqueness : String, Codable
{
    case NotUnique
    case Unique
    case UniqueToCustomer
}

public enum UserDataFieldModes : String, Codable
{
    case Hidden
    case ReadOnly
    case ReadWrite
}

public enum FlowChannels : String, Codable
{
    case Voice
    case Chat
    case Fax
}

public class FlowNodeUI : Codable
{
    /**
    * The X position of the node
    */
    // @ApiMember(Description="The X position of the node")
    public var x:Double

    /**
    * The Y position of the node
    */
    // @ApiMember(Description="The Y position of the node")
    public var y:Double

    /**
    * Notes for this node
    */
    // @ApiMember(Description="Notes for this node")
    public var notes:String

    required public init(){}
}

public class NodeParameterMap : List<String:NodeParameter>
{
    required public init(){ super.init() }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
    }
}

public class NodeParameter : Codable
{
    public var id:String
    public var type:ValueTypes
    public var source:ValueSources
    public var isAsync:Bool
    public var referenceId:String
    public var value:Value
    public var noEvalTemplate:Bool
    public var listParameters:[NodeParameterMap]
    public var structParameters:NodeParameterMap
    public var isOutput:Bool
    public var expression:String
    public var listType:DataType

    required public init(){}
}

public enum ValueSources : String, Codable
{
    case Value
    case Flow
    case System
    case Customer
    case Session
    case Endpoint
    case Expression
    case User
}

public class FlowParameter : DataField
{
    public var isPublic:Bool
    public var isKnob:Bool

    required public init(){ super.init() }

    private enum CodingKeys : String, CodingKey {
        case isPublic
        case isKnob
    }

    required public init(from decoder: Decoder) throws {
        try super.init(from: decoder)
        let container = try decoder.container(keyedBy: CodingKeys.self)
        isPublic = try container.decodeIfPresent(Bool.self, forKey: .isPublic)
        isKnob = try container.decodeIfPresent(Bool.self, forKey: .isKnob)
    }

    public override func encode(to encoder: Encoder) throws {
        try super.encode(to: encoder)
        var container = encoder.container(keyedBy: CodingKeys.self)
        if isPublic != nil { try container.encode(isPublic, forKey: .isPublic) }
        if isKnob != nil { try container.encode(isKnob, forKey: .isKnob) }
    }
}

public class FlowExit : Codable
{
    /**
    * The unique ID for this exit
    */
    // @ApiMember(Description="The unique ID for this exit")
    public var id:String

    /**
    * The name of this exit
    */
    // @ApiMember(Description="The name of this exit")
    public var name:String

    /**
    * The UI for the exit
    */
    // @ApiMember(Description="The UI for the exit")
    public var ui:FlowNodeUI

    required public init(){}
}

public class FlowUI : Codable
{
    public var selectedNode:String
    public var canvasX:Double
    public var canvasY:Double
    public var canvasZoom:Double

    required public init(){}
}

public class Tag : Codable
{
    public var id:String
    public var name:String
    public var color:TagColors

    required public init(){}
}

public enum TagColors : String, Codable
{
    case Magenta
    case Red
    case Volcano
    case Orange
    case Gold
    case Lime
    case Green
    case Cyan
    case Blue
    case GeekBlue
    case Purple
}

Swift CopyFlow DTOs

To override the Content-type in your clients, use the HTTP Accept Header, append the .xml suffix or ?format=xml

HTTP + XML

The following are sample HTTP requests and responses. The placeholders shown need to be replaced with actual values.

POST /flows/{flowId}/copy HTTP/1.1 
Host: team.evovoice.io 
Accept: application/xml
Content-Type: application/xml
Content-Length: length

<CopyFlow xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows">
  <FlowId>String</FlowId>
</CopyFlow>

HTTP/1.1 200 OK
Content-Type: application/xml
Content-Length: length

<FlowInfo xmlns:i="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows">
  <CreatedBy xmlns="http://schemas.datacontract.org/2004/07/Voice.Api">String</CreatedBy>
  <DateCreated xmlns="http://schemas.datacontract.org/2004/07/Voice.Api">String</DateCreated>
  <DateLastModified xmlns="http://schemas.datacontract.org/2004/07/Voice.Api">String</DateLastModified>
  <Id xmlns="http://schemas.datacontract.org/2004/07/Voice.Api">String</Id>
  <LastModifiedBy xmlns="http://schemas.datacontract.org/2004/07/Voice.Api">String</LastModifiedBy>
  <AccountId>String</AccountId>
  <AccountName>String</AccountName>
  <CustomerBreadcrumb xmlns:d2p1="http://schemas.datacontract.org/2004/07/Voice.Api.Customers">
    <d2p1:CustomerBreadcrumb>
      <d2p1:Id>String</d2p1:Id>
      <d2p1:Name>String</d2p1:Name>
    </d2p1:CustomerBreadcrumb>
  </CustomerBreadcrumb>
  <CustomerId>String</CustomerId>
  <CustomerName>String</CustomerName>
  <Description>String</Description>
  <Exits>
    <FlowExit>
      <Id>String</Id>
      <Name>String</Name>
      <UI>
        <Notes>String</Notes>
        <X>0</X>
        <Y>0</Y>
      </UI>
    </FlowExit>
  </Exits>
  <Name>String</Name>
  <NodeCount>0</NodeCount>
  <Nodes>
    <FlowNode>
      <Id>String</Id>
      <IsStartNode>false</IsStartNode>
      <Name>String</Name>
      <Parameters xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
        <d4p1:KeyValueOfstringNodeParameteripFhVFNS>
          <d4p1:Key>String</d4p1:Key>
          <d4p1:Value i:nil="true" />
        </d4p1:KeyValueOfstringNodeParameteripFhVFNS>
      </Parameters>
      <Spec>
        <Category>General</Category>
        <DataType xmlns:d5p1="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data" i:nil="true" />
        <Description>String</Description>
        <DocumentationUrl>String</DocumentationUrl>
        <IconClass>String</IconClass>
        <Name>String</Name>
        <RestrictToChannels>
          <FlowChannels>Voice</FlowChannels>
        </RestrictToChannels>
        <TypeName>String</TypeName>
        <Url>String</Url>
      </Spec>
      <UI>
        <Notes>String</Notes>
        <X>0</X>
        <Y>0</Y>
      </UI>
    </FlowNode>
  </Nodes>
  <Notes>String</Notes>
  <Parameters>
    <FlowParameter>
      <AnyValueType xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</AnyValueType>
      <ConditionalVisibilityField xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</ConditionalVisibilityField>
      <ConditionalVisibilityValue xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</ConditionalVisibilityValue>
      <CustomFieldValuesUrl xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</CustomFieldValuesUrl>
      <DefaultValue xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">
        <BoolValue>false</BoolValue>
        <ListValue xmlns:d5p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays">
          <d5p1:ArrayOfKeyValueOfstringValue8Ahp2kgT i:nil="true" />
        </ListValue>
        <NumberValue>0</NumberValue>
        <StringValue>String</StringValue>
        <StructValue xmlns:d5p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" i:nil="true" />
      </DefaultValue>
      <Description xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</Description>
      <DisableBinding xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</DisableBinding>
      <Id xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</Id>
      <IsAsync xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</IsAsync>
      <IsOutput xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</IsOutput>
      <ListType i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data" />
      <Name xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</Name>
      <NoEvalTemplate xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</NoEvalTemplate>
      <PossibleValues xmlns:d4p1="http://schemas.microsoft.com/2003/10/Serialization/Arrays" xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">
        <d4p1:string>String</d4p1:string>
      </PossibleValues>
      <StructType i:nil="true" xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data" />
      <TransitionNameFormat xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</TransitionNameFormat>
      <Type xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">NotSpecified</Type>
      <UIHint xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">None</UIHint>
      <UITab xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">String</UITab>
      <Uniqueness xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">NotUnique</Uniqueness>
      <UserMode xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">Hidden</UserMode>
      <VoiceOnly xmlns="http://schemas.datacontract.org/2004/07/Voice.Api.Flows.Data">false</VoiceOnly>
      <IsKnob>false</IsKnob>
      <IsPublic>false</IsPublic>
    </FlowParameter>
  </Parameters>
  <Roles>
    <FlowRoles>UI</FlowRoles>
  </Roles>
  <Tags xmlns:d2p1="http://schemas.datacontract.org/2004/07/Voice.Api.Settings">
    <d2p1:Tag>
      <d2p1:Color>Magenta</d2p1:Color>
      <d2p1:Id>String</d2p1:Id>
      <d2p1:Name>String</d2p1:Name>
    </d2p1:Tag>
  </Tags>
  <UI>
    <CanvasX>0</CanvasX>
    <CanvasY>0</CanvasY>
    <CanvasZoom>0</CanvasZoom>
    <SelectedNode>String</SelectedNode>
  </UI>
</FlowInfo>