conductor_ruby 0.1.0

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # PromptResourceApi - API for prompt template management operations (Orkes)
+      class PromptResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Save a prompt template
+        # @param [String] name Prompt name
+        # @param [String] body Prompt template text
+        # @param [String] description Description
+        # @param [Array<String>] models Associated models
+        # @param [Integer] version Version number
+        # @param [Boolean] auto_increment Auto increment version
+        def save_prompt(name, body, description: nil, models: nil, version: nil, auto_increment: false)
+          query = {}
+          query[:description] = description if description
+          query[:models] = models if models
+          query[:version] = version if version
+          query[:autoIncrement] = auto_increment if auto_increment
+
+          @api_client.call_api(
+            '/prompts/{name}',
+            'POST',
+            path_params: { name: name },
+            query_params: query,
+            body: body,
+            return_http_data_only: true
+          )
+        end
+
+        # Get a prompt template
+        def get_prompt(name)
+          @api_client.call_api('/prompts/{name}', 'GET', path_params: { name: name }, return_type: 'PromptTemplate',
+                                                         return_http_data_only: true)
+        end
+
+        # Get all prompt templates
+        def get_prompts
+          @api_client.call_api('/prompts', 'GET', return_type: 'Array<PromptTemplate>', return_http_data_only: true)
+        end
+
+        # Delete a prompt template
+        def delete_prompt(name)
+          @api_client.call_api('/prompts/{name}', 'DELETE', path_params: { name: name }, return_http_data_only: true)
+        end
+
+        # Get tags for a prompt template
+        def get_tags_for_prompt_template(name)
+          @api_client.call_api('/prompts/{name}/tags', 'GET', path_params: { name: name },
+                                                              return_type: 'Array<TagObject>', return_http_data_only: true)
+        end
+
+        # Update tags for a prompt template
+        def update_tag_for_prompt_template(name, tags)
+          @api_client.call_api('/prompts/{name}/tags', 'PUT', path_params: { name: name }, body: tags,
+                                                              return_http_data_only: true)
+        end
+
+        # Delete tags for a prompt template
+        def delete_tag_for_prompt_template(name, tags)
+          @api_client.call_api('/prompts/{name}/tags', 'DELETE', path_params: { name: name }, body: tags,
+                                                                 return_http_data_only: true)
+        end
+
+        # Test a prompt template
+        def test_prompt(body)
+          @api_client.call_api('/prompts/test', 'POST', body: body, return_type: 'String', return_http_data_only: true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # RoleResourceApi - API for role management operations (Orkes)
+      class RoleResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # List all roles
+        def list_all_roles
+          @api_client.call_api('/roles', 'GET', return_type: 'Array<Role>', return_http_data_only: true)
+        end
+
+        # List system roles
+        def list_system_roles
+          @api_client.call_api('/roles/system', 'GET', return_type: 'Object', return_http_data_only: true)
+        end
+
+        # List custom roles
+        def list_custom_roles
+          @api_client.call_api('/roles/custom', 'GET', return_type: 'Array<Role>', return_http_data_only: true)
+        end
+
+        # List available permissions
+        def list_available_permissions
+          @api_client.call_api('/roles/permissions', 'GET', return_type: 'Object', return_http_data_only: true)
+        end
+
+        # Create a role
+        def create_role(body)
+          @api_client.call_api('/roles', 'POST', body: body, return_type: 'Object', return_http_data_only: true)
+        end
+
+        # Get a role by name
+        def get_role(name)
+          @api_client.call_api('/roles/{name}', 'GET', path_params: { name: name }, return_type: 'Object',
+                                                       return_http_data_only: true)
+        end
+
+        # Update a role
+        def update_role(name, body)
+          @api_client.call_api('/roles/{name}', 'PUT', path_params: { name: name }, body: body, return_type: 'Object',
+                                                       return_http_data_only: true)
+        end
+
+        # Delete a role
+        def delete_role(name)
+          @api_client.call_api('/roles/{name}', 'DELETE', path_params: { name: name }, return_http_data_only: true)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # SchedulerResourceApi - API for workflow schedule operations
+      class SchedulerResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Save (create/update) a workflow schedule
+        # @param [SaveScheduleRequest] body Schedule request
+        # @return [void]
+        def save_schedule(body)
+          @api_client.call_api(
+            '/scheduler/schedules',
+            'POST',
+            body: body,
+            return_http_data_only: true
+          )
+        end
+
+        # Get a schedule by name
+        # @param [String] name Schedule name
+        # @return [WorkflowSchedule]
+        def get_schedule(name)
+          @api_client.call_api(
+            '/scheduler/schedules/{name}',
+            'GET',
+            path_params: { name: name },
+            return_type: 'WorkflowSchedule',
+            return_http_data_only: true
+          )
+        end
+
+        # Get all schedules
+        # @param [String] workflow_name Filter by workflow name (optional)
+        # @return [Array<WorkflowSchedule>]
+        def get_all_schedules(workflow_name: nil)
+          query_params = {}
+          query_params[:workflowName] = workflow_name if workflow_name
+
+          @api_client.call_api(
+            '/scheduler/schedules',
+            'GET',
+            query_params: query_params,
+            return_type: 'Array<WorkflowSchedule>',
+            return_http_data_only: true
+          )
+        end
+
+        # Delete a schedule
+        # @param [String] name Schedule name
+        # @return [void]
+        def delete_schedule(name)
+          @api_client.call_api(
+            '/scheduler/schedules/{name}',
+            'DELETE',
+            path_params: { name: name },
+            return_http_data_only: true
+          )
+        end
+
+        # Pause a schedule
+        # @param [String] name Schedule name
+        # @return [void]
+        def pause_schedule(name)
+          @api_client.call_api(
+            '/scheduler/schedules/{name}/pause',
+            'GET',
+            path_params: { name: name },
+            return_http_data_only: true
+          )
+        end
+
+        # Resume a schedule
+        # @param [String] name Schedule name
+        # @return [void]
+        def resume_schedule(name)
+          @api_client.call_api(
+            '/scheduler/schedules/{name}/resume',
+            'GET',
+            path_params: { name: name },
+            return_http_data_only: true
+          )
+        end
+
+        # Pause all schedules
+        # @return [Hash]
+        def pause_all_schedules
+          @api_client.call_api(
+            '/scheduler/admin/pause',
+            'GET',
+            return_type: 'Hash<String, Object>',
+            return_http_data_only: true
+          )
+        end
+
+        # Resume all schedules
+        # @return [Hash]
+        def resume_all_schedules
+          @api_client.call_api(
+            '/scheduler/admin/resume',
+            'GET',
+            return_type: 'Hash<String, Object>',
+            return_http_data_only: true
+          )
+        end
+
+        # Get next few schedule execution times
+        # @param [String] cron_expression Cron expression
+        # @param [Integer] schedule_start_time Start time (epoch ms, optional)
+        # @param [Integer] schedule_end_time End time (epoch ms, optional)
+        # @param [Integer] limit Number of times to return (optional)
+        # @return [Array<Integer>]
+        def get_next_few_schedules(cron_expression, schedule_start_time: nil, schedule_end_time: nil, limit: nil)
+          query_params = { cronExpression: cron_expression }
+          query_params[:scheduleStartTime] = schedule_start_time if schedule_start_time
+          query_params[:scheduleEndTime] = schedule_end_time if schedule_end_time
+          query_params[:limit] = limit if limit
+
+          @api_client.call_api(
+            '/scheduler/nextFewSchedules',
+            'GET',
+            query_params: query_params,
+            return_type: 'Array<Integer>',
+            return_http_data_only: true
+          )
+        end
+
+        # Search schedule executions
+        # @param [Integer] start Start index (default: 0)
+        # @param [Integer] size Page size (default: 100)
+        # @param [String] sort Sort order (optional)
+        # @param [String] free_text Free text search (default: '*')
+        # @param [String] query Query string (optional)
+        # @return [SearchResult]
+        def search_v2(start: 0, size: 100, sort: nil, free_text: '*', query: nil)
+          query_params = { start: start, size: size, freeText: free_text }
+          query_params[:sort] = sort if sort
+          query_params[:query] = query if query
+
+          @api_client.call_api(
+            '/scheduler/search/executions',
+            'GET',
+            query_params: query_params,
+            return_type: 'SearchResult',
+            return_http_data_only: true
+          )
+        end
+
+        # Requeue all execution records
+        # @return [Hash]
+        def requeue_all_execution_records
+          @api_client.call_api(
+            '/scheduler/admin/requeue',
+            'GET',
+            return_type: 'Hash<String, Object>',
+            return_http_data_only: true
+          )
+        end
+
+        # Set tags for a schedule
+        # @param [String] name Schedule name
+        # @param [Array<Hash>] tags List of tags
+        # @return [void]
+        def put_tag_for_schedule(name, tags)
+          @api_client.call_api(
+            '/scheduler/schedules/{name}/tags',
+            'PUT',
+            path_params: { name: name },
+            body: tags,
+            return_http_data_only: true
+          )
+        end
+
+        # Get tags for a schedule
+        # @param [String] name Schedule name
+        # @return [Array<Hash>]
+        def get_tags_for_schedule(name)
+          @api_client.call_api(
+            '/scheduler/schedules/{name}/tags',
+            'GET',
+            path_params: { name: name },
+            return_type: 'Array<Object>',
+            return_http_data_only: true
+          )
+        end
+
+        # Delete tags for a schedule
+        # @param [String] name Schedule name
+        # @param [Array<Hash>] tags List of tags to delete
+        # @return [void]
+        def delete_tag_for_schedule(name, tags)
+          @api_client.call_api(
+            '/scheduler/schedules/{name}/tags',
+            'DELETE',
+            path_params: { name: name },
+            body: tags,
+            return_http_data_only: true
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # SchemaResourceApi - API for schema management operations (Orkes)
+      class SchemaResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Save a schema definition
+        # @param [SchemaDef] body Schema definition
+        # @param [Boolean] new_version Whether to create a new version
+        # @return [void]
+        def save(body, new_version: false)
+          @api_client.call_api(
+            '/schema',
+            'POST',
+            query_params: { newVersion: new_version },
+            body: body,
+            return_http_data_only: true
+          )
+        end
+
+        # Get a schema by name and version
+        # @param [String] name Schema name
+        # @param [Integer] version Schema version
+        # @return [SchemaDef]
+        def get_schema_by_name_and_version(name, version)
+          @api_client.call_api(
+            '/schema/{name}/{version}',
+            'GET',
+            path_params: { name: name, version: version },
+            return_type: 'SchemaDef',
+            return_http_data_only: true
+          )
+        end
+
+        # Get all schemas
+        # @return [Array<SchemaDef>]
+        def get_all_schemas
+          @api_client.call_api(
+            '/schema',
+            'GET',
+            return_type: 'Array<SchemaDef>',
+            return_http_data_only: true
+          )
+        end
+
+        # Delete a schema by name and version
+        # @param [String] name Schema name
+        # @param [Integer] version Schema version
+        # @return [void]
+        def delete_schema_by_name_and_version(name, version)
+          @api_client.call_api(
+            '/schema/{name}/{version}',
+            'DELETE',
+            path_params: { name: name, version: version },
+            return_http_data_only: true
+          )
+        end
+
+        # Delete all versions of a schema by name
+        # @param [String] name Schema name
+        # @return [void]
+        def delete_schema_by_name(name)
+          @api_client.call_api(
+            '/schema/{name}',
+            'DELETE',
+            path_params: { name: name },
+            return_http_data_only: true
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require_relative '../api_client'
+
+module Conductor
+  module Http
+    module Api
+      # SecretResourceApi - API for secret management operations (Orkes)
+      class SecretResourceApi
+        attr_accessor :api_client
+
+        def initialize(api_client = nil)
+          @api_client = api_client || ApiClient.new
+        end
+
+        # Store a secret value
+        # @param [String] key Secret key
+        # @param [String] value Secret value
+        # @return [void]
+        def put_secret(value, key)
+          @api_client.call_api(
+            '/secrets/{key}',
+            'PUT',
+            path_params: { key: key },
+            body: value,
+            return_http_data_only: true
+          )
+        end
+
+        # Get a secret value
+        # @param [String] key Secret key
+        # @return [String]
+        def get_secret(key)
+          @api_client.call_api(
+            '/secrets/{key}',
+            'GET',
+            path_params: { key: key },
+            return_type: 'String',
+            return_http_data_only: true
+          )
+        end
+
+        # List all secret names
+        # @return [Array<String>]
+        def list_all_secret_names
+          @api_client.call_api(
+            '/secrets',
+            'POST',
+            return_type: 'Array<String>',
+            return_http_data_only: true
+          )
+        end
+
+        # List secrets that user can grant access to
+        # @return [Array<String>]
+        def list_secrets_that_user_can_grant_access_to
+          @api_client.call_api(
+            '/secrets',
+            'GET',
+            return_type: 'Array<String>',
+            return_http_data_only: true
+          )
+        end
+
+        # Delete a secret
+        # @param [String] key Secret key
+        # @return [void]
+        def delete_secret(key)
+          @api_client.call_api(
+            '/secrets/{key}',
+            'DELETE',
+            path_params: { key: key },
+            return_http_data_only: true
+          )
+        end
+
+        # Check if a secret exists
+        # @param [String] key Secret key
+        # @return [Boolean]
+        def secret_exists(key)
+          @api_client.call_api(
+            '/secrets/{key}/exists',
+            'GET',
+            path_params: { key: key },
+            return_type: 'Boolean',
+            return_http_data_only: true
+          )
+        end
+
+        # Set tags for a secret
+        # @param [Array<TagObject>] tags Tags to set
+        # @param [String] key Secret key
+        # @return [void]
+        def put_tag_for_secret(tags, key)
+          @api_client.call_api(
+            '/secrets/{key}/tags',
+            'PUT',
+            path_params: { key: key },
+            body: tags,
+            return_http_data_only: true
+          )
+        end
+
+        # Get tags for a secret
+        # @param [String] key Secret key
+        # @return [Array<TagObject>]
+        def get_tags(key)
+          @api_client.call_api(
+            '/secrets/{key}/tags',
+            'GET',
+            path_params: { key: key },
+            return_type: 'Array<TagObject>',
+            return_http_data_only: true
+          )
+        end
+
+        # Delete tags for a secret
+        # @param [Array<TagObject>] tags Tags to delete
+        # @param [String] key Secret key
+        # @return [Array<TagObject>]
+        def delete_tag_for_secret(tags, key)
+          @api_client.call_api(
+            '/secrets/{key}/tags',
+            'DELETE',
+            path_params: { key: key },
+            body: tags,
+            return_type: 'Array<TagObject>',
+            return_http_data_only: true
+          )
+        end
+      end
+    end
+  end
+end