async-vikunja 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8d1420cbccb11b7d3c779e16482c9e2e7181d924eb148f15abb8d663d2776047
+  data.tar.gz: 409c2841ca1b637ff139b48ff0cadd35ab27b29c1fa2727847a00dcf0a97b691
+SHA512:
+  metadata.gz: a6332a41f269ff1df2d09747524b04934eec02165b530b4d9b189a08e977442523b62aef0e500de019f0d3c0f4a761841b8f460bb9ab98c7e5aee1012f40df2d
+  data.tar.gz: 1f75d82c9811c6f9518c2999808850e97a146f524b16653a10fcc95874c561e5c9a4a525490a9c33c03f2bb16471bc773d996d2ce33b4662dc861d7bdc2430ec

data/README.md

@@ -0,0 +1,362 @@
+# async-vikunja
+
+```ruby
+gem "async-vikunja"
+```
+
+```ruby
+require "async/vikunja"
+
+Async::Vikunja::Client.open("https://vikunja.example.com/api/v2/") do |client|
+  vikunja = client.authenticated(ENV.fetch("VIKUNJA_TOKEN"))
+
+  vikunja.info.version
+  vikunja.user.username
+  vikunja.test_token.message
+end
+```
+
+```ruby
+Async::Vikunja::Client.open do |client|
+  vikunja = client.authenticated(ENV.fetch("VIKUNJA_TOKEN"))
+end
+```
+
+```ruby
+jwt = Async::Vikunja::Client.open(url) do |client|
+  client.login({username: "tester", password: "secret", long_token: true}).token
+end
+```
+
+```ruby
+vikunja.projects.map(&:title)
+vikunja.projects(q: "inbox").first.id
+vikunja.projects(is_archived: true).count
+
+vikunja.projects.each_page(per_page: 25) do |page|
+  page.page
+  page.total
+  page.total_pages
+  page.items.size
+  page.metadata["content-type"]
+
+  page.each{|project| project.title}
+end
+
+vikunja.projects.take(2).map(&:title)
+```
+
+```ruby
+project = vikunja.create_project({title: "Inbox", hex_color: "4287f5"})
+
+project.id
+project.identifier
+project.owner.username
+project.views.map(&:title)
+
+vikunja.project(project.id).title
+vikunja.project(project.id).update({id: project.id, title: "Renamed"})
+vikunja.project(project.id).patch({title: "Patched"})
+vikunja.project(project.id).delete
+```
+
+```ruby
+project = vikunja.project(1)
+
+task = project.create_task({title: "write the client", priority: 3})
+
+project.tasks(filter: "done = false", sort_by: ["due_date"]).map(&:title)
+project.task_by_index(1).title
+
+vikunja.task(task.id).title
+vikunja.task(task.id).update({id: task.id, title: "write the client", done: true})
+vikunja.task(task.id).patch({percent_done: 0.5})
+vikunja.task(task.id).mark_read
+vikunja.task(task.id).delete
+```
+
+```ruby
+vikunja.tasks(filter: "due_date > now", expand: "subtasks").each do |task|
+  task.title
+  task.due_date
+  task.project_id
+  task.done?
+  task.labels.map(&:title)
+  task.assignees.map(&:username)
+end
+```
+
+```ruby
+task = vikunja.task(7)
+
+comment = task.create_comment({comment: "shipped"})
+
+comment.author.username
+task.task_comments(order_by: "desc").map(&:comment)
+task.comment(comment.id).update({id: comment.id, comment: "shipped twice"})
+task.comment(comment.id).delete
+```
+
+```ruby
+label = vikunja.create_label({title: "urgent", hex_color: "e8384f"})
+
+vikunja.task(7).add_label(label.id)
+vikunja.task(7).task_labels.map(&:title)
+vikunja.task(7).replace_labels([{id: label.id}])
+vikunja.task(7).remove_label(label.id)
+
+vikunja.labels.map(&:title)
+vikunja.label(label.id).patch({title: "later"})
+vikunja.label(label.id).delete
+```
+
+```ruby
+vikunja.task(7).add_assignee(2)
+vikunja.task(7).task_assignees.map(&:username)
+vikunja.task(7).replace_assignees([{id: 2}, {id: 3}])
+vikunja.task(7).remove_assignee(2)
+```
+
+```ruby
+vikunja.task(7).add_relation({other_task_id: 8, relation_kind: "subtask"})
+vikunja.task(7).remove_relation("subtask", 8)
+vikunja.task(7).duplicate.duplicated_task.title
+vikunja.task(7).reposition({project_view_id: 4, position: 2.5})
+```
+
+```ruby
+view = vikunja.project(1).view(4)
+
+view.view_kind
+view.tasks.map(&:title)
+view.buckets.map(&:title)
+view.buckets_with_tasks.items.flat_map{|bucket| bucket.tasks.map(&:title)}
+
+bucket = view.create_bucket({title: "Doing", limit: 5})
+
+view.move_task(bucket.id, {task_id: 7, project_view_id: view.id})
+view.update_bucket(bucket.id, {id: bucket.id, title: "In progress"})
+view.remove_bucket(bucket.id)
+```
+
+```ruby
+entry = vikunja.create_time_entry({task_id: 7, start_time: Time.now.utc.iso8601, comment: "pairing"})
+
+vikunja.time_entries(filter: "start_time > now/w").map(&:comment)
+vikunja.task(7).task_time_entries.map(&:id)
+vikunja.project(1).time_entries.sum{|each| each.id}
+vikunja.stop_timer.end_time
+vikunja.time_entry(entry.id).delete
+```
+
+```ruby
+team = vikunja.create_team({name: "platform", is_public: false})
+
+team.add_member({username: "tester"})
+team.members.map(&:username)
+team.toggle_admin("tester")
+team.remove_member("tester")
+
+vikunja.project(1).add_team({team_id: team.id, permission: 1})
+vikunja.project(1).teams.map(&:name)
+vikunja.project(1).remove_team(team.id)
+```
+
+```ruby
+share = vikunja.project(1).create_share({permission: 0, name: "read only"})
+
+vikunja.project(1).shares.map(&:hash)
+vikunja.authenticate_share(share.hash, {password: "secret"}).token
+vikunja.project(1).remove_share(share.id)
+
+vikunja.project(1).add_user({username: "tester", permission: 1})
+vikunja.project(1).users.map(&:username)
+vikunja.project(1).search_users("test").map(&:username)
+vikunja.project(1).remove_user("tester")
+```
+
+```ruby
+result = vikunja.task(7).upload_attachments([
+  {name: "files", filename: "notes.txt", content_type: "text/plain", body: File.read("notes.txt")},
+])
+
+result.success.map{|attachment| attachment.file.name}
+result.errors.map(&:message)
+
+vikunja.task(7).task_attachments.map{|attachment| attachment.file.size}
+vikunja.task(7).download_attachment(3).bytes
+vikunja.task(7).attachment(3).delete
+```
+
+```ruby
+vikunja.project(1).upload_background({name: "background", filename: "wall.jpg", content_type: "image/jpeg", body: File.read("wall.jpg")})
+
+background = vikunja.project(1).background
+
+background.media_type
+background.bytes
+
+vikunja.project(1).remove_background
+```
+
+```ruby
+filter = vikunja.create_filter({title: "overdue", filters: {filter: "due_date < now && done = false"}})
+
+vikunja.filter(filter.id).filters.filter
+vikunja.filter(filter.id).patch({title: "late"})
+vikunja.filter(filter.id).delete
+```
+
+```ruby
+vikunja.notifications.map(&:name)
+vikunja.update_notification(3, {id: 3, read: true})
+vikunja.mark_notifications_read.message
+vikunja.clear_notifications
+
+vikunja.subscribe("projects", 1).entity
+vikunja.unsubscribe("projects", 1)
+
+vikunja.add_reaction("tasks", 7, {value: "👍"})
+vikunja.reactions("tasks", 7).value
+vikunja.remove_reaction("tasks", 7, {value: "👍"})
+```
+
+```ruby
+webhook = vikunja.project(1).create_webhook({target_url: "https://example.com/hook", events: ["task.created"]})
+
+vikunja.webhook_events.value
+vikunja.project(1).webhooks.map(&:target_url)
+vikunja.project(1).update_webhook(webhook.id, {id: webhook.id, events: ["task.updated"]})
+vikunja.project(1).remove_webhook(webhook.id)
+```
+
+```ruby
+token = vikunja.create_token({
+  title: "integration",
+  expires_at: (Time.now.utc + 86400).iso8601,
+  permissions: {projects: ["read_all", "create"]},
+})
+
+token.token
+vikunja.tokens.map(&:title)
+vikunja.delete_token(token.id)
+
+vikunja.caldav_tokens.map(&:created)
+vikunja.create_caldav_token.token
+```
+
+```ruby
+vikunja.user.settings.timezone
+vikunja.update_settings({name: "Tester", week_start: 1, timezone: "Europe/London"}).message
+vikunja.upload_avatar({name: "avatar", filename: "me.png", content_type: "image/png", body: File.read("me.png")})
+vikunja.avatar("tester", size: 64).bytes
+vikunja.set_avatar_provider(avatar_provider: "initials")
+
+vikunja.enroll_totp.url
+vikunja.enable_totp(passcode: "123456")
+vikunja.totp_qrcode.bytes
+vikunja.disable_totp(password: "secret")
+
+vikunja.sessions.map(&:device_info)
+vikunja.delete_session("abc")
+```
+
+```ruby
+vikunja.users("test").map(&:username)
+vikunja.timezones.value
+vikunja.health.status
+vikunja.routes.value
+vikunja.notifications_atom.bytes
+```
+
+```ruby
+bot = vikunja.create_bot({username: "ci-bot", name: "CI"})
+
+vikunja.bots.map(&:username)
+vikunja.bot(bot.id).patch({name: "CI runner"})
+vikunja.bot(bot.id).delete
+```
+
+```ruby
+overview = vikunja.admin_overview
+
+overview.users
+overview.projects
+overview.shares.link_shares
+overview.license.licensed
+
+vikunja.admin_users(q: "test").map(&:username)
+vikunja.create_admin_user({username: "new", email: "new@example.com", password: "secret"})
+vikunja.set_admin(1, {is_admin: true})
+vikunja.set_user_status(1, {status: 0})
+vikunja.set_user_password(1, {new_password: "another"})
+vikunja.send_password_reset_email(1)
+vikunja.remove_admin_user(1, mode: "soft")
+
+vikunja.admin_projects(q: "inbox").map(&:title)
+vikunja.set_project_owner(1, {owner_id: 2})
+```
+
+```ruby
+case vikunja.project(1)
+in {title: String => title, owner: {username: String => owner}}
+  [title, owner]
+end
+
+case vikunja.task(7)
+in {done: true, title:}
+  "#{title} is done"
+in {done: false, due_date: String => due}
+  "#{title} is due #{due}"
+end
+```
+
+```ruby
+begin
+  vikunja.create_project({})
+rescue Async::Vikunja::Failure => error
+  error.status
+  error.code
+  error.title
+  error.detail
+  error.errors.map{|each| each[:message]}
+  error.retry_after
+end
+
+begin
+  vikunja.project(404).title
+rescue Async::REST::ResponseError => error
+  error.response.status
+rescue ::JSON::ParserError => error
+  error.message
+end
+```
+
+```ruby
+project = vikunja.project(1)
+
+project.title
+project = vikunja.project(1) unless project.cacheable?
+project.title
+```
+
+```ruby
+token = vikunja.create_token({title: "ci"})
+
+token.inspect
+token.value[:token]
+```
+
+```ruby
+Async::Vikunja::Client.open(url) do |client|
+  vikunja = client.authenticated(ENV.fetch("VIKUNJA_TOKEN"))
+
+  tasks = vikunja.projects.map do |project|
+    Async do
+      project.tasks.count
+    end
+  end
+
+  tasks.sum(&:wait)
+end
+```

data/lib/async/vikunja/admin.rb

@@ -0,0 +1,97 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class Info < Representation
+      def instance_id = self.value[:instance_id]
+
+      def licensed = self.value[:licensed]
+
+      def last_check_failed = self.value[:last_check_failed]
+
+      def features = self.value[:features]
+
+      def max_users = self.value[:max_users]
+
+      def expires_at = self.value[:expires_at]
+
+      def validated_at = self.value[:validated_at]
+    end
+
+    class ShareCounts < Representation
+      def link_shares = self.value[:link_shares]
+
+      def team_shares = self.value[:team_shares]
+
+      def user_shares = self.value[:user_shares]
+    end
+
+    class Overview < Representation
+      def projects = self.value[:projects]
+
+      def tasks = self.value[:tasks]
+
+      def teams = self.value[:teams]
+
+      def users = self.value[:users]
+
+      def license = self.nested(Info, self.value[:license])
+
+      def shares = self.nested(ShareCounts, self.value[:shares])
+    end
+
+    class AdminUser < Representation
+      def id = self.value[:id]
+
+      def username = self.value[:username]
+
+      def name = self.value[:name]
+
+      def email = self.value[:email]
+
+      def is_admin = self.value[:is_admin]
+
+      def status = self.value[:status]
+
+      def issuer = self.value[:issuer]
+
+      def subject = self.value[:subject]
+
+      def auth_provider = self.value[:auth_provider]
+
+      def bot_owner_id = self.value[:bot_owner_id]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def admin? = self.is_admin == true
+    end
+
+    class AdminUserPage < Page
+      MEMBER = AdminUser
+    end
+
+    module Admin
+      def admin_overview = Overview.new(self.with(path: "admin/overview"))
+
+      def admin_projects(**parameters) = Collection.for(self, "admin/projects", AdminProjectPage, **parameters)
+
+      def set_project_owner(id, payload) = self.submit(Project, self.with(path: "admin/projects/" + Vikunja.escape(id) + "/owner"), payload, method: :patch)
+
+      def admin_users(**parameters) = Collection.for(self, "admin/users", AdminUserPage, **parameters)
+
+      def create_admin_user(payload) = self.submit(AdminUser, self.with(path: "admin/users"), payload, identify: true)
+
+      def remove_admin_user(id, **parameters) = self.discard(self.with(path: "admin/users/" + Vikunja.escape(id), parameters: parameters))
+
+      def set_admin(id, payload) = self.submit(AdminUser, self.with(path: "admin/users/" + Vikunja.escape(id) + "/admin"), payload, method: :patch)
+
+      def set_user_password(id, payload) = self.submit(AdminUser, self.with(path: "admin/users/" + Vikunja.escape(id) + "/password"), payload, method: :patch)
+
+      def set_user_status(id, payload) = self.submit(AdminUser, self.with(path: "admin/users/" + Vikunja.escape(id) + "/status"), payload, method: :patch)
+
+      def send_password_reset_email(id) = self.submit(Message, self.with(path: "admin/users/" + Vikunja.escape(id) + "/password-reset-email"), nil)
+    end
+  end
+end

data/lib/async/vikunja/assignees.rb

@@ -0,0 +1,20 @@
+require_relative "page"
+require_relative "users"
+
+module Async
+  module Vikunja
+    class TaskAssginee < Representation
+      def user_id = self.value[:user_id]
+
+      def created = self.value[:created]
+    end
+
+    class BulkAssignees < Representation
+      def assignees = self.nested_list(User, self.value[:assignees])
+    end
+
+    class TaskAssigneePage < Page
+      MEMBER = User
+    end
+  end
+end

data/lib/async/vikunja/attachments.rb

@@ -0,0 +1,51 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class File < Representation
+      def id = self.value[:id]
+
+      def name = self.value[:name]
+
+      def mime = self.value[:mime]
+
+      def size = self.value[:size]
+
+      def created = self.value[:created]
+    end
+
+    class TaskAttachment < Representation
+      def id = self.value[:id]
+
+      def task_id = self.value[:task_id]
+
+      def created = self.value[:created]
+
+      def created_by = self.nested(User, self.value[:created_by])
+
+      def file = self.nested(File, self.value[:file])
+
+      def download = Download.new(@resource)
+
+      def preview(size) = Download.new(@resource.with(parameters: {preview_size: size}))
+
+      def delete = self.discard(@resource)
+    end
+
+    class AttachmentUploadError < Representation
+      def code = self.value[:code]
+
+      def message = self.value[:message]
+    end
+
+    class AttachmentUploadResult < Representation
+      def success = self.nested_list(TaskAttachment, self.value[:success])
+
+      def errors = self.nested_list(AttachmentUploadError, self.value[:errors])
+    end
+
+    class TaskAttachmentPage < Page
+      MEMBER = TaskAttachment
+    end
+  end
+end

data/lib/async/vikunja/auth.rb

@@ -0,0 +1,52 @@
+require_relative "page"
+require "async/rest/wrapper/form"
+
+module Async
+  module Vikunja
+    class AuthorizeResponse < Representation
+      def code = self.value[:code]
+
+      def redirect_uri = self.value[:redirect_uri]
+
+      def state = self.value[:state]
+    end
+
+    class TokenResponse < Representation
+      WRAPPER = ::Async::REST::Wrapper::Form.new
+
+      def access_token = self.value[:access_token]
+
+      def expires_in = self.value[:expires_in]
+
+      def refresh_token = self.value[:refresh_token]
+
+      def token_type = self.value[:token_type]
+    end
+
+    class AuthToken < Representation
+      def self.schema = "AuthTokenBodyBody"
+
+      def token = self.value[:token]
+    end
+
+    module Auth
+      def login(payload) = self.submit(AuthToken, self.with(path: "login"), payload)
+
+      def logout = self.submit(Representation, self.with(path: "logout"), nil)
+
+      def renew_token = self.submit(AuthToken, self.with(path: "user/token"), nil)
+
+      def refresh_token = self.submit(AuthToken, self.with(path: "user/token/refresh"), nil)
+
+      def confirm_email(payload) = self.submit(Message, self.with(path: "user/confirm"), payload)
+
+      def reset_password(payload) = self.submit(Message, self.with(path: "user/password/reset"), payload)
+
+      def request_password_token(payload) = self.submit(Message, self.with(path: "user/password/token"), payload)
+
+      def oauth_authorize(payload) = self.submit(AuthorizeResponse, self.with(path: "oauth/authorize"), payload)
+
+      def oauth_token(payload) = self.submit(TokenResponse, self.with(path: "oauth/token"), payload)
+    end
+  end
+end

data/lib/async/vikunja/bots.rb

@@ -0,0 +1,43 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class BotUser < Representation
+      def id = self.value[:id]
+
+      def bot_owner_id = self.value[:bot_owner_id]
+
+      def email = self.value[:email]
+
+      def name = self.value[:name]
+
+      def status = self.value[:status]
+
+      def username = self.value[:username]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def max_permission = self.value[:max_permission]
+
+      def update(payload) = self.submit(BotUser, @resource, payload, method: :put)
+
+      def patch(payload) = self.merge_patch(BotUser, @resource, payload)
+
+      def delete = self.discard(@resource)
+    end
+
+    class BotUserPage < Page
+      MEMBER = BotUser
+    end
+
+    module Bots
+      def bots(**parameters) = Collection.for(self, "user/bots", BotUserPage, **parameters)
+
+      def bot(id) = BotUser.new(self.with(path: "user/bots/" + Vikunja.escape(id)))
+
+      def create_bot(payload) = self.submit(BotUser, self.with(path: "user/bots"), payload, identify: true)
+    end
+  end
+end

data/lib/async/vikunja/buckets.rb

@@ -0,0 +1,51 @@
+require_relative "page"
+
+module Async
+  module Vikunja
+    class Bucket < Representation
+      def id = self.value[:id]
+
+      def title = self.value[:title]
+
+      def limit = self.value[:limit]
+
+      def position = self.value[:position]
+
+      def count = self.value[:count]
+
+      def project_view_id = self.value[:project_view_id]
+
+      def created = self.value[:created]
+
+      def updated = self.value[:updated]
+
+      def created_by = self.nested(User, self.value[:created_by])
+
+      def tasks = self.nested_list(Task, self.value[:tasks])
+    end
+
+    class TaskBucket < Representation
+      def task_id = self.value[:task_id]
+
+      def bucket_id = self.value[:bucket_id]
+
+      def project_view_id = self.value[:project_view_id]
+
+      def task = self.nested(Task, self.value[:task])
+
+      def bucket = self.nested(Bucket, self.value[:bucket])
+    end
+
+    class BucketsWithTasks < Representation
+      def self.schema = "BucketsWithTasksBodyBody"
+
+      def total = self.value[:total]
+
+      def items = self.nested_list(Bucket, self.value[:items])
+    end
+
+    class BucketPage < Page
+      MEMBER = Bucket
+    end
+  end
+end