fizzy-api-client 0.1.0

data/lib/fizzy_api_client/resources/cards.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module Cards
+      def cards(page: nil, auto_paginate: false, account_slug: nil, **filters)
+        params = build_card_filters(filters)
+        paginate("/cards", params: params, account_slug: account_slug, auto_paginate: auto_paginate, page: page)
+      end
+
+      def card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.get("/#{slug}/cards/#{card_number}")
+        response.body
+      end
+
+      def create_card(board_id:, title:, description: nil, status: nil, tag_ids: nil,
+                      created_at: nil, last_active_at: nil, image: nil, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        payload = { title: title }
+        payload[:description] = description unless description.nil?
+        payload[:status] = status unless status.nil?
+        payload[:tag_ids] = tag_ids unless tag_ids.nil?
+        payload[:created_at] = created_at unless created_at.nil?
+        payload[:last_active_at] = last_active_at unless last_active_at.nil?
+
+        if image
+          response = create_card_with_image(slug, board_id, payload, image)
+        else
+          response = connection.post("/#{slug}/boards/#{board_id}/cards", body: { card: payload })
+        end
+
+        response = connection.follow_location(response)
+        response.body
+      end
+
+      def update_card(card_number, title: nil, description: nil, status: nil, tag_ids: nil,
+                      last_active_at: nil, image: nil, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        payload = {}
+        payload[:title] = title unless title.nil?
+        payload[:description] = description unless description.nil?
+        payload[:status] = status unless status.nil?
+        payload[:tag_ids] = tag_ids unless tag_ids.nil?
+        payload[:last_active_at] = last_active_at unless last_active_at.nil?
+
+        if image
+          response = update_card_with_image(slug, card_number, payload, image)
+        else
+          response = connection.put("/#{slug}/cards/#{card_number}", body: { card: payload })
+        end
+
+        response.no_content? ? nil : response.body
+      end
+
+      def delete_card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/cards/#{card_number}")
+        response.no_content? ? nil : response.body
+      end
+
+      def close_card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post("/#{slug}/cards/#{card_number}/closure")
+        response.no_content? ? nil : response.body
+      end
+
+      def reopen_card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/cards/#{card_number}/closure")
+        response.no_content? ? nil : response.body
+      end
+
+      def postpone_card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post("/#{slug}/cards/#{card_number}/not_now")
+        response.no_content? ? nil : response.body
+      end
+
+      alias not_now_card postpone_card
+
+      def triage_card(card_number, column_id:, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post("/#{slug}/cards/#{card_number}/triage",
+                                   body: { column_id: column_id })
+        response.no_content? ? nil : response.body
+      end
+
+      def untriage_card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/cards/#{card_number}/triage")
+        response.no_content? ? nil : response.body
+      end
+
+      def toggle_assignment(card_number, assignee_id:, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post("/#{slug}/cards/#{card_number}/assignments",
+                                   body: { assignee_id: assignee_id })
+        response.no_content? ? nil : response.body
+      end
+
+      def toggle_tag(card_number, tag_title:, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post("/#{slug}/cards/#{card_number}/taggings",
+                                   body: { tag_title: tag_title })
+        response.no_content? ? nil : response.body
+      end
+
+      def watch_card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post("/#{slug}/cards/#{card_number}/watch")
+        response.no_content? ? nil : response.body
+      end
+
+      def unwatch_card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/cards/#{card_number}/watch")
+        response.no_content? ? nil : response.body
+      end
+
+      # Makes a card a "golden ticket" (highlighted/pinned card)
+      def gild_card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post("/#{slug}/cards/#{card_number}/goldness")
+        response.no_content? ? nil : response.body
+      end
+
+      # Removes "golden ticket" status from a card
+      def ungild_card(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/cards/#{card_number}/goldness")
+        response.no_content? ? nil : response.body
+      end
+
+      private
+
+      def build_card_filters(filters)
+        params = {}
+
+        # Array filters - encode with []
+        %i[board_ids tag_ids assignee_ids creator_ids closer_ids card_ids terms].each do |key|
+          params[key] = filters[key] if filters[key]
+        end
+
+        # Scalar filters
+        %i[indexed_by sorted_by assignment_status creation closure].each do |key|
+          params[key] = filters[key] if filters[key]
+        end
+
+        params
+      end
+
+      def create_card_with_image(slug, board_id, payload, image)
+        fields = build_multipart_fields("card", payload)
+        files = { "card[image]" => build_file_info(image) }
+
+        connection.post_multipart("/#{slug}/boards/#{board_id}/cards", fields: fields, files: files)
+      end
+
+      def update_card_with_image(slug, card_number, payload, image)
+        fields = build_multipart_fields("card", payload)
+        files = { "card[image]" => build_file_info(image) }
+
+        connection.put_multipart("/#{slug}/cards/#{card_number}", fields: fields, files: files)
+      end
+
+      def build_multipart_fields(prefix, payload)
+        fields = {}
+        payload.each do |key, value|
+          if value.is_a?(Array)
+            value.each_with_index do |v, i|
+              fields["#{prefix}[#{key}][]"] = v.to_s
+            end
+          else
+            fields["#{prefix}[#{key}]"] = value.to_s
+          end
+        end
+        fields
+      end
+
+      def build_file_info(file)
+        if file.is_a?(String)
+          # File path
+          {
+            filename: File.basename(file),
+            content: File.read(file),
+            content_type: guess_content_type(file)
+          }
+        else
+          # IO object
+          {
+            filename: file.respond_to?(:path) ? File.basename(file.path) : "upload",
+            content: file.read,
+            content_type: "application/octet-stream"
+          }
+        end
+      end
+
+      def guess_content_type(path)
+        case File.extname(path).downcase
+        when ".png" then "image/png"
+        when ".jpg", ".jpeg" then "image/jpeg"
+        when ".gif" then "image/gif"
+        when ".webp" then "image/webp"
+        else "application/octet-stream"
+        end
+      end
+    end
+  end
+end

data/lib/fizzy_api_client/resources/columns.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module Columns
+      def columns(board_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.get("/#{slug}/boards/#{board_id}/columns")
+        response.body
+      end
+
+      def column(board_id, column_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.get("/#{slug}/boards/#{board_id}/columns/#{column_id}")
+        response.body
+      end
+
+      # Creates a column on a board.
+      #
+      # @param board_id [String] the board ID
+      # @param name [String] the column name
+      # @param color [Symbol, String, nil] the column color - accepts named colors
+      #   (:blue, :gray, :tan, :yellow, :lime, :aqua, :violet, :purple, :pink)
+      #   or CSS variable strings
+      # @param account_slug [String, nil] optional account slug override
+      # @return [Hash] the created column
+      #
+      # @example Create with named color
+      #   client.create_column(board_id: 'board_1', name: 'Review', color: :lime)
+      #
+      # @example Create with CSS variable (still supported)
+      #   client.create_column(board_id: 'board_1', name: 'Review', color: 'var(--color-card-4)')
+      #
+      def create_column(board_id:, name:, color: nil, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        payload = { name: name }
+        payload[:color] = Colors.resolve(color) unless color.nil?
+
+        response = connection.post("/#{slug}/boards/#{board_id}/columns", body: { column: payload })
+        response = connection.follow_location(response)
+        response.body
+      end
+
+      # Updates a column.
+      #
+      # @param board_id [String] the board ID
+      # @param column_id [String] the column ID
+      # @param name [String, nil] the new column name
+      # @param color [Symbol, String, nil] the new column color - accepts named colors
+      #   (:blue, :gray, :tan, :yellow, :lime, :aqua, :violet, :purple, :pink)
+      #   or CSS variable strings
+      # @param account_slug [String, nil] optional account slug override
+      # @return [Hash, nil] the updated column or nil if 204 response
+      #
+      # @example Update with named color
+      #   client.update_column('board_id', 'col_id', color: :purple)
+      #
+      def update_column(board_id, column_id, name: nil, color: nil, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        payload = {}
+        payload[:name] = name unless name.nil?
+        payload[:color] = Colors.resolve(color) unless color.nil?
+
+        response = connection.put("/#{slug}/boards/#{board_id}/columns/#{column_id}",
+                                  body: { column: payload })
+        response.no_content? ? nil : response.body
+      end
+
+      def delete_column(board_id, column_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/boards/#{board_id}/columns/#{column_id}")
+        response.no_content? ? nil : response.body
+      end
+    end
+  end
+end

data/lib/fizzy_api_client/resources/comments.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module Comments
+      def comments(card_number, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.get("/#{slug}/cards/#{card_number}/comments")
+        response.body
+      end
+
+      def comment(card_number, comment_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.get("/#{slug}/cards/#{card_number}/comments/#{comment_id}")
+        response.body
+      end
+
+      def create_comment(card_number, body:, created_at: nil, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        payload = { body: body }
+        payload[:created_at] = created_at unless created_at.nil?
+
+        response = connection.post("/#{slug}/cards/#{card_number}/comments",
+                                   body: { comment: payload })
+        response = connection.follow_location(response)
+        response.body
+      end
+
+      def update_comment(card_number, comment_id, body:, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        response = connection.put("/#{slug}/cards/#{card_number}/comments/#{comment_id}",
+                                  body: { comment: { body: body } })
+        response.no_content? ? nil : response.body
+      end
+
+      def delete_comment(card_number, comment_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/cards/#{card_number}/comments/#{comment_id}")
+        response.no_content? ? nil : response.body
+      end
+    end
+  end
+end

data/lib/fizzy_api_client/resources/direct_uploads.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module DirectUploads
+      def create_direct_upload(filename:, byte_size:, checksum:, content_type:, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        payload = {
+          filename: filename,
+          byte_size: byte_size,
+          checksum: checksum,
+          content_type: content_type
+        }
+
+        response = connection.post("/#{slug}/rails/active_storage/direct_uploads",
+                                   body: { blob: payload })
+        response.body
+      end
+
+      def upload_file(file_path_or_io, filename: nil, content_type: nil, account_slug: nil)
+        file_content, file_name, file_size = read_file_info(file_path_or_io, filename)
+        checksum = calculate_checksum(file_content)
+        content_type ||= "application/octet-stream"
+
+        # Step 1: Create direct upload
+        result = create_direct_upload(
+          filename: file_name,
+          byte_size: file_size,
+          checksum: checksum,
+          content_type: content_type,
+          account_slug: account_slug
+        )
+
+        # Step 2: Upload to storage URL
+        upload_url = result["direct_upload"]["url"]
+        upload_headers = result["direct_upload"]["headers"] || {}
+
+        put_to_external_url(upload_url, file_content, upload_headers)
+
+        # Step 3: Return signed_id
+        result["signed_id"]
+      end
+
+      private
+
+      def read_file_info(file_path_or_io, filename)
+        if file_path_or_io.is_a?(String)
+          content = File.binread(file_path_or_io)
+          name = filename || File.basename(file_path_or_io)
+          size = content.bytesize
+        else
+          content = file_path_or_io.read
+          name = filename || (file_path_or_io.respond_to?(:path) ? File.basename(file_path_or_io.path) : "upload")
+          size = content.bytesize
+        end
+
+        [content, name, size]
+      end
+
+      def calculate_checksum(content)
+        Base64.strict_encode64(Digest::MD5.digest(content))
+      end
+
+      def put_to_external_url(url, body, headers)
+        uri = URI.parse(url)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+
+        request = Net::HTTP::Put.new(uri.request_uri)
+        headers.each { |key, value| request[key] = value }
+        request.body = body
+
+        response = http.request(request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise ApiError.new(
+            message: "Failed to upload file to storage",
+            status: response.code.to_i
+          )
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/fizzy_api_client/resources/identity.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module Identity
+      def identity
+        response = connection.get("/my/identity")
+        response.body
+      end
+    end
+  end
+end

data/lib/fizzy_api_client/resources/notifications.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module Notifications
+      def notifications(page: nil, auto_paginate: false, account_slug: nil)
+        paginate("/notifications", account_slug: account_slug, auto_paginate: auto_paginate, page: page)
+      end
+
+      def mark_notification_read(notification_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post("/#{slug}/notifications/#{notification_id}/reading")
+        response.no_content? ? nil : response.body
+      end
+
+      def mark_notification_unread(notification_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/notifications/#{notification_id}/reading")
+        response.no_content? ? nil : response.body
+      end
+
+      def mark_all_notifications_read(account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post("/#{slug}/notifications/bulk_reading")
+        response.no_content? ? nil : response.body
+      end
+    end
+  end
+end

data/lib/fizzy_api_client/resources/reactions.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module Reactions
+      def reactions(card_number, comment_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.get("/#{slug}/cards/#{card_number}/comments/#{comment_id}/reactions")
+        response.body
+      end
+
+      def add_reaction(card_number, comment_id, content:, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.post(
+          "/#{slug}/cards/#{card_number}/comments/#{comment_id}/reactions",
+          body: { reaction: { content: content } }
+        )
+        response = connection.follow_location(response)
+        response.body
+      end
+
+      def remove_reaction(card_number, comment_id, reaction_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete(
+          "/#{slug}/cards/#{card_number}/comments/#{comment_id}/reactions/#{reaction_id}"
+        )
+        response.no_content? ? nil : response.body
+      end
+    end
+  end
+end

data/lib/fizzy_api_client/resources/steps.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module Steps
+      def step(card_number, step_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.get("/#{slug}/cards/#{card_number}/steps/#{step_id}")
+        response.body
+      end
+
+      def create_step(card_number, content:, completed: nil, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        payload = { content: content }
+        payload[:completed] = completed unless completed.nil?
+
+        response = connection.post("/#{slug}/cards/#{card_number}/steps",
+                                   body: { step: payload })
+        response = connection.follow_location(response)
+        response.body
+      end
+
+      def update_step(card_number, step_id, content: nil, completed: nil, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        payload = {}
+        payload[:content] = content unless content.nil?
+        payload[:completed] = completed unless completed.nil?
+
+        response = connection.put("/#{slug}/cards/#{card_number}/steps/#{step_id}",
+                                  body: { step: payload })
+        response.no_content? ? nil : response.body
+      end
+
+      def complete_step(card_number, step_id, account_slug: nil)
+        update_step(card_number, step_id, completed: true, account_slug: account_slug)
+      end
+
+      def incomplete_step(card_number, step_id, account_slug: nil)
+        update_step(card_number, step_id, completed: false, account_slug: account_slug)
+      end
+
+      def delete_step(card_number, step_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/cards/#{card_number}/steps/#{step_id}")
+        response.no_content? ? nil : response.body
+      end
+    end
+  end
+end

data/lib/fizzy_api_client/resources/tags.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module Tags
+      def tags(page: nil, auto_paginate: false, account_slug: nil)
+        paginate("/tags", account_slug: account_slug, auto_paginate: auto_paginate, page: page)
+      end
+    end
+  end
+end

data/lib/fizzy_api_client/resources/users.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module FizzyApiClient
+  module Resources
+    module Users
+      def users(page: nil, auto_paginate: false, account_slug: nil)
+        paginate("/users", account_slug: account_slug, auto_paginate: auto_paginate, page: page)
+      end
+
+      def user(user_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.get("/#{slug}/users/#{user_id}")
+        response.body
+      end
+
+      def update_user(user_id, name: nil, avatar: nil, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+
+        if avatar
+          response = update_user_with_avatar(slug, user_id, name, avatar)
+        else
+          payload = {}
+          payload[:name] = name unless name.nil?
+
+          response = connection.put("/#{slug}/users/#{user_id}", body: { user: payload })
+        end
+
+        response.no_content? ? nil : response.body
+      end
+
+      def deactivate_user(user_id, account_slug: nil)
+        slug = effective_account_slug(account_slug)
+        response = connection.delete("/#{slug}/users/#{user_id}")
+        response.no_content? ? nil : response.body
+      end
+
+      private
+
+      def update_user_with_avatar(slug, user_id, name, avatar)
+        fields = {}
+        fields["user[name]"] = name if name
+
+        files = { "user[avatar]" => build_user_file_info(avatar) }
+
+        connection.put_multipart("/#{slug}/users/#{user_id}", fields: fields, files: files)
+      end
+
+      def build_user_file_info(file)
+        if file.is_a?(String)
+          {
+            filename: File.basename(file),
+            content: File.read(file),
+            content_type: guess_user_content_type(file)
+          }
+        else
+          {
+            filename: file.respond_to?(:path) ? File.basename(file.path) : "avatar",
+            content: file.read,
+            content_type: "application/octet-stream"
+          }
+        end
+      end
+
+      def guess_user_content_type(path)
+        case File.extname(path).downcase
+        when ".png" then "image/png"
+        when ".jpg", ".jpeg" then "image/jpeg"
+        when ".gif" then "image/gif"
+        when ".webp" then "image/webp"
+        else "application/octet-stream"
+        end
+      end
+    end
+  end
+end