async-vikunja 1.0.0

data/lib/async/vikunja/tasks.rb

@@ -0,0 +1,207 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    module TaskFields
+      def id = self.value[:id]
+
+      def title = self.value[:title]
+
+      def description = self.value[:description]
+
+      def identifier = self.value[:identifier]
+
+      def index = self.value[:index]
+
+      def done = self.value[:done]
+
+      def done_at = self.value[:done_at]
+
+      def due_date = self.value[:due_date]
+
+      def start_date = self.value[:start_date]
+
+      def end_date = self.value[:end_date]
+
+      def hex_color = self.value[:hex_color]
+
+      def percent_done = self.value[:percent_done]
+
+      def position = self.value[:position]
+
+      def priority = self.value[:priority]
+
+      def project_id = self.value[:project_id]
+
+      def bucket_id = self.value[:bucket_id]
+
+      def cover_image_attachment_id = self.value[:cover_image_attachment_id]
+
+      def comment_count = self.value[:comment_count]
+
+      def time_entries_count = self.value[:time_entries_count]
+
+      def repeat_after = self.value[:repeat_after]
+
+      def repeat_mode = self.value[:repeat_mode]
+
+      def is_favorite = self.value[:is_favorite]
+
+      def is_unread = self.value[:is_unread]
+
+      def deleted_at = self.value[:deleted_at]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def reactions = self.value[:reactions]
+
+      def related_tasks = self.value[:related_tasks]
+
+      def created_by = self.nested(User, self.value[:created_by])
+
+      def subscription = self.nested(Subscription, self.value[:subscription])
+
+      def assignees = self.nested_list(User, self.value[:assignees])
+
+      def attachments = self.nested_list(TaskAttachment, self.value[:attachments])
+
+      def buckets = self.nested_list(Bucket, self.value[:buckets])
+
+      def comments = self.nested_list(TaskComment, self.value[:comments])
+
+      def labels = self.nested_list(Label, self.value[:labels])
+
+      def reminders = self.nested_list(TaskReminder, self.value[:reminders])
+
+      def done? = self.done == true
+
+      def favorite? = self.is_favorite == true
+    end
+
+    class Task < Representation
+      include TaskFields
+
+      def task_comments(**parameters) = Collection.for(@resource, "comments", TaskCommentPage, **parameters)
+
+      def task_attachments(**parameters) = Collection.for(@resource, "attachments", TaskAttachmentPage, **parameters)
+
+      def task_labels(**parameters) = Collection.for(@resource, "labels", TaskLabelPage, **parameters)
+
+      def task_assignees(**parameters) = Collection.for(@resource, "assignees", TaskAssigneePage, **parameters)
+
+      def task_time_entries(**parameters) = Collection.for(@resource, "time-entries", TaskTimeEntryPage, **parameters)
+
+      def comment(id) = TaskComment.new(@resource.with(path: "comments/" + Vikunja.escape(id)))
+
+      def attachment(id) = TaskAttachment.new(@resource.with(path: "attachments/" + Vikunja.escape(id)))
+
+      def download_attachment(id) = Download.new(@resource.with(path: "attachments/" + Vikunja.escape(id)))
+
+      def create_comment(payload) = self.submit(TaskComment, @resource.with(path: "comments"), payload, identify: true)
+
+      def upload_attachments(parts) = self.upload(AttachmentUploadResult, @resource.with(path: "attachments"), parts)
+
+      def add_label(label) = self.submit(LabelTask, @resource.with(path: "labels"), {label_id: label})
+
+      def replace_labels(labels) = self.submit(LabelTaskBulk, @resource.with(path: "labels/bulk"), {labels: labels}, method: :put)
+
+      def remove_label(label) = self.discard(@resource.with(path: "labels/" + Vikunja.escape(label)))
+
+      def add_assignee(user) = self.submit(TaskAssginee, @resource.with(path: "assignees"), {user_id: user})
+
+      def replace_assignees(assignees) = self.submit(BulkAssignees, @resource.with(path: "assignees/bulk"), {assignees: assignees}, method: :put)
+
+      def remove_assignee(user) = self.discard(@resource.with(path: "assignees/" + Vikunja.escape(user)))
+
+      def add_relation(payload) = self.submit(TaskRelation, @resource.with(path: "relations"), payload)
+
+      def remove_relation(kind, other) = self.discard(@resource.with(path: "relations/" + Vikunja.escape(kind) + "/" + Vikunja.escape(other)))
+
+      def reposition(payload) = self.submit(TaskPosition, @resource.with(path: "position"), payload, method: :put)
+
+      def mark_read = self.submit(Message, @resource.with(path: "read"), nil, method: :put)
+
+      def duplicate = self.submit(TaskDuplicate, @resource.with(path: "duplicate"))
+
+      def update(payload) = self.submit(Task, @resource, payload, method: :put)
+
+      def patch(payload) = self.merge_patch(Task, @resource, payload)
+
+      def delete = self.discard(@resource)
+    end
+
+    class TaskReadOneBody < Representation
+      include TaskFields
+
+      def max_permission = self.value[:max_permission]
+    end
+
+    class TaskReminder < Representation
+      def reminder = self.value[:reminder]
+
+      def relative_period = self.value[:relative_period]
+
+      def relative_to = self.value[:relative_to]
+    end
+
+    class TaskRelation < Representation
+      def task_id = self.value[:task_id]
+
+      def other_task_id = self.value[:other_task_id]
+
+      def relation_kind = self.value[:relation_kind]
+
+      def created = self.value[:created]
+
+      def created_by = self.nested(User, self.value[:created_by])
+    end
+
+    class TaskPosition < Representation
+      def task_id = self.value[:task_id]
+
+      def project_view_id = self.value[:project_view_id]
+
+      def position = self.value[:position]
+    end
+
+    class TaskDuplicate < Representation
+      def duplicated_task = self.nested(Task, self.value[:duplicated_task])
+    end
+
+    class BulkTaskCreation < Representation
+      def tasks = self.nested_list(Task, self.value[:tasks])
+    end
+
+    class BulkTask < Representation
+      def task_ids = Array(self.value[:task_ids])
+
+      def fields = Array(self.value[:fields])
+
+      def values = self.nested(Task, self.value[:values])
+
+      def tasks = self.nested_list(Task, self.value[:tasks])
+    end
+
+    class TaskPage < Page
+      MEMBER = Task
+    end
+
+    class ProjectTaskPage < TaskPage
+      def member_path(record) = "../../../tasks/" + Vikunja.escape(record[:id])
+    end
+
+    class ProjectViewTaskPage < TaskPage
+      def member_path(record) = "../../../../../tasks/" + Vikunja.escape(record[:id])
+    end
+
+    module Tasks
+      def tasks(**parameters) = Collection.for(self, "tasks", TaskPage, **parameters)
+
+      def task(id) = Task.new(self.with(path: "tasks/" + Vikunja.escape(id)))
+
+      def update_tasks(payload) = self.submit(BulkTask, self.with(path: "tasks/bulk"), payload, method: :put)
+    end
+  end
+end

data/lib/async/vikunja/teams.rb

@@ -0,0 +1,85 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class Team < 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 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])
+
+      def max_permission = self.value[:max_permission]
+
+      def public? = self.is_public == true
+
+      def add_member(payload) = self.submit(TeamMember, @resource.with(path: "members"), payload)
+
+      def remove_member(user) = self.discard(@resource.with(path: "members/" + Vikunja.escape(user)))
+
+      def toggle_admin(user) = self.submit(TeamMember, @resource.with(path: "members/" + Vikunja.escape(user) + "/admin"), nil)
+
+      def update(payload) = self.submit(Team, @resource, payload, method: :put)
+
+      def patch(payload) = self.merge_patch(Team, @resource, payload)
+
+      def delete = self.discard(@resource)
+    end
+
+    class TeamMember < Representation
+      def id = self.value[:id]
+
+      def username = self.value[:username]
+
+      def admin = self.value[:admin]
+
+      def created = self.value[:created]
+
+      def admin? = self.admin == true
+    end
+
+    class TeamUser < Representation
+      def id = self.value[:id]
+
+      def username = self.value[:username]
+
+      def name = self.value[:name]
+
+      def email = self.value[:email]
+
+      def admin = self.value[:admin]
+
+      def bot_owner_id = self.value[:bot_owner_id]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def admin? = self.admin == true
+    end
+
+    class TeamPage < Page
+      MEMBER = Team
+    end
+
+    module Teams
+      def teams(**parameters) = Collection.for(self, "teams", TeamPage, **parameters)
+
+      def team(id) = Team.new(self.with(path: "teams/" + Vikunja.escape(id)))
+
+      def create_team(payload) = self.submit(Team, self.with(path: "teams"), payload, identify: true)
+    end
+  end
+end

data/lib/async/vikunja/time_entries.rb

@@ -0,0 +1,55 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class TimeEntry < Representation
+      def id = self.value[:id]
+
+      def comment = self.value[:comment]
+
+      def start_time = self.value[:start_time]
+
+      def end_time = self.value[:end_time]
+
+      def project_id = self.value[:project_id]
+
+      def task_id = self.value[:task_id]
+
+      def user_id = self.value[:user_id]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def max_permission = self.value[:max_permission]
+
+      def update(payload) = self.submit(TimeEntry, @resource, payload, method: :put)
+
+      def patch(payload) = self.merge_patch(TimeEntry, @resource, payload)
+
+      def delete = self.discard(@resource)
+    end
+
+    class TimeEntryPage < Page
+      MEMBER = TimeEntry
+    end
+
+    class ProjectTimeEntryPage < TimeEntryPage
+      def member_path(record) = "../../../time-entries/" + Vikunja.escape(record[:id])
+    end
+
+    class TaskTimeEntryPage < TimeEntryPage
+      def member_path(record) = "../../../time-entries/" + Vikunja.escape(record[:id])
+    end
+
+    module TimeEntries
+      def time_entries(**parameters) = Collection.for(self, "time-entries", TimeEntryPage, **parameters)
+
+      def time_entry(id) = TimeEntry.new(self.with(path: "time-entries/" + Vikunja.escape(id)))
+
+      def create_time_entry(payload) = self.submit(TimeEntry, self.with(path: "time-entries"), payload, identify: true)
+
+      def stop_timer = self.submit(TimeEntry, self.with(path: "time-entries/timer/stop"), nil)
+    end
+  end
+end

data/lib/async/vikunja/tokens.rb

@@ -0,0 +1,59 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class APIToken < Representation
+      def id = self.value[:id]
+
+      def title = self.value[:title]
+
+      def owner_id = self.value[:owner_id]
+
+      def permissions = self.value[:permissions]
+
+      def expires_at = self.value[:expires_at]
+
+      def created = self.value[:created]
+
+      def token = self.value[:token]
+
+      def delete = self.discard(@resource)
+    end
+
+    class Token < Representation
+      def id = self.value[:id]
+
+      def created = self.value[:created]
+
+      def token = self.value[:token]
+
+      def delete = self.discard(@resource)
+    end
+
+    class APITokenPage < Page
+      MEMBER = APIToken
+    end
+
+    class CaldavTokenPage < Page
+      MEMBER = Token
+    end
+
+    module Tokens
+      def tokens(**parameters) = Collection.for(self, "tokens", APITokenPage, **parameters)
+
+      def create_token(payload) = self.submit(APIToken, self.with(path: "tokens"), payload, identify: true)
+
+      def delete_token(id) = self.discard(self.with(path: "tokens/" + Vikunja.escape(id)))
+
+      def test_token = Message.new(self.with(path: "token/test"))
+
+      def check_token = self.submit(Message, self.with(path: "token/test"), nil)
+
+      def caldav_tokens(**parameters) = Collection.for(self, "user/settings/token/caldav", CaldavTokenPage, **parameters)
+
+      def create_caldav_token = self.submit(Token, self.with(path: "user/settings/token/caldav"), nil, identify: true)
+
+      def delete_caldav_token(id) = self.discard(self.with(path: "user/settings/token/caldav/" + Vikunja.escape(id)))
+    end
+  end
+end

data/lib/async/vikunja/users.rb

@@ -0,0 +1,107 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class User < Representation
+      def id = self.value[:id]
+
+      def username = self.value[:username]
+
+      def name = self.value[:name]
+
+      def email = self.value[:email]
+
+      def bot_owner_id = self.value[:bot_owner_id]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+    end
+
+    class UserInfoBody < Representation
+      def id = self.value[:id]
+
+      def username = self.value[:username]
+
+      def name = self.value[:name]
+
+      def email = self.value[:email]
+
+      def bot_owner_id = self.value[:bot_owner_id]
+
+      def auth_provider = self.value[:auth_provider]
+
+      def is_admin = self.value[:is_admin]
+
+      def is_local_user = self.value[:is_local_user]
+
+      def deletion_scheduled_at = self.value[:deletion_scheduled_at]
+
+      def pending_email = self.value[:pending_email]
+
+      def settings = self.nested(UserGeneralSettings, self.value[:settings])
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def admin? = self.is_admin == true
+
+      def local_user? = self.is_local_user == true
+    end
+
+    class UserActionMessageBody < Representation
+      def message = self.value[:message]
+    end
+
+    class UserExportStatus < Representation
+      def id = self.value[:id]
+
+      def created = self.value[:created]
+
+      def expires = self.value[:expires]
+
+      def size = self.value[:size]
+    end
+
+    class UserPage < Page
+      MEMBER = User
+    end
+
+    class UserSearchPage < Page
+      MEMBER = User
+
+      def member_resource(record) = @resource
+    end
+
+    module Users
+      def user = UserInfoBody.new(self.with(path: "user"))
+
+      def users(query) = UserSearchPage.new(self.with(path: "users", parameters: {q: query}))
+
+      def avatar(username, **parameters) = Download.new(self.with(path: "avatar/" + Vikunja.escape(username), parameters: parameters))
+
+      def timezones = Representation.new(self.with(path: "user/timezones"))
+
+      def change_password(old_password:, new_password:) = self.submit(UserActionMessageBody, self.with(path: "user/password"), {old_password: old_password, new_password: new_password})
+
+      def update_email(new_email:, password:) = self.submit(UserActionMessageBody, self.with(path: "user/settings/email"), {new_email: new_email, password: password}, method: :put)
+
+      def cancel_email_update = self.submit(UserActionMessageBody, self.with(path: "user/settings/email"), nil, method: :delete)
+
+      def resend_email_confirmation = self.submit(UserActionMessageBody, self.with(path: "user/settings/email/resend"), nil)
+
+      def export_status = UserExportStatus.new(self.with(path: "user/export"))
+
+      def request_export(password:) = self.submit(Message, self.with(path: "user/export/request"), {password: password})
+
+      def download_export(password:) = self.submit(Download, self.with(path: "user/export/download"), {password: password})
+
+      def request_deletion(password:) = self.discard(self.with(path: "user/deletion/request"), {password: password}, method: :post)
+
+      def confirm_deletion(token:) = self.discard(self.with(path: "user/deletion/confirm"), {token: token}, method: :post)
+
+      def cancel_deletion(password:) = self.discard(self.with(path: "user/deletion/cancel"), {password: password}, method: :post)
+    end
+  end
+end

data/lib/async/vikunja/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2026, by Nathan Kidd.
+
+module Async
+  module Vikunja
+    VERSION = "1.0.0"
+  end
+end

data/lib/async/vikunja/views.rb

@@ -0,0 +1,75 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class ProjectView < Representation
+      def id = self.value[:id]
+
+      def title = self.value[:title]
+
+      def view_kind = self.value[:view_kind]
+
+      def position = self.value[:position]
+
+      def project_id = self.value[:project_id]
+
+      def bucket_configuration_mode = self.value[:bucket_configuration_mode]
+
+      def default_bucket_id = self.value[:default_bucket_id]
+
+      def done_bucket_id = self.value[:done_bucket_id]
+
+      def max_permission = self.value[:max_permission]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def filter = self.nested(TaskCollection, self.value[:filter])
+
+      def bucket_configuration = self.nested_list(ProjectViewBucketConfiguration, self.value[:bucket_configuration])
+
+      def buckets(**parameters) = Collection.for(@resource, "buckets", BucketPage, **parameters)
+
+      def tasks(**parameters) = Collection.for(@resource, "tasks", ProjectViewTaskPage, **parameters)
+
+      def buckets_with_tasks(**parameters) = BucketsWithTasks.new(@resource.with(path: "buckets/tasks", parameters: parameters))
+
+      def create_bucket(payload) = self.submit(Bucket, @resource.with(path: "buckets"), payload, identify: true)
+
+      def update_bucket(bucket, payload) = self.submit(Bucket, @resource.with(path: "buckets/" + Vikunja.escape(bucket)), payload, method: :put)
+
+      def remove_bucket(bucket) = self.discard(@resource.with(path: "buckets/" + Vikunja.escape(bucket)))
+
+      def move_task(bucket, payload) = self.submit(TaskBucket, @resource.with(path: "buckets/" + Vikunja.escape(bucket) + "/tasks"), payload, method: :put)
+
+      def update(payload) = self.submit(ProjectView, @resource, payload, method: :put)
+
+      def patch(payload) = self.merge_patch(ProjectView, @resource, payload)
+
+      def delete = self.discard(@resource)
+    end
+
+    class ProjectViewBucketConfiguration < Representation
+      def title = self.value[:title]
+
+      def filter = self.nested(TaskCollection, self.value[:filter])
+    end
+
+    class TaskCollection < Representation
+      def filter = self.value[:filter]
+
+      def filter_include_nulls = self.value[:filter_include_nulls]
+
+      def s = self.value[:s]
+
+      def sort_by = self.value[:sort_by]
+
+      def order_by = self.value[:order_by]
+    end
+
+    class ProjectViewPage < Page
+      MEMBER = ProjectView
+    end
+  end
+end

data/lib/async/vikunja/webhooks.rb

@@ -0,0 +1,55 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class Webhook < Representation
+      def id = self.value[:id]
+
+      def target_url = self.value[:target_url]
+
+      def events = self.value[:events]
+
+      def project_id = self.value[:project_id]
+
+      def user_id = self.value[:user_id]
+
+      def secret = self.value[:secret]
+
+      def basic_auth_user = self.value[:basic_auth_user]
+
+      def basic_auth_password = self.value[:basic_auth_password]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def created_by = self.nested(User, self.value[:created_by])
+
+      def update(payload) = self.submit(Webhook, @resource, payload, method: :put)
+
+      def delete = self.discard(@resource)
+    end
+
+    class ProjectWebhookPage < Page
+      MEMBER = Webhook
+    end
+
+    class UserWebhookPage < Page
+      MEMBER = Webhook
+    end
+
+    module Webhooks
+      def webhook_events = Representation.new(self.with(path: "webhooks/events"))
+
+      def webhooks(**parameters) = Collection.for(self, "user/settings/webhooks", UserWebhookPage, **parameters)
+
+      def create_webhook(payload) = self.submit(Webhook, self.with(path: "user/settings/webhooks"), payload, identify: true)
+
+      def update_webhook(webhook, payload) = self.submit(Webhook, self.with(path: "user/settings/webhooks/" + Vikunja.escape(webhook)), payload, method: :put)
+
+      def remove_webhook(webhook) = self.discard(self.with(path: "user/settings/webhooks/" + Vikunja.escape(webhook)))
+
+      def user_webhook_events = Representation.new(self.with(path: "user/settings/webhooks/events"))
+    end
+  end
+end