jungle_path 0.0.1 → 0.0.2

data/lib/jungle_path/app/controllers/controller.rb

@@ -0,0 +1,197 @@
+# controller.rb
+require 'base64'
+require 'jungle_path/controller'
+require 'jungle_path/api/helpers'
+require 'jungle_path/authentication/helpers'
+require 'jungle_path/exceptions'
+
+require_relative '../config/config'
+require_relative '../schemas/schema'
+require_relative 'generated'
+
+module Controller
+	class User < JunglePath::Controller::Base
+		def initialize(current_user, current_key, params, db)
+			super(current_user, current_key, params, db, Schema::User)
+		end
+
+		def insert(include_secure_columns: false)
+			params = self.class.add_audit_parameter_values_for_insert(@params, @current_user, @current_key, @table_class)
+			model = @table_class.new params
+			#puts "params: #{params}."
+			#puts "model: #{model.to_h}."
+
+			#model.user_name = params[:email] unless model.user_name
+			model.user_name = model.email unless model.user_name
+			model.user_name = model.user_name.downcase if model.user_name
+
+			if params[:first_name] and params[:last_name]
+				model.name = "#{model.first_name} #{model.last_name}"
+			elsif params[:first_name]
+				model.name = model.first_name
+			elsif params[:last_name]
+				model.name = model.last_name
+			elsif params[:name]
+					name = params[:name].split(' ')
+					model.first_name = name[0]
+					model.last_name = name[1..-1].join(' ') if name.length > 1
+			end
+
+			#puts "model: #{model}."
+
+			model.sms_verification_code = validate_or_set_sms_verification_code(model.sms_verification_code)
+			model.activation_key = validate_or_set_activation_key(model.activation_key)
+
+			password = params[:password]
+			password = model.sms_verification_code unless password
+
+			message = self.class.validate_password_message(password)
+			if message
+				self.class.validate_insert(model, message)
+				raise Exceptions::InvalidPassword, "#{message}", caller
+			end
+			## todo: validate password strength, etc. here!
+			#model.hash = PasswordHash.createHash(password)
+			#model.key = KeyHelpers.generate_api_key unless model.key #create a new key_string unless one was passed in.
+			#model.key = model.key.downcase if model.key
+
+			self.class.validate_insert(model)
+			# result = handle_profile_image params
+			# model.profile_image_id = result.id if result
+			begin
+				result = @db.insert._model(model)
+				#puts "result: #{result}."
+				result = self.class.handle_include_secure_columns_flag(result, include_secure_columns, @table_class)
+				#default to role admin:
+				#params[:role_id] = 2 unless params[:role_id] # default to 'user' role.
+				#if params[:role_id]
+	      #  user_role = {role_id: params[:role_id], user_id: result.id}
+	      #  Controller::UserRole.new(@current_user, @current_key, user_role, @db).insert
+	      #end
+			rescue Sequel::UniqueConstraintViolation => e
+				# already there? update instead...
+				puts "not unique!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
+				user_query = Schema::User.new({user_name: params[:user_name]})
+				user = @db.select._model_by_any(user_query)
+				puts "user: #{user}."
+				params[:id] = user.id if user
+				if user
+					update
+					user = @db.select._model(user)
+				else
+					raise
+				end
+			end
+			result
+		end
+
+		def update
+			params = self.class.add_audit_parameter_values_for_update(@params, @current_user, @current_key, @table_class)
+			model = @table_class.new params
+			puts "params: #{params}."
+			puts "model: #{model.to_h}."
+			puts "aaa model.id: #{model.id}, #{model.id.class}."
+			model.user_name = params[:email] unless model.user_name
+			model.user_name = model.user_name.downcase if model.user_name
+			model.sms_verification_code = validate_or_set_sms_verification_code(model.sms_verification_code)
+			model.activation_key = validate_or_set_activation_key(model.activation_key)
+
+			password = params[:password]
+			if password
+				message = self.class.validate_password_message(password)
+				if message
+					self.class.validate_update(model, message)
+					raise Exceptions::InvalidPassword, "#{message}", caller
+				end
+				# todo: validate password strength, etc. here!
+				model.hash = PasswordHash.createHash(password)
+			end
+			#model.key = KeyHelpers.generate_api_key unless model.key #create a new key_string unless one was passed in.
+			#model.key = model.key.downcase if model.key
+
+			self.class.validate_update(model)
+			# result = handle_profile_image params
+			# model.profile_image_id = result.id if result
+			result = @db.update._model(model)
+			if params[:role_id]
+				puts "model.class #{model.class}."
+				puts "model.id: #{model.id}, #{model.id.class}."
+        if model.id > 0 #don't delete root's role!!!
+          delete_user_roles model.id
+        end
+        #user_role = {role_id: params[:role_id], user_id: params[:id]}
+        #temp = Controller::UserRole.new(@current_user, @current_key, user_role, @db).insert
+      end
+			result
+		end
+
+		def self.validate_hash_with_password(hash, password)
+			PasswordHash.validatePassword(password, hash)
+		end
+
+		def self.strip_phone_leave_domain_if_any user_phone
+			phone = nil
+			if user_phone
+				parts = user_phone.split('@')
+				phone = parts[0].gsub(/[^0-9]/,'')
+				phone = phone[1..-1] if phone[0] == '1'
+				phone = "#{phone}@#{parts[1]}" if parts.length > 1
+			end
+			phone
+		end
+
+		def delete
+			model = @table_class.new @params
+      self.class.validate_delete(model)
+			delete_user_roles model.id
+      result = @db.delete._model(model)
+		end
+
+		private
+
+		def delete_user_roles user_id
+			ds = @db.base['delete from user_role where user_id = ?', user_id]
+			result = ds.all
+			puts "deleted all user_roles for user_id #{user_id}: #{result}."
+		end
+
+		def handle_profile_image params
+			result = nil
+			if params[:image_name] and params[:image]
+				encoding = (params[:image_encoding] or 'base64')
+				hash = {image_file: params[:image_name], image_file_data: params[:image], image_file_data_encoding: encoding}
+				result = ::Controller::Image.new(@current_user, @current_key, hash, @db).insert
+			end
+			result
+		end
+
+		def self.validate_password_message(password)
+			message = ''
+			pw_set = configatron.application.password_settings
+			# returns message if password is not a minimum strength...
+			message = "#{pw_set[:length][:message]}\n" unless password and password.length > pw_set[:length][:must_be_greater_than]
+			pw_set[:regular_expression_matches].each do |match|
+				message += "#{match[:message]}\n" if (match[:expression] =~ password) == nil
+			end
+			# message += "Password must have at least one alphabetical character.\n" if (/[[:alpha:]]/ =~ password) == nil
+			# message += "Password must have at least one numeric character." if (/[[:digit:]]/ =~ password) == nil
+			# message = "Password may not contain a '@' character." if password and password.include? '@'
+			if message == ''
+				nil
+			else
+				message
+			end
+		end
+
+		def validate_or_set_sms_verification_code(sms_verification_code)
+			sms_verification_code = "000000#{(rand() * 1000000).to_i}"[-6, 6] unless sms_verification_code
+      sms_verification_code = "000000#{sms_verification_code}"[-6, 6] unless sms_verification_code.length == 6
+			sms_verification_code
+		end
+
+		def validate_or_set_activation_key(activation_key)
+			activation_key = KeyHelpers.generate_api_key('ak_') unless activation_key
+			activation_key
+		end
+	end
+end

data/lib/jungle_path/app/controllers/generated.rb

@@ -0,0 +1,13 @@
+#This file was generated using the ../lib/controller_template.erb. Do not modify directly.
+require 'jungle_path/controller'
+require_relative '../schemas/schema'
+
+module Controller
+
+  class Answer < JunglePath::Controller::Base
+    def initialize(current_user, current_key, params, db)
+      super(current_user, current_key, params, db, Schema::Answer)
+    end
+  end
+
+end

data/lib/jungle_path/app/db/db.rb

@@ -0,0 +1,13 @@
+# (data) db.rb - db access layer...
+require 'singleton'
+require 'jungle_path/db_access'
+require_relative '../config/config' # contains all settings (except sensitive data set to nil -- set sensitive data in override.rb.
+
+module Server
+  class DB < JunglePath::DBAccess::IO::DB
+    include Singleton
+    def initialize
+      super jungle.db
+    end
+  end
+end

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

@@ -19,3 +19,84 @@ class Answer < Schema::Base
 		[:audit_user]
 	)
 end
+
+class Practice < Schema::Base
+	self.description = ""
+	define(
+		[:id, :primary_key],
+		[:user_id, :foreign_key, :user],
+		[:notes, :string],
+		[:random_question_order, :boolean],
+		[:random_answer_order, :boolean],
+		[:audit_user]
+	)
+end
+
+class PracticeQuiz < Schema::Base
+	self.description = ""
+	define(
+		[:practice_id, :foreign_key, :practice, :primary_key],
+		[:quiz_id, :foreign_key, :quiz, :primary_key],
+		[:audit_user]
+	)
+	def self.plural_table_name
+		"practice_quizzes"
+	end
+end
+
+class PracticeQuestion < Schema::Base
+	self.description = ""
+	define(
+		[:practice_id, :foreign_key, :practice, :primary_key],
+		[:question_id, :foreign_key, :question, :primary_key],
+		[:note, :string],
+		[:audit_user]
+	)
+end
+
+class PracticeAnswer < Schema::Base
+	self.description = ""
+	define(
+		[:practice_id, :foreign_key, :practice, :primary_key],
+		[:answer_id, :foreign_key, :answer, :primary_key],
+		[:label, :string],
+		[:selected, :boolean],
+		[:audit_user]
+	)
+end
+
+class Question < Schema::Base
+	self.description = ""
+	define(
+		[:id, :primary_key],
+		[:quiz_id, :foreign_key, :quiz],
+		[:name, :string],
+		[:description, :string],
+		[:audit_user]
+	)
+end
+
+class Quiz < Schema::Base
+	self.description = ""
+	define(
+		[:id, :primary_key],
+		[:name, :string],
+		[:description, :string],
+		[:private, :boolean, :default, true],
+		[:audit_user]
+	)
+	def self.plural_table_name
+		"quizzes"
+	end
+end
+
+class Log < Schema::Base
+	define(
+		[:id, :primary_key],
+		[:set_id, :integer],
+		[:name, :string],
+		[:type, :string],
+		[:item, :string, :secure],
+		[:timestamp, :timestamp]
+	)
+end

data/lib/jungle_path/app/services/email.rb

@@ -0,0 +1,138 @@
+require 'pony'
+require_relative '../config/config'
+require_relative '../controllers/controller'
+
+module Services
+	module Email
+		def self.send_user_verification user
+			message = []
+			message << "<p>Please click the link below to verify your GIS  sign-up.</p>"
+			message << "<p><a href='#{configatron.application.url}/activate/#{user.id}/activation_key/#{user.activation_key}?html=1'>#{configatron.application.url}/activate/#{user.id}/activation_key/#{user.activation_key}</a></p>"
+			message = message.join("\n")
+
+			user_email = user.email || user.user_name
+
+			Pony.mail({
+				to: "#{user_email}",
+				subject: "Subject: GIS Sign-up Verification",
+				html_body: message,
+				via: :smtp,
+				via_options: {
+					address: configatron.smtp.host,
+					port: configatron.smtp.port,
+					enable_starttls_auto: configatron.smtp.enable_tls,
+					user_name: configatron.smtp.user_name,
+					password: configatron.smtp.password,
+					authentication: :plain,
+					domain: configatron.smtp.domain_of_sender
+				}
+			})
+		end
+
+		def self.send_user_password_reset_code user
+			message = []
+			message << "<p>Your password reset code:</p>"
+			message << "<p>#{user.password_reset_code}</p>"
+			message = message.join("\n")
+
+			user_email = user.email || user.user_name
+
+			Pony.mail({
+				to: "#{user_email}",
+				from: configatron.smtp.from,
+				subject: "Subject: GIS Password Reset Code",
+				html_body: message,
+				via: :smtp,
+				via_options: {
+					address: configatron.smtp.host,
+					port: configatron.smtp.port,
+					enable_starttls_auto: configatron.smtp.enable_tls,
+					user_name: configatron.smtp.user_name,
+					password: configatron.smtp.password,
+					authentication: configatron.smtp.authentication,
+					domain: configatron.smtp.domain_of_sender,
+				}
+			})
+		end
+
+		def self.send_user_text_message_verification user
+			subject = "GIS Verification Code"
+			phone = Controller::User.strip_phone_leave_domain_if_any user.phone
+			puts "phone:  #{phone}."
+			gateways = [
+				'@txt.att.net',
+				'@tmomail.net',
+				'@vtext.com',
+				'@messaging.sprintpcs.com',
+
+				'@mms.aiowireless.net',
+				'@sms.alltel.com',
+				'@paging.acswireless.com',
+
+				'@message.bam.com',
+				'@blsdcs.net',
+				'@blueskyfrog.com',
+				'@myboostmobile.com',
+				'@csouth1.com',
+				'@comcastpcs.textmsg.com',
+				'@sms.mycricket.com',
+				'@mobile.kajeet.net',
+				'@mymetropcs.com',
+				'@messaging.nextel.com',
+				'@ptel.net',
+				'@sms.pscel.com',
+				'@qwestmp.com',
+				'@page.southernlinc.com',
+
+				'@tms.suncom.com',
+
+				'@mmst5.tracfone.com',
+				'@msg.telus.com',
+				'@vmobl.com',
+
+				'@chat.wirefree.ca',
+				'@sms.beeline.ua',
+				'@txt.bell.ca'
+			]
+			if user.phone.include? '@'
+				Pony.mail({
+					to: phone,
+					subject: subject,
+					html_body: user.sms_verification_code,
+					via: :smtp,
+					via_options: {
+						address: configatron.smtp.host,
+						port: configatron.smtp.port,
+						enable_starttls_auto: true,
+						user_name: configatron.smtp.user_name,
+						password: configatron.smtp.password,
+						authentication: :plain,
+						domain: configatron.smtp.domain_of_sender
+					}
+				})
+			else
+				gateways.each do |gw|
+					begin
+						Pony.mail({
+							to: "#{phone}#{gw}",
+							subject: subject,
+							html_body: user.sms_verification_code,
+							via: :smtp,
+							via_options: {
+								address: configatron.smtp.host,
+								port: configatron.smtp.port,
+								enable_starttls_auto: true,
+								user_name: configatron.smtp.user_name,
+								password: configatron.smtp.password,
+								authentication: :plain,
+								domain: configatron.smtp.domain_of_sender
+							}
+						})
+					rescue Exception => ex
+						puts "exception sending text to #{user.phone}#{gw}: #{ex}."
+					end
+				end
+			end
+		end
+	end
+end

data/lib/jungle_path/app/services/sms.rb

@@ -0,0 +1,17 @@
+require 'twilio-ruby'
+require_relative '../config/config'
+
+module Services
+	module SMS
+		def self.send account_sid, auth_token, from_phone, to_phone, message
+			client = Twilio::REST::Client.new account_sid, auth_token
+			client.account.messages.create(
+				to: to_phone,
+				from: from_phone,
+				body: message
+			)
+		#rescue => e
+		#	puts "SMS.send: #{e}!"
+		end
+	end
+end

data/lib/jungle_path/app/web_apps/public/index.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+    <title>JunglePath</title>
+  </head>
+  <body>
+    JunglePath
+  </body>
+</html>

data/lib/jungle_path/app/ztools/db/migrations/000_root.rb

@@ -0,0 +1 @@
+# prevent sequel migration error -- needed at least one file, empty ok as long as 000_... name matches schema version 0 in table.

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

@@ -0,0 +1,57 @@
+# (who) zbootstrapdata.rb
+require 'time'
+require 'http'
+
+require 'jungle_path/api/helpers'
+require 'jungle_path/authentication/helpers'
+require 'jungle_path/json'
+
+require_relative '../db/db'
+require_relative '../controllers/controller'
+require_relative '../schemas/schema'
+require_relative '../config/config' # contains all settings except sensitive data set to nil.
+
+module ZBootstrap
+  def self.root_data db_config=nil, schema_initial_version=nil
+    db = JunglePath::DBAccess::IO::DB.new(db_config) if db_config
+    db = Server::DB.instance unless db
+
+    # set starting version numnber
+    if schema_initial_version
+      schema_info = Schema::SchemaInfo.new({version: schema_initial_version})
+      db.insert._model(schema_info)
+    end
+
+    hash = 'sha1:1000:/CloeFSPBOT7Ac/Jf/qQLk59iQbflhxf:H4eHZ0w51f3UdQpM+tp2DdhofDPkTf2P\n'
+    users = [
+      Schema::User.new({id: 0, name: 'root', user_name: 'root', role: 'root', hash: hash, email: nil, active: true, created_by_user_id: 0, updated_by_user_id: 0}),
+      Schema::User.new({id: 1, name: 'admin', user_name: 'admin', role: 'admin', hash: hash, email: nil, active: true, created_by_user_id: 0, updated_by_user_id: 0}),
+      Schema::User.new({id: 2, name: 'user', user_name: 'user', role: 'user', hash: hash, email: nil, active: true, created_by_user_id: 0, updated_by_user_id: 0})
+    ]
+    users.each {|user| db.insert._model(user)}
+
+    #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}),
+    #  Schema::Role.new({id: 2, name: 'user', description: 'basic user of system', created_by_user_id: 0, updated_by_user_id: 0})
+    #]
+    #roles.each {|role| db.insert._model(role)}
+
+    #user_roles = [
+    #  Schema::UserRole.new({user_id: 0, role_id: 0, created_by_user_id: 0, updated_by_user_id: 0}),
+    #  Schema::UserRole.new({user_id: 1, role_id: 1, created_by_user_id: 0, updated_by_user_id: 0}),
+    #  Schema::UserRole.new({user_id: 2, role_id: 2, created_by_user_id: 0, updated_by_user_id: 0})
+    #]
+    #user_roles.each {|user_role| db.insert._model(user_role)}
+
+		fix_serial db
+  end
+
+  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")
+  end
+end
+
+ZBootstrap.root_data if ARGV[0] == 'run'

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

@@ -0,0 +1,19 @@
+require 'jungle_path/gen/db'
+require 'jungle_path/gen/schema'
+require_relative '../schemas/schema'
+require_relative '../config/config' # contains all settings except sensitive data set to nil.
+
+module ZCreateDb
+	def self.run db_config=nil
+		db_config = jungle.db unless db_config
+		puts "db_config port/name/user_name/password: #{db_config.port}/#{db_config.name}/#{db_config.user_name}/#{db_config.password}."
+		JunglePath::Gen::DB.reset!(db_config)
+		JunglePath::Gen::Schema.create(Schema::Base.models_dependent_order, db_config)
+
+		this_path = File.expand_path(File.dirname(__FILE__))
+		migrations_path = File.join(this_path, 'db', 'migrations')
+		JunglePath::Gen::Schema.set_version_to_latest(Schema::SchemaInfo, db_config, migrations_path)
+	end
+end
+
+ZCreateDb.run if ARGV[0] == 'run'

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

@@ -0,0 +1,9 @@
+# zgen.rb -- this project's generators:
+require 'jungle_path/gen/api'
+require 'jungle_path/gen/controllers'
+
+require '../config/config.rb'
+require '../schemas/schema'
+
+JunglePath::Gen.controllers(configatron.application.root_dir, Schema::Base.models.values)
+JunglePath::Gen.api(configatron.application.root_dir, Schema::Base.models.values)

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

@@ -0,0 +1,14 @@
+#require 'pp'
+require_relative 'jungle_path/gen/schema_tree'
+require_relative '../config/config'
+require_relative '../schemas/schema'
+
+root = JunglePath::Gen::SchemaTree.gen_node_tree(Schema::Base.models)
+
+## write node tree to schema_tree.txt file for use by query api test page.
+#template_file = File.join(configatron.application.public_dir, 'query/documents/schema_tree_template.txt')
+#template = File.read(template_file)
+#template_output = "#{template}\n\n#{root.to_str}"
+#output_file = File.join(configatron.application.public_dir, 'query/documents/schema_tree.txt')
+#File.write(output_file, template_output)
+puts root.to_str

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

@@ -0,0 +1,7 @@
+require 'jungle_path/migration'
+require_relative '../schemas/schema'
+require_relative '../db/db'
+
+version = nil
+version = ARGV[0].to_i if ARGV[0]
+JunglePath::Migration.run Schema, ServerAPI::DB.instance, version