module JunglePath::API::Helpers::StandardAPIs

Public Class Methods

get_forward_host(target) click to toggle source
# File lib/jungle_path/api/helpers/standard_apis.rb, line 149
def self.get_forward_host target
        if target == 'gbwho'
                host = configatron.who.host
                port = configatron.who.port
                user_name = configatron.who.user_name
                password = configatron.who.password
        elsif target == 'gbwhat'
                host = configatron.what.host
                port = configatron.what.port
                user_name = request.env['REMOTE_USER']
                password = request.env['REMOTE_PASSWORD']
        end
        return host, port, user_name, password
end

Public Instance Methods

set_standard_api_default_html_page() click to toggle source
# File lib/jungle_path/api/helpers/standard_apis.rb, line 5
def set_standard_api_default_html_page
        get '/' do
                send_file './public/index.html'
        end
end
set_standard_api_get_log_file() click to toggle source
# File lib/jungle_path/api/helpers/standard_apis.rb, line 179
def set_standard_api_get_log_file
        get '/logs/:filename' do
                send_file(gzip_log_file(params[:filename]))
        end
end
set_standard_api_get_log_file_list() click to toggle source
# File lib/jungle_path/api/helpers/standard_apis.rb, line 173
def set_standard_api_get_log_file_list
        get '/logs' do
                handle_result get_log_file_list
        end
end
set_standard_api_query() click to toggle source
# File lib/jungle_path/api/helpers/standard_apis.rb, line 11
def set_standard_api_query
        post '/query' do
                result = {}

                query = params[:query]

                #default to true:
                temp = params[:apply_limit_offset_to_sql]
                if temp == nil
                        apply_limit_offset_to_sql = true
                else
                        apply_limit_offset_to_sql = JunglePath::DBModel::Params.to_bool(temp)
                end

                ##default to false: (will be false if nil).
                #apply_limit_offset_to_sql = DBModel::Params.to_bool(params[:apply_limit_offset_to_sql])

                result[:query] = query
                log "\napply_limit_offset_to_sql: #{apply_limit_offset_to_sql}."
                log "\nuql query:\n\n#{query}."
                log ""
                # todo: pass generated node tree instead of models:
                #engine = Query::Engine.new(Schema::Base.models, current_user, apply_limit_offset_to_sql)
                node_tree = current_auth.schema_node_tree
                #puts "node_tree: #{node_tree.to_str}."
                engine = Query::Engine.new(node_tree, current_identity, apply_limit_offset_to_sql)
                puts "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz"
                q = engine.get_query_from_string(query)
                result[:sql] = q.sql
                result[:sql_parameter_values] = q.values

                log "sql query:\n\n#{q.sql}."
                log ""
                #log "sql parameter values: #{q.values}."
                #log ""

                data = Query::Engine.run(q, db.base)
                result[:data] = data
                #puts data

                result[:count] = data.length
                #log "results count: #{data.length}."
                #log ""

                handle_result(result)
        end
end
set_standard_api_sample_queries_list() click to toggle source
# File lib/jungle_path/api/helpers/standard_apis.rb, line 164
def set_standard_api_sample_queries_list
        get '/v1/sample/queries' do
                files = Dir["./public/query/queries/*.uql"]
                files = files.map {|n| n.split('/').pop().split('.')[0] }
                files.sort!
                handle_result(files)
        end
end
set_standard_forward_api() click to toggle source
# File lib/jungle_path/api/helpers/standard_apis.rb, line 59
def set_standard_forward_api
        get '/forward/:target/*' do
                #log "forward get"
                target = params[:target]
                splat = params[:splat].join('/')
                host = nil
                #log "forward target: #{target}."
                #log "forward splat: #{splat}."
                user_name = request.env['REMOTE_USER']
                #log "forward user_name: #{user_name}"
                host, port, user_name, password = APIHelpers::StandardAPIs.get_forward_host target
                if host
                        response = Remote.get user_name, password, host, port, "/#{splat}"
                        #log "response: #{response}."
                        if response.code == 200
                                response = JsonWrap.load(response.to_s)
                        else
                                halt response.to_a
                        end
                else
                        raise ArgumentError.new("Invalid forward GET target: \"#{target}\".")
                end
                handle_result(response)
        end

        post '/forward/:target/*' do
                #log "forward post"
                target = params[:target]
                splat = params[:splat].join('/')
                host = nil
                #log "forward target: #{target}."
                #log "forward splat: #{splat}."
                user_name = request.env['REMOTE_USER']
                #log "forward user_name: #{user_name}"
                host, port, user_name, password = APIHelpers::StandardAPIs.get_forward_host target
                if host
                        response = Remote.post user_name, password, host, port, "/#{splat}", params
                        #log "response: #{response}."
                        if response.code == 200
                                response = JsonWrap.load(response.to_s)
                        else
                                halt response.to_a
                        end
                else
                        raise ArgumentError.new("Invalid forward POST target: \"#{target}\".")
                end
                handle_result(response)
        end

        put '/forward/:target/*' do
                #log "forward post"
                target = params[:target]
                splat = params[:splat].join('/')
                host = nil
                #log "forward target: #{target}."
                #log "forward splat: #{splat}."
                user_name = request.env['REMOTE_USER']
                #log "forward user_name: #{user_name}"
                host, port, user_name, password = APIHelpers::StandardAPIs.get_forward_host target
                if host
                        response = Remote.put user_name, password, host, port, "/#{splat}", params
                        #log "response: #{response}."
                        response = JsonWrap.load(response.to_s) if response.code == 200
                else
                        raise ArgumentError.new("Invalid forward POST target: \"#{target}\".")
                end
                handle_result(response)
        end

        delete '/forward/:target/*' do
                #log "forward post"
                target = params[:target]
                splat = params[:splat].join('/')
                host = nil
                #log "forward target: #{target}."
                #log "forward splat: #{splat}."
                user_name = request.env['REMOTE_USER']
                #log "forward user_name: #{user_name}"
                host, port, user_name, password = APIHelpers::StandardAPIs.get_forward_host target
                if host
                        response = Remote.delete user_name, password, host, port, "/#{splat}"
                        #log "response: #{response}."
                        response = JsonWrap.load(response.to_s) if response.code == 200
                else
                        raise ArgumentError.new("Invalid forward POST target: \"#{target}\".")
                end
                handle_result(response)
        end
end
set_standard_keys_api() click to toggle source
# File lib/jungle_path/api/helpers/standard_apis.rb, line 204
def set_standard_keys_api
        get '/test' do
                puts "valid_user: #{valid_user}"
        end

        delete '/keys/:id' do
                key_id = params[:id]
                #puts "delete /keys/#{key_id}"
                if key_id == current_key.id
                        halt 403, "Self deletion of key not allowed."
                end
                handle_result(Controller::Key.new(current_identity, params, db).delete)
        end

        begin # authorization
                get '/current/user' do
                        result = {user: current_user, key: current_key, roles: current_roles}
                        puts "current/user: #{result}."
                        puts "current_key.key: #{current_key.key}."
                        handle_result(result)
                end

                get '/current/user/auth' do
                        message = {
                                user_id: current_user.id,
                                user_name: current_user.user_name,
                                key_id: current_key.id,
                                key_name: current_key.name,
                                key_value: current_key.key,
                                roles: current_auth.roles,
                                permissions: current_auth.permissions,
                                restrictions: current_auth.restrictions,
                                query_filters: current_user.query_filters
                        }
                        handle_result message
                end

                get '/roles/key/:id' do
                        key = Schema::Key.new(params, false, true)
                        roles = SQL::Role.by_key(db, key)
                        handle_result(roles)
                end
        end

        begin # api_keys gets
                get '/keys/:key' do
                        pass if params['key'].match(/^\d+$/) # if key is an integer goto route /api_keys/:id
                        handle_result(Controller::Key.new(current_identity, params, db).select_by_key)
                end

                get '/keys/user/:user_id' do
                        # get the api keys for this user.
                        handle_result(Controller::Key.new(current_identity, params, db).select_by_user)
                end

                get '/keys/user/:user_id/default' do
                        # get the default api keys for this user.
                        handle_result(Controller::Key.new(current_identity, params, db).select_default_by_user)
                end

                get '/keys/user/:user_id/application/:application_id' do
                        # get the api keys for this user for this application.
                        handle_result(Controller::Key.new(current_identity, params, db).select_by_user)
                end

                get '/keys/user/:user_id/application/:application_id/default' do
                        # get the default api keys for this user for this application.
                        result = Controller::Key.new(current_identity, params, db).select_default_by_user
                        #puts "result: #{result}."
                        handle_result(result)
                end
        end
end
set_standard_users_api() click to toggle source
# File lib/jungle_path/api/helpers/standard_apis.rb, line 185
def set_standard_users_api
        get '/users/:user_name/:password' do
                #puts "get '/users/:user_name/:password'"
                user = get_any_user(params[:user_name], params[:password])
                puts "user.is_valid: #{(user and user.is_valid)}"
                return handle_result(user) if (user and user.is_valid)
                handle_result(nil)
        end

        delete '/users/:id' do
                user_id = params[:id].to_i
                puts "delete: /users/#{user_id}"
                if user_id == current_user.id
                        halt 403, "Self deletion not allowed."
                end
                handle_result(Controller::User.new(current_identity, params, db).delete)
        end
end