async-firefly 1.0.0

data/lib/async/firefly/search.rb

@@ -0,0 +1,40 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class SearchAccountPage < Page
+      MEMBER = Account
+
+      def member_path(record) = "../../accounts/" + self.identifier(record, :id)
+    end
+
+    class SearchTransactionPage < Page
+      def member_class = Transaction
+
+      def member_path(record) = "../../transactions/" + self.identifier(record, :id)
+    end
+
+    module Search
+      def search_accounts(query:, field:, type: nil, **parameters) = Collection.for(self, "v1/search/accounts", SearchAccountPage, **{query:, field:, type:}.compact, **parameters)
+
+      def search_transactions(query:, **parameters) = Collection.for(self, "v1/search/transactions", SearchTransactionPage, query:, **parameters)
+
+      def count_transactions(external_identifier: nil, internal_reference: nil, notes: nil, description: nil, include_deleted: nil)
+        resource = self.with(path: "v1/search/transactions/count", parameters: {external_identifier:, internal_reference:, notes:, description:, include_deleted:}.compact)
+
+        Representation.get(resource) do |target, response|
+          unless response.success?
+            raise Failure.for(response)
+          end
+
+          case response.read
+          in {count: Integer => count}
+            count
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/async/firefly/submit.rb

@@ -0,0 +1,139 @@
+require_relative "error"
+
+module Async
+  module Firefly
+    module Submit
+      TOO_MANY_REQUESTS = 429
+
+      MAXIMUM_ATTEMPTS = 4
+
+      MAXIMUM_DELAY = 30.0
+
+      def submit(klass, resource, payload = nil, method: :post, through: nil, identify: nil)
+        carrier = through || klass
+
+        self.with_retry do
+          carrier.public_send(method, resource, payload) do |target, response|
+            unless response.success?
+              raise Failure.for(response)
+            end
+
+            self.representation_of(klass, target, response, identify)
+          end
+        end
+      end
+
+      def fetch(klass, resource, &block)
+        self.with_retry do
+          klass.get(resource) do |target, response|
+            unless response.success?
+              raise Failure.for(response)
+            end
+
+            if block
+              block.call(target, response)
+            else
+              klass.new(target, value: response.read, metadata: response.headers)
+            end
+          end
+        end
+      end
+
+      def representation_of(klass, resource, response, identify)
+        value = response.read
+
+        klass.new(self.identified(resource, identify, value), value: value, metadata: response.headers)
+      end
+
+      def identified(resource, identify, value)
+        id = self.identifier_of(value, identify)
+
+        if identify.nil? || id.nil?
+          resource
+        else
+          resource.with(path: self.prefix_of(identify) + Firefly.escape(id), parameters: nil, merge: false)
+        end
+      end
+
+      def identifier_of(value, identify)
+        if identify.is_a?(Symbol)
+          self.attribute_of(value, identify)
+        else
+          self.record_identifier_of(value)
+        end
+      end
+
+      def record_identifier_of(value)
+        case value
+        in {data: {id: String | Integer => id}}
+          id
+        else
+          nil
+        end
+      end
+
+      def attribute_of(value, name)
+        case value
+        in {data: {attributes: Hash => attributes}}
+          attributes[name]
+        in {data: Hash => data}
+          data[name]
+        else
+          nil
+        end
+      end
+
+      def prefix_of(identify)
+        if identify == true || identify.is_a?(Symbol)
+          ""
+        else
+          identify
+        end
+      end
+
+      def upload(klass, resource, bytes, method: :post)
+        self.submit(klass, resource, bytes, method: method, through: Upload)
+      end
+
+      def discard(resource, payload = nil, method: :delete)
+        self.with_retry do
+          Representation.public_send(method, resource, payload) do |target, response|
+            unless response.success?
+              raise Failure.for(response)
+            end
+
+            true
+          end
+        end
+      end
+
+      def with_retry(attempts: MAXIMUM_ATTEMPTS, &block)
+        attempt = 1
+
+        while true
+          begin
+            break block.call
+          rescue Failure => failure
+            if attempt >= attempts
+              raise
+            end
+
+            unless failure.status == TOO_MANY_REQUESTS
+              raise
+            end
+
+            delay = failure.retry_after.to_f
+
+            if delay <= 0.0 || delay > MAXIMUM_DELAY
+              raise
+            end
+
+            attempt += 1
+
+            sleep(delay)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/async/firefly/summary.rb

@@ -0,0 +1,45 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class BasicSummaryEntry < Representation
+      def key = self.value[:key]
+
+      def title = self.value[:title]
+
+      def monetary_value = self.value[:monetary_value]
+
+      def currency_id = self.value[:currency_id]
+
+      def currency_code = self.value[:currency_code]
+
+      def currency_symbol = self.value[:currency_symbol]
+
+      def currency_decimal_places = self.value[:currency_decimal_places]
+
+      def no_available_budgets = self.value[:no_available_budgets]
+
+      def value_parsed = self.value[:value_parsed]
+
+      def sub_title = self.value[:sub_title]
+    end
+
+    class BasicSummary < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct_keys(nil).each do |_, entry|
+            block.call(BasicSummaryEntry.new(@resource, value: entry, metadata: self.metadata))
+          end
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    module Summary
+      def basic_summary(**parameters) = self.fetch(BasicSummary, self.with(path: "v1/summary/basic", parameters: parameters))
+    end
+  end
+end

data/lib/async/firefly/sums.rb

@@ -0,0 +1,17 @@
+require_relative "representation"
+
+module Async
+  module Firefly
+    class ArrayEntryWithCurrencyAndSum < Representation
+      def currency_id = self.value[:currency_id]
+
+      def currency_code = self.value[:currency_code]
+
+      def currency_symbol = self.value[:currency_symbol]
+
+      def currency_decimal_places = self.value[:currency_decimal_places]
+
+      def sum = self.value[:sum]
+    end
+  end
+end

data/lib/async/firefly/tags.rb

@@ -0,0 +1,57 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class Tag < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def tag = self.attributes[:tag]
+
+      def date = self.attributes[:date]
+
+      def description = self.attributes[:description]
+
+      def latitude = self.attributes[:latitude]
+
+      def longitude = self.attributes[:longitude]
+
+      def zoom_level = self.attributes[:zoom_level]
+
+      def attachments(**parameters) = Collection.for(@resource, "attachments", TagAttachmentPage, **parameters)
+
+      def transactions(**parameters) = Collection.for(@resource, "transactions", TagTransactionPage, **parameters)
+
+      def update(payload) = self.submit(Tag, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+    end
+
+    class TagPage < Page
+      MEMBER = Tag
+
+      def member_path(record) = self.identifier(record, :attributes, :tag)
+    end
+
+    class TagAttachmentPage < NestedPage
+      def member_class = Attachment
+
+      def collection = "attachments"
+    end
+
+    class TagTransactionPage < NestedPage
+      def member_class = Transaction
+
+      def collection = "transactions"
+    end
+
+    module Tags
+      def tags(**parameters) = Collection.for(self, "v1/tags", TagPage, **parameters)
+
+      def tag(name) = Tag.new(self.with(path: "v1/tags/" + Firefly.escape(name)))
+
+      def create_tag(payload) = self.submit(Tag, self.with(path: "v1/tags"), payload, identify: :tag)
+    end
+  end
+end

data/lib/async/firefly/transactions.rb

@@ -0,0 +1,231 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class TransactionSplit < Representation
+      def user = self.value[:user]
+
+      def transaction_journal_id = self.value[:transaction_journal_id]
+
+      def type = self.value[:type]
+
+      def date = self.value[:date]
+
+      def order = self.value[:order]
+
+      def object_has_currency_setting = self.value[:object_has_currency_setting]
+
+      def currency_id = self.value[:currency_id]
+
+      def currency_code = self.value[:currency_code]
+
+      def currency_symbol = self.value[:currency_symbol]
+
+      def currency_name = self.value[:currency_name]
+
+      def currency_decimal_places = self.value[:currency_decimal_places]
+
+      def foreign_currency_id = self.value[:foreign_currency_id]
+
+      def foreign_currency_code = self.value[:foreign_currency_code]
+
+      def foreign_currency_symbol = self.value[:foreign_currency_symbol]
+
+      def foreign_currency_decimal_places = self.value[:foreign_currency_decimal_places]
+
+      def primary_currency_id = self.value[:primary_currency_id]
+
+      def primary_currency_code = self.value[:primary_currency_code]
+
+      def primary_currency_symbol = self.value[:primary_currency_symbol]
+
+      def primary_currency_decimal_places = self.value[:primary_currency_decimal_places]
+
+      def amount = self.value[:amount]
+
+      def pc_amount = self.value[:pc_amount]
+
+      def foreign_amount = self.value[:foreign_amount]
+
+      def pc_foreign_amount = self.value[:pc_foreign_amount]
+
+      def source_balance_after = self.value[:source_balance_after]
+
+      def pc_source_balance_after = self.value[:pc_source_balance_after]
+
+      def destination_balance_after = self.value[:destination_balance_after]
+
+      def pc_destination_balance_after = self.value[:pc_destination_balance_after]
+
+      def description = self.value[:description]
+
+      def source_id = self.value[:source_id]
+
+      def source_name = self.value[:source_name]
+
+      def source_iban = self.value[:source_iban]
+
+      def source_type = self.value[:source_type]
+
+      def destination_id = self.value[:destination_id]
+
+      def destination_name = self.value[:destination_name]
+
+      def destination_iban = self.value[:destination_iban]
+
+      def destination_type = self.value[:destination_type]
+
+      def budget_id = self.value[:budget_id]
+
+      def budget_name = self.value[:budget_name]
+
+      def category_id = self.value[:category_id]
+
+      def category_name = self.value[:category_name]
+
+      def bill_id = self.value[:bill_id]
+
+      def bill_name = self.value[:bill_name]
+
+      def subscription_id = self.value[:subscription_id]
+
+      def subscription_name = self.value[:subscription_name]
+
+      def reconciled = self.value[:reconciled]
+
+      def notes = self.value[:notes]
+
+      def tags = self.value[:tags]
+
+      def internal_reference = self.value[:internal_reference]
+
+      def external_id = self.value[:external_id]
+
+      def external_url = self.value[:external_url]
+
+      def original_source = self.value[:original_source]
+
+      def recurrence_id = self.value[:recurrence_id]
+
+      def recurrence_total = self.value[:recurrence_total]
+
+      def recurrence_count = self.value[:recurrence_count]
+
+      def import_hash_v2 = self.value[:import_hash_v2]
+
+      def sepa_cc = self.value[:sepa_cc]
+
+      def sepa_ct_op = self.value[:sepa_ct_op]
+
+      def sepa_ct_id = self.value[:sepa_ct_id]
+
+      def sepa_db = self.value[:sepa_db]
+
+      def sepa_country = self.value[:sepa_country]
+
+      def sepa_ep = self.value[:sepa_ep]
+
+      def sepa_ci = self.value[:sepa_ci]
+
+      def sepa_batch_id = self.value[:sepa_batch_id]
+
+      def interest_date = self.value[:interest_date]
+
+      def book_date = self.value[:book_date]
+
+      def process_date = self.value[:process_date]
+
+      def due_date = self.value[:due_date]
+
+      def payment_date = self.value[:payment_date]
+
+      def invoice_date = self.value[:invoice_date]
+
+      def latitude = self.value[:latitude]
+
+      def longitude = self.value[:longitude]
+
+      def zoom_level = self.value[:zoom_level]
+
+      def has_attachments = self.value[:has_attachments]
+    end
+
+    class Transaction < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def user = self.attributes[:user]
+
+      def group_title = self.attributes[:group_title]
+
+      def transactions
+        Array(self.attributes[:transactions]).map do |split|
+          TransactionSplit.new(@resource, value: split, metadata: self.metadata)
+        end
+      end
+
+      def update(payload) = self.submit(Transaction, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+
+      def attachments(**parameters) = Collection.for(@resource, "attachments", TransactionAttachmentPage, **parameters)
+
+      def piggy_bank_events(**parameters) = Collection.for(@resource, "piggy-bank-events", TransactionPiggyBankEventPage, **parameters)
+    end
+
+    class TransactionJournal < Representation
+      def self.schema = "Transaction"
+
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def user = self.attributes[:user]
+
+      def group_title = self.attributes[:group_title]
+
+      def transactions
+        Array(self.attributes[:transactions]).map do |split|
+          TransactionSplit.new(@resource, value: split, metadata: self.metadata)
+        end
+      end
+
+      def delete = self.discard(@resource)
+
+      def links(**parameters) = Collection.for(@resource, "links", TransactionJournalLinkPage, **parameters)
+    end
+
+    class TransactionPage < Page
+      MEMBER = Transaction
+    end
+
+    class TransactionAttachmentPage < Page
+      MEMBER = Attachment
+
+      def member_path(record) = "../../../attachments/" + self.identifier(record, :id)
+    end
+
+    class TransactionPiggyBankEventPage < Page
+      MEMBER = PiggyBankEvent
+
+      def member_resource(record) = @resource
+    end
+
+    class TransactionJournalLinkPage < Page
+      MEMBER = TransactionLink
+
+      def member_path(record) = "../../../transaction-links/" + self.identifier(record, :id)
+    end
+
+    module Transactions
+      def transactions(**parameters) = Collection.for(self, "v1/transactions", TransactionPage, **parameters)
+
+      def transaction(id) = Transaction.new(self.with(path: "v1/transactions/" + Firefly.escape(id)))
+
+      def create_transaction(payload) = self.submit(Transaction, self.with(path: "v1/transactions"), payload, identify: true)
+
+      def transaction_journal(id) = TransactionJournal.new(self.with(path: "v1/transaction-journals/" + Firefly.escape(id)))
+    end
+  end
+end

data/lib/async/firefly/user_groups.rb

@@ -0,0 +1,49 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class UserGroupReadMembers < Representation
+      def user_id = self.value[:user_id]
+
+      def user_email = self.value[:user_email]
+
+      def you = self.value[:you]
+
+      def roles = self.value[:roles]
+    end
+
+    class UserGroup < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def in_use = self.attributes[:in_use]
+
+      def can_see_members = self.attributes[:can_see_members]
+
+      def title = self.attributes[:title]
+
+      def primary_currency_id = self.attributes[:primary_currency_id]
+
+      def primary_currency_code = self.attributes[:primary_currency_code]
+
+      def primary_currency_symbol = self.attributes[:primary_currency_symbol]
+
+      def primary_currency_decimal_places = self.attributes[:primary_currency_decimal_places]
+
+      def members = Array(self.attributes[:members]).map{|member| UserGroupReadMembers.new(@resource, value: member, metadata: self.metadata)}
+
+      def update(payload) = self.submit(UserGroup, @resource, payload, method: :put)
+    end
+
+    class UserGroupPage < Page
+      MEMBER = UserGroup
+    end
+
+    module UserGroups
+      def user_groups(**parameters) = Collection.for(self, "v1/user-groups", UserGroupPage, **parameters)
+
+      def user_group(id) = UserGroup.new(self.with(path: "v1/user-groups/" + Firefly.escape(id)))
+    end
+  end
+end

data/lib/async/firefly/users.rb

@@ -0,0 +1,35 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class User < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def email = self.attributes[:email]
+
+      def blocked = self.attributes[:blocked]
+
+      def blocked_code = self.attributes[:blocked_code]
+
+      def role = self.attributes[:role]
+
+      def update(payload) = self.submit(User, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+    end
+
+    class UserPage < Page
+      MEMBER = User
+    end
+
+    module Users
+      def users(**parameters) = Collection.for(self, "v1/users", UserPage, **parameters)
+
+      def user(id) = User.new(self.with(path: "v1/users/" + Firefly.escape(id)))
+
+      def create_user(payload) = self.submit(User, self.with(path: "v1/users"), payload, identify: true)
+    end
+  end
+end

data/lib/async/firefly/version.rb

@@ -0,0 +1,5 @@
+module Async
+  module Firefly
+    VERSION = "1.0.0"
+  end
+end