mat_views 0.2.0 → 0.3.0

data/app/controllers/mat_views/admin/mat_view_definitions_controller.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+module MatViews
+  module Admin
+    # MatViews::Admin::MatViewDefinitionsController
+    # ---------------------------------------------
+    # Admin CRUD controller for {MatViews::MatViewDefinition} records.
+    #
+    # Responsibilities:
+    # - Full CRUD lifecycle: index, show, new, create, edit, update, destroy.
+    # - Admin-only actions to trigger materialised view operations:
+    #   - {#create_now} → enqueues {MatViews::CreateViewJob}
+    #   - {#refresh} → enqueues {MatViews::RefreshViewJob}
+    #   - {#delete_now} → enqueues {MatViews::DeleteViewJob}
+    # - Integrates with Turbo Frames (uses frame-aware redirects/responses).
+    # - Normalizes array fields (`unique_index_columns`, `dependencies`) from
+    #   comma-separated params into arrays.
+    #
+    # Filters:
+    # - `before_action :set_definition` for member actions.
+    # - `before_action :normalize_array_fields` for create/update.
+    # - `before_action :ensure_frame` to enforce frame context.
+    #
+    class MatViewDefinitionsController < ApplicationController
+      before_action :set_definition, only: %i[show edit update destroy create_now refresh delete_now]
+      before_action :normalize_array_fields, only: %i[create update]
+      before_action :ensure_frame
+
+      # GET /:lang/admin/definitions
+      #
+      # Lists all definitions with existence checks against the database.
+      #
+      # @return [void]
+      def index
+        # sleep 20
+        authorize_mat_views!(:read, MatViews::MatViewDefinition)
+        @definitions = MatViews::MatViewDefinition.order(:name).to_a
+        @mv_exists_map = @definitions.index_with do |defn|
+          MatViews::Services::CheckMatviewExists.new(defn).call.response[:exists]
+        end
+        render 'index', formats: :html, layout: 'mat_views/turbo_frame'
+      end
+
+      # GET /:lang/admin/definitions/:id
+      #
+      # Shows a single definition, including run history.
+      #
+      # @return [void]
+      def show
+        authorize_mat_views!(:read, @definition)
+        @mv_exists = MatViews::Services::CheckMatviewExists.new(@definition).call.response[:exists]
+        @runs = @definition.mat_view_runs.order(created_at: :desc).to_a
+        render 'show', formats: :html, layout: 'mat_views/turbo_frame'
+      end
+
+      # GET /:lang/admin/definitions/new
+      #
+      # Renders the new definition form.
+      #
+      # @return [void]
+      def new
+        authorize_mat_views!(:create, MatViews::MatViewDefinition)
+        @definition = MatViews::MatViewDefinition.new
+        render 'form', formats: :html, layout: 'mat_views/turbo_frame'
+      end
+
+      # POST /:lang/admin/definitions
+      #
+      # Creates a new definition from params.
+      #
+      # @return [void]
+      def create
+        authorize_mat_views!(:create, MatViews::MatViewDefinition)
+        @definition = MatViews::MatViewDefinition.new(definition_params)
+        if @definition.save
+          handle_frame_response(status: 298)
+        else
+          render 'form', formats: :html, layout: 'mat_views/turbo_frame', status: :unprocessable_content
+        end
+      end
+
+      # GET /:lang/admin/definitions/:id/edit
+      #
+      # Renders the edit form for an existing definition.
+      #
+      # @return [void]
+      def edit
+        authorize_mat_views!(:update, @definition)
+        render 'form', formats: :html, layout: 'mat_views/turbo_frame'
+      end
+
+      # PATCH/PUT /:lang/admin/definitions/:id
+      #
+      # Updates an existing definition.
+      #
+      # @return [void]
+      def update
+        authorize_mat_views!(:update, @definition)
+        if @definition.update(definition_params)
+          handle_frame_response(status: 298)
+        else
+          render 'form', formats: :html, layout: 'mat_views/turbo_frame', status: :unprocessable_content
+        end
+      end
+
+      # DELETE /:lang/admin/definitions/:id
+      #
+      # Destroys the definition. Frame-specific redirect/empty response.
+      #
+      # @return [void]
+      def destroy
+        authorize_mat_views!(:destroy, @definition)
+        @definition.destroy!
+        if @frame_id == 'dash-definitions'
+          redirect_to admin_mat_view_definitions_path(frame_id: @frame_id, frame_action: @frame_action), status: :see_other
+        else
+          render 'empty', formats: :html, layout: 'mat_views/turbo_frame', status: 298
+        end
+      end
+
+      # POST /:lang/admin/definitions/:id/create_now
+      #
+      # Immediately enqueues a background job to create the materialised view.
+      #
+      # @return [void]
+      def create_now
+        force = params[:force].to_s.downcase == 'true'
+        authorize_mat_views!(:create_view, @definition)
+        MatViews::Jobs::Adapter.enqueue(
+          MatViews::CreateViewJob,
+          queue: MatViews.configuration.job_queue,
+          args: [@definition.id, force, row_count_strategy]
+        )
+        handle_frame_response
+      end
+
+      # POST /:lang/admin/definitions/:id/refresh
+      #
+      # Immediately enqueues a background job to refresh the materialised view.
+      #
+      # @return [void]
+      def refresh
+        authorize_mat_views!(:refresh, @definition)
+        MatViews::Jobs::Adapter.enqueue(
+          MatViews::RefreshViewJob,
+          queue: MatViews.configuration.job_queue,
+          args: [@definition.id, row_count_strategy]
+        )
+        handle_frame_response
+      end
+
+      # POST /:lang/admin/definitions/:id/delete_now
+      #
+      # Immediately enqueues a background job to delete the materialised view.
+      #
+      # @return [void]
+      def delete_now
+        authorize_mat_views!(:delete_view, @definition)
+
+        cascade = params[:cascade].to_s.downcase == 'true'
+        MatViews::Jobs::Adapter.enqueue(
+          MatViews::DeleteViewJob,
+          queue: MatViews.configuration.job_queue,
+          args: [@definition.id, cascade, row_count_strategy]
+        )
+        handle_frame_response
+      end
+
+      private
+
+      # Returns the configured row count strategy for admin UI operations.
+      #
+      # @api private
+      #
+      # @return [Symbol, nil] row count strategy (e.g., :estimated, :exact, :none)
+      def row_count_strategy
+        MatViews.configuration.admin_ui[:row_count_strategy] || :none
+      end
+
+      # Handles redirect/response after a frame-based action.
+      #
+      # @api private
+      #
+      # @param status [Symbol,Integer] the HTTP status for redirect
+      # @return [void]
+      def handle_frame_response(status: :see_other)
+        if @frame_id == 'dash-definitions'
+          redirect_to admin_mat_view_definitions_path(frame_id: @frame_id, frame_action: @frame_action), status: :see_other
+        else
+          redirect_to admin_mat_view_definition_path(@definition, frame_id: @frame_id, frame_action: @frame_action), status: status
+        end
+      end
+
+      # Loads a definition by `params[:id]`.
+      #
+      # @api private
+      #
+      # @return [void]
+      def set_definition
+        @definition = MatViews::MatViewDefinition.find(params[:id])
+      end
+
+      # Normalizes array fields (unique_index_columns, dependencies) from
+      # comma-separated strings into arrays.
+      #
+      # @api private
+      #
+      # @return [void]
+      def normalize_array_fields
+        normalize_array_field(:mat_view_definition, :unique_index_columns)
+        normalize_array_field(:mat_view_definition, :dependencies)
+      end
+
+      # Normalizes a specific array field from a comma-separated string into an array.
+      #
+      # @api private
+      #
+      # @param object_key [Symbol] the params object key (e.g., :mat_view_definition)
+      # @param array_key [Symbol] the specific array field key (e.g., :unique_index_columns)
+      #
+      # @return [void]
+      def normalize_array_field(object_key, array_key)
+        object = params[object_key]
+        values = object[array_key]
+        return if values.nil?
+
+        object[array_key] = values.split(',').map(&:strip).reject(&:blank?)
+      end
+
+      # Strong params for mat view definitions.
+      #
+      # @api private
+      #
+      # @return [ActionController::Parameters]
+      def definition_params
+        params.require(:mat_view_definition).permit(
+          :name, :sql, :refresh_strategy, :schedule_cron,
+          unique_index_columns: [], dependencies: []
+        )
+      end
+    end
+  end
+end

data/app/controllers/mat_views/admin/preferences_controller.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+module MatViews
+  module Admin
+    # MatViews::Admin::PreferencesController
+    # --------------------------------------
+    # Controller for managing user preferences in the MatViews admin UI.
+    #
+    # Responsibilities:
+    # - Allows users to view and update UI preferences such as theme and locale.
+    # - Stores theme in cookies and locale in session.
+    # - Provides a force-reload response option to update Turbo frames dynamically.
+    #
+    # Filters:
+    # - `before_action :authorize!` → ensures user can access preferences.
+    # - `before_action :ensure_frame` → requires Turbo frame context for `show`.
+    #
+    class PreferencesController < ApplicationController
+      before_action :authorize!
+      before_action :ensure_frame
+
+      # GET /:lang/admin/preferences
+      #
+      # Displays the current preferences (theme + locale) and available locales.
+      # If `force_reload=1` is passed, sets a non-standard status code (299) and
+      # a custom header to signal the client to reload.
+      #
+      # @return [void]
+      def show
+        @theme   = read_theme
+        @locale  = I18n.locale.to_s
+        @locales = MatViews::Engine.locale_code_mapping.sort_by { |_key, name| name }.map { |code, _name| code.to_s }.uniq
+
+        # force reload frame if requested
+        if params[:force_reload].to_s == '1'
+          response.status = 299
+          response.set_header('X-Status-Name', 'Success force reload')
+        end
+
+        render 'show', formats: :html, layout: 'mat_views/turbo_frame'
+      end
+
+      # PATCH/PUT /:lang/admin/preferences
+      #
+      # Updates preferences:
+      # - Theme (`light`, `dark`, or deleted if invalid) stored in cookies.
+      # - Locale stored in session if valid.
+      # Redirects back to preferences with `force_reload=1` to trigger a refresh.
+      #
+      # @return [void]
+      def update
+        theme_param = params[:theme].to_s
+        case theme_param
+        when 'light', 'dark' then cookies[:theme] = { value: theme_param, expires: 1.year.from_now, httponly: false }
+        else cookies.delete(:theme)
+        end
+
+        locale = params[:locale].to_s.presence || MatViews::Engine.default_locale.to_s
+        session[:mat_views_locale] = locale if MatViews::Engine.available_locales.map(&:to_s).include?(locale)
+
+        redirect_to "#{admin_preferences_path}?force_reload=1&frame_id=#{@frame_id}", status: :see_other
+      end
+
+      private
+
+      # Authorizes access to preferences.
+      #
+      # @api private
+      #
+      # @return [void]
+      def authorize!
+        authorize_mat_views!(:read, MatViews::MatViewDefinition)
+      end
+
+      # Reads the theme from cookies.
+      #
+      # @api private
+      #
+      # @return ["light", "dark", "auto"] theme preference or "auto" if unset/invalid
+      def read_theme
+        t = cookies[:theme].to_s
+        %w[light dark].include?(t) ? t : 'auto'
+      end
+    end
+  end
+end

data/app/controllers/mat_views/admin/runs_controller.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+# Copyright Codevedas Inc. 2025-present
+#
+# This source code is licensed under the MIT license found in the
+# LICENSE file in the root directory of this source tree.
+
+module MatViews
+  module Admin
+    # MatViews::Admin::RunsController
+    # -------------------------------
+    # Controller for viewing materialised view run history in the admin UI.
+    #
+    # Responsibilities:
+    # - Provides a list of recent runs (create/refresh/delete) for all definitions.
+    # - Shows details for an individual run in a Turbo frame/drawer context.
+    #
+    # Filters:
+    # - `before_action :ensure_frame` → enforces frame-only access.
+    # - `before_action :set_mat_view_run` → loads and authorizes a single run.
+    #
+    # Views:
+    # - Index renders `mat_views/admin/runs/embed_frame` partial.
+    # - Show renders `mat_views/admin/runs/embed_show_drawer` partial.
+    #
+    class RunsController < ApplicationController
+      before_action :ensure_frame
+      helper_method :definition
+      before_action :ensure_frame, only: %i[index show]
+      before_action :set_mat_view_run, only: %i[show]
+
+      # GET /:lang/admin/runs
+      #
+      # Lists all materialised view runs ordered by start time.
+      #
+      # @return [void]
+      def index
+        authorize_mat_views!(:read, :mat_views_runs)
+
+        @definitions = MatViews::MatViewDefinition.order(:name).to_a
+        @runs = MatViews::MatViewRun.order(started_at: :desc)
+
+        %i[mat_view_definition_id operation status].each do |param|
+          param_value = params[param]
+          next unless param_value.present?
+
+          @runs = @runs.where(param => param_value)
+        end
+        render 'index', formats: :html, layout: 'mat_views/turbo_frame'
+      end
+
+      # GET /:lang/admin/runs/:id
+      #
+      # Displays details for a single run.
+      #
+      # @return [void]
+      def show
+        render 'show', formats: :html, layout: 'mat_views/turbo_frame'
+      end
+
+      private
+
+      # Loads the requested run and checks authorization.
+      #
+      # @api private
+      #
+      # @return [void]
+      def set_mat_view_run
+        @run = MatViews::MatViewRun.find(params[:id])
+        authorize_mat_views!(:read, @run)
+      end
+    end
+  end
+end