Moved support_ticket configuration to UserConfiguration class

apps/dashboard/app/apps/request_tracker_client.rb

@@ -15,20 +15,6 @@
 class RequestTrackerClient
   # THIS CLIENT IS BASED ON https://github.com/uidzip/rt-client
 
-  def self.create
-    rt_config = ::Configuration.support_ticket_config.fetch(:rt_api, {})
-
-    new({
-          server:     rt_config[:server],
-          user:       rt_config[:user],
-          pass:       rt_config[:pass],
-          auth_token: rt_config[:auth_token],
-          timeout:    rt_config[:timeout],
-          verify_ssl: rt_config[:verify_ssl],
-          proxy:      rt_config[:proxy]
-        })
-  end
-
   UA = 'Open OnDemand ruby RT Client'
   attr_reader :server, :rt_client, :resource, :timeout, :verify_ssl
 

apps/dashboard/app/apps/request_tracker_service.rb

@@ -3,19 +3,20 @@
 # Generates the support ticket payload and sends it to a request tracker system using the API
 #
 class RequestTrackerService
-  def initialize
-    rt_config = ::Configuration.support_ticket_config.fetch(:rt_api, {})
+
+  attr_reader :rt_config, :queues, :priority
+
+  def initialize(request_tracker_config)
+    @rt_config = request_tracker_config
     @queues = rt_config[:queues]
     @priority = rt_config[:priority]
 
-    if !@queues || @queues.empty? || !@priority
+    if !queues || queues.empty? || !priority
       raise ArgumentError, 'queues and priority are required options for RequestTrackerService'
     end
   end
 
   def create_ticket(support_ticket_request, session)
-    rt_config = ::Configuration.support_ticket_config.fetch(:rt_api, {})
-
     ticket_template_context = {
       session:     session,
       description: support_ticket_request.description,
@@ -28,17 +29,17 @@ def create_ticket(support_ticket_request, session)
                                                               helpers: TemplateHelpers.new })
 
     payload = create_payload(support_ticket_request, ticket_text)
-    rt_client = RequestTrackerClient.create
+    rt_client = RequestTrackerClient.new(rt_config)
     rt_client.create(payload)
   end
 
   private
 
   def create_payload(support_ticket_request, ticket_text)
     # default to first configured queue
-    queue = @queues[0]
+    queue = queues[0]
     if support_ticket_request.queue && support_ticket_request.queue != ''
-      if @queues.include?(support_ticket_request.queue)
+      if queues.include?(support_ticket_request.queue)
         queue = support_ticket_request.queue
       else
         raise ArgumentError, 'invalid queue selection'
@@ -49,7 +50,7 @@ def create_payload(support_ticket_request, ticket_text)
       Queue:     queue,
       Requestor: support_ticket_request.email,
       Cc:        support_ticket_request.cc,
-      Priority:  @priority,
+      Priority:  priority,
       Subject:   support_ticket_request.subject,
       Text:      ticket_text
     }

apps/dashboard/app/apps/support_ticket_email_service.rb

@@ -4,14 +4,24 @@
 #
 # It implements the support ticket interface as defined in the SupportTicketController
 class SupportTicketEmailService
+
+  attr_reader :support_ticket_config
+
+  # Constructor
+  #
+  # @param [Hash] support_ticket_config Support ticket configuration
+  def initialize(support_ticket_config)
+    @support_ticket_config = support_ticket_config
+  end
+
   # Creates a support ticket model with default data.
   # will load an interactive session if a session_id provided in the request parameters.
   #
   # @param [Hash] request_params Request data sent to the controller
   #
   # @return [SupportTicket] support_ticket model
   def default_support_ticket(request_params)
-    support_ticket = SupportTicket.from_config(::Configuration.support_ticket_config)
+    support_ticket = SupportTicket.from_config(support_ticket_config)
     support_ticket.username = CurrentUser.name
     support_ticket.session_id = request_params[:session_id]
     set_session(support_ticket)
@@ -24,7 +34,7 @@ def default_support_ticket(request_params)
   #
   # @return [SupportTicket] support_ticket model
   def validate_support_ticket(request_data = {})
-    support_ticket = SupportTicket.from_config(::Configuration.support_ticket_config)
+    support_ticket = SupportTicket.from_config(support_ticket_config)
     support_ticket.attributes = request_data
     set_session(support_ticket)
     support_ticket.tap(&:validate)
@@ -36,14 +46,14 @@ def validate_support_ticket(request_data = {})
   #
   # @return [String] success message
   def deliver_support_ticket(support_ticket)
-    email_service_config = ::Configuration.support_ticket_config.fetch(:email, {})
+    email_service_config = support_ticket_config.fetch(:email, {})
     session = get_session(support_ticket)
     context = OpenStruct.new({
                                support_ticket: support_ticket,
                                session: session,
                              })
 
-    SupportTicketMailer.support_email(context).deliver_now
+    SupportTicketMailer.support_email(support_ticket_config, context).deliver_now
     email_service_config.fetch(:success_message,
                                I18n.t('dashboard.support_ticket.creation_success', to: email_service_config.fetch(:to)))
   end

apps/dashboard/app/apps/support_ticket_rt_service.rb

@@ -4,6 +4,16 @@
 #
 # It implements the support ticket interface as defined in the SupportTicketController
 class SupportTicketRtService
+
+  attr_reader :support_ticket_config
+
+  # Constructor
+  #
+  # @param [Hash] support_ticket_config Support ticket configuration
+  def initialize(support_ticket_config)
+    @support_ticket_config = support_ticket_config
+  end
+
   # Creates a support ticket model with default data.
   # Will load an interactive session if a session_id provided in the request parameters.
   # Accepts a queue parameter to override the default. Useful for testing.
@@ -12,7 +22,7 @@ class SupportTicketRtService
   #
   # @return [SupportTicket] support_ticket model
   def default_support_ticket(request_params)
-    support_ticket = SupportTicket.from_config(::Configuration.support_ticket_config)
+    support_ticket = SupportTicket.from_config(support_ticket_config)
     support_ticket.username = CurrentUser.name
     support_ticket.session_id = request_params[:session_id]
     support_ticket.queue = request_params[:queue]
@@ -26,7 +36,7 @@ def default_support_ticket(request_params)
   #
   # @return [SupportTicket] support_ticket model
   def validate_support_ticket(request_data = {})
-    support_ticket = SupportTicket.from_config(::Configuration.support_ticket_config)
+    support_ticket = SupportTicket.from_config(support_ticket_config)
     support_ticket.attributes = request_data
     set_session(support_ticket)
     support_ticket.tap(&:validate)
@@ -38,9 +48,9 @@ def validate_support_ticket(request_data = {})
   #
   # @return [String] success message
   def deliver_support_ticket(support_ticket)
-    service_config = ::Configuration.support_ticket_config.fetch(:rt_api, {})
+    service_config = support_ticket_config.fetch(:rt_api, {})
     session = get_session(support_ticket)
-    rts = RequestTrackerService.new
+    rts = RequestTrackerService.new(service_config)
     ticket_id = rts.create_ticket(support_ticket, session)
     service_config.fetch(:success_message, I18n.t('dashboard.support_ticket.rt.creation_success', ticket_id: ticket_id))
   end

apps/dashboard/app/controllers/support_ticket_controller.rb

@@ -40,17 +40,12 @@ def create
 
   private
 
-  # Load support ticket service class based on the configuration
   def create_service_class
-    # Supported delivery mechanism
-    return SupportTicketEmailService.new if ::Configuration.support_ticket_config[:email]
-    return SupportTicketRtService.new if ::Configuration.support_ticket_config[:rt_api]
-
-    raise StandardError, 'No support ticket service class configured'
+    @user_configuration.support_ticket_service
   end
 
   def get_ui_template
-    ::Configuration.support_ticket_config.fetch(:ui_template, 'email_service_template')
+    @user_configuration.support_ticket.fetch(:ui_template, 'email_service_template')
   end
 
   def read_support_ticket_from_request

apps/dashboard/app/helpers/batch_connect/sessions_helper.rb

@@ -46,7 +46,7 @@ def session_view(session)
           concat created(session)
           concat session_time(session)
           concat id(session)
-          concat support_ticket(session) if Configuration.support_ticket_enabled?
+          concat support_ticket(session) unless @user_configuration.support_ticket.empty?
           concat display_choices(session)
           safe_concat custom_info_view(session) if session.app.session_info_view
         end

apps/dashboard/app/helpers/support_ticket_helper.rb

@@ -3,7 +3,7 @@
 # helper for the support ticket pages, email, and request tracker content.
 module SupportTicketHelper
   def support_ticket_description_text
-    ::Configuration.support_ticket_config[:description]
+    @user_configuration.support_ticket[:description]
   end
 
   def filter_session_parameters(session_info)

apps/dashboard/app/mailers/support_ticket_mailer.rb

@@ -8,7 +8,7 @@ class SupportTicketMailer < ActionMailer::Base
   default template_path: ['support_ticket/email']
   default template_name: 'email_layout'
 
-  def support_email(context)
+  def support_email(support_ticket_config, context)
     @context = context
 
     unless @context.support_ticket.attachments.blank?
@@ -17,7 +17,7 @@ def support_email(context)
       end
     end
 
-    email_service_config = ::Configuration.support_ticket_config.fetch(:email, {})
+    email_service_config = support_ticket_config.fetch(:email, {})
 
     mail_data = {}.tap do |settings|
       settings[:from] = email_service_config.fetch(:from, @context.support_ticket.email)

apps/dashboard/app/models/concerns/support_ticket_validator.rb

@@ -7,21 +7,9 @@
 #  - email
 #  - attachments
 module SupportTicketValidator
-  # Common file sizes
-  # 2MB = 2097152
-  # 5MB = 5242880
-  # 6MB = 6291456
-  # 10MB = 10485760
-  def self.restrictions
-    @@restrictions ||= {}.tap do |hash|
-      config = ::Configuration.support_ticket_config.fetch(:attachments, {})
-      hash[:max_items] = config.fetch(:max_items, 4)
-      hash[:max_size] = config.fetch(:max_size, 6_291_456)
-    end
-  end
 
   def support_ticket_validation
-    @attributes.each do |attribute|
+    attributes.each do |attribute|
       validate_required(attribute) if attribute.required
       validate_email(attribute) if attribute.widget == 'email_field'
       validate_attachments(attribute) if attribute.widget == 'file_attachments'
@@ -42,15 +30,15 @@ def validate_attachments(attribute)
       return
     end
 
-    if attribute.value.size > SupportTicketValidator.restrictions[:max_items]
-      errors.add(attribute.id, I18n.t('dashboard.support_ticket.validation.attachments_items', id: attribute.id, items: attribute.value.size, max: SupportTicketValidator.restrictions[:max_items]))
+    if attribute.value.size > restrictions[:max_items]
+      errors.add(attribute.id, I18n.t('dashboard.support_ticket.validation.attachments_items', id: attribute.id, items: attribute.value.size, max: restrictions[:max_items]))
       return
     end
 
     attribute.value.each do |attachment|
-      next unless attachment.size > SupportTicketValidator.restrictions[:max_size]
+      next unless attachment.size > restrictions[:max_size]
 
-      errors.add(attribute.id, I18n.t('dashboard.support_ticket.validation.attachments_size', id: attribute.id, max: size_to_string(SupportTicketValidator.restrictions[:max_size])))
+      errors.add(attribute.id, I18n.t('dashboard.support_ticket.validation.attachments_size', id: attribute.id, max: size_to_string(restrictions[:max_size])))
       return
     end
   end

apps/dashboard/app/models/support_ticket.rb

@@ -8,12 +8,13 @@ class SupportTicket
   include SupportTicketValidator
 
   attr_reader :attributes
+  attr_reader :restrictions
 
   validate :support_ticket_validation
 
-  def self.from_config(attributes_config)
-    local_opts = attributes_config.fetch(:attributes, {})
-    attrib_list = attributes_config.fetch(:form, default_opts.keys)
+  def self.from_config(support_ticket_config)
+    local_opts = support_ticket_config.fetch(:attributes, {})
+    attrib_list = support_ticket_config.fetch(:form, default_opts.keys)
     Rails.logger.info "SupportTicket defined attributes: #{attrib_list}"
 
     attributes = attrib_list.map do |attribute_id|
@@ -25,7 +26,17 @@ def self.from_config(attributes_config)
       SmartAttributes::AttributeFactory.build(attribute_id, attribute_opts)
     end
 
-    SupportTicket.new(attributes)
+    # Common file sizes
+    # 2MB = 2097152
+    # 5MB = 5242880
+    # 6MB = 6291456
+    # 10MB = 10485760
+    restrictions = {
+      max_items: support_ticket_config.dig(:attachments, :max_items) || 4,
+      max_size: support_ticket_config.dig(:attachments, :max_size) || 6_291_456,
+    }
+
+    SupportTicket.new(attributes, restrictions)
   end
 
   def attributes=(params = {})
@@ -35,8 +46,10 @@ def attributes=(params = {})
   end
 
   # @param attributes [Array<Attribute>] list of attribute objects
-  def initialize(attributes = [])
+  # @param restrictions [Hash<>] Attachment restriction properties for validation
+  def initialize(attributes = [], restrictions = {})
     @attributes = attributes
+    @restrictions = restrictions
     @attributes.each do |attribute|
       define_singleton_method("#{attribute.id}="){ |value| attribute.value = value }
       define_singleton_method("#{attribute.id}"){ attribute.value }

apps/dashboard/app/models/user_configuration.rb

@@ -66,11 +66,13 @@ class UserConfiguration
     ConfigurationProperty.property(name: :interactive_apps_menu, default_value: []),
 
     # Custom pages configuration property
-    ConfigurationProperty.property(name: :custom_pages, default_value: {})
+    ConfigurationProperty.property(name: :custom_pages, default_value: {}),
+    # Support ticket configuration property
+    ConfigurationProperty.property(name: :support_ticket, default_value: {})
   ].freeze
 
-  def initialize(request_hostname: nil)
-    @config = ::Configuration.config
+  def initialize(config: nil, request_hostname: nil)
+    @config = config || ::Configuration.config
     @request_hostname = request_hostname.to_sym if request_hostname
     add_property_methods
   end
@@ -120,6 +122,15 @@ def nav_categories
     fetch(:nav_categories, nil) || NavConfig.categories
   end
 
+  # Create support ticket service class based on the configuration
+  def support_ticket_service
+    # Supported delivery mechanism
+    return SupportTicketEmailService.new(support_ticket) if support_ticket[:email]
+    return SupportTicketRtService.new(support_ticket) if support_ticket[:rt_api]
+
+    raise StandardError, 'No support ticket service class configured'
+  end
+
   # The current user profile. Used to select the configuration properties.
   def profile
     return CurrentUser.user_settings[:profile_override].to_sym if CurrentUser.user_settings[:profile_override]

apps/dashboard/app/views/layouts/nav/_help_dropdown.html.erb

@@ -11,7 +11,7 @@
     <% if help_custom_url %>
       <%= nav_link(t('dashboard.nav_help_custom'), "question-circle", help_custom_url, new_tab: true) %>
     <% end %>
-    <% if Configuration.support_ticket_enabled? %>
+    <% unless @user_configuration.support_ticket.empty? %>
       <%= nav_link(t('dashboard.nav_help_support_ticket'), "medkit", support_path, new_tab: false) %>
     <% end %>
 

apps/dashboard/app/views/support_ticket/email_service_template.html.erb

@@ -2,7 +2,7 @@
 
 <%= javascript_tag nonce: true do -%>
 
-    const SUPPORT_TICKET_RESTRICTIONS = <%= raw SupportTicketValidator.restrictions.to_json %>
+    const SUPPORT_TICKET_RESTRICTIONS = <%= raw @support_ticket.restrictions.to_json %>
     const SUPPORT_TICKET_MESSAGES = {
         "items.attachments": "<%= t('dashboard.support_ticket.validation.items.attachments_js') %>",
         "size.attachments": "<%= t('dashboard.support_ticket.validation.size.attachments_js') %>",

apps/dashboard/config/configuration_singleton.rb

@@ -190,12 +190,8 @@ def xdmod_integration_enabled?
   end
 
   # Support ticket configuration
-  def support_ticket_config
-    config.fetch(:support_ticket, {})
-  end
-
   def support_ticket_enabled?
-    !support_ticket_config.empty?
+    config.has_key?(:support_ticket) || config.fetch(:profiles, {}).any? { |_, profile| profile.has_key?(:support_ticket) }
   end
 
   # Load the dotenv local files first, then the /etc dotenv files and