jungle_path 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61179dfea18fd9bfef83ac47f07a8ec178752c66
-  data.tar.gz: cf9b2c08672ea2d236956bcc6d34f0147f7039aa
+  metadata.gz: aa568e6121f73ebcf9e37a3fa48f87b73b2c2d26
+  data.tar.gz: b4b800b43f212c708ffd76681c342cddca969d76
 SHA512:
-  metadata.gz: 916535ebfdd122a1107fa132fa8663490167b7422af9b45652bd2d38fa944730f787896488e28f193c6725b3d775f7445cae8625aa3c28d756f0e6f4104bdd3b
-  data.tar.gz: 2b4c38646c95ae2e2881f1e01bf208c23399633b2d1ced1dd8c7636b14e4e60834cbe3207b6619b690386a3ea039fafef0fbc4e8c89b56a40d380db17238118c
+  metadata.gz: c3968c3ba0864c05c8f2e2b05148d93d110f4c570ffc2d2d9df1174697be3d00b5b33cc1b328e669758d7920a7de5f10cfd81b5bbd4f744e5b78ab425ede06a6
+  data.tar.gz: 99ec0c3dbca92db4336fdf47cb68af87f20368a618f9fe37dc7d8a681bb12a014af06646e4aea3f5a04090af5a0e18c4b7f494003c38a1849e8740c84270c170

data/Gemfile

@@ -4,6 +4,7 @@ source "https://rubygems.org"
 # gem "rails"
 gem 'pry'
 gem 'pry-byebug'
+gem 'thin'
 gem 'sequel'
 gem 'pg'
 gem 'sequel_pg', :require=>'sequel'

data/jungle_path.gemspec

@@ -1,10 +1,13 @@
 # coding: utf-8
+puts "ARGV: #{ARGV}"
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jungle_path/version'
 
 Gem::Specification.new do |spec|
   spec.name          = 'jungle_path'
-  spec.version       = '0.0.1'
+  spec.version       = JunglePath::VERSION
   spec.authors       = ['Michael VanZant']
   spec.email         = ['mxvanzant@yahoo.com']
   spec.summary       = 'Full-stack web application framework for creating API services.'

data/lib/jungle_path/api/helpers/auth.rb

@@ -3,11 +3,11 @@ module JunglePath
 	module API
 		module Helpers
 			module Auth
-				def authenticate auth_provider=nil, data_provider=nil, no_cache=false
+				def authenticate auth_provider, data_provider, no_cache=false
 					puts "Auth.authenticate"
-					data_provider = JunglePath::Authentication::DataProvider::Default.new unless data_provider
-					auth_provider = JunglePath::Authentication::AuthProvider::Default.new unless auth_provider
-					@current_identity = auth_provider.authenticate(data_provider, no_cache)
+					#data_provider = JunglePath::Authentication::DataProvider::Default.new unless data_provider
+					#auth_provider = JunglePath::Authentication::AuthProvider::Default.new unless auth_provider
+					@current_identity = auth_provider.authenticate(request, data_provider, no_cache)
 					halt 401 unless @current_identity and @current_identity.valid?
 					request.body.rewind
 				end
@@ -24,16 +24,12 @@ module JunglePath
 					@current_identity and @current_identity.key
 				end
 
-				def current_roles
-					@current_identity and @current_identity.roles
-				end
-
 				def current_role
-					@current_identity and @current_identity.default_role
+					@current_identity and @current_identity.role
 				end
 
 				def current_auth
-					@current_identity and @current_identity.auth
+					@current_identity and @current_identity.authorization_filter
 				end
 
 				def current_query_filters

data/lib/jungle_path/api/helpers/defaults.rb

@@ -10,9 +10,9 @@ module JunglePath
 			module Defaults
 				# default mixin that may be included in your Sinatra application class.
 
-				def set_default_rack_middleware issue_challenge=true
-					use Rack::MobileDetect
-					use Rack::CommonLogger, configatron.application.logger
+				def set_default_rack_middleware logger, issue_challenge=true
+					use ::Rack::MobileDetect
+					use ::Rack::CommonLogger, logger
 					use JunglePath::Rack::JsonBodyParser, true
 					# This is rack middleware that adds 'REMOTE_USER' and 'REMOTE_PASSWORD'
 					# keys with their associated basic auth values to request.env (if present in the HTTP header).
@@ -23,7 +23,7 @@ module JunglePath
 					use JunglePath::Rack::BasicCredentials::Basic, "Basic Authentication Required.", issue_challenge
 				end
 
-				def set_default_error_handling
+				def set_default_error_handling logger
 					# These must be disabled to allow error methods to fire.
 					disable :raise_errors
 					disable :show_exceptions
@@ -59,13 +59,14 @@ module JunglePath
 					helpers JunglePath::API::Helpers::QueryFilters
 				end
 
-				def set_default_authentication_check
+				def set_default_authentication_check debug_show_params=false
 					before do
 						puts ""
 						puts "::::[request_start: #{Time.now.utc}]::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::"
 						puts "::::[#{request.env['REMOTE_USER']}: #{request.request_method} #{request.url}"
 						puts "(api_helpsers - before do - default authentication check)"
-						puts "[params] #{params.to_h}" if configatron.debug.show_params
+						#puts "[params] #{params.to_h}" if configatron.debug.show_params
+						puts "[params] #{params.to_h}" if debug_show_params
 						puts "authenticate..."
 						# These three request paths return user info, so force no_cache = true so that stale user data is not returned!
 						no_cache = request.path_info == '/authenticate' or request.path_info == '/current/user' or request.path_info == '/current/user/auth'

data/lib/jungle_path/api/helpers/logging.rb

@@ -10,9 +10,15 @@ module JunglePath
 					puts info
 				end
 
+				#def set_logger logger
+				#	@logger = logger
+				#end
+
 				def logger
 					#API.logger
-					Logger.new(configatron.application.logger)
+					#Logger.new(configatron.application.logger)
+					#@logger
+					jungle.application.logger
 				end
 
 				def get_log_file_list

data/lib/jungle_path/api/helpers.rb

@@ -4,8 +4,8 @@ module JunglePath
 			require 'jungle_path/api/helpers/logging'
 			require 'jungle_path/api/helpers/rescues'
 			require 'jungle_path/api/helpers/auth'
-			require 'jungle_path/api/helpers/auth_local_user'
-			require 'jungle_path/api/helpers/auth_old'
+			#require 'jungle_path/api/helpers/auth_local_user'
+			#require 'jungle_path/api/helpers/auth_old'
 			require 'jungle_path/api/helpers/result'
 			require 'jungle_path/api/helpers/query_filters'
 			require 'jungle_path/api/helpers/standard_apis'

data/lib/jungle_path/api/template.erb

@@ -3,11 +3,11 @@
 require 'sinatra/base'
 require_relative '../db/db'
 require_relative '../schemas/schema'
-require_relative 'server_base'
+require_relative 'base'
 require_relative '../controllers/controller'
 
 module <%= name_space %>
-  class API < <%= name_space %>::BaseAPI
+  class <%= class_name %> < <%= name_space %>::<%= base_class_name %>
     <% for table in tables %>
     begin # <%= table.plural_table_name %>
       get '/<%= table.plural_table_name %>' do

data/lib/jungle_path/app/api/{server_base.rb → base.rb}

@@ -1,27 +1,27 @@
+require 'time'
 require 'rack'
 require 'sinatra/base'
 require 'jungle_path/json'
 require 'jungle_path/api/helpers'
 require 'jungle_path/authentication/auth_provider'
 require 'jungle_path/authentication/data_provider'
+require 'jungle_path/authorization/filter'
+require 'jungle_path/authorization/paths'
 require 'jungle_path/query/filter'
+require 'jungle_path/rack/basic_credentials'
+require 'jungle_path/sql'
 
-
-#require_relative '../config/base_config'
-#require_relative '../../lib/basic_credentials'
-#require_relative '../../lib/sql'
-#require_relative '../../lib/api_helpers'
-#require_relative '../../lib/authorization'
-#require_relative '../db/db'
-#require_relative '../schemas/schema'
-#require_relative '../auth/authorization'
+require_relative '../config/config' #for config settings use jungle.setting...
+require_relative '../db/db'
+require_relative '../schemas/schema'
+require_relative '../auth/authorization'
 
 module Server
   #class BaseAPI < Sinatra::Application
-  class BaseAPI < Sinatra::Base
+  class Base < Sinatra::Base
     configure do
-      set :public_folder, configatron.application.public_dir
-      set :root, configatron.application.root_dir
+      set :public_folder, jungle.application.public_dir
+      set :root, jungle.application.root_dir
       set :dump_errors, true
       set :sessions, false
       set :logging, true
@@ -38,22 +38,23 @@ module Server
     extend JunglePath::API::Helpers::StandardAPIs
 
 		# Your own:
-    #extend ServerAPI::Authorization
+    extend Auth::Authorization
 
     def self.inherited(subclass)
       super
       subclass.instance_eval do
-        set_default_rack_middleware false
-        set_default_error_handling
+        set_default_rack_middleware jungle.application.logger, false
+        set_default_error_handling jungle.application.logger
 
         helpers JunglePath::API::Helpers::DataCache
         helpers JunglePath::API::Helpers::Logging
+        #set_logger jungle.application.logger
         helpers JunglePath::API::Helpers::Result
         helpers JunglePath::API::Helpers::Auth
         helpers Server::Base::Database
 
 				# Your own:
-        #set_authorization
+        set_authorization jungle.route_access
 
         set_standard_api_get_log_file_list
         set_standard_api_get_log_file
@@ -70,26 +71,26 @@ module Server
       puts "[request_start: #{Time.now.utc}]::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::"
       puts "[#{request.env['REMOTE_USER']}: #{request.request_method} #{request.url}"
       puts "(base_api - before do - authentication check)"
-      puts "[params] #{params.to_h}" if configatron.debug.show_params
-      if ServerAPI::Authorization.is_open_path?(request, configatron)
+      puts "[params] #{params.to_h}" if jungle.debug.show_params
+      if JunglePath::Authorization::Paths.is_open_path?(request, jungle.route_access)
         puts "is open path: #{request.path_info}"
       else
         puts "is secured path: #{request.path_info}"
         # These three request paths return user info, so force no_cache = true so that stale user data is not returned!
         no_cache = (request.path_info == '/authenticate' or request.path_info == '/current/user' or request.path_info == '/current/user/auth')
         puts "authenticate no_cache: #{no_cache}."
+        #data_provider = JunglePath::Authentication::DataProvider::Test.new(Schema::Base.models)
+        #def initialize db, user_model, models, roles, schema_filters, role_schema_filters, role_query_filters, restriction_query_filters, user_query_filters
+        data_provider = JunglePath::Authentication::DataProvider::Default.new(self, cache, db, ::Schema::User, ::Schema::Base.models, jungle.roles, jungle.schema_filters, jungle.role_schema_filters, jungle.role_query_filters, jungle.restriction_query_filters, jungle.user_query_filters)
         auth_provider = JunglePath::Authentication::AuthProvider::Default.new
-        data_provider = JunglePath::Authentication::DataProvider::Default.new
-        JunglePath::API::Helpers::Auth.authenticate auth_provider, data_provider, no_cache
+        authenticate auth_provider, data_provider, no_cache
       end
     end
 
     module Database
       def db
-        ServerAPI::DB.instance
+        Server::DB.instance
       end
     end
-
-    end
   end
 end

data/lib/jungle_path/app/api/{server_custom.rb → custom.rb}

@@ -3,21 +3,17 @@ require 'time'
 require 'date'
 require 'pp'
 
-require_relative '../config/base_config'
-require_relative '../../lib/query'
-require_relative '../../lib/controller'
-require_relative '../../lib/key_helpers'
-require_relative '../../lib/gen_node_tree'
-#require_relative 'pubnub_rs'
+require 'jungle_path/query'
+require 'jungle_path/controller'
+require 'jungle_path/cache'
+
 require_relative '../db/db'
 require_relative '../schemas/schema'
-require_relative 'server_base'
-require_relative '../utils/utils'
+require_relative 'base'
 require_relative '../controllers/controller'
-require_relative '../services/email'
 
 module Server
-  class API < Server::BaseAPI
+  class API < Server::Base
     get '/' do
       # default page:
       #if request.env['X_MOBILE_DEVICE']
@@ -77,7 +73,7 @@ module Server
 
     get '/cachetest/:key' do
       key = params[:key]
-      value = LocalCache[key]
+      value = JunglePath::Cache[key]
       handle_result({key: "#{key}", value: "#{value}"})
     end
 
@@ -93,16 +89,19 @@ module Server
 		end
 
     get '/current/user' do
-      handle_result({user: current_user, key: current_key, roles: current_roles, auth: {permissions: current_auth.permissions, restrictions: current_auth.restrictions, schema_filter: current_auth.schema_filter}} )
+      handle_result({user: current_user, key: current_key, role: current_role, auth: {permissions: current_auth.permissions, restrictions: current_auth.restrictions, schema_filter: current_auth.schema_filter}} )
     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,
+        #key_id: current_key.id,
+        #key_name: current_key.name,
+        #key_value: current_key.key,
+        key_id: current_user.id,
+        key_name: current_user.user_name,
+        key_value: current_user.user_name,
         roles: current_auth.roles,
         permissions: current_auth.permissions,
         restrictions: current_auth.restrictions,
@@ -118,4 +117,4 @@ module Server
   end
 end
 
-require_relative 'server_gen'
+require_relative 'generated'

data/lib/jungle_path/app/api/{server_gen.rb → generated.rb}

@@ -2,10 +2,10 @@
 require 'sinatra/base'
 require_relative '../db/db'
 require_relative '../schemas/schema'
-require_relative 'base_api'
+require_relative 'base'
 require_relative '../controllers/controller'
 
 module Server
-  class API < Server::BaseAPI
+  class API < Server::Base
 	end
 end

data/lib/jungle_path/app/auth/authorization.rb

@@ -1,17 +1,18 @@
 require 'jungle_path/authorization/paths'
-require '../config/config'
+require 'jungle_path/sql'
+require_relative '../config/config'
 
-module ServerAPI
+module Auth
 	module Authorization
-		def set_authorization
+		def set_authorization route_access
 			before do
 				puts "verb: #{request.request_method}."
 				puts "path: #{request.path_info}."
 
 				authorized = false
 
-				authorized = JunglePath::Authorization::Path.is_open_path?(request, jungle.route_access)
-				authorized = JunglePath::Authorization::Path.is_authenticated_path?(request, jungle.route_access) unless authorized
+				authorized = JunglePath::Authorization::Paths.is_open_path?(request, route_access)
+				authorized = JunglePath::Authorization::Paths.is_authenticated_path?(request, route_access) unless authorized
 
 				unless authorized
 					if request.get?
@@ -24,11 +25,11 @@ module ServerAPI
 						authorized = true if current_auth.has_permission?(:write) unless authorized
 						authorized = true if request.path_info == "/query" and current_auth.has_permission?(:read) unless authorized
 						authorized = true if request.path_info == "/users/#{current_user.id}" unless authorized
-						authorized = true if ServerAPI::Authorization.authorized_admin?(request, params, current_auth, db) unless authorized
+						authorized = true if Auth::Authorization.authorized_admin?(request, params, current_auth, db) unless authorized
 						authorized = false if current_auth.has_restriction?(:read)
 					end
 
-					authorized = false if current_auth.has_restriction?(:query_only) unless JunglePath::Authorization::Path.is_query_only_path? request, current_auth
+					authorized = false if current_auth.has_restriction?(:query_only) unless JunglePath::Authorization::Paths.is_query_only_path? request, current_auth
 				end
 
 				unless authorized
@@ -63,25 +64,25 @@ module ServerAPI
 
 				if request.path_info == "/users" # post...
 					role_id = params[:role_id]
-					authorized = false if role_id and SQL::UserRole.is_root_role_by_role_id(db, role_id) # :auth_admin not allowed to add a root user_role.
+					authorized = false if role_id and JunglePath::SQL::UserRole.is_root_role_by_role_id(db, role_id) # :auth_admin not allowed to add a root user_role.
 
 				elsif parts[1] == "users" # put or delete
 					user_id = parts[2].to_i
 					role_id = params[:role_id]
-					authorized = false if SQL::AuthLocalUser::UserRole.has_root_role_by_user_id(db, user_id) # :auth_admin not allowed to modify data related to a user with a role of root.
-					authorized = false if authorized and role_id and SQL::UserRole.is_root_role_by_role_id(db, role_id) # :auth_admin not allowed to add a root user_role.
+					authorized = false if JunglePath::SQL::UserRole.has_root_role_by_user_id(db, user_id) # :auth_admin not allowed to modify data related to a user with a role of root.
+					authorized = false if authorized and role_id and JunglePath::SQL::UserRole.is_root_role_by_role_id(db, role_id) # :auth_admin not allowed to add a root user_role.
 
 				elsif request.path_info == "/user_roles" # post...
 					user_id = params[:user_id]
 					role_id = params[:role_id]
-					authorized = false if SQL::AuthLocalUser::UserRole.has_root_role_by_user_id(db, user_id)
-					authorized = false if authorized and SQL::UserRole.is_root_role_by_role_id(db, role_id)
+					authorized = false if JunglePath::SQL::UserRole.has_root_role_by_user_id(db, user_id)
+					authorized = false if authorized and JunglePath::SQL::UserRole.is_root_role_by_role_id(db, role_id)
 
 				elsif parts[1] == "user_roles" # put or delete
 					user_id = parts[2].to_i
 					role_id = parts[3].to_i
-					authorized = false if SQL::AuthLocalUser::UserRole.has_root_role_by_user_id(db, user_id)
-					authorized = false if authorized and SQL::UserRole.is_root_role_by_role_id(db, role_id)
+					authorized = false if JunglePath::SQL::UserRole.has_root_role_by_user_id(db, user_id)
+					authorized = false if authorized and JunglePath::SQL::UserRole.is_root_role_by_role_id(db, role_id)
 
 				elsif allowed[parts[1]]
 					authorized = true

data/lib/jungle_path/app/config/config.rb

@@ -22,9 +22,8 @@ module Config
 		role_query_filters
 		restriction_query_filters
 		user_query_filters
-		permissions_and_restrictions
+		#permissions_and_restrictions
 		route_access
-		schema_filters
 		debug
 		config_override
 		jungle.lock = true
@@ -38,7 +37,7 @@ module Config
 			puts "[application root]/config/environment.rb file was loaded."
 			puts "jungle.environment.name == '#{jungle.environment.name}'"
 		rescue LoadError => ex
-			puts "[application root]/config/environment.rb file was not found, defaulting to jungle.environment.name == '#{jungle_config.environment.name}'."
+			puts "[application root]/config/environment.rb file was not found, defaulting to jungle.environment.name == '#{jungle.environment.name}'."
 			puts "to override, create file ./config/environment.rb with one line like this:"
 			puts "jungle.environment.name = 'stage' \# valid environments may be: 'dev', 'stage' or 'prod' or whatever you want to use :)"
 		end
@@ -62,11 +61,11 @@ module Config
 	def self.db
 		jungle.db.name = "jungle_path"
 		jungle.db.type = "postgres"
-		jungle.db.user_name = "jungle_path"
+		jungle.db.user_name = "junglepath"
 		jungle.db.password =  nil
 		jungle.db.host = "localhost"
 		jungle.db.extensions = [:pg_json]
-		jungle.db.port = nil # defaults to PostgreSQL default port of 5432.
+		jungle.db.port = nil # defaults to PostgreSQL default port of 5432 if nil.
 		jungle.db.options = {max_connections: 4}
 	end
 
@@ -136,7 +135,7 @@ module Config
 				active: true,
 				user_name: :root,
 				password: 'test',
-				roles: [:root]
+				role: :root
 			},
 			admin: {
 				id: 1,
@@ -146,7 +145,7 @@ module Config
 				active: true,
 				user_name: :admin,
 				password: 'test',
-				roles: [:admin]
+				role: :admin
 			},
 			user: {
 				id: 2,
@@ -156,7 +155,7 @@ module Config
 				active: true,
 				user_name: :user,
 				password: 'test',
-				roles: [:user]
+				roles: :user
 			}
 		}
 	end
@@ -184,7 +183,7 @@ module Config
 		jungle.role_query_filters = lambda {|identity|
 			filters = {
 				admin: [
-					{table_name: :table_i_want_to_filter, sub_select: "select id from table_i_want_to_filter where a = b"}
+					{table_name: :table_i_want_to_filter, sub_select: "select id from table_i_want_to_filter where a = b", use_not_in: false}
 				]
 				# more...
 			}

data/lib/jungle_path/app/config/override.rb

@@ -1,3 +1,4 @@
 # Use override.rb for configuration of any sensitive data such as passwords.
 # Do not push override.rb to git! :)
-jungle.db.password =  nil
+jungle.db.port = 15432 # vagrant
+jungle.db.password =  'test'

data/lib/jungle_path/app/config.ru

@@ -4,25 +4,26 @@
 #require 'sinatra'
 require 'time'
 #require 'rack/mobile-detect'
+require 'jungle_path/migration'
 #require_relative '../lib/rack_json_body_parser'
-require_relative 'api/server_custom'
+require_relative 'api/custom'
 require_relative 'config/config' # contains all settings except sensitive data set to nil. Put sensitive data (passwords, etc.) in config/override.rb and .gitignore override.rb!
 require_relative 'schemas/schema'
 require_relative 'db/db'
-require_relative 'ztools/migration'
+
 puts "startup at #{Time.now}."
 
 #use Rack::MobileDetect
 #use Rack::CommonLogger, configatron.application.logger
 #use Rack::PostBodyContentTypeParser, true
 
-if jungle.application.on_startup.run_database_migrations
+if jungle.on_startup.run_database_migrations
 	puts "running (main) database migrations..."
-	puts "set jungle.application.on_startup.run_database_migrations = false in your config.rb or override.rb to prevent running main database migrations at startup."
+	puts "set jungle.on_startup.run_database_migrations = false in your config.rb or override.rb to prevent running main database migrations at startup."
 	Migration.run Schema, ServerAPI::DB.instance
 else
 	puts "skipping database (main) migrations."
-	puts "set jungle.application.on_startup.run_database_migrations = true in your config.rb or override.rb to run main database migrations at startup."
+	puts "set jungle.on_startup.run_database_migrations = true in your config.rb or override.rb to run main database migrations at startup."
 end
 
 map('/') {run Server::API}