jungle_path 0.0.12 → 0.0.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f266ff3bb55b4ddca59bfde5fa45eff36b673239
-  data.tar.gz: 5031896e6a7aa4ce2f20d65ead5ef6d1161c59a4
+  metadata.gz: c3d7af2ccd2d0dee2d679b8c544bb5490dad5ca1
+  data.tar.gz: b4d6e98aea0b599ea9eca0c7fe45f9e995d59a6c
 SHA512:
-  metadata.gz: 9989e46b46336ae4222093568659e14476ffc4d095dbfdba74694c62126344da0a74446af1b1d33d90885c0c3dcaf1a2d4df58b2922af94fa63fd585a700cbc8
-  data.tar.gz: 7f0fd364cad67d6143276be5b48dca4b84349aad8c46b0d8b873084121114630f67f4f020082478b7f2910808388b6d73e48a60894aacff7ae8afe6fcf75e9a6
+  metadata.gz: 71a3d3dbf58cf74c883401463c0d0fff2bcb98cffe20556185be44463b04b62049678c96d8bf116319d79eb0d8a44db5a3d72c72a8372e5ec2a4b16d0b866dd9
+  data.tar.gz: de05d0e32c106570d48dd1bb19ca6a341d9dcc5b25905674076bf998c455a82f48646fb4a46ff67bee13a4ced00bea802d857ffe4bcde96d8d436bae67efebf9

data/lib/jungle_path/app/api/base.rb

@@ -81,7 +81,8 @@ module Server
         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)
+        alternative_user_key_queries = [{name: :contact_id, query: "select id as alt_key from contact where user_id = ?"}]
+        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, jungle.role_table_filters, jungle.restriction_table_filters, jungle.user_table_filters, alternative_user_key_queries)
         auth_provider = JunglePath::Authentication::AuthProvider::Default.new
         authenticate auth_provider, data_provider, no_cache
       end

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

@@ -22,6 +22,9 @@ module Config
 		role_query_filters
 		restriction_query_filters
 		user_query_filters
+		role_table_filters
+		restriction_table_filters
+		user_table_filters
 		#permissions_and_restrictions
 		route_access
 		debug
@@ -189,9 +192,9 @@ module Config
 	def self.restriction_query_filters
 		jungle.restriction_query_filters = lambda {|identity|
 			filters = {
-				me_related:[
-					{table_name: :user, sub_select: "select id from user where id = #{identity.user.id}"}
-				]
+				#me_related:[
+				#	{table_name: :user, sub_select: "select id from user where id = #{identity.user.id}"}
+				#]
 			}
 		}
 	end
@@ -202,6 +205,28 @@ module Config
 		}
 	end
 
+	def self.role_table_filters
+		# Replace usage of a table in a query with the given view or parameterized function
+		jungle.role_table_filters = {
+			user: [
+				{table_name: :contact, replacement: :filter_contact}
+			]
+				# more...
+		}
+	end
+
+	def self.restriction_table_filters
+		jungle.restriction_table_filters = {
+			me_related:[
+				{table_name: :contact, replacement: :filter_contact}
+			]
+		}
+	end
+
+	def self.user_table_filters
+		jungle.user_table_filters = {}
+	end
+
 	def self.route_access
 		jungle.route_access = {
 			public: {

data/lib/jungle_path/app/schemas/schema.rb

@@ -6,6 +6,7 @@ require 'jungle_path/schema/version'
 require 'jungle_path/schema/base'
 require 'jungle_path/schema/db'
 require 'jungle_path/schema/auth'
+require_relative 'views'
 
 # application tables examples:
 module Schema
@@ -20,6 +21,30 @@ module Schema
 		)
 	end
 
+	class Contact < Schema::Base
+		self.description = ""
+		define(
+			[:id, :primary_key],
+			[:name, :string],
+			[:email, :string],
+			[:user_id, :foreign_key, :user, :unique],
+			[:audit_user]
+		)
+	end
+
+	class FilterContact < Schema::Base
+    self.description = "Test View filter stuff."
+    define(
+      [:id, :primary_key],
+      [:name, :string],
+      [:email, :string],
+			[:user_id, :foreign_key, :user],
+      [:audit_user]
+    )
+    self.view = Views.filter_contact
+  end
+
+
 	class Practice < Schema::Base
 		self.description = ""
 		define(

data/lib/jungle_path/app/schemas/views.rb

@@ -0,0 +1,34 @@
+require 'jungle_path/sql/helpers'
+require 'jungle_path/db_model/view'
+
+module Views
+	def self.filter_contact
+		@f = JunglePath::DBModel::View.new(
+			JunglePath::SQL::Helpers.sql("
+				create or replace function filter_contact(p_contact_id int)
+				returns table (
+				  id int,
+				  name text,
+				  email text,
+					user_id int,
+				  created_at timestamp,
+				  created_by_user_id int,
+				  updated_at timestamp,
+				  updated_by_user_id int
+				)
+				as
+				$body$
+					select
+						a.*
+					from contact a
+					where a.id = p_contact_id
+				$body$
+				language sql;
+			"),
+			"drop function filter_contact(int)",
+			[:user],
+			[:contact_id]
+		) unless @f
+		@f
+	end
+end

data/lib/jungle_path/app/ztools/zbootstrapdata.rb

@@ -31,6 +31,13 @@ module ZBootstrap
     ]
     users.each {|user| db.insert._model(user)}
 
+    contacts = [
+      Schema::Contact.new({id: 0, name: 'root', email: 'root@junglepath.com', user_id: 0, created_by_user_id: 0, updated_by_user_id: 0}),
+      Schema::Contact.new({id: 1, name: 'admin', email: 'admin@junglepath.com', user_id: 1, created_by_user_id: 0, updated_by_user_id: 0}),
+      Schema::Contact.new({id: 2, name: 'user', email: 'user@junglepath.com', user_id: 2, created_by_user_id: 0, updated_by_user_id: 0})
+    ]
+    contacts.each {|contact| db.insert._model(contact)}
+
     #roles = [
     #  Schema::Role.new({id: 0, name: 'root', description: 'do anything', created_by_user_id: 0, updated_by_user_id: 0}),
     #  Schema::Role.new({id: 1, name: 'admin', description: 'general admin -- filtered by organization', created_by_user_id: 0, updated_by_user_id: 0}),
@@ -51,7 +58,7 @@ module ZBootstrap
   def self.fix_serial db=nil
     db = Server::API::DB.instance unless db
     db.reset_sequence_for_table("user")
-    #db.reset_sequence_for_table("role")
+    db.reset_sequence_for_table("contact")
   end
 end
 

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

@@ -70,7 +70,7 @@ module JunglePath
 						end
 						idn.valid = (idn.user and idn.user.is_valid)
 						if idn.valid
-							idn.alternative_user_key = data_provider.get_alternative_user_key(idn.user.id, no_cache) if data_provider.respond_to?('get_alternative_user_key')
+							idn.alternative_user_keys = data_provider.get_alternative_user_keys(idn.user.id, no_cache) if data_provider.respond_to?('get_alternative_user_keys')
 						end
 					end
 					idn
@@ -84,12 +84,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!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+							idn.table_filters = data_provider.get_table_filters(idn, no_cache) if data_provider.respond_to?('get_table_filters')
 						else
 							idn.role = nil
 							idn.authorization_filter = nil
 							idn.query_filters = nil
-							puts "query_filters: nil!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+							idn.table_filters = nil
 						end
 					end
 					idn

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

@@ -7,7 +7,7 @@ module JunglePath
 	module Authentication
 		module DataProvider
 			class Default
-				def initialize sinatra, cache, db, user_model, models, roles, schema_filters, role_schema_filters, role_query_filters, restriction_query_filters, user_query_filters, alternative_user_key_query=nil
+				def initialize sinatra, cache, db, user_model, models, roles={}, schema_filters={}, role_schema_filters={}, role_query_filters=nil, restriction_query_filters=nil, user_query_filters=nil, role_table_filters=nil, restriction_table_filters=nil, user_table_filters=nil, alternative_user_key_queries=nil
 					@sinatra = sinatra
 					@cache = cache
 					@db = db
@@ -25,7 +25,10 @@ module JunglePath
 					@role_query_filters = role_query_filters
 					@restriction_query_filters = restriction_query_filters
 					@user_query_filters = user_query_filters
-					@alternative_user_key_query = alternative_user_key_query
+					@role_table_filters = role_table_filters
+					@restriction_table_filters = restriction_table_filters
+					@user_table_filters = user_table_filters
+					@alternative_user_key_queries = alternative_user_key_queries
 				end
 
 				def get_user(user_name, password, assume_identity=false, no_cache=false)
@@ -77,12 +80,12 @@ module JunglePath
 				def get_query_filters(identity, no_cache=false)
 					filters = []
 
-					temp_filters = @role_query_filters.call(identity)[identity.role] || []
+					temp_filters = (@role_query_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
 
-					temp_filters = @restriction_query_filters.call(identity)
+					temp_filters = (@restriction_query_filters && @restriction_query_filters.call(identity)) || {}
 					identity.authorization_filter.restrictions.each do |restriction|
 						temp = temp_filters[restriction] || []
 						temp.each do |filter|
@@ -90,7 +93,7 @@ module JunglePath
 						end
 					end
 
-					temp_filters = @user_query_filters.call(identity)
+					temp_filters = (@user_query_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])
@@ -99,19 +102,48 @@ module JunglePath
 					filters
 				end
 
-				def get_alternative_user_key(user_id, no_cache=false)
-					cache_key = "#{user_id}_alt_key"
-					alt_key = @cache[cache_key]
-					if alt_key == nil or no_cache
-						if @alternative_user_key_query
-							ds = @db.base[@alternative_user_key_query, user_id]
-							hash = ds.first
-							if hash
-								alt_key = hash[:alt_key]
+				def get_table_filters(identity, no_cache=false)
+					filters = {}
+
+					temp_filters = (@role_table_filters && @role_table_filters[identity.role]) || []
+					temp_filters.each do |filter|
+						filters[filter[:table_name]] = filter
+					end
+
+					identity.authorization_filter.restrictions.each do |restriction|
+						temp_filters = (@restriction_table_filters && @restriction_table_filters[restriction]) || []
+						temp_filters.each do |filter|
+							filters[filter[:table_name]] = filter
+						end
+					end
+
+					temp_filters = (@user_table_filters && @user_table_filters[identity.user.id]) || []
+					temp_filters.each do |filter|
+						filters[filter[:table_name]] = filter
+					end
+
+					filters
+				end
+
+				def get_alternative_user_keys(user_id, no_cache=false)
+					cache_key = "#{user_id}_alt_keys"
+					alt_keys = @cache[cache_key]
+					if alt_keys == nil or no_cache
+						alt_keys = {}
+						alt_keys[:user_id] = user_id
+						if @alternative_user_key_queries
+							@alternative_user_key_queries.each do |alt_key_query|
+								ds = @db.base[alt_key_query[:query], user_id]
+								hash = ds.first
+								if hash
+									alt_key = hash[:alt_key]
+									alt_keys[alt_key_query[:name]] = alt_key
+								end
 							end
 						end
 					end
-					alt_key
+					puts "alt_keys: #{alt_keys}."
+					alt_keys
 				end
 			end
 		end

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

@@ -98,6 +98,17 @@ module JunglePath
 					@user_query_filters = lambda do |identity| {
 						}
 					end
+					@role_table_filters = {
+						user: [
+							{table_name: :opportunity, replacement: :filter_opportunity}
+						]
+					}
+					@restriction_table_filters = {
+						me_related:[
+							{table_name: :opportunity, replacement: :filter_opportunity}
+						]
+					}
+					@user_table_filters = {}
 				end
 
 				def get_user(user_name, password, assume_identity=false, no_cache=false)
@@ -151,6 +162,33 @@ module JunglePath
 
 					filters
 				end
+
+				def get_table_filters(identity, no_cache=false)
+					filters = {}
+
+					temp_filters = @role_table_filters[identity.role] || []
+					temp_filters.each do |filter|
+						filters[filter[:table_name]] = filter
+					end
+
+					identity.authorization_filter.restrictions.each do |restriction|
+						temp_filters = @restriction_table_filters[restriction] or []
+						temp.each do |filter|
+							filters[filter[:table_name]] = filter
+						end
+					end
+
+					temp_filters = @user_table_filters[identity.user.id] or []
+					temp_filters.each do |filter|
+						filters[filter[:table_name]] = filter
+					end
+
+					filters
+				end
+
+				def get_alternative_user_keys(user_id, no_cache=false)
+					{}
+				end
 			end
 		end
 	end

data/lib/jungle_path/authentication/identity.rb

@@ -1,9 +1,9 @@
 module JunglePath
   module Authentication
 		class Identity
-			attr_accessor :remote_user, :remote_password, :user_name, :user, :key, :valid, :role, :authorization_filter, :query_filters, :alternative_user_key
+			attr_accessor :remote_user, :remote_password, :user_name, :user, :key, :valid, :role, :authorization_filter, :query_filters, :table_filters
 			def to_s
-				"JunglePath::Authentication::Identity: {\n  remote_user: #{@remote_user},\n  remote_password: #{@remote_password},\n  user_name: #{@user_name},\n  user: #{@user},\n  key: #{@key},\n  valid: #{@valid},\n  role: #{@role},\n  authorization_filter: #{@authorization_filter}\n,query_filters: #{@query_filters}\n}"
+				"JunglePath::Authentication::Identity: {\n  remote_user: #{@remote_user},\n  remote_password: #{@remote_password},\n  user_name: #{@user_name},\n  user: #{@user},\n  key: #{@key},\n  valid: #{@valid},\n  role: #{@role},\n  authorization_filter: #{@authorization_filter}\n,query_filters: #{@query_filters},\ntable_filters: #{@table_filters},\nalternative_user_keys: #{@alternative_user_keys}}"
 			end
       def to_h
         {
@@ -16,9 +16,18 @@ module JunglePath
           role: @role,
           authorization_filter: @authorization_filter,
           query_filters: @query_filters,
-          alternative_user_key: @alternative_user_key
+          table_filters: @table_filters,
+          alternative_user_keys: @alternative_user_keys
         }
       end
+      def alternative_user_keys
+        return @alternative_user_keys if @alternative_user_keys
+        @alternative_user_keys = {user_id: @user.id} if @user
+        @alternative_user_keys
+      end
+      def alternative_user_keys= value
+        @alternative_user_keys = value
+      end
       def to_hash
         to_h
       end

data/lib/jungle_path/db_model/view.rb

@@ -14,6 +14,24 @@ module JunglePath
 			def has_reference_to?(table_name)
 				@references.member?(table_name)
 			end
+			def build_call(identity, table)
+				parameters = identity.alternative_user_keys.select{|k, v| @parameters.include?(k)}.values.map{|n| convert_to_parameter(n)}.join(', ')
+				if parameters.length > 0
+					"#{table.table_name}(#{parameters})"
+				else
+					"#{table.table_name}"
+				end
+			end
+			def convert_to_parameter(value)
+				return value if value.class == Fixnum
+				return "'#{value}'" if value.class == String
+				return value if value.class == Float
+				return "'#{value.to_s}'::date'" if value.class == Date
+				return "'#{value.to_time.utc}'::timestamp'" if value.class == DateTime
+				return "'#{value.utc}'::timestamp'" if value.class == Time
+				return value.to_s if value.class == TrueClass or value.class == FalseClass
+				return "#{value}"
+			end
 		end
 	end
 end

data/lib/jungle_path/gen/schema.rb

@@ -16,7 +16,7 @@ module JunglePath
 	      table_subclasses.each do |table|
 					if table.is_view?
 	          puts "create view: #{table.table_name}"
-	          db.run(table.view_sql)
+	          db.run(table.view.create)
 	        else
 	          puts "create table: #{table.table_name}"
 	          schema.create_table table

data/lib/jungle_path/query/from.rb

@@ -8,6 +8,7 @@ module JunglePath
   module Query
     class From
       attr_reader :join_text, :table_name, :table_alias, :on_a_column_name, :on_b_alias, :on_b_column_name
+      attr_accessor :table_replacement_text
       def initialize join_text, table_name, table_alias, on_a_column_name=nil, on_b_alias=nil, on_b_column_name=nil
         @join_text = join_text
         @table_name = table_name.to_sym
@@ -15,13 +16,16 @@ module JunglePath
         @on_a_column_name = on_a_column_name
         @on_b_alias = on_b_alias
         @on_b_column_name = on_b_column_name
+        @table_replacement_text = nil
       end
 
       def to_s
+        table_name = @table_replacement_text || @table_name
+        table_name = "\"#{table_name}\"" unless table_name.class == String and table_name.include?('(')
         if join_text == "" or join_text == nil
-          "\"#{@table_name}\" #{@table_alias}"
+          "#{table_name} #{@table_alias}"
         else
-          "  #{@join_text} \"#{@table_name}\" #{@table_alias} on #{@table_alias}.#{@on_a_column_name} = #{@on_b_alias}.#{@on_b_column_name}"
+          "  #{@join_text} #{table_name} #{@table_alias} on #{@table_alias}.#{@on_a_column_name} = #{@on_b_alias}.#{@on_b_column_name}"
         end
       end
 

data/lib/jungle_path/query/sql_string.rb

@@ -28,6 +28,7 @@ module JunglePath
 
         if outer
           hook_in_filters engine, select, from, where, sort, entity
+          hook_in_table_filters engine, select, from, where, sort, entity
           sql = generate_sql(select, from, where, sort, entity, engine.apply_limit_offset_to_sql)
           return sql, aliases, symbols, sort_ids, primary_key_field_count
         else
@@ -120,6 +121,27 @@ module JunglePath
         end
       end
 
+      def self.hook_in_table_filters(engine, select, from, where, sort, entity)
+        puts "hook_in_table_filters QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ  FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFf"
+        #binding.pry
+        if engine.identity and engine.identity.table_filters
+          from.each do |frm|
+            filter = engine.identity.table_filters[frm.table_name]
+            if filter
+              puts "hook_in_table_filters: frm.table_name: #{frm.table_name}."
+              replacement_table = engine.tables[filter[:replacement]]
+              table_replacement_text = nil
+              if replacement_table.view
+                table_replacement_text = replacement_table.view.build_call(engine.identity, replacement_table)
+              else
+                table_replacement_text = "#{replacement_table.table_name}"
+              end
+              frm.table_replacement_text = table_replacement_text
+            end
+          end
+        end
+      end
+
       def self.generate_sql(select, from, where, sort, entity, apply_limit_offset_to_sql)
         lf = "\n"
         indent_comma = ",\n  "

data/lib/jungle_path/version.rb

@@ -1,3 +1,3 @@
 module JunglePath
-	VERSION = '0.0.12'
+	VERSION = '0.0.13'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jungle_path
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.0.13
 platform: ruby
 authors:
 - Michael VanZant
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-05-04 00:00:00.000000000 Z
+date: 2017-05-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,6 +83,7 @@ files:
 - lib/jungle_path/app/run.sh
 - lib/jungle_path/app/schemas/schema.rb
 - lib/jungle_path/app/schemas/schema_all_in_one.rb
+- lib/jungle_path/app/schemas/views.rb
 - lib/jungle_path/app/services/email.rb
 - lib/jungle_path/app/services/sms.rb
 - lib/jungle_path/app/web_apps/public/index.html