sincerely 1.0.0 → 1.1.0

data/app/assets/stylesheets/sincerely/template_form.css

@@ -0,0 +1,74 @@
+.preview-tabs {
+  display: flex;
+  gap: 0;
+  margin-bottom: -1px;
+  position: relative;
+  z-index: 1;
+}
+
+.preview-tab {
+  padding: 0.5rem 1rem;
+  background: var(--bg-secondary);
+  border: 1px solid var(--border-color);
+  border-bottom: none;
+  border-radius: 0.375rem 0.375rem 0 0;
+  cursor: pointer;
+  font-size: 0.8125rem;
+  font-weight: 500;
+  color: var(--text-secondary);
+  transition: all 0.15s;
+  display: flex;
+  align-items: center;
+  gap: 0.375rem;
+}
+
+.preview-tab:hover {
+  color: var(--text-primary);
+}
+
+.preview-tab.active {
+  background: var(--bg-primary);
+  color: var(--primary);
+  border-bottom: 1px solid var(--bg-primary);
+}
+
+.preview-tab svg {
+  width: 0.875rem;
+  height: 0.875rem;
+}
+
+.preview-container {
+  position: relative;
+}
+
+.preview-panel {
+  display: none;
+}
+
+.preview-panel.active {
+  display: block;
+}
+
+.preview-frame {
+  width: 100%;
+  min-height: 300px;
+  border: 1px solid var(--border-color);
+  border-radius: 0 0.375rem 0.375rem 0.375rem;
+  background: #ffffff;
+}
+
+.preview-text {
+  width: 100%;
+  min-height: 200px;
+  padding: 1rem;
+  border: 1px solid var(--border-color);
+  border-radius: 0 0.375rem 0.375rem 0.375rem;
+  background: var(--bg-primary);
+  font-family: 'SF Mono', Consolas, monospace;
+  font-size: 0.8125rem;
+  white-space: pre-wrap;
+  word-break: break-word;
+  color: var(--text-primary);
+  margin: 0;
+  overflow: auto;
+}

data/app/assets/stylesheets/sincerely/template_preview.css

@@ -0,0 +1,75 @@
+body {
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+  margin: 0;
+  padding: 0;
+  background: #f5f5f5;
+}
+
+.preview-header {
+  background: #1f2937;
+  color: white;
+  padding: 1rem 2rem;
+}
+
+.preview-header h1 {
+  margin: 0;
+  font-size: 1.25rem;
+}
+
+.preview-meta {
+  margin-top: 0.5rem;
+  font-size: 0.875rem;
+  opacity: 0.8;
+}
+
+.preview-tabs {
+  display: flex;
+  gap: 0;
+  background: #374151;
+}
+
+.preview-tab {
+  padding: 0.75rem 1.5rem;
+  color: #9ca3af;
+  cursor: pointer;
+  border: none;
+  background: none;
+  font-size: 0.875rem;
+}
+
+.preview-tab.active {
+  color: white;
+  background: #4f46e5;
+}
+
+.preview-content {
+  padding: 2rem;
+}
+
+.preview-frame {
+  background: white;
+  border-radius: 8px;
+  box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+  overflow: hidden;
+}
+
+.preview-frame-html {
+  padding: 0;
+}
+
+.preview-frame-html iframe {
+  width: 100%;
+  height: 600px;
+  border: none;
+}
+
+.preview-frame--hidden {
+  display: none;
+}
+
+.preview-frame-text {
+  padding: 2rem;
+  white-space: pre-wrap;
+  font-family: monospace;
+  background: #fafafa;
+}

data/app/assets/stylesheets/sincerely/variables.css

@@ -0,0 +1,88 @@
+:root {
+  --primary: #d4183d;
+  --primary-dark: #70041e;
+  --success: #8acb88;
+  --warning: #78c6cc;
+  --danger: #d4183d;
+  --gray-50: #f9fafb;
+  --gray-100: #f3f4f6;
+  --gray-200: #e5e7eb;
+  --gray-300: #d1d5db;
+  --gray-500: #6b7280;
+  --gray-700: #374151;
+  --gray-900: #111827;
+  --bg-primary: #ffffff;
+  --bg-secondary: #e6e6e6;
+  --text-primary: #70041e;
+  --text-secondary: #717182;
+  --border-color: #e5e7eb;
+
+  --success-bg: #d1fae5;
+  --success-text: #047857;
+  --warning-bg: #fef3c7;
+  --warning-text: #b45309;
+  --danger-bg: #fee2e2;
+  --danger-text: #dc2626;
+  --danger-border: #fecaca;
+  --info-bg: #dbeafe;
+  --info-text: #1d4ed8;
+  --purple-bg: #ddd6fe;
+  --purple-text: #7c3aed;
+}
+
+[data-theme="dark"] {
+  --primary: #d4183d;
+  --primary-dark: #490c13;
+  --gray-50: #1f2937;
+  --gray-100: #374151;
+  --gray-200: #4b5563;
+  --gray-300: #6b7280;
+  --gray-500: #9ca3af;
+  --gray-700: #d1d5db;
+  --gray-900: #f9fafb;
+  --bg-primary: #1e1e1e;
+  /* --bg-primary: #9393a1; */
+  --bg-secondary: #303030;
+  /* --bg-secondary: #1e1e1e; */
+  --text-primary: #f9fafb;
+  --text-secondary: #9ca3af;
+  --border-color: #374151;
+}
+
+* {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+
+html,
+body {
+  height: 100%;
+}
+
+body {
+  font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+  background: var(--bg-secondary);
+  color: var(--text-primary);
+  line-height: 1.5;
+  transition: background-color 0.3s, color 0.3s;
+  display: flex;
+  flex-direction: column;
+  overflow: hidden;
+}
+
+@media (max-width: 768px) {
+  body {
+    overflow: auto;
+  }
+}
+
+a {
+  color: var(--primary);
+}
+
+.container {
+  max-width: 1280px;
+  margin: 0 auto;
+  padding: 0 1rem;
+}

data/app/controllers/sincerely/application_controller.rb

@@ -2,80 +2,11 @@
 
 module Sincerely
   class ApplicationController < ActionController::Base
+    include Concerns::Authorization
+    include Concerns::Notifications
+
     protect_from_forgery with: :exception
 
     layout 'sincerely/application'
-
-    before_action :authenticate_user!
-
-    helper_method :notification_model
-
-    private
-
-    def authenticate_user!
-      return unless Sincerely.authenticate_with
-
-      instance_exec(&Sincerely.authenticate_with)
-    end
-
-    def notification_model
-      @notification_model ||= Sincerely.notification_model
-    end
-
-    def paginate(collection, per_page: 25)
-      page = (params[:page] || 1).to_i
-      offset = (page - 1) * per_page
-      total = collection.count
-
-      {
-        records: collection.offset(offset).limit(per_page),
-        total_count: total,
-        current_page: page,
-        per_page:,
-        total_pages: (total.to_f / per_page).ceil
-      }
-    end
-
-    def time_filter_start
-      period = params[:period]
-      period = '24h' unless %w[1h 24h 7d 30d 3m all].include?(period)
-
-      case period
-      when '1h' then 1.hour.ago
-      when '24h' then 24.hours.ago
-      when '7d' then 7.days.ago
-      when '30d' then 30.days.ago
-      when '3m' then 3.months.ago
-      when 'all' then nil
-      end
-    end
-
-    def apply_time_filter(collection, column: :created_at)
-      start_time = time_filter_start
-      return collection unless start_time
-
-      collection.where("#{column} >= ?", start_time)
-    end
-
-    def apply_notification_filter(scope)
-      filter = Sincerely.config.filter_notifications_by
-      return scope unless filter.respond_to?(:call)
-
-      conditions = instance_exec(&filter)
-      return scope if conditions.blank?
-
-      scope.where(conditions)
-    end
-
-    def apply_event_filter(scope)
-      filter = Sincerely.config.filter_notifications_by
-      return scope unless filter.respond_to?(:call)
-
-      conditions = instance_exec(&filter)
-      return scope if conditions.blank?
-
-      message_ids = notification_model.where(conditions).where.not(message_id: nil).pluck(:message_id)
-      scope.where(message_id: message_ids)
-    end
   end
 end

data/app/controllers/sincerely/concerns/authorization.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Concerns
+    module Authorization
+      extend ActiveSupport::Concern
+
+      included do
+        before_action :authenticate_sincerely_user!
+      end
+
+      private
+
+      def authenticate_sincerely_user!
+        return unless Sincerely.authenticate_with
+
+        instance_exec(&Sincerely.authenticate_with)
+      end
+    end
+  end
+end

data/app/controllers/sincerely/concerns/delivery_metrics.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Concerns
+    module DeliveryMetrics
+      extend ActiveSupport::Concern
+
+      EXCLUDED_FROM_SENT = %w[draft rejected].freeze
+      DELIVERED_STATES = %w[delivered opened clicked].freeze
+      ENGAGED_STATES = %w[opened clicked].freeze
+
+      private_constant :EXCLUDED_FROM_SENT, :DELIVERED_STATES, :ENGAGED_STATES
+
+      private
+
+      def calculate_delivery_rate
+        percentage(delivered_count, total_sent)
+      end
+
+      def calculate_open_rate
+        percentage(engaged_count, delivered_count)
+      end
+
+      def calculate_bounce_rate
+        percentage(bounced_count, total_sent)
+      end
+
+      def total_sent
+        @total_sent ||= filtered_notifications.where.not(delivery_state: EXCLUDED_FROM_SENT).count
+      end
+
+      def delivered_count
+        @delivered_count ||= filtered_notifications.where(delivery_state: DELIVERED_STATES).count
+      end
+
+      def engaged_count
+        @engaged_count ||= filtered_notifications.where(delivery_state: ENGAGED_STATES).count
+      end
+
+      def bounced_count
+        @bounced_count ||= filtered_notifications.where(delivery_state: 'bounced').count
+      end
+
+      def percentage(numerator, denominator)
+        return 0 unless denominator.positive?
+
+        (numerator.to_f / denominator * 100).round(1)
+      end
+    end
+  end
+end

data/app/controllers/sincerely/concerns/event_filtering.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Concerns
+    module EventFiltering
+      extend ActiveSupport::Concern
+
+      private
+
+      def filtered_events
+        scope = apply_event_filter(apply_time_filter(event_model, column: :timestamp)).order(timestamp: :desc)
+        scope = filter_by_event_type(scope)
+        scope = filter_by_recipient(scope)
+        filter_by_notification_attributes(scope)
+      end
+
+      def filter_by_event_type(scope)
+        return scope if params[:event_type].blank?
+
+        scope.where(event_type: params[:event_type])
+      end
+
+      def filter_by_recipient(scope)
+        return scope if params[:recipient].blank?
+
+        scope.where('recipient LIKE ?', "%#{params[:recipient]}%")
+      end
+
+      def filter_by_notification_attributes(scope)
+        return scope unless params[:template_id].present? || params[:notification_type].present?
+
+        scope.where(message_id: filtered_message_ids)
+      end
+
+      def filtered_message_ids
+        scope = notification_model.all
+        scope = scope.where(template_id: params[:template_id]) if params[:template_id].present?
+        scope = scope.where(notification_type: params[:notification_type]) if params[:notification_type].present?
+        scope.where.not(message_id: nil).select(:message_id)
+      end
+
+      def preload_notifications(events)
+        message_ids = events.map(&:message_id).compact.uniq
+        return {} if message_ids.empty?
+
+        notification_model.where(message_id: message_ids).index_by(&:message_id)
+      end
+
+      def available_event_types
+        event_model.distinct.pluck(:event_type).compact
+      end
+
+      def available_templates
+        Sincerely::Templates::NotificationTemplate.all
+      end
+    end
+  end
+end

data/app/controllers/sincerely/concerns/event_timeline.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Concerns
+    module EventTimeline
+      extend ActiveSupport::Concern
+
+      private
+
+      def build_event_timeline
+        (delivery_events + engagement_events).sort_by { |e| e[:timestamp] }.reverse
+      end
+
+      def delivery_events
+        events_for_model(Sincerely::DeliveryEvent)
+      end
+
+      def engagement_events
+        events_for_model(Sincerely::EngagementEvent)
+      end
+
+      def events_for_model(model)
+        return [] if @notification.message_id.nil?
+
+        model.where(message_id: @notification.message_id).map do |event|
+          {
+            type: event.event_type,
+            timestamp: event.timestamp || event.created_at,
+            details: format_event_details(event.options)
+          }
+        end
+      end
+
+      def format_event_details(data)
+        return nil if data.blank?
+
+        data.is_a?(Hash) ? data.map { |k, v| "#{k}: #{v}" }.join(', ') : data.to_s
+      end
+    end
+  end
+end

data/app/controllers/sincerely/concerns/notification_timeline.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Concerns
+    module NotificationTimeline
+      extend ActiveSupport::Concern
+
+      private
+
+      def build_timeline_data(notifications)
+        buckets = generate_time_buckets
+        series = build_timeline_series(notifications, buckets)
+        labels = buckets.map { |b| b.strftime(timeline_bucket_config[:format]) }
+
+        { labels:, series:, buckets: }
+      end
+
+      def build_timeline_series(notifications, buckets)
+        return {} if buckets.empty?
+
+        interval = timeline_bucket_config[:interval].to_i
+        start_epoch = buckets.first.to_i
+
+        counts = notifications
+                 .unscope(:order)
+                 .group(:delivery_state, bucket_index_sql(start_epoch, interval))
+                 .count
+
+        counts.each_with_object({}) do |((state, raw_idx), count), series|
+          idx = raw_idx.to_i
+          next unless idx >= 0 && idx < buckets.length
+
+          series[state] ||= Array.new(buckets.length, 0)
+          series[state][idx] = count
+        end
+      end
+
+      def timeline_bucket_config
+        @timeline_bucket_config ||= case current_period
+                                    when '1h'
+                                      { interval: 5.minutes, format: '%H:%M', start: 1.hour.ago }
+                                    when '24h'
+                                      { interval: 1.hour, format: '%H:%M', start: 24.hours.ago }
+                                    when '7d'
+                                      { interval: 6.hours, format: '%a %H:%M', start: 7.days.ago }
+                                    when '30d'
+                                      { interval: 1.day, format: '%b %d', start: 30.days.ago }
+                                    when '3m'
+                                      { interval: 1.week, format: '%b %d', start: 3.months.ago }
+                                    when 'all'
+                                      oldest = filtered_notifications.minimum(:created_at) || 1.year.ago
+                                      { interval: 1.month, format: '%b %Y', start: oldest }
+                                    end
+      end
+
+      def generate_time_buckets
+        config = timeline_bucket_config
+        interval = config[:interval].to_i
+        start_epoch = (config[:start].to_i / interval) * interval
+        (start_epoch..Time.current.to_i).step(interval).map { |t| Time.zone.at(t) }
+      end
+
+      def bucket_index_sql(start_epoch, interval)
+        epoch_sql = case ActiveRecord::Base.connection.adapter_name.downcase
+                    when 'postgresql' then 'FLOOR(EXTRACT(EPOCH FROM created_at))'
+                    when 'mysql2'     then 'FLOOR(UNIX_TIMESTAMP(created_at))'
+                    else                   "CAST(strftime('%s', created_at) AS INTEGER)"
+                    end
+        Arel.sql("FLOOR((#{epoch_sql} - #{start_epoch}) / #{interval})")
+      end
+    end
+  end
+end

data/app/controllers/sincerely/concerns/notifications.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Concerns
+    module Notifications
+      extend ActiveSupport::Concern
+
+      included do
+        helper_method :notification_model
+      end
+
+      private
+
+      def notification_model
+        @notification_model ||= Sincerely.notification_model
+      end
+
+      def apply_notification_filter(scope)
+        return scope unless notification_filter_callable?
+
+        conditions = notification_filter_conditions
+        conditions.blank? ? scope : scope.where(conditions)
+      end
+
+      def apply_event_filter(scope)
+        return scope unless notification_filter_callable?
+
+        conditions = notification_filter_conditions
+        return scope if conditions.blank?
+
+        scope.where(message_id: filtered_message_ids_for_events(conditions))
+      end
+
+      def notification_filter_callable?
+        Sincerely.config.filter_notifications_by.respond_to?(:call)
+      end
+
+      def notification_filter_conditions
+        instance_exec(&Sincerely.config.filter_notifications_by)
+      end
+
+      def filtered_message_ids_for_events(conditions)
+        notification_model.where(conditions).where.not(message_id: nil).select(:message_id).distinct
+      end
+    end
+  end
+end

data/app/controllers/sincerely/concerns/pagination.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Concerns
+    module Pagination
+      extend ActiveSupport::Concern
+
+      DEFAULT_PER_PAGE = 25
+      private_constant :DEFAULT_PER_PAGE
+
+      private
+
+      def paginate(collection, per_page: DEFAULT_PER_PAGE)
+        page = current_page
+        total = collection.count
+
+        {
+          records: collection.offset(page_offset(page, per_page)).limit(per_page),
+          total_count: total,
+          current_page: page,
+          per_page:,
+          total_pages: total_pages(total, per_page)
+        }
+      end
+
+      def current_page
+        [(params[:page] || 1).to_i, 1].max
+      end
+
+      def page_offset(page, per_page)
+        (page - 1) * per_page
+      end
+
+      def total_pages(total, per_page)
+        (total.to_f / per_page).ceil
+      end
+    end
+  end
+end

data/app/controllers/sincerely/concerns/periods.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Sincerely
+  module Concerns
+    module Periods
+      extend ActiveSupport::Concern
+
+      VALID_PERIODS = %w[1h 24h 7d 30d 3m all].freeze
+      DEFAULT_PERIOD = '24h'
+
+      PERIOD_DURATIONS = {
+        '1h' => 1.hour,
+        '24h' => 24.hours,
+        '7d' => 7.days,
+        '30d' => 30.days,
+        '3m' => 3.months,
+        'all' => nil
+      }.freeze
+
+      private_constant :VALID_PERIODS, :DEFAULT_PERIOD, :PERIOD_DURATIONS
+
+      private
+
+      def current_period
+        VALID_PERIODS.include?(params[:period]) ? params[:period] : DEFAULT_PERIOD
+      end
+
+      def time_filter_start
+        duration = PERIOD_DURATIONS[current_period]
+        duration&.ago
+      end
+
+      def apply_time_filter(collection, column: :created_at)
+        return collection.all unless time_filter_start
+
+        collection.where("#{column} >= ?", time_filter_start)
+      end
+    end
+  end
+end