activeproject 0.3.0 → 0.5.0

data/lib/active_project/adapters/basecamp/issues.rb

@@ -25,10 +25,10 @@ module ActiveProject
           loop do
             response = @connection.get(path, query)
             todos_data = begin
-                           JSON.parse(response.body)
-                         rescue StandardError
-                           []
-                         end
+              JSON.parse(response.body)
+            rescue StandardError
+              []
+            end
             break if todos_data.empty?
 
             todos_data.each do |todo_data|
@@ -145,7 +145,8 @@ module ActiveProject
         def delete_issue(todo_id, context = {})
           project_id = context[:project_id]
           unless project_id
-            raise ArgumentError, "Missing required context: :project_id must be provided for BasecampAdapter#delete_issue"
+            raise ArgumentError,
+                  "Missing required context: :project_id must be provided for BasecampAdapter#delete_issue"
           end
 
           path = "buckets/#{project_id}/todos/#{todo_id}.json"

data/lib/active_project/adapters/basecamp/webhooks.rb

@@ -38,7 +38,8 @@ module ActiveProject
           when /todo_created$/
             event_type = :issue_created
             object_kind = :issue
-          when /todo_assignment_changed$/, /todo_completion_changed$/, /todo_content_updated$/, /todo_description_changed$/, /todo_due_on_changed$/
+          when /todo_assignment_changed$/, /todo_completion_changed$/, /todo_content_updated$/,
+               /todo_description_changed$/, /todo_due_on_changed$/
             event_type = :issue_updated
             object_kind = :issue
           when /comment_created$/
@@ -52,16 +53,14 @@ module ActiveProject
           end
 
           WebhookEvent.new(
-            event_type: event_type,
-            object_kind: object_kind,
-            event_object_id: event_object_id,
-            object_key: object_key,
+            type: event_type,
+            resource_type: object_kind,
+            resource_id: event_object_id,
             project_id: project_id,
             actor: map_user_data(creator),
             timestamp: timestamp,
-            adapter_source: :basecamp,
-            changes: changes,
-            object_data: object_data,
+            source: webhook_type,
+            data: (object_data || {}).merge(changes: changes, object_key: object_key),
             raw_data: payload
           )
         rescue JSON::ParserError

data/lib/active_project/adapters/fizzy/columns.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module Fizzy
+      module Columns
+        # Lists columns (workflow stages) on a board.
+        # @param board_id [String] The board ULID.
+        # @return [Array<Hash>] An array of column hashes.
+        def list_lists(board_id)
+          path = "boards/#{board_id}/columns.json"
+          response = @connection.get(path)
+          columns_data = parse_response(response)
+
+          columns_data.map do |column_data|
+            map_column_data(column_data, board_id)
+          end
+        rescue Faraday::Error => e
+          handle_faraday_error(e)
+        end
+
+        # Creates a new column on a board.
+        # @param board_id [String] The board ULID.
+        # @param attributes [Hash] Column attributes.
+        #   - :name [String] Required. The column name.
+        #   - :color [String] Optional. CSS var color (e.g., "var(--color-card-4)").
+        # @return [Hash] The created column hash.
+        def create_list(board_id, attributes)
+          unless attributes[:name] && !attributes[:name].empty?
+            raise ArgumentError, "Missing required attribute for Fizzy column creation: :name"
+          end
+
+          path = "boards/#{board_id}/columns.json"
+          payload = {
+            column: {
+              name: attributes[:name],
+              color: attributes[:color]
+            }.compact
+          }
+
+          response = @connection.post(path) do |req|
+            req.body = payload.to_json
+          end
+
+          # Extract column ID from Location header and fetch it
+          location = response.headers["Location"]
+          if location
+            column_id = location.match(%r{/columns/([^/.]+)})[1]
+            find_list(board_id, column_id)
+          else
+            # Fallback: parse response body if available
+            column_data = parse_response(response)
+            map_column_data(column_data, board_id)
+          end
+        rescue Faraday::Error => e
+          handle_faraday_error(e)
+        end
+
+        # Finds a specific column.
+        # @param board_id [String] The board ULID.
+        # @param column_id [String] The column ULID.
+        # @return [Hash] The column hash.
+        def find_list(board_id, column_id)
+          path = "boards/#{board_id}/columns/#{column_id}.json"
+          column_data = make_request(:get, path)
+          return nil unless column_data
+
+          map_column_data(column_data, board_id)
+        end
+
+        # Updates a column.
+        # @param board_id [String] The board ULID.
+        # @param column_id [String] The column ULID.
+        # @param attributes [Hash] Attributes to update.
+        #   - :name [String] The column name.
+        #   - :color [String] CSS var color.
+        # @return [Hash] The updated column hash.
+        def update_list(board_id, column_id, attributes)
+          path = "boards/#{board_id}/columns/#{column_id}.json"
+          payload = {
+            column: {
+              name: attributes[:name],
+              color: attributes[:color]
+            }.compact
+          }
+
+          make_request(:put, path, payload.to_json)
+          find_list(board_id, column_id)
+        end
+
+        # Deletes a column.
+        # @param board_id [String] The board ULID.
+        # @param column_id [String] The column ULID.
+        # @return [Boolean] True if successfully deleted.
+        def delete_list(board_id, column_id)
+          path = "boards/#{board_id}/columns/#{column_id}.json"
+          make_request(:delete, path)
+          true
+        end
+
+        private
+
+        def map_column_data(column_data, board_id)
+          {
+            id: column_data["id"],
+            name: column_data["name"],
+            color: column_data["color"],
+            board_id: board_id,
+            created_at: column_data["created_at"] ? Time.parse(column_data["created_at"]) : nil,
+            raw_data: column_data
+          }
+        end
+      end
+    end
+  end
+end

data/lib/active_project/adapters/fizzy/comments.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module Fizzy
+      module Comments
+        # Lists comments on a card.
+        # @param card_number [Integer, String] The card number.
+        # @return [Array<ActiveProject::Resources::Comment>] An array of comment resources.
+        def list_comments(card_number)
+          all_comments = []
+          path = "cards/#{card_number}/comments.json"
+
+          loop do
+            response = @connection.get(path)
+            comments_data = parse_response(response)
+            break if comments_data.empty?
+
+            comments_data.each do |comment_data|
+              all_comments << map_comment_data(comment_data, card_number)
+            end
+
+            next_url = parse_next_link(response.headers["Link"])
+            break unless next_url
+
+            path = extract_path_from_url(next_url)
+          end
+
+          all_comments
+        rescue Faraday::Error => e
+          handle_faraday_error(e)
+        end
+
+        # Adds a comment to a card.
+        # @param card_number [Integer, String] The card number.
+        # @param comment_body [String] The comment body (supports HTML rich text).
+        # @param context [Hash] Optional context (not required for Fizzy).
+        # @return [ActiveProject::Resources::Comment] The created comment resource.
+        def add_comment(card_number, comment_body, context = {})
+          path = "cards/#{card_number}/comments.json"
+          payload = {
+            comment: {
+              body: comment_body
+            }
+          }
+
+          response = @connection.post(path) do |req|
+            req.body = payload.to_json
+          end
+
+          # Extract comment ID from Location header and fetch it
+          location = response.headers["Location"]
+          if location
+            comment_id = location.match(%r{/comments/([^/.]+)})[1]
+            find_comment(card_number, comment_id)
+          else
+            # Fallback: parse response body if available
+            comment_data = parse_response(response)
+            map_comment_data(comment_data, card_number)
+          end
+        rescue Faraday::Error => e
+          handle_faraday_error(e)
+        end
+
+        # Finds a specific comment.
+        # @param card_number [Integer, String] The card number.
+        # @param comment_id [String] The comment ULID.
+        # @return [ActiveProject::Resources::Comment] The comment resource.
+        def find_comment(card_number, comment_id)
+          path = "cards/#{card_number}/comments/#{comment_id}.json"
+          comment_data = make_request(:get, path)
+          return nil unless comment_data
+
+          map_comment_data(comment_data, card_number)
+        end
+
+        # Updates a comment.
+        # @param card_number [Integer, String] The card number.
+        # @param comment_id [String] The comment ULID.
+        # @param comment_body [String] The new comment body.
+        # @return [ActiveProject::Resources::Comment] The updated comment resource.
+        def update_comment(card_number, comment_id, comment_body)
+          path = "cards/#{card_number}/comments/#{comment_id}.json"
+          payload = {
+            comment: {
+              body: comment_body
+            }
+          }
+
+          make_request(:put, path, payload.to_json)
+          find_comment(card_number, comment_id)
+        end
+
+        # Deletes a comment.
+        # @param card_number [Integer, String] The card number.
+        # @param comment_id [String] The comment ULID.
+        # @return [Boolean] True if successfully deleted.
+        def delete_comment(card_number, comment_id)
+          path = "cards/#{card_number}/comments/#{comment_id}.json"
+          make_request(:delete, path)
+          true
+        end
+
+        private
+
+        def map_comment_data(comment_data, card_number)
+          # Fizzy returns body as { plain_text: "...", html: "..." }
+          body = if comment_data["body"].is_a?(Hash)
+                   comment_data["body"]["plain_text"] || comment_data["body"]["html"]
+          else
+                   comment_data["body"]
+          end
+
+          Resources::Comment.new(
+            self,
+            id: comment_data["id"],
+            body: body,
+            author: map_user_data(comment_data["creator"]),
+            created_at: comment_data["created_at"] ? Time.parse(comment_data["created_at"]) : nil,
+            updated_at: comment_data["updated_at"] ? Time.parse(comment_data["updated_at"]) : nil,
+            issue_id: card_number.to_s,
+            adapter_source: :fizzy,
+            raw_data: comment_data
+          )
+        end
+      end
+    end
+  end
+end

data/lib/active_project/adapters/fizzy/connection.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module Fizzy
+      module Connection
+        include Connections::Rest
+
+        DEFAULT_BASE_URL = "https://app.fizzy.do"
+
+        # Initializes the Fizzy Adapter.
+        # @param config [Configurations::FizzyConfiguration] The configuration object for Fizzy.
+        # @raise [ArgumentError] if required configuration options are missing.
+        def initialize(config:)
+          unless config.is_a?(ActiveProject::Configurations::FizzyConfiguration)
+            raise ArgumentError, "FizzyAdapter requires a FizzyConfiguration object"
+          end
+
+          super(config: config)
+
+          account_slug = @config.options.fetch(:account_slug)
+          access_token = @config.options.fetch(:access_token)
+          base_url = @config.options[:base_url] || DEFAULT_BASE_URL
+
+          # Fizzy uses account_slug in URL path: /:account_slug/boards, etc.
+          @base_url = "#{base_url}/#{account_slug}/"
+
+          init_rest(
+            base_url: @base_url,
+            auth_middleware: ->(conn) { conn.request :authorization, "Bearer", access_token },
+            extra_headers: { "Accept" => "application/json", "Content-Type" => "application/json" }
+          )
+
+          return if account_slug && !account_slug.to_s.empty? && access_token && !access_token.empty?
+
+          raise ArgumentError, "FizzyAdapter configuration requires :account_slug and :access_token"
+        end
+      end
+    end
+  end
+end

data/lib/active_project/adapters/fizzy/issues.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module Fizzy
+      module Issues
+        # Lists cards within a specific board.
+        # @param board_id [String] The ULID of the Fizzy board.
+        # @param options [Hash] Optional options for filtering.
+        #   - :tag_ids [Array<String>] Filter by tag IDs
+        #   - :assignee_ids [Array<String>] Filter by assignee user IDs
+        #   - :indexed_by [String] Filter: all, closed, not_now, stalled, postponing_soon, golden
+        #   - :sorted_by [String] Sort: latest, newest, oldest
+        # @return [Array<ActiveProject::Resources::Issue>] An array of issue resources.
+        def list_issues(board_id, options = {})
+          all_cards = []
+          query = { "board_ids[]" => board_id }
+
+          # Add optional filters
+          options[:tag_ids]&.each { |id| query["tag_ids[]"] = id }
+          options[:assignee_ids]&.each { |id| query["assignee_ids[]"] = id }
+          query[:indexed_by] = options[:indexed_by] if options[:indexed_by]
+          query[:sorted_by] = options[:sorted_by] if options[:sorted_by]
+
+          path = "cards.json"
+
+          loop do
+            response = @connection.get(path, query)
+            cards_data = parse_response(response)
+            break if cards_data.empty?
+
+            cards_data.each do |card_data|
+              all_cards << map_card_data(card_data, board_id)
+            end
+
+            next_url = parse_next_link(response.headers["Link"])
+            break unless next_url
+
+            path = extract_path_from_url(next_url)
+            query = {} # Query params are in the URL now
+          end
+
+          all_cards
+        rescue Faraday::Error => e
+          handle_faraday_error(e)
+        end
+
+        # Finds a specific card by its number.
+        # @param card_number [Integer, String] The card number (sequential per account).
+        # @param context [Hash] Optional context (not required for Fizzy).
+        # @return [ActiveProject::Resources::Issue] The issue resource.
+        def find_issue(card_number, context = {})
+          path = "cards/#{card_number}.json"
+          card_data = make_request(:get, path)
+          return nil unless card_data
+
+          board_id = card_data.dig("board", "id")
+          map_card_data(card_data, board_id)
+        end
+
+        # Creates a new card in a board.
+        # @param board_id [String] The ULID of the Fizzy board.
+        # @param attributes [Hash] Card attributes.
+        #   - :title [String] Required. The card title.
+        #   - :description [String] Optional. Rich text description (HTML).
+        #   - :status [String] Optional. Initial status: published (default), drafted.
+        #   - :tag_ids [Array<String>] Optional. Tag IDs to apply.
+        # @return [ActiveProject::Resources::Issue] The created issue resource.
+        def create_issue(board_id, attributes)
+          title = attributes[:title]
+          unless title && !title.empty?
+            raise ArgumentError, "Missing required attribute for Fizzy card creation: :title"
+          end
+
+          path = "boards/#{board_id}/cards.json"
+          payload = {
+            card: {
+              title: title,
+              description: attributes[:description],
+              status: attributes[:status] || "published",
+              tag_ids: attributes[:tag_ids]
+            }.compact
+          }
+
+          # Fizzy returns 201 Created with Location header
+          response = @connection.post(path) do |req|
+            req.body = payload.to_json
+          end
+
+          # Extract card number from Location header and fetch it
+          location = response.headers["Location"]
+          if location
+            card_number = location.match(%r{/cards/(\d+)})[1]
+            find_issue(card_number)
+          else
+            # Fallback: parse response body if available
+            card_data = parse_response(response)
+            map_card_data(card_data, board_id)
+          end
+        rescue Faraday::Error => e
+          handle_faraday_error(e)
+        end
+
+        # Updates an existing card.
+        # @param card_number [Integer, String] The card number.
+        # @param attributes [Hash] Attributes to update.
+        #   - :title [String] The card title.
+        #   - :description [String] Rich text description.
+        #   - :status [Symbol] Status change: :open, :closed, :on_hold.
+        #   - :tag_ids [Array<String>] Tag IDs to apply.
+        # @param context [Hash] Optional context (not required for Fizzy).
+        # @return [ActiveProject::Resources::Issue] The updated issue resource.
+        def update_issue(card_number, attributes, context = {})
+          put_payload = {}
+          put_payload[:title] = attributes[:title] if attributes.key?(:title)
+          put_payload[:description] = attributes[:description] if attributes.key?(:description)
+          put_payload[:tag_ids] = attributes[:tag_ids] if attributes.key?(:tag_ids)
+
+          status_change_required = attributes.key?(:status)
+          target_status = attributes[:status] if status_change_required
+
+          unless !put_payload.empty? || status_change_required
+            raise ArgumentError, "No attributes provided to update for FizzyAdapter#update_issue"
+          end
+
+          # Update basic fields via PUT
+          unless put_payload.empty?
+            put_path = "cards/#{card_number}.json"
+            make_request(:put, put_path, { card: put_payload }.to_json)
+          end
+
+          # Handle status changes via separate endpoints
+          if status_change_required
+            handle_status_change(card_number, target_status)
+          end
+
+          find_issue(card_number, context)
+        end
+
+        # Deletes a card.
+        # @param card_number [Integer, String] The card number to delete.
+        # @param context [Hash] Optional context (not required for Fizzy).
+        # @return [Boolean] True if successfully deleted.
+        def delete_issue(card_number, context = {})
+          path = "cards/#{card_number}.json"
+          make_request(:delete, path)
+          true
+        end
+
+        private
+
+        def handle_status_change(card_number, target_status)
+          case target_status
+          when :closed
+            # POST /cards/:num/closure
+            make_request(:post, "cards/#{card_number}/closure.json")
+          when :open
+            # DELETE /cards/:num/closure (reopen)
+            begin
+              make_request(:delete, "cards/#{card_number}/closure.json")
+            rescue NotFoundError
+              # Card wasn't closed, ignore
+            end
+          when :on_hold
+            # POST /cards/:num/not_now
+            make_request(:post, "cards/#{card_number}/not_now.json")
+          end
+        end
+
+        def map_card_data(card_data, board_id)
+          # Determine status based on card state and column
+          status = determine_card_status(card_data, board_id)
+
+          # Map creator
+          creator = map_user_data(card_data["creator"])
+
+          # Map assignees if present (Fizzy cards can have multiple assignees)
+          assignees = (card_data["assignees"] || []).map { |a| map_user_data(a) }.compact
+
+          Resources::Issue.new(
+            self,
+            id: card_data["id"],
+            key: card_data["number"]&.to_s,
+            title: card_data["title"],
+            description: card_data["description"],
+            status: status,
+            assignees: assignees,
+            reporter: creator,
+            project_id: board_id || card_data.dig("board", "id"),
+            created_at: card_data["created_at"] ? Time.parse(card_data["created_at"]) : nil,
+            updated_at: card_data["last_active_at"] ? Time.parse(card_data["last_active_at"]) : nil,
+            due_on: nil, # Fizzy doesn't have due dates on cards
+            priority: nil,
+            adapter_source: :fizzy,
+            raw_data: card_data
+          )
+        end
+
+        def determine_card_status(card_data, board_id)
+          # Check for closed status
+          return :closed if card_data["closed"] == true
+
+          # Check for not_now status
+          return :on_hold if card_data["not_now"].present?
+
+          # Check column-based status mapping from config
+          column_name = card_data.dig("column", "name")
+          if column_name && board_id
+            board_mappings = @config.status_mappings[board_id]
+            if board_mappings && board_mappings.key?(column_name)
+              return board_mappings[column_name]
+            end
+          end
+
+          # Default: published cards are open
+          card_data["status"] == "drafted" ? :open : :open
+        end
+      end
+    end
+  end
+end

data/lib/active_project/adapters/fizzy/projects.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module ActiveProject
+  module Adapters
+    module Fizzy
+      module Projects
+        # Lists boards accessible by the configured credentials.
+        # Handles pagination automatically using the Link header.
+        # @return [Array<ActiveProject::Resources::Project>] An array of project resources.
+        def list_projects
+          all_boards = []
+          path = "boards.json"
+
+          loop do
+            response = @connection.get(path)
+            boards_data = parse_response(response)
+            break if boards_data.empty?
+
+            boards_data.each do |board_data|
+              all_boards << map_board_data(board_data)
+            end
+
+            next_url = parse_next_link(response.headers["Link"])
+            break unless next_url
+
+            path = extract_path_from_url(next_url)
+          end
+
+          all_boards
+        rescue Faraday::Error => e
+          handle_faraday_error(e)
+        end
+
+        # Finds a specific board by its ID.
+        # @param board_id [String] The ULID of the Fizzy board.
+        # @return [ActiveProject::Resources::Project] The project resource.
+        def find_project(board_id)
+          path = "boards/#{board_id}.json"
+          board_data = make_request(:get, path)
+          return nil unless board_data
+
+          map_board_data(board_data)
+        end
+
+        # Creates a new board in Fizzy.
+        # @param attributes [Hash] Board attributes. Required: :name. Optional: :all_access, :auto_postpone_period.
+        # @return [ActiveProject::Resources::Project] The created project resource.
+        def create_project(attributes)
+          unless attributes[:name] && !attributes[:name].empty?
+            raise ArgumentError, "Missing required attribute for Fizzy board creation: :name"
+          end
+
+          path = "boards.json"
+          payload = {
+            board: {
+              name: attributes[:name],
+              all_access: attributes.fetch(:all_access, true),
+              auto_postpone_period: attributes[:auto_postpone_period]
+            }.compact
+          }
+
+          # Fizzy returns 201 Created with Location header, need to fetch the board
+          response = @connection.post(path) do |req|
+            req.body = payload.to_json
+          end
+
+          # Extract board ID from Location header and fetch it
+          location = response.headers["Location"]
+          if location
+            board_id = location.match(%r{/boards/([^/.]+)})[1]
+            find_project(board_id)
+          else
+            # Fallback: parse response body if available
+            board_data = parse_response(response)
+            map_board_data(board_data)
+          end
+        rescue Faraday::Error => e
+          handle_faraday_error(e)
+        end
+
+        # Deletes a board in Fizzy.
+        # @param board_id [String] The ULID of the board to delete.
+        # @return [Boolean] true if deletion was successful (API returns 204).
+        def delete_project(board_id)
+          path = "boards/#{board_id}.json"
+          make_request(:delete, path)
+          true
+        end
+
+        private
+
+        def map_board_data(board_data)
+          Resources::Project.new(
+            self,
+            id: board_data["id"],
+            key: nil,
+            name: board_data["name"],
+            adapter_source: :fizzy,
+            raw_data: board_data
+          )
+        end
+      end
+    end
+  end
+end