foreman_datacenter 0.0.1

data/app/controllers/foreman_datacenter/device_bay_templates_controller.rb

@@ -0,0 +1,41 @@
+module ForemanDatacenter
+  class DeviceBayTemplatesController < ApplicationController
+    before_action :set_device_bay_template, only: [:destroy]
+
+    def new
+      @device_bay_template = DeviceBayTemplate.new(
+        device_type: DeviceType.find(params[:device_type_id])
+      )
+    end
+
+    def create
+      @device_bay_template = DeviceBayTemplate.new(device_bay_template_params)
+
+      if @device_bay_template.save
+        redirect_to device_type_url(@device_bay_template.device_type),
+                    notice: 'Device bay template was successfully created'
+      else
+        process_error object: @device_bay_template
+      end
+    end
+
+    def destroy
+      if @device_bay_template.destroy
+        redirect_to device_type_url(@device_bay_template.device_type),
+                    notice: 'Device bay template was successfully destroyed'
+      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

@@ -0,0 +1,74 @@
+module ForemanDatacenter
+  class DeviceBaysController < ApplicationController
+    before_action :set_device_bay, only: [:depopulate, :populate,
+                                          :populate_new, :edit, :update, :destroy]
+
+    def new
+      @device_bay = DeviceBay.new(device: Device.find(params[:device_id]))
+    end
+
+    def edit
+    end
+
+    def create
+      @device_bay = DeviceBay.new(device_bay_params)
+
+      if @device_bay.save
+        redirect_to device_url(@device_bay.device),
+                    notice: 'New device bay was successfully created'
+      else
+        process_error object: @device_bay
+      end
+    end
+
+    def update
+      if @device_bay.update(device_bay_params)
+        redirect_to device_url(@device_bay.device),
+                    notice: 'Device bay was successfully updated'
+      else
+        process_error object: @device_bay
+      end
+    end
+
+    def destroy
+      if @device_bay.destroy
+        redirect_to device_url(@device_bay.device),
+                    notice: 'Device bay was successfully destroyed'
+      else
+        process_error object: @device_bay
+      end
+    end
+
+    def populate_new
+    end
+
+    def populate
+      device_id = params[:device_bay][:installed_device_id]
+      if @device_bay.update(installed_device_id: device_id)
+        redirect_to device_url(@device_bay.device),
+                    notice: 'Device bay was successfully populated'
+      else
+        process_error object: @device_bay
+      end
+    end
+
+    def depopulate
+      if @device_bay.update(installed_device_id: nil)
+        redirect_to device_url(@device_bay.device),
+                    notice: 'Device bay was successfully depopulated'
+      else
+        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

@@ -0,0 +1,65 @@
+module ForemanDatacenter
+  class DeviceInterfaceConnectionsController < ApplicationController
+    before_action :set_device_interface_connection,
+                  only: [:destroy, :planned, :connected]
+
+    def index
+      @device_interface_connections = DeviceInterfaceConnection.includes(
+        :second_interface, first_interface: [:device]
+      )
+    end
+
+    def new
+      @device_interface_connection = DeviceInterfaceConnection.connected.new(
+        first_interface: get_device_interface
+      )
+    end
+
+    def create
+      @device_interface_connection = DeviceInterfaceConnection.new(device_interface_connection_params)
+      @device_interface_connection.first_interface = get_device_interface
+
+      if @device_interface_connection.save
+        redirect_to device_url(@device_interface_connection.first_interface.device),
+                    notice: 'Connection was successfully created.'
+      else
+        process_error object: @device_interface_connection
+      end
+    end
+
+    def destroy
+      @device_interface_connection.destroy
+      head :ok
+    end
+
+    def planned
+      @device_interface_connection.planned!
+      head :ok
+    end
+
+    def connected
+      @device_interface_connection.connected!
+      head :ok
+    end
+
+    def interfaces
+      @interfaces = 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])
+    end
+  end
+end

data/app/controllers/foreman_datacenter/device_interfaces_controller.rb

@@ -0,0 +1,65 @@
+module ForemanDatacenter
+  class DeviceInterfacesController < ApplicationController
+    before_action :set_device_interface, only: [:edit, :update, :destroy]
+
+    def new
+      device = Device.find(params[:device_id])
+      @device_interface = DeviceInterface.new(
+        device: device,
+        form_factor: DeviceInterface::DEFAULT_FORM_FACTOR
+      )
+    end
+
+    def new_management
+      @device_interface = DeviceInterface.new(
+        device: Device.find(params[:device_id]),
+        form_factor: DeviceInterface::DEFAULT_FORM_FACTOR,
+        mgmt_only: true
+      )
+      render :new
+    end
+
+    def edit
+    end
+
+    def create
+      @device_interface = DeviceInterface.new(device_interface_params)
+
+      if @device_interface.save
+        redirect_to device_url(id: @device_interface.device_id),
+                    notice: 'Device interface was successfully created.'
+      else
+        process_error object: @device_interface
+      end
+    end
+
+    def update
+      if @device_interface.update(device_interface_params)
+        redirect_to device_url(id: @device_interface.device_id),
+                    notice: 'Device interface was successfully updated.'
+      else
+        process_error object: @device_interface
+      end
+    end
+
+    def destroy
+      if @device_interface.destroy
+        redirect_to device_url(id: @device_interface.device_id),
+                    notice: 'Device interface was successfully destroyed.'
+      else
+        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)
+    end
+  end
+end

data/app/controllers/foreman_datacenter/device_modules_controller.rb

@@ -0,0 +1,53 @@
+module ForemanDatacenter
+  class DeviceModulesController < ApplicationController
+    before_action :set_device_module, only: [:edit, :update, :destroy]
+
+    def new
+      @device_module = DeviceModule.new(
+        device: Device.find(params[:device_id])
+      )
+    end
+
+    def edit
+    end
+
+    def create
+      @device_module = DeviceModule.new(device_module_params)
+
+      if @device_module.save
+        redirect_to inventory_device_url(id: @device_module.device_id),
+                    notice: 'Device module was successfully created.'
+      else
+        process_error object: @device_module
+      end
+    end
+
+    def update
+      if @device_module.update(device_module_params)
+        redirect_to inventory_device_url(id: @device_module.device_id),
+                    notice: 'Device module was successfully updated.'
+      else
+        process_error object: @device_module
+      end
+    end
+
+    def destroy
+      if @device_module.destroy
+        redirect_to inventory_device_url(id: @device_module.device_id),
+                    notice: 'Device module was successfully destroyed.'
+      else
+        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

@@ -0,0 +1,55 @@
+module ForemanDatacenter
+  class DeviceRolesController < ApplicationController
+    before_action :set_device_role, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @device_roles = DeviceRole.includes(:devices).all
+    end
+
+    def show
+    end
+
+    def new
+      @device_role = DeviceRole.new
+    end
+
+    def edit
+    end
+
+    def create
+      @device_role = DeviceRole.new(device_role_params)
+
+      if @device_role.save
+        process_success object: @device_role
+      else
+        process_error object: @device_role
+      end
+    end
+
+    def update
+      if @device_role.update(device_role_params)
+        process_success object: @device_role
+      else
+        process_error object: @device_role
+      end
+    end
+
+    def destroy
+      if @device_role.destroy
+        process_success object: @device_role
+      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

@@ -0,0 +1,60 @@
+module ForemanDatacenter
+  class DeviceTypesController < ApplicationController
+    before_action :set_device_type, only: [:show, :edit, :update, :destroy]
+
+    def index
+      @device_types = DeviceType.includes(:manufacturer).all
+    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)
+    end
+
+    def edit
+    end
+
+    def create
+      @device_type = DeviceType.new(device_type_params)
+
+      if @device_type.save
+        process_success object: @device_type
+      else
+        process_error object: @device_type
+      end
+    end
+
+    def update
+      if @device_type.update(device_type_params)
+        redirect_to device_type_url(@device_type),
+                    notice: 'Device type was successfully updated'
+      else
+        process_error object: @device_type
+      end
+    end
+
+    def destroy
+      if @device_type.destroy
+        process_success object: @device_type
+      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

@@ -0,0 +1,82 @@
+module ForemanDatacenter
+  class DevicesController < ApplicationController
+    before_action :set_device, only: [:edit, :update, :destroy, :inventory]
+
+    def index
+      @devices = Device.includes(:device_role, :device_type, rack: [:site]).all
+    end
+
+    def show
+      @device = Device.includes(
+        device_bays: [:installed_device],
+        console_server_ports: [:console_port],
+        power_outlets: [:power_port],
+        console_ports: [:console_server_port],
+        power_ports: [:power_outlet]
+      ).find(params[:id])
+    end
+
+    def inventory
+    end
+
+    def new
+      @device = Device.new
+    end
+
+    def edit
+    end
+
+    def create
+      @device = Device.new(device_params)
+
+      if @device.save
+        process_success object: @device
+      else
+        process_error object: @device
+      end
+    end
+
+    def update
+      if @device.update(device_params)
+        process_success object: @device
+      else
+        process_error object: @device
+      end
+    end
+
+    def destroy
+      if @device.destroy
+        process_success object: @device
+      else
+        process_error object: @device
+      end
+    end
+
+    def device_types
+      @manufacturer_id = params[:manufacturer_id]
+      render partial: 'device_types'
+    end
+
+    def racks
+      @site_id = params[:site_id]
+      render partial: 'racks'
+    end
+
+    def for_rack
+      @rack = ForemanDatacenter::Rack.find(params[:rack_id])
+      render partial: 'for_rack'
+    end
+
+    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, :face,
+                             :status, :primary_ip4, :primary_ip6, :comments)
+    end
+  end
+end