tyler_efm_client 1.0.0.pre.alpha.1

data/lib/tyler_efm_client/result_types.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module TylerEfmClient
+  ##
+  # Result from authentication request
+  class AuthenticationResult
+    attr_reader :success, :password_hash, :user_id, :first_name, :last_name, 
+                :email, :expiration_date, :error_code, :error_message
+
+    def initialize(success: false, password_hash: nil, user_id: nil, first_name: nil,
+                   last_name: nil, email: nil, expiration_date: nil, error_code: nil, error_message: nil)
+      @success = success
+      @password_hash = password_hash
+      @user_id = user_id
+      @first_name = first_name
+      @last_name = last_name
+      @email = email
+      @expiration_date = expiration_date
+      @error_code = error_code
+      @error_message = error_message
+    end
+
+    ##
+    # Returns true if authentication was successful
+    def success?
+      @success
+    end
+
+    ##
+    # Returns a hash representation of the result
+    def to_h
+      {
+        success: @success,
+        password_hash: @password_hash,
+        user_id: @user_id,
+        first_name: @first_name,
+        last_name: @last_name,
+        email: @email,
+        expiration_date: @expiration_date,
+        error_code: @error_code,
+        error_message: @error_message
+      }
+    end
+  end
+
+  ##
+  # Response from EFM service call
+  class ServiceResponse
+    attr_reader :success, :status_code, :raw_xml, :json_data, :error_message
+
+    def initialize(success: false, status_code: 0, raw_xml: '', json_data: nil, error_message: nil)
+      @success = success
+      @status_code = status_code
+      @raw_xml = raw_xml
+      @json_data = json_data
+      @error_message = error_message
+    end
+
+    ##
+    # Returns true if the service call was successful
+    def success?
+      @success
+    end
+
+    ##
+    # Returns a hash representation of the response
+    def to_h
+      {
+        success: @success,
+        status_code: @status_code,
+        raw_xml: @raw_xml,
+        json_data: @json_data,
+        error_message: @error_message
+      }
+    end
+  end
+end

data/lib/tyler_efm_client/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module TylerEfmClient
+  # Current version of the Tyler EFM Client gem
+  VERSION = '1.0.0.pre.alpha.1'
+end

data/lib/tyler_efm_client.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'tyler_efm_client/version'
+require_relative 'tyler_efm_client/client'
+require_relative 'tyler_efm_client/errors'
+require_relative 'tyler_efm_client/result_types'
+
+##
+# Tyler EFM Client - Ruby SDK for Tyler Technologies Electronic Filing Manager (EFM) Services
+#
+# This gem provides a simple, production-ready interface for integrating with Tyler's
+# ECF (Electronic Court Filing) services, including authentication and SOAP service calls.
+#
+# Author:: Tyler Technologies ECF Integration Team
+# License:: MIT
+#
+# @example Basic usage
+#   client = TylerEfmClient::Client.new
+#   
+#   # Authenticate
+#   auth_result = client.authenticate(
+#     base_url: "https://server.com/EFM/EFMUserService.svc",
+#     pfx_file: "certificate.pfx",
+#     pfx_password: "password",
+#     user_email: "user@example.com",
+#     user_password: "userpass"
+#   )
+#   
+#   if auth_result.success?
+#     # Call a service
+#     response = client.call_service(
+#       base_url: "https://server.com/efm/v5/CourtRecordService.svc",
+#       password_hash: auth_result.password_hash,
+#       operation: "GetCaseList",
+#       soap_body: "<GetCaseListRequest>...</GetCaseListRequest>",
+#       user_email: "user@example.com",
+#       return_json: true
+#     )
+#   end
+module TylerEfmClient
+end

data/publish_gem.rb

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'fileutils'
+
+##
+# Publication script for Tyler EFM Client Ruby gem
+def run_command(command, description)
+  puts "🔄 #{description}..."
+  result = system(command)
+  if result
+    puts "✅ #{description} completed"
+    true
+  else
+    puts "❌ #{description} failed"
+    false
+  end
+end
+
+def clean_build
+  puts '🧹 Cleaning previous build artifacts...'
+  
+  files_to_clean = ['*.gem', 'Gemfile.lock']
+  files_to_clean.each do |pattern|
+    Dir.glob(pattern).each do |file|
+      File.delete(file)
+      puts "   Removed: #{file}"
+    end
+  end
+  
+  puts '✅ Build artifacts cleaned'
+end
+
+def pre_publication_checks
+  puts '🔍 Running pre-publication checks...'
+  
+  # Check for required files
+  required_files = ['lib/tyler_efm_client.rb', 'README.md', 'LICENSE', 'CHANGELOG.md']
+  missing_files = required_files.reject { |file| File.exist?(file) }
+  
+  unless missing_files.empty?
+    puts "❌ Missing required files: #{missing_files.join(', ')}"
+    return false
+  end
+  
+  # Check version in gemspec
+  unless File.read('tyler_efm_client.gemspec').include?('1.0.0')
+    puts '❌ Version not found in gemspec'
+    return false
+  end
+  
+  puts '✅ Pre-publication checks passed'
+  true
+end
+
+def build_and_verify_gem
+  puts '🔨 Building gem...'
+  
+  unless run_command('gem build tyler_efm_client.gemspec', 'Building gem')
+    return false
+  end
+  
+  # Verify the built gem
+  gem_file = 'tyler_efm_client-1.0.0.gem'
+  unless File.exist?(gem_file)
+    puts "❌ Gem file #{gem_file} not found after build"
+    return false
+  end
+  
+  size = File.size(gem_file)
+  puts "📦 Built gem: #{gem_file} (#{size} bytes)"
+  
+  # Verify gem contents
+  puts '🔍 Verifying gem contents...'
+  result = `gem specification #{gem_file} 2>&1`
+  if $?.success?
+    puts '✅ Gem structure verified'
+    true
+  else
+    puts "❌ Gem verification failed: #{result}"
+    false
+  end
+end
+
+def publish_gem
+  gem_file = 'tyler_efm_client-1.0.0.gem'
+  
+  puts '🚀 Publishing gem to RubyGems.org...'
+  puts "📋 About to publish: #{gem_file}"
+  puts
+  puts '⚠️  IMPORTANT: Make sure you have:'
+  puts '   1. Created your RubyGems.org account'
+  puts '   2. Verified your email address'
+  puts '   3. Set up API key with: gem signin'
+  puts
+  print 'Continue with publication? (y/N): '
+  
+  response = STDIN.gets.chomp.downcase
+  unless response == 'y' || response == 'yes'
+    puts '📦 Publication cancelled. Gem is ready when you are!'
+    return true
+  end
+  
+  if run_command("gem push #{gem_file}", 'Publishing to RubyGems.org')
+    puts
+    puts '🎉 Gem published successfully!'
+    puts "📋 Your gem is now available at: https://rubygems.org/gems/tyler_efm_client"
+    puts
+    puts '📚 Next steps:'
+    puts '   1. Verify the gem page on RubyGems.org'
+    puts '   2. Test installation: gem install tyler_efm_client'
+    puts '   3. Update any documentation with the new gem location'
+    true
+  else
+    puts '❌ Publication failed. Please check your RubyGems.org credentials and try again.'
+    false
+  end
+end
+
+def main
+  puts 'Tyler EFM Client - Ruby Gem Publication Script'
+  puts '=' * 55
+  
+  # Clean previous builds
+  clean_build
+  
+  # Run pre-publication checks
+  unless pre_publication_checks
+    puts '❌ Pre-publication checks failed. Please fix issues and try again.'
+    return false
+  end
+  
+  # Install dependencies
+  unless run_command('bundle install', 'Installing dependencies')
+    return false
+  end
+  
+  # Build and verify gem
+  unless build_and_verify_gem
+    puts '❌ Gem build or verification failed.'
+    return false
+  end
+  
+  # Run tests one more time
+  puts '🧪 Running final tests...'
+  unless run_command('ruby test_gem.rb', 'Running gem tests')
+    puts '❌ Tests failed. Please fix issues before publishing.'
+    return false
+  end
+  
+  # Publish gem
+  publish_gem
+end
+
+exit(main ? 0 : 1) if __FILE__ == $0

data/samples/court_filing_workflow/README.md

@@ -0,0 +1,332 @@
+# Court Filing Workflow Samples - Ruby
+
+This directory contains complete examples for common court filing workflows using the Tyler EFM Ruby SDK.
+
+## 📋 Overview
+
+These samples demonstrate real-world integration patterns for:
+- Document filing processes
+- Case status checking
+- Filing status monitoring
+- Error handling and retry logic
+
+## 🗂️ Samples Included
+
+### 1. Basic Document Filing (`file_document.rb`)
+Complete workflow for filing a document:
+- Authenticate with Tyler EFM
+- Prepare filing metadata
+- Submit document for filing
+- Monitor filing status
+
+### 2. Filing Status Check (`check_filing_status.rb`)
+Monitor the status of filed documents:
+- Check filing progress
+- Handle different status types
+- Implement polling logic
+- Process completion notifications
+
+### 3. Multi-Document Filing (`bulk_filing.rb`)
+File multiple documents in a single workflow:
+- Batch document preparation
+- Sequential filing process
+- Error handling for partial failures
+- Summary reporting
+
+## 🚀 Quick Start
+
+### Prerequisites
+```bash
+gem install tyler_efm_client
+```
+
+### Configuration
+Create a `config.json` file:
+```json
+{
+  "staging": {
+    "user_service": "https://georgia-stage.tylertech.cloud/EFM/EFMUserService.svc",
+    "court_service": "https://georgia-stage.tylertech.cloud/efm/v5/CourtRecordService.svc",
+    "cert_file": "path/to/certificate.pfx",
+    "cert_password": "certificate_password",
+    "user_email": "your-email@example.com",
+    "user_password": "your_password"
+  }
+}
+```
+
+### Run Samples
+```bash
+ruby file_document.rb
+ruby check_filing_status.rb
+ruby bulk_filing.rb
+```
+
+## 📖 Sample Details
+
+### File Document Workflow
+
+```ruby
+require 'tyler_efm_client'
+
+class DocumentFilingWorkflow
+  def initialize(config)
+    @config = config
+    @client = TylerEfmClient::Client.new
+    @password_hash = nil
+  end
+  
+  def file_document_workflow(case_id:, document_path:, document_type: 'Motion')
+    # Step 1: Authenticate
+    authenticate_user
+    
+    # Step 2: Prepare filing
+    filing_data = prepare_filing_request(
+      case_id: case_id,
+      doc_type: document_type,
+      document_path: document_path
+    )
+    
+    # Step 3: Submit filing
+    filing_result = submit_filing(filing_data)
+    
+    # Step 4: Monitor status
+    if filing_result[:success]
+      final_status = monitor_filing_status(filing_result[:filing_id])
+      return final_status
+    end
+    
+    filing_result
+  end
+end
+```
+
+### Status Monitoring with Ruby Blocks
+
+```ruby
+def monitor_filing_status(filing_id, timeout_minutes: 30)
+  start_time = Time.now
+  timeout_seconds = timeout_minutes * 60
+  
+  loop do
+    elapsed = Time.now - start_time
+    break if elapsed > timeout_seconds
+    
+    status_response = check_filing_status(filing_id)
+    
+    case status_response[:status]
+    when 'Complete', 'Filed'
+      return status_response
+    when 'Error', 'Rejected'
+      return status_response
+    else
+      puts "Status: #{status_response[:status]} - Waiting..."
+      sleep(30)
+    end
+  end
+  
+  raise StandardError, "Filing status check timed out after #{timeout_minutes} minutes"
+end
+```
+
+## 🔧 Ruby-Specific Patterns
+
+### 1. Hash-Based Configuration
+```ruby
+class FilingConfiguration
+  attr_reader :environment, :config
+  
+  def initialize(config_file: 'config.json', environment: :staging)
+    @environment = environment
+    @config = load_config(config_file)
+  end
+  
+  private
+  
+  def load_config(config_file)
+    raise "Configuration file not found: #{config_file}" unless File.exist?(config_file)
+    
+    require 'json'
+    config = JSON.parse(File.read(config_file), symbolize_names: true)
+    
+    raise "Environment '#{environment}' not found in config" unless config[environment]
+    
+    config[environment]
+  end
+end
+```
+
+### 2. Method Chaining
+```ruby
+class TylerEfmWorkflow
+  def initialize
+    @client = TylerEfmClient::Client.new
+  end
+  
+  def authenticate(config)
+    @auth_result = @client.authenticate(**config)
+    raise TylerEfmClient::AuthenticationError, @auth_result.error_message unless @auth_result.success?
+    self
+  end
+  
+  def file_document(case_id:, document_path:, **options)
+    # Implementation
+    self
+  end
+  
+  def monitor_status(filing_id, **options)
+    # Implementation
+    self
+  end
+end
+
+# Usage
+workflow = TylerEfmWorkflow.new
+  .authenticate(config)
+  .file_document(case_id: '12345', document_path: 'motion.pdf')
+  .monitor_status(filing_id, timeout_minutes: 30)
+```
+
+### 3. Error Handling with Custom Exceptions
+```ruby
+module TylerEfmWorkflow
+  class FilingError < StandardError
+    attr_reader :filing_id, :error_code
+    
+    def initialize(message, filing_id: nil, error_code: nil)
+      super(message)
+      @filing_id = filing_id
+      @error_code = error_code
+    end
+  end
+  
+  def robust_filing_workflow
+    yield
+  rescue TylerEfmClient::AuthenticationError => e
+    puts "Authentication failed: #{e.message}"
+    # Handle authentication issues
+  rescue TylerEfmClient::ServiceError => e
+    puts "Service error: #{e.message}"
+    # Handle service-specific errors
+  rescue FilingError => e
+    puts "Filing error: #{e.message}"
+    puts "Filing ID: #{e.filing_id}" if e.filing_id
+    puts "Error Code: #{e.error_code}" if e.error_code
+  rescue StandardError => e
+    puts "Unexpected error: #{e.message}"
+    # Handle unexpected issues
+  end
+end
+```
+
+### 4. Document Preparation with Ruby
+```ruby
+require 'base64'
+require 'pathname'
+
+def prepare_document_for_filing(document_path, document_type: 'Motion')
+  doc_path = Pathname.new(document_path)
+  raise "Document not found: #{document_path}" unless doc_path.exist?
+  
+  # Read and encode document
+  document_content = doc_path.binread
+  encoded_content = Base64.strict_encode64(document_content)
+  
+  {
+    filename: doc_path.basename.to_s,
+    content: encoded_content,
+    content_type: 'application/pdf',
+    document_type: document_type,
+    size: document_content.bytesize
+  }
+end
+```
+
+## 📊 Ruby Response Handling
+
+### Using Structs for Response Objects
+```ruby
+FilingResponse = Struct.new(:success, :filing_id, :status, :message, :errors, keyword_init: true) do
+  def accepted?
+    %w[Accepted Processing].include?(status)
+  end
+  
+  def complete?
+    %w[Complete Filed].include?(status)
+  end
+  
+  def error?
+    %w[Error Rejected].include?(status) || !errors.empty?
+  end
+end
+```
+
+### Pattern Matching (Ruby 3.0+)
+```ruby
+def handle_filing_response(response)
+  case response
+  in { success: true, status: 'Complete' | 'Filed' }
+    puts "✅ Filing completed successfully"
+  in { success: true, status: 'Processing' | 'Accepted' }
+    puts "⏳ Filing is being processed"
+  in { success: false, error_message: message }
+    puts "❌ Filing failed: #{message}"
+  else
+    puts "⚠️ Unknown response format"
+  end
+end
+```
+
+## 🔍 Troubleshooting Ruby-Specific Issues
+
+### Gem Installation Issues
+```ruby
+# Check Ruby version
+puts RUBY_VERSION  # Should be 2.7+
+
+# Check installed gems
+puts Gem.loaded_specs['tyler_efm_client']&.version
+
+# Verify dependencies
+require 'nokogiri'
+puts Nokogiri::VERSION
+```
+
+### Encoding Issues
+```ruby
+# Ensure proper encoding for file operations
+File.open(document_path, 'rb:BINARY') do |file|
+  content = file.read
+  Base64.strict_encode64(content)
+end
+```
+
+### SSL Certificate Issues
+```ruby
+# Debug SSL issues
+require 'openssl'
+puts OpenSSL::OPENSSL_VERSION
+
+# Check certificate
+cert = OpenSSL::PKCS12.new(File.binread(pfx_file), password)
+puts "Certificate subject: #{cert.certificate.subject}"
+```
+
+## 🔗 Related Documentation
+
+- [Getting Started Guide](../../docs/getting_started.md)
+- [Authentication Guide](../../docs/authentication_guide.md)
+- [API Reference](../../docs/api_reference.md)
+- [Case Management Samples](../case_management/)
+
+## 📞 Support
+
+For Ruby-specific filing workflow questions:
+1. Review Tyler ECF documentation
+2. Check Ruby version compatibility
+3. Verify gem installation
+4. Test with staging environment first
+
+---
+
+**🏛️💎 Ready to integrate court filing workflows with Tyler EFM using Ruby!**