add subfolders

app/controllers/api/form_events_controller.rb

@@ -11,8 +11,9 @@ module Api
       params[:before] = Time.zone.at(params[:before].to_i) if params[:before].present?
 
       submitters = paginate(
-        submitters.preload(template: :folder, submission: [:submitters, { audit_trail_attachment: :blob,
-                                                                          combined_document_attachment: :blob }],
+        submitters.preload(template: { folder: :parent_folder },
+                           submission: [:submitters, { audit_trail_attachment: :blob,
+                                                       combined_document_attachment: :blob }],
                            documents_attachments: :blob, attachments_attachments: :blob),
         field: :completed_at
       )

app/controllers/api/submissions_controller.rb

@@ -14,7 +14,7 @@ module Api
       submissions = filter_submissions(submissions, params)
 
       submissions = paginate(submissions.preload(:created_by_user, :submitters,
-                                                 template: :folder,
+                                                 template: { folder: :parent_folder },
                                                  combined_document_attachment: :blob,
                                                  audit_trail_attachment: :blob))
 
@@ -104,9 +104,10 @@ module Api
       submissions = submissions.where(slug: params[:slug]) if params[:slug].present?
 
       if params[:template_folder].present?
-        folder_ids = TemplateFolder.accessible_by(current_ability).where(name: params[:template_folder]).pluck(:id)
+        folders =
+          TemplateFolders.filter_by_full_name(TemplateFolder.accessible_by(current_ability), params[:template_folder])
 
-        submissions = submissions.joins(:template).where(template: { folder_id: folder_ids })
+        submissions = submissions.joins(:template).where(template: { folder_id: folders.pluck(:id) })
       end
 
       if params.key?(:archived)

app/controllers/api/templates_controller.rb

@@ -7,7 +7,7 @@ module Api
     def index
       templates = filter_templates(@templates, params)
 
-      templates = paginate(templates.preload(:author, :folder))
+      templates = paginate(templates.preload(:author, folder: :parent_folder))
 
       schema_documents =
         ActiveStorage::Attachment.where(record_id: templates.map(&:id),
@@ -92,9 +92,9 @@ module Api
       templates = templates.where(slug: params[:slug]) if params[:slug].present?
 
       if params[:folder].present?
-        folder_ids = TemplateFolder.accessible_by(current_ability).where(name: params[:folder]).pluck(:id)
+        folders = TemplateFolders.filter_by_full_name(TemplateFolder.accessible_by(current_ability), params[:folder])
 
-        templates = templates.where(folder_id: folder_ids)
+        templates = templates.where(folder_id: folders.pluck(:id))
       end
 
       templates

app/controllers/template_folders_autocomplete_controller.rb

@@ -3,14 +3,31 @@
 class TemplateFoldersAutocompleteController < ApplicationController
   load_and_authorize_resource :template_folder, parent: false
 
-  LIMIT = 100
+  LIMIT = 30
 
   def index
-    templates_query = Template.accessible_by(current_ability).where(archived_at: nil)
+    parent_name, name =
+      if params[:parent_name].present?
+        [params[:parent_name], params[:q]]
+      else
+        params[:q].to_s.split(' /', 2).map(&:squish)
+      end
 
-    template_folders = @template_folders.where(id: templates_query.select(:folder_id))
-    template_folders = TemplateFolders.search(template_folders, params[:q]).limit(LIMIT)
+    if name
+      parent_folder = @template_folders.find_by(name: parent_name, parent_folder_id: nil)
+    else
+      name = parent_name
+    end
 
-    render json: template_folders.as_json(only: %i[name archived_at])
+    template_folders = TemplateFolders.filter_active_folders(@template_folders.where(parent_folder:),
+                                                             Template.accessible_by(current_ability))
+
+    name = name.to_s.downcase
+
+    template_folders = TemplateFolders.search(template_folders, name).order(id: :desc).limit(LIMIT)
+
+    render json: template_folders.preload(:parent_folder)
+                                 .sort_by { |e| e.name.downcase.index(name) || Float::MAX }
+                                 .as_json(only: %i[name archived_at], methods: %i[full_name])
   end
 end

app/controllers/template_folders_controller.rb

@@ -5,13 +5,39 @@ class TemplateFoldersController < ApplicationController
 
   helper_method :selected_order
 
-  def show
-    @templates = @template_folder.templates.active.accessible_by(current_ability)
-                                 .preload(:author, :template_accesses)
-    @templates = Templates.search(current_user, @templates, params[:q])
-    @templates = Templates::Order.call(@templates, current_user, selected_order)
+  TEMPLATES_PER_PAGE = 12
+  FOLDERS_PER_PAGE = 18
 
-    @pagy, @templates = pagy_auto(@templates, limit: 12)
+  def show
+    @templates = Template.active.accessible_by(current_ability)
+                         .where(folder: [@template_folder, *(params[:q].present? ? @template_folder.subfolders : [])])
+                         .preload(:author, :template_accesses)
+
+    @template_folders =
+      @template_folder.subfolders.where(id: Template.accessible_by(current_ability).active.select(:folder_id))
+
+    @template_folders = TemplateFolders.search(@template_folders, params[:q])
+    @template_folders = TemplateFolders.sort(@template_folders, current_user, selected_order)
+
+    if @templates.exists?
+      @templates = Templates.search(current_user, @templates, params[:q])
+      @templates = Templates::Order.call(@templates, current_user, selected_order)
+
+      limit =
+        if @template_folders.size < 4
+          TEMPLATES_PER_PAGE
+        else
+          (@template_folders.size < 7 ? 9 : 6)
+        end
+
+      @pagy, @templates = pagy_auto(@templates, limit:)
+
+      load_related_submissions if params[:q].present? && @templates.blank?
+    else
+      @pagy, @template_folders = pagy(@template_folders, limit: FOLDERS_PER_PAGE)
+
+      @templates = @templates.none
+    end
   end
 
   def edit; end
@@ -40,4 +66,21 @@ class TemplateFoldersController < ApplicationController
   def template_folder_params
     params.require(:template_folder).permit(:name)
   end
+
+  def load_related_submissions
+    @related_submissions =
+      Submission.accessible_by(current_ability)
+                .where(archived_at: nil)
+                .where(template_id: current_account.templates.active
+                                                   .where(folder: [@template_folder, *@template_folder.subfolders])
+                                                   .select(:id))
+                .preload(:template_accesses, :created_by_user,
+                         template: :author,
+                         submitters: :start_form_submission_events)
+
+    @related_submissions = Submissions.search(current_user, @related_submissions, params[:q])
+                                      .order(id: :desc)
+
+    @related_submissions_pagy, @related_submissions = pagy_auto(@related_submissions, limit: 5)
+  end
 end

app/controllers/templates_archived_controller.rb

@@ -4,9 +4,27 @@ class TemplatesArchivedController < ApplicationController
   load_and_authorize_resource :template, parent: false
 
   def index
-    @templates = @templates.where.not(archived_at: nil).preload(:author, :folder, :template_accesses).order(id: :desc)
+    @templates = @templates.where.not(archived_at: nil)
+                           .preload(:author, :template_accesses, folder: :parent_folder)
+                           .order(id: :desc)
+
     @templates = Templates.search(current_user, @templates, params[:q])
 
     @pagy, @templates = pagy_auto(@templates, limit: 12)
+
+    return unless params[:q].present? && @templates.blank?
+
+    @related_submissions =
+      Submission.accessible_by(current_ability)
+                .joins(:template)
+                .where.not(templates: { archived_at: nil })
+                .preload(:template_accesses, :created_by_user,
+                         template: :author,
+                         submitters: :start_form_submission_events)
+
+    @related_submissions = Submissions.search(current_user, @related_submissions, params[:q])
+                                      .order(id: :desc)
+
+    @related_submissions_pagy, @related_submissions = pagy_auto(@related_submissions, limit: 5)
   end
 end

app/controllers/templates_dashboard_controller.rb

@@ -11,10 +11,11 @@ class TemplatesDashboardController < ApplicationController
   helper_method :selected_order
 
   def index
-    @template_folders = @template_folders.where(id: @templates.active.select(:folder_id))
+    @template_folders =
+      TemplateFolders.filter_active_folders(@template_folders.where(parent_folder_id: nil), @templates)
 
     @template_folders = TemplateFolders.search(@template_folders, params[:q])
-    @template_folders = sort_template_folders(@template_folders, current_user, selected_order)
+    @template_folders = TemplateFolders.sort(@template_folders, current_user, selected_order)
 
     @pagy, @template_folders = pagy(
       @template_folders,
@@ -68,40 +69,6 @@ class TemplatesDashboardController < ApplicationController
     Templates.search(current_user, rel, params[:q])
   end
 
-  def sort_template_folders(template_folders, current_user, order)
-    case order
-    when 'used_at'
-      subquery =
-        Template.left_joins(:submissions)
-                .group(:folder_id)
-                .where(account_id: current_user.account_id)
-                .select(
-                  :folder_id,
-                  Template.arel_table[:updated_at].maximum.as('updated_at_max'),
-                  Submission.arel_table[:created_at].maximum.as('submission_created_at_max')
-                )
-
-      template_folders = template_folders.joins(
-        Template.arel_table
-                .join(subquery.arel.as('templates'), Arel::Nodes::OuterJoin)
-                .on(TemplateFolder.arel_table[:id].eq(Template.arel_table[:folder_id]))
-                .join_sources
-      )
-
-      template_folders.order(
-        Arel::Nodes::Case.new
-                         .when(Template.arel_table[:submission_created_at_max].gt(Template.arel_table[:updated_at_max]))
-                         .then(Template.arel_table[:submission_created_at_max])
-                         .else(Template.arel_table[:updated_at_max])
-                         .desc
-      )
-    when 'name'
-      template_folders.order(name: :asc)
-    else
-      template_folders.order(id: :desc)
-    end
-  end
-
   def selected_order
     @selected_order ||=
       if cookies.permanent[:dashboard_templates_order].blank? ||

app/controllers/templates_folders_controller.rb

@@ -6,7 +6,9 @@ class TemplatesFoldersController < ApplicationController
   def edit; end
 
   def update
-    @template.folder = TemplateFolders.find_or_create_by_name(current_user, params[:name])
+    name = [params[:parent_name], params[:name]].compact_blank.join(' / ')
+
+    @template.folder = TemplateFolders.find_or_create_by_name(current_user, name)
 
     if @template.save
       redirect_back(fallback_location: template_path(@template), notice: I18n.t('document_template_has_been_moved'))