collavre 0.1.0

data/app/services/collavre/google_calendar_service.rb

@@ -0,0 +1,149 @@
+module Collavre
+  require "google/apis/calendar_v3"
+  require "googleauth"
+
+  class GoogleCalendarService
+    def initialize(user:)
+      @user = user
+      @service = Google::Apis::CalendarV3::CalendarService.new
+      @service.client_options.application_name = "Collavre"
+      @service.authorization = user_credentials
+    end
+
+    # Creates a Google Calendar event.
+    # Optional params supported: location, recurrence (array), attendees (array of emails or attendee hashes),
+    # reminders (hash: { use_default: true/false, overrides: [{ method: 'email'|'popup', minutes: Integer }, ...] })
+    def create_event(
+      calendar_id: "primary",
+      start_time:,
+      end_time:,
+      summary:,
+      description: nil,
+      timezone: nil,
+      location: nil,
+      recurrence: nil,
+      attendees: nil,
+      reminders: nil,
+      all_day: false,
+      creative: nil
+    )
+      timezone ||= @user.timezone || Time.zone.tzinfo.name
+      event_args = { summary: summary, description: description }
+
+      if all_day
+        # All-day events must use date (no time or timezone). End date is exclusive per Google Calendar API.
+        start_date = start_time.to_date
+        end_date_exclusive = end_time.to_date + 1
+        event_args[:start] = { date: start_date.iso8601 }
+        event_args[:end]   = { date: end_date_exclusive.iso8601 }
+      else
+        event_args[:start] = { date_time: start_time.iso8601, time_zone: timezone }
+        event_args[:end]   = { date_time: end_time.iso8601,   time_zone: timezone }
+      end
+
+      event_args[:location] = location if location.present?
+      event_args[:recurrence] = recurrence if recurrence.present?
+
+      if attendees.present?
+        event_args[:attendees] = Array(attendees).map do |a|
+          if a.is_a?(String)
+            Google::Apis::CalendarV3::EventAttendee.new(email: a)
+          elsif a.is_a?(Hash)
+            # Support keys like :email, :response_status, etc.
+            Google::Apis::CalendarV3::EventAttendee.new(**a.symbolize_keys)
+          else
+            nil
+          end
+        end.compact
+      end
+
+      if reminders.present?
+        use_default = reminders[:use_default]
+        overrides = Array(reminders[:overrides]).map do |r|
+          # IMPORTANT: Ruby client uses method_prop instead of method
+          meth = r[:method] || r[:method_prop]
+          mins = r[:minutes]
+          Google::Apis::CalendarV3::EventReminder.new(method_prop: meth, minutes: mins)
+        end
+        event_args[:reminders] = Google::Apis::CalendarV3::Event::Reminders.new(use_default: !!use_default, overrides: overrides)
+      end
+
+      event = Google::Apis::CalendarV3::Event.new(**event_args)
+
+      if @service.authorization.scope.include?(Google::Apis::CalendarV3::AUTH_CALENDAR_APP_CREATED)
+        @user.calendar_id ||= create_app_calendar
+        calendar_id = @user.calendar_id
+      end
+      result = @service.insert_event(calendar_id, event)
+      CalendarEvent.create!(
+        user: @user,
+        creative: creative,
+        google_event_id: result.id,
+        summary: result.summary,
+        start_time: result.start.date_time || result.start.date,
+        end_time: result.end.date_time || result.end.date,
+        html_link: result.html_link
+      )
+      result
+    rescue Google::Apis::ClientError => e
+      # Surface helpful error info to aid debugging 400 errors
+      Rails.logger.error("Google Calendar insert_event 4xx: #{e.class} #{e.status_code} - #{e.message} body=#{e.body}")
+      raise
+    end
+
+    # Deletes a Google Calendar event.
+    def delete_event(event_id, calendar_id: "primary")
+      if @service.authorization.scope.include?(Google::Apis::CalendarV3::AUTH_CALENDAR_APP_CREATED)
+        @user.calendar_id ||= create_app_calendar
+        calendar_id = @user.calendar_id
+      end
+      @service.delete_event(calendar_id, event_id)
+    rescue Google::Apis::ClientError => e
+      raise unless e.status_code == 404
+    end
+
+    def list_calendars
+      @service.list_calendar_lists.items.map { |c| [ c.summary, c.id ] }.to_h
+    end
+
+    private
+
+    def user_credentials
+      Google::Auth::UserRefreshCredentials.new(
+        client_id:     ENV["GOOGLE_CLIENT_ID"] || Rails.application.credentials.dig(:google, :client_id),
+        client_secret: ENV["GOOGLE_CLIENT_SECRET"] || Rails.application.credentials.dig(:google, :client_secret),
+        scope:         [ Google::Apis::CalendarV3::AUTH_CALENDAR_APP_CREATED ],
+        refresh_token: @user.google_refresh_token
+      ).tap(&:fetch_access_token!)
+    end
+
+    def create_app_calendar
+      calendar = @service.insert_calendar(Google::Apis::CalendarV3::Calendar.new(summary: @service.client_options.application_name))
+      # save calendar id to user profile
+      @user.update(calendar_id: calendar.id)
+      calendar.id
+    rescue Google::Apis::ClientError => e
+      # Surface helpful error info to aid debugging 400 errors
+      Rails.logger.error("Google Calendar create_calendar 4xx: #{e.class} #{e.status_code} - #{e.message} body=#{e.body}")
+      raise
+    end
+
+    public
+
+    # Ensure user's app calendar exists if the token has calendar.app.created scope.
+    # Returns the calendar_id if created/found, otherwise nil.
+    def ensure_app_calendar!
+      if @service.authorization.scope.include?(Google::Apis::CalendarV3::AUTH_CALENDAR_APP_CREATED)
+        if @user.calendar_id.nil?
+          @user.calendar_id = create_app_calendar
+        else
+          calendar = @service.get_calendar(@user.calendar_id)
+          if calendar.id != @user.calendar_id
+            @user.calendar_id = create_app_calendar
+          end
+        end
+      end
+      @user.calendar_id
+    end
+  end
+end

data/app/services/collavre/link_preview_fetcher.rb

@@ -0,0 +1,230 @@
+module Collavre
+  require "open-uri"
+  require "nokogiri"
+  require "uri"
+  require "ipaddr"
+  require "resolv"
+
+  class LinkPreviewFetcher
+    USER_AGENT = "Plan42LinkPreview/1.0".freeze
+    OPEN_TIMEOUT = 5
+    READ_TIMEOUT = 5
+    MAX_BYTES = 200_000
+    MAX_REDIRECTS = 3
+    HTML_CONTENT_TYPES = [ "text/html", "application/xhtml+xml" ].freeze
+    REQUEST_OPTIONS = {
+      "User-Agent" => USER_AGENT,
+      "Accept" => "text/html,application/xhtml+xml"
+    }.freeze
+    DISALLOWED_IPV4_RANGES = [
+      IPAddr.new("0.0.0.0/8"),
+      IPAddr.new("100.64.0.0/10"),
+      IPAddr.new("192.0.0.0/24"),
+      IPAddr.new("198.18.0.0/15"),
+      IPAddr.new("224.0.0.0/4"),
+      IPAddr.new("240.0.0.0/4")
+    ].freeze
+    DISALLOWED_IPV6_RANGES = [
+      IPAddr.new("::/128"),
+      IPAddr.new("ff00::/8")
+    ].freeze
+
+    def self.fetch(url)
+      new(url).fetch
+    end
+
+    def initialize(url, io_opener: URI, logger: Rails.logger)
+      @url = url
+      @io_opener = io_opener
+      @logger = logger
+    end
+
+    def fetch
+      uri = safe_http_uri
+      return {} unless uri
+
+      html, base_uri = read_html(uri)
+      return {} if html.blank?
+
+      document = Nokogiri::HTML(html)
+      build_metadata(document, base_uri)
+    rescue StandardError => e
+      @logger&.warn("Link preview fetch failed for #{@url}: #{e.class} #{e.message}")
+      {}
+    end
+
+    private
+
+    def read_html(uri, redirect_limit = MAX_REDIRECTS)
+      html = nil
+      base_uri = nil
+      options = REQUEST_OPTIONS.merge(read_timeout: READ_TIMEOUT, open_timeout: OPEN_TIMEOUT, redirect: false)
+      @io_opener.open(uri.to_s, options) do |io|
+        content_type = io.respond_to?(:content_type) ? io.content_type : nil
+        if content_type && HTML_CONTENT_TYPES.none? { |type| content_type.include?(type) }
+          return [ nil, nil ]
+        end
+        base_uri = io.respond_to?(:base_uri) ? io.base_uri : uri
+        html = io.read(MAX_BYTES)
+      end
+      [ html, base_uri ]
+    rescue OpenURI::HTTPRedirect => e
+      return [ nil, nil ] if redirect_limit <= 0
+
+      redirected_uri = safe_redirect_uri(uri, e.uri)
+      return [ nil, nil ] unless redirected_uri
+
+      read_html(redirected_uri, redirect_limit - 1)
+    rescue OpenURI::HTTPError, SocketError, IOError, SystemCallError, URI::InvalidURIError => e
+      @logger&.info("Link preview fetch skipped for #{@url}: #{e.class} #{e.message}")
+      [ nil, nil ]
+    end
+
+    def safe_http_uri
+      uri = parse_http_uri(@url)
+      return unless uri
+      return unless allowed_destination?(uri)
+
+      uri
+    end
+
+    def safe_redirect_uri(current_uri, redirected)
+      new_uri = normalize_redirect_uri(current_uri, redirected)
+      return unless new_uri
+      return unless allowed_destination?(new_uri)
+
+      new_uri
+    end
+
+    def normalize_redirect_uri(current_uri, redirected)
+      target_uri = redirected.is_a?(URI) ? redirected : URI.parse(redirected.to_s)
+      target_uri = current_uri.merge(target_uri) if target_uri.relative?
+      return unless %w[http https].include?(target_uri.scheme)
+
+      target_uri
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def parse_http_uri(url)
+      uri = URI.parse(url)
+      return unless %w[http https].include?(uri.scheme)
+      return unless uri.hostname && !uri.hostname.empty?
+
+      uri
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def allowed_destination?(uri)
+      host = uri.hostname
+      return false if host.nil? || host.empty?
+
+      addresses = resolve_addresses(host)
+      return false if addresses.empty?
+      return false if addresses.any? { |address| unsafe_ip?(address) }
+
+      true
+    end
+
+    def resolve_addresses(host)
+      Resolv.getaddresses(host).uniq
+    rescue Resolv::ResolvError, SocketError, ArgumentError
+      []
+    end
+
+    def unsafe_ip?(address)
+      ip = IPAddr.new(address)
+      ip = ip.native if ip.ipv4_mapped?
+
+      return true if ip.loopback? || ip.link_local? || ip.private?
+
+      ranges = ip.ipv4? ? DISALLOWED_IPV4_RANGES : DISALLOWED_IPV6_RANGES
+      ranges.any? { |range| range.include?(ip) }
+    rescue IPAddr::InvalidAddressError
+      true
+    end
+
+    def build_metadata(document, base_uri)
+      title = extract_title(document)
+      description = extract_description(document)
+      image_url = extract_image(document, base_uri)
+      site_name = extract_site_name(document)
+
+      metadata = {}
+      metadata[:title] = title if title.present?
+      metadata[:description] = description if description.present?
+      metadata[:image_url] = image_url if image_url.present?
+      metadata[:site_name] = site_name if site_name.present?
+      metadata
+    end
+
+    def extract_title(document)
+      [
+        [ "property", "og:title" ],
+        [ "name", "og:title" ],
+        [ "name", "twitter:title" ],
+        [ "name", "title" ]
+      ].each do |attr, value|
+        node = document.at_css(%(meta[#{attr}="#{value}"]))
+        content = node&.[]("content")
+        return normalize_text(content) if content.present?
+      end
+      title_tag = document.at_css("title")&.text
+      normalize_text(title_tag)
+    end
+
+    def extract_description(document)
+      [
+        [ "property", "og:description" ],
+        [ "name", "og:description" ],
+        [ "name", "description" ],
+        [ "name", "twitter:description" ]
+      ].each do |attr, value|
+        node = document.at_css(%(meta[#{attr}="#{value}"]))
+        content = node&.[]("content")
+        return normalize_text(content) if content.present?
+      end
+      nil
+    end
+
+    def extract_site_name(document)
+      node = document.at_css('meta[property="og:site_name"]')
+      normalize_text(node&.[]("content"))
+    end
+
+    def extract_image(document, base_uri)
+      [
+        [ "property", "og:image" ],
+        [ "name", "og:image" ],
+        [ "name", "twitter:image" ],
+        [ "property", "og:image:url" ]
+      ].each do |attr, value|
+        node = document.at_css(%(meta[#{attr}="#{value}"]))
+        url = node&.[]("content")
+        next if url.blank?
+
+        resolved = resolve_url(url, base_uri)
+        return resolved if resolved.present?
+      end
+      nil
+    end
+
+    def resolve_url(url, base_uri)
+      uri = URI.parse(url)
+      if uri.scheme.blank? && base_uri
+        URI.join(base_uri.to_s, url).to_s
+      else
+        uri.to_s
+      end
+    rescue URI::InvalidURIError
+      nil
+    end
+
+    def normalize_text(text)
+      return if text.blank?
+
+      text.to_s.gsub(/\s+/, " ").strip
+    end
+  end
+end

data/app/services/collavre/markdown_importer.rb

@@ -0,0 +1,202 @@
+module Collavre
+  class MarkdownImporter
+    def self.import(content, parent:, user:, create_root: false)
+      lines = content.to_s.lines
+      image_refs = {}
+      lines.reject! do |ln|
+        if ln =~ /^\s*\[([^\]]+)\]:\s*<\s*(data:image\/[^>]+)\s*>\s*$/
+          image_refs[$1] = $2.strip
+          true
+        else
+          false
+        end
+      end
+      created = []
+      root = parent
+      i = 0
+      if create_root
+        while i < lines.size && lines[i].strip.empty?
+          i += 1
+        end
+        if i < lines.size && lines[i] !~ /^\s*#/ && lines[i] !~ /^\s*[-*+]/
+          page_title = lines[i].strip
+          root = Creative.create(user: user, parent: parent, description: page_title)
+          created << root
+          i += 1
+        end
+      end
+      stack = [ [ 0, root ] ]
+      current_fence = nil
+      while i < lines.size
+        line = lines[i]
+        if (fence_match = line.match(/^\s*(`{3,}|~{3,})/))
+          fence_marker = fence_match[1]
+          fence_char = fence_marker[0]
+          fence_length = fence_marker.length
+          if current_fence.nil?
+            current_fence = { char: fence_char, length: fence_length }
+          elsif current_fence[:char] == fence_char && fence_length >= current_fence[:length]
+            current_fence = nil
+          end
+        end
+
+        if current_fence.nil? && (table_data = parse_markdown_table(lines, i))
+          table_html = build_table_html(table_data, image_refs)
+          new_parent = stack.any? ? stack.last[1] : root
+          c = Creative.create(user: user, parent: new_parent, description: table_html)
+          created << c
+          i = table_data[:next_index]
+        elsif line =~ /^(#+)\s+(.*)$/
+          level = $1.length
+          desc = ApplicationController.helpers.markdown_links_to_html($2.strip, image_refs)
+          stack.pop while stack.any? && stack.last[0] >= level
+          new_parent = stack.any? ? stack.last[1] : root
+          c = Creative.create(user: user, parent: new_parent, description: desc)
+          created << c
+          stack << [ level, c ]
+          i += 1
+        elsif line =~ /^([ \t]*)([-*+])\s+(.*)$/
+          indent = $1.length
+          desc = ApplicationController.helpers.markdown_links_to_html($3.strip, image_refs)
+          bullet_level = 10 + indent / 2
+          stack.pop while stack.any? && stack.last[0] >= bullet_level
+          new_parent = stack.any? ? stack.last[1] : root
+          c = Creative.create(user: user, parent: new_parent, description: desc)
+          created << c
+          stack << [ bullet_level, c ]
+          i += 1
+        elsif !line.strip.empty?
+          desc = ApplicationController.helpers.markdown_links_to_html(line.strip, image_refs)
+          new_parent = stack.any? ? stack.last[1] : root
+          c = Creative.create(user: user, parent: new_parent, description: desc)
+          created << c
+          i += 1
+        else
+          i += 1
+        end
+      end
+      created
+    end
+
+    def self.parse_markdown_table(lines, index)
+      return nil if index >= lines.length
+      header_line = lines[index]
+      return nil unless table_row?(header_line)
+
+      align_index = index + 1
+      return nil if align_index >= lines.length
+      alignment_line = lines[align_index]
+      return nil unless alignment_row?(alignment_line)
+
+      header_cells = split_markdown_table_row(header_line)
+      alignments = parse_alignment_row(alignment_line, header_cells.length)
+
+      rows = []
+      data_index = align_index + 1
+      while data_index < lines.length && table_row?(lines[data_index])
+        rows << split_markdown_table_row(lines[data_index])
+        data_index += 1
+      end
+
+      {
+        header: header_cells,
+        alignments: alignments,
+        rows: rows,
+        next_index: data_index
+      }
+    end
+
+    def self.table_row?(line)
+      return false if line.nil?
+      stripped = line.strip
+      return false if stripped.empty?
+      stripped.include?("|") && split_markdown_table_row(line).any?
+    end
+
+    def self.alignment_row?(line)
+      return false unless table_row?(line)
+      split_markdown_table_row(line).all? do |cell|
+        cell.strip =~ /^:?-{3,}:?$/
+      end
+    end
+
+    def self.split_markdown_table_row(line)
+      body = line.strip
+      body = body.sub(/^\|/, "").sub(/\|\s*$/, "")
+      return [] if body.strip.empty?
+      body.split(/(?<!\\)\|/).map { |cell| cell.gsub(/\\\|/, "|").strip }
+    end
+
+    def self.parse_alignment_row(line, expected_count)
+      cells = split_markdown_table_row(line)
+      cells = cells.first(expected_count)
+      cells.fill("", cells.length...expected_count)
+      cells.map do |cell|
+        trimmed = cell.strip
+        left = trimmed.start_with?(":")
+        right = trimmed.end_with?(":")
+        if left && right
+          :center
+        elsif right
+          :right
+        elsif left
+          :left
+        else
+          nil
+        end
+      end
+    end
+
+    def self.build_table_html(table_data, image_refs)
+      helper = ApplicationController.helpers
+      header_cells = table_data[:header]
+      alignments = table_data[:alignments]
+      rows = table_data[:rows]
+
+      header_html = header_cells.map { |cell| helper.markdown_links_to_html(cell, image_refs) }
+      max_row_length = rows.map(&:length).max || 0
+      column_count = [ header_html.length, max_row_length ].max
+
+      row_html = rows.map do |row|
+        normalized = row.first(column_count)
+        normalized.fill("", normalized.length...column_count)
+        normalized.map { |cell| helper.markdown_links_to_html(cell, image_refs) }
+      end
+
+      column_count = [ column_count, alignments.length ].max
+      alignments = alignments.first(column_count)
+      alignments.fill(nil, alignments.length...column_count)
+
+      build_html_table(header_html, row_html, alignments)
+    end
+
+    def self.build_html_table(header_html, rows_html, alignments)
+      table = +"<table>\n"
+      table << "  <thead>\n"
+      table << "    <tr>"
+      header_html.each_with_index do |cell, idx|
+        table << table_cell_tag("th", cell, alignments[idx])
+      end
+      table << "</tr>\n"
+      table << "  </thead>\n"
+      unless rows_html.empty?
+        table << "  <tbody>\n"
+        rows_html.each do |row|
+          table << "    <tr>"
+          row.each_with_index do |cell, idx|
+            table << table_cell_tag("td", cell, alignments[idx])
+          end
+          table << "</tr>\n"
+        end
+        table << "  </tbody>\n"
+      end
+      table << "</table>"
+      table
+    end
+
+    def self.table_cell_tag(tag_name, content, alignment)
+      align_attr = alignment ? " style=\"text-align: #{alignment};\"" : ""
+      "<#{tag_name}#{align_attr}>#{content}</#{tag_name}>"
+    end
+  end
+end