Plugins » Katello » Hammer CLI CSV

  %w(setup resources).each do |task_name|

  Rake::Task['test:setup'].invoke

      def export(csv)

        csv << [NAME, ORGANIZATION, DESCRIPTION, LIMIT, ENVIRONMENT, CONTENTVIEW,

                HOSTCOLLECTIONS, AUTOATTACH, SERVICELEVEL, RELEASEVER, SUBSCRIPTIONS]

        @api.resource(:organizations).call(:index, {

            :per_page => 999999

        })['results'].each do |organization|

          next if option_organization && organization['name'] != option_organization

          @api.resource(:activation_keys).call(:index, {

              'per_page' => 999999,

              'organization_id' => organization['id']

          })['results'].each do |activationkey|

            name = namify(activationkey['name'])

            count = 1

            description = activationkey['description']

            limit = activationkey['unlimited_content_hosts'] ? 'Unlimited' : activationkey['max_content_hosts']

            environment = activationkey['environment']['label']

            contentview = activationkey['content_view']['name']

            hostcollections = export_column(activationkey, 'host_collections', 'name')

            autoattach = activationkey['auto_attach'] ? 'Yes' : 'No'

            servicelevel = activationkey['service_level']

            releasever = activationkey['release_version']

            subscriptions = CSV.generate do |column|

              column << @api.resource(:subscriptions).call(:index, {

                            'organization_id' => organization['id'],

                            'activation_key_id' => activationkey['id']

                        })['results'].collect do |subscription|

                amount = subscription['amount'] == 0 ? 'Automatic' : subscription['amount']

                sku = subscription['product_id'].match(/\A[0-9]/) ? 'Custom' : subscription['product_id']

                "#{amount}|#{sku}|#{subscription['product_name']}"

            subscriptions.delete!("\n")

            csv << [name, count, organization['name'], description, limit, environment, contentview,

                    hostcollections, servicelevel, releasever, autoattach, subscriptions]

      def export(csv)

        csv << [NAME, OPERATINGSYSTEMS]

        @api.resource(:architectures).call(:index, {:per_page => 999999})['results'].each do |architecture|

          architecture = @api.resource(:architectures).call(:show, {:id => architecture['id']})

          name = architecture['name']

          operatingsystems = export_column(architecture, 'operatingsystems', 'title')

          csv << [name, operatingsystems]

      if option_export?

        if option_file

          CSV.open(option_file, 'wb', {:force_quotes => false}) do |csv|

            export csv

          end

        else

          CSV do |csv|

            export csv

          end

        end

      else

        import

      end

        csv << [NAME, ORGANIZATIONS, LOCATIONS, DESCRIPTION, PROVIDER, URL]

        @api.resource(:compute_profiles).call(:index, {:per_page => 999999})['results'].each do |compute_profile|

          puts compute_profile

          compute_profile = @api.resource(:compute_profiles).call(:show, {'id' => compute_profile['id']})

          name = compute_profile['name']

          organizations = export_column(compute_profile, 'organizations', 'name')

          locations = export_column(compute_profile, 'locations', 'name')

          description = compute_profile['description']

          provider = compute_profile['provider']

          url = compute_profile['url']

          csv << [name, organizations, locations, description, provider, url]

      def export(csv)

        csv << [NAME, ORGANIZATIONS, LOCATIONS, DESCRIPTION, PROVIDER, URL]

        @api.resource(:compute_resources).call(:index, {:per_page => 999999})['results'].each do |compute_resource|

          compute_resource = @api.resource(:compute_resources).call(:show, {'id' => compute_resource['id']})

          name = compute_resource['name']

          organizations = export_column(compute_resource, 'organizations', 'name')

          locations = export_column(compute_resource, 'locations', 'name')

          description = compute_resource['description']

          provider = compute_resource['provider']

          url = compute_resource['url']

          csv << [name, organizations, locations, description, provider, url]

      def export(csv)

        csv << [NAME, REGISTRY, REPOSITORY, COMPUTERESOURCE, ATTACH, ENTRYPOINT, COMMAND]

        @api.resource(:containers).call(:index, {'per_page' => 999999})['results'].each do |container|

          csv << [container['name'],

                  container['registry_name'],

                  "#{container['repository_name']}:#{container['tag']}",

                  container['compute_resource_name'],

                  export_attach_types(container),

                  container['entrypoint'],

                  container['command']]

      def self.supported?

        true

      end

      option %w(--subscriptions-only), :flag, 'Export only detailed subscription information'

      SUBS_NAME = 'Subscription Name'

      SUBS_TYPE = 'Subscription Type'

      SUBS_QUANTITY = 'Subscription Quantity'

      SUBS_SKU = 'Subscription SKU'

      SUBS_CONTRACT = 'Subscription Contract'

      SUBS_ACCOUNT = 'Subscription Account'

      SUBS_START = 'Subscription Start'

      SUBS_END = 'Subscription End'

      def export(csv)

        if option_subscriptions_only?

          export_subscriptions csv

        else

          export_all csv

      def export_subscriptions(csv)

        csv << shared_headers + [SUBS_NAME, SUBS_TYPE, SUBS_QUANTITY, SUBS_SKU,

                                 SUBS_CONTRACT, SUBS_ACCOUNT, SUBS_START, SUBS_END]

        iterate_hosts(csv) do |host|

          export_line = shared_columns(host)

          if host['subscription_facet_attributes']

            subscriptions = @api.resource(:host_subscriptions).call(:index, {

                'organization_id' => host['organization_id'],

                'host_id' => host['id']

            })['results']

            if subscriptions.empty?

              csv << export_line + [nil, nil, nil, nil, nil, nil]

              subscriptions.each do |subscription|

                subscription_type = subscription['product_id'].to_i == 0 ? 'Red Hat' : 'Custom'

                subscription_type += ' Guest' if subscription['type'] == 'STACK_DERIVED'

                subscription_type += ' Temporary' if subscription['type'] == 'UNMAPPED_GUEST'

                csv << export_line + [subscription['product_name'], subscription_type,

                                      subscription['quantity_consumed'], subscription['product_id'],

                                      subscription['contract_number'], subscription['account_number'],

                                      DateTime.parse(subscription['start_date']).strftime('%m/%d/%Y'),

                                      DateTime.parse(subscription['end_date']).strftime('%m/%d/%Y')]

              end

          else

            csv << export_line + [nil, nil, nil, nil, nil, nil]

          end

        end

      end

      def export_all(csv)

        csv << shared_headers + [SUBSCRIPTIONS]

        iterate_hosts(csv) do |host|

          if host['subscription_facet_attributes']

                  'organization_id' => host['organization_id'],

          else

            subscriptions = nil

          csv << shared_columns(host) + [subscriptions]

        @all_subscriptions = {}

                  'autoheal' => false,

          if option_subscriptions_only?

            update_subscriptions_only(name, line)

            update_or_create(name, line)

        end

      end

      private

      def update_subscriptions_only(name, line)

        raise _("Content host '%{name}' must already exist with --subscriptions-only") % {:name => name} unless @existing.include? name

        print(_("Updating subscriptions for content host '%{name}'...") % {:name => name}) if option_verbose?

        host = @api.resource(:hosts).call(:show, {:id => @existing[name]})

        update_subscriptions(host, line, false)

        puts _('done') if option_verbose?

      end

      def update_or_create(name, line)

        if !@existing.include? name

          print(_("Creating content host '%{name}'...") % {:name => name}) if option_verbose?

          params = {

            'name' => name,

            'facts' => facts(name, line),

            'lifecycle_environment_id' => lifecycle_environment(line[ORGANIZATION], :name => line[ENVIRONMENT]),

            'content_view_id' => katello_contentview(line[ORGANIZATION], :name => line[CONTENTVIEW])

          }

          params['installed_products'] = products(line) if line[PRODUCTS]

          params['service_level'] = line[SLA] if line[SLA]

          host = @api.resource(:host_subscriptions).call(:create, params)

          @existing[name] = host['id']

        else

          print(_("Updating content host '%{name}'...") % {:name => name}) if option_verbose?

          params = {

            'id' => @existing[name],

            'host' => {

              'content_facet_attributes' => {

                'lifecycle_environment_id' => lifecycle_environment(line[ORGANIZATION], :name => line[ENVIRONMENT]),

                'content_view_id' => katello_contentview(line[ORGANIZATION], :name => line[CONTENTVIEW])

              },

              'subscription_facet_attributes' => {

                'facts' => facts(name, line),

                'installed_products' => products(line),

                'service_level' => line[SLA]

              }

            }

          }

          host = @api.resource(:hosts).call(:update, params)

        end

        if line[VIRTUAL] == 'Yes' && line[HOST]

          raise "Content host '#{line[HOST]}' not found" if !@existing[line[HOST]]

          @hypervisor_guests[@existing[line[HOST]]] ||= []

          @hypervisor_guests[@existing[line[HOST]]] << "#{line[ORGANIZATION]}/#{name}"

        update_host_collections(host, line)

        update_subscriptions(host, line, true)

        puts _('done') if option_verbose?

        # TODO: http://projects.theforeman.org/issues/16234

        # return nil if line[HOSTCOLLECTIONS].nil? || line[HOSTCOLLECTIONS].empty?

        # CSV.parse_line(line[HOSTCOLLECTIONS]).each do |hostcollection_name|

        #   @api.resource(:host_collections).call(:add_hosts, {

        #       'id' => katello_hostcollection(line[ORGANIZATION], :name => hostcollection_name),

        #       'host_ids' => [host['id']]

        #   })

        # end

      def update_subscriptions(host, line, remove_existing)

        if remove_existing && existing_subscriptions.length != 0

          existing_subscriptions.map! do |existing_subscription|

            {:id => existing_subscription['id'], :quantity => existing_subscription['quantity_consumed']}

          end

          existing_subscriptions = []

        end

        if line[SUBS_NAME].nil? && line[SUBS_SKU].nil?

          all_in_one_subscription(host, existing_subscriptions, line)

        else

          single_subscription(host, existing_subscriptions, line)

      end

      def single_subscription(host, existing_subscriptions, line)

        already_attached = false

        if line[SUBS_SKU]

          already_attached = existing_subscriptions.detect do |subscription|

            line[SUBS_SKU] == subscription['product_id']

          end

        elsif line[SUBS_NAME]

          already_attached = existing_subscriptions.detect do |subscription|

            line[SUBS_NAME] == subscription['name']

          end

        end

        if already_attached

          print _(" '%{name}' already attached...") % {:name => already_attached['name']}

          return

        end

        available_subscriptions = @api.resource(:subscriptions).call(:index, {

          'organization_id' => host['organization_id'],

          'host_id' => host['id'],

          'available_for' => 'host',

          'match_host' => true

        })['results']

        matches = matches_by_sku_and_name([], line, available_subscriptions)

        matches = matches_by_type(matches, line)

        matches = matches_by_account(matches, line)

        matches = matches_by_contract(matches, line)

        matches = matches_by_quantity(matches, line)

        raise _("No matching subscriptions") if matches.empty?

        match = matches[0]

        print _(" attaching '%{name}'...") % {:name => match['name']} if option_verbose?

        @api.resource(:host_subscriptions).call(:add_subscriptions, {

            'host_id' => host['id'],

            'subscriptions' => existing_subscriptions + [match]

        })

      end

      def all_in_one_subscription(host, existing_subscriptions, line)

      def get_all_subscriptions(organization)

        @api.resource(:subscriptions).call(:index, {

            :per_page => 999999,

            'organization_id' => foreman_organization(:name => organization)

        })['results']

      end

      def iterate_hosts(csv)

        hypervisors = []

        hosts = []

        @api.resource(:organizations).call(:index, {:per_page => 999999})['results'].each do |organization|

          next if option_organization && organization['name'] != option_organization

          @api.resource(:hosts).call(:index, {

              'per_page' => 999999,

              'organization_id' => foreman_organization(:name => organization['name'])

          })['results'].each do |host|

            host = @api.resource(:hosts).call(:show, {

                'id' => host['id']

            })

            host['facts'] ||= {}

            if host['subscription_facet_attributes']['virtual_guests'].empty?

              hosts.push(host)

            else

              hypervisors.push(host)

            end

          end

        end

        hypervisors.each do |host|

          yield host

        end

        hosts.each do |host|

          yield host

        end

      end

      def shared_headers

        [NAME, ORGANIZATION, ENVIRONMENT, CONTENTVIEW, HOSTCOLLECTIONS, VIRTUAL, HOST,

         OPERATINGSYSTEM, ARCHITECTURE, SOCKETS, RAM, CORES, SLA, PRODUCTS]

      end

      def shared_columns(host)

        name = host['name']

        organization_name = host['organization_name']

        if host['content_facet_attributes']

          environment = host['content_facet_attributes']['lifecycle_environment']['name']

          contentview = host['content_facet_attributes']['content_view']['name']

          hostcollections = export_column(host['content_facet_attributes'], 'host_collections', 'name')

        else

          environment = nil

          contentview = nil

          hostcollections = nil

        end

        if host['subscription_facet_attributes']

          hypervisor_host = host['subscription_facet_attributes']['virtual_host'].nil? ? nil : host['subscription_facet_attributes']['virtual_host']['name']

          products = export_column(host['subscription_facet_attributes'], 'installed_products') do |product|

            "#{product['productId']}|#{product['productName']}"

          end

        else

          hypervisor_host = nil

          products = nil

        end

        virtual = host['facts']['virt::is_guest'] == 'true' ? 'Yes' : 'No'

        operatingsystem = host['facts']['distribution::name'] if host['facts']['distribution::name']

        operatingsystem += " #{host['facts']['distribution::version']}" if host['facts']['distribution::version']

        architecture = host['facts']['uname::machine']

        sockets = host['facts']['cpu::cpu_socket(s)']

        ram = host['facts']['memory::memtotal']

        cores = host['facts']['cpu::core(s)_per_socket'] || 1

        sla = ''

        [name, organization_name, environment, contentview, hostcollections, virtual, hypervisor_host,

         operatingsystem, architecture, sockets, ram, cores, sla, products]

      end

      def matches_by_sku_and_name(matches, line, subscriptions)

        if line[SUBS_SKU]

          matches = subscriptions.select do |subscription|

            line[SUBS_SKU] == subscription['product_id']

          end

          raise _("No subscriptions match SKU '%{sku}'") % {:sku => line[SUBS_SKU]} if matches.empty?

        elsif line[SUBS_NAME]

          matches = subscriptions.select do |subscription|

            line[SUBS_NAME] == subscription['name']

          end

          raise _("No subscriptions match name '%{name}'") % {:name => line[SUBS_NAME]} if matches.empty?

        end

        matches

      end

      def matches_by_type(matches, line)

        if line[SUBS_TYPE] == 'Red Hat' || line[SUBS_TYPE] == 'Custom'

          matches = matches.select do |subscription|

            subscription['type'] == 'NORMAL'

          end

        elsif line[SUBS_TYPE] == 'Red Hat Guest'

          matches = matches.select do |subscription|

            subscription['type'] == 'STACK_DERIVED'

          end

        elsif line[SUBS_TYPE] == 'Red Hat Temporary'

          matches = matches.select do |subscription|

            subscription['type'] == 'UNMAPPED_GUEST'

          end

        end

        raise _("No subscriptions match type '%{type}'") % {:type => line[SUBS_TYPE]} if matches.empty?

        matches

      end

      def matches_by_account(matches, line)

        if matches.length > 1 && line[SUBS_ACCOUNT]

          refined = matches.select do |subscription|

            line[SUBS_ACCOUNT] == subscription['account_number']

          end

          matches = refined unless refined.empty?

        end

        matches

      end

      def matches_by_contract(matches, line)

        if matches.length > 1 && line[SUBS_CONTRACT]

          refined = matches.select do |subscription|

            line[SUBS_CONTRACT] == subscription['contract_number']

          end

          matches = refined unless refined.empty?

        end

        matches

      end

      def matches_by_quantity(matches, line)

        if line[SUBS_QUANTITY] && line[SUBS_QUANTITY] != 'Automatic'

          refined = matches.select do |subscription|

            subscription['available'] == -1 || line[SUBS_QUANTITY].to_i <= subscription['available']

          end

          raise _("No '%{name}' subscription with quantity %{quantity} or more available") %

                    {:name => matches[0]['name'], :quantity => line[SUBS_QUANTITY]} if refined.empty?

          matches = refined

        end

        matches

      end

      def export(csv)

        csv << [NAME, CONTENTVIEW, ORGANIZATION, TYPE, DESCRIPTION, REPOSITORIES, RULES]

        @api.resource(:organizations).call(:index, {

            :per_page => 999999

        })['results'].each do |organization|

          next if option_organization && organization['name'] != option_organization

          @api.resource(:content_views).call(:index, {

              'per_page' => 999999,

              'organization_id' => organization['id'],

              'nondefault' => true

          })['results'].each do |contentview|

            @api.resource(:content_view_filters).call(:index, {

                'content_view_id' => contentview['id']

            })['results'].collect do |filter|

              filter_type = "#{filter['inclusion'] == true ? 'Include' : 'Exclude'} #{export_filter_type(filter['type'])}"

              rules = nil

              case filter['type']

              when /rpm/

                rules = export_rpm_rules(filter)

              when /erratum/

                rules = export_erratum_rules(filter)

              when /package_group/

                rules = export_package_group_rules(filter)

              else

                raise "Unknown filter rule type '#{filter['type']}'"

              name = filter['name']

              repositories = export_column(filter, 'repositories', 'name')

              csv << [name, contentview['name'], organization['name'], filter_type, filter['description'],

                      repositories, rules]

      def export(csv)

        csv << [NAME, LABEL, ORGANIZATION, COMPOSITE, REPOSITORIES, ENVIRONMENTS]

        @api.resource(:organizations).call(:index, {

            :per_page => 999999

        })['results'].each do |organization|

          next if option_organization && organization['name'] != option_organization

          composite_contentviews = []

          @api.resource(:content_views).call(:index, {

              'per_page' => 999999,

              'organization_id' => organization['id'],

              'nondefault' => true

          })['results'].each do |contentview|

            name = contentview['name']

            label = contentview['label']

            orgname = organization['name']

            environments = CSV.generate do |column|

              column << environment_names(contentview)

            end

            environments.delete!("\n")

            composite = contentview['composite'] == true ? 'Yes' : 'No'

            if composite == 'Yes'

              contentviews = CSV.generate do |column|

                column << contentview['components'].collect do |component|

                  component['content_view']['name']

              contentviews.delete!("\n")

              composite_contentviews << [name, 1, label, orgname, composite, contentviews, environments]

            else

              repositories = export_column(contentview, 'repositories', 'name')

              csv << [name, label, orgname, composite, repositories, environments]

          end

          composite_contentviews.each do |contentview|

            csv << contentview

      def export(csv)

        csv << [NAME, ORGANIZATIONS, LOCATIONS, DESCRIPTION, SMART_PROXY, PARAMETERS]

        search_options = {:per_page => 999999}

        search_options['search'] = "organization=\"#{option_organization}\"" if option_organization

        @api.resource(:domains).call(:index, search_options)['results'].each do |domain|

          domain = @api.resource(:domains).call(:show, {'id' => domain['id']})

          raise "Domain 'id=#{domain['id']}' not found" if !domain || domain.empty?

          name = domain['name']

          organizations = option_organization ? option_organization : export_column(domain, 'organizations', 'name')

          locations = export_column(domain, 'locations', 'name')

          description = domain['fullname']

          capsule = foreman_smart_proxy(:id => domain['dns_id'])

          parameters = export_parameters(domain['parameters'])

          csv << [name, organizations, locations, description, capsule, parameters]

      def export(csv)

        csv << [NAME, ORGANIZATION, LIMIT, DESCRIPTION]

        if @server_status['release'] == 'Headpin'

          @headpin.get(:organizations).each do |organization|

            next if option_organization && organization['name'] != option_organization

            @headpin.get("organizations/#{organization['label']}/system_groups").each do |systemgroup|

              csv << [systemgroup['name'], organization['name'],

                      systemgroup['max_systems'].to_i < 0 ? 'Unlimited' : systemgroup['max_systems'],

                      systemgroup['description']]

          end

        else

          @api.resource(:organizations).call(:index, {'per_page' => 999999})['results'].each do |organization|

            next if option_organization && organization['name'] != option_organization

            @api.resource(:host_collections).call(:index, {

                'organization_id' => organization['id']

            })['results'].each do |hostcollection|

              limit = hostcollection['unlimited_content_hosts'] ? 'Unlimited' : hostcollection['max_content_hosts']

              csv << [hostcollection['name'], organization['name'],

                      limit,

                      hostcollection['description']]

      def export(csv)

        csv << [NAME, PARENT, ORGANIZATIONS, LOCATIONS, SUBNET, DOMAIN, OPERATING_SYSTEM,

                ENVIRONMENT, COMPUTE_PROFILE, PARTITION_TABLE, MEDIUM, ARCHITECTURE, REALM,

                PUPPET_PROXY, PUPPET_CA_PROXY, CONTENT_SOURCE, PASSWORD, PUPPET_CLASSES]

        search_options = {:per_page => 999999}

        search_options['search'] = "organization=\"#{option_organization}\"" if option_organization

        @api.resource(:hostgroups).call(:index, search_options)['results'].each do |hostgroup|

          hostgroup = @api.resource(:hostgroups).call(:show, {'id' => hostgroup['id']})

          raise "Host Group 'id=#{hostgroup['id']}' not found" if !hostgroup || hostgroup.empty?

          name = hostgroup['name']

          organizations = export_column(hostgroup, 'organizations', 'name')

          locations = export_column(hostgroup, 'locations', 'name')

          subnet = hostgroup['subnet_name']

          operating_system = hostgroup['operatingsystem_name']

          domain = hostgroup['domain_name']

          puppet_environment = hostgroup['environment_name']

          compute_profile = hostgroup['compute_profile_name']

          partition_table = hostgroup['ptable_name']

          medium = hostgroup['medium_name']

          architecture = hostgroup['architecture_name']

          realm = hostgroup['realm_name']

          puppet_proxy = hostgroup['puppet_proxy_id'] ? foreman_host(:id => hostgroup['puppet_proxy_id']) : nil

          puppet_ca_proxy = hostgroup['puppet_ca_proxy_id'] ? foreman_host(:id => hostgroup['puppet_ca_proxy_id']) : nil

          content_source = hostgroup['content_source_id'] ? foreman_host(:id => hostgroup['content_source_id']) : nil

          parent = hostgroup['ancestry'] ? foreman_hostgroup(:id => hostgroup['ancestry']) : nil

          password = nil

          puppet_classes = export_column(hostgroup, 'puppetclasses') do |puppet_class|

            "#{puppet_class['module_name']}/#{puppet_class['name']}"

          end

          # TODO: http://projects.theforeman.org/issues/6273

          # API call to get the smart class variable override values

          csv << [name, parent, organizations, locations, subnet, domain, operating_system,

                  puppet_environment, compute_profile, partition_table, medium, architecture,

                  realm, puppet_proxy, puppet_ca_proxy, content_source, password, puppet_classes]

      def export(csv)

        csv << [NAME, ORGANIZATION, LOCATION, ENVIRONMENT, OPERATINGSYSTEM, ARCHITECTURE,

                MACADDRESS, DOMAIN, PARTITIONTABLE, SUBNET, REALM, MEDIUM, HOSTGROUP,

                COMPUTERESOURCE, COMPUTEPROFILE, IMAGE, ENABLED, MANAGED]

        search_options = {:per_page => 999999}

        search_options['search'] = "organization=\"#{option_organization}\"" if option_organization

        @api.resource(:hosts).call(:index, search_options)['results'].each do |host|

          host = @api.resource(:hosts).call(:show, {'id' => host['id']})

          raise "Host 'id=#{host['id']}' not found" if !host || host.empty?

          name = host['name']

          organization = host['organization_name']

          location = host['location_name']

          environment = host['environment_name']

          operatingsystem = host['operatingsystem_name']

          architecture = host['architecture_name']

          mac = host['mac']

          domain = host['domain_name']

          ptable = host['ptable_name']

          subnet = host['subnet_name']

          realm = host['realm_name']

          medium = host['medium_name']

          hostgroup = host['hostgroup_name']

          compute_resource = host['compute_resource_name']

          compute_profile = host['compute_profile_name']

          image = host['image_name']

          enabled = host['enabled'] ? 'Yes' : 'No'

          managed = host['managed'] ? 'Yes' : 'No'

          csv << [name, organization, location, environment, operatingsystem, architecture,

                  mac, domain, ptable, subnet, realm, medium, hostgroup, compute_resource,

                  compute_profile, image, enabled, managed]

      def export(csv)

        csv << [NAME, ORGANIZATIONS, LOCATIONS, PATH, OSFAMILY, OPERATING_SYSTEMS]

        @api.resource(:media).call(:index, {:per_page => 999999})['results'].each do |medium|

          medium = @api.resource(:media).call(:show, :id => medium['id'])

          name = medium['name']

          organizations = export_column(medium, 'organizations', 'name')

          locations = export_column(medium, 'locations', 'name')

          count = 1

          path = medium['path']

          os_family = medium['os_family']

          operating_systems = export_column(medium, 'operatingsystems', 'title')

          csv << [name, organizations, locations, path, os_family, operating_systems]

      def export(csv)

        csv << [NAME, ORGANIZATIONS, LOCATIONS, DESCRIPTION, JOB, PROVIDER, SNIPPET, TEMPLATE,

                INPUT_NAME, INPUT_DESCRIPTION, INPUT_REQUIRED, INPUT_TYPE, INPUT_PARAMETERS]

        @api.resource(:job_templates).call(:index, {

            :per_page => 999999

        })['results'].each do |template_id|

          template = @api.resource(:job_templates).call(:show, {:id => template_id['id']})

          next if template['locked']

          next unless option_organization.nil? || template['organizations'].detect { |org| org['name'] == option_organization }

          name = template['name']

          description = template['description_format']

          job = template['job_category']

          snippet = template['snippet'] ? 'Yes' : 'No'

          provider = template['provider_type']

          organizations = export_column(template, 'organizations', 'name')

          locations = export_column(template, 'locations', 'name')

          csv << [name, organizations, locations, description, job, provider, snippet, template['template']]

          template_columns = [name] + Array.new(7)

          @api.resource(:template_inputs).call(:index, {

              :template_id => template['id']

          })['results'].each  do|input|

            input_field = nil

            input_options = nil

            case input['input_type']

            when /user/

              input_name = export_column(input, 'options') do |value|

                value

            when /fact/

              input_name = input['fact_name']

            when /variable/

              input_name = input['variable_name']

            when /puppet_parameter/

              input_name = "#{input['puppet_class_name']}|#{input['puppet_parameter_name']}"

            else

              raise _("Unknown job template input type '%{type}'") % {:type => input['input_type']}

            required = input['required'] ? 'Yes' : 'No'

            csv << template_columns + [input['name'], input['description'], required, input['input_type'], input_name]

      def export(csv)

        csv << [NAME, ORGANIZATION, PRIORENVIRONMENT, DESCRIPTION]

        @api.resource(:organizations).call(:index, {

            'per_page' => 999999

        })['results'].each do |organization|

          next if option_organization && organization['name'] != option_organization

          @api.resource(:lifecycle_environments).call(:index, {

              'per_page' => 999999,

              'organization_id' => organization['id']

          })['results'].sort { |a, b| a['created_at'] <=> b['created_at'] }.each do |environment|

            if environment['name'] != 'Library'

              name = environment['name']

              prior = environment['prior']['name']

              description = environment['description']

              csv << [name, organization['name'], prior, description]

      def export(csv)

        csv << [NAME, PARENT]

        @api.resource(:locations).call(:index, {:per_page => 999999})['results'].each do |location|

          csv << [location['name'], '']

      def export(csv)

        csv << [NAME, DESCRIPTION, FAMILY, PASSWORD_HASH, PARTITION_TABLES, ARCHITECTURES, MEDIA,

                PROVISIONING_TEMPLATES, PARAMETERS]

        @api.resource(:operatingsystems).call(:index, {:per_page => 999999})['results'].each do |operatingsystem_id|

          operatingsystem = @api.resource(:operatingsystems).call(:show, {:id => operatingsystem_id['id']})

          name = build_os_name(operatingsystem['name'], operatingsystem['major'], operatingsystem['minor'])

          description = operatingsystem['description']

          family = operatingsystem['family']

          password_hash = operatingsystem['password_hash']

          partition_tables = export_column(operatingsystem, 'ptables', 'name')

          architectures = export_column(operatingsystem, 'architectures', 'name')

          media = export_column(operatingsystem, 'media', 'name')

          partition_tables = export_column(operatingsystem, 'ptables', 'name')

          parameters = export_column(operatingsystem, 'parameters') do |parameter|

            "#{parameter['name']}|#{parameter['value']}"

          csv << [name, description, family, password_hash, partition_tables, architectures,

                  media, partition_tables, parameters]

      def export(csv)

        csv << [NAME, LABEL, DESCRIPTION]

        if @server_status['release'] == 'Headpin'

          @headpin.get(:organizations).each do |organization|

            next if option_organization && organization['name'] != option_organization

            csv << [organization['name'], organization['label'], organization['description']]

          end

        else

          @api.resource(:organizations).call(:index, {:per_page => 999999})['results'].each do |organization|

            next if option_organization && organization['name'] != option_organization

            csv << [organization['name'], organization['label'], organization['description']]

      def export(csv)

        csv << [NAME, ORGANIZATIONS, LOCATIONS, OSFAMILY, OPERATINGSYSTEMS, LAYOUT]

        @api.resource(:ptables).call(:index, {:per_page => 999999})['results'].each do |ptable|

          ptable = @api.resource(:ptables).call(:show, {'id' => ptable['id']})

          name = ptable['name']

          osfamily = ptable['os_family']

          layout = ptable['layout']