foreman_datacenter 0.1.54 → 0.1.55

data/app/controllers/concerns/foreman_datacenter/controller/parameters/rack_group.rb

@@ -0,0 +1,15 @@
+module ForemanDatacenter::Controller::Parameters::RackGroup
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def rack_group_params_filter
+      Foreman::ParameterFilter.new(::ForemanDatacenter::RackGroup).tap do |filter|
+        filter.permit :name, :site_id
+      end
+    end
+  end
+
+  def rack_group_params
+    self.class.rack_group_params_filter.filter_params(params, parameter_filter_context)
+  end
+end

data/app/controllers/concerns/foreman_datacenter/controller/parameters/site.rb

@@ -0,0 +1,16 @@
+module ForemanDatacenter::Controller::Parameters::Site
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def site_params_filter
+      Foreman::ParameterFilter.new(::ForemanDatacenter::Site).tap do |filter|
+        filter.permit :name, :facility, :asn,
+          :physical_address, :shipping_address, :comments
+      end
+    end
+  end
+
+  def site_params
+    self.class.site_params_filter.filter_params(params, parameter_filter_context)
+  end
+end

data/app/controllers/foreman_datacenter/application_controller.rb

@@ -0,0 +1,99 @@
+module ForemanDatacenter
+  class ApplicationController < ApplicationController
+    rescue_from ActiveRecord::RecordNotFound, :with => :not_found
+
+    def not_found(exception = nil)
+      logger.debug "not found: #{exception}" if exception
+      respond_to do |format|
+        format.html { render "foreman_datacenter/common/404", :status => :not_found }
+        format.any { head :not_found}
+      end
+      true
+    end
+
+    def find_resource
+      instance_variable_set("@#{resource_name}",
+                            resource_finder(resource_scope, params[:id]))
+    end
+
+    def resource_finder(scope, id)
+      raise ActiveRecord::RecordNotFound if scope.empty?
+      result = scope.from_param(id) if scope.respond_to?(:from_param)
+      begin
+        result ||= scope.friendly.find(id) if scope.respond_to?(:friendly)
+      rescue ActiveRecord::RecordNotFound
+      end
+      result || scope.find(id)
+    end
+
+    def controller_permission
+      controller_name
+    end
+
+    def resource_name(resource = controller_name)
+      resource.singularize
+    end
+
+    def resource_class
+      @resource_class ||= resource_class_for(resource_name)
+      raise NameError, "Could not find resource class for resource #{resource_name}" if @resource_class.nil?
+      @resource_class
+    end
+
+    def resource_scope(options = {})
+      @resource_scope ||= scope_for(resource_class, options)
+    end
+
+    def scope_for(resource, options = {})
+      controller = options.delete(:controller){ controller_permission }
+      # don't call the #action_permission method here, we are not sure if the resource is authorized at this point
+      # calling #action_permission here can cause an exception, in order to avoid this, ensure :authorized beforehand
+      permission = options.delete(:permission)
+
+      if resource.respond_to?(:authorized)
+        permission ||= "#{action_permission}_#{controller}"
+        resource = resource.authorized(permission, resource)
+      end
+
+      resource.where(options)
+    end
+
+    def resource_class_for(resource)
+      klass = "ForemanDatacenter::#{resource.classify}".constantize
+      klass
+    rescue NameError
+      nil
+    end
+
+    # def resource_base_search_and_page(tables = [])
+    #   base = tables.empty? ? resource_base_with_search : resource_base_with_search.eager_load(*tables)
+    #   base.paginate(:page => params[:page], :per_page => params[:per_page])
+    # end
+
+    def action_permission
+      case params[:action]
+        when 'new_connection'
+          'new_connection'
+        when 'connect'
+          'connect'
+        when 'planned'
+          'planned'
+        when 'connected'
+          'connected'
+        when 'disconnect'
+          'disconnect'
+        when 'populate_new'
+          'populate_new'
+        when 'depopulate'
+          'depopulate'
+        when 'populate'
+          'populate'
+        when 'move'
+          'move'
+        else
+          super
+      end
+    end
+
+  end
+end

data/app/controllers/foreman_datacenter/comments_controller.rb

@@ -1,99 +1,84 @@
 module ForemanDatacenter
-  class CommentsController < ApplicationController
-    before_action :load_resource, :load_commentable, :load_current_user
-    before_action :check_owner, only: [:edit]
+  class CommentsController < ForemanDatacenter::ApplicationController
+    include ForemanDatacenter::Controller::Parameters::Comment
+
+    before_action :load_resource, only: [:create]
 
     def new
-      @comment = Comment.new
-      @parent = Comment.find(params[:parent_id])
+      @comment = ForemanDatacenter::Comment.new
+      @parent = ForemanDatacenter::Comment.find(params[:parent_id])
+      @resource_class = @parent.commentable_type.gsub("ForemanDatacenter::","")
+      @resource = @resource_class.pluralize.split(/(?<!\s)(?=[A-Z])/).join('_').downcase
+      @commentable = load_resource(@resource, @parent.commentable_id)
     end
 
     def edit
-      @comment = Comment.find(params[:id])
+      @comment = ForemanDatacenter::Comment.find(params[:id])
       @parent = @comment.parent
+      @resource_class = @comment.commentable_type.split("::")[1]
+      @current_user = current_user
     end
 
     def create
-      @comment = @commentable.comments.new(comment_params.merge(user_id: User.current.id))
+      @comment = @commentable.comments.new(comment_params.merge(user_id: current_user.id))
       if @comment.save
-        process_success :success_redirect => "/datacenter/#{@resource}/#{@id}#comment-#{@comment.id}", success_msg: "Comment successfully created."
+        process_success success_redirect: commentable_path(@comment),
+                        success_msg: "Comment successfully created."
       else
-        process_error :redirect => "/datacenter/#{@resource}/#{@id}", :error_msg => _("Failed: %s") % (e)
+        process_error redirect: "/datacenter/#{@resource}/#{@id}", :error_msg => _("Failed: %s") % (e)
       end
     end
 
     def update
-      @comment = Comment.find(params[:id])
-      @device = find_commentable(@comment)
-      @submodule = parse_submodule(@comment)
-      if @comment.user == @current_user or @comment.user.nil?
-        if @comment.update(comment_params)
-          process_success :success_redirect => "/datacenter/#{@submodule}/#{@comment.commentable_id}#comment-#{@comment.id}", success_msg: "Comment successfully updated."
+      @comment = ForemanDatacenter::Comment.find(params[:id])
+      @resource = @comment.commentable_type.split("::")[1]
+      if @comment.user == current_user or @comment.user.nil? or current_user.admin?
+        if @comment.update(comment_params.merge(user_id: current_user.id))
+          process_success :success_redirect => commentable_path(@comment), success_msg: "Comment successfully updated."
         else
-          process_error :redirect => "/datacenter/#{@submodule}/#{@comment.commentable_id}#comment-#{@comment.id}", :error_msg => _("Failed: %s") % (e)
+          process_error :redirect => commentable_path(@comment), :error_msg => _("Failed: %s") % (e)
         end
       else
-          process_error :redirect => "/datacenter/#{@submodule}/#{@comment.commentable_id}#comment-#{@comment.id}", :error_msg => _("You can edit only your own comments")
+          process_error :redirect => commentable_path(@comment), :error_msg => _("You can edit only your own comments")
       end
     end
 
     def destroy
-      @comment = Comment.find(params[:id])
-      if @comment.user == @current_user or @comment.user.nil?
+      @comment = ForemanDatacenter::Comment.find(params[:id])
+      if @comment.user == current_user or @comment.user.nil? or current_user.admin?
         if @comment.destroy
-          process_success :success_redirect => "/datacenter/#{@resource}/#{@id}#comment-#{@comment.id}", success_msg: "Comment successfully deleted."
+          process_success :success_redirect => commentable_path(@comment, true), success_msg: "Comment successfully deleted."
         else
-          process_error :redirect => "/datacenter/#{@resource}/#{@id}", :error_msg => _("Failed: %s") % (e)
+          process_error :redirect => commentable_path(@comment, true), :error_msg => _("Failed: %s") % (e)
         end
       else
-          process_error :redirect => "/datacenter/#{@resource}/#{@id}", :error_msg => _("You can delete only your own comments")
+          process_error :redirect => commentable_path(@comment, true), :error_msg => _("You can delete only your own comments")
       end
     end
 
     private
 
-    def load_current_user
-      @current_user = User.current
-    end
-
-    def check_owner
-      comment = Comment.find(params[:id])
-      commentable = comment.commentable_type.constantize.find(comment.commentable_id)
-      resource = parse_submodule(comment)
-      unless comment.user == @current_user or comment.user.nil?
-        process_error :redirect => (request.referrer || "/datacenter/#{resource}/#{commentable.id}" || root_path), :error_msg => _("You can edit only your own comments")
-        return
-      end
-    end
-
-    def load_resource
-      if (params[:resource] && params[:resource_id])
-        @resource, @id = params[:resource], params[:resource_id]
+    def commentable_path(comment, r = false)
+      resource = comment.commentable.class.to_s.gsub("ForemanDatacenter::","").pluralize.split(/(?<!\s)(?=[A-Z])/).join('_').downcase
+      if r == false
+        return "/datacenter/#{resource}/#{comment.commentable.id}#comment-#{comment.id}"
       else
-        @resource, @id = request.path.split('/')[2, 3]
+        return "/datacenter/#{resource}/#{comment.commentable.id}"
       end
     end
 
-    def load_commentable
-      begin
+    def load_resource(resource = nil, id = nil)
+      if resource.nil?
+        @resource, @id = request.path.split('/')[2, 3] if resource.nil?
         @commentable = "foreman_datacenter::#{@resource.capitalize}".singularize.classify.constantize.find(@id.to_i)
-      rescue
-        @commentable = "foreman_datacenter::#{params[:resource].capitalize}".singularize.classify.constantize.find(params[:resource_id].to_i)
+      else
+        @commentable = "foreman_datacenter::#{resource.capitalize}".singularize.classify.constantize.find(id.to_i)
       end
     end
 
     def comment_params
       params[:foreman_datacenter_comment].permit(:content, :commntable_type, :commentable_id, :parent_id, :user_id)
     end
-
-    def find_commentable(comment)
-      comment.commentable_type.classify.constantize.find(comment.commentable_id)
-    end
-
-    def parse_submodule(comment)
-      comment.commentable_type.gsub("ForemanDatacenter::", "").pluralize.downcase
-    end
-
   end
 end
 

data/app/controllers/foreman_datacenter/console_port_templates_controller.rb

@@ -1,19 +1,20 @@
 module ForemanDatacenter
-  class ConsolePortTemplatesController < ApplicationController
-    before_action :set_console_port_template, only: [:destroy]
+  class ConsolePortTemplatesController < ForemanDatacenter::ApplicationController
+    include ForemanDatacenter::Controller::Parameters::ConsolePortTemplate
+
+    before_action :find_resource, only: [:destroy]
 
     def new
-      @console_port_template = ConsolePortTemplate.new(
-        device_type: DeviceType.find(params[:device_type_id])
+      @console_port_template = ForemanDatacenter::ConsolePortTemplate.new(
+        device_type: ForemanDatacenter::DeviceType.find(params[:device_type_id])
       )
     end
 
     def create
-      @console_port_template = ConsolePortTemplate.new(console_port_template_params)
+      @console_port_template = ForemanDatacenter::ConsolePortTemplate.new(console_port_template_params.merge(device_type_id: params[:device_type_id]))
 
       if @console_port_template.save
-        redirect_to device_type_url(@console_port_template.device_type),
-                    notice: 'New console port template was successfully created'
+        process_success success_redirect: device_type_url(@console_port_template.device_type_id)
       else
         process_error object: @console_port_template
       end
@@ -21,21 +22,10 @@ module ForemanDatacenter
 
     def destroy
       if @console_port_template.destroy
-        redirect_to device_type_url(@console_port_template.device_type),
-                    notice: 'Console port template was successfully destroyed'
+        process_success success_redirect: device_type_url(params[:device_type_id])
       else
         process_error object: @console_port_template
       end
     end
-
-    private
-
-    def set_console_port_template
-      @console_port_template = ConsolePortTemplate.find(params[:id])
-    end
-
-    def console_port_template_params
-      params[:console_port_template].permit(:device_type_id, :name)
-    end
   end
 end

data/app/controllers/foreman_datacenter/console_ports_controller.rb

@@ -1,12 +1,16 @@
 module ForemanDatacenter
-  class ConsolePortsController < ApplicationController
-    before_action :set_console_port, only: [:edit, :update, :destroy,
-                                            :connected, :planned, :new_connection,
-                                            :connect, :disconnect]
+  class ConsolePortsController < ForemanDatacenter::ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+    include ForemanDatacenter::Controller::Parameters::ConsolePort
+
+    before_action :find_resource, only: [:edit, :update, :destroy,
+                                         :connected, :planned, :new_connection,
+                                         :connect, :disconnect]
 
     def index
-      @console_ports = ConsolePort.where.not(console_server_port_id: nil).
-        includes(:device, console_server_port: [:device])
+      @console_ports = resource_base_search_and_page.where.not(console_server_port_id: nil).includes(:device, console_server_port: [:device])
+      # @console_ports = ConsolePort.where.not(console_server_port_id: nil).
+      #   includes(:device, console_server_port: [:device])
     end
 
     def new
@@ -19,11 +23,10 @@ module ForemanDatacenter
     end
 
     def create
-      @console_port = ConsolePort.new(console_port_params)
+      @console_port = ConsolePort.new(console_port_params.merge(device_id: params[:device_id]))
 
       if @console_port.save
-        redirect_to device_url(id: @console_port.device_id),
-                    notice: 'Console port was successfully created.'
+        process_success success_redirect: device_path(@console_port.device_id)
       else
         process_error object: @console_port
       end
@@ -31,8 +34,7 @@ module ForemanDatacenter
 
     def update
       if @console_port.update(console_port_params)
-        redirect_to device_url(id: @console_port.device_id),
-                    notice: 'Console port was successfully updated.'
+        process_success success_redirect: device_path(@console_port.device_id)
       else
         process_error object: @console_port
       end
@@ -40,8 +42,7 @@ module ForemanDatacenter
 
     def destroy
       if @console_port.destroy
-        redirect_to device_url(id: @console_port.device_id),
-                    notice: 'Console port was successfully destroyed.'
+        process_success success_redirect: device_path(@console_port.device_id)
       else
         process_error object: @console_port
       end
@@ -80,15 +81,5 @@ module ForemanDatacenter
       redirect_to device_url(id: @console_port.device_id),
                   notice: 'Console port was successfully disconnected.'
     end
-
-    private
-
-    def set_console_port
-      @console_port = ConsolePort.find(params[:id])
-    end
-
-    def console_port_params
-      params[:console_port].permit(:device_id, :name)
-    end
   end
 end

data/app/controllers/foreman_datacenter/console_server_port_templates_controller.rb

@@ -1,19 +1,20 @@
 module ForemanDatacenter
-  class ConsoleServerPortTemplatesController < ApplicationController
-    before_action :set_console_server_port_template, only: [:destroy]
+  class ConsoleServerPortTemplatesController < ForemanDatacenter::ApplicationController
+    include ForemanDatacenter::Controller::Parameters::ConsoleServerPortTemplate
+
+    before_action :find_resource, only: [:destroy]
 
     def new
-      @console_server_port_template = ConsoleServerPortTemplate.new(
-        device_type: DeviceType.find(params[:device_type_id])
+      @console_server_port_template = ForemanDatacenter::ConsoleServerPortTemplate.new(
+        device_type: ForemanDatacenter::DeviceType.find(params[:device_type_id])
       )
     end
 
     def create
-      @console_server_port_template = ConsoleServerPortTemplate.new(console_server_port_template_params)
+      @console_server_port_template = ForemanDatacenter::ConsoleServerPortTemplate.new(console_server_port_template_params.merge(device_type_id: params[:device_type_id]))
 
       if @console_server_port_template.save
-        redirect_to device_type_url(@console_server_port_template.device_type),
-                    notice: 'New console server port template was successfully created'
+        process_success success_redirect: device_type_url(@console_server_port_template.device_type_id)
       else
         process_error object: @console_server_port_template
       end
@@ -21,21 +22,10 @@ module ForemanDatacenter
 
     def destroy
       if @console_server_port_template.destroy
-        redirect_to device_type_url(@console_server_port_template.device_type),
-                    notice: 'Console server port template was successfully destroyed'
+        process_success success_redirect: device_type_url(params[:device_type_id])
       else
         process_error object: @console_server_port_template
       end
     end
-
-    private
-
-    def set_console_server_port_template
-      @console_server_port_template = ConsoleServerPortTemplate.find(params[:id])
-    end
-
-    def console_server_port_template_params
-      params[:console_server_port_template].permit(:device_type_id, :name)
-    end
   end
 end

data/app/controllers/foreman_datacenter/console_server_ports_controller.rb

@@ -1,19 +1,21 @@
 module ForemanDatacenter
-  class ConsoleServerPortsController < ApplicationController
-    before_action :set_console_server_port, only: [:edit, :update, :destroy,
-                                                   :new_connection, :connect,
-                                                   :disconnect]
+  class ConsoleServerPortsController < ForemanDatacenter::ApplicationController
+    include ForemanDatacenter::Controller::Parameters::ConsoleServerPort
+
+    before_action :find_resource, only: [:edit, :update, :destroy,
+                                         :new_connection, :connect,
+                                         :disconnect]
 
     def new
-      device = Device.find(params[:device_id])
-      @console_server_port = ConsoleServerPort.new(device: device)
+      device = ForemanDatacenter::Device.find(params[:device_id])
+      @console_server_port = ForemanDatacenter::ConsoleServerPort.new(device: device)
     end
 
     def edit
     end
 
     def create
-      @console_server_port = ConsoleServerPort.new(console_server_port_params)
+      @console_server_port = ForemanDatacenter::ConsoleServerPort.new(console_server_port_params.merge(device_id: params[:device_id]))
 
       if @console_server_port.save
         redirect_to device_url(id: @console_server_port.device_id),
@@ -45,7 +47,7 @@ module ForemanDatacenter
     end
 
     def connect
-      console_port = ConsolePort.find(params[:console_port][:id])
+      console_port = ForemanDatacenter::ConsolePort.find(params[:console_port][:id])
       console_port.connect(
         @console_server_port,
         params[:console_port][:connection_status]
@@ -61,18 +63,8 @@ module ForemanDatacenter
     end
 
     def for_device
-      @device = Device.find(params[:device_id])
+      @device = ForemanDatacenter::Device.find(params[:device_id])
       render partial: 'for_device'
     end
-
-    private
-
-    def set_console_server_port
-      @console_server_port = ConsoleServerPort.find(params[:id])
-    end
-
-    def console_server_port_params
-      params[:console_server_port].permit(:device_id, :name)
-    end
   end
 end