diff --git a/app/controllers/hosts_controller.rb b/app/controllers/hosts_controller.rb
index 3c46da0..7cbdf29 100644
--- a/app/controllers/hosts_controller.rb
+++ b/app/controllers/hosts_controller.rb
@@ -1,63 +1,63 @@
 class HostsController < ApplicationController
   before_action :fetch_host, only: [:show, :edit, :update, :destroy, :submit_config, :revoke]
 
-  # GET /hosts
+  # GET /hosts/new
   def new
     @host = Host.new
   end
 
   # POST /hosts
   def create
     @host = Host.new(fetch_params)
     if @host.save
       redirect_to host_path @host
     else
       render :new
     end
   end
 
   # GET /hosts/1
   def show; end
 
   # GET /hosts/1/edit
   def edit; end
 
   # PATCH /hosts/1
   def update
     updates = fetch_params.slice(:port, :password)
     if updates.present? && @host.update_attributes(updates)
       @host.recalculate
       redirect_to host_path @host
     else
       render :edit
     end
   end
 
   # DELETE /hosts/1
   def destroy
     @host.destroy
     redirect_to root_path
   end
 
   # POST /hosts/1/submit_config
   def submit_config
     @host.dispatch_to_bacula
     redirect_to host_path(@host)
   end
 
   # DELETE /hosts/1/revoke
   def revoke
     @host.remove_from_bacula
     redirect_to root_path
   end
 
   private
 
   def fetch_host
     @host = Host.includes(job_templates: [:fileset, :schedule]).find(params[:id])
   end
 
   def fetch_params
     params.require(:host).permit(:fqdn, :port, :password)
   end
 end
diff --git a/app/models/host.rb b/app/models/host.rb
index a4dfef6..379ca21 100644
--- a/app/models/host.rb
+++ b/app/models/host.rb
@@ -1,158 +1,160 @@
 class Host < ActiveRecord::Base
   establish_connection Baas::settings[:local_db]
 
   FILE_RETENTION_DAYS = 60
   JOB_RETENTION_DAYS = 180
   CATALOG = 'MyCatalog'
   AUTOPRUNE = 1
 
   STATUSES = {
     pending: 0,
     configured: 1,
     dispatched: 2,
     deployed: 3,
     updated: 4,
     redispatched: 5,
     for_removal: 6
   }
 
   belongs_to :client, class_name: :Client, foreign_key: :name, primary_key: :name
 
   has_many :filesets, dependent: :destroy
   has_many :job_templates, dependent: :destroy
   has_many :schedules, dependent: :destroy
 
   validates :file_retention, :job_retention,
     :port, :password, presence: true
   validates :port, numericality: true
 
   validates :fqdn, presence: true, uniqueness: true
 
   validate :fqdn_format
 
-  scope :not_baculized, -> { where(baculized: false) }
+  scope :not_baculized, -> {
+    joins("left join Client on Client.Name = hosts.name").where(Client: { Name: nil })
+  }
 
   before_validation :set_retention, :unset_baculized, :sanitize_name
 
   state_machine :status, initial: :pending do
     STATUSES.each do |status_name, value|
       state status_name, value: value
     end
 
     event :add_configuration do
       transition [:pending, :dispatched] => :configured
     end
 
     event :dispatch do
       transition :configured => :dispatched
     end
 
     event :redispatch do
       transition :updated => :redispatched
     end
 
     event :set_deployed do
       transition [:dispatched, :redispatched, :configured, :updated] => :deployed
     end
 
     event :change_deployed_config do
       transition [:deployed, :redispatched, :for_removal] => :updated
     end
 
     event :mark_for_removal do
       transition [:dispatched, :deployed, :updated, :redispatched] => :for_removal
     end
 
     event :disable do
       transition all => :pending
     end
   end
 
   def baculize_config
     templates = job_templates.enabled.includes(:fileset, :schedule)
 
     result = [self] + templates.map {|x| [x, x.fileset, x.schedule] }.flatten.compact.uniq
     result.map(&:to_bacula_config_array)
   end
 
   def to_bacula_config_array
     [
       "Client {",
       "  Name = #{name}",
       "  Address = #{fqdn}",
       "  FDPort = #{port}",
       "  Catalog = #{CATALOG}",
       "  Password = \"#{password}\"",
       "  File Retention = #{file_retention} days",
       "  Job Retention = #{job_retention} days",
       "  AutoPrune = yes",
       "}"
     ]
   end
 
   def auto_prune_human
     AUTOPRUNE == 1 ? 'yes' : 'no'
   end
 
   # Uploads the host's config to bacula
   # Reloads bacula server
   #
   # It updates the host's status accordingly
   def dispatch_to_bacula
     return false if not needs_dispatch?
     BaculaHandler.new(self).deploy_config
   end
 
   # Removes a Host from bacula configuration.
   # Reloads bacula server
   #
   # If all go well it changes the host's status and returns true
   def remove_from_bacula
     return false unless needs_revoke?
     BaculaHandler.new(self).undeploy_config
   end
 
   def needs_dispatch?
     verified? && (can_dispatch? || can_redispatch?)
   end
 
   def needs_revoke?
     for_removal?
   end
 
   # Handles the host's job changes by updating the host's status
   def recalculate
     if job_templates(true).enabled.any?
       add_configuration || change_deployed_config
     else
       mark_for_removal || disable
     end
   end
 
   private
 
   # automatic setters
 
   def sanitize_name
     self.name = fqdn
   end
 
   def set_retention
     self.file_retention = FILE_RETENTION_DAYS
     self.job_retention = JOB_RETENTION_DAYS
   end
 
   def unset_baculized
     self.baculized = false if new_record?
     true
   end
 
   # validation
 
   def fqdn_format
     regex = /(?=^.{4,253}$)(^((?!-)[a-zA-Z0-9-]{1,63}(?<!-)\.)+[a-zA-Z]{2,63}$)/
     unless fqdn =~ regex
       self.errors.add(:fqdn)
     end
   end
 end