async-firefly 1.0.0

data/lib/async/firefly/piggy_banks.rb

@@ -0,0 +1,153 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class PiggyBankAccount < Representation
+      def account_id = self.data[:account_id]
+
+      def name = self.data[:name]
+
+      def current_amount = self.data[:current_amount]
+
+      def pc_current_amount = self.data[:pc_current_amount]
+    end
+
+    class PiggyBank < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def name = self.attributes[:name]
+
+      def percentage = self.attributes[:percentage]
+
+      def start_date = self.attributes[:start_date]
+
+      def target_date = self.attributes[:target_date]
+
+      def order = self.attributes[:order]
+
+      def active = self.attributes[:active]
+
+      def notes = self.attributes[:notes]
+
+      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 accounts = self.nested_list(PiggyBankAccount, self.attributes[:accounts])
+
+      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 target_amount = self.attributes[:target_amount]
+
+      def pc_target_amount = self.attributes[:pc_target_amount]
+
+      def current_amount = self.attributes[:current_amount]
+
+      def pc_current_amount = self.attributes[:pc_current_amount]
+
+      def left_to_save = self.attributes[:left_to_save]
+
+      def pc_left_to_save = self.attributes[:pc_left_to_save]
+
+      def save_per_month = self.attributes[:save_per_month]
+
+      def pc_save_per_month = self.attributes[:pc_save_per_month]
+
+      def active? = self.active == true
+
+      def events(**parameters) = Collection.for(@resource, "events", PiggyBankEventPage, **parameters)
+
+      def attachments(**parameters) = Collection.for(@resource, "attachments", NestedAttachmentPage, **parameters)
+
+      def linked_accounts(**parameters) = Collection.for(@resource, "accounts", PiggyBankLinkedAccountPage, **parameters)
+
+      def update(payload) = self.submit(PiggyBank, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+    end
+
+    class PiggyBankEvent < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def amount = self.attributes[:amount]
+
+      def pc_amount = self.attributes[:pc_amount]
+
+      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 transaction_journal_id = self.attributes[:transaction_journal_id]
+
+      def transaction_group_id = self.attributes[:transaction_group_id]
+    end
+
+    class PiggyBankPage < Page
+      MEMBER = PiggyBank
+    end
+
+    class PiggyBankEventPage < Page
+      MEMBER = PiggyBankEvent
+
+      def member_resource(record) = @resource
+    end
+
+    class PiggyBankLinkedAccountPage < NestedPage
+      def member_class = Account
+
+      def collection = "accounts"
+    end
+
+    module PiggyBanks
+      def piggy_banks(**parameters) = Collection.for(self, "v1/piggy-banks", PiggyBankPage, **parameters)
+
+      def piggy_bank(id) = PiggyBank.new(self.with(path: "v1/piggy-banks/" + Firefly.escape(id)))
+
+      def create_piggy_bank(payload) = self.submit(PiggyBank, self.with(path: "v1/piggy-banks"), payload, identify: true)
+    end
+  end
+end

data/lib/async/firefly/preferences.rb

@@ -0,0 +1,58 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class Preference < Representation
+      def id
+        case self.value
+        in {data: {id: String | Integer => id}}
+          id
+        else
+          nil
+        end
+      end
+
+      def type
+        case self.value
+        in {data: {type: String => type}}
+          type
+        else
+          nil
+        end
+      end
+
+      def attributes
+        case self.value
+        in {data: {attributes: Hash => attributes}}
+          attributes
+        else
+          {}
+        end
+      end
+
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def name = self.attributes[:name]
+
+      def data = self.attributes[:data]
+
+      def update(payload) = self.submit(Preference, @resource, payload, method: :put)
+    end
+
+    class PreferencePage < Page
+      MEMBER = Preference
+
+      def member_path(record) = self.identifier(record, :attributes, :name)
+    end
+
+    module Preferences
+      def preferences(**parameters) = Collection.for(self, "v1/preferences", PreferencePage, **parameters)
+
+      def preference(name) = Preference.new(self.with(path: "v1/preferences/" + Firefly.escape(name)))
+
+      def create_preference(payload) = self.submit(Preference, self.with(path: "v1/preferences"), payload, identify: :name)
+    end
+  end
+end

data/lib/async/firefly/recurrences.rb

@@ -0,0 +1,169 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class RecurrenceRepetition < Representation
+      def id = self.value[:id]
+
+      def created_at = self.value[:created_at]
+
+      def updated_at = self.value[:updated_at]
+
+      def type = self.value[:type]
+
+      def moment = self.value[:moment]
+
+      def skip = self.value[:skip]
+
+      def weekend = self.value[:weekend]
+
+      def description = self.value[:description]
+
+      def occurrences = self.value[:occurrences]
+    end
+
+    class RecurrenceTransaction < Representation
+      def id = self.value[:id]
+
+      def description = self.value[:description]
+
+      def object_has_currency_setting = self.value[:object_has_currency_setting]
+
+      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 primary_currency_id = self.value[:primary_currency_id]
+
+      def primary_currency_name = self.value[:primary_currency_name]
+
+      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 foreign_currency_id = self.value[:foreign_currency_id]
+
+      def foreign_currency_name = self.value[:foreign_currency_name]
+
+      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 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 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 tags = self.value[:tags]
+
+      def piggy_bank_id = self.value[:piggy_bank_id]
+
+      def piggy_bank_name = self.value[:piggy_bank_name]
+
+      def subscription_id = self.value[:subscription_id]
+
+      def subscription_name = self.value[:subscription_name]
+    end
+
+    class Recurrence < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def type = self.attributes[:type]
+
+      def title = self.attributes[:title]
+
+      def description = self.attributes[:description]
+
+      def first_date = self.attributes[:first_date]
+
+      def latest_date = self.attributes[:latest_date]
+
+      def repeat_until = self.attributes[:repeat_until]
+
+      def apply_rules = self.attributes[:apply_rules]
+
+      def active = self.attributes[:active]
+
+      def nr_of_repetitions = self.attributes[:nr_of_repetitions]
+
+      def notes = self.attributes[:notes]
+
+      def repetitions = self.nested_list(RecurrenceRepetition, self.attributes[:repetitions])
+
+      def transactions = self.nested_list(RecurrenceTransaction, self.attributes[:transactions])
+
+      def active? = self.active == true
+
+      def transaction_history(**parameters) = Collection.for(@resource, "transactions", RecurrenceTransactionPage, **parameters)
+
+      def fire(**parameters) = self.submit(RecurrenceTriggerPage, @resource.with(path: "trigger", parameters: parameters), identify: nil)
+
+      def update(payload) = self.submit(Recurrence, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+    end
+
+    class RecurrencePage < Page
+      MEMBER = Recurrence
+    end
+
+    class RecurrenceTransactionPage < Page
+      def member_class = Transaction
+
+      def member_path(record) = "../../../transactions/" + self.identifier(record, :id)
+    end
+
+    class RecurrenceTriggerPage < Page
+      def member_class = Transaction
+
+      def member_path(record) = "../../../transactions/" + self.identifier(record, :id)
+    end
+
+    module Recurrences
+      def recurrences(**parameters) = Collection.for(self, "v1/recurrences", RecurrencePage, **parameters)
+
+      def recurrence(id) = Recurrence.new(self.with(path: "v1/recurrences/" + Firefly.escape(id)))
+
+      def create_recurrence(payload) = self.submit(Recurrence, self.with(path: "v1/recurrences"), payload, identify: true)
+    end
+  end
+end

data/lib/async/firefly/redacted.rb

@@ -0,0 +1,32 @@
+module Async
+  module Firefly
+    module Redacted
+      SECRET = [
+        :access_token,
+        :client_secret,
+        :code_verifier,
+        :password,
+        :refresh_token,
+        :secret,
+        :token,
+      ].freeze
+
+      REDACTED = "[redacted]"
+
+      def self.redact(value)
+        case value
+        when Hash
+          value.to_h{|key, nested| SECRET.include?(key) ? [key, REDACTED] : [key, self.redact(nested)]}
+        when Array
+          value.map{|each| self.redact(each)}
+        else
+          value
+        end
+      end
+
+      def inspect
+        "\#<" + self.class.to_s + " " + @resource.path.to_s.inspect + " value=" + Redacted.redact(@value).inspect + ">"
+      end
+    end
+  end
+end

data/lib/async/firefly/representation.rb

@@ -0,0 +1,99 @@
+require "async/rest/representation"
+
+require_relative "escape"
+require_relative "redacted"
+require_relative "submit"
+require_relative "wrapper"
+
+module Async
+  module Firefly
+    class Representation < Async::REST::Representation[Wrapper]
+      include Redacted
+      include Submit
+
+      def self.schema = self.name.to_s.split("::").last
+
+      def data
+        case self.value
+        in {data: Hash => data}
+          data
+        in {data: Array}
+          {}
+        in Hash => value
+          value
+        else
+          {}
+        end
+      end
+
+      def attributes
+        case self.data
+        in {attributes: Hash => attributes}
+          attributes
+        else
+          {}
+        end
+      end
+
+      def id = self.data[:id]
+
+      def type = self.data[:type]
+
+      def deconstruct_keys(keys)
+        case self.value
+        in Hash => value
+          value
+        else
+          {}
+        end
+      end
+
+      def deconstruct
+        case self.value
+        in Array => value
+          value
+        else
+          []
+        end
+      end
+
+      def cacheable?
+        cache_control = self.metadata["cache-control"]
+
+        if cache_control
+          !cache_control.no_store?
+        else
+          true
+        end
+      end
+
+      def nested(klass, value)
+        if value
+          klass.new(@resource, value: value, metadata: self.metadata)
+        end
+      end
+
+      def nested_list(klass, values)
+        Array(values).map do |value|
+          self.nested(klass, value)
+        end
+      end
+    end
+
+    class Download < Representation
+      WRAPPER = Content.new
+
+      def bytes = self.value
+
+      def media_type = self.metadata["content-type"]&.split(";")&.first
+
+      def content_disposition = self.metadata["content-disposition"]
+
+      def size = self.value.to_s.bytesize
+    end
+
+    class Upload < Representation
+      WRAPPER = Binary.new
+    end
+  end
+end

data/lib/async/firefly/rule_groups.rb

@@ -0,0 +1,55 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class RuleGroup < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def title = self.attributes[:title]
+
+      def description = self.attributes[:description]
+
+      def order = self.attributes[:order]
+
+      def active = self.attributes[:active]
+
+      def active? = self.active == true
+
+      def rules(**parameters) = Collection.for(@resource, "rules", RuleGroupRulePage, **parameters)
+
+      def test(**parameters) = Collection.for(@resource, "test", RuleGroupTestPage, **parameters)
+
+      def fire(**parameters) = self.discard(@resource.with(path: "trigger", parameters: parameters), method: :post)
+
+      def update(payload) = self.submit(RuleGroup, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+    end
+
+    class RuleGroupPage < Page
+      MEMBER = RuleGroup
+    end
+
+    class RuleGroupRulePage < Page
+      def member_class = Rule
+
+      def member_path(record) = "../../../rules/" + self.identifier(record, :id)
+    end
+
+    class RuleGroupTestPage < Page
+      def member_class = Transaction
+
+      def member_path(record) = "../../../transactions/" + self.identifier(record, :id)
+    end
+
+    module RuleGroups
+      def rule_groups(**parameters) = Collection.for(self, "v1/rule-groups", RuleGroupPage, **parameters)
+
+      def rule_group(id) = RuleGroup.new(self.with(path: "v1/rule-groups/" + Firefly.escape(id)))
+
+      def create_rule_group(payload) = self.submit(RuleGroup, self.with(path: "v1/rule-groups"), payload, identify: true)
+    end
+  end
+end

data/lib/async/firefly/rules.rb

@@ -0,0 +1,105 @@
+require_relative "page"
+
+module Async
+  module Firefly
+    class RuleAction < Representation
+      def id = self.value[:id]
+
+      def created_at = self.value[:created_at]
+
+      def updated_at = self.value[:updated_at]
+
+      def type = self.value[:type]
+
+      def value_attribute = self.value[:value]
+
+      def order = self.value[:order]
+
+      def active = self.value[:active]
+
+      def stop_processing = self.value[:stop_processing]
+    end
+
+    class RuleTrigger < Representation
+      def id = self.value[:id]
+
+      def created_at = self.value[:created_at]
+
+      def updated_at = self.value[:updated_at]
+
+      def type = self.value[:type]
+
+      def value_attribute = self.value[:value]
+
+      def prohibited = self.value[:prohibited]
+
+      def order = self.value[:order]
+
+      def active = self.value[:active]
+
+      def stop_processing = self.value[:stop_processing]
+    end
+
+    class Rule < Representation
+      def created_at = self.attributes[:created_at]
+
+      def updated_at = self.attributes[:updated_at]
+
+      def title = self.attributes[:title]
+
+      def description = self.attributes[:description]
+
+      def rule_group_id = self.attributes[:rule_group_id]
+
+      def rule_group_title = self.attributes[:rule_group_title]
+
+      def order = self.attributes[:order]
+
+      def trigger = self.attributes[:trigger]
+
+      def active = self.attributes[:active]
+
+      def strict = self.attributes[:strict]
+
+      def stop_processing = self.attributes[:stop_processing]
+
+      def triggers = self.nested_list(RuleTrigger, self.attributes[:triggers])
+
+      def actions = self.nested_list(RuleAction, self.attributes[:actions])
+
+      def active? = self.active == true
+
+      def test(**parameters) = RuleTestPage.new(@resource.with(path: "test", parameters: parameters))
+
+      def fire(**parameters) = self.discard(@resource.with(path: "trigger", parameters: parameters), method: :post)
+
+      def update(payload) = self.submit(Rule, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+    end
+
+    class RulePage < Page
+      MEMBER = Rule
+    end
+
+    class RuleTestPage < Page
+      def member_class = Transaction
+
+      def member_path(record) = "../../../transactions/" + self.identifier(record, :id)
+    end
+
+    class RuleExpressionValidity < Representation
+      def valid = self.value[:valid]
+    end
+
+    module Rules
+      def rules(**parameters) = Collection.for(self, "v1/rules", RulePage, **parameters)
+
+      def rule(id) = Rule.new(self.with(path: "v1/rules/" + Firefly.escape(id)))
+
+      def create_rule(payload) = self.submit(Rule, self.with(path: "v1/rules"), payload, identify: true)
+
+      def validate_rule_expression(expression) = RuleExpressionValidity.new(self.with(path: "v1/rules/validate-expression", parameters: {expression: expression}))
+    end
+  end
+end