jungle_path 0.0.1 → 0.0.2

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

@@ -0,0 +1,292 @@
+# (data) zportdata_from_sqlserver.rb
+# select / transform / insert current GB data into new db.
+#require 'pry-byebug'
+require 'date'
+
+require 'jungle_path/gen/db'
+require 'jungle_path/gen/schema'
+require 'jungle_path/db_model'
+require 'jungle_path/sql/helpers'
+require 'jungle_path/authentication/helpers'
+require 'jungle_path/db_access/io/db'
+require 'jungle_path/db_access/import/db_dir'
+require 'jungle_path/logging'
+
+require_relative '../schemas/schema'
+require_relative '../controllers/controller'
+require_relative '../db/db'
+require_relative '../config/config'
+require_relative 'zcreatedb'
+require_relative 'zbootstrapdata'
+
+# notes: key_id lookup has been hardcoded to use @current_key.
+# users will not be ported, but must be added as new users in new system.
+
+class Port
+  def initialize(source_db, target_db, target_db_postgresql, logger=nil, source_database_type=:sql_server)
+    @user_params = {id: 0, user_name: "root"}
+    @current_user = Schema::User.new(@user_params)
+    @current_key = @current_user
+    @logger = logger
+    log "initialize"
+    if source_database_type == :sql_server
+      # sql server:
+      @sql_true = "1"
+      @sql_allow_order_bys_in_sub_select = "top 1000000000"
+      @left_bracket = "["
+      @right_bracket = "]"
+      @convert_nvarchar_beg = "convert(nvarchar, "
+      @convert_nvarchar_end = ")"
+    else
+      # postgresql:
+      @sql_true = "true"
+      @sql_allow_order_bys_in_sub_select = ""
+      @left_bracket = ""
+      @right_bracket = ""
+      @convert_nvarchar_beg = ""
+      @convert_nvarchar_end = "::text"
+    end
+
+    @source_db = source_db
+    @target_db = target_db
+    @target_db_postgresql = target_db_postgresql
+    @lookup = Lookup.new(@target_db_postgresql)
+
+    if @target_db.respond_to? :log_path
+      Dir.mkdir @target_db.log_path unless Dir.exist? @target_db.log_path
+      @error_log_file_name = "#{@target_db.log_path}/error_#{DateTime.now.strftime("%Y%m%d_%H%M%S")}.log"
+    else
+      Dir.mkdir "../logs" unless Dir.exist? "../logs"
+      @error_log_file_name = "../logs/error_#{DateTime.now.strftime("%Y%m%d_%H%M%S")}.log"
+    end
+  end
+
+  def reset_db
+    log 'reset_db'
+    JunglePath::Gen::DB.reset!(@target_db.postgresql)
+  end
+
+  def create_log_table
+    drop_table Controller::Log
+    create_table Controller::Log
+    @log_id = -1
+  end
+
+  def set_log_id
+    log_id = @target_db_postgresql.get_max_id_for_table(:log)
+    log_id = -1 if log_id == nil
+    @log_id = log_id
+  end
+
+  def create_db_and_schema
+    log 'create_db_and_schema'
+    ZCreateDb.run @target_db.postgresql
+  end
+
+  def initial_data
+    log 'initial_data', @target_db_postgresql
+    reset_table Controller::User
+    reset_table Controller::Role
+    reset_table Controller::UserRole
+    ZBootstrap.root_data(@target_db.postgresql)
+  end
+
+  def user
+    log 'user', @target_db_postgresql
+    drop_table Controller::Contact
+    create_table Controller::Contact
+    sql = JunglePath::SQL::Helpers.sql("
+      select
+        a.ROW_ID as siebel_id,
+        b.FST_NAME as first_name,
+        b.LAST_NAME as last_name,
+        lower(b.EMAIL_ADDR) as email,
+        b.CELL_PH_NUM as phone,
+        lower(a.LOGIN) as user_name,
+        a.PASSWORD as password,
+        a.CREATED as created_at,
+        a.CREATED_BY as created_by_siebel_id,
+        a.LAST_UPD as updated_at,
+        a.LAST_UPD_BY as updated_by_siebel_id
+      from dbo.S_USER a
+      join dbo.S_CONTACT b on a.ROW_ID = b.ROW_ID
+      order by a.ROW_ID
+    ")
+    ds = @source_db.base[sql]
+    results = ds.all
+    id = @target_db_postgresql.get_max_id_for_table(:user)
+    results.each do |item|
+      id += 1
+      item[:user_id] = id
+      item[:contact_id] = id
+    end
+    count = 0
+    @target_db.transaction do
+      results.each do |h|
+        h = hash_values_nil_if_blank(h)
+        count += 1
+        puts "user: #{count} of #{results.length}."
+        h[:email] = nil unless h[:email] and h[:email].include?('@')
+        h[:password] = JunglePath::Authentication::Helpers.generate_api_key('generated_password_') #generate a random password for ported users. They will not have their password unless it is changed, so they will not be able to log on directly.
+        #also, defaulting portal users to active for now...:
+        hash = {id: h[:user_id], siebel_id: h[:siebel_id], user_name: h[:user_name], email: h[:email], first_name: h[:first_name], last_name: h[:last_name], password: h[:password], active: true}
+        user = Controller::User.new(@current_user, @current_key, hash, @target_db).insert
+        h[:password] = nil
+        Controller::SiebelUser.new(@current_user, @current_key, h, @target_db).insert
+        Controller::Contact.new(@current_user, @current_key, h, @target_db).insert
+        Controller::SiebelContact.new(@current_user, @current_key, h, @target_db).insert
+      end
+    end
+    @target_db_postgresql.reset_sequence_for_table(:user)
+    log "user: processed #{results.length} rows.", @target_db_postgresql
+  end
+
+  def log_error(msg, db=nil)
+    puts "log error: #{msg}"
+    @logger.error(msg)
+    db_log(msg, 'error', db) if db
+  end
+
+  def log_warn(msg, db=nil)
+    puts "log warn: #{msg}"
+    @logger.warn(msg)
+    db_log(msg, 'warn', db) if db
+  end
+
+  def log(msg, db=nil)
+    puts "log info: #{msg}"
+    @logger.info(msg)
+    db_log(msg, 'info', db) if db
+  end
+
+  def db_log(msg, type, db)
+    @log_id += 1
+    Controller::Log.new(@current_user, @current_key, {id: @log_id, name: "zport_data", type: type, item: msg, timestamp: Time.now.utc}, db).insert if db
+  end
+
+  private
+
+    def correlated_lookup table, value, search_column, target_column
+      @lookup.value(table, value, search_column, target_column)
+    end
+
+    def hash_values_nil_if_blank(hash)
+      hash.each do |key, value|
+        #puts "hash[#{key}] = '#{value}'" if value and value.to_s[0] == "\t"
+        hash[key] = nil_if_blank(value)
+      end
+      hash
+    end
+
+    def nil_if_blank(value)
+      if value.class == String
+        v = value.strip
+        v = nil if v.empty? or v == 'No Match Row Id'
+        v
+      else
+        value
+      end
+    end
+
+    def drop_table(controller_class)
+      controller_class.new(@current_user, @current_key, {}, @target_db).drop_table
+    end
+
+    def create_table(controller_class)
+      controller_class.new(@current_user, @current_key, {}, @target_db).create_table
+    end
+
+    def reset_table(controller_class)
+      drop_table controller_class
+      create_table controller_class
+    end
+end
+
+class Lookup
+  def initialize(db)
+    @target_db = db
+    @current_user = nil
+    @current_key = nil
+    @lookups = {}
+  end
+
+  def value table, value, search_column, target_column
+    key = "#{table}.#{search_column}"
+    @lookups[key] = load_lookup(table, search_column, target_column) unless @lookups[key]
+    @lookups[key][value]
+  end
+
+  private
+    def load_lookup table, search_column, target_column
+      lookup = {}
+      lookup[nil] = nil
+      lookup['No Match Row Id'] = nil
+      sql = SQLHelpers.sql("select #{search_column}, #{target_column} from #{table}")
+      ds = @target_db.base[sql]
+      results = ds.all
+      results.each do |item|
+        lookup[item[search_column]] = item[target_column]
+      end
+      lookup
+    end
+end
+
+def run_import port, db_log_target
+  skip_some_items = false
+
+  log = []
+
+  port.log 'run_import'
+  log << 'run_import'
+
+  unless skip_some_items
+    port.reset_db
+    log << 'reset_db'
+  end
+
+  port.create_log_table
+  log << 'create_log_table'
+
+  ##port.create_db_and_schema
+  ##log << 'create_db_and_schema'
+
+  port.set_log_id
+  log << 'set_log_id'
+
+  log.each do |item|
+    port.log item, db_log_target
+  end
+
+  unless skip_some_items
+    port.initial_data
+    port.user
+  end
+rescue Exception => ex
+  port.log_error ex
+  raise
+end
+
+def get_logger
+  this_dir = File.expand_path(File.dirname(__FILE__))
+  one_up = File.expand_path('..', this_dir)
+  puts "one_up: #{one_up}."
+  logger = JunglePath::Logging.make_logger(one_up, 'zport_data.log', reset: true)
+end
+
+def run
+  logger = get_logger
+  logger.info('test!!!!!!!!!!!!!!!!!!!!!!11')
+  #binding.pry
+  # get source and target databases:
+  db_source = JunglePath::DBAccess::IO::DB.new(configatron.source.db, logger)
+  db_target = JunglePath::DBAccess::Import::DBDir.new(configatron.source.port_to.data_files_import, logger)
+  db_target_postgresql = JunglePath::DBAccess::IO::DB.new(db_target.postgresql, logger)
+
+  # setup and run data port:
+  port = Port.new(db_source, db_target, db_target_postgresql, logger) # (source_db, target_db)
+  run_import port, db_target_postgresql
+
+  ## generate any tables in schema that do not already exist:
+  # Gen::Schema.create(Schema::Base.models_dependent_order, db_target.postgresql)
+end
+run

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

@@ -2,15 +2,15 @@ module JunglePath
 	module Authentication
 		module AuthProvider
 			class Default
-				def authenticate request, data_provider=nil, no_cache=false
-					puts "Auth.authenticate"
-					data_provider = JunglePath::Authentication::DataProvider::Default.new unless data_provider
+				def authenticate request, data_provider, no_cache=false
+					puts "JunglePath::Authentication::AuthProvider::Default.authenticate"
+					#data_provider = JunglePath::Authentication::DataProvider::Default.new unless data_provider
 					remote_user = request.env['REMOTE_USER']
 					remote_password = request.env['REMOTE_PASSWORD']
 					puts "remote_user: #{remote_user}."
 					puts "remote_password: #{remote_password}."
 					identity = basic_authentication(data_provider, remote_user, remote_password, no_cache)
-					identity = basic_authentication(data_provider, remote_user, remote_password, true) unless identity and identity.valid?
+					#identity = basic_authentication(data_provider, remote_user, remote_password, true) unless identity and identity.valid?
 				end
 
 				def basic_authentication data_provider, remote_user, remote_password, no_cache=false
@@ -19,11 +19,13 @@ module JunglePath
 					puts "assume_identity: #{assume_identity}"
 					valid = false
 					identity = authenticate_identity(data_provider, identity, no_cache)
+					puts "authenticated identity: #{identity}."
 					identity = authorize_identity(data_provider, identity, no_cache)
-					assume_identity = authenticate_identity(assume_identity, no_cache) if assume_identity and identity and identity.valid?
-					assume_identity = authorize_identity(data_provider, assume_identity, no_cache) if assume_identity
-					valid = (assume_identity and assume_identity.valid?) or (identity and identity.valid?)
-					return assume_identity if assume_identity
+					puts "authorized identity: #{identity}."
+					#assume_identity = authenticate_identity(assume_identity, no_cache) if assume_identity and identity and identity.valid?
+					#assume_identity = authorize_identity(data_provider, assume_identity, no_cache) if assume_identity
+					#valid = (assume_identity and assume_identity.valid?) or (identity and identity.valid?)
+					#return assume_identity if assume_identity
 					identity
 				end
 
@@ -44,39 +46,44 @@ module JunglePath
 					end
 					return identity, assume_identity
 				end
-				
+
 				def authenticate_identity data_provider, identity, no_cache=false
-					id = nil
+					idn = nil
 					if identity
-						id = identity.dup
-						id.user = data_provider.get_user(identity.user_name, identity.remote_password, no_cache)
-						id.key = id.user
-						id.valid = (id.user and id.user.is_valid)
+						idn = identity.dup
+						if user_name_is_key? identity.user_name, identity.remote_password
+							idn.user = data_provider.get_user_by_key(identity.user_name, no_cache, identity.remote_password)
+							idn.key = identity.user_name
+						else
+							idn.user = data_provider.get_user(identity.user_name, identity.remote_password, no_cache)
+							idn.key = nil
+						end
+						idn.valid = (idn.user and idn.user.is_valid)
 					end
-					id
+					idn
 				end
 
 				def authorize_identity data_provider, identity, no_cache
-					id = nil
+					idn = nil
 					if identity
-						id = identity.dup
-						if id.valid?
-							id.roles = data_provider.get_roles(id, no_cache)
-							id.default_role = id.roles[0] if id.roles
-							id.auth = data_provider.get_auth(id, no_cache)
-							id.user.auth = id.auth if id.user
-							id.query_filters = data_provider.get_query_filters(id, no_cache)
+						idn = identity.dup
+						if idn.valid?
+							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)
 						else
-							id.roles = nil
-							id.default_role = nil
-							id.auth = nil
-							id.user.auth = nil if id.user
-							id.query_filters = nil
+							idn.role = nil
+							idn.authorization_filter = nil
+							idn.query_filters = nil
 						end
 					end
-					id
+					idn
 				end
 
+				def user_name_is_key? user_name, password
+					#puts "user_name: #{user_name}, password: #{password}. password == nil: #{password == nil}."
+					user_name and user_name.start_with?("sk_") and !user_name.include?("@") and (password == nil or password.strip.length == 0)
+				end
 			end
 		end
 	end

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

@@ -1,139 +1,85 @@
 module JunglePath
+	require 'jungle_path/authentication/password_hash'
 	require 'jungle_path/authorization/filter'
+	require 'jungle_path/schema/auth'
+	require 'jungle_path/sql/user'
 	module Authentication
 		module DataProvider
 			class Default
-				def initialize models_hash
-					@roles = {
-						root: {
-							id: 0,
-							name: :root,
-							description: 'root can do anything',
-							permissions: [:root],
-							restrictions: []
-						},
-						admin: {
-							id: 1,
-							name: :admin,
-							description: 'admin and add, edit and delete users, but not root users.',
-							permissions: [:admin],
-							restrictions: []
-						},
-						user: {
-							id: 2,
-							name: :user,
-							description: 'basic system user -- has read only access.',
-							permissions: [:read],
-							restrictions: [:query_only, :me_related]
-						}
-					}
-					@users = {
-						root: {
-							id: 0,
-							name: 'root',
-							email: nil,
-							phone: nil,
-							active: true,
-							user_name: :root,
-							password: 'test',
-							roles: [:root]
-						},
-						admin: {
-							id: 1,
-							name: 'admin',
-							email: nil,
-							phone: nil,
-							active: true,
-							user_name: :admin,
-							password: 'test',
-							roles: [:admin]
-						},
-						user: {
-							id: 2,
-							name: 'user',
-							email: nil,
-							phone: nil,
-							active: true,
-							user_name: :user,
-							password: 'test',
-							roles: [:user]
-						}
-					}
-					@models = models_hash # (parameter models_hash usually from Schema::Base.models)
+				def initialize sinatra, cache, db, user_model, models, roles, schema_filters, role_schema_filters, role_query_filters, restriction_query_filters, user_query_filters
+					@sinatra = sinatra
+					@cache = cache
+					@db = db
+					@user_model = user_model
+					@models = models # (parameter models usually from Schema::Base.models)
+					@roles = roles
 					@role_permissions = {}
 					@role_restrictions = {}
-					@roles.each do |role|
-						@role_permissions[role.name] = role.permissions
-						@role_restrictions[role.name] = role.role_restrictions
+					@roles.each do |key, role|
+						@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
-						}
-					}
-					@schema_filters = lambda {|identity|
-						filters = {
-							allow_all_tables: {allow: [table: /./]},
-							hide_nonpublic_tables: {allow: [{table: /./}], deny: [{table: /^utility_/}, {table: /^temp_/}]}
-						}
-					}
-					@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"}
-							]
-							# more...
-						}
-					}
-					@restriction_query_filters = lambda {|identity|
-						filters = {
-							me_related:[
-								{table_name: :user, sub_select: "select id from user where id = #{identity.user.id}"}
-							]
-						}
-					}
-					@user_query_filters = lambda {|identity|
-						filters = {}
-					}
+					@schema_filters = schema_filters
+					@role_schema_filters = role_schema_filters
+					@role_query_filters = role_query_filters
+					@restriction_query_filters = restriction_query_filters
+					@user_query_filters = user_query_filters
 				end
 
 				def get_user(user_name, password, no_cache=false)
 					lower_case_user_name = nil
 					lower_case_user_name = user_name.downcase.to_sym if user_name
-					hash = @users[lower_case_user_name]
-					user = JunglePath::Schema::User.new(hash, false) if hash
-					halt 401, "Unauthorized" unless user
-					halt 401, "Unauthorized: user #{user.user_name} is not marked as active." unless user.active
-					user.is_valid = (user.password == password)
-					user.password = password
+					cache_key = "#{lower_case_user_name}.#{password}"
+					user = @cache[cache_key]
+					if user == nil or no_cache
+						hash = JunglePath::SQL::User.by_user_name(@db, user_name)
+						puts "hash: #{hash}."
+						#ds = @db.base["select * from \"user\" where user_name = ?", lower_case_user_name]
+						#hash = ds.first
+						user = @user_model.new(hash, false) if hash
+						@sinatra.halt 401, "Unauthorized" unless user
+						@sinatra.halt 401, "Unauthorized: user #{user.user_name} is not marked as active." unless user.active
+						user.is_valid = JunglePath::Authentication::PasswordHash.validate_password(password, user.hash)
+						user.password = password
+						@cache[cache_key] = user if user
+					end
 					user
 				end
 
-				def get_roles(identity, no_cache=false)
-					result = []
-					roles = @users[identity.user.user_name.to_sym].roles
-					roles.each do |role_symbol|
-						role = @roles[role_symbol]
-						result << ({id: role[:id], name: role[:name], description: role[:description]})
+				def get_user_by_key(key, no_cache=false, password=nil)
+					cache_key = "#{key}."
+					user = @cache[cache_key]
+					if user == nil or no_cache
+						hash = JunglePath::SQL::User.by_key(@db, key)
+						puts "hash: #{hash}."
+						#ds = @db.base['select * from "user" where id in (select user_id from key where key = ?)', key]
+						#hash = ds.first
+						user = @user_model.new(hash, false) if hash
+						@sinatra.halt 401, "Unauthorized" unless user
+						@sinatra.halt 401, "Unauthorized: user #{user.user_name} is not marked as active." unless user.active
+						@cache[cache_key] = user if user
 					end
-					result
+					user
+					get_user(user_name, password, no_cache)
+				end
+
+				def get_role(identity, no_cache=false)
+					@roles[identity.user.role.to_sym]
 				end
 
-				def get_auth(identity, no_cache=false)
-					auth = JunglePath::Authorization::Filter.new(identity.roles, @models, @role_permissions, @role_restrictions, @role_schema_filters.call(identity), @schema_filters.call(identity))
+				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))
 				end
 
 				def get_query_filters(identity, no_cache=false)
 					filters = []
-					@role_query_filters.call(identity).each do |filter|
+					@role_query_filters.call(identity).each do |key, filter|
 						filters << filter
 					end
-					@restriction_query_filters.call(identity).each do |filter|
+					@restriction_query_filters.call(identity).each do |key, filter|
 						filters << filter
 					end
-					@user_query_filters.call(identity).each do |filter|
+					@user_query_filters.call(identity).each do |key, filter|
 						filters << filter
 					end
 					filters