sage-rails 0.0.3

data/app/controllers/sage/dashboards_controller.rb

@@ -0,0 +1,130 @@
+module Sage
+  class DashboardsController < BaseController
+    before_action :set_dashboard, only: [:show, :edit, :update, :destroy, :refresh]
+
+    def index
+      @q = Blazer::Dashboard.ransack(params[:q])
+      @dashboards = @q.result
+      
+      # Only include creator if Blazer.user_class is configured
+      @dashboards = @dashboards.includes(:creator) if Blazer.user_class
+      
+      @dashboards = @dashboards.order(:name)
+      
+      # Apply additional filters if needed
+      if blazer_user && params[:filter] == "mine"
+        @dashboards = @dashboards.where(creator_id: blazer_user.id).reorder(updated_at: :desc)
+      end
+      
+      # Apply pagination with Pagy
+      @pagy, @dashboards = pagy(@dashboards)
+    end
+
+    def new
+      @dashboard = Blazer::Dashboard.new
+    end
+
+    def create
+      @dashboard = Blazer::Dashboard.new
+      # use creator_id instead of creator
+      # since we setup association without checking if column exists
+      @dashboard.creator = blazer_user if @dashboard.respond_to?(:creator_id=) && blazer_user
+
+      if update_dashboard(@dashboard)
+        redirect_to dashboard_path(@dashboard)
+      else
+        render_errors @dashboard
+      end
+    end
+
+    def show
+      @queries = @dashboard.dashboard_queries.order(:position).preload(:query).map(&:query)
+      @query_errors = {}
+      
+      @queries.each do |query|
+        # Check if the query has a valid data source
+        if query.data_source.blank? || !Blazer.data_sources.key?(query.data_source)
+          @query_errors[query.id] = "Invalid or missing data source: #{query.data_source.inspect}"
+        else
+          @success = process_vars(query.statement_object)
+        end
+      end
+      @bind_vars ||= []
+
+      @smart_vars = {}
+      @sql_errors = []
+      @data_sources = @queries.map { |q| 
+        # Use the query's data source if specified, otherwise use the default
+        source = q.data_source.presence || Blazer.data_sources.keys.first
+        Blazer.data_sources[source]
+      }.compact.uniq
+      
+      @bind_vars.each do |var|
+        @data_sources.each do |data_source|
+          smart_var, error = parse_smart_variables(var, data_source)
+          ((@smart_vars[var] ||= []).concat(smart_var)).uniq! if smart_var
+          @sql_errors << error if error
+        end
+      end
+
+      add_cohort_analysis_vars if @queries.any?(&:cohort_analysis?)
+    end
+
+    def edit
+    end
+
+    def update
+      if update_dashboard(@dashboard)
+        redirect_to dashboard_path(@dashboard, params: variable_params(@dashboard))
+      else
+        render_errors @dashboard
+      end
+    end
+
+    def destroy
+      @dashboard.destroy
+      redirect_to root_path
+    end
+
+    def refresh
+      @dashboard.queries.each do |query|
+        refresh_query(query)
+      end
+      redirect_to dashboard_path(@dashboard, params: variable_params(@dashboard))
+    end
+
+    private
+
+    def dashboard_params
+      params.require(:dashboard).permit(:name)
+    end
+
+    def set_dashboard
+      @dashboard = Blazer::Dashboard.find(params[:id])
+    end
+
+    def update_dashboard(dashboard)
+      dashboard.assign_attributes(dashboard_params)
+      Blazer::Dashboard.transaction do
+        if params[:query_ids].is_a?(Array)
+          query_ids = params[:query_ids].map(&:to_i)
+          @queries = Blazer::Query.find(query_ids).sort_by { |q| query_ids.index(q.id) }
+        end
+        if dashboard.save
+          if @queries
+            @queries.each_with_index do |query, i|
+              dashboard_query = dashboard.dashboard_queries.where(query_id: query.id).first_or_initialize
+              dashboard_query.position = i
+              dashboard_query.save!
+            end
+            if dashboard.persisted?
+              dashboard.dashboard_queries.where.not(query_id: query_ids).destroy_all
+            end
+          end
+          true
+        end
+      end
+    end
+  end
+end
+

data/app/controllers/sage/queries/messages_controller.rb

@@ -0,0 +1,62 @@
+
+module Sage
+  module Queries
+    class MessagesController < BaseController
+      before_action :set_query
+
+      def index
+        page = params[:page] || 1
+
+        # For reverse infinite scroll, we want:
+        # Page 1: Most recent messages (to show at bottom initially)
+        # Page 2: Older messages (to prepend when scrolling up)
+        # Page 3: Even older messages, etc.
+
+        base_query = @query.messages.order(created_at: :desc)
+        @pagy, messages = pagy(base_query, page: page, overflow: :last_page)
+
+        # For page 1 (initial load), show newest messages in chronological order (oldest first)
+        # For page 2+, keep reverse chronological order for prepending
+        if page.to_i == 1
+          @messages = messages.reverse # Show oldest first for initial display
+        else
+          @messages = messages # Keep newest first for prepending
+        end
+
+        respond_to do |format|
+          format.html # For turbo_frame initial load
+          format.turbo_stream # For infinite scroll pagination
+        end
+      end
+
+      def create
+        @message = @query.messages.create!(body: params[:statement])
+        creator_id = blazer_user.present? ? blazer_user.id : 0
+
+        @message.creator_id = creator_id
+        @message.save!
+        @message.reload
+
+        stream_target_id = SecureRandom.hex(8)
+
+        Sage::ProcessReportJob.perform_later(
+          @message.body,
+          query_id: @message.blazer_query.id,
+          stream_target_id:
+        )
+
+        # Check if we need a new day separator
+        @need_day_separator = @query.messages.where(
+          "DATE(created_at) = ?",
+          @message.created_at.to_date
+        ).count == 1
+      end
+
+      private
+
+      def set_query
+        @query = Blazer::Query.find(params[:query_id])
+      end
+    end
+  end
+end