xero-kiwi 0.1.0

data/lib/xero_kiwi/accounting/line_item.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module XeroKiwi
+  module Accounting
+    # Represents a line item nested within Xero documents (invoices, credit
+    # notes, prepayments, overpayments).
+    #
+    # See: https://developer.xero.com/documentation/api/accounting/invoices
+    class LineItem
+      ATTRIBUTES = {
+        line_item_id:    "LineItemID",
+        description:     "Description",
+        quantity:        "Quantity",
+        unit_amount:     "UnitAmount",
+        item_code:       "ItemCode",
+        account_code:    "AccountCode",
+        account_id:      "AccountId",
+        tax_type:        "TaxType",
+        tax_amount:      "TaxAmount",
+        line_amount:     "LineAmount",
+        discount_rate:   "DiscountRate",
+        discount_amount: "DiscountAmount",
+        tracking:        "Tracking",
+        item:            "Item"
+      }.freeze
+
+      attr_reader(*ATTRIBUTES.keys)
+
+      def initialize(attrs) # rubocop:disable Metrics/AbcSize
+        attrs            = attrs.transform_keys(&:to_s)
+        @line_item_id    = attrs["LineItemID"]
+        @description     = attrs["Description"]
+        @quantity        = attrs["Quantity"]
+        @unit_amount     = attrs["UnitAmount"]
+        @item_code       = attrs["ItemCode"]
+        @account_code    = attrs["AccountCode"]
+        @account_id      = attrs["AccountId"]
+        @tax_type        = attrs["TaxType"]
+        @tax_amount      = attrs["TaxAmount"]
+        @line_amount     = attrs["LineAmount"]
+        @discount_rate   = attrs["DiscountRate"]
+        @discount_amount = attrs["DiscountAmount"]
+        @tracking        = (attrs["Tracking"] || []).map { |t| TrackingCategory.new(t) }
+        @item            = attrs["Item"]
+      end
+
+      def to_h
+        ATTRIBUTES.keys.to_h { |key| [key, public_send(key)] }
+      end
+
+      def ==(other)
+        other.is_a?(LineItem) && to_h == other.to_h
+      end
+      alias eql? ==
+
+      def hash = to_h.hash
+
+      def inspect
+        "#<#{self.class} description=#{description.inspect} " \
+          "line_amount=#{line_amount.inspect}>"
+      end
+    end
+  end
+end

data/lib/xero_kiwi/accounting/organisation.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "time"
+
+module XeroKiwi
+  module Accounting
+    # Represents a Xero Organisation (tenant) returned by the Accounting API.
+    #
+    # See: https://developer.xero.com/documentation/api/accounting/organisation
+    class Organisation
+      ATTRIBUTES = {
+        organisation_id:                "OrganisationID",
+        api_key:                        "APIKey",
+        name:                           "Name",
+        legal_name:                     "LegalName",
+        pays_tax:                       "PaysTax",
+        version:                        "Version",
+        organisation_type:              "OrganisationType",
+        base_currency:                  "BaseCurrency",
+        country_code:                   "CountryCode",
+        is_demo_company:                "IsDemoCompany",
+        organisation_status:            "OrganisationStatus",
+        registration_number:            "RegistrationNumber",
+        employer_identification_number: "EmployerIdentificationNumber",
+        tax_number:                     "TaxNumber",
+        financial_year_end_day:         "FinancialYearEndDay",
+        financial_year_end_month:       "FinancialYearEndMonth",
+        sales_tax_basis:                "SalesTaxBasis",
+        sales_tax_period:               "SalesTaxPeriod",
+        default_sales_tax:              "DefaultSalesTax",
+        default_purchases_tax:          "DefaultPurchasesTax",
+        period_lock_date:               "PeriodLockDate",
+        end_of_year_lock_date:          "EndOfYearLockDate",
+        created_date_utc:               "CreatedDateUTC",
+        timezone:                       "Timezone",
+        organisation_entity_type:       "OrganisationEntityType",
+        short_code:                     "ShortCode",
+        organisation_class:             "Class",
+        edition:                        "Edition",
+        line_of_business:               "LineOfBusiness",
+        addresses:                      "Addresses",
+        phones:                         "Phones",
+        external_links:                 "ExternalLinks",
+        payment_terms:                  "PaymentTerms"
+      }.freeze
+
+      attr_reader(*ATTRIBUTES.keys)
+
+      def self.from_response(payload)
+        return nil if payload.nil?
+
+        items = payload["Organisations"]
+        return nil if items.nil? || items.empty?
+
+        new(items.first)
+      end
+
+      def initialize(attrs) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
+        attrs                           = attrs.transform_keys(&:to_s)
+        @organisation_id                = attrs["OrganisationID"]
+        @api_key                        = attrs["APIKey"]
+        @name                           = attrs["Name"]
+        @legal_name                     = attrs["LegalName"]
+        @pays_tax                       = attrs["PaysTax"]
+        @version                        = attrs["Version"]
+        @organisation_type              = attrs["OrganisationType"]
+        @base_currency                  = attrs["BaseCurrency"]
+        @country_code                   = attrs["CountryCode"]
+        @is_demo_company                = attrs["IsDemoCompany"]
+        @organisation_status            = attrs["OrganisationStatus"]
+        @registration_number            = attrs["RegistrationNumber"]
+        @employer_identification_number = attrs["EmployerIdentificationNumber"]
+        @tax_number                     = attrs["TaxNumber"]
+        @financial_year_end_day         = attrs["FinancialYearEndDay"]
+        @financial_year_end_month       = attrs["FinancialYearEndMonth"]
+        @sales_tax_basis                = attrs["SalesTaxBasis"]
+        @sales_tax_period               = attrs["SalesTaxPeriod"]
+        @default_sales_tax              = attrs["DefaultSalesTax"]
+        @default_purchases_tax          = attrs["DefaultPurchasesTax"]
+        @period_lock_date               = parse_time(attrs["PeriodLockDate"])
+        @end_of_year_lock_date          = parse_time(attrs["EndOfYearLockDate"])
+        @created_date_utc               = parse_time(attrs["CreatedDateUTC"])
+        @timezone                       = attrs["Timezone"]
+        @organisation_entity_type       = attrs["OrganisationEntityType"]
+        @short_code                     = attrs["ShortCode"]
+        @organisation_class             = attrs["Class"]
+        @edition                        = attrs["Edition"]
+        @line_of_business               = attrs["LineOfBusiness"]
+        @addresses                      = (attrs["Addresses"] || []).map { |a| Address.new(a) }
+        @phones                         = (attrs["Phones"] || []).map { |p| Phone.new(p) }
+        @external_links                 = (attrs["ExternalLinks"] || []).map { |l| ExternalLink.new(l) }
+        @payment_terms                  = PaymentTerms.from_hash(attrs["PaymentTerms"])
+      end
+
+      def demo_company? = is_demo_company == true
+
+      def to_h
+        ATTRIBUTES.keys.to_h { |key| [key, public_send(key)] }
+      end
+
+      def ==(other)
+        other.is_a?(Organisation) && other.organisation_id == organisation_id
+      end
+      alias eql? ==
+
+      def hash = [self.class, organisation_id].hash
+
+      def inspect
+        "#<#{self.class} organisation_id=#{organisation_id.inspect} " \
+          "name=#{name.inspect} organisation_type=#{organisation_type.inspect}>"
+      end
+
+      private
+
+      # Xero uses two timestamp formats depending on the endpoint:
+      #
+      # - ISO 8601: "2019-07-09T23:40:30.1833130" (connections API)
+      # - .NET JSON: "/Date(1574275974000)/" (accounting API)
+      #
+      # Handle both, always returning UTC.
+      def parse_time(value)
+        return nil if value.nil?
+
+        str = value.to_s.strip
+        return nil if str.empty?
+
+        if (match = str.match(%r{\A/Date\((\d+)([+-]\d{4})?\)/\z}))
+          Time.at(match[1].to_i / 1000.0).utc
+        else
+          str = "#{str}Z" unless str.match?(/[Zz]\z|[+-]\d{2}:?\d{2}\z/)
+          Time.iso8601(str)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/xero_kiwi/accounting/overpayment.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "time"
+
+module XeroKiwi
+  module Accounting
+    # Represents a Xero Overpayment returned by the Accounting API.
+    #
+    # See: https://developer.xero.com/documentation/api/accounting/overpayments
+    class Overpayment
+      ATTRIBUTES = {
+        overpayment_id:    "OverpaymentID",
+        type:              "Type",
+        contact:           "Contact",
+        date:              "Date",
+        status:            "Status",
+        line_amount_types: "LineAmountTypes",
+        line_items:        "LineItems",
+        sub_total:         "SubTotal",
+        total_tax:         "TotalTax",
+        total:             "Total",
+        updated_date_utc:  "UpdatedDateUTC",
+        currency_code:     "CurrencyCode",
+        currency_rate:     "CurrencyRate",
+        remaining_credit:  "RemainingCredit",
+        allocations:       "Allocations",
+        payments:          "Payments",
+        has_attachments:   "HasAttachments",
+        reference:         "Reference"
+      }.freeze
+
+      attr_reader(*ATTRIBUTES.keys)
+
+      def self.from_response(payload)
+        return [] if payload.nil?
+
+        items = payload["Overpayments"]
+        return [] if items.nil?
+
+        items.map { |attrs| new(attrs) }
+      end
+
+      def initialize(attrs, reference: false) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        attrs              = attrs.transform_keys(&:to_s)
+        @is_reference      = reference
+        @overpayment_id    = attrs["OverpaymentID"]
+        @type              = attrs["Type"]
+        @contact           = attrs["Contact"] ? Contact.new(attrs["Contact"], reference: true) : nil
+        @date              = parse_time(attrs["Date"])
+        @status            = attrs["Status"]
+        @line_amount_types = attrs["LineAmountTypes"]
+        @line_items        = (attrs["LineItems"] || []).map { |li| LineItem.new(li) }
+        @sub_total         = attrs["SubTotal"]
+        @total_tax         = attrs["TotalTax"]
+        @total             = attrs["Total"]
+        @updated_date_utc  = parse_time(attrs["UpdatedDateUTC"])
+        @currency_code     = attrs["CurrencyCode"]
+        @currency_rate     = attrs["CurrencyRate"]
+        @remaining_credit  = attrs["RemainingCredit"]
+        @allocations       = (attrs["Allocations"] || []).map { |a| Allocation.new(a) }
+        @payments          = (attrs["Payments"] || []).map { |p| Payment.new(p, reference: true) }
+        @has_attachments   = attrs["HasAttachments"]
+        @reference         = attrs["Reference"]
+      end
+
+      def receive? = type == "RECEIVE-OVERPAYMENT"
+
+      def spend? = type == "SPEND-OVERPAYMENT"
+
+      def reference? = @is_reference
+
+      def to_h
+        ATTRIBUTES.keys.to_h { |key| [key, public_send(key)] }
+      end
+
+      def ==(other)
+        other.is_a?(Overpayment) && other.overpayment_id == overpayment_id
+      end
+      alias eql? ==
+
+      def hash = [self.class, overpayment_id].hash
+
+      def inspect
+        "#<#{self.class} overpayment_id=#{overpayment_id.inspect} " \
+          "type=#{type.inspect} status=#{status.inspect} total=#{total.inspect}>"
+      end
+
+      private
+
+      def parse_time(value)
+        return nil if value.nil?
+
+        str = value.to_s.strip
+        return nil if str.empty?
+
+        if (match = str.match(%r{\A/Date\((\d+)([+-]\d{4})?\)/\z}))
+          Time.at(match[1].to_i / 1000.0).utc
+        else
+          str = "#{str}Z" unless str.match?(/[Zz]\z|[+-]\d{2}:?\d{2}\z/)
+          Time.iso8601(str)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/xero_kiwi/accounting/payment.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require "time"
+
+module XeroKiwi
+  module Accounting
+    # Represents a Xero Payment returned by the Accounting API.
+    #
+    # See: https://developer.xero.com/documentation/api/accounting/payments
+    class Payment
+      ATTRIBUTES = {
+        payment_id:       "PaymentID",
+        date:             "Date",
+        currency_rate:    "CurrencyRate",
+        amount:           "Amount",
+        bank_amount:      "BankAmount",
+        reference:        "Reference",
+        is_reconciled:    "IsReconciled",
+        status:           "Status",
+        payment_type:     "PaymentType",
+        updated_date_utc: "UpdatedDateUTC",
+        batch_payment_id: "BatchPaymentID",
+        batch_payment:    "BatchPayment",
+        account:          "Account",
+        invoice:          "Invoice",
+        credit_note:      "CreditNote",
+        prepayment:       "Prepayment",
+        overpayment:      "Overpayment",
+        has_account:      "HasAccount"
+      }.freeze
+
+      attr_reader(*ATTRIBUTES.keys)
+
+      def self.from_response(payload)
+        return [] if payload.nil?
+
+        items = payload["Payments"]
+        return [] if items.nil?
+
+        items.map { |attrs| new(attrs) }
+      end
+
+      def initialize(attrs, reference: false) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        attrs              = attrs.transform_keys(&:to_s)
+        @is_reference      = reference
+        @payment_id        = attrs["PaymentID"]
+        @date              = parse_time(attrs["Date"])
+        @currency_rate     = attrs["CurrencyRate"]
+        @amount            = attrs["Amount"]
+        @bank_amount       = attrs["BankAmount"]
+        @reference         = attrs["Reference"]
+        @is_reconciled     = attrs["IsReconciled"]
+        @status            = attrs["Status"]
+        @payment_type      = attrs["PaymentType"]
+        @updated_date_utc  = parse_time(attrs["UpdatedDateUTC"])
+        @batch_payment_id  = attrs["BatchPaymentID"]
+        @batch_payment     = attrs["BatchPayment"]
+        @account           = attrs["Account"]
+        @invoice           = attrs["Invoice"] ? Invoice.new(attrs["Invoice"], reference: true) : nil
+        @credit_note       = attrs["CreditNote"] ? CreditNote.new(attrs["CreditNote"], reference: true) : nil
+        @prepayment        = attrs["Prepayment"] ? Prepayment.new(attrs["Prepayment"], reference: true) : nil
+        @overpayment       = attrs["Overpayment"] ? Overpayment.new(attrs["Overpayment"], reference: true) : nil
+        @has_account       = attrs["HasAccount"]
+      end
+
+      def reference? = @is_reference
+
+      def reconciled? = is_reconciled == true
+
+      def to_h
+        ATTRIBUTES.keys.to_h { |key| [key, public_send(key)] }
+      end
+
+      def ==(other)
+        other.is_a?(Payment) && other.payment_id == payment_id
+      end
+      alias eql? ==
+
+      def hash = [self.class, payment_id].hash
+
+      def inspect
+        "#<#{self.class} payment_id=#{payment_id.inspect} " \
+          "payment_type=#{payment_type.inspect} status=#{status.inspect} amount=#{amount.inspect}>"
+      end
+
+      private
+
+      def parse_time(value)
+        return nil if value.nil?
+
+        str = value.to_s.strip
+        return nil if str.empty?
+
+        if (match = str.match(%r{\A/Date\((\d+)([+-]\d{4})?\)/\z}))
+          Time.at(match[1].to_i / 1000.0).utc
+        else
+          str = "#{str}Z" unless str.match?(/[Zz]\z|[+-]\d{2}:?\d{2}\z/)
+          Time.iso8601(str)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/xero_kiwi/accounting/payment_terms.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module XeroKiwi
+  module Accounting
+    # Xero payment terms for an Organisation or Contact, containing separate
+    # terms for bills (payable) and sales (receivable).
+    #
+    # See: https://developer.xero.com/documentation/api/accounting/types#paymentterms
+    class PaymentTerms
+      attr_reader :bills, :sales
+
+      def self.from_hash(hash)
+        return nil if hash.nil?
+
+        new(hash)
+      end
+
+      def initialize(attrs)
+        attrs  = attrs.transform_keys(&:to_s)
+        @bills = PaymentTerm.from_hash(attrs["Bills"])
+        @sales = PaymentTerm.from_hash(attrs["Sales"])
+      end
+
+      def to_h
+        { bills: bills&.to_h, sales: sales&.to_h }
+      end
+
+      def ==(other)
+        other.is_a?(PaymentTerms) && bills == other.bills && sales == other.sales
+      end
+      alias eql? ==
+
+      def hash = [self.class, bills, sales].hash
+
+      def inspect
+        "#<#{self.class} bills=#{bills.inspect} sales=#{sales.inspect}>"
+      end
+    end
+
+    # A single payment term (either bills or sales side).
+    class PaymentTerm
+      ATTRIBUTES = {
+        day:  "Day",
+        type: "Type"
+      }.freeze
+
+      attr_reader(*ATTRIBUTES.keys)
+
+      def self.from_hash(hash)
+        return nil if hash.nil? || hash.empty?
+
+        new(hash)
+      end
+
+      def initialize(attrs)
+        attrs = attrs.transform_keys(&:to_s)
+        @day  = attrs["Day"]
+        @type = attrs["Type"]
+      end
+
+      def to_h
+        ATTRIBUTES.keys.to_h { |key| [key, public_send(key)] }
+      end
+
+      def ==(other)
+        other.is_a?(PaymentTerm) && day == other.day && type == other.type
+      end
+      alias eql? ==
+
+      def hash = [self.class, day, type].hash
+
+      def inspect
+        "#<#{self.class} day=#{day.inspect} type=#{type.inspect}>"
+      end
+    end
+  end
+end

data/lib/xero_kiwi/accounting/phone.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module XeroKiwi
+  module Accounting
+    # A Xero phone number. Used by Organisation, Contact, and other resources.
+    #
+    # See: https://developer.xero.com/documentation/api/accounting/types#phones
+    class Phone
+      ATTRIBUTES = {
+        phone_type:         "PhoneType",
+        phone_number:       "PhoneNumber",
+        phone_area_code:    "PhoneAreaCode",
+        phone_country_code: "PhoneCountryCode"
+      }.freeze
+
+      attr_reader(*ATTRIBUTES.keys)
+
+      def initialize(attrs)
+        attrs               = attrs.transform_keys(&:to_s)
+        @phone_type         = attrs["PhoneType"]
+        @phone_number       = attrs["PhoneNumber"]
+        @phone_area_code    = attrs["PhoneAreaCode"]
+        @phone_country_code = attrs["PhoneCountryCode"]
+      end
+
+      def default? = phone_type == "DEFAULT"
+      def mobile?  = phone_type == "MOBILE"
+      def fax?     = phone_type == "FAX"
+
+      def to_h
+        ATTRIBUTES.keys.to_h { |key| [key, public_send(key)] }
+      end
+
+      def ==(other)
+        other.is_a?(Phone) && to_h == other.to_h
+      end
+      alias eql? ==
+
+      def hash = to_h.hash
+
+      def inspect
+        "#<#{self.class} type=#{phone_type.inspect} number=#{phone_number.inspect}>"
+      end
+    end
+  end
+end

data/lib/xero_kiwi/accounting/prepayment.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require "time"
+
+module XeroKiwi
+  module Accounting
+    # Represents a Xero Prepayment returned by the Accounting API.
+    #
+    # See: https://developer.xero.com/documentation/api/accounting/prepayments
+    class Prepayment
+      ATTRIBUTES = {
+        prepayment_id:      "PrepaymentID",
+        type:               "Type",
+        contact:            "Contact",
+        date:               "Date",
+        status:             "Status",
+        line_amount_types:  "LineAmountTypes",
+        line_items:         "LineItems",
+        sub_total:          "SubTotal",
+        total_tax:          "TotalTax",
+        total:              "Total",
+        updated_date_utc:   "UpdatedDateUTC",
+        currency_code:      "CurrencyCode",
+        currency_rate:      "CurrencyRate",
+        invoice_number:     "InvoiceNumber",
+        remaining_credit:   "RemainingCredit",
+        allocations:        "Allocations",
+        payments:           "Payments",
+        has_attachments:    "HasAttachments",
+        fully_paid_on_date: "FullyPaidOnDate"
+      }.freeze
+
+      attr_reader(*ATTRIBUTES.keys)
+
+      def self.from_response(payload)
+        return [] if payload.nil?
+
+        items = payload["Prepayments"]
+        return [] if items.nil?
+
+        items.map { |attrs| new(attrs) }
+      end
+
+      def initialize(attrs, reference: false) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+        attrs               = attrs.transform_keys(&:to_s)
+        @is_reference       = reference
+        @prepayment_id      = attrs["PrepaymentID"]
+        @type               = attrs["Type"]
+        @contact            = attrs["Contact"] ? Contact.new(attrs["Contact"], reference: true) : nil
+        @date               = parse_time(attrs["Date"])
+        @status             = attrs["Status"]
+        @line_amount_types  = attrs["LineAmountTypes"]
+        @line_items         = (attrs["LineItems"] || []).map { |li| LineItem.new(li) }
+        @sub_total          = attrs["SubTotal"]
+        @total_tax          = attrs["TotalTax"]
+        @total              = attrs["Total"]
+        @updated_date_utc   = parse_time(attrs["UpdatedDateUTC"])
+        @currency_code      = attrs["CurrencyCode"]
+        @currency_rate      = attrs["CurrencyRate"]
+        @invoice_number     = attrs["InvoiceNumber"]
+        @remaining_credit   = attrs["RemainingCredit"]
+        @allocations        = (attrs["Allocations"] || []).map { |a| Allocation.new(a) }
+        @payments           = (attrs["Payments"] || []).map { |p| Payment.new(p, reference: true) }
+        @has_attachments    = attrs["HasAttachments"]
+        @fully_paid_on_date = parse_time(attrs["FullyPaidOnDate"])
+      end
+
+      def reference? = @is_reference
+
+      def receive? = type == "RECEIVE-PREPAYMENT"
+
+      def spend? = type == "SPEND-PREPAYMENT"
+
+      def to_h
+        ATTRIBUTES.keys.to_h { |key| [key, public_send(key)] }
+      end
+
+      def ==(other)
+        other.is_a?(Prepayment) && other.prepayment_id == prepayment_id
+      end
+      alias eql? ==
+
+      def hash = [self.class, prepayment_id].hash
+
+      def inspect
+        "#<#{self.class} prepayment_id=#{prepayment_id.inspect} " \
+          "type=#{type.inspect} status=#{status.inspect} total=#{total.inspect}>"
+      end
+
+      private
+
+      def parse_time(value)
+        return nil if value.nil?
+
+        str = value.to_s.strip
+        return nil if str.empty?
+
+        if (match = str.match(%r{\A/Date\((\d+)([+-]\d{4})?\)/\z}))
+          Time.at(match[1].to_i / 1000.0).utc
+        else
+          str = "#{str}Z" unless str.match?(/[Zz]\z|[+-]\d{2}:?\d{2}\z/)
+          Time.iso8601(str)
+        end
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/xero_kiwi/accounting/tracking_category.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module XeroKiwi
+  module Accounting
+    # Represents a tracking category assignment on a line item or contact.
+    #
+    # See: https://developer.xero.com/documentation/api/accounting/invoices
+    class TrackingCategory
+      ATTRIBUTES = {
+        tracking_category_id: "TrackingCategoryID",
+        tracking_option_id:   "TrackingOptionID",
+        name:                 "Name",
+        option:               "Option"
+      }.freeze
+
+      attr_reader(*ATTRIBUTES.keys)
+
+      def initialize(attrs)
+        attrs                 = attrs.transform_keys(&:to_s)
+        @tracking_category_id = attrs["TrackingCategoryID"]
+        @tracking_option_id   = attrs["TrackingOptionID"]
+        @name                 = attrs["Name"]
+        @option               = attrs["Option"]
+      end
+
+      def to_h
+        ATTRIBUTES.keys.to_h { |key| [key, public_send(key)] }
+      end
+
+      def ==(other)
+        other.is_a?(TrackingCategory) && to_h == other.to_h
+      end
+      alias eql? ==
+
+      def hash = to_h.hash
+
+      def inspect
+        "#<#{self.class} name=#{name.inspect} option=#{option.inspect}>"
+      end
+    end
+  end
+end