async-vikunja 1.0.0

data/lib/async/vikunja/client.rb

@@ -0,0 +1,76 @@
+require "async/rest/resource"
+
+require_relative "admin"
+require_relative "assignees"
+require_relative "attachments"
+require_relative "auth"
+require_relative "bots"
+require_relative "buckets"
+require_relative "comments"
+require_relative "error"
+require_relative "filters"
+require_relative "labels"
+require_relative "migration"
+require_relative "notifications"
+require_relative "page"
+require_relative "projects"
+require_relative "reactions"
+require_relative "service"
+require_relative "sessions"
+require_relative "settings"
+require_relative "sharing"
+require_relative "subscriptions"
+require_relative "submit"
+require_relative "tasks"
+require_relative "teams"
+require_relative "time_entries"
+require_relative "tokens"
+require_relative "users"
+require_relative "version"
+require_relative "views"
+require_relative "webhooks"
+
+module Async
+  module Vikunja
+    class Client < Async::REST::Resource
+      ENDPOINT = Async::HTTP::Endpoint.parse(ENV.fetch("VIKUNJA_URL", "http://localhost:3456/api/v2/"))
+
+      USER_AGENT = "async-vikunja (https://github.com/n-at-han-k/async-vikunja, v" + VERSION + ")"
+
+      include Submit
+
+      include Admin
+      include Auth
+      include Bots
+      include Filters
+      include Labels
+      include Migration
+      include Notifications
+      include Projects
+      include Reactions
+      include Service
+      include Sessions
+      include Settings
+      include Sharing
+      include Subscriptions
+      include Tasks
+      include Teams
+      include TimeEntries
+      include Tokens
+      include Users
+      include Webhooks
+
+      def initialize(delegate, reference = ::Protocol::URL::Reference.parse, headers = ::Protocol::HTTP::Headers.new)
+        super
+
+        unless @headers["user-agent"]
+          @headers = @headers.merge("user-agent" => USER_AGENT)
+        end
+      end
+
+      def authenticated(token)
+        self.with(headers: {"authorization" => "Bearer " + token})
+      end
+    end
+  end
+end

data/lib/async/vikunja/comments.rb

@@ -0,0 +1,31 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class TaskComment < Representation
+      def id = self.value[:id]
+
+      def comment = self.value[:comment]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def reactions = self.value[:reactions]
+
+      def author = self.nested(User, self.value[:author])
+
+      def max_permission = self.value[:max_permission]
+
+      def update(payload) = self.submit(TaskComment, @resource, payload, method: :put)
+
+      def patch(payload) = self.merge_patch(TaskComment, @resource, payload)
+
+      def delete = self.discard(@resource)
+    end
+
+    class TaskCommentPage < Page
+      MEMBER = TaskComment
+    end
+  end
+end

data/lib/async/vikunja/error.rb

@@ -0,0 +1,52 @@
+module Async
+  module Vikunja
+    class Error < StandardError
+    end
+
+    class Failure < Error
+      def self.for(response)
+        problem = self.problem_for(response.read)
+
+        self.new(
+          response.status.to_s + ": " + self.summary_of(problem),
+          status: response.status,
+          problem: problem,
+          retry_after: response.headers["retry-after"],
+        )
+      end
+
+      def self.problem_for(payload)
+        case payload
+        in Hash => problem
+          problem
+        else
+          {detail: payload.to_s}
+        end
+      end
+
+      def self.summary_of(problem)
+        problem[:title] || problem[:detail] || problem.inspect
+      end
+
+      def initialize(message, status:, problem: {}, retry_after: nil)
+        super(message)
+
+        @status = status
+        @problem = problem
+        @retry_after = retry_after
+      end
+
+      attr :status
+      attr :problem
+      attr :retry_after
+
+      def code = @problem[:code]
+
+      def title = @problem[:title]
+
+      def detail = @problem[:detail]
+
+      def errors = Array(@problem[:errors])
+    end
+  end
+end

data/lib/async/vikunja/escape.rb

@@ -0,0 +1,9 @@
+require "protocol/url/encoding"
+
+module Async
+  module Vikunja
+    def self.escape(value)
+      ::Protocol::URL::Encoding.escape(value.to_s)
+    end
+  end
+end

data/lib/async/vikunja/filters.rb

@@ -0,0 +1,39 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class SavedFilter < Representation
+      def id = self.value[:id]
+
+      def title = self.value[:title]
+
+      def description = self.value[:description]
+
+      def is_favorite = self.value[:is_favorite]
+
+      def max_permission = self.value[:max_permission]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def owner = self.nested(User, self.value[:owner])
+
+      def filters = self.nested(TaskCollection, self.value[:filters])
+
+      def favorite? = self.is_favorite == true
+
+      def update(payload) = self.submit(SavedFilter, @resource, payload, method: :put)
+
+      def patch(payload) = self.merge_patch(SavedFilter, @resource, payload)
+
+      def delete = self.discard(@resource)
+    end
+
+    module Filters
+      def filter(id) = SavedFilter.new(self.with(path: "filters/" + Vikunja.escape(id)))
+
+      def create_filter(payload) = self.submit(SavedFilter, self.with(path: "filters"), payload, identify: true)
+    end
+  end
+end

data/lib/async/vikunja/labels.rb

@@ -0,0 +1,71 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class Label < Representation
+      def id = self.value[:id]
+
+      def title = self.value[:title]
+
+      def description = self.value[:description]
+
+      def hex_color = self.value[:hex_color]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def created_by = self.nested(User, self.value[:created_by])
+
+      def max_permission = self.value[:max_permission]
+
+      def update(payload) = self.submit(Label, @resource, payload, method: :put)
+
+      def patch(payload) = self.merge_patch(Label, @resource, payload)
+
+      def delete = self.discard(@resource)
+    end
+
+    class LabelWithTaskID < Representation
+      def id = self.value[:id]
+
+      def title = self.value[:title]
+
+      def description = self.value[:description]
+
+      def hex_color = self.value[:hex_color]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def created_by = self.nested(User, self.value[:created_by])
+    end
+
+    class LabelTask < Representation
+      def label_id = self.value[:label_id]
+
+      def created = self.value[:created]
+    end
+
+    class LabelTaskBulk < Representation
+      def labels = self.nested_list(Label, self.value[:labels])
+    end
+
+    class LabelPage < Page
+      MEMBER = LabelWithTaskID
+    end
+
+    class TaskLabelPage < Page
+      MEMBER = LabelWithTaskID
+    end
+
+    module Labels
+      def labels(**parameters) = Collection.for(self, "labels", LabelPage, **parameters)
+
+      def label(id) = Label.new(self.with(path: "labels/" + Vikunja.escape(id)))
+
+      def create_label(payload) = self.submit(Label, self.with(path: "labels"), payload, identify: true)
+    end
+  end
+end

data/lib/async/vikunja/migration.rb

@@ -0,0 +1,89 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class ColumnMapping < Representation
+      def attribute = self.value[:attribute]
+
+      def column_index = self.value[:column_index]
+
+      def column_name = self.value[:column_name]
+    end
+
+    class DetectionResult < Representation
+      def columns = self.value[:columns]
+
+      def date_format = self.value[:date_format]
+
+      def delimiter = self.value[:delimiter]
+
+      def preview_rows = self.value[:preview_rows]
+
+      def quote_char = self.value[:quote_char]
+
+      def suggested_mapping = self.nested_list(ColumnMapping, self.value[:suggested_mapping])
+    end
+
+    class PreviewTask < Representation
+      def title = self.value[:title]
+
+      def description = self.value[:description]
+
+      def done = self.value[:done]
+
+      def due_date = self.value[:due_date]
+
+      def start_date = self.value[:start_date]
+
+      def end_date = self.value[:end_date]
+
+      def labels = self.value[:labels]
+
+      def priority = self.value[:priority]
+
+      def project = self.value[:project]
+    end
+
+    class PreviewResult < Representation
+      def tasks = self.nested_list(PreviewTask, self.value[:tasks])
+
+      def total_rows = self.value[:total_rows]
+    end
+
+    class Status < Representation
+      def id = self.value[:id]
+
+      def migrator_name = self.value[:migrator_name]
+
+      def started_at = self.value[:started_at]
+
+      def finished_at = self.value[:finished_at]
+    end
+
+    module Migration
+      def csv_detect(part) = self.upload(DetectionResult, self.with(path: "migration/csv/detect"), [part])
+
+      def csv_preview(parts) = self.upload(PreviewResult, self.with(path: "migration/csv/preview"), parts)
+
+      def csv_migrate(parts) = self.upload(Message, self.with(path: "migration/csv/migrate"), parts)
+
+      def csv_status = Status.new(self.with(path: "migration/csv/status"))
+
+      def planka_migrate(payload) = self.submit(Message, self.with(path: "migration/planka/migrate"), payload)
+
+      def planka_status = Status.new(self.with(path: "migration/planka/status"))
+
+      def ticktick_migrate(part) = self.upload(Message, self.with(path: "migration/ticktick/migrate"), [part])
+
+      def ticktick_status = Status.new(self.with(path: "migration/ticktick/status"))
+
+      def vikunja_file_migrate(part) = self.upload(Message, self.with(path: "migration/vikunja-file/migrate"), [part])
+
+      def vikunja_file_status = Status.new(self.with(path: "migration/vikunja-file/status"))
+
+      def wekan_migrate(part) = self.upload(Message, self.with(path: "migration/wekan/migrate"), [part])
+
+      def wekan_status = Status.new(self.with(path: "migration/wekan/status"))
+    end
+  end
+end

data/lib/async/vikunja/notifications.rb

@@ -0,0 +1,45 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class DatabaseNotification < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def notification = self.value[:notification]
+
+      def read_at = self.value[:read_at]
+
+      def created = self.value[:created]
+    end
+
+    class DatabaseNotifications < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def notification = self.value[:notification]
+
+      def read = self.value[:read]
+
+      def read_at = self.value[:read_at]
+
+      def created = self.value[:created]
+    end
+
+    class NotificationPage < Page
+      MEMBER = DatabaseNotification
+    end
+
+    module Notifications
+      def notifications(**parameters) = Collection.for(self, "notifications", NotificationPage, **parameters)
+
+      def mark_notifications_read = self.submit(Message, self.with(path: "notifications"), nil)
+
+      def clear_notifications = self.discard(self.with(path: "notifications"))
+
+      def update_notification(id, payload) = self.submit(DatabaseNotifications, self.with(path: "notifications/" + Vikunja.escape(id)), payload, method: :put)
+    end
+  end
+end

data/lib/async/vikunja/page.rb

@@ -0,0 +1,112 @@
+require_relative "representation"
+
+module Async
+  module Vikunja
+    class Page < Representation
+      include Enumerable
+
+      MEMBER = Representation
+
+      def items = Array(self.value[:items])
+
+      def page = self.value[:page].to_i
+
+      def per_page = self.value[:per_page].to_i
+
+      def total = self.value[:total].to_i
+
+      def total_pages = self.value[:total_pages].to_i
+
+      def last? = self.page >= [self.total_pages, 1].max
+
+      def empty? = self.items.empty?
+
+      def each(&block)
+        if block
+          self.items.each do |record|
+            block.call(self.member_for(record))
+          end
+        else
+          self.to_enum(:each)
+        end
+      end
+
+      def member_class = self.class::MEMBER
+
+      def member_path(record) = Vikunja.escape(record[:id])
+
+      def member_resource(record)
+        @resource.with(path: self.member_path(record), parameters: nil, merge: false)
+      end
+
+      def member_for(record)
+        self.member_class.new(self.member_resource(record), value: record, metadata: self.metadata)
+      end
+    end
+
+    class Collection
+      include Enumerable
+
+      DEFAULT_PER_PAGE = 50
+
+      def self.for(parent, path, page_class, **parameters)
+        self.new(parent.with(path: path, parameters: parameters), page_class)
+      end
+
+      def initialize(resource, page_class)
+        @resource = resource
+        @page_class = page_class
+      end
+
+      attr :resource
+
+      attr :page_class
+
+      def each_page(per_page: DEFAULT_PER_PAGE, &block)
+        if block
+          self.walk(per_page, &block)
+        else
+          self.to_enum(:each_page, per_page: per_page)
+        end
+      end
+
+      def each(**options, &block)
+        if block
+          self.each_page(**options) do |page|
+            page.each(&block)
+          end
+        else
+          self.to_enum(:each, **options)
+        end
+      end
+
+      def page(number, per_page: DEFAULT_PER_PAGE)
+        @page_class.new(@resource.with(parameters: {page: number, per_page: per_page}))
+      end
+
+      def total
+        self.page(1, per_page: 1).total
+      end
+
+      def walk(per_page, &block)
+        number = 1
+
+        while true
+          page = self.page(number, per_page: per_page)
+
+          if page.empty?
+            break
+          end
+
+          block.call(page)
+
+          if page.last?
+            break
+          end
+
+          number += 1
+        end
+      end
+    end
+  end
+end

data/lib/async/vikunja/projects.rb

@@ -0,0 +1,133 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class Project < Representation
+      def id = self.value[:id]
+
+      def title = self.value[:title]
+
+      def description = self.value[:description]
+
+      def identifier = self.value[:identifier]
+
+      def hex_color = self.value[:hex_color]
+
+      def position = self.value[:position]
+
+      def parent_project_id = self.value[:parent_project_id]
+
+      def is_archived = self.value[:is_archived]
+
+      def is_favorite = self.value[:is_favorite]
+
+      def max_permission = self.value[:max_permission]
+
+      def background_blur_hash = self.value[:background_blur_hash]
+
+      def background_information = self.value[:background_information]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def owner = self.nested(User, self.value[:owner])
+
+      def subscription = self.nested(Subscription, self.value[:subscription])
+
+      def views = self.nested_list(ProjectView, self.value[:views])
+
+      def archived? = self.is_archived == true
+
+      def favorite? = self.is_favorite == true
+
+      def tasks(**parameters) = Collection.for(@resource, "tasks", ProjectTaskPage, **parameters)
+
+      def project_views(**parameters) = Collection.for(@resource, "views", ProjectViewPage, **parameters)
+
+      def shares(**parameters) = Collection.for(@resource, "shares", LinkSharingPage, **parameters)
+
+      def teams(**parameters) = Collection.for(@resource, "teams", TeamWithPermissionPage, **parameters)
+
+      def users(**parameters) = Collection.for(@resource, "users", ProjectUserPage, **parameters)
+
+      def webhooks(**parameters) = Collection.for(@resource, "webhooks", ProjectWebhookPage, **parameters)
+
+      def time_entries(**parameters) = Collection.for(@resource, "time-entries", ProjectTimeEntryPage, **parameters)
+
+      def view(id) = ProjectView.new(@resource.with(path: "views/" + Vikunja.escape(id)))
+
+      def share(id) = LinkSharing.new(@resource.with(path: "shares/" + Vikunja.escape(id)))
+
+      def task_by_index(index) = TaskReadOneBody.new(@resource.with(path: "tasks/by-index/" + Vikunja.escape(index)))
+
+      def background = Download.new(@resource.with(path: "background"))
+
+      def search_users(query) = UserSearchPage.new(@resource.with(path: "users/search", parameters: {q: query}))
+
+      def create_task(payload) = self.submit(Task, @resource.with(path: "tasks"), payload, identify: "../../../tasks/")
+
+      def create_tasks(titles) = self.submit(BulkTaskCreation, @resource.with(path: "tasks/bulk"), {tasks: titles}, identify: nil)
+
+      def create_view(payload) = self.submit(ProjectView, @resource.with(path: "views"), payload, identify: true)
+
+      def create_share(payload) = self.submit(LinkSharing, @resource.with(path: "shares"), payload, identify: true)
+
+      def create_webhook(payload) = self.submit(Webhook, @resource.with(path: "webhooks"), payload, identify: true)
+
+      def add_team(payload) = self.submit(TeamProject, @resource.with(path: "teams"), payload)
+
+      def add_user(payload) = self.submit(ProjectUser, @resource.with(path: "users"), payload)
+
+      def update_team(team, payload) = self.submit(TeamProject, @resource.with(path: "teams/" + Vikunja.escape(team)), payload, method: :put)
+
+      def update_user(user, payload) = self.submit(ProjectUser, @resource.with(path: "users/" + Vikunja.escape(user)), payload, method: :put)
+
+      def update_webhook(webhook, payload) = self.submit(Webhook, @resource.with(path: "webhooks/" + Vikunja.escape(webhook)), payload, method: :put)
+
+      def remove_team(team) = self.discard(@resource.with(path: "teams/" + Vikunja.escape(team)))
+
+      def remove_user(user) = self.discard(@resource.with(path: "users/" + Vikunja.escape(user)))
+
+      def remove_webhook(webhook) = self.discard(@resource.with(path: "webhooks/" + Vikunja.escape(webhook)))
+
+      def remove_share(id) = self.discard(@resource.with(path: "shares/" + Vikunja.escape(id)))
+
+      def duplicate(payload = {}) = self.submit(ProjectDuplicate, @resource.with(path: "duplicate"), payload)
+
+      def upload_background(part) = self.upload(Project, @resource.with(path: "backgrounds/upload"), [part], method: :put)
+
+      def remove_background = self.submit(Project, @resource.with(path: "background"), nil, method: :delete)
+
+      def update(payload) = self.submit(Project, @resource, payload, method: :put)
+
+      def patch(payload) = self.merge_patch(Project, @resource, payload)
+
+      def delete = self.discard(@resource)
+    end
+
+    class ProjectDuplicate < Representation
+      def parent_project_id = self.value[:parent_project_id]
+
+      def duplicate_shares = self.value[:duplicate_shares]
+
+      def duplicated_project = self.nested(Project, self.value[:duplicated_project])
+    end
+
+    class ProjectPage < Page
+      MEMBER = Project
+    end
+
+    class AdminProjectPage < ProjectPage
+      def member_path(record) = "../../projects/" + Vikunja.escape(record[:id])
+    end
+
+    module Projects
+      def projects(**parameters) = Collection.for(self, "projects", ProjectPage, **parameters)
+
+      def project(id) = Project.new(self.with(path: "projects/" + Vikunja.escape(id)))
+
+      def create_project(payload) = self.submit(Project, self.with(path: "projects"), payload, identify: true)
+    end
+  end
+end

data/lib/async/vikunja/reactions.rb

@@ -0,0 +1,19 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class Reaction < Representation
+      def created = self.value[:created]
+
+      def user = self.nested(User, self.value[:user])
+    end
+
+    module Reactions
+      def reactions(entitykind, entityid) = Representation.new(self.with(path: Vikunja.escape(entitykind) + "/" + Vikunja.escape(entityid) + "/reactions"))
+
+      def add_reaction(entitykind, entityid, payload) = self.submit(Reaction, self.with(path: Vikunja.escape(entitykind) + "/" + Vikunja.escape(entityid) + "/reactions"), payload)
+
+      def remove_reaction(entitykind, entityid, payload) = self.submit(Representation, self.with(path: Vikunja.escape(entitykind) + "/" + Vikunja.escape(entityid) + "/reactions/delete"), payload)
+    end
+  end
+end