nquery 0.1.0

data/app/controllers/nquery/admin/data_sources_controller.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Nquery
+  module Admin
+    class DataSourcesController < BaseController
+      before_action :set_data_source, only: %i[edit update]
+
+      def index
+        @data_sources = DataSource.order(:name)
+      end
+
+      def new
+        @data_source = DataSource.new(adapter: "postgresql")
+      end
+
+      def create
+        @data_source = DataSource.new(data_source_params)
+        if @data_source.save
+          redirect_to admin_data_sources_path, notice: "Data source created."
+        else
+          render :new, status: :unprocessable_content
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @data_source.update(data_source_params)
+          redirect_to admin_data_sources_path, notice: "Data source updated."
+        else
+          render :edit, status: :unprocessable_content
+        end
+      end
+
+      private
+
+      def set_data_source
+        @data_source = DataSource.find(params[:id])
+      end
+
+      def data_source_params
+        params.require(:data_source).permit(:name, :adapter, :active, :connection_config)
+      end
+    end
+  end
+end

data/app/controllers/nquery/admin/groups_controller.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Nquery
+  module Admin
+    class GroupsController < BaseController
+      before_action :set_group, only: %i[show edit update add_member remove_member]
+
+      def index
+        @groups = Group.includes(:users).order(:name)
+      end
+
+      def show
+        @available_users = User.active.where.not(id: @group.user_ids).order(:email)
+      end
+
+      def new
+        @group = Group.new
+      end
+
+      def create
+        @group = Group.new(group_params.merge(system_group: "custom"))
+        if @group.save
+          redirect_to admin_groups_path, notice: "Group created."
+        else
+          render :new, status: :unprocessable_content
+        end
+      end
+
+      def edit
+      end
+
+      def update
+        if @group.update(group_params)
+          redirect_to admin_groups_path, notice: "Group updated."
+        else
+          render :edit, status: :unprocessable_content
+        end
+      end
+
+      def add_member
+        user = User.find(params[:user_id])
+        @group.group_memberships.find_or_create_by!(user: user)
+        redirect_to admin_group_path(@group), notice: "#{user.name} added to group."
+      end
+
+      def remove_member
+        membership = @group.group_memberships.find_by!(user_id: params[:user_id])
+        membership.destroy unless @group.system_group == "all_users"
+        redirect_to admin_group_path(@group), notice: "Member removed."
+      end
+
+      private
+
+      def set_group
+        @group = Group.includes(:users).find(params[:id])
+      end
+
+      def group_params
+        params.require(:group).permit(:name, :description)
+      end
+    end
+  end
+end

data/app/controllers/nquery/admin/logs_controller.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Nquery
+  module Admin
+    class LogsController < BaseController
+      def index
+        @collections = Collection.order(:name)
+        @dashboards = Dashboard.order(:name)
+        @audits = filtered_audits
+          .includes(:user, query: [:collection, { chart: { dashboard_cards: :dashboard } }])
+          .recent
+          .limit(100)
+      end
+
+      private
+
+      def filtered_audits
+        scope = Audit.all
+        scope = scope.for_user(params[:user]) if params[:user].present?
+        scope = scope.for_collection(params[:collection]) if params[:collection].present?
+        scope = scope.for_dashboard(params[:dashboard]) if params[:dashboard].present?
+        scope = scope.since(params[:from]) if params[:from].present?
+        scope = scope.until_date(params[:to]) if params[:to].present?
+        scope
+      end
+    end
+  end
+end

data/app/controllers/nquery/admin/permissions_controller.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Nquery
+  module Admin
+    class PermissionsController < BaseController
+      def index
+        redirect_to by_group_admin_permissions_path
+      end
+
+      def by_group
+        @view = "group"
+        @groups = Group.order(:name)
+        @selected_group = Group.find_by(id: params[:group_id]) || @groups.first
+        @collections = Collection.shared.order(:name)
+        @data_sources = DataSource.order(:name)
+        @warnings = permission_warnings(@selected_group)
+      end
+
+      def by_data_source
+        @view = "data_source"
+        @data_sources = DataSource.order(:name)
+        @selected_data_source = DataSource.find_by(id: params[:data_source_id]) || @data_sources.first
+        @groups = Group.order(:name)
+      end
+
+      def by_collection
+        @view = "collection"
+        @collections = Collection.shared.order(:name)
+        @selected_collection = Collection.find_by(id: params[:collection_id]) || @collections.first
+        @groups = Group.order(:name)
+        @warnings = @groups.filter_map do |group|
+          "All Users is more permissive than #{group.name}" if permission_resolver.all_users_more_permissive?(group, collection: @selected_collection)
+        end
+      end
+
+      private
+
+      def permission_warnings(group)
+        return [] unless group
+
+        Collection.shared.filter_map do |collection|
+          next unless permission_resolver.all_users_more_permissive?(group, collection: collection)
+
+          "All Users has broader access than #{group.name} on #{collection.name}"
+        end
+      end
+
+      def permission_resolver
+        @permission_resolver ||= Permissions::Resolver.new(current_nquery_user)
+      end
+    end
+  end
+end

data/app/controllers/nquery/admin/users_controller.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Nquery
+  module Admin
+    class UsersController < BaseController
+      before_action :set_user, only: %i[show edit update deactivate destroy]
+
+      def index
+        @users = User.active.includes(:groups).order(:email)
+      end
+
+      def show
+      end
+
+      def new
+        @user = User.new
+        @groups = Group.order(:name)
+      end
+
+      def create
+        @user = User.new(user_params)
+        if @user.save
+          assign_groups(@user)
+          @user.ensure_all_users_membership!
+          @user.ensure_personal_collection!
+          redirect_to admin_users_path, notice: "User created."
+        else
+          @groups = Group.order(:name)
+          render :new, status: :unprocessable_content
+        end
+      end
+
+      def edit
+        @groups = Group.order(:name)
+      end
+
+      def update
+        if @user.update(user_params)
+          assign_groups(@user)
+          redirect_to admin_users_path, notice: "User updated."
+        else
+          @groups = Group.order(:name)
+          render :edit, status: :unprocessable_content
+        end
+      end
+
+      def deactivate
+        return redirect_to admin_users_path, alert: "You cannot disable your own account." if @user == current_nquery_user
+
+        @user.deactivate!
+        redirect_to admin_users_path, notice: "#{@user.name} has been disabled."
+      end
+
+      def destroy
+        return redirect_to admin_users_path, alert: "You cannot remove your own account." if @user == current_nquery_user
+
+        name = @user.name
+        @user.destroy!
+        redirect_to admin_users_path, notice: "#{name} has been removed."
+      end
+
+      private
+
+      def set_user
+        @user = User.find(params[:id])
+      end
+
+      def user_params
+        params.require(:user).permit(:email, :first_name, :last_name, :password, :password_confirmation)
+      end
+
+      def assign_groups(user)
+        group_ids = params[:group_ids]&.reject(&:blank?) || []
+        user.group_memberships.where.not(group_id: group_ids).destroy_all
+        group_ids.each { |gid| user.group_memberships.find_or_create_by!(group_id: gid) }
+        user.ensure_all_users_membership!
+      end
+    end
+  end
+end

data/app/controllers/nquery/application_controller.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Nquery
+  class ApplicationController < ActionController::Base
+    include Nquery::AuthorizesCollection
+    include Nquery::Breadcrumbs
+    include Nquery::Engine.routes.url_helpers
+
+    protect_from_forgery with: :exception
+    layout "nquery/application"
+
+    helper_method :current_nquery_user, :permission_resolver
+
+    before_action :_authenticate!
+    before_action :set_current_user_context
+
+    private
+
+    def _authenticate!
+      if Nquery.configuration.authenticate
+        instance_eval(&Nquery.configuration.authenticate)
+      else
+        default_authenticate!
+      end
+    end
+
+    def default_authenticate!
+      return if current_nquery_user
+      return if auth_exempt?
+
+      redirect_to login_path, alert: "Please sign in to continue."
+    end
+
+    def auth_exempt?
+      controller_path.in?(%w[nquery/sessions nquery/registrations nquery/embed/charts nquery/embed/dashboards])
+    end
+
+    def current_nquery_user
+      @current_nquery_user ||= resolve_current_user
+    end
+
+    def resolve_current_user
+      if session[:nquery_user_id]
+        return User.active.find_by(id: session[:nquery_user_id])
+      end
+
+      if Nquery.configuration.authentication_mode.in?(%i[sso hybrid])
+        host_method = Nquery.configuration.current_user_method
+        host_user = host_method.is_a?(Symbol) ? send(host_method) : instance_eval(&host_method)
+        if host_user && Nquery.configuration.resolve_user
+          return instance_eval { Nquery.configuration.resolve_user.call(host_user) }
+        end
+      end
+
+      nil
+    end
+
+    def set_current_user_context
+      @permission_resolver = Permissions::Resolver.new(current_nquery_user) if current_nquery_user
+    end
+
+    def permission_resolver
+      @permission_resolver ||= Permissions::Resolver.new(current_nquery_user)
+    end
+
+    def require_admin!
+      redirect_to root_path, alert: "Admin access required." unless permission_resolver.admin?
+    end
+  end
+end

data/app/controllers/nquery/charts_controller.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Nquery
+  class ChartsController < ApplicationController
+    include ChartActions
+
+    before_action :set_root_collection, only: %i[new create]
+    before_action :authorize_chart_create!, only: %i[new create]
+
+    def new
+      @chart = Chart.new
+      @chart.build_query(statement: "SELECT 1 AS example")
+      load_chart_builder_assigns
+    end
+
+    def create
+      @chart = Chart.new(
+        chart_params.merge(
+          creator: current_nquery_user,
+          collection: @root_collection
+        )
+      )
+      @chart.name = @chart.name.presence || @chart.query&.name
+      @chart.visualization = { "type" => "table" } if @chart.visualization.blank?
+      @chart.query&.creator = current_nquery_user
+      @chart.query&.collection = @root_collection
+
+      if @chart.save
+        redirect_to edit_chart_path(@chart), notice: "Chart created."
+      else
+        load_chart_builder_assigns
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    private
+
+    def set_root_collection
+      @root_collection = Collection.roots.first
+      redirect_to root_path, alert: "No collection available." unless @root_collection
+    end
+
+    def authorize_chart_create!
+      authorize_collection_access!(@root_collection, required: :curate)
+    end
+
+    def set_chart
+      @chart = Chart.find(params[:id])
+    end
+  end
+end

data/app/controllers/nquery/collection/dashboards_controller.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Nquery
+  class Collection::DashboardsController < ApplicationController
+    include Browsable
+
+    before_action :set_collection
+    before_action :authorize_collection_curate!
+
+    def new
+      @dashboard = Dashboard.new(collection: @collection)
+    end
+
+    def create
+      @dashboard = Dashboard.new(dashboard_params.merge(collection: @collection, creator: current_nquery_user))
+
+      if @dashboard.save
+        redirect_to dashboard_path(@dashboard), notice: "Dashboard created."
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    private
+
+    def set_collection
+      @collection = Collection.find(params[:collection_id])
+    end
+
+    def authorize_collection_curate!
+      authorize_collection_access!(@collection, required: :curate)
+    end
+
+    def dashboard_params
+      params.require(:dashboard).permit(:name, :description, settings: {})
+    end
+  end
+end

data/app/controllers/nquery/collections_controller.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Nquery
+  class CollectionsController < ApplicationController
+    include Browsable
+
+    before_action :set_collection, only: %i[show edit update destroy archive unarchive]
+    before_action :set_parent_collection, only: %i[new create]
+    before_action :authorize_collection_view!, only: %i[show]
+    before_action :authorize_collection_curate!, only: %i[edit update destroy archive unarchive]
+    before_action :authorize_parent_curate!, only: %i[new create]
+
+    before_action :prevent_root_deletion, only: %i[destroy]
+    before_action :prevent_root_archival, only: %i[archive]
+
+    def index
+      @collections = viewable_collections
+    end
+
+    def show
+      load_collection_contents(@collection)
+    end
+
+    def new
+      @collection = Collection.new(kind: "standard", parent: @parent_collection)
+      @parent_collections = assignable_collections
+    end
+
+    def create
+      @collection = Collection.new(collection_params.merge(kind: "standard", parent: @parent_collection))
+      @parent_collections = assignable_collections
+
+      if @collection.save
+        redirect_to collection_path(@collection), notice: "Collection created."
+      else
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    def edit
+      @parent_collections = assignable_collections.reject { |c| c.id == @collection.id }
+    end
+
+    def update
+      @parent_collections = assignable_collections.reject { |c| c.id == @collection.id }
+      if collection_params[:parent_id].present?
+        parent = Collection.find_by(id: collection_params[:parent_id])
+        authorize_collection_access!(parent, required: :curate) if parent
+      end
+
+      if @collection.update(collection_params)
+        redirect_to collection_path(@collection), notice: "Collection updated."
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      @collection.destroy
+      redirect_to collections_path, notice: "Collection deleted."
+    end
+
+    def archive
+      @collection.archive!
+      redirect_to collections_path, notice: "Collection archived."
+    end
+
+    def unarchive
+      @collection.unarchive!
+      redirect_to collection_path(@collection), notice: "Collection unarchived."
+    end
+
+    private
+
+    def set_collection
+      @collection = Collection.find(params[:id])
+    end
+
+    def set_parent_collection
+      return if params[:collection_id].blank?
+
+      @parent_collection = Collection.find(params[:collection_id])
+    end
+
+    def authorize_parent_curate!
+      parent_id = params.dig(:collection, :parent_id)
+      parent = @parent_collection || Collection.find_by(id: parent_id)
+      return if parent.nil?
+
+      authorize_collection_access!(parent, required: :curate)
+    end
+
+    def authorize_collection_view!
+      authorize_collection_access!(@collection, required: :view)
+    end
+
+    def authorize_collection_curate!
+      authorize_collection_access!(@collection, required: :curate)
+    end
+
+    def prevent_root_deletion
+      return unless @collection.kind == "root"
+
+      redirect_to collections_path, alert: "Root collections cannot be deleted."
+    end
+
+    def prevent_root_archival
+      return unless @collection.kind == "root"
+
+      redirect_to collections_path, alert: "Root collections cannot be archived."
+    end
+
+    def collection_params
+      params.require(:collection).permit(:name, :parent_id)
+    end
+  end
+end

data/app/controllers/nquery/dashboard/charts_controller.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Nquery
+  class Dashboard::ChartsController < ApplicationController
+    include ChartActions
+
+    prepend_before_action :set_dashboard
+    before_action :authorize_dashboard_view!, only: %i[show embed]
+    before_action :authorize_dashboard_curate!, except: %i[show embed]
+
+    def new
+      @chart = Chart.new
+      @chart.build_query(statement: "SELECT 1 AS example")
+      load_chart_builder_assigns
+    end
+
+    def create
+      @chart = Chart.new(
+        chart_params.merge(
+          creator: current_nquery_user,
+          collection: @dashboard.collection
+        )
+      )
+      @chart.name = @chart.name.presence || @chart.query&.name
+      @chart.visualization = { "type" => "table" } if @chart.visualization.blank?
+      @chart.query&.creator = current_nquery_user
+      @chart.query&.collection = @dashboard.collection
+
+      if @chart.save
+        @dashboard.dashboard_cards.create!(
+          chart: @chart,
+          pos_x: 0,
+          pos_y: 0,
+          width: 6,
+          height: 4
+        )
+        redirect_to edit_dashboard_chart_path(@dashboard, @chart), notice: "Chart created."
+      else
+        load_chart_builder_assigns
+        render :new, status: :unprocessable_content
+      end
+    end
+
+    private
+
+    def set_dashboard
+      @dashboard = Dashboard.find(params[:dashboard_id])
+    end
+
+    def set_chart
+      @chart = @dashboard.charts.find(params[:id])
+    end
+
+    def authorize_dashboard_view!
+      authorize_collection_access!(@dashboard.collection, required: :view)
+    end
+
+    def authorize_dashboard_curate!
+      authorize_collection_access!(@dashboard.collection, required: :curate)
+    end
+  end
+end

data/app/controllers/nquery/dashboards_controller.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Nquery
+  class DashboardsController < ApplicationController
+    include ChartResults
+    include Browsable
+
+    before_action :set_dashboard, only: %i[show edit update destroy archive unarchive update_layout]
+    before_action :authorize_dashboard_view!, only: %i[show]
+    before_action :authorize_dashboard_curate!, only: %i[edit update destroy archive unarchive update_layout]
+
+    def index
+      @dashboards = filter_viewable_dashboards(Dashboard.active.includes(:collection).order(:name))
+    end
+
+    def show
+      @dashboard_cards = @dashboard.dashboard_cards
+        .joins(:chart)
+        .merge(Chart.active)
+        .includes(:chart)
+      @card_results = @dashboard_cards.index_with { |card| chart_result(card.chart) }
+    end
+
+    def edit
+      @collections = assignable_collections
+    end
+
+    def update
+      @collections = assignable_collections
+      authorize_collection_access!(Collection.find(dashboard_params[:collection_id]), required: :curate) if dashboard_params[:collection_id].present?
+
+      if @dashboard.update(dashboard_params)
+        redirect_to dashboard_path(@dashboard), notice: "Dashboard updated."
+      else
+        render :edit, status: :unprocessable_content
+      end
+    end
+
+    def destroy
+      @dashboard.destroy
+      redirect_to dashboards_path, notice: "Dashboard removed."
+    end
+
+    def archive
+      @dashboard.archive!
+      redirect_to dashboards_path, notice: "Dashboard archived."
+    end
+
+    def unarchive
+      @dashboard.unarchive!
+      redirect_to dashboard_path(@dashboard), notice: "Dashboard unarchived."
+    end
+
+    def update_layout
+      card_layouts.each do |card_id, layout|
+        card = @dashboard.dashboard_cards.find(card_id)
+        card.update(pos_x: layout[:x], pos_y: layout[:y], width: layout[:w], height: layout[:h])
+      end
+      head :ok
+    end
+
+    private
+
+    def set_dashboard
+      @dashboard = if action_name.in?(%w[show edit])
+                     Dashboard.includes(:creator, dashboard_cards: :chart).find(params[:id])
+                   else
+                     Dashboard.find(params[:id])
+                   end
+    end
+
+    def authorize_dashboard_view!
+      authorize_collection_access!(@dashboard.collection, required: :view)
+    end
+
+    def authorize_dashboard_curate!
+      authorize_collection_access!(@dashboard.collection, required: :curate)
+    end
+
+    def card_layouts
+      params.permit(cards: {}).fetch(:cards, {}).transform_values do |layout|
+        layout.permit(:x, :y, :w, :h).to_h.symbolize_keys
+      end
+    end
+
+    def dashboard_params
+      params.require(:dashboard).permit(:name, :description, :collection_id, settings: {})
+    end
+  end
+end