jungle_path 0.0.0

data/lib/jungle_path/rack/basic_credentials.rb

@@ -0,0 +1,70 @@
+# basic_credentials.rb
+# Add basic auth credentials into Rack env.
+# Return 401 Unauthorized if no credentials are passed.
+require 'rack'
+require 'rack/auth/abstract/handler'
+require 'rack/auth/abstract/request'
+
+module JunglePath
+  module Rack
+    module BasicCredentials
+      # Rack::Auth::Basic implements HTTP Basic Authentication, as per RFC 2617.
+      #
+      # Initialize with the Rack application that you want protecting,
+      # and a block that checks if a username and password pair are valid.
+      #
+      # See also: <tt>example/protectedlobster.rb</tt>
+      class Basic < ::Rack::Auth::AbstractHandler
+        def initialize(app, realm=nil, issue_challenge=true, &authenticator)
+          @issue_challenge = issue_challenge
+          super(app, realm, &authenticator)
+        end
+
+        def call(env)
+          #puts "realm: #{realm}."
+
+          auth = Basic::Request.new(env)
+
+          if @issue_challenge
+            return unauthorized unless auth.provided?
+            return bad_request unless auth.basic?
+          end
+
+          if auth.provided? and auth.basic?
+            env['REMOTE_USER'] = auth.username
+            env['REMOTE_PASSWORD'] = auth.password
+          else
+            env['REMOTE_USER'] = nil
+            env['REMOTE_PASSWORD'] = nil
+          end
+
+          @app.call(env)
+        end
+
+        private
+
+        def challenge
+          'Basic realm="%s"' % realm
+        end
+
+        class Request < ::Rack::Auth::AbstractRequest
+          def basic?
+            "basic" == scheme
+          end
+
+          def credentials
+            @credentials ||= params.unpack("m*").first.split(/:/, 2)
+          end
+
+          def username
+            credentials.first
+          end
+
+          def password
+            credentials.last
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jungle_path/rack/json_body_parser.rb

@@ -0,0 +1,41 @@
+# rack_json_body_parser.rb -- mod of code from rack-contrib. This mod allows sybolizing the hash key names by passing in a second parameter to initialize.
+#begin
+#  require 'json'
+#rescue LoadError => e
+#  require 'json/pure'
+#end
+#require 'rack'
+
+module JunglePath
+  require 'jungle_path/json'
+
+  module Rack
+    # A Rack middleware for parsing POST/PUT body data when Content-Type is
+    # not one of the standard supported types, like <tt>application/json</tt>.
+    class JsonBodyParser
+      # Constants
+      CONTENT_TYPE = 'CONTENT_TYPE'.freeze
+      POST_BODY = 'rack.input'.freeze
+      FORM_INPUT = 'rack.request.form_input'.freeze
+      FORM_HASH = 'rack.request.form_hash'.freeze
+
+      # Supported Content-Types
+      APPLICATION_JSON = 'application/json'.freeze
+
+      def initialize(app, symbolize_names=false)
+        @app = app
+        @symbolize_names = symbolize_names
+      end
+
+      def call(env)
+        if Rack::Request.new(env).media_type == APPLICATION_JSON && (body = env[POST_BODY].read).length != 0
+          puts "rack body: #{body}."
+          env[POST_BODY].rewind # somebody might try to read this stream
+          #env.update(FORM_HASH => JSON.parse(body, :symbolize_names=>@symbolize_names), FORM_INPUT => env[POST_BODY])
+          env.update(FORM_HASH => JunglePath::Json.parse(body, :symbolize_names=>@symbolize_names), FORM_INPUT => env[POST_BODY])
+        end
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/jungle_path/rack.rb

@@ -0,0 +1,6 @@
+module JunglePath
+	module Rack
+		require 'jungle_path/rack/basic_credentials'
+		require 'jungle_path/rack/json_body_parser'
+	end
+end

data/lib/jungle_path/schema/auth.rb

@@ -0,0 +1,83 @@
+require 'jungle_path/schema'
+
+module Schema
+	class Key < Schema::Base
+		define(
+			[:id, :primary_key],
+			[:key, :string, :unique, :secure, :not_null],
+			[:name, :string, :not_null],
+			[:user_id, :foreign_key, :user, :not_null, :unique_index, [:user_id, :name]],
+			[:expires_at, :timestamp, :not_null],
+			[:is_default, :boolean, :default, false],
+			[:audit_key]
+		)
+	end
+
+	class UserQueryFilter < Schema::Base
+    self.description = "Links users (actually their keys) to query_filters -- will be used to restrict certain users to only be able to query entities (such as products, etc.) as restricted by the related query_filter."
+    define(
+      [:user_id, :foreign_key, :user, :primary_key],
+      [:query_filter_id, :foreign_key, :query_filter, :primary_key],
+      [:audit_key]
+    )
+  end
+
+	class KeyRole < Schema::Base
+		define(
+			[:user_id, :foreign_key, :user, :primary_key],
+			[:role_id, :foreign_key, :role, :primary_key],
+			[:audit_key]
+		)
+	end
+
+	class QueryFilter < Schema::Base
+    self.description = "misc. filters to apply against product/or other entities of the form: select product.id from product join table_x on table_x.product_id = product.id where table_x.some_column = 'abc'"
+    define(
+      [:id, :primary_key],
+      [:name, :string, :desc, "Give this filter a name so you know who it should apply to."],
+      [:base_table_name, :string, :desc, "Should be the name of the base table you are filtering on such as 'product'. Your filter will be applied to any queries containing tables which relate to the base table."],
+      [:sub_select, :string, :desc, "Your sub_select query should select a set of ids from your base table. You can join to any other related tables and add where clause conditions. Do not use table aliases, instead use the full table names to avoid naming collisions as your sub_select will be hooked into queries generated by API users."],
+			[:use_not_in, :boolean, :desc, "use a query like 'id not in (list....)' instead of 'id in (list...)'."],
+      [:audit_key]
+    )
+  end
+
+	class Role < Schema::Base # use roles to group privileges and restrictions
+		define(
+			[:id, :primary_key],
+			[:name, :string, :unique_index, [:name], :not_null],
+			[:description, :string],
+			[:audit_key]
+		)
+	end
+
+	class User < Schema::Base
+		self.description = "User of system."
+		define(
+			[:id, :primary_key],
+			[:user_name, :string, :unique, :not_null, :alternate_key, :secure],
+			[:hash, :string, :not_null, :secure, :calculated, :desc, "See password_hash.rb for details."],
+			[:name, :string, :secure, :desc, "Your human name! :)"],
+			[:email, :string, :secure],
+			[:organization, :string, :secure],
+			[:notes, :string, :desc, "For any misc. notes about this user including addition email addresses, phone numbers, etc."],
+			[:active, :boolean, :default, true],
+			[:is_valid, :boolean, :calculated],
+			[:audit_user]
+		)
+	end
+
+	class User
+		@auth
+		@query_filters
+		attr_accessor :auth, :query_filters
+	end
+
+	class Key
+		def valid?
+			#puts "expires_at: #{expires_at}."
+			#puts "expires_at.class: #{expires_at.class}."
+			expires_at > Time.now
+		end
+	end
+end

data/lib/jungle_path/schema/base.rb

@@ -0,0 +1,6 @@
+require 'jungle_path/db_model'
+
+module Schema
+	class Base < JunglePath::DBModel::Table
+	end
+end

data/lib/jungle_path/schema/db.rb

@@ -0,0 +1,10 @@
+require 'jungle_path/schema/base'
+
+module Schema
+	class SchemaInfo < Schema::Base
+    self.description = "Used by sequel migration."
+    define(
+      [:version, :integer, :primary_key]
+    )
+  end
+end

data/lib/jungle_path/schema/version.rb

@@ -0,0 +1,19 @@
+module Schema
+  # schema meta data:
+
+  def self.version
+    # Specify database version number.
+    # This version number will be used to apply database
+    # migrations.
+    # If the configatron.db.name does not exist, then
+    # this schema is applied directly and the appropriate
+    # version number is recorded in the database.
+    # Version of nil will run all available migrations
+    #1
+    nil
+  end
+
+  def self.migrations_path
+    ::File.expand_path('../ztools/db/migrations',::File.dirname(__FILE__))
+  end
+end

data/lib/jungle_path/schema.rb

@@ -0,0 +1,8 @@
+module JunglePath
+	module Schema
+		require 'jungle_path/schema/version'
+		require 'jungle_path/schema/base'
+		require 'jungle_path/schema/db'
+		require 'jungle_path/schema/auth'
+	end
+end

data/lib/jungle_path/sql/auth_local_user.rb

@@ -0,0 +1,5 @@
+module JunglePath
+	module Sql
+		
+	end
+end

data/lib/jungle_path/sql/general.rb

@@ -0,0 +1,10 @@
+module JunglePath
+	module Sql
+		def self.get_count(db, sql, arg)
+	    ds = db.base[sql, arg]
+	    result = ds.first
+	    puts "result: #{result}."
+	    count = result[:count].to_i
+	  end
+	end
+end

data/lib/jungle_path/sql/helpers.rb

@@ -0,0 +1,11 @@
+module JunglePath
+	module Sql
+		module Helpers
+		  def self.sql(input)
+		    a = input.split("\n")
+		    a = a.map {|s| s.strip}
+		    output = a.join("\n").strip
+		  end
+		end
+	end
+end

data/lib/jungle_path/sql/key.rb

@@ -0,0 +1,107 @@
+module JunglePath
+	module Sql
+		module Key
+			def self.by_key(db, key)
+				sql = SQLHelpers.sql("
+					#{base_sql}
+					where a.key = ?
+					order by a.id
+				")
+				#puts "sql:\n#{sql}"
+				#puts "key: #{key}"
+				ds = db.base[sql, key]
+				all = ds.all
+				#puts "count: #{all.length}"
+				all
+			end
+
+			def self.by_user_id(db, user_id)
+				sql = SQLHelpers.sql("
+					#{base_sql}
+					where a.user_id = ?
+					order by a.id
+				")
+				ds = db.base[sql, user_id]
+				ds.all
+			end
+
+			def self.by_user_id_key_name(db, user_id, key_name)
+				sql = SQLHelpers.sql("
+					select
+						a.id,
+						a.key,
+						a.name,
+						a.user_id,
+						a.expires_at,
+						a.is_default,
+						a.created_at,
+						a.created_by_key_id,
+						a.updated_at,
+						a.updated_by_key_id
+					from key a
+					where a.user_id = ?
+					and a.name = ?
+				")
+				puts "db.class: #{db.class}."
+				ds = db.base[sql, user_id, key_name]
+				#puts "sql: #{ds.sql}."
+				ds.all
+			end
+
+			def self.default_by_user_id(db, user_id)
+				sql = SQLHelpers.sql("
+					#{base_sql}
+					where a.user_id = ?
+					and a.is_default = true
+					order by a.id
+				")
+				ds = db.base[sql, user_id]
+				ds.all
+			end
+
+			def self.by_user_id(db, user_id)
+				sql = SQLHelpers.sql("
+					#{base_sql}
+					where a.user_id = ?
+					order by a.id
+				")
+				ds = db.base[sql, user_id]
+				ds.all
+			end
+
+			def self.default_by_user_id(db, user_id)
+				sql = SQLHelpers.sql("
+					#{base_sql}
+					where a.user_id = ?
+					and a.is_default = true
+					order by a.id
+				")
+				#puts "sql:\n#{sql}."
+				ds = db.base[sql, user_id]
+				ds.all
+			end
+
+			private
+
+			def self.base_sql
+				SQLHelpers.sql("
+					select
+						a.id,
+						a.key,
+						a.name,
+						a.user_id,
+						a.expires_at,
+						a.is_default
+					from key a
+					join (
+						select
+							b.key_id
+						from role a
+						join key_role b on b.role_id = a.id
+						group by b.key_id
+					) b on b.key_id = a.id
+				")
+			end
+		end
+	end
+end

data/lib/jungle_path/sql/query_filter.rb

@@ -0,0 +1,5 @@
+module JunglePath
+	module Sql
+		
+	end
+end

data/lib/jungle_path/sql/role.rb

@@ -0,0 +1,5 @@
+module JunglePath
+	module Sql
+		
+	end
+end

data/lib/jungle_path/sql/user.rb

@@ -0,0 +1,35 @@
+module JunglePath
+	module Sql
+		module User
+			def self.by_user_name(db, user_name)
+				sql = SQLHelpers.sql("
+					#{base_sql}
+					where a.user_name = ?
+				")
+				puts "sql:\n#{sql}."
+				puts "user_name: #{user_name}."
+				ds = db.base[sql, user_name]
+				row = ds.first
+				puts "row: #{row}."
+				row
+			end
+
+			private
+
+			def self.base_sql
+				SQLHelpers.sql("
+					select
+						a.id,
+						a.user_name,
+						a.hash,
+						a.name,
+						a.email,
+						a.organization,
+						a.notes,
+						a.active
+					from \"user\" a
+				")
+			end
+		end
+	end
+end

data/lib/jungle_path/sql/user_role.rb

@@ -0,0 +1,5 @@
+module JunglePath
+	module Sql
+		
+	end
+end

data/lib/jungle_path/sql.rb

@@ -0,0 +1,12 @@
+module JunglePath
+	module Sql
+		require 'jungle_path/sql/helpers'
+		require 'jungle_path/sql/general'
+		require 'jungle_path/sql/user'
+		require 'jungle_path/sql/key'
+		require 'jungle_path/sql/role'
+		require 'jungle_path/sql/user_role'
+		require 'jungle_path/sql/auth_local_user'
+		require 'jungle_path/sql/query_filter'
+	end
+end

data/lib/jungle_path.rb

@@ -0,0 +1,13 @@
+module JunglePath
+	require 'jungle_path/api'
+	require 'jungle_path/authentication'
+	require 'jungle_path/cache'
+	require 'jungle_path/config'
+	require 'jungle_path/controller'
+	require 'jungle_path/db_model'
+	require 'jungle_path/exceptions'
+	require 'jungle_path/json'
+	require 'jungle_path/query'
+	#require 'jungle_path/schema' #should be required by app when needed...
+	require 'jungle_path/sql'
+end

data/test.rb

@@ -0,0 +1,33 @@
+
+
+
+module Model
+	class Table
+		def self.models
+			@models
+		end
+		def self.inherited(sub_class)
+			puts "#{sub_class} is a child of #{self}."
+			@models = [] unless models
+			@models << sub_class
+		end
+	end
+end
+
+module MySchema
+	class Base < Model::Table
+		#extend Tables
+	end
+	class MyTableA < MySchema::Base
+	end
+	class MyTableB < MySchema::Base
+	end
+end
+
+module MyOtherSchema
+	class Base < Model::Table
+		#extend Tables
+	end
+	class MyOtherTable < MyOtherSchema::Base
+	end
+end

data/test2.rb

@@ -0,0 +1,15 @@
+module JunglePath
+	module Schema
+		def classes
+			puts 'classes'
+		end
+	end
+end
+
+module Schema
+	extend JunglePath::Schema
+end
+
+module Test
+	extend Schema
+end