conductor_ruby 0.1.0

data/lib/conductor/http/api/event_resource_api.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # EventResourceApi - API for event handler operations
+      class EventResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Add an event handler
+        # @param [EventHandler] body Event handler definition
+        # @return [void]
+        def add_event_handler(body)
+          @api_client.call_api(
+            '/event',
+            'POST',
+            body: body,
+            return_http_data_only: true
+          )
+        end
+
+        # Update an event handler
+        # @param [EventHandler] body Event handler definition
+        # @return [void]
+        def update_event_handler(body)
+          @api_client.call_api(
+            '/event',
+            'PUT',
+            body: body,
+            return_http_data_only: true
+          )
+        end
+
+        # Get all event handlers
+        # @return [Array<EventHandler>]
+        def get_event_handlers
+          @api_client.call_api(
+            '/event',
+            'GET',
+            return_type: 'Array<EventHandler>',
+            return_http_data_only: true
+          )
+        end
+
+        # Get event handlers for a specific event
+        # @param [String] event Event name
+        # @param [Boolean] active_only Only return active handlers (default: true)
+        # @return [Array<EventHandler>]
+        def get_event_handlers_for_event(event, active_only: true)
+          @api_client.call_api(
+            '/event/{event}',
+            'GET',
+            path_params: { event: event },
+            query_params: { activeOnly: active_only },
+            return_type: 'Array<EventHandler>',
+            return_http_data_only: true
+          )
+        end
+
+        # Remove an event handler
+        # @param [String] name Event handler name
+        # @return [void]
+        def remove_event_handler(name)
+          @api_client.call_api(
+            '/event/{name}',
+            'DELETE',
+            path_params: { name: name },
+            return_http_data_only: true
+          )
+        end
+
+        # Get queue configuration
+        # @param [String] queue_type Queue type
+        # @param [String] queue_name Queue name
+        # @return [Hash]
+        def get_queue_config(queue_type, queue_name)
+          @api_client.call_api(
+            '/event/queue/config/{queueType}/{queueName}',
+            'GET',
+            path_params: { queueType: queue_type, queueName: queue_name },
+            return_type: 'Hash<String, Object>',
+            return_http_data_only: true
+          )
+        end
+
+        # Update queue configuration
+        # @param [String] queue_type Queue type
+        # @param [String] queue_name Queue name
+        # @param [String] body Queue configuration (JSON string)
+        # @return [void]
+        def put_queue_config(queue_type, queue_name, body)
+          @api_client.call_api(
+            '/event/queue/config/{queueType}/{queueName}',
+            'PUT',
+            path_params: { queueType: queue_type, queueName: queue_name },
+            body: body,
+            return_http_data_only: true
+          )
+        end
+
+        # Delete queue configuration
+        # @param [String] queue_type Queue type
+        # @param [String] queue_name Queue name
+        # @return [void]
+        def delete_queue_config(queue_type, queue_name)
+          @api_client.call_api(
+            '/event/queue/config/{queueType}/{queueName}',
+            'DELETE',
+            path_params: { queueType: queue_type, queueName: queue_name },
+            return_http_data_only: true
+          )
+        end
+
+        # Get all queue names
+        # @return [Hash<String, String>]
+        def get_queue_names
+          @api_client.call_api(
+            '/event/queue/config',
+            'GET',
+            return_type: 'Hash<String, String>',
+            return_http_data_only: true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/api/gateway_auth_resource_api.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # GatewayAuthResourceApi - API for gateway authentication config (Orkes)
+      class GatewayAuthResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Create gateway auth config
+        def create_config(body)
+          @api_client.call_api('/gateway/config/auth', 'POST', body: body, return_type: 'String',
+                                                               return_http_data_only: true)
+        end
+
+        # Get gateway auth config by ID
+        def get_config(id)
+          @api_client.call_api('/gateway/config/auth/{id}', 'GET', path_params: { id: id },
+                                                                   return_type: 'AuthenticationConfig', return_http_data_only: true)
+        end
+
+        # List all gateway auth configs
+        def list_configs
+          @api_client.call_api('/gateway/config/auth', 'GET', return_type: 'Array<AuthenticationConfig>',
+                                                              return_http_data_only: true)
+        end
+
+        # Update gateway auth config
+        def update_config(id, body)
+          @api_client.call_api('/gateway/config/auth/{id}', 'PUT', path_params: { id: id }, body: body,
+                                                                   return_http_data_only: true)
+        end
+
+        # Delete gateway auth config
+        def delete_config(id)
+          @api_client.call_api('/gateway/config/auth/{id}', 'DELETE', path_params: { id: id },
+                                                                      return_http_data_only: true)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/api/group_resource_api.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # GroupResourceApi - API for group management operations (Orkes)
+      class GroupResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Create or update a group
+        def upsert_group(body, id)
+          @api_client.call_api('/groups/{id}', 'PUT', path_params: { id: id }, body: body, return_type: 'Group',
+                                                      return_http_data_only: true)
+        end
+
+        # Get a group by ID
+        def get_group(id)
+          @api_client.call_api('/groups/{id}', 'GET', path_params: { id: id }, return_type: 'Group',
+                                                      return_http_data_only: true)
+        end
+
+        # List all groups
+        def list_groups
+          @api_client.call_api('/groups', 'GET', return_type: 'Array<Group>', return_http_data_only: true)
+        end
+
+        # Delete a group
+        def delete_group(id)
+          @api_client.call_api('/groups/{id}', 'DELETE', path_params: { id: id }, return_http_data_only: true)
+        end
+
+        # Add a user to a group
+        def add_user_to_group(group_id, user_id)
+          @api_client.call_api('/groups/{groupId}/users/{userId}', 'POST',
+                               path_params: { groupId: group_id, userId: user_id }, return_http_data_only: true)
+        end
+
+        # Get users in a group
+        def get_users_in_group(id)
+          @api_client.call_api('/groups/{id}/users', 'GET', path_params: { id: id },
+                                                            return_type: 'Array<ConductorUser>', return_http_data_only: true)
+        end
+
+        # Remove a user from a group
+        def remove_user_from_group(group_id, user_id)
+          @api_client.call_api('/groups/{groupId}/users/{userId}', 'DELETE',
+                               path_params: { groupId: group_id, userId: user_id }, return_http_data_only: true)
+        end
+
+        # Add multiple users to a group
+        def add_users_to_group(group_id, user_ids)
+          @api_client.call_api('/groups/{groupId}/users', 'POST', path_params: { groupId: group_id }, body: user_ids,
+                                                                  return_http_data_only: true)
+        end
+
+        # Remove multiple users from a group
+        def remove_users_from_group(group_id, user_ids)
+          @api_client.call_api('/groups/{groupId}/users', 'DELETE', path_params: { groupId: group_id }, body: user_ids,
+                                                                    return_http_data_only: true)
+        end
+
+        # Get granted permissions for a group
+        def get_granted_permissions(group_id)
+          @api_client.call_api('/groups/{groupId}/permissions', 'GET', path_params: { groupId: group_id },
+                                                                       return_type: 'Object', return_http_data_only: true)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/api/integration_resource_api.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # IntegrationResourceApi - API for integration management operations (Orkes)
+      class IntegrationResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Save (create/update) an integration provider
+        def save_integration(body, name)
+          @api_client.call_api('/integrations/provider/{name}', 'POST', path_params: { name: name }, body: body,
+                                                                        return_http_data_only: true)
+        end
+
+        # Get an integration provider
+        def get_integration(name)
+          @api_client.call_api('/integrations/provider/{name}', 'GET', path_params: { name: name },
+                                                                       return_type: 'Integration', return_http_data_only: true)
+        end
+
+        # Get all integration providers
+        def get_integrations
+          @api_client.call_api('/integrations/provider', 'GET', return_type: 'Array<Integration>',
+                                                                return_http_data_only: true)
+        end
+
+        # Delete an integration provider
+        def delete_integration(name)
+          @api_client.call_api('/integrations/provider/{name}', 'DELETE', path_params: { name: name },
+                                                                          return_http_data_only: true)
+        end
+
+        # Save (create/update) an integration API
+        def save_integration_api(body, name, integration_name)
+          @api_client.call_api('/integrations/provider/{name}/integration/{integration_name}', 'POST',
+                               path_params: { name: name, integration_name: integration_name }, body: body, return_http_data_only: true)
+        end
+
+        # Get an integration API
+        def get_integration_api(name, integration_name)
+          @api_client.call_api('/integrations/provider/{name}/integration/{integration_name}', 'GET',
+                               path_params: { name: name, integration_name: integration_name }, return_type: 'IntegrationApi', return_http_data_only: true)
+        end
+
+        # Get all integration APIs for a provider
+        def get_integration_apis(name)
+          @api_client.call_api('/integrations/provider/{name}/integration', 'GET',
+                               path_params: { name: name }, return_type: 'Array<IntegrationApi>', return_http_data_only: true)
+        end
+
+        # Delete an integration API
+        def delete_integration_api(name, integration_name)
+          @api_client.call_api('/integrations/provider/{name}/integration/{integration_name}', 'DELETE',
+                               path_params: { name: name, integration_name: integration_name }, return_http_data_only: true)
+        end
+
+        # Associate a prompt with an integration
+        def associate_prompt_with_integration(integration_provider, integration_name, prompt_name)
+          @api_client.call_api('/integrations/provider/{integration_provider}/integration/{integration_name}/prompt/{prompt_name}', 'POST',
+                               path_params: { integration_provider: integration_provider, integration_name: integration_name, prompt_name: prompt_name },
+                               return_http_data_only: true)
+        end
+
+        # Get prompts associated with an integration
+        def get_prompts_with_integration(integration_provider, integration_name)
+          @api_client.call_api('/integrations/provider/{integration_provider}/integration/{integration_name}/prompt', 'GET',
+                               path_params: { integration_provider: integration_provider, integration_name: integration_name },
+                               return_type: 'Array<PromptTemplate>', return_http_data_only: true)
+        end
+
+        # Get token usage for an integration API
+        def get_token_usage_for_integration(name, integration_name)
+          @api_client.call_api('/integrations/provider/{name}/integration/{integration_name}/metrics', 'GET',
+                               path_params: { name: name, integration_name: integration_name }, return_type: 'Integer', return_http_data_only: true)
+        end
+
+        # Get token usage for an integration provider
+        def get_token_usage_for_integration_provider(name)
+          @api_client.call_api('/integrations/provider/{name}/metrics', 'GET',
+                               path_params: { name: name }, return_type: 'Object', return_http_data_only: true)
+        end
+
+        # Set tags for an integration API
+        def put_tag_for_integration(body, name, integration_name)
+          @api_client.call_api('/integrations/provider/{name}/integration/{integration_name}/tags', 'PUT',
+                               path_params: { name: name, integration_name: integration_name }, body: body, return_http_data_only: true)
+        end
+
+        # Get tags for an integration API
+        def get_tags_for_integration(name, integration_name)
+          @api_client.call_api('/integrations/provider/{name}/integration/{integration_name}/tags', 'GET',
+                               path_params: { name: name, integration_name: integration_name }, return_type: 'Array<TagObject>', return_http_data_only: true)
+        end
+
+        # Delete tags for an integration API
+        def delete_tag_for_integration(body, name, integration_name)
+          @api_client.call_api('/integrations/provider/{name}/integration/{integration_name}/tags', 'DELETE',
+                               path_params: { name: name, integration_name: integration_name }, body: body, return_http_data_only: true)
+        end
+
+        # Set tags for an integration provider
+        def put_tag_for_integration_provider(body, name)
+          @api_client.call_api('/integrations/provider/{name}/tags', 'PUT',
+                               path_params: { name: name }, body: body, return_http_data_only: true)
+        end
+
+        # Get tags for an integration provider
+        def get_tags_for_integration_provider(name)
+          @api_client.call_api('/integrations/provider/{name}/tags', 'GET',
+                               path_params: { name: name }, return_type: 'Array<TagObject>', return_http_data_only: true)
+        end
+
+        # Delete tags for an integration provider
+        def delete_tag_for_integration_provider(body, name)
+          @api_client.call_api('/integrations/provider/{name}/tags', 'DELETE',
+                               path_params: { name: name }, body: body, return_http_data_only: true)
+        end
+
+        # Get available APIs for an integration
+        def get_integration_available_apis(name)
+          @api_client.call_api('/integrations/provider/{name}/integration/all', 'GET',
+                               path_params: { name: name }, return_type: 'Array<IntegrationApi>', return_http_data_only: true)
+        end
+
+        # Get integration provider definitions
+        def get_integration_provider_defs
+          @api_client.call_api('/integrations/def', 'GET', return_type: 'Object', return_http_data_only: true)
+        end
+
+        # Get all providers and integrations
+        def get_providers_and_integrations
+          @api_client.call_api('/integrations/all', 'GET', return_type: 'Array<Integration>',
+                                                           return_http_data_only: true)
+        end
+      end
+    end
+  end
+end

data/lib/conductor/http/api/metadata_resource_api.rb

@@ -0,0 +1,231 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # MetadataResourceApi - API for workflow and task metadata operations
+      # Manages task definitions and workflow definitions
+      class MetadataResourceApi
+        attr_accessor :api_client
+
+        # Initialize MetadataResourceApi
+        # @param [ApiClient] api_client Optional API client
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # ==========================================
+        # Workflow Definition Operations
+        # ==========================================
+
+        # Create a new workflow definition
+        # @param [WorkflowDef] body Workflow definition
+        # @param [Boolean] overwrite Overwrite existing definition (default: false)
+        # @return [Object] Response object
+        def create_workflow(body, overwrite: false)
+          @api_client.call_api(
+            '/metadata/workflow',
+            'POST',
+            query_params: { overwrite: overwrite },
+            body: body,
+            return_type: 'Object',
+            return_http_data_only: true
+          )
+        end
+
+        # Update workflow definition(s)
+        # @param [Array<WorkflowDef>] body List of workflow definitions
+        # @param [Boolean] overwrite Overwrite existing definitions (default: true)
+        # @return [Object] Response object
+        def update_workflows(body, overwrite: true)
+          @api_client.call_api(
+            '/metadata/workflow',
+            'PUT',
+            query_params: { overwrite: overwrite },
+            body: body,
+            return_type: 'Object',
+            return_http_data_only: true
+          )
+        end
+
+        # Get a workflow definition by name
+        # @param [String] name Workflow name
+        # @param [Integer] version Workflow version (optional, returns latest if not specified)
+        # @return [WorkflowDef] Workflow definition
+        def get_workflow_def(name, version: nil)
+          query_params = {}
+          query_params[:version] = version if version
+
+          @api_client.call_api(
+            '/metadata/workflow/{name}',
+            'GET',
+            path_params: { name: name },
+            query_params: query_params,
+            return_type: 'WorkflowDef',
+            return_http_data_only: true
+          )
+        end
+
+        # Get all workflow definitions
+        # @param [String] access Access level filter (optional)
+        # @return [Array<WorkflowDef>] List of workflow definitions
+        def get_all_workflows(access: nil)
+          query_params = {}
+          query_params[:access] = access if access
+
+          @api_client.call_api(
+            '/metadata/workflow',
+            'GET',
+            query_params: query_params,
+            return_type: 'Array<WorkflowDef>',
+            return_http_data_only: true
+          )
+        end
+
+        # Unregister (delete) a workflow definition
+        # @param [String] name Workflow name
+        # @param [Integer] version Workflow version
+        # @return [void]
+        def unregister_workflow_def(name, version:)
+          @api_client.call_api(
+            '/metadata/workflow/{name}/{version}',
+            'DELETE',
+            path_params: { name: name, version: version },
+            return_http_data_only: true
+          )
+        end
+
+        # ==========================================
+        # Task Definition Operations
+        # ==========================================
+
+        # Register (create) task definition(s)
+        # @param [Array<TaskDef>] body List of task definitions
+        # @return [Object] Response object
+        def register_task_def(body)
+          # Ensure body is an array
+          task_defs = body.is_a?(Array) ? body : [body]
+
+          @api_client.call_api(
+            '/metadata/taskdefs',
+            'POST',
+            body: task_defs,
+            return_type: 'Object',
+            return_http_data_only: true
+          )
+        end
+
+        # Update an existing task definition
+        # @param [TaskDef] body Task definition
+        # @return [Object] Response object
+        def update_task_def(body)
+          @api_client.call_api(
+            '/metadata/taskdefs',
+            'PUT',
+            body: body,
+            return_type: 'Object',
+            return_http_data_only: true
+          )
+        end
+
+        # Get a task definition by name
+        # @param [String] task_type Task type name
+        # @return [TaskDef] Task definition
+        def get_task_def(task_type)
+          @api_client.call_api(
+            '/metadata/taskdefs/{tasktype}',
+            'GET',
+            path_params: { tasktype: task_type },
+            return_type: 'TaskDef',
+            return_http_data_only: true
+          )
+        end
+
+        # Get all task definitions
+        # @param [String] access Access level filter (optional)
+        # @return [Array<TaskDef>] List of task definitions
+        def get_all_task_defs(access: nil)
+          query_params = {}
+          query_params[:access] = access if access
+
+          @api_client.call_api(
+            '/metadata/taskdefs',
+            'GET',
+            query_params: query_params,
+            return_type: 'Array<TaskDef>',
+            return_http_data_only: true
+          )
+        end
+
+        # Unregister (delete) a task definition
+        # @param [String] task_type Task type name
+        # @return [void]
+        def unregister_task_def(task_type)
+          @api_client.call_api(
+            '/metadata/taskdefs/{tasktype}',
+            'DELETE',
+            path_params: { tasktype: task_type },
+            return_http_data_only: true
+          )
+        end
+
+        # ==========================================
+        # Workflow Metadata (Tags) Operations
+        # ==========================================
+
+        # Store metadata (tags) associated with a workflow
+        # @param [String] name Workflow name
+        # @param [Object] body Workflow tag/metadata
+        # @param [Integer] version Workflow version (optional)
+        # @return [void]
+        def create_workflow_metadata(name, body, version: nil)
+          query_params = {}
+          query_params[:version] = version if version
+
+          @api_client.call_api(
+            '/metadata/tags/workflow/{name}',
+            'POST',
+            path_params: { name: name },
+            query_params: query_params,
+            body: body,
+            return_http_data_only: true
+          )
+        end
+
+        # Get metadata (tags) associated with a workflow
+        # @param [String] name Workflow name
+        # @param [Integer] version Workflow version (optional)
+        # @return [Object] Workflow metadata/tags
+        def get_workflow_metadata(name, version: nil)
+          query_params = {}
+          query_params[:version] = version if version
+
+          @api_client.call_api(
+            '/metadata/tags/workflow/{name}',
+            'GET',
+            path_params: { name: name },
+            query_params: query_params,
+            return_type: 'Object',
+            return_http_data_only: true
+          )
+        end
+
+        # Delete metadata (tags) associated with a workflow
+        # @param [String] name Workflow name
+        # @param [Integer] version Workflow version
+        # @return [void]
+        def delete_workflow_metadata(name, version:)
+          @api_client.call_api(
+            '/metadata/tags/workflow/{name}',
+            'DELETE',
+            path_params: { name: name },
+            query_params: { version: version },
+            return_http_data_only: true
+          )
+        end
+      end
+    end
+  end
+end