jungle_path 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c9a76586270cb176c12b4cee2c5634f095986dd
-  data.tar.gz: 8c5a58c3e0c272e1e1d3fa54e0043eb515153a66
+  metadata.gz: 162b61d2490684693fc8cd9b7ff7c814628c29cb
+  data.tar.gz: 61438251aa193d15755d7aa9ef73f6e58d3a22d5
 SHA512:
-  metadata.gz: 8fac534b4b48fcb7ccc3bcb3404da09e7f5108c867523e7eafb33f553b6cbfd0267359ed52c4ea4fa205f7c7235501ce006e23fa04475d8cc3acafbafa826b30
-  data.tar.gz: 8cbe0b457b9c522d8aadc11ec76b1dd24fef8803f052abfd78b55310770727d68596e461d773a9132274c7270e6db4256375aa3ce23d8610852febd709e96b52
+  metadata.gz: 6ebc40995f918fa40f4ae6bdeb1ec1ce75d94c3218e71f34a659c5608aa90fcd82703b9b4da6377600d168527e44e38cfbe600950becb76cd0d1a1d355cbf11c
+  data.tar.gz: ddee9e142757902d4fbf3aef70b0a74e22b7400267bf1424a6f58aaaf283eda5dd1f19576217a45e2b38a9c9ae6c4c126466d21d098deccbb1feab370124b2ff

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

@@ -33,7 +33,7 @@ module JunglePath
 						#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_user, apply_limit_offset_to_sql)
+						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

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

@@ -161,21 +161,17 @@ module Config
 	end
 
 	def self.schema_filters
-		jungle.schema_filters = lambda {|identity|
-			filters = {
-				allow_all_tables: {allow: [table: /./]},
-				hide_nonpublic_tables: {allow: [{table: /./}], deny: [{table: /^utility_/}, {table: /^temp_/}]}
-			}
+		jungle.schema_filters = {
+			allow_all_tables: {allow: [table: /./]},
+			hide_nonpublic_tables: {allow: [{table: /./}], deny: [{table: /^utility_/}, {table: /^temp_/}]}
 		}
 	end
 
 	def self.role_schema_filters
-		jungle.role_schema_filters = lambda {|identity|
-			filters = {
-				root: :allow_all_tables,
-				admin: :allow_all_tables,
-				user: :hide_nonpublic_tables
-			}
+		jungle.role_schema_filters = {
+			root: :allow_all_tables,
+			admin: :allow_all_tables,
+			user: :hide_nonpublic_tables
 		}
 	end
 

data/lib/jungle_path/authentication/auth_provider/default.rb

@@ -71,10 +71,12 @@ module JunglePath
 							idn.role = data_provider.get_role(idn, no_cache)
 							idn.authorization_filter = data_provider.get_authorization_filter(idn, no_cache)
 							idn.query_filters = data_provider.get_query_filters(idn, no_cache)
+							puts "query_filters: set!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
 						else
 							idn.role = nil
 							idn.authorization_filter = nil
 							idn.query_filters = nil
+							puts "query_filters: nil!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
 						end
 					end
 					idn

data/lib/jungle_path/authentication/data_provider/default.rb

@@ -1,6 +1,7 @@
 module JunglePath
 	require 'jungle_path/authentication/password_hash'
 	require 'jungle_path/authorization/filter'
+	require 'jungle_path/query/filter'
 	require 'jungle_path/schema/auth'
 	require 'jungle_path/sql/user'
 	module Authentication
@@ -68,22 +69,51 @@ module JunglePath
 				end
 
 				def get_authorization_filter(identity, no_cache=false)
-					JunglePath::Authorization::Filter.new([identity.role], @models, @role_permissions, @role_restrictions, @role_schema_filters.call(identity), @schema_filters.call(identity))
+					JunglePath::Authorization::Filter.new([identity.role], @models, @role_permissions, @role_restrictions, @role_schema_filters, @schema_filters)
 				end
 
 				def get_query_filters(identity, no_cache=false)
 					filters = []
-					@role_query_filters.call(identity).each do |key, filter|
-						filters << filter
+
+					temp_filters = @role_query_filters.call(identity)[identity.role] || []
+					temp_filters.each do |filter|
+						filters << JunglePath::Query::Filter.new(filter[:table_name], filter[:sub_select])
 					end
-					@restriction_query_filters.call(identity).each do |key, filter|
-						filters << filter
+
+					temp_filters = @restriction_query_filters.call(identity)
+					identity.authorization_filter.restrictions.each do |restriction|
+						temp = temp_filters[restriction] || []
+						temp.each do |filter|
+							filters << JunglePath::Query::Filter.new(filter[:table_name], filter[:sub_select])
+						end
 					end
-					@user_query_filters.call(identity).each do |key, filter|
-						filters << filter
+
+					temp_filters = @user_query_filters.call(identity)
+					temp = temp_filters[identity.user.id] || []
+					temp.each do |filter|
+						filters << JunglePath::Query::Filter.new(filter[:table_name], filter[:sub_select])
 					end
+
 					filters
 				end
+
+
+				# def get_query_filters(identity, no_cache=false)
+				# 	filters = []
+				# 	@role_query_filters.call(identity).each do |key, filter|
+				# 		puts "role_query_filters: key/filter: #{key}/#{filter}"
+				# 		filters << filter
+				# 	end
+				# 	@restriction_query_filters.call(identity).each do |key, filter|
+				# 		puts "restriction_query_filters: key/filter: #{key}/#{filter}"
+				# 		filters << filter
+				# 	end
+				# 	@user_query_filters.call(identity).each do |key, filter|
+				# 		puts "user_query_filters: key/filter: #{key}/#{filter}"
+				# 		filters << filter
+				# 	end
+				# 	filters
+				# end
 			end
 		end
 	end

data/lib/jungle_path/authentication/data_provider/test.rb

@@ -1,6 +1,7 @@
 module JunglePath
 	require 'jungle_path/authentication/password_hash'
 	require 'jungle_path/authorization/filter'
+	require 'jungle_path/query/filter'
 	require 'jungle_path/schema/auth'
 	module Authentication
 		module DataProvider
@@ -71,37 +72,30 @@ module JunglePath
 						@role_permissions[role[:name]] = role[:permissions]
 						@role_restrictions[role[:name]] = role[:restrictions]
 					end
-					@role_schema_filters = lambda {|identity|
-						filters = {
-							root: :allow_all_tables,
-							admin: :allow_all_tables,
-							user: :hide_nonpublic_tables
-						}
+					@role_schema_filters = {
+						root: :allow_all_tables,
+						admin: :allow_all_tables,
+						user: :hide_nonpublic_tables
 					}
-					@schema_filters = lambda {|identity|
-						filters = {
-							allow_all_tables: {allow: [table: /./]},
-							hide_nonpublic_tables: {allow: [{table: /./}], deny: [{table: /^utility_/}, {table: /^temp_/}]}
-						}
+					@schema_filters = {
+						allow_all_tables: {allow: [table: /./]},
+						hide_nonpublic_tables: {allow: [{table: /./}], deny: [{table: /^utility_/}, {table: /^temp_/}]}
 					}
-					@role_query_filters = lambda {|identity|
-						filters = {
+					@role_query_filters = lambda do |identity| {
 							admin: [
 								{table_name: :table_i_want_to_filter, sub_select: "select id from table_i_want_to_filter where a = b"}
 							]
-							# more...
 						}
-					}
-					@restriction_query_filters = lambda {|identity|
-						filters = {
+					end
+					@restriction_query_filters = lambda do |identity| {
 							me_related:[
 								{table_name: :user, sub_select: "select id from user where id = #{identity.user.id}"}
 							]
 						}
-					}
-					@user_query_filters = lambda {|identity|
-						filters = {}
-					}
+					end
+					@user_query_filters = lambda do |identity| {
+						}
+					end
 				end
 
 				def get_user(user_name, password, no_cache=false)
@@ -127,20 +121,31 @@ module JunglePath
 				end
 
 				def get_authorization_filter(identity, no_cache=false)
-					JunglePath::Authorization::Filter.new([identity.role], @models, @role_permissions, @role_restrictions, @role_schema_filters.call(identity), @schema_filters.call(identity))
+					JunglePath::Authorization::Filter.new([identity.role], @models, @role_permissions, @role_restrictions, @role_schema_filters, @schema_filters)
 				end
 
 				def get_query_filters(identity, no_cache=false)
 					filters = []
-					@role_query_filters.call(identity).each do |key, filter|
-						filters << filter
+
+					temp_filters = @role_query_filters.call(identity)[identity.role] or []
+					temp_filters.each do |filter|
+						filters << JunglePath::Query::Filter.new(filter[:table_name], filter[:sub_select])
 					end
-					@restriction_query_filters.call(identity).each do |key, filter|
-						filters << filter
+
+					temp_filters = @restriction_query_filters.call(identity)
+					identity.authorization_filter.restrictions.each do |restriction|
+						temp = temp_filters[restriction] or []
+						temp.each do |filter|
+							filters << JunglePath::Query::Filter.new(filter[:table_name], filter[:sub_select])
+						end
 					end
-					@user_query_filters.call(identity).each do |key, filter|
-						filters << filter
+
+					temp_filters = @user_query_filters.call(identity)
+					temp = temp_filters[identity.user.id] or []
+					temp.each do |filter|
+						filters << JunglePath::Query::Filter.new(filter[:table_name], filter[:sub_select])
 					end
+
 					filters
 				end
 			end

data/lib/jungle_path/authentication/identity.rb

@@ -13,8 +13,7 @@ module JunglePath
           user: @user,
           key: @key,
           valid: @valid,
-          role: @roles,
-          default_role: @default_role,
+          role: @role,
           authorization_filter: @authorization_filter,
           query_filters: @query_filters
         }

data/lib/jungle_path/authorization/filter.rb

@@ -1,4 +1,6 @@
 module JunglePath
+	require 'jungle_path/gen/schema_tree'
+	require 'jungle_path/gen/schema_tree/filter'
 	require 'jungle_path/gen/schema_tree/node'
 	module Authorization
 		class Filter
@@ -65,6 +67,10 @@ module JunglePath
 				@root_roles
 			end
 
+			def to_s
+				"roles: #{@roles}\npermissions: #{@permissions}\nrestrictions: #{@restrictions}\nschema_filter: #{@schema_filter}"
+			end
+
 			private
 
 			def eat_roles roles, role_permissions, role_restrictions, role_schema_filters, schema_filters

data/lib/jungle_path/gen/schema_tree/filter.rb

@@ -1,13 +1,14 @@
 module JunglePath
 	module Gen
 		module SchemaTree
+			require 'jungle_path/gen/schema_tree/match_tables'
 			class Filter
 				def initialize hash=nil
 					throw "Invalid data parameter: expected a hash, but got this: #{hash}" unless hash.class == Hash or hash == nil
 					allow = hash[:allow] if hash
 					deny = hash[:deny] if hash
-					@match_tables_allow = MatchTables.new allow
-					@match_tables_deny = MatchTables.new deny
+					@match_tables_allow = JunglePath::Gen::SchemaTree::MatchTables.new allow
+					@match_tables_deny = JunglePath::Gen::SchemaTree::MatchTables.new deny
 				end
 				def allow? table_name, column_name=nil
 					if @match_tables_allow.matched?(table_name, column_name)

data/lib/jungle_path/gen/schema_tree/match_table_data.rb

@@ -1,11 +1,12 @@
 module JunglePath
 	module Gen
 		module SchemaTree
+			require 'jungle_path/gen/schema_tree/match_columns'
 			class MatchTableData
 				attr_reader :name, :columns, :regexp
 				def initialize name, columns
 					@name = name
-					@columns = MatchColumns.new(columns)
+					@columns = JunglePath::Gen::SchemaTree::MatchColumns.new(columns)
 					@regexp = @name if @name and @name.class == Regexp
 				end
 

data/lib/jungle_path/gen/schema_tree/match_tables.rb

@@ -1,6 +1,7 @@
 module JunglePath
 	module Gen
 		module SchemaTree
+			require 'jungle_path/gen/schema_tree/match_table_data'
 			class MatchTables
 				def initialize data
 					@hash = {}
@@ -14,7 +15,7 @@ module JunglePath
 								columns = h[:columns]
 								puts "columns: #{columns}."
 								if table
-									mtd = MatchTableData.new(table, columns)
+									mtd = JunglePath::Gen::SchemaTree::MatchTableData.new(table, columns)
 									puts "mtd: #{mtd}."
 									@hash[mtd.name] = mtd
 									@match_data << mtd if mtd.regexp

data/lib/jungle_path/query/engine.rb

@@ -6,12 +6,12 @@ require 'jungle_path/query'
 module JunglePath
   module Query
     class Engine
-      attr_reader :root, :tables, :user, :apply_limit_offset_to_sql
+      attr_reader :root, :tables, :identity, :apply_limit_offset_to_sql
 
-      #def initialize(tables_hash, user=nil, apply_limit_offset_to_sql=true)
-      def initialize(node_tree, user=nil, apply_limit_offset_to_sql=true)
+      #def initialize(tables_hash, identity=nil, apply_limit_offset_to_sql=true)
+      def initialize(node_tree, identity=nil, apply_limit_offset_to_sql=true)
         @tables = node_tree.tables_hash
-        @user = user
+        @identity = identity
         @apply_limit_offset_to_sql = apply_limit_offset_to_sql
         #@root = Gen.gen_node_tree(tables_hash)
         @root = node_tree

data/lib/jungle_path/query/sql_string.rb

@@ -64,7 +64,7 @@ module JunglePath
                 sort_ids << "#{entity.alias_}.#{field.name}".to_sym
               end
               puts "#{entity.alias_}.#{field.name} as \"#{entity.alias_}.#{field.name}\" is_secure? #{field.is_secure?}."
-              if !field.is_secure? or (field.is_secure? and engine.user.auth.is_root? or engine.user.auth.is_user_admin?)
+              if !field.is_secure? or (field.is_secure? and engine.identity.authorization_filter.is_root? or engine.identity.authorization_filter.is_user_admin?)
                 select << "#{entity.alias_}.#{field.name} as \"#{entity.alias_}.#{field.name}\""
               end
             end
@@ -96,8 +96,8 @@ module JunglePath
       def self.hook_in_filters(engine, select, from, where, sort, entity)
         puts "hook_in_filters QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFf"
         #binding.pry
-        if engine.user and engine.user.query_filters
-          engine.user.query_filters.each do |filter|
+        if engine.identity and engine.identity.query_filters
+          engine.identity.query_filters.each do |filter|
             puts "hook_in_filters: filter.table_name: #{filter.table_name}."
             from.each do |frm|
               puts "hook_in_filters: frm.table_name: #{frm.table_name}."

data/lib/jungle_path/version.rb

@@ -1,3 +1,3 @@
 module JunglePath
-	VERSION = '0.0.4'
+	VERSION = '0.0.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jungle_path
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Michael VanZant
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-24 00:00:00.000000000 Z
+date: 2017-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler