async-firefly 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f90a30a418fa36fec833ef10098195310c76bea241a5b50b48b906def3f3106e
+  data.tar.gz: 8030cdd358f7b9998dca1bcc805ea7f8ad5701d00cfa89ff64721c7797934299
+SHA512:
+  metadata.gz: 11de04a7f8b75afe632b0a9c5265823a0c8a54190ce049d9a4865259eacc6c8203b719ca3fd6930ea3af7a3febe72c2100039162284aad7995f0a22ab4053d52
+  data.tar.gz: d7d2593a527111211acf9b1268731a2f126c8daf3cdcc6d317cc15e6b431c5906d7a47cf67c74378d43a43bef01d5a69ba5262d192cc76f6cfd77cacd089274b

data/lib/async/firefly/about.rb

@@ -0,0 +1,79 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class SystemInfo < Representation
+      def data = self.value[:data] || {}
+
+      def version = self.data[:version]
+
+      def api_version = self.data[:api_version]
+
+      def php_version = self.data[:php_version]
+
+      def os = self.data[:os]
+
+      def driver = self.data[:driver]
+    end
+
+    class ReleaseNotes < Representation
+      def version = self.value[:version]
+
+      def release_notes = self.value[:release_notes]
+
+      def release_notes_markdown = self.value[:release_notes_markdown]
+    end
+
+    class CronResultRow < Representation
+      def job_fired = self.value[:job_fired]
+
+      def job_succeeded = self.value[:job_succeeded]
+
+      def job_errored = self.value[:job_errored]
+
+      def message = self.value[:message]
+
+      def user = self.value[:user]
+    end
+
+    class CronResult < Representation
+      def recurring_transactions = Array(self.value[:recurring_transactions]).map{|row| CronResultRow.new(@resource, value: row, metadata: self.metadata)}
+
+      def auto_budgets = Array(self.value[:auto_budgets]).map{|row| CronResultRow.new(@resource, value: row, metadata: self.metadata)}
+
+      def exchange_rates = Array(self.value[:exchange_rates]).map{|row| CronResultRow.new(@resource, value: row, metadata: self.metadata)}
+
+      def bill_notifications = Array(self.value[:bill_notifications]).map{|row| CronResultRow.new(@resource, value: row, metadata: self.metadata)}
+
+      def webhooks = Array(self.value[:webhooks]).map{|row| CronResultRow.new(@resource, value: row, metadata: self.metadata)}
+    end
+
+    class CurrentUser < Representation
+      def self.schema = "User"
+
+      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]
+    end
+
+    module About
+      def about = SystemInfo.new(self.with(path: "v1/about"))
+
+      def current_user = CurrentUser.new(self.with(path: "v1/about/user"))
+
+      def release_notes(version) = ReleaseNotes.new(self.with(path: "v1/release-notes/" + Firefly.escape(version)))
+
+      def cron(token, date: nil, force: nil) = CronResult.new(self.with(path: "v1/cron/" + Firefly.escape(token), parameters: {date: date, force: force}.compact))
+
+      def finish_batch = self.discard(self.with(path: "v1/batch/finish"), method: :post)
+    end
+  end
+end

data/lib/async/firefly/accounts.rb

@@ -0,0 +1,129 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class Account < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def active = self.attributes[:active]
+
+      def order = self.attributes[:order]
+
+      def name = self.attributes[:name]
+
+      def type = self.attributes[:type]
+
+      def account_role = self.attributes[:account_role]
+
+      def object_group_id = self.attributes[:object_group_id]
+
+      def object_group_order = self.attributes[:object_group_order]
+
+      def object_group_title = self.attributes[:object_group_title]
+
+      def object_has_currency_setting = self.attributes[:object_has_currency_setting]
+
+      def currency_id = self.attributes[:currency_id]
+
+      def currency_name = self.attributes[:currency_name]
+
+      def currency_code = self.attributes[:currency_code]
+
+      def currency_symbol = self.attributes[:currency_symbol]
+
+      def currency_decimal_places = self.attributes[:currency_decimal_places]
+
+      def primary_currency_id = self.attributes[:primary_currency_id]
+
+      def primary_currency_name = self.attributes[:primary_currency_name]
+
+      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 current_balance = self.attributes[:current_balance]
+
+      def pc_current_balance = self.attributes[:pc_current_balance]
+
+      def balance_difference = self.attributes[:balance_difference]
+
+      def pc_balance_difference = self.attributes[:pc_balance_difference]
+
+      def opening_balance = self.attributes[:opening_balance]
+
+      def pc_opening_balance = self.attributes[:pc_opening_balance]
+
+      def virtual_balance = self.attributes[:virtual_balance]
+
+      def pc_virtual_balance = self.attributes[:pc_virtual_balance]
+
+      def debt_amount = self.attributes[:debt_amount]
+
+      def pc_debt_amount = self.attributes[:pc_debt_amount]
+
+      def current_balance_date = self.attributes[:current_balance_date]
+
+      def notes = self.attributes[:notes]
+
+      def monthly_payment_date = self.attributes[:monthly_payment_date]
+
+      def credit_card_type = self.attributes[:credit_card_type]
+
+      def account_number = self.attributes[:account_number]
+
+      def iban = self.attributes[:iban]
+
+      def bic = self.attributes[:bic]
+
+      def opening_balance_date = self.attributes[:opening_balance_date]
+
+      def liability_type = self.attributes[:liability_type]
+
+      def liability_direction = self.attributes[:liability_direction]
+
+      def interest = self.attributes[:interest]
+
+      def interest_period = self.attributes[:interest_period]
+
+      def include_net_worth = self.attributes[:include_net_worth]
+
+      def longitude = self.attributes[:longitude]
+
+      def latitude = self.attributes[:latitude]
+
+      def zoom_level = self.attributes[:zoom_level]
+
+      def last_activity = self.attributes[:last_activity]
+
+      def active? = self.active == true
+
+      def asset? = self.type == "asset"
+
+      def transactions(**parameters) = Collection.for(@resource, "transactions", NestedTransactionPage, **parameters)
+
+      def attachments(**parameters) = Collection.for(@resource, "attachments", NestedAttachmentPage, **parameters)
+
+      def piggy_banks(**parameters) = Collection.for(@resource, "piggy-banks", NestedPiggyBankPage, **parameters)
+
+      def update(payload) = self.submit(Account, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+    end
+
+    class AccountPage < Page
+      MEMBER = Account
+    end
+
+    module Accounts
+      def accounts(**parameters) = Collection.for(self, "v1/accounts", AccountPage, **parameters)
+
+      def account(id) = Account.new(self.with(path: "v1/accounts/" + Firefly.escape(id)))
+
+      def create_account(payload) = self.submit(Account, self.with(path: "v1/accounts"), payload, identify: true)
+    end
+  end
+end

data/lib/async/firefly/attachments.rb

@@ -0,0 +1,53 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class Attachment < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def attachable_type = self.attributes[:attachable_type]
+
+      def attachable_id = self.attributes[:attachable_id]
+
+      def hash_attribute = self.attributes[:hash]
+
+      def filename = self.attributes[:filename]
+
+      def download_url = self.attributes[:download_url]
+
+      def upload_url = self.attributes[:upload_url]
+
+      def title = self.attributes[:title]
+
+      def notes = self.attributes[:notes]
+
+      def mime = self.attributes[:mime]
+
+      def size = self.attributes[:size]
+
+      def update(payload) = self.submit(Attachment, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+
+      def download = self.fetch(Download, @resource.with(path: "download"))
+
+      def upload_file(bytes, content_type: Content::OCTET_STREAM)
+        self.upload(Attachment, @resource.with(path: "upload", headers: {"content-type" => content_type}), bytes)
+      end
+    end
+
+    class AttachmentPage < Page
+      MEMBER = Attachment
+    end
+
+    module Attachments
+      def attachments(**parameters) = Collection.for(self, "v1/attachments", AttachmentPage, **parameters)
+
+      def attachment(id) = Attachment.new(self.with(path: "v1/attachments/" + Firefly.escape(id)))
+
+      def create_attachment(payload) = self.submit(Attachment, self.with(path: "v1/attachments"), payload, identify: true)
+    end
+  end
+end

data/lib/async/firefly/autocomplete.rb

@@ -0,0 +1,435 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class AutocompleteAccount < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def name_with_balance = self.value[:name_with_balance]
+
+      def active = self.value[:active]
+
+      def type = self.value[:type]
+
+      def currency_id = self.value[:currency_id]
+
+      def currency_name = self.value[:currency_name]
+
+      def currency_code = self.value[:currency_code]
+
+      def currency_symbol = self.value[:currency_symbol]
+
+      def currency_decimal_places = self.value[:currency_decimal_places]
+
+      def account_currency_id = self.value[:account_currency_id]
+
+      def account_currency_name = self.value[:account_currency_name]
+
+      def account_currency_code = self.value[:account_currency_code]
+
+      def account_currency_symbol = self.value[:account_currency_symbol]
+
+      def account_currency_decimal_places = self.value[:account_currency_decimal_places]
+    end
+
+    class AutocompleteAccounts < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteAccount.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteBill < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def active = self.value[:active]
+    end
+
+    class AutocompleteBills < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteBill.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteBudget < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def active = self.value[:active]
+    end
+
+    class AutocompleteBudgets < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteBudget.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteCategory < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+    end
+
+    class AutocompleteCategories < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteCategory.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteCurrency < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def code = self.value[:code]
+
+      def symbol = self.value[:symbol]
+
+      def decimal_places = self.value[:decimal_places]
+    end
+
+    class AutocompleteCurrencies < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteCurrency.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteObjectGroup < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def title = self.value[:title]
+    end
+
+    class AutocompleteObjectGroups < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteObjectGroup.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompletePiggyBalance < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def name_with_balance = self.value[:name_with_balance]
+
+      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 object_group_id = self.value[:object_group_id]
+
+      def object_group_title = self.value[:object_group_title]
+    end
+
+    class AutocompletePiggyBalances < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompletePiggyBalance.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteRecurrence < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def description = self.value[:description]
+
+      def active = self.value[:active]
+    end
+
+    class AutocompleteRecurrences < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteRecurrence.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteRule < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def description = self.value[:description]
+
+      def active = self.value[:active]
+    end
+
+    class AutocompleteRules < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteRule.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteRuleGroup < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def description = self.value[:description]
+
+      def active = self.value[:active]
+    end
+
+    class AutocompleteRuleGroups < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteRuleGroup.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteTag < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def tag = self.value[:tag]
+    end
+
+    class AutocompleteTags < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteTag.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteTransaction < Representation
+      def id = self.value[:id]
+
+      def transaction_group_id = self.value[:transaction_group_id]
+
+      def name = self.value[:name]
+
+      def description = self.value[:description]
+    end
+
+    class AutocompleteTransactions < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteTransaction.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteTransactionType < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def type = self.value[:type]
+    end
+
+    class AutocompleteTransactionTypes < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteTransactionType.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    class AutocompleteTransactionWithMeta < Representation
+      def id = self.value[:id]
+
+      def transaction_group_id = self.value[:transaction_group_id]
+
+      def name = self.value[:name]
+
+      def description = self.value[:description]
+
+      def date = self.value[:date]
+
+      def currency_code = self.value[:currency_code]
+
+      def amount = self.value[:amount]
+    end
+
+    class AutocompleteTransactionsWithMeta < Representation
+      include Enumerable
+
+      def each(&block)
+        if block
+          self.deconstruct.each{|record| block.call(AutocompleteTransactionWithMeta.new(@resource, value: record, metadata: self.metadata))}
+        else
+          self.to_enum(:each)
+        end
+      end
+    end
+
+    module Autocomplete
+      def autocomplete_accounts(query: nil, limit: nil, date: nil, types: nil)
+        parameters = {query: query, limit: limit, date: date}.compact
+
+        if types
+          parameters[:types] = Array(types).join(",")
+        end
+
+        self.fetch(AutocompleteAccounts, self.with(path: "v1/autocomplete/accounts", parameters: parameters))
+      end
+
+      def autocomplete_bills(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteBills, self.with(path: "v1/autocomplete/bills", parameters: parameters))
+      end
+
+      def autocomplete_budgets(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteBudgets, self.with(path: "v1/autocomplete/budgets", parameters: parameters))
+      end
+
+      def autocomplete_categories(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteCategories, self.with(path: "v1/autocomplete/categories", parameters: parameters))
+      end
+
+      def autocomplete_currencies(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteCurrencies, self.with(path: "v1/autocomplete/currencies", parameters: parameters))
+      end
+
+      def autocomplete_object_groups(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteObjectGroups, self.with(path: "v1/autocomplete/object-groups", parameters: parameters))
+      end
+
+      def autocomplete_piggy_banks(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompletePiggyBalances, self.with(path: "v1/autocomplete/piggy-banks", parameters: parameters))
+      end
+
+      def autocomplete_recurrences(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteRecurrences, self.with(path: "v1/autocomplete/recurring", parameters: parameters))
+      end
+
+      def autocomplete_rule_groups(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteRuleGroups, self.with(path: "v1/autocomplete/rule-groups", parameters: parameters))
+      end
+
+      def autocomplete_rules(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteRules, self.with(path: "v1/autocomplete/rules", parameters: parameters))
+      end
+
+      def autocomplete_subscriptions(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteBills, self.with(path: "v1/autocomplete/subscriptions", parameters: parameters))
+      end
+
+      def autocomplete_tags(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteTags, self.with(path: "v1/autocomplete/tags", parameters: parameters))
+      end
+
+      def autocomplete_transaction_types(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteTransactionTypes, self.with(path: "v1/autocomplete/transaction-types", parameters: parameters))
+      end
+
+      def autocomplete_transactions(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteTransactions, self.with(path: "v1/autocomplete/transactions", parameters: parameters))
+      end
+
+      def autocomplete_transactions_with_meta(query: nil, limit: nil)
+        parameters = {query: query, limit: limit}.compact
+
+        self.fetch(AutocompleteTransactionsWithMeta, self.with(path: "v1/autocomplete/transactions-with-meta", parameters: parameters))
+      end
+    end
+  end
+end