conductor_ruby 0.1.0

data/lib/conductor/http/models/bulk_response.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Response from bulk workflow operations
+      class BulkResponse < BaseModel
+        SWAGGER_TYPES = {
+          bulk_error_results: 'Hash<String, String>',
+          bulk_successful_results: 'Array<String>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          bulk_error_results: :bulkErrorResults,
+          bulk_successful_results: :bulkSuccessfulResults
+        }.freeze
+
+        attr_accessor :bulk_error_results, :bulk_successful_results
+
+        def initialize(params = {})
+          @bulk_error_results = params[:bulk_error_results] || {}
+          @bulk_successful_results = params[:bulk_successful_results] || []
+        end
+
+        # Check if any errors occurred
+        # @return [Boolean]
+        def errors?
+          !@bulk_error_results.empty?
+        end
+
+        # Check if all operations succeeded
+        # @return [Boolean]
+        def all_successful?
+          @bulk_error_results.empty?
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/conductor_application.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # ConductorApplication model - represents an application in Conductor
+      class ConductorApplication < BaseModel
+        SWAGGER_TYPES = {
+          id: 'String',
+          name: 'String',
+          created_by: 'String',
+          create_time: 'Integer',
+          update_time: 'Integer',
+          updated_by: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          id: :id,
+          name: :name,
+          created_by: :createdBy,
+          create_time: :createTime,
+          update_time: :updateTime,
+          updated_by: :updatedBy
+        }.freeze
+
+        attr_accessor :id, :name, :created_by, :create_time, :update_time, :updated_by
+
+        def initialize(params = {})
+          @id = params[:id]
+          @name = params[:name]
+          @created_by = params[:created_by]
+          @create_time = params[:create_time]
+          @update_time = params[:update_time]
+          @updated_by = params[:updated_by]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/conductor_user.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # ConductorUser model - represents a user in Conductor
+      class ConductorUser < BaseModel
+        SWAGGER_TYPES = {
+          id: 'String',
+          name: 'String',
+          roles: 'Array<Role>',
+          groups: 'Array<Group>',
+          uuid: 'String',
+          application_user: 'Boolean',
+          encrypted_id: 'Boolean',
+          encrypted_id_display_value: 'String',
+          contact_information: 'Hash<String, String>',
+          namespace: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          id: :id,
+          name: :name,
+          roles: :roles,
+          groups: :groups,
+          uuid: :uuid,
+          application_user: :applicationUser,
+          encrypted_id: :encryptedId,
+          encrypted_id_display_value: :encryptedIdDisplayValue,
+          contact_information: :contactInformation,
+          namespace: :namespace
+        }.freeze
+
+        attr_accessor :id, :name, :roles, :groups, :uuid, :application_user,
+                      :encrypted_id, :encrypted_id_display_value,
+                      :contact_information, :namespace
+
+        def initialize(params = {})
+          @id = params[:id]
+          @name = params[:name]
+          @roles = params[:roles]
+          @groups = params[:groups]
+          @uuid = params[:uuid]
+          @application_user = params[:application_user]
+          @encrypted_id = params[:encrypted_id]
+          @encrypted_id_display_value = params[:encrypted_id_display_value]
+          @contact_information = params[:contact_information]
+          @namespace = params[:namespace]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/create_or_update_application_request.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # CreateOrUpdateApplicationRequest model - request to create or update an application
+      class CreateOrUpdateApplicationRequest < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name
+        }.freeze
+
+        attr_accessor :name
+
+        def initialize(params = {})
+          @name = params[:name]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/create_or_update_role_request.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # CreateOrUpdateRoleRequest model - request to create or update a role
+      class CreateOrUpdateRoleRequest < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          permissions: 'Array<String>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          permissions: :permissions
+        }.freeze
+
+        attr_accessor :name, :permissions
+
+        def initialize(params = {})
+          @name = params[:name]
+          @permissions = params[:permissions]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/event_handler.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Event handler definition
+      class EventHandler < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          event: 'String',
+          condition: 'String',
+          actions: 'Array<EventHandlerAction>',
+          active: 'Boolean',
+          evaluator_type: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          event: :event,
+          condition: :condition,
+          actions: :actions,
+          active: :active,
+          evaluator_type: :evaluatorType
+        }.freeze
+
+        attr_accessor :name, :event, :condition, :actions, :active, :evaluator_type
+
+        def initialize(params = {})
+          @name = params[:name]
+          @event = params[:event]
+          @condition = params[:condition]
+          @actions = params[:actions] || []
+          @active = params.fetch(:active, true)
+          @evaluator_type = params[:evaluator_type]
+        end
+      end
+
+      # Action within an event handler
+      class EventHandlerAction < BaseModel
+        SWAGGER_TYPES = {
+          action: 'String',
+          start_workflow: 'StartWorkflow',
+          complete_task: 'TaskDetails',
+          fail_task: 'TaskDetails',
+          expand_inline_json: 'Boolean'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          action: :action,
+          start_workflow: :start_workflow,
+          complete_task: :complete_task,
+          fail_task: :fail_task,
+          expand_inline_json: :expandInlineJSON
+        }.freeze
+
+        # Action types
+        module ActionType
+          START_WORKFLOW = 'start_workflow'
+          COMPLETE_TASK = 'complete_task'
+          FAIL_TASK = 'fail_task'
+        end
+
+        attr_accessor :action, :start_workflow, :complete_task, :fail_task, :expand_inline_json
+
+        def initialize(params = {})
+          @action = params[:action]
+          @start_workflow = params[:start_workflow]
+          @complete_task = params[:complete_task]
+          @fail_task = params[:fail_task]
+          @expand_inline_json = params.fetch(:expand_inline_json, false)
+        end
+      end
+
+      # Start workflow action details
+      class StartWorkflow < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String',
+          version: 'Integer',
+          input: 'Hash<String, Object>',
+          correlation_id: 'String',
+          task_to_domain: 'Hash<String, String>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name,
+          version: :version,
+          input: :input,
+          correlation_id: :correlationId,
+          task_to_domain: :taskToDomain
+        }.freeze
+
+        attr_accessor :name, :version, :input, :correlation_id, :task_to_domain
+
+        def initialize(params = {})
+          @name = params[:name]
+          @version = params[:version]
+          @input = params[:input] || {}
+          @correlation_id = params[:correlation_id]
+          @task_to_domain = params[:task_to_domain]
+        end
+      end
+
+      # Task details for event handler actions (complete_task / fail_task)
+      class TaskDetails < BaseModel
+        SWAGGER_TYPES = {
+          workflow_id: 'String',
+          task_ref_name: 'String',
+          output: 'Hash<String, Object>',
+          task_id: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          workflow_id: :workflowId,
+          task_ref_name: :taskRefName,
+          output: :output,
+          task_id: :taskId
+        }.freeze
+
+        attr_accessor :workflow_id, :task_ref_name, :output, :task_id
+
+        def initialize(params = {})
+          @workflow_id = params[:workflow_id]
+          @task_ref_name = params[:task_ref_name]
+          @output = params[:output] || {}
+          @task_id = params[:task_id]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/generate_token_request.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # GenerateTokenRequest model - request to generate an authentication token
+      class GenerateTokenRequest < BaseModel
+        SWAGGER_TYPES = {
+          key_id: 'String',
+          key_secret: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          key_id: :keyId,
+          key_secret: :keySecret
+        }.freeze
+
+        attr_accessor :key_id, :key_secret
+
+        def initialize(params = {})
+          @key_id = params[:key_id]
+          @key_secret = params[:key_secret]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/group.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Group model - represents a user group
+      class Group < BaseModel
+        SWAGGER_TYPES = {
+          id: 'String',
+          description: 'String',
+          roles: 'Array<Role>',
+          default_access: 'Hash<String, Array<String>>',
+          contact_information: 'Hash<String, String>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          id: :id,
+          description: :description,
+          roles: :roles,
+          default_access: :defaultAccess,
+          contact_information: :contactInformation
+        }.freeze
+
+        attr_accessor :id, :description, :roles, :default_access, :contact_information
+
+        def initialize(params = {})
+          @id = params[:id]
+          @description = params[:description]
+          @roles = params[:roles]
+          @default_access = params[:default_access]
+          @contact_information = params[:contact_information]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/integration.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Integration category constants
+      module IntegrationCategory
+        API = 'API'
+        AI_MODEL = 'AI_MODEL'
+        VECTOR_DB = 'VECTOR_DB'
+        RELATIONAL_DB = 'RELATIONAL_DB'
+      end
+
+      # Integration model - represents an integration provider
+      class Integration < BaseModel
+        SWAGGER_TYPES = {
+          category: 'String',
+          configuration: 'Hash<String, Object>',
+          created_by: 'String',
+          created_on: 'Integer',
+          description: 'String',
+          enabled: 'Boolean',
+          models_count: 'Integer',
+          name: 'String',
+          tags: 'Array<TagObject>',
+          type: 'String',
+          updated_by: 'String',
+          updated_on: 'Integer',
+          apis: 'Array<IntegrationApi>'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          category: :category,
+          configuration: :configuration,
+          created_by: :createdBy,
+          created_on: :createdOn,
+          description: :description,
+          enabled: :enabled,
+          models_count: :modelsCount,
+          name: :name,
+          tags: :tags,
+          type: :type,
+          updated_by: :updatedBy,
+          updated_on: :updatedOn,
+          apis: :apis
+        }.freeze
+
+        attr_accessor :category, :configuration, :created_by, :created_on,
+                      :description, :enabled, :models_count, :name, :tags,
+                      :type, :updated_by, :updated_on, :apis
+
+        def initialize(params = {})
+          @category = params[:category]
+          @configuration = params[:configuration]
+          @created_by = params[:created_by]
+          @created_on = params[:created_on]
+          @description = params[:description]
+          @enabled = params[:enabled]
+          @models_count = params[:models_count]
+          @name = params[:name]
+          @tags = params[:tags]
+          @type = params[:type]
+          @updated_by = params[:updated_by]
+          @updated_on = params[:updated_on]
+          @apis = params[:apis]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/integration_api.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # IntegrationApi model - represents an API/model within an integration provider
+      class IntegrationApi < BaseModel
+        SWAGGER_TYPES = {
+          api: 'String',
+          configuration: 'Hash<String, Object>',
+          created_by: 'String',
+          created_on: 'Integer',
+          description: 'String',
+          enabled: 'Boolean',
+          integration_name: 'String',
+          tags: 'Array<TagObject>',
+          updated_by: 'String',
+          updated_on: 'Integer'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          api: :api,
+          configuration: :configuration,
+          created_by: :createdBy,
+          created_on: :createdOn,
+          description: :description,
+          enabled: :enabled,
+          integration_name: :integrationName,
+          tags: :tags,
+          updated_by: :updatedBy,
+          updated_on: :updatedOn
+        }.freeze
+
+        attr_accessor :api, :configuration, :created_by, :created_on,
+                      :description, :enabled, :integration_name, :tags,
+                      :updated_by, :updated_on
+
+        def initialize(params = {})
+          @api = params[:api]
+          @configuration = params[:configuration]
+          @created_by = params[:created_by]
+          @created_on = params[:created_on]
+          @description = params[:description]
+          @enabled = params[:enabled]
+          @integration_name = params[:integration_name]
+          @tags = params[:tags]
+          @updated_by = params[:updated_by]
+          @updated_on = params[:updated_on]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/integration_api_update.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Frequency constants for integration API updates
+      module Frequency
+        DAILY = 'daily'
+        WEEKLY = 'weekly'
+        MONTHLY = 'monthly'
+      end
+
+      # IntegrationApiUpdate model - request to create/update an integration API
+      class IntegrationApiUpdate < BaseModel
+        SWAGGER_TYPES = {
+          configuration: 'Hash<String, Object>',
+          description: 'String',
+          enabled: 'Boolean',
+          max_tokens: 'Integer',
+          frequency: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          configuration: :configuration,
+          description: :description,
+          enabled: :enabled,
+          max_tokens: :maxTokens,
+          frequency: :frequency
+        }.freeze
+
+        attr_accessor :configuration, :description, :enabled, :max_tokens, :frequency
+
+        def initialize(params = {})
+          @configuration = params[:configuration]
+          @description = params[:description]
+          @enabled = params[:enabled]
+          @max_tokens = params[:max_tokens]
+          @frequency = params[:frequency]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/integration_update.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # IntegrationUpdate model - request to create/update an integration provider
+      class IntegrationUpdate < BaseModel
+        SWAGGER_TYPES = {
+          category: 'String',
+          configuration: 'Hash<String, Object>',
+          description: 'String',
+          enabled: 'Boolean',
+          type: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          category: :category,
+          configuration: :configuration,
+          description: :description,
+          enabled: :enabled,
+          type: :type
+        }.freeze
+
+        attr_accessor :category, :configuration, :description, :enabled, :type
+
+        def initialize(params = {})
+          @category = params[:category]
+          @configuration = params[:configuration]
+          @description = params[:description]
+          @enabled = params[:enabled]
+          @type = params[:type]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/permission.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Permission model - represents a permission entry
+      class Permission < BaseModel
+        SWAGGER_TYPES = {
+          name: 'String'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          name: :name
+        }.freeze
+
+        attr_accessor :name
+
+        def initialize(params = {})
+          @name = params[:name]
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/models/poll_data.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Conductor
+  module Http
+    module Models
+      # Poll data for a task queue
+      class PollData < BaseModel
+        SWAGGER_TYPES = {
+          queue_name: 'String',
+          domain: 'String',
+          worker_id: 'String',
+          last_poll_time: 'Integer'
+        }.freeze
+
+        ATTRIBUTE_MAP = {
+          queue_name: :queueName,
+          domain: :domain,
+          worker_id: :workerId,
+          last_poll_time: :lastPollTime
+        }.freeze
+
+        attr_accessor :queue_name, :domain, :worker_id, :last_poll_time
+
+        def initialize(params = {})
+          @queue_name = params[:queue_name]
+          @domain = params[:domain]
+          @worker_id = params[:worker_id]
+          @last_poll_time = params[:last_poll_time]
+        end
+      end
+    end
+  end
+end