sincerely 1.0.0 → 1.1.0

data/app/controllers/sincerely/dashboard_controller.rb

@@ -2,111 +2,53 @@
 
 module Sincerely
   class DashboardController < ApplicationController
-    def index
-      filtered_notifications = apply_time_filter(notification_model)
-      filtered_notifications = apply_notification_filter(filtered_notifications)
+    include Concerns::Periods
+    include Concerns::DeliveryMetrics
+    include Concerns::NotificationTimeline
 
+    def index
       @total_notifications = filtered_notifications.count
       @notifications_by_state = filtered_notifications.group(:delivery_state).count
       @recent_notifications = filtered_notifications.order(created_at: :desc).limit(10)
-
-      # Delivery rates
-      total_sent = filtered_notifications.where.not(delivery_state: %w[draft rejected]).count
-      delivered = filtered_notifications.where(delivery_state: %w[delivered opened clicked]).count
-      @delivery_rate = total_sent.positive? ? (delivered.to_f / total_sent * 100).round(1) : 0
-
-      # Engagement rates
-      delivered_count = filtered_notifications.where(delivery_state: %w[delivered opened clicked]).count
-      engaged = filtered_notifications.where(delivery_state: %w[opened clicked]).count
-      @open_rate = delivered_count.positive? ? (engaged.to_f / delivered_count * 100).round(1) : 0
-
-      # Recent events (filtered by user's notifications)
-      user_message_ids = filtered_notifications.where.not(message_id: nil).pluck(:message_id)
-      @recent_delivery_events = apply_time_filter(Sincerely::DeliveryEvent)
-                                .where(message_id: user_message_ids)
-                                .order(created_at: :desc).limit(5)
-      @recent_engagement_events = apply_time_filter(Sincerely::EngagementEvent)
-                                  .where(message_id: user_message_ids)
-                                  .order(created_at: :desc).limit(5)
-
-      # Bounce rate
-      bounced = filtered_notifications.where(delivery_state: 'bounced').count
-      @bounce_rate = total_sent.positive? ? (bounced.to_f / total_sent * 100).round(1) : 0
-
-      # Current period for display
-      @current_period = params[:period] || '24h'
-
+      @delivery_rate = calculate_delivery_rate
+      @open_rate = calculate_open_rate
+      @bounce_rate = calculate_bounce_rate
+      @recent_delivery_events = recent_delivery_events
+      @recent_engagement_events = recent_engagement_events
+      @notifications_by_message_id = preload_notifications_for_events
+      @current_period = current_period
       @notifications_timeline = build_timeline_data(filtered_notifications)
     end
 
     private
 
-    def build_timeline_data(notifications)
-      bucket_config = timeline_bucket_config
-      buckets = generate_time_buckets(bucket_config)
-      interval = bucket_config[:interval]
-      series = {}
-
-      notifications.find_each do |notification|
-        bucket_index = find_bucket_index(notification.created_at, buckets, interval)
-        next if bucket_index.nil?
-
-        state = notification.delivery_state
-        series[state] ||= Array.new(buckets.length, 0)
-        series[state][bucket_index] += 1
-      end
-
-      labels = buckets.map { |b| format_bucket_label(b, bucket_config) }
-
-      { labels:, series:, buckets: }
+    def filtered_notifications
+      @filtered_notifications ||= apply_notification_filter(apply_time_filter(notification_model))
     end
 
-    def timeline_bucket_config
-      period = params[:period]
-      period = '24h' unless %w[1h 24h 7d 30d 3m all].include?(period)
-
-      case 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'
-        { interval: 1.month, format: '%b %Y', start: 1.year.ago }
-      end
+    def user_message_ids_subquery
+      filtered_notifications.where.not(message_id: nil).select(:message_id)
     end
 
-    def generate_time_buckets(config)
-      buckets = []
-      current = config[:start].beginning_of_hour
-      now = Time.current
-
-      while current <= now
-        buckets << current
-        current += config[:interval]
-      end
-
-      buckets
+    def recent_delivery_events
+      apply_time_filter(Sincerely::DeliveryEvent, column: :timestamp)
+        .where(message_id: user_message_ids_subquery)
+        .order(timestamp: :desc)
+        .limit(5)
     end
 
-    def find_bucket_index(time, buckets, interval)
-      return nil if buckets.empty?
-
-      buckets.each_with_index do |bucket_start, index|
-        bucket_end = bucket_start + interval
-        return index if time >= bucket_start && time < bucket_end
-      end
-
-      buckets.length - 1 if time >= buckets.last && time < buckets.last + interval
+    def recent_engagement_events
+      apply_time_filter(Sincerely::EngagementEvent, column: :timestamp)
+        .where(message_id: user_message_ids_subquery)
+        .order(timestamp: :desc)
+        .limit(5)
     end
 
-    def format_bucket_label(bucket, config)
-      bucket.strftime(config[:format])
+    def preload_notifications_for_events
+      message_ids = (@recent_delivery_events + @recent_engagement_events).map(&:message_id).compact.uniq
+      return {} if message_ids.empty?
+
+      notification_model.where(message_id: message_ids).index_by(&:message_id)
     end
   end
 end

data/app/controllers/sincerely/delivery_events_controller.rb

@@ -2,30 +2,22 @@
 
 module Sincerely
   class DeliveryEventsController < ApplicationController
-    def index
-      @events = apply_time_filter(Sincerely::DeliveryEvent).order(created_at: :desc)
-      @events = apply_event_filter(@events)
-
-      @events = @events.where(event_type: params[:event_type]) if params[:event_type].present?
-      @events = @events.where('recipient LIKE ?', "%#{params[:recipient]}%") if params[:recipient].present?
-
-      if params[:template_id].present? || params[:notification_type].present?
-        notification_scope = notification_model.all
-        if params[:template_id].present?
-          notification_scope = notification_scope.where(template_id: params[:template_id])
-        end
-        if params[:notification_type].present?
-          notification_scope = notification_scope.where(notification_type: params[:notification_type])
-        end
-        message_ids = notification_scope.pluck(:message_id).compact
-        @events = @events.where(message_id: message_ids)
-      end
+    include Concerns::Pagination
+    include Concerns::Periods
+    include Concerns::EventFiltering
 
-      @pagination = paginate(@events)
+    def index
+      @pagination = paginate(filtered_events)
       @events = @pagination[:records]
+      @notifications_by_message_id = preload_notifications(@events)
+      @event_types = available_event_types
+      @templates = available_templates
+    end
+
+    private
 
-      @event_types = Sincerely::DeliveryEvent.distinct.pluck(:event_type).compact
-      @templates = Sincerely::Templates::NotificationTemplate.all
+    def event_model
+      Sincerely::DeliveryEvent
     end
   end
 end

data/app/controllers/sincerely/engagement_events_controller.rb

@@ -2,31 +2,22 @@
 
 module Sincerely
   class EngagementEventsController < ApplicationController
-    def index
-      @events = apply_time_filter(Sincerely::EngagementEvent).order(created_at: :desc)
-      @events = apply_event_filter(@events)
-
-      @events = @events.where(event_type: params[:event_type]) if params[:event_type].present?
-      @events = @events.where('recipient LIKE ?', "%#{params[:recipient]}%") if params[:recipient].present?
-
-      # Filter by notification properties via message_id
-      if params[:template_id].present? || params[:notification_type].present?
-        notification_scope = notification_model.all
-        if params[:template_id].present?
-          notification_scope = notification_scope.where(template_id: params[:template_id])
-        end
-        if params[:notification_type].present?
-          notification_scope = notification_scope.where(notification_type: params[:notification_type])
-        end
-        message_ids = notification_scope.pluck(:message_id).compact
-        @events = @events.where(message_id: message_ids)
-      end
+    include Concerns::Pagination
+    include Concerns::Periods
+    include Concerns::EventFiltering
 
-      @pagination = paginate(@events)
+    def index
+      @pagination = paginate(filtered_events)
       @events = @pagination[:records]
+      @notifications_by_message_id = preload_notifications(@events)
+      @event_types = available_event_types
+      @templates = available_templates
+    end
+
+    private
 
-      @event_types = Sincerely::EngagementEvent.distinct.pluck(:event_type).compact
-      @templates = Sincerely::Templates::NotificationTemplate.all
+    def event_model
+      Sincerely::EngagementEvent
     end
   end
 end

data/app/controllers/sincerely/notifications_controller.rb

@@ -2,68 +2,87 @@
 
 module Sincerely
   class NotificationsController < ApplicationController
+    include Concerns::Pagination
+    include Concerns::Periods
+    include Concerns::EventTimeline
+
     def index
-      @notifications = apply_time_filter(notification_model).order(created_at: :desc)
-
-      # Apply host app filter (e.g., filter by logged-in user's email)
-      @notifications = apply_notification_filter(@notifications)
-
-      # Apply filters
-      @notifications = @notifications.where(delivery_state: params[:status]) if params[:status].present?
-      @notifications = @notifications.where(template_id: params[:template_id]) if params[:template_id].present?
-      if params[:recipient].present?
-        @notifications = @notifications.where('recipient LIKE ?',
-                                              "%#{params[:recipient]}%")
-      end
-      if params[:notification_type].present?
-        @notifications = @notifications.where(notification_type: params[:notification_type])
-      end
-
-      @notifications = @notifications.where(created_at: Date.parse(params[:date_from])..) if params[:date_from].present?
-      if params[:date_to].present?
-        @notifications = @notifications.where(created_at: ..Date.parse(params[:date_to]).end_of_day)
-      end
-
-      @pagination = paginate(@notifications)
+      @pagination = paginate(filtered_notifications)
       @notifications = @pagination[:records]
-      @templates = Sincerely::Templates::NotificationTemplate.all
-      @states = notification_model.aasm.states.map(&:name)
+      @templates = available_templates
+      @states = available_states
     end
 
     def show
-      @notification = apply_notification_filter(notification_model).find(params[:id])
+      @notification = find_notification
       @template = @notification.template
-      @timeline = build_event_timeline(@notification)
+      @timeline = build_event_timeline
     end
 
     private
 
-    def build_event_timeline(notification)
-      events = []
-
-      Sincerely::DeliveryEvent.where(message_id: notification.message_id).find_each do |event|
-        events << {
-          type: event.event_type,
-          timestamp: event.timestamp || event.created_at,
-          details: format_event_details(event.options)
-        }
-      end
-
-      Sincerely::EngagementEvent.where(message_id: notification.message_id).find_each do |event|
-        events << {
-          type: event.event_type,
-          timestamp: event.timestamp || event.created_at,
-          details: format_event_details(event.options)
-        }
-      end
-
-      events.sort_by { |e| e[:timestamp] }.reverse
+    def filtered_notifications
+      scope = base_notifications_scope
+      scope = filter_by_status(scope)
+      scope = filter_by_template(scope)
+      scope = filter_by_recipient(scope)
+      scope = filter_by_notification_type(scope)
+      filter_by_date_range(scope)
+    end
+
+    def base_notifications_scope
+      apply_notification_filter(apply_time_filter(notification_model)).includes(:template).order(created_at: :desc)
+    end
+
+    def filter_by_status(scope)
+      return scope if params[:status].blank?
+
+      scope.where(delivery_state: params[:status])
+    end
+
+    def filter_by_template(scope)
+      return scope if params[:template_id].blank?
+
+      scope.where(template_id: params[:template_id])
+    end
+
+    def filter_by_recipient(scope)
+      return scope if params[:recipient].blank?
+
+      scope.where('recipient LIKE ?', "%#{params[:recipient]}%")
     end
 
-    def format_event_details(data)
-      return nil if data.blank?
+    def filter_by_notification_type(scope)
+      return scope if params[:notification_type].blank?
+
+      scope.where(notification_type: params[:notification_type])
+    end
+
+    def filter_by_date_range(scope)
+      date_from = safe_parse_date(params[:date_from])
+      date_to   = safe_parse_date(params[:date_to])
+
+      scope = scope.where(created_at: date_from..) if date_from
+      scope = scope.where(created_at: ..date_to.end_of_day) if date_to
+      scope
+    end
+
+    def safe_parse_date(value)
+      Date.iso8601(value) if value.present?
+    rescue ArgumentError
+      nil
+    end
+
+    def find_notification
+      apply_notification_filter(notification_model).find(params[:id])
+    end
+
+    def available_templates
+      Sincerely::Templates::NotificationTemplate.all
+    end
 
-      data.is_a?(Hash) ? data.map { |k, v| "#{k}: #{v}" }.join(', ') : data.to_s
+    def available_states
+      notification_model.aasm.states.map(&:name)
     end
   end
 end

data/app/controllers/sincerely/send_controller.rb

@@ -3,103 +3,118 @@
 module Sincerely
   class SendController < ApplicationController
     MAX_RECIPIENTS = 50
+    EMAIL_PATTERN = /\A[^@\s]+@[^@\s]+\z/
+    RECIPIENT_DELIMITER = /[\s,;\n]+/
+
+    private_constant :MAX_RECIPIENTS, :EMAIL_PATTERN, :RECIPIENT_DELIMITER
 
     def new
-      @templates = Sincerely::Templates::NotificationTemplate.order(:name)
+      @templates = available_templates
     end
 
     def create
-      recipients = parse_recipients(params[:recipients])
+      return render_error('No valid recipients provided') if recipients.empty?
+      return render_error("Maximum #{MAX_RECIPIENTS} recipients allowed") if recipients.size > MAX_RECIPIENTS
+      return render_error('Template not found') unless template
 
-      if recipients.empty?
-        render json: { success: false, error: 'No valid recipients provided' }, status: :unprocessable_entity
-        return
-      end
+      render json: send_results
+    end
 
-      if recipients.size > MAX_RECIPIENTS
-        render json: { success: false, error: "Maximum #{MAX_RECIPIENTS} recipients allowed" },
-               status: :unprocessable_entity
-        return
-      end
+    def template_variables
+      return render json: { variables: [] } unless template
 
-      template = Sincerely::Templates::NotificationTemplate.find_by(id: params[:template_id])
-      unless template
-        render json: { success: false, error: 'Template not found' }, status: :unprocessable_entity
-        return
-      end
+      render json: { variables: extract_liquid_variables.uniq.sort }
+    end
 
-      template_data = params[:template_data]&.to_unsafe_h || {}
+    private
 
-      results = { sent: 0, failed: 0, errors: [] }
+    def available_templates
+      Sincerely::Templates::NotificationTemplate.order(:name)
+    end
+
+    def template
+      @template ||= Sincerely::Templates::NotificationTemplate.find_by(id: params[:template_id] || params[:id])
+    end
+
+    def recipients
+      @recipients ||= parse_recipients(params[:recipients])
+    end
 
-      recipients.each do |recipient|
-        notification = notification_model.new(
-          recipient:,
-          notification_type: 'email',
-          template_id: template.id,
-          delivery_options: { template_data: }
-        )
-
-        if notification.save
-          begin
-            notification.deliver
-            results[:sent] += 1
-          rescue StandardError => e
-            results[:failed] += 1
-            results[:errors] << { recipient:, error: e.message }
-          end
-        else
-          results[:failed] += 1
-          results[:errors] << { recipient:, error: notification.errors.full_messages.join(', ') }
-        end
+    def template_data
+      @template_data ||= begin
+        raw = params[:template_data]
+        data = case raw
+               when ActionController::Parameters then raw.to_unsafe_h
+               when Hash then raw
+               else {}
+               end
+        allowed_keys = extract_liquid_variables.uniq
+        data.slice(*allowed_keys)
       end
+    end
+
+    def send_results
+      results = { sent: 0, failed: 0, errors: [] }
+
+      recipients.each { |recipient| process_recipient(recipient, results) }
 
-      render json: {
-        success: true,
-        sent: results[:sent],
-        failed: results[:failed],
-        errors: results[:errors].first(5) # Limit error details
-      }
+      { success: true, sent: results[:sent], failed: results[:failed], errors: results[:errors].first(5) }
     end
 
-    def template_variables
-      template = Sincerely::Templates::NotificationTemplate.find_by(id: params[:id])
+    def process_recipient(recipient, results)
+      notification = build_notification(recipient)
 
-      unless template
-        render json: { variables: [] }
-        return
+      if notification.save
+        deliver_notification(notification, recipient, results)
+      else
+        record_failure(results, recipient, notification.errors.full_messages.join(', '))
       end
+    end
 
-      variables = extract_liquid_variables(template)
-      render json: { variables: variables.uniq.sort }
+    def build_notification(recipient)
+      notification_model.new(
+        recipient:,
+        notification_type: 'email',
+        template_id: template.id,
+        delivery_options: { template_data: }
+      )
     end
 
-    private
+    def deliver_notification(notification, recipient, results)
+      notification.deliver
+      results[:sent] += 1
+    rescue StandardError => e
+      Rails.logger.error("Sincerely delivery failed for #{recipient}: #{e.class}: #{e.message}")
+      record_failure(results, recipient, 'Delivery failed')
+    end
+
+    def record_failure(results, recipient, error)
+      results[:failed] += 1
+      results[:errors] << { recipient:, error: }
+    end
+
+    def render_error(message)
+      render json: { success: false, error: message }, status: :unprocessable_entity
+    end
 
     def parse_recipients(input)
       return [] if input.blank?
 
-      # Split by comma, semicolon, space, or newline
-      input.split(/[\s,;\n]+/)
+      input.split(RECIPIENT_DELIMITER)
            .map(&:strip)
            .compact_blank
-           .grep(/\A[^@\s]+@[^@\s]+\z/)
+           .grep(EMAIL_PATTERN)
            .uniq
-           .first(MAX_RECIPIENTS)
     end
 
-    def extract_liquid_variables(template)
-      content = [
-        template.subject,
-        template.html_content,
-        template.text_content
-      ].compact.join(' ')
+    def extract_liquid_variables
+      template_content.scan(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_.]*?)[\s|}]/)
+                      .flatten
+                      .map { |v| v.split('.').first }
+    end
 
-      # Extract {{ variable }} and {{ variable.property }} patterns
-      content.scan(/\{\{\s*([a-zA-Z_][a-zA-Z0-9_]*(?:\.[a-zA-Z_][a-zA-Z0-9_]*)*)\s*\}\}/)
-             .flatten
-             .map { |v| v.split('.').first } # Get root variable name
-             .uniq
+    def template_content
+      [template.subject, template.html_content, template.text_content].compact.join(' ')
     end
   end
 end

data/app/controllers/sincerely/templates_controller.rb

@@ -2,15 +2,17 @@
 
 module Sincerely
   class TemplatesController < ApplicationController
+    include Concerns::Pagination
+
     before_action :set_template, only: %i[show edit update preview]
 
     def index
-      @pagination = paginate(Sincerely::Templates::NotificationTemplate.order(created_at: :desc))
+      @pagination = paginate(all_templates)
       @templates = @pagination[:records]
     end
 
     def show
-      @notification_count = notification_model.where(template_id: @template.id).count
+      @notification_count = template_notification_count
     end
 
     def new
@@ -38,14 +40,13 @@ module Sincerely
     end
 
     def preview
-      sample_data = params[:sample_data].present? ? JSON.parse(params[:sample_data]) : {}
-      @rendered_subject = @template.renderer.render(@template.subject || '', { 'template_data' => sample_data })
-      @rendered_html = @template.render(:html, { 'template_data' => sample_data })
-      @rendered_text = @template.render(:text, { 'template_data' => sample_data })
-
-      render layout: false
+      render_preview
     rescue JSON::ParserError
       render plain: 'Invalid JSON in sample data', status: :bad_request
+    rescue ArgumentError => e
+      render plain: e.message, status: :bad_request
+    rescue Liquid::Error => e
+      render plain: "Template rendering error: #{e.message}", status: :unprocessable_entity
     end
 
     private
@@ -57,5 +58,33 @@ module Sincerely
     def template_params
       params.require(:template).permit(:name, :subject, :sender, :html_content, :text_content)
     end
+
+    def all_templates
+      Sincerely::Templates::NotificationTemplate.order(created_at: :desc)
+    end
+
+    def template_notification_count
+      notification_model.where(template_id: @template.id).count
+    end
+
+    def render_preview
+      @rendered_subject = @template.renderer.render(@template.subject || '', preview_context)
+      @rendered_html = @template.render(:html, preview_context)
+      @rendered_text = @template.render(:text, preview_context)
+      render layout: false
+    end
+
+    def preview_context
+      { 'template_data' => parsed_sample_data }
+    end
+
+    def parsed_sample_data
+      return {} if params[:sample_data].blank?
+
+      parsed = JSON.parse(params[:sample_data])
+      raise ArgumentError, 'Sample data must be a JSON object' unless parsed.is_a?(Hash)
+
+      parsed
+    end
   end
 end

data/app/helpers/sincerely/application_helper.rb

@@ -17,12 +17,34 @@ module Sincerely
       end
     end
 
+    def inline_svg(name)
+      return '' unless name.match?(%r{\A[a-z0-9_\-/]+\z}i) && name.exclude?('..')
+
+      base = Sincerely::Engine.root.join('app', 'assets', 'images')
+      path = base.join("#{name}.svg")
+      return '' unless path.to_s.start_with?(base.to_s) && path.exist?
+
+      raw path.read # rubocop:disable Rails/OutputSafety -- SVGs are read from the engine's own assets, not user input
+    end
+
     def format_timestamp(time)
       return '-' unless time
 
       time.strftime('%b %d, %Y %H:%M:%S')
     end
 
+    def event_timestamp(event)
+      event.timestamp || event.created_at
+    end
+
+    def format_event_options(options)
+      return nil if options.blank?
+
+      JSON.pretty_generate(options)
+    rescue JSON::GeneratorError
+      options.to_s
+    end
+
     def event_type_badge_class(event_type)
       case event_type.to_s.downcase
       when 'delivery', 'send' then 'badge-delivered'