async-vikunja 1.0.0

data/lib/async/vikunja/redacted.rb

@@ -0,0 +1,37 @@
+module Async
+  module Vikunja
+    module Redacted
+      SECRET = [
+        :access_token,
+        :basic_auth_password,
+        :client_secret,
+        :code_verifier,
+        :new_password,
+        :old_password,
+        :passcode,
+        :password,
+        :refresh_token,
+        :secret,
+        :token,
+        :totp_passcode,
+      ].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/vikunja/representation.rb

@@ -0,0 +1,73 @@
+require "async/rest/representation"
+
+require_relative "escape"
+require_relative "redacted"
+require_relative "submit"
+require_relative "wrapper"
+
+module Async
+  module Vikunja
+    class Representation < Async::REST::Representation[Wrapper]
+      include Redacted
+      include Submit
+
+      def self.schema = self.name.to_s.split("::").last
+
+      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 PatchRepresentation < Representation
+      WRAPPER = MergePatch.new
+    end
+
+    class UploadRepresentation < Representation
+      WRAPPER = Multipart.new
+    end
+
+    class Download < Representation
+      WRAPPER = Wrapper.new
+
+      def bytes = self.value
+
+      def media_type = self.metadata["content-type"]
+    end
+  end
+end

data/lib/async/vikunja/service.rb

@@ -0,0 +1,137 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class LocalAuthInfo < Representation
+      def enabled = self.value[:enabled]
+
+      def registration_enabled = self.value[:registration_enabled]
+    end
+
+    class LdapAuthInfo < Representation
+      def enabled = self.value[:enabled]
+    end
+
+    class Provider < Representation
+      def auth_url = self.value[:auth_url]
+
+      def client_id = self.value[:client_id]
+
+      def email_fallback = self.value[:email_fallback]
+
+      def force_user_info = self.value[:force_user_info]
+
+      def key = self.value[:key]
+
+      def logout_url = self.value[:logout_url]
+
+      def name = self.value[:name]
+
+      def scope = self.value[:scope]
+
+      def username_fallback = self.value[:username_fallback]
+    end
+
+    class OpenIDAuthInfo < Representation
+      def enabled = self.value[:enabled]
+
+      def providers = self.nested_list(Provider, self.value[:providers])
+    end
+
+    class AuthInfo < Representation
+      def ldap = self.nested(LdapAuthInfo, self.value[:ldap])
+
+      def local = self.nested(LocalAuthInfo, self.value[:local])
+
+      def openid_connect = self.nested(OpenIDAuthInfo, self.value[:openid_connect])
+    end
+
+    class LegalInfo < Representation
+      def imprint_url = self.value[:imprint_url]
+
+      def privacy_policy_url = self.value[:privacy_policy_url]
+    end
+
+    class VikunjaInfos < Representation
+      def allow_icon_changes = self.value[:allow_icon_changes]
+
+      def auth = self.nested(AuthInfo, self.value[:auth])
+
+      def available_migrators = self.value[:available_migrators]
+
+      def caldav_enabled = self.value[:caldav_enabled]
+
+      def concurrent_writes = self.value[:concurrent_writes]
+
+      def demo_mode_enabled = self.value[:demo_mode_enabled]
+
+      def email_reminders_enabled = self.value[:email_reminders_enabled]
+
+      def enabled_background_providers = self.value[:enabled_background_providers]
+
+      def enabled_pro_features = self.value[:enabled_pro_features]
+
+      def frontend_url = self.value[:frontend_url]
+
+      def legal = self.nested(LegalInfo, self.value[:legal])
+
+      def link_sharing_enabled = self.value[:link_sharing_enabled]
+
+      def max_file_size = self.value[:max_file_size]
+
+      def max_items_per_page = self.value[:max_items_per_page]
+
+      def motd = self.value[:motd]
+
+      def public_teams_enabled = self.value[:public_teams_enabled]
+
+      def task_attachments_enabled = self.value[:task_attachments_enabled]
+
+      def task_comments_enabled = self.value[:task_comments_enabled]
+
+      def totp_enabled = self.value[:totp_enabled]
+
+      def user_deletion_enabled = self.value[:user_deletion_enabled]
+
+      def version = self.value[:version]
+
+      def webhooks_enabled = self.value[:webhooks_enabled]
+    end
+
+    class ProviderStatus < Representation
+      def available = self.value[:available]
+
+      def key = self.value[:key]
+    end
+
+    class Health < Representation
+      def self.schema = "HealthBodyBody"
+
+      def openid_providers = self.nested_list(ProviderStatus, self.value[:openid_providers])
+
+      def status = self.value[:status]
+
+      def ok? = self.status == "OK"
+    end
+
+    class RouteDetail < Representation
+      def method = self.value[:method]
+
+      def path = self.value[:path]
+    end
+
+    class Message < Representation
+      def message = self.value[:message]
+    end
+
+    module Service
+      def info = VikunjaInfos.new(self.with(path: "info"))
+
+      def health = Health.new(self.with(path: "health"))
+
+      def routes = Representation.new(self.with(path: "routes"))
+
+      def notifications_atom = Download.new(self.with(path: "notifications.atom"))
+    end
+  end
+end

data/lib/async/vikunja/sessions.rb

@@ -0,0 +1,29 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class Session < Representation
+      def id = self.value[:id]
+
+      def created = self.value[:created]
+
+      def device_info = self.value[:device_info]
+
+      def ip_address = self.value[:ip_address]
+
+      def last_active = self.value[:last_active]
+
+      def refresh_token = self.value[:refresh_token]
+    end
+
+    class SessionPage < Page
+      MEMBER = Session
+    end
+
+    module Sessions
+      def sessions(**parameters) = Collection.for(self, "user/sessions", SessionPage, **parameters)
+
+      def delete_session(id) = self.discard(self.with(path: "user/sessions/" + Vikunja.escape(id)))
+    end
+  end
+end

data/lib/async/vikunja/settings.rb

@@ -0,0 +1,67 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class UserGeneralSettings < Representation
+      def default_project_id = self.value[:default_project_id]
+
+      def discoverable_by_email = self.value[:discoverable_by_email]
+
+      def discoverable_by_name = self.value[:discoverable_by_name]
+
+      def email_reminders_enabled = self.value[:email_reminders_enabled]
+
+      def extra_settings_links = self.value[:extra_settings_links]
+
+      def frontend_settings = self.value[:frontend_settings]
+
+      def language = self.value[:language]
+
+      def name = self.value[:name]
+
+      def overdue_tasks_reminders_enabled = self.value[:overdue_tasks_reminders_enabled]
+
+      def overdue_tasks_reminders_time = self.value[:overdue_tasks_reminders_time]
+
+      def timezone = self.value[:timezone]
+
+      def week_start = self.value[:week_start]
+    end
+
+    class UserAvatarProviderBody < Representation
+      def avatar_provider = self.value[:avatar_provider]
+    end
+
+    class TOTP < Representation
+      def enabled = self.value[:enabled]
+
+      def secret = self.value[:secret]
+
+      def url = self.value[:url]
+
+      def enabled? = self.enabled == true
+    end
+
+    module Settings
+      def update_settings(payload) = self.submit(UserActionMessageBody, self.with(path: "user/settings/general"), payload, method: :put)
+
+      def avatar_provider = UserAvatarProviderBody.new(self.with(path: "user/settings/avatar/provider"))
+
+      def set_avatar_provider(avatar_provider:) = self.submit(UserAvatarProviderBody, self.with(path: "user/settings/avatar/provider"), {avatar_provider: avatar_provider}, method: :put)
+
+      def patch_avatar_provider(payload) = self.merge_patch(UserAvatarProviderBody, self.with(path: "user/settings/avatar/provider"), payload)
+
+      def upload_avatar(part) = self.upload(Message, self.with(path: "user/settings/avatar"), [part], method: :put)
+
+      def totp = TOTP.new(self.with(path: "user/settings/totp"))
+
+      def enroll_totp = self.submit(TOTP, self.with(path: "user/settings/totp/enroll"), nil)
+
+      def enable_totp(passcode:) = self.submit(Message, self.with(path: "user/settings/totp/enable"), {passcode: passcode})
+
+      def disable_totp(password:) = self.submit(Message, self.with(path: "user/settings/totp/disable"), {password: password})
+
+      def totp_qrcode = Download.new(self.with(path: "user/settings/totp/qrcode"))
+    end
+  end
+end

data/lib/async/vikunja/sharing.rb

@@ -0,0 +1,131 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class LinkSharing < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def hash = self.value[:hash]
+
+      def password = self.value[:password]
+
+      def permission = self.value[:permission]
+
+      def sharing_type = self.value[:sharing_type]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def shared_by = self.nested(User, self.value[:shared_by])
+    end
+
+    class LinkShareToken < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def hash = self.value[:hash]
+
+      def password = self.value[:password]
+
+      def permission = self.value[:permission]
+
+      def project_id = self.value[:project_id]
+
+      def sharing_type = self.value[:sharing_type]
+
+      def token = self.value[:token]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def shared_by = self.nested(User, self.value[:shared_by])
+    end
+
+    class ProjectUser < Representation
+      def id = self.value[:id]
+
+      def username = self.value[:username]
+
+      def permission = self.value[:permission]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+    end
+
+    class TeamProject < Representation
+      def id = self.value[:id]
+
+      def team_id = self.value[:team_id]
+
+      def permission = self.value[:permission]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+    end
+
+    class TeamWithPermission < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def description = self.value[:description]
+
+      def is_public = self.value[:is_public]
+
+      def external_id = self.value[:external_id]
+
+      def permission = self.value[:permission]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def created_by = self.nested(User, self.value[:created_by])
+
+      def members = self.nested_list(TeamUser, self.value[:members])
+    end
+
+    class UserWithPermission < Representation
+      def id = self.value[:id]
+
+      def username = self.value[:username]
+
+      def name = self.value[:name]
+
+      def email = self.value[:email]
+
+      def permission = self.value[:permission]
+
+      def bot_owner_id = self.value[:bot_owner_id]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+    end
+
+    class LinkSharingPage < Page
+      MEMBER = LinkSharing
+    end
+
+    class TeamWithPermissionPage < Page
+      MEMBER = TeamWithPermission
+    end
+
+    class ProjectUserPage < Page
+      MEMBER = UserWithPermission
+
+      def member_path(record) = Vikunja.escape(record[:username])
+    end
+
+    module Sharing
+      def authenticate_share(share, payload = {}) = self.submit(LinkShareToken, self.with(path: "shares/" + Vikunja.escape(share) + "/auth"), payload)
+    end
+  end
+end

data/lib/async/vikunja/submit.rb

@@ -0,0 +1,97 @@
+require_relative "error"
+
+module Async
+  module Vikunja
+    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|
+            if response.success?
+              self.representation_of(klass, target, response, identify)
+            else
+              raise Failure.for(response)
+            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)
+        if identify.nil? || !value.is_a?(Hash) || value[:id].nil?
+          resource
+        else
+          resource.with(path: self.prefix_of(identify) + Vikunja.escape(value[:id]), parameters: nil, merge: false)
+        end
+      end
+
+      def prefix_of(identify)
+        if identify == true
+          ""
+        else
+          identify
+        end
+      end
+
+      def merge_patch(klass, resource, payload)
+        self.submit(klass, resource, payload, method: :patch, through: PatchRepresentation)
+      end
+
+      def upload(klass, resource, parts, method: :post)
+        self.submit(klass, resource, parts, method: method, through: UploadRepresentation)
+      end
+
+      def discard(resource, payload = nil, method: :delete)
+        self.with_retry do
+          Representation.public_send(method, resource, payload) do |target, response|
+            if response.success?
+              true
+            else
+              raise Failure.for(response)
+            end
+          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/vikunja/subscriptions.rb

@@ -0,0 +1,21 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class Subscription < Representation
+      def created = self.value[:created]
+
+      def entity = self.value[:entity]
+
+      def entity_id = self.value[:entity_id]
+
+      def id = self.value[:id]
+    end
+
+    module Subscriptions
+      def subscribe(entity, entity_id) = self.submit(Subscription, self.with(path: "subscriptions/" + Vikunja.escape(entity) + "/" + Vikunja.escape(entity_id)))
+
+      def unsubscribe(entity, entity_id) = self.discard(self.with(path: "subscriptions/" + Vikunja.escape(entity) + "/" + Vikunja.escape(entity_id)))
+    end
+  end
+end