foreman_datacenter 0.1.54 → 0.1.55

data/app/controllers/foreman_datacenter/device_bay_templates_controller.rb

@@ -1,19 +1,20 @@
 module ForemanDatacenter
-  class DeviceBayTemplatesController < ApplicationController
-    before_action :set_device_bay_template, only: [:destroy]
+  class DeviceBayTemplatesController < ForemanDatacenter::ApplicationController
+    include ForemanDatacenter::Controller::Parameters::DeviceBayTemplate
+
+    before_action :find_resource, only: [:destroy]
 
     def new
-      @device_bay_template = DeviceBayTemplate.new(
-        device_type: DeviceType.find(params[:device_type_id])
+      @device_bay_template = ForemanDatacenter::DeviceBayTemplate.new(
+        device_type: ForemanDatacenter::DeviceType.find(params[:device_type_id])
       )
     end
 
     def create
-      @device_bay_template = DeviceBayTemplate.new(device_bay_template_params)
+      @device_bay_template = ForemanDatacenter::DeviceBayTemplate.new(device_bay_template_params.merge(device_type_id: params[:device_type_id]))
 
       if @device_bay_template.save
-        redirect_to device_type_url(@device_bay_template.device_type),
-                    notice: 'Device bay template was successfully created'
+        process_success success_redirect: device_type_url(@device_bay_template.device_type_id)
       else
         process_error object: @device_bay_template
       end
@@ -21,21 +22,10 @@ module ForemanDatacenter
 
     def destroy
       if @device_bay_template.destroy
-        redirect_to device_type_url(@device_bay_template.device_type),
-                    notice: 'Device bay template was successfully destroyed'
+        process_success success_redirect: device_type_url(params[:device_type_id])
       else
         process_error object: @device_bay_template
       end
     end
-
-    private
-
-    def set_device_bay_template
-      @device_bay_template = DeviceBayTemplate.find(params[:id])
-    end
-
-    def device_bay_template_params
-      params[:device_bay_template].permit(:device_type_id, :name)
-    end
   end
 end

data/app/controllers/foreman_datacenter/device_bays_controller.rb

@@ -1,17 +1,20 @@
 module ForemanDatacenter
-  class DeviceBaysController < ApplicationController
-    before_action :set_device_bay, only: [:depopulate, :populate,
-                                          :populate_new, :edit, :update, :destroy]
+  class DeviceBaysController < ForemanDatacenter::ApplicationController
+    include ForemanDatacenter::Controller::Parameters::DeviceBay
+
+    before_action :find_resource, only: [:depopulate, :populate,
+                                         :populate_new, :edit,
+                                         :update, :destroy]
 
     def new
-      @device_bay = DeviceBay.new(device: Device.find(params[:device_id]))
+      @device_bay = ForemanDatacenter::DeviceBay.new(device: ForemanDatacenter::Device.find(params[:device_id]))
     end
 
     def edit
     end
 
     def create
-      @device_bay = DeviceBay.new(device_bay_params)
+      @device_bay = ForemanDatacenter::DeviceBay.new(device_bay_params.merge(device_id: params[:device_id]))
 
       if @device_bay.save
         redirect_to device_url(@device_bay.device),
@@ -60,15 +63,5 @@ module ForemanDatacenter
         process_error object: @device_bay
       end
     end
-
-    private
-
-    def set_device_bay
-      @device_bay = DeviceBay.find(params[:id])
-    end
-
-    def device_bay_params
-      params[:device_bay].permit(:name, :device_id)
-    end
   end
 end

data/app/controllers/foreman_datacenter/device_interface_connections_controller.rb

@@ -1,22 +1,22 @@
 module ForemanDatacenter
-  class DeviceInterfaceConnectionsController < ApplicationController
-    before_action :set_device_interface_connection,
-                  only: [:destroy, :planned, :connected]
+  class DeviceInterfaceConnectionsController < ForemanDatacenter::ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+    include ForemanDatacenter::Controller::Parameters::DeviceInterfaceConnection
+
+    before_action :find_resource, only: [:destroy, :planned, :connected]
 
     def index
-      @device_interface_connections = DeviceInterfaceConnection.includes(
-        :second_interface, first_interface: [:device]
-      )
+      @device_interface_connections = resource_base_search_and_page.includes(:second_interface, first_interface: [:device])
     end
 
     def new
-      @device_interface_connection = DeviceInterfaceConnection.connected.new(
+      @device_interface_connection = ForemanDatacenter::DeviceInterfaceConnection.connected.new(
         first_interface: get_device_interface
       )
     end
 
     def create
-      @device_interface_connection = DeviceInterfaceConnection.new(device_interface_connection_params)
+      @device_interface_connection = ForemanDatacenter::DeviceInterfaceConnection.new(device_interface_connection_params.merge(interface_a: params[:device_interface_id]))
       @device_interface_connection.first_interface = get_device_interface
 
       if @device_interface_connection.save
@@ -43,23 +43,14 @@ module ForemanDatacenter
     end
 
     def interfaces
-      @interfaces = Device.find(params[:device_id]).free_interfaces
+      @interfaces = ForemanDatacenter::Device.find(params[:device_id]).free_interfaces
       render partial: 'interfaces'
     end
 
     private
 
-    def set_device_interface_connection
-      @device_interface_connection = DeviceInterfaceConnection.find(params[:id])
-    end
-
-    def device_interface_connection_params
-      params[:device_interface_connection].
-        permit(:interface_a, :interface_b, :connection_status)
-    end
-
     def get_device_interface
-      DeviceInterface.find(params[:device_interface_id])
+      ForemanDatacenter::DeviceInterface.find(params[:device_interface_id])
     end
   end
 end

data/app/controllers/foreman_datacenter/device_interfaces_controller.rb

@@ -1,9 +1,11 @@
 module ForemanDatacenter
-  class DeviceInterfacesController < ApplicationController
-    before_action :set_device_interface, only: [:edit, :update, :destroy]
+  class DeviceInterfacesController < ForemanDatacenter::ApplicationController
+    include ForemanDatacenter::Controller::Parameters::DeviceInterface
+
+    before_action :find_resource, only: [:edit, :update, :destroy]
 
     def new
-      device = Device.find(params[:device_id])
+      device = ForemanDatacenter::Device.find(params[:device_id])
       @device_interface = DeviceInterface.new(
         device: device,
         form_factor: DeviceInterface::DEFAULT_FORM_FACTOR
@@ -11,8 +13,8 @@ module ForemanDatacenter
     end
 
     def new_management
-      @device_interface = DeviceInterface.new(
-        device: Device.find(params[:device_id]),
+      @device_interface = ForemanDatacenter::DeviceInterface.new(
+        device: ForemanDatacenter::Device.find(params[:device_id]),
         form_factor: DeviceInterface::DEFAULT_FORM_FACTOR,
         mgmt_only: true
       )
@@ -23,7 +25,7 @@ module ForemanDatacenter
     end
 
     def create
-      @device_interface = DeviceInterface.new(device_interface_params)
+      @device_interface = ForemanDatacenter::DeviceInterface.new(device_interface_params.merge(device_id: params[:device_id]))
 
       if @device_interface.save
         redirect_to device_url(id: @device_interface.device_id),
@@ -50,16 +52,5 @@ module ForemanDatacenter
         process_error object: @device_interface
       end
     end
-
-    private
-
-    def set_device_interface
-      @device_interface = DeviceInterface.find(params[:id])
-    end
-
-    def device_interface_params
-      params[:device_interface].
-        permit(:device_id, :name, :form_factor, :mac_address, :mgmt_only, :description, :ip_address)
-    end
   end
 end

data/app/controllers/foreman_datacenter/device_modules_controller.rb

@@ -1,10 +1,12 @@
 module ForemanDatacenter
   class DeviceModulesController < ApplicationController
-    before_action :set_device_module, only: [:edit, :update, :destroy]
+    include ForemanDatacenter::Controller::Parameters::DeviceModule
+
+    before_action :find_resource, only: [:edit, :update, :destroy]
 
     def new
-      @device_module = DeviceModule.new(
-        device: Device.find(params[:device_id])
+      @device_module = ForemanDatacenter::DeviceModule.new(
+        device: ForemanDatacenter::Device.find(params[:device_id])
       )
     end
 
@@ -12,7 +14,7 @@ module ForemanDatacenter
     end
 
     def create
-      @device_module = DeviceModule.new(device_module_params)
+      @device_module = ForemanDatacenter::DeviceModule.new(device_module_params.merge(device_id: params[:device_id]))
 
       if @device_module.save
         redirect_to inventory_device_url(id: @device_module.device_id),
@@ -39,15 +41,5 @@ module ForemanDatacenter
         process_error object: @device_module
       end
     end
-
-    private
-
-    def set_device_module
-      @device_module = DeviceModule.find(params[:id])
-    end
-
-    def device_module_params
-      params[:device_module].permit(:device_id, :name, :part_id, :serial)
-    end
   end
 end

data/app/controllers/foreman_datacenter/device_roles_controller.rb

@@ -1,23 +1,26 @@
 module ForemanDatacenter
-  class DeviceRolesController < ApplicationController
-    before_action :set_device_role, only: [:show, :edit, :update, :destroy]
+  class DeviceRolesController < ForemanDatacenter::ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+    include ForemanDatacenter::Controller::Parameters::DeviceRole
+
+    before_action :find_resource, only: [:show, :edit, :update, :destroy]
 
     def index
-      @device_roles = DeviceRole.includes(:devices).all
+      @device_roles = resource_base_search_and_page
     end
 
     def show
     end
 
     def new
-      @device_role = DeviceRole.new
+      @device_role = ForemanDatacenter::DeviceRole.new
     end
 
     def edit
     end
 
     def create
-      @device_role = DeviceRole.new(device_role_params)
+      @device_role = ForemanDatacenter::DeviceRole.new(device_role_params)
 
       if @device_role.save
         process_success object: @device_role
@@ -35,21 +38,17 @@ module ForemanDatacenter
     end
 
     def destroy
+      unless params['object_only']
+        @device_role.devices.each { |d| d.destroy }
+      else
+        @device_role.devices.delete_all(:nullify)
+      end
+
       if @device_role.destroy
-        process_success object: @device_role
+        process_success success_redirect: device_roles_path
       else
         process_error object: @device_role
       end
     end
-
-    private
-
-    def set_device_role
-      @device_role = DeviceRole.find(params[:id])
-    end
-
-    def device_role_params
-      params[:device_role].permit(:name, :color)
-    end
   end
 end

data/app/controllers/foreman_datacenter/device_types_controller.rb

@@ -1,26 +1,28 @@
 module ForemanDatacenter
-  class DeviceTypesController < ApplicationController
-    before_action :set_device_type, only: [:show, :edit, :update, :destroy]
+  class DeviceTypesController < ForemanDatacenter::ApplicationController
+    include Foreman::Controller::AutoCompleteSearch
+    include ForemanDatacenter::Controller::Parameters::DeviceType
+
+    before_action :find_resource, only: [:show, :edit, :update, :destroy]
 
     def index
-      @device_types = DeviceType.includes(:manufacturer).
-        paginate(:page => params[:page], :per_page => params[:per_page])
+      @device_types = resource_base_search_and_page.includes(:manufacturer)
     end
 
     def show
     end
 
     def new
-      @device_type = DeviceType.new(u_height: 1, is_full_depth: true,
-                                    is_console_server: false, is_pdu: false,
-                                    is_network_device: true)
+      @device_type = ForemanDatacenter::DeviceType.new(u_height: 1, is_full_depth: true,
+                                                       is_console_server: false, is_pdu: false,
+                                                       is_network_device: true)
     end
 
     def edit
     end
 
     def create
-      @device_type = DeviceType.new(device_type_params)
+      @device_type = ForemanDatacenter::DeviceType.new(device_type_params)
 
       if @device_type.save
         process_success object: @device_type
@@ -39,23 +41,17 @@ module ForemanDatacenter
     end
 
     def destroy
+      unless params['object_only']
+        @device_type.devices.each { |d| d.destroy }
+      else
+        @device_type.devices.delete_all(:nullify)
+      end
+
       if @device_type.destroy
-        process_success object: @device_type
+        process_success success_redirect: device_types_path
       else
         process_error object: @device_type
       end
     end
-
-    private
-
-    def set_device_type
-      @device_type = DeviceType.find(params[:id])
-    end
-
-    def device_type_params
-      params[:device_type].permit(:manufacturer_id, :model, :u_height,
-                                  :is_full_depth, :is_console_server,
-                                  :is_pdu, :is_network_device, :subdevice_role)
-    end
   end
 end

data/app/controllers/foreman_datacenter/devices_controller.rb

@@ -3,57 +3,52 @@ require 'prawn'
 require 'prawn/measurement_extensions'
 
 module ForemanDatacenter
-  class DevicesController < ApplicationController
+  class DevicesController < ForemanDatacenter::ApplicationController
     include Foreman::Controller::AutoCompleteSearch
+    include ForemanDatacenter::Controller::Parameters::Device
 
-    before_action :set_device, only: [:update, :destroy, :inventory,
-                                      :destroy_interfaces, :qr_code,
-                                      :sync_interfaces_with_host]
-
-    before_action :load_resource
+    before_action :find_resource, only: [:update, :destroy, :inventory,
+                                         :destroy_interfaces, :qr_code,
+                                         :sync_interfaces_with_host]
 
     def index
-      begin
-        search = resource_base.search_for(params[:search], :order => params[:order])
-      rescue => e
-        error e.to_s
-        search = resource_base.search_for ''
-      end
-      @devices = search.includes(:device_role, :device_type, :site, :rack).
-        paginate(:page => params[:page], :per_page => params[:per_page])
+      @devices = resource_base_search_and_page.includes(:device_role, :device_type, :site, :rack)
     end
 
     def show
-      @device = Device.includes(
+      @device = ForemanDatacenter::Device.includes(
+        power_ports: [:power_outlet, :device],
+        power_outlets: [:device, :power_port],
+        console_ports: [:console_server_port, :device],
+        console_server_ports: [:console_port, :device],
         device_bays: [:installed_device],
-        console_server_ports: [:console_port],
-        power_outlets: [:power_port],
-        console_ports: [:console_server_port],
-        power_ports: [:power_outlet]
+        comments: [:user]
       ).find(params[:id])
-      @current_user = User.current
+      @comments = @device.comments
       @commentable = @device
-      @comment = Comment.new
+      @comment = ForemanDatacenter::Comment.new
+      @resource = request.path.split('/')[2]
+      @current_user = current_user
     end
 
     def inventory
     end
 
     def new
-      @device = Device.new
+      @device = ForemanDatacenter::Device.new
       populate_from_host
     end
 
     def edit
-      @device = Device.find(params[:id])
+      @device = ForemanDatacenter::Device.find(params[:id])
       populate_from_host
     end
 
     def create
-      @device = Device.new(device_params)
+      @device = ForemanDatacenter::Device.new(device_params.merge(host_id: params[:host_id]))
 
       if @device.save
-        process_success object: @device
+        process_success success_redirect: device_url(@device)
       else
         process_error object: @device
       end
@@ -68,10 +63,21 @@ module ForemanDatacenter
     end
 
     def destroy
-      if @device.destroy
-        process_success success_redirect: "/datacenter/devices"
+      unless params['object_only']
+        if @device.destroy
+          process_success success_redirect: "/datacenter/devices"
+        else
+          process_error object: @device
+        end
       else
-        process_error object: @device
+        if @device.host
+          @device.host.destroy
+          new_device_name = "Unassigned device (former: #{@device.name})"
+          @device.update(name: new_device_name)
+          process_success success_redirect: '/datacenter/devices', success_msg: 'Associated host deleted'
+        else
+          process_error success_redirect: '/datacenter/devices', error_msg: 'Associated host not found'
+        end
       end
     end
 
@@ -91,7 +97,7 @@ module ForemanDatacenter
     end
 
     def site_racks
-      @site = Site.find(params[:site_id])
+      @site = ForemanDatacenter::Site.find(params[:site_id])
       render partial: 'site_racks'
     end
 
@@ -125,22 +131,6 @@ module ForemanDatacenter
 
     private
 
-    def set_device
-      @device = Device.find(params[:id])
-    end
-
-    def device_params
-      params[:device].permit(:device_type_id, :device_role_id, :platform_id,
-                             :name, :serial, :rack_id, :position, :side,
-                             :face, :status, :primary_ip4, :primary_ip6,
-                             :host_id, :size)
-    end
-
-    def load_resource
-      resource, id = request.path.split('/')[2, 3]
-      @commentable_data = {resource: resource, id: id }
-    end
-
     def populate_from_host
       if params[:host_id]
         host = Host.find(params[:host_id])