servicetrade 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 82dc5b71eb88760c25b84d5341b0db78a94245eca3e78e3ecec623b263eb8bb2
+  data.tar.gz: 589dd883ba165436c59fe3b1cb562e4ed2263bd36061977c290a12743b2e76b5
+SHA512:
+  metadata.gz: ba667f7a59253c9bc20ba7bc6f97350d2e0b444eed0e39a9825e9b63a4bae78f1fb0b540dcc681455e5c177c9550dc09707d702672fc253d6e480ca172e4e4c8
+  data.tar.gz: 1de099c1400de275c0a0bd15a4de7a72bc1c6629d72649782bfbc4bf8c6af33f0a8d7045148fd55c03466cec1f67d7adbad97c9366464aaebea9e493fc0c385f

data/README.md

@@ -0,0 +1,143 @@
+# ServiceTrade Ruby
+
+A Ruby client library for the ServiceTrade API.
+
+[![Gem Version](https://badge.fury.io/rb/servicetrade.svg)](https://badge.fury.io/rb/servicetrade)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'servicetrade'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install servicetrade
+
+## Configuration
+
+Configure the client with your ServiceTrade credentials:
+
+```ruby
+ServiceTrade.configure do |config|
+  config.username = 'your_username'
+  config.password = 'your_password'
+  config.api_version = '1'  # Optional, defaults to '1'
+  config.timeout = 30       # Optional, defaults to 30 seconds
+  config.open_timeout = 10  # Optional, defaults to 10 seconds
+end
+```
+
+## Authentication
+
+The gem automatically handles authentication with the ServiceTrade API using your username and password. Session management is handled internally.
+
+## Usage
+
+### Jobs
+
+```ruby
+# List all jobs
+jobs = ServiceTrade::Job.list
+
+# Create a new job
+job = ServiceTrade::Job.create(
+  name: 'Service Call',
+  customer_id: 123,
+  location_id: 456,
+  scheduled_date: '2023-12-01'
+)
+
+# Update a job
+ServiceTrade::Job.update(job_id, {
+  status: 'completed',
+  completed_date: Time.now.iso8601
+})
+
+# Delete a job
+ServiceTrade::Job.delete(job_id)
+```
+
+### Appointments
+
+```ruby
+# List appointments
+appointments = ServiceTrade::Appointment.list
+
+# Create an appointment
+appointment = ServiceTrade::Appointment.create(
+  job_id: 123,
+  start_time: '2023-12-01T09:00:00Z',
+  end_time: '2023-12-01T10:00:00Z'
+)
+```
+
+### Locations
+
+```ruby
+# List locations
+locations = ServiceTrade::Location.list
+
+# Create a location
+location = ServiceTrade::Location.create(
+  name: 'Customer Site',
+  address: '123 Main St',
+  city: 'Anytown',
+  state: 'CA',
+  zip: '12345'
+)
+```
+
+## Error Handling
+
+The gem provides specific error classes for different types of API errors:
+
+```ruby
+begin
+  job = ServiceTrade::Job.create(invalid_data)
+rescue ServiceTrade::AuthenticationError => e
+  # Handle authentication errors (401)
+  puts "Authentication failed: #{e.message}"
+rescue ServiceTrade::AuthorizationError => e
+  # Handle authorization errors (403)
+  puts "Not authorized: #{e.message}"
+rescue ServiceTrade::NotFoundError => e
+  # Handle not found errors (404)
+  puts "Resource not found: #{e.message}"
+rescue ServiceTrade::ApiError => e
+  # Handle other API errors
+  puts "API error: #{e.message}"
+end
+```
+
+## Available Resources
+
+- **Job** - Create, read, update, and delete jobs
+- **Appointment** - Manage appointments associated with jobs
+- **Location** - Manage customer locations
+
+Each resource supports standard CRUD operations where applicable:
+- `list` - Retrieve a list of resources
+- `create(params)` - Create a new resource
+- `update(id, params)` - Update an existing resource
+- `delete(id)` - Delete a resource
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/destilado/servicetrade-ruby.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/lib/servicetrade/api_operations/create.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ServiceTrade
+  module ApiOperations
+    module Create
+      def create(params = {})
+        response = ServiceTrade.client.request(:post, resource_url, params)
+        new(response['data'])
+      end
+    end
+  end
+end

data/lib/servicetrade/api_operations/delete.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ServiceTrade
+  module ApiOperations
+    module Delete
+      def delete(id)
+        ServiceTrade.client.request(:delete, "#{resource_url}/#{id}")
+        true
+      end
+    end
+  end
+end

data/lib/servicetrade/api_operations/list.rb

@@ -0,0 +1,67 @@
+# lib/servicetrade/api_operations/list.rb
+module ServiceTrade
+  module ApiOperations
+    module List
+      def list(filters = {}, page: 1, per_page: 100)
+        params = filters.merge({
+          page: page,
+          per_page: per_page
+        })
+
+        response = ServiceTrade.client.request(:get, resource_url, params)
+        ListResponse.new(response, self)
+      end
+
+      # Iterator method for automatically handling pagination
+      def all(filters = {}, per_page: 100, &block)
+        if block_given?
+          page = 1
+          loop do
+            response = list(filters, page: page, per_page: per_page)
+            response.data.each(&block)
+            break unless response.has_more?
+            page += 1
+          end
+        else
+          Enumerator.new do |yielder|
+            page = 1
+            loop do
+              response = list(filters, page: page, per_page: per_page)
+              response.data.each { |item| yielder << item }
+              break unless response.has_more?
+              page += 1
+            end
+          end
+        end
+      end
+    end
+  end
+
+  class ListResponse
+    attr_reader :data, :total_count, :page, :per_page
+
+    def initialize(response, resource_class)
+      # Handle ServiceTrade API response format
+      data_key = case resource_class.name.split('::').last.downcase
+                 when 'job'
+                   'jobs'
+                 when 'appointment'
+                   'appointments'
+                 when 'location'
+                   'locations'
+                 else
+                   'data'
+                 end
+      
+      items = response.dig('data', data_key) || response['data'] || []
+      @data = items.map { |item| resource_class.new(item) }
+      @total_count = response.dig('data', 'total') || response['total'] || items.length
+      @page = response.dig('data', 'page') || response['page'] || 1
+      @per_page = response.dig('data', 'per_page') || response['per_page'] || items.length
+    end
+
+    def has_more?
+      (@page * @per_page) < @total_count
+    end
+  end
+end

data/lib/servicetrade/api_operations/update.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module ServiceTrade
+  module ApiOperations
+    module Update
+      def update(id, params = {})
+        response = ServiceTrade.client.request(:put, "#{resource_url}/#{id}", params)
+        new(response['data'])
+      end
+    end
+  end
+end

data/lib/servicetrade/auth.rb

@@ -0,0 +1,42 @@
+module ServiceTrade
+  class Auth
+    attr_reader :session_id
+    
+    def initialize
+      @session_id = nil
+      @last_auth_time = nil
+    end
+    
+    def authenticate
+      response = Client.new.request(
+        :post,
+        'auth',
+        {
+          username: ServiceTrade.configuration.username,
+          password: ServiceTrade.configuration.password
+        },
+        skip_auth: true
+      )
+      
+      @session_id = response['sessionId']
+      @last_auth_time = Time.now
+      
+      @session_id
+    end
+    
+    def session_id
+      if @session_id.nil? || session_expired?
+        authenticate
+      end
+      @session_id
+    end
+    
+    private
+    
+    def session_expired?
+      return true if @last_auth_time.nil?
+      # ServiceTrade sessions typically expire after 24 hours
+      Time.now - @last_auth_time > 86400 # 24 hours in seconds
+    end
+  end
+end

data/lib/servicetrade/client.rb

@@ -0,0 +1,72 @@
+module ServiceTrade
+  class Client
+    attr_reader :api_base
+    
+    def initialize
+      @api_base = ServiceTrade.api_base
+    end
+    
+    def request(method, path, params = {}, headers = {}, skip_auth: false)
+      uri = URI.parse("#{api_base}/#{path}")
+      
+      # Set up the request
+      klass = case method
+      when :get
+        Net::HTTP::Get
+      when :post
+        Net::HTTP::Post
+      when :put
+        Net::HTTP::Put
+      when :delete
+        Net::HTTP::Delete
+      else
+        raise ArgumentError, "Unknown HTTP method: #{method}"
+      end
+      
+      request = klass.new(uri)
+      
+      # Add headers
+      request['Content-Type'] = 'application/json'
+      request['Accept'] = 'application/json'
+      unless skip_auth
+        request['X-Session-Id'] = ServiceTrade.auth.session_id
+      end
+      headers.each { |key, value| request[key] = value }
+      
+      # Add parameters
+      if [:post, :put].include?(method)
+        request.body = params.to_json
+      elsif method == :get && !params.empty?
+        uri.query = URI.encode_www_form(params)
+      end
+      
+      # Make the request
+      response = Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.open_timeout = ServiceTrade.configuration.open_timeout
+        http.read_timeout = ServiceTrade.configuration.timeout
+        http.request(request)
+      end
+      
+      handle_response(response)
+    end
+    
+    private
+    
+    def handle_response(response)
+      case response.code.to_i
+      when 200..299
+        # Handle 204 No Content responses
+        return {} if response.body.nil? || response.body.strip.empty?
+        JSON.parse(response.body)
+      when 401
+        raise ServiceTrade::AuthenticationError, "Invalid credentials or expired session"
+      when 403
+        raise ServiceTrade::AuthorizationError, "Not authorized to perform this action"
+      when 404
+        raise ServiceTrade::NotFoundError, "Resource not found"
+      else
+        raise ServiceTrade::ApiError, "API error (#{response.code}): #{response.body}"
+      end
+    end
+  end
+end

data/lib/servicetrade/configuration.rb

@@ -0,0 +1,11 @@
+module ServiceTrade
+  class Configuration
+    attr_accessor :username, :password, :api_version, :timeout, :open_timeout
+    
+    def initialize
+      @api_version = '1'
+      @timeout = 30
+      @open_timeout = 10
+    end
+  end
+end

data/lib/servicetrade/errors.rb

@@ -0,0 +1,7 @@
+module ServiceTrade
+  class Error < StandardError; end
+  class ApiError < Error; end
+  class AuthenticationError < Error; end
+  class AuthorizationError < Error; end
+  class NotFoundError < Error; end
+end

data/lib/servicetrade/resources/appointment.rb

@@ -0,0 +1,14 @@
+module ServiceTrade
+  class Appointment
+    extend ServiceTrade::ApiOperations::Create
+    extend ServiceTrade::ApiOperations::List
+    extend ServiceTrade::ApiOperations::Update
+    extend ServiceTrade::ApiOperations::Delete
+    
+    OBJECT_NAME = 'appointments'
+    
+    def self.resource_url
+      OBJECT_NAME
+    end
+  end
+end

data/lib/servicetrade/resources/base_resource.rb

@@ -0,0 +1,30 @@
+module ServiceTrade
+  class BaseResource
+    attr_reader :attributes
+
+    def initialize(attributes = {})
+      @attributes = attributes
+      set_attributes(attributes)
+    end
+
+    private
+
+    def set_attributes(attributes)
+      attributes.each do |key, value|
+        # Convert camelCase to snake_case for Ruby conventions
+        snake_key = camel_to_snake(key.to_s)
+        
+        # Only set attributes that have corresponding reader methods
+        if self.respond_to?(snake_key)
+          instance_variable_set("@#{snake_key}", value)
+        end
+      end
+    end
+
+    def camel_to_snake(str)
+      str.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+         .downcase
+    end
+  end
+end

data/lib/servicetrade/resources/job.rb

@@ -0,0 +1,149 @@
+module ServiceTrade
+  class Job < BaseResource
+    extend ServiceTrade::ApiOperations::Create
+    extend ServiceTrade::ApiOperations::List
+    extend ServiceTrade::ApiOperations::Update
+    extend ServiceTrade::ApiOperations::Delete
+
+    OBJECT_NAME = 'job'.freeze
+
+    # Core job attributes
+    attr_reader :id, :uri, :name, :custom_name, :type, :job_type_weight,
+                :status, :display_status, :substatus, :display_substatus,
+                :number, :ref_number, :customer_po, :visibility, :section_visibilities,
+                :description, :scheduled_date, :estimated_price, :latest_clock_in,
+                :ivr_open, :ivr_activity, :service_line, :due_by, :due_after,
+                :completed_on, :percent_complete, :is_project, :budgeted,
+                :created, :updated
+
+    # Related objects
+    attr_reader :vendor, :customer, :location, :owner, :sales, :primary_contact,
+                :current_appointment, :assigned_office, :offices, :tags,
+                :external_ids, :terms, :contract, :project, :notes,
+                :service_requests, :scheduling_comments
+
+    # Service link visibility
+    attr_reader :service_link_attachment_visibility, :service_link_comment_visibility,
+                :service_link_attachment_category_visibility
+
+    # Deprecated fields (kept for backwards compatibility)
+    attr_reader :deficiencies_found, :other_trade_deficiencies_found, :red_tags_found
+
+    def self.resource_url
+      OBJECT_NAME
+    end
+
+    # Find a specific job by ID
+    def self.find(id)
+      response = ServiceTrade.client.request(:get, "#{resource_url}/#{id}")
+      new(response['data'])
+    end
+
+    # Enhanced list method with comprehensive filtering
+    def self.list(filters = {})
+      # Set default status to 'scheduled' if not provided and no job number is specified
+      unless filters.key?(:status) || filters.key?('status') || filters.key?(:number) || filters.key?('number')
+        filters[:status] = 'scheduled'
+      end
+
+      response = ServiceTrade.client.request(:get, resource_url, filters)
+      
+      # Handle the nested response structure from ServiceTrade API
+      jobs_data = response.dig('data', 'jobs') || response['data'] || []
+      jobs_data.map { |job_data| new(job_data) }
+    end
+
+    # Create a new job
+    def self.create(params = {})
+      response = ServiceTrade.client.request(:post, resource_url, params)
+      new(response['data'])
+    end
+
+    # Update an existing job
+    def self.update(id, params = {})
+      response = ServiceTrade.client.request(:put, "#{resource_url}/#{id}", params)
+      new(response['data'])
+    end
+
+    # Update this job instance
+    def update(params = {})
+      self.class.update(id, params)
+    end
+
+    # Delete a job
+    def self.delete(id)
+      ServiceTrade.client.request(:delete, "#{resource_url}/#{id}")
+      true
+    end
+
+    # Delete this job instance
+    def delete
+      self.class.delete(id)
+    end
+
+    # Add task responses to a job
+    def add_task_responses(task_responses)
+      params = { task_responses: task_responses }
+      response = ServiceTrade.client.request(:post, "#{self.class.resource_url}/#{id}/taskresponses", params)
+      response['data']
+    end
+
+    # Convenience methods for common job filtering
+    def self.by_status(status)
+      list(status: status)
+    end
+
+    def self.by_customer(customer_id)
+      list(customer_id: customer_id)
+    end
+
+    def self.by_vendor(vendor_id)
+      list(vendor_id: vendor_id)
+    end
+
+    def self.by_location(location_id)
+      list(location_id: location_id)
+    end
+
+    def self.by_owner(owner_id)
+      list(owner_id: owner_id)
+    end
+
+    def self.around_location(lat, lon, radius)
+      list(lat: lat, lon: lon, radius: radius)
+    end
+
+    def self.due_between(start_timestamp, end_timestamp)
+      list(due_by_begin: start_timestamp, due_by_end: end_timestamp)
+    end
+
+    def self.completed_between(start_timestamp, end_timestamp)
+      list(completed_on_begin: start_timestamp, completed_on_end: end_timestamp)
+    end
+
+    # Check if job is completed
+    def completed?
+      status == 'completed'
+    end
+
+    # Check if job is canceled
+    def canceled?
+      status == 'canceled'
+    end
+
+    # Check if job is scheduled
+    def scheduled?
+      status == 'scheduled'
+    end
+
+    # Check if job is invoiced
+    def invoiced?
+      status == 'invoiced'
+    end
+
+    # Check if job has IVR activity open
+    def ivr_open?
+      ivr_open == true
+    end
+  end
+end

data/lib/servicetrade/resources/location.rb

@@ -0,0 +1,218 @@
+module ServiceTrade
+  class Location < BaseResource
+    extend ServiceTrade::ApiOperations::Create
+    extend ServiceTrade::ApiOperations::List
+    extend ServiceTrade::ApiOperations::Update
+    extend ServiceTrade::ApiOperations::Delete
+
+    OBJECT_NAME = 'location'.freeze
+
+    # Core location attributes
+    attr_reader :id, :uri, :name, :ref_number, :lat, :lon, :geocode_quality,
+                :distance, :phone_number, :email, :general_manager, :status,
+                :taxable, :store_number, :created, :updated
+
+    # Address components
+    attr_reader :address, :address_street, :address_city, :address_state, :address_postal_code
+
+    # Related objects
+    attr_reader :company, :brand, :primary_contact, :offices, :tags, :tax_group,
+                :external_ids, :remit_to_address, :remit_to_source
+
+    # Deprecated fields (kept for backwards compatibility)
+    attr_reader :legacy_id
+
+    def self.resource_url
+      OBJECT_NAME
+    end
+
+    # Find a specific location by ID
+    def self.find(id)
+      response = ServiceTrade.client.request(:get, "#{resource_url}/#{id}")
+      new(response['data'])
+    end
+
+    # Enhanced list method with comprehensive filtering
+    def self.list(filters = {})
+      # Set default isCustomer to true if not specified
+      unless filters.key?(:is_customer) || filters.key?('isCustomer')
+        filters[:is_customer] = true
+      end
+
+      response = ServiceTrade.client.request(:get, resource_url, filters)
+      
+      # Handle the nested response structure from ServiceTrade API
+      locations_data = response.dig('data', 'locations') || response['data'] || []
+      locations_data.map { |location_data| new(location_data) }
+    end
+
+    # Create a new location
+    def self.create(params = {})
+      response = ServiceTrade.client.request(:post, resource_url, params)
+      new(response['data'])
+    end
+
+    # Update an existing location
+    def self.update(id, params = {})
+      response = ServiceTrade.client.request(:put, "#{resource_url}/#{id}", params)
+      new(response['data'])
+    end
+
+    # Update this location instance
+    def update(params = {})
+      self.class.update(id, params)
+    end
+
+    # Delete a location
+    def self.delete(id)
+      ServiceTrade.client.request(:delete, "#{resource_url}/#{id}")
+      true
+    end
+
+    # Delete this location instance
+    def delete
+      self.class.delete(id)
+    end
+
+    # Merge this location into another location
+    def merge(replacement_id)
+      params = { replacement_id: replacement_id }
+      response = ServiceTrade.client.request(:post, "#{self.class.resource_url}/#{id}/merge", params)
+      self.class.new(response['data'])
+    end
+
+    # Get assets at this location
+    def assets
+      response = ServiceTrade.client.request(:get, "#{self.class.resource_url}/#{id}/asset")
+      assets_data = response.dig('data', 'assets') || []
+      # For now, return raw data - could create Asset resource class later
+      assets_data
+    end
+
+    # Get comments for this location
+    def comments
+      response = ServiceTrade.client.request(:get, "#{self.class.resource_url}/#{id}/comment")
+      comments_data = response.dig('data', 'comments') || []
+      # For now, return raw data - could create Comment resource class later
+      comments_data
+    end
+
+    # Create a comment for this location
+    def create_comment(params = {})
+      response = ServiceTrade.client.request(:post, "#{self.class.resource_url}/#{id}/comment", params)
+      response['data']
+    end
+
+    # Convenience methods for common location filtering
+    def self.by_name(name)
+      list(name: name)
+    end
+
+    def self.by_company(company_id)
+      list(company_id: company_id)
+    end
+
+    def self.by_ref_number(ref_number)
+      list(ref_number: ref_number)
+    end
+
+    def self.by_status(status)
+      list(status: status)
+    end
+
+    def self.by_region(region_ids)
+      region_ids = Array(region_ids).join(',') if region_ids.is_a?(Array)
+      list(region_ids: region_ids)
+    end
+
+    def self.by_office(office_ids)
+      office_ids = Array(office_ids).join(',') if office_ids.is_a?(Array)
+      list(office_ids: office_ids)
+    end
+
+    def self.customers_only
+      list(is_customer: true)
+    end
+
+    def self.vendors_only
+      list(is_vendor: true)
+    end
+
+    def self.active_locations
+      list(status: 'active')
+    end
+
+    def self.inactive_locations
+      list(status: 'inactive')
+    end
+
+    def self.updated_after(timestamp)
+      list(updated_after: timestamp)
+    end
+
+    def self.updated_before(timestamp)
+      list(updated_before: timestamp)
+    end
+
+    def self.created_after(timestamp)
+      list(created_after: timestamp)
+    end
+
+    def self.created_before(timestamp)
+      list(created_before: timestamp)
+    end
+
+    def self.with_tags(tags)
+      tags = Array(tags).join(',') if tags.is_a?(Array)
+      list(tag: tags)
+    end
+
+    # Status check methods
+    def active?
+      status == 'active'
+    end
+
+    def inactive?
+      status == 'inactive'
+    end
+
+    def pending?
+      status == 'pending'
+    end
+
+    def on_hold?
+      status == 'on_hold'
+    end
+
+    # Check if location is taxable
+    def taxable?
+      taxable == true
+    end
+
+    # Get the full address as a string
+    def full_address
+      parts = []
+      
+      if address
+        parts = [
+          address['street'],
+          address['city'],
+          address['state'],
+          address['postalCode']
+        ]
+      else
+        parts = [
+          address_street,
+          address_city,
+          address_state,
+          address_postal_code
+        ]
+      end
+      
+      parts = parts.compact
+      return nil if parts.empty?
+      
+      parts.join(', ')
+    end
+  end
+end

data/lib/servicetrade/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ServiceTrade
+  VERSION = "0.1.0"
+end

data/lib/servicetrade.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "servicetrade/version"
+require_relative "servicetrade/configuration"
+require_relative "servicetrade/client"
+require_relative "servicetrade/auth"
+require_relative "servicetrade/errors"
+
+# API Operations
+require_relative "servicetrade/api_operations/create"
+require_relative "servicetrade/api_operations/list"
+require_relative "servicetrade/api_operations/update"
+require_relative "servicetrade/api_operations/delete"
+
+# Resources
+require_relative "servicetrade/resources/base_resource"
+require_relative "servicetrade/resources/job"
+require_relative "servicetrade/resources/appointment"
+require_relative "servicetrade/resources/location"
+
+require "net/http"
+require "json"
+
+module ServiceTrade
+  class << self
+    attr_accessor :configuration, :auth_instance, :client_instance
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+  end
+
+  def self.auth
+    @auth_instance ||= Auth.new
+  end
+
+  def self.client
+    @client_instance ||= Client.new
+  end
+
+  def self.api_base
+    "https://api.servicetrade.com/api"
+  end
+
+  # Reset all instances (useful for testing)
+  def self.reset!
+    @configuration = nil
+    @auth_instance = nil  
+    @client_instance = nil
+  end
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: servicetrade
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Bryce Holcomb
+bindir: bin
+cert_chain: []
+date: 2025-09-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: stringio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.2
+description: A Ruby library for interacting with the ServiceTrade API
+email:
+- bryce@destilado.tech
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- lib/servicetrade.rb
+- lib/servicetrade/api_operations/create.rb
+- lib/servicetrade/api_operations/delete.rb
+- lib/servicetrade/api_operations/list.rb
+- lib/servicetrade/api_operations/update.rb
+- lib/servicetrade/auth.rb
+- lib/servicetrade/client.rb
+- lib/servicetrade/configuration.rb
+- lib/servicetrade/errors.rb
+- lib/servicetrade/resources/appointment.rb
+- lib/servicetrade/resources/base_resource.rb
+- lib/servicetrade/resources/job.rb
+- lib/servicetrade/resources/location.rb
+- lib/servicetrade/util.rb
+- lib/servicetrade/version.rb
+homepage: https://github.com/destilado/servicetrade-ruby
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Ruby client for the ServiceTrade API
+test_files: []