# Clone any parameters as well

    @original.host_parameters.each{|param| @host.host_parameters << param.clone}

    flash[:error_customisation] = {:header_message => nil, :class => "flash notice", :id => nil,

    @host.valid?

    render :action => :new

  end

  def index

    @usergroups = Usergroup.all

  end

  def new

    @usergroup = Usergroup.new

  end

  def create

    @usergroup = Usergroup.new(params[:usergroup])

    if @usergroup.save

      render :action => 'new'

    end

  end

  def edit

    @usergroup = Usergroup.find(params[:id])

    render :action => :edit

  end

  def update

    @usergroup = Usergroup.find(params[:id])

      flash[:foreman_notice] = "Successfully updated usergroup."

      redirect_to usergroups_path

    else

      render :action => 'edit'

    end

  end

  def destroy

    @usergroup = Usergroup.find(params[:id])

      flash[:foreman_notice] = "Successfully destroyed usergroup."

    else

    end

    redirect_to usergroups_path

  end

      link_to_if(Report.maximum('id', :conditions => {:host_id => record.id}), time, report_host_path(record))

  end

  end

# method that reformats the hostname column by adding the status icons

    attrs = []

    # get user's DN

    if not account.nil? and self.account.include? "$login" then

    else

    end

    login_filter = Net::LDAP::Filter.eq( self.attr_login, login )

    object_filter = Net::LDAP::Filter.eq( "objectClass", "*" )

    dn = String.new

    ldap_con.search( :base => self.base_dn,

      dn = entry.dn

      attrs = [:firstname => AuthSourceLdap.get_attr(entry, self.attr_firstname),

    return nil if dn.empty?

    logger.debug "DN found for #{login}: #{dn}" if logger && logger.debug?

    # authenticate user

  def initialize_ldap_con(ldap_user, ldap_password)

    options = { :host => self.host,

    options.merge!(:auth => { :method => :simple, :username => ldap_user, :password => ldap_password }) unless ldap_user.blank? && ldap_password.blank?

    Net::LDAP.new options

  end

class DomainParameter < Parameter

  belongs_to :domain

  validates_presence_of :domain_id, :message => "parameters require an associated domain", :unless => :nested

end

class GroupParameter < Parameter

  belongs_to :hostgroup

end

    ((puppet_status >> #{Report::BIT_NUM*Report::METRIC.index("skipped")} & #{Report::MAX}) != 0)"

  }

  named_scope :with_changes, { :conditions => "(puppet_status > 0) and

    ((puppet_status >> #{Report::BIT_NUM*Report::METRIC.index("applied")} & #{Report::MAX}) != 0) or

    ((puppet_status >> #{Report::BIT_NUM*Report::METRIC.index("restarted")} & #{Report::MAX}) !=0)"

    validates_length_of      :root_pass, :minimum => 8,:too_short => 'should be 8 characters or more'

    validates_format_of      :mac,       :with => /([a-f0-9]{1,2}:){5}[a-f0-9]{1,2}/

    validates_format_of      :ip,        :with => /(\d{1,3}\.){3}\d{1,3}/

                             :if => Proc.new { |host| host.disk.empty? and not defined?(Rake) }

    validates_format_of      :sp_mac,    :with => /([a-f0-9]{1,2}:){5}[a-f0-9]{1,2}/, :allow_nil => true, :allow_blank => true

    validates_format_of      :sp_ip,     :with => /(\d{1,3}\.){3}\d{1,3}/, :allow_nil => true, :allow_blank => true

  def <=>(other)

    self.name <=> other.name

  end

  # Returns the name of this host as a string

  # String: the host's name

  def to_label

  end

  def is_owned_by

  end

  def is_owned_by=(the_owner)

    if match = the_owner.match(/^[^\(]+\(([^\)]+)\)/)

      owner = User.find_by_login(match[1])

    else

    end

    if owner

    else

      errors.add_to_base "Unable to set the owner of this host to #{the_owner}"

    end

  def error_state(report)

    host = report.host

    raise "unable to find recipients" if email.empty?

    recipients email

    from "Foreman-noreply"

class HostParameter < Parameter

  belongs_to :host

  validates_presence_of :host_id, :message => "parameters require an associated host", :unless => :nested

  def to_s

    "#{host_id ? host.name : "unassociated"}: #{name} = #{value}"

  belongs_to :auth_source

  has_many :changes, :class_name => 'Audit', :as => :user

  has_many :usergroups, :through => :usergroup_member

  has_many :direct_hosts, :as => :owner, :class_name => "Host"

  validates_uniqueness_of :login, :message => "already exists"

  end

  alias_method :to_s, :to_label

  alias_method :name, :to_label

  def <=>(other)

    self.name <=> other.name

  end

  # The text item to see in a select dropdown menu

  def select_title

    name + " (#{login})"

  end

  def self.try_to_login(login, password)

    # Make sure no one can sign in with an empty password

    return nil if password.to_s.empty?

    end

    all_groups.uniq.map{|g| g.hosts}.flatten.uniq

  end

  def hosts

    direct_hosts + indirect_hosts

  end

  def recipients

    [mail]

  end

  protected

  def validate

    if Usergroup.all.map(&:name).include?(self.login)

      errors.add_to_base "A usergroup already exists with this name"

class Usergroup < ActiveRecord::Base

  has_many_polymorphs :members, :from => [:usergroups, :users ], :as => :member, :through => :usergroup_member, :foreign_key => :usergroup_id, :dependent => :destroy

  has_many :hosts, :as => :owner

  validates_uniqueness_of :name

  before_destroy Ensure_not_used_by.new(:hosts, :usergroups)

  def to_s

    name

  end

  # The text item to see in a select dropdown menu

  alias_method :select_title, :to_s

  def recipients

    all_users.map(&:mail)

  end

  # This methods retrieves all users in a usergroup

  # Returns: Array of users

  def all_users(group_list=[self], user_list=[])

    retrieve_users_and_groups group_list, user_list

    user_list.sort.uniq

  end

  # This methods retrieves all usergroups in a usergroup

  # Returns: Array of usergroups

  def all_usergroups(group_list=[self], user_list=[])

  # Recurses down the tree of usergroups and finds the users

  # [+group_list+]: Array of Usergroups that have already been processed

  # [+users+]     : Array of users accumulated at this point

  def retrieve_users_and_groups(group_list, user_list)

    for group in usergroups

      next if group_list.include? group

      group_list << group

    end

    user_list.concat users

  end

      errors.add :name, "is already used by a user account"

    end

  end

end

<%= collection_select :host, :operatingsystem_id, @architecture.operatingsystems, :id, :to_label, :include_blank => true %>

<span id=os_sub_select>

  <% if @operatingsystem -%>

  <% field_set_tag 'Primary settings' do -%>

    <table>

      <tr>

        <td><%= f.text_field :name, :size => 16, :value => @host.shortname %></td>

        <td><%= f.collection_select :hostgroup_id, Hostgroup.all, :id, :name, :include_blank => true %></td>

        <td><%= f.collection_select :environment_id, Environment.all, :id, :to_label, :include_blank => true %></td>

        <td><%= f.text_field :puppetmaster, :size => 10, :value => @host.puppetmaster %></td>

        <td><%= link_to_function "Additional Classes", toggle_div(:classlist) %></td>

      </tr>

    <%= render 'unattended', :f => f %>

  <% end -%>

  <% field_set_tag 'Additional Information' do -%>

    <%= f.text_area :comment, :size => "120x5" %>

  <% end -%>

<%= collection_select :host, :media_id, @operatingsystem.medias, :id, :to_label %>

<%= collection_select :host, :ptable_id, @operatingsystem.ptables, :id, :to_label %>

  <% field_set_tag 'Network settings', :id => "network" do -%>

    <table>

      <tr>

        <td><%= f.collection_select :domain_id, Domain.all, :id, :to_label %></td>

        <td><%= f.text_field :ip, :size => 16 %></td>

        <td><%= f.text_field :mac, :size => 17 %></td>

      </tr>

    </table>

      <tr>

        <td colspan="6">

          <span id="architecture">

            <%= f.collection_select :architecture_id, Architecture.all, :id, :to_label, :include_blank => true %>

            <span id="host_os">

              <% if @architecture -%>

        </td>

      </tr>

      <tr>

        <td><%= f.password_field :root_pass %></td>

        <td><%= f.collection_select :model_id, Model.all, :id, :to_label, :include_blank => true %></td>

        <td><%= f.select :serial, ["","0,9600n8","0,19200n8","1,9600n8","1,19200n8"] %></td>

      </tr>

      <tr>

        <td colspan="6">

          <%= link_to_function "Switch to custom disk layout", toggle_div("custom_disk") %>

          <div id="custom_disk", style=display:none;>

            <%= f.text_area :disk, :size => "50x10", :disabled => true %>

          </div>

        </td>

    <tr>

      <td>

        Name

        <%= f.text_field :name %>

    </tr>

    <tr>

      <td>

        <%= edit_habtm @usergroup, Usergroup, @usergroup %>

      </td>

    </tr>

    <tr><td><%= f.submit "Submit" %></td></tr>

  </table>

<% end %>

    end

  end

end

#:modulepath: /etc/puppet/modules/

:tftppath: tftp/

#:rrd_report_url: report/

#your default puppet server - can be overridden in the host level

#if none specified, plain "puppet" will be used.

#:puppet_server: puppet

#:unattended: false

#use the following setting to override the default 30 minutes puppet run interval - value must be in minutes

    def mediapath host

      uri = media_uri(host)

      server = uri.select(:host, :port).compact.join(':')

      case uri.scheme

        when 'http', 'https', 'ftp'

        epel_url.gsub!("$os","4-9")

      when "5"

        epel_url.gsub!("$os","5-3")

      else

        return ""

      end

    end

    def yumrepo host

  name: test

  value: myvalue

  type: CommonParameter

    parameter.domain_id = domain.id

    assert parameter.save

  end

end

    parameter.value.strip!.squeeze!(" ").empty?

    assert parameter.save

  end

end