GET /api/[collection] HTTP/1.1
Accept: [MIME type]

GET /api/[collection]/[resource_id] HTTP/1.1
Accept: [MIME type]

POST /api/[collection] HTTP/1.1
Accept: [MIME type]
Content-Type: [MIME type]

[body]

PUT /api/collection/resource_id HTTP/1.1
Accept: [MIME type]
Content-Type: [MIME type]

[body]

DELETE /api/[collection]/[resource_id] HTTP/1.1
Accept: [MIME type]

#!/usr/bin/python

import json
import sys


try:
    import requests
except ImportError:
    print "Please install the python-requests module."
    sys.exit(-1)

# URL to your Satellite 6 server
URL = "https://satellite6.example.com"
# URL for the API to your deployed Satellite 6 server
SAT_API = "%s/katello/api/v2/" % URL
# Katello-specific API
KATELLO_API = "%s/katello/api/" % URL
POST_HEADERS = {'content-type': 'application/json'}
# Default credentials to login to Satellite 6
USERNAME = "admin"
PASSWORD = "changeme"
# Ignore SSL for now
SSL_VERIFY = False

# Name of the organization to be either created or used
ORG_NAME = "MyOrg"
# Name for lifecycle environments to be either created or used
ENVIRONMENTS = ["Development", "Testing", "Production"]


def get_json(location):
    """
    Performs a GET using the passed URL location
    """

    r = requests.get(location, auth=(USERNAME, PASSWORD), verify=SSL_VERIFY)

    return r.json()


def post_json(location, json_data):
    """
    Performs a POST and passes the data to the URL location
    """

    result = requests.post(
        location,
        data=json_data,
        auth=(USERNAME, PASSWORD),
        verify=SSL_VERIFY,
        headers=POST_HEADERS)

    return result.json()


def main():
    """
    Main routine that creates or re-uses an organization and
    lifecycle environments. If lifecycle environments already
    exist, exit out.
    """

    # Check if our organization already exists
    org = get_json(SAT_API + "organizations/" + ORG_NAME)

    # If our organization is not found, create it
    if org.get('error', None):
        org_id = post_json(
            SAT_API + "organizations/",
            json.dumps({"name": ORG_NAME}))["organization"]["id"]
        print "Creating organization: \t" + ORG_NAME
    else:
        # Our organization exists, so let's grab it
        org_id = org['id']
        print "Organization '%s' exists." % ORG_NAME

    # Now, let's fetch all available lifecycle environments for this org...
    envs = get_json(
        SAT_API + "organizations/" + str(org_id) + "/environments/")

    # ... and add them to a dictionary, with respective 'Prior' environment
    prior_env_id = 0
    env_list = {}
    for env in envs['results']:
        env_list[env['id']] = env['name']
        prior_env_id = env['id'] if env['name'] == "Library" else prior_env_id

    # Exit the script if at least one lifecycle environment already exists
    if all(environment in env_list.values() for environment in ENVIRONMENTS):
        print "ERROR: One of the Environments is not unique to organization"
        sys.exit(-1)

    # Create lifecycle environments
    for environment in ENVIRONMENTS:
        new_env_id = post_json(
            SAT_API + "organizations/" + str(org_id) + "/environments/",
            json.dumps(
                {
                    "name": environment,
                    "organization_id": org_id,
                    "prior": prior_env_id}
            ))["id"]

        print "Creating environment: \t" + environment
        prior_env_id = new_env_id


if __name__ == "__main__":
    main()

#!/usr/bin/ruby

require 'rest-client'
require 'json'

url = 'https://satellite6.example.com/api/v2/'
katello_url = 'https://satellite6.example.com/katello/api/v2/'
$username = 'admin'
$password = 'changeme'

org_name = "MyOrg"
environments = ["Development","Testing","Production"]

def get_json(location)
    response = RestClient::Request.new(
        :method => :get,
        :url => location,
        :user => $username,
        :password => $password,
        :headers => { :accept => :json,
        :content_type => :json }
    ).execute
    results = JSON.parse(response.to_str)
end

def post_json(location, json_data)
    response = RestClient::Request.new(
        :method => :post,
        :url => location,
        :user => $username,
        :password => $password,
        :headers => { :accept => :json,
        :content_type => :json},
        :payload => json_data
    ).execute
    results = JSON.parse(response.to_str)
end

orgs = get_json(url+"organizations")
org_list = {}
orgs['results'].each do |org|
    org_list[org['id']] = org['name']
end

if !org_list.has_value?(org_name)
    org_id = post_json(url+"organizations", JSON.generate({"name"=> org_name}))["organization"]["id"]
    puts "Creating organization: \t" + org_name
else
    org_id = org_list.key(org_name)
    puts "Organization \"" + org_name + "\" exists"
end

envs = get_json(katello_url+"organizations/" + org_id.to_s + "/environments")
env_list = {}
envs['results'].each do |env|
    env_list[env['id']] = env['name']
end
prior_env_id = env_list.key("Library")

environments.each do |e|
    if env_list.has_value?(e)
        puts "ERROR: One of the Environments is not unique to organization"
        exit()
    end
end

environments.each do |environment|
    new_env_id = post_json(katello_url+"organizations/" + org_id.to_s + "/environments", JSON.generate({"name" => environment, "organization_id" => org_id,"prior" => prior_env_id}))["id"]
    puts "Creating environment: \t" + environment
    prior_env_id = new_env_id
end
exit()