collavre 0.1.1 → 0.2.0

data/app/jobs/collavre/notion_sync_job.rb

@@ -1,48 +0,0 @@
-module Collavre
-class NotionSyncJob < ApplicationJob
-  queue_as :default
-
-  def perform(creative, notion_account, page_id)
-    service = NotionService.new(user: notion_account.user)
-
-    begin
-      # Find the existing link
-      link = NotionPageLink.find_by(
-        creative: creative,
-        notion_account: notion_account,
-        page_id: page_id
-      )
-
-      unless link
-        Rails.logger.error("No Notion page link found for creative #{creative.id} and page #{page_id}")
-        return
-      end
-
-      # Update the existing Notion page with children as blocks
-      title = ActionController::Base.helpers.strip_tags(creative.description).strip.presence || "Untitled Creative"
-      children = creative.children.to_a
-      Rails.logger.info("NotionSyncJob: Syncing creative #{creative.id} as page title with #{children.count} children as blocks")
-      blocks = children.any? ? NotionCreativeExporter.new(creative).export_tree_blocks(children, 1, 0) : []
-
-      properties = {
-        title: {
-          title: [ { text: { content: title } } ]
-        }
-      }
-
-      service.update_page(page_id, properties: properties, blocks: blocks)
-      link.update!(page_title: title)
-      link.mark_synced!
-
-      Rails.logger.info("Successfully synced creative #{creative.id} to Notion page #{page_id}")
-
-    rescue NotionError => e
-      Rails.logger.error("Notion sync failed for creative #{creative.id}: #{e.message}")
-      raise e
-    rescue StandardError => e
-      Rails.logger.error("Unexpected error during Notion sync for creative #{creative.id}: #{e.message}")
-      raise e
-    end
-  end
-end
-end

data/app/models/collavre/notion_account.rb

@@ -1,17 +0,0 @@
-module Collavre
-  class NotionAccount < ApplicationRecord
-    self.table_name = "notion_accounts"
-
-    belongs_to :user, class_name: Collavre.configuration.user_class_name
-    has_many :notion_page_links, class_name: "Collavre::NotionPageLink", dependent: :destroy
-
-    encrypts :token, deterministic: false
-
-    validates :notion_uid, :token, presence: true
-    validates :notion_uid, uniqueness: true
-
-    def expired?
-      token_expires_at.present? && token_expires_at < Time.current
-    end
-  end
-end

data/app/models/collavre/notion_block_link.rb

@@ -1,10 +0,0 @@
-module Collavre
-  class NotionBlockLink < ApplicationRecord
-    self.table_name = "notion_block_links"
-
-    belongs_to :notion_page_link, class_name: "Collavre::NotionPageLink"
-    belongs_to :creative, class_name: "Collavre::Creative"
-
-    validates :block_id, presence: true, uniqueness: { scope: :notion_page_link_id }
-  end
-end

data/app/models/collavre/notion_page_link.rb

@@ -1,19 +0,0 @@
-module Collavre
-  class NotionPageLink < ApplicationRecord
-    self.table_name = "notion_page_links"
-
-    belongs_to :creative, class_name: "Collavre::Creative"
-    belongs_to :notion_account, class_name: "Collavre::NotionAccount"
-    has_many :notion_block_links, class_name: "Collavre::NotionBlockLink", dependent: :destroy
-
-    validates :page_id, :page_title, presence: true
-    validates :page_id, uniqueness: true
-
-    scope :recent, -> { order(last_synced_at: :desc) }
-    scope :synced, -> { where.not(last_synced_at: nil) }
-
-    def mark_synced!
-      touch(:last_synced_at)
-    end
-  end
-end

data/app/services/collavre/notion_client.rb

@@ -1,231 +0,0 @@
-module Collavre
-  class NotionClient
-    BASE_URL = "https://api.notion.com/v1"
-    API_VERSION = "2022-06-28"
-
-    def initialize(account)
-      @account = account
-      @token = account.token
-    end
-
-    def search_pages(query: nil, start_cursor: nil, page_size: 10)
-      Rails.logger.info("NotionClient: Searching for pages with query: #{query}, page_size: #{page_size}")
-
-      body = {
-        filter: { property: "object", value: "page" },
-        page_size: page_size
-      }
-      body[:query] = query if query.present?
-      body[:start_cursor] = start_cursor if start_cursor.present?
-
-      Rails.logger.info("NotionClient: Search request body: #{body.to_json}")
-      result = post("search", body)
-      Rails.logger.info("NotionClient: Search returned #{result["results"]&.length || 0} results")
-      result
-    end
-
-    def get_page(page_id)
-      get("pages/#{format_id(page_id)}")
-    end
-
-    def create_page(parent_id:, title:, blocks: [])
-      Rails.logger.info("NotionClient: Creating page with #{blocks.length} blocks")
-
-      # Notion limits page creation to 100 blocks, so create with minimal content first
-      body = {
-        parent: { page_id: parent_id },
-        properties: {
-          title: {
-            title: [ { text: { content: title } } ]
-          }
-        },
-        children: blocks.length > 100 ? [] : blocks
-      }
-
-      response = post("pages", body)
-
-      # If we have more than 100 blocks, add them in batches after page creation
-      if blocks.length > 100
-        Rails.logger.info("NotionClient: Adding #{blocks.length} blocks in batches (100 per batch)")
-        page_id = response["id"]
-        Rails.logger.info("NotionClient: Created page ID: #{page_id}")
-
-        # Give Notion a moment to fully create the page
-        sleep(1)
-
-        # Add blocks in batches of 100
-        blocks.each_slice(100).with_index do |block_batch, index|
-          Rails.logger.info("NotionClient: Adding batch #{index + 1} with #{block_batch.length} blocks")
-          append_blocks(page_id, block_batch)
-          Rails.logger.info("NotionClient: Successfully added batch #{index + 1}")
-        end
-      end
-
-      response
-    end
-
-    def update_page(page_id, properties: {}, blocks: nil)
-      body = { properties: properties }
-      response = patch("pages/#{format_id(page_id)}", body)
-
-      if blocks.present?
-        replace_page_blocks(page_id, blocks)
-      end
-
-      response
-    end
-
-    def get_page_blocks(page_id, start_cursor: nil, page_size: 100)
-      params = { page_size: page_size }
-      params[:start_cursor] = start_cursor if start_cursor.present?
-
-      get("blocks/#{format_id(page_id)}/children", params)
-    end
-
-    def replace_page_blocks(page_id, blocks)
-      Rails.logger.info("NotionClient: Replacing page blocks with #{blocks.length} blocks")
-
-      # First, get existing blocks
-      existing_blocks = get_page_blocks(page_id)
-
-      # Delete existing blocks
-      existing_blocks.dig("results")&.each do |block|
-        delete_block(block["id"])
-      end
-
-      # Add new blocks in batches of 100
-      if blocks.any?
-        blocks.each_slice(100).with_index do |block_batch, index|
-          Rails.logger.info("NotionClient: Adding replacement batch #{index + 1} with #{block_batch.length} blocks")
-          append_blocks(page_id, block_batch)
-        end
-      end
-    end
-
-    def append_blocks(page_id, blocks)
-      # Notion also limits append operations to 100 blocks
-      if blocks.length > 100
-        Rails.logger.info("NotionClient: Appending #{blocks.length} blocks in batches")
-        aggregated_results = []
-
-        blocks.each_slice(100).with_index do |block_batch, index|
-          Rails.logger.info("NotionClient: Appending batch #{index + 1} with #{block_batch.length} blocks")
-          response = patch("blocks/#{format_id(page_id)}/children", { children: block_batch })
-
-          if response.is_a?(Hash)
-            batch_results = response.fetch("results", [])
-            aggregated_results.concat(batch_results) if batch_results.any?
-          end
-        end
-
-        aggregated_results.any? ? { "results" => aggregated_results } : nil
-      else
-        patch("blocks/#{format_id(page_id)}/children", { children: blocks })
-      end
-    end
-
-    def delete_block(block_id)
-      delete("blocks/#{format_id(block_id)}")
-    end
-
-    def get_workspace
-      get("users/me")
-    end
-
-    private
-
-    def get(path, params = {})
-      url = "#{BASE_URL}/#{path}"
-      url += "?#{params.to_query}" if params.any?
-
-      response = HTTParty.get(
-        url,
-        headers: headers,
-        timeout: 30
-      )
-
-      handle_response(response)
-    end
-
-    def post(path, body)
-      response = HTTParty.post(
-        "#{BASE_URL}/#{path}",
-        headers: headers,
-        body: body.to_json,
-        timeout: 30
-      )
-
-      handle_response(response)
-    end
-
-    def patch(path, body)
-      response = HTTParty.patch(
-        "#{BASE_URL}/#{path}",
-        headers: headers,
-        body: body.to_json,
-        timeout: 30
-      )
-
-      handle_response(response)
-    end
-
-    def delete(path)
-      response = HTTParty.delete(
-        "#{BASE_URL}/#{path}",
-        headers: headers,
-        timeout: 30
-      )
-
-      handle_response(response)
-    end
-
-    def headers
-      {
-        "Authorization" => "Bearer #{@token}",
-        "Notion-Version" => API_VERSION,
-        "Content-Type" => "application/json"
-      }
-    end
-
-    def format_id(id)
-      # Keep dashes in UUIDs - Notion API expects them
-      id.to_s
-    end
-
-    def handle_response(response)
-      Rails.logger.info("Notion API Response: #{response.code} for #{response.request.last_uri}")
-      Rails.logger.debug("Notion API Response Body: #{response.body}")
-
-      case response.code
-      when 200, 201
-        response.parsed_response
-      when 400
-        Rails.logger.error("Notion API 400 error: #{response.body}")
-        raise NotionError, "Bad request: #{response.parsed_response}"
-      when 401
-        Rails.logger.error("Notion API 401 error: #{response.body}")
-        raise NotionAuthError, "Unauthorized: Token may be expired"
-      when 403
-        Rails.logger.error("Notion API 403 error: #{response.body}")
-        raise NotionError, "Forbidden: Insufficient permissions"
-      when 404
-        Rails.logger.error("Notion API 404 error: #{response.body}")
-        raise NotionError, "Resource not found"
-      when 429
-        Rails.logger.error("Notion API 429 error: #{response.body}")
-        raise NotionRateLimitError, "Rate limit exceeded"
-      else
-        Rails.logger.error("Notion API error: #{response.code} #{response.body}")
-        raise NotionError, "API error: #{response.code}"
-      end
-    rescue HTTParty::Error, SocketError, Timeout::Error => e
-      Rails.logger.error("Notion API connection error: #{e.message}")
-      raise NotionConnectionError, "Connection failed: #{e.message}"
-    end
-  end
-
-  class NotionError < StandardError; end
-  class NotionAuthError < NotionError; end
-  class NotionRateLimitError < NotionError; end
-  class NotionConnectionError < NotionError; end
-end

data/app/services/collavre/notion_creative_exporter.rb

@@ -1,296 +0,0 @@
-module Collavre
-  class NotionCreativeExporter
-    include CreativesHelper
-
-    def initialize(creative, with_progress: false)
-      @creative = creative
-      @with_progress = with_progress
-    end
-
-    def export_blocks
-      convert_creative_to_blocks(@creative, level: 1)
-    end
-
-    def export_tree_blocks(creatives, level = 1, bullet_depth = 0)
-      return [] if creatives.blank?
-
-      blocks = []
-      creatives.each do |creative|
-        # Convert the creative to blocks
-        creative_blocks = convert_creative_to_blocks(creative, level: level)
-
-        # Handle children based on the level
-        if creative.respond_to?(:children) && creative.children.present?
-          if level > 3
-            # For bullet points (level > 3), limit nesting depth to 2 levels max
-            text_content = extract_text_content(creative.effective_description(nil, true).gsub(/<!--.*?-->/m, "").strip)
-
-            if bullet_depth < 2
-              # Can still nest deeper
-              children_blocks = export_tree_blocks(creative.children, level + 1, bullet_depth + 1)
-              bullet_block = create_bulleted_list_item_block(text_content, children_blocks)
-              blocks << bullet_block
-            else
-              # Max depth reached, flatten remaining levels
-              bullet_block = create_bulleted_list_item_block(text_content)
-              blocks << bullet_block
-              # Add children as flat bullet points at same level
-              blocks.concat(export_tree_blocks(creative.children, level, bullet_depth))
-            end
-          else
-            # For headings (level <= 3), add heading then children as separate blocks
-            blocks.concat(creative_blocks)
-            blocks.concat(export_tree_blocks(creative.children, level + 1, 0))
-          end
-        else
-          # No children, just add the blocks
-          blocks.concat(creative_blocks)
-        end
-      end
-
-      blocks
-    end
-
-    private
-
-    def convert_creative_to_blocks(creative, level: 1)
-      blocks = []
-      description_content = creative.effective_description(nil, true)
-      desc = description_content.present? ? description_content.to_s : ""
-
-      # Add progress if requested and available
-      if @with_progress && creative.respond_to?(:progress) && !creative.progress.nil?
-        pct = (creative.progress.to_f * 100).round
-        desc = "#{desc} (#{pct}%)"
-      end
-
-      # Clean HTML and prepare content
-      raw_html = desc.gsub(/<!--.*?-->/m, "").strip
-
-      # Handle different content types
-      if level <= 3 && contains_table?(raw_html)
-        blocks.concat(convert_table_to_blocks(raw_html))
-      elsif level <= 3
-        # Use as heading
-        text_content = extract_text_content(raw_html)
-        if text_content.present?
-          blocks << create_heading_block(text_content, level)
-        end
-      else
-        # Use as bulleted list item for deeper levels
-        text_content = extract_text_content(raw_html)
-        if text_content.present?
-          blocks << create_bulleted_list_item_block(text_content)
-        end
-      end
-
-      # Handle rich content like images and links within the HTML
-      blocks.concat(convert_rich_content_to_blocks(raw_html))
-
-      blocks
-    end
-
-    def contains_table?(html)
-      html.match?(%r{<table\b[^>]*>.*?</table>}im) ||
-        html.match?(/^\s*\|.*?\|(?:\s*\n\s*\|.*?\|)*\s*$/m)
-    end
-
-    def convert_table_to_blocks(html)
-      blocks = []
-
-      # Extract table content
-      table_match = html.match(%r{<table\b[^>]*>(.*?)</table>}im)
-      if table_match
-        table_html = table_match[1]
-        table_data = parse_html_table(table_html)
-        if table_data.any?
-          blocks << create_table_block(table_data)
-        end
-      else
-        # Try markdown table format
-        markdown_table = extract_markdown_table(html)
-        if markdown_table
-          table_data = parse_markdown_table(markdown_table)
-          if table_data.any?
-            blocks << create_table_block(table_data)
-          end
-        end
-      end
-
-      blocks
-    end
-
-    def parse_html_table(table_html)
-      fragment = Nokogiri::HTML::DocumentFragment.parse("<table>#{table_html}</table>")
-      table = fragment.at_css("table")
-      return [] unless table
-
-      rows = []
-      table.css("tr").each do |row|
-        cells = row.css("th,td").map do |cell|
-          text = extract_text_content(cell.inner_html)
-          create_table_cell_content(text)
-        end
-        rows << cells if cells.any?
-      end
-
-      rows
-    end
-
-    def parse_markdown_table(table_text)
-      lines = table_text.strip.split("\n").map(&:strip)
-      return [] if lines.length < 2
-
-      rows = []
-      lines.each_with_index do |line, index|
-        next if index == 1 # Skip alignment row
-
-        cells = line.split("|").map(&:strip).reject(&:empty?)
-        next if cells.empty?
-
-        cell_contents = cells.map { |cell| create_table_cell_content(cell.strip) }
-        rows << cell_contents
-      end
-
-      rows
-    end
-
-    def extract_markdown_table(html)
-      # Look for markdown table patterns in the HTML
-      html.match(/(\|.*?\|(?:\s*\n\s*\|.*?\|)*)/m)&.captures&.first
-    end
-
-    def convert_rich_content_to_blocks(html)
-      blocks = []
-
-      # Extract images
-      html.scan(%r{<action-text-attachment ([^>]+)>(?:</action-text-attachment>)?}) do |match|
-        attrs = Hash[match[0].scan(/(\S+?)="([^"]*)"/)]
-        sgid = attrs["sgid"]
-        caption = attrs["caption"] || ""
-
-        if (blob = GlobalID::Locator.locate_signed(sgid, for: "attachable"))
-          # For now, we'll create a paragraph with the image description
-          # In a full implementation, you'd upload to Notion's file storage
-          blocks << create_paragraph_block("📷 #{caption.presence || 'Image attachment'}")
-        end
-      end
-
-      # Extract data URLs for images
-      html.scan(/<img [^>]*src=['"](data:[^'"]+)['"][^>]*alt=['"]([^'"]*)['"][^>]*>/) do |data_url, alt_text|
-        blocks << create_paragraph_block("📷 #{alt_text.presence || 'Image'}")
-      end
-
-      blocks
-    end
-
-    def extract_text_content(html)
-      # Remove HTML tags and get plain text
-      ActionView::Base.full_sanitizer.sanitize(html).strip
-    end
-
-    def create_heading_block(text, level)
-      # Notion supports heading_1, heading_2, heading_3
-      heading_type = case level
-      when 1 then "heading_1"
-      when 2 then "heading_2"
-      else "heading_3"
-      end
-
-      heading_key = heading_type.to_sym
-
-      {
-        object: "block",
-        type: heading_type,
-        heading_key => {
-          rich_text: [ create_rich_text(text) ]
-        }
-      }
-    end
-
-    def create_paragraph_block(text)
-      {
-        object: "block",
-        type: "paragraph",
-        paragraph: {
-          rich_text: [ create_rich_text(text) ]
-        }
-      }
-    end
-
-    def create_bulleted_list_item_block(text, children_blocks = [])
-      block = {
-        object: "block",
-        type: "bulleted_list_item",
-        bulleted_list_item: {
-          rich_text: [ create_rich_text(text) ]
-        }
-      }
-
-      # Add nested children if present
-      if children_blocks.any?
-        block[:bulleted_list_item][:children] = children_blocks
-      end
-
-      block
-    end
-
-    def create_table_block(table_data)
-      return nil if table_data.empty?
-
-      # Notion tables need consistent column count
-      max_columns = table_data.map(&:length).max
-      normalized_rows = table_data.map do |row|
-        row + Array.new([ max_columns - row.length, 0 ].max) { create_table_cell_content("") }
-      end
-
-      {
-        object: "block",
-        type: "table",
-        table: {
-          table_width: max_columns,
-          has_column_header: true,
-          has_row_header: false,
-          children: normalized_rows.map do |row_data|
-            {
-              object: "block",
-              type: "table_row",
-              table_row: {
-                cells: row_data
-              }
-            }
-          end
-        }
-      }
-    end
-
-    def create_table_cell_content(text)
-      [ create_rich_text(text.to_s) ]
-    end
-
-    def create_rich_text(text)
-      # Notion has a 2000 character limit per text block
-      content = text.to_s.strip
-      if content.length > 1990  # Be conservative to account for any extra characters
-        original_length = content.length
-        content = content[0..1986] + "..."  # 1987 + 3 = 1990 chars
-        Rails.logger.warn("NotionCreativeExporter: Truncated content from #{original_length} to #{content.length} characters")
-      end
-
-      {
-        type: "text",
-        text: {
-          content: content
-        },
-        annotations: {
-          bold: false,
-          italic: false,
-          strikethrough: false,
-          underline: false,
-          code: false,
-          color: "default"
-        }
-      }
-    end
-  end
-end