wordjelly-auth 0.0.1

data/lib/auth/job_exception_handler.rb

@@ -0,0 +1,7 @@
+module Auth
+	module JobExceptionHandler
+		def log_exception(exception)
+			$redis.zadd("errors",Time.now.to_i,exception.to_s)
+		end
+	end
+end

data/lib/auth/mailgun.rb

@@ -0,0 +1,28 @@
+module Auth
+	module Mailgun
+		## returns the email after adding a webhook identifier variable.
+		def add_webhook_identifier_to_email(email)
+			email.message.mailgun_variables = {}
+        	email.message.mailgun_variables["webhook_identifier"] = BSON::ObjectId.new.to_s
+        	email
+		end
+
+		def self.set_webhook_identifier(notification_response,last_response)
+			
+			last_response = JSON.parse(last_response).deep_symbolize_keys
+			notification_response.webhook_identifier = last_response[:webhook_identifier] if not last_response[:webhook_identifier].nil?
+		end
+
+
+		def email_webhook(params)	
+			
+			Auth.configuration.notification_response_class.constantize.find_and_update_notification_response(params[:webhook_identifier], JSON.generate(params)) do |notification_response|
+
+				#puts "found email notification response:"
+				#puts notification_response.attributes.to_s
+
+			end
+		end
+	end
+end
+

data/lib/auth/notify.rb

@@ -0,0 +1,8 @@
+module Auth::Notify
+	def self.send_notification(notification)
+		## for tests.
+		##return if Auth.configuration.notify == false
+		notification.send_notification
+	end
+
+end

data/lib/auth/omniauth/path.rb

@@ -0,0 +1,104 @@
+module Auth
+	module OmniAuth
+		module Path
+
+			##############################################
+			##
+			## FOR BUILDING THE PATHS FOR SHOPPING CLASSES.
+			##
+			##############################################
+
+			def self.new_path(cls)
+				"new_" + cls.constantize.new.class.name.underscore.gsub(/\//,"_") + "_path"
+			end
+
+
+			def self.show_or_update_or_delete_path(cls)
+				
+				parts = cls.constantize.new.class.name.split("::")
+				parts.map{|c| c.underscore.downcase}.join("_") + "_path"
+			end
+
+				
+			def self.create_or_index_path(cls)
+				parts = cls.constantize.new.class.name.split("::")
+				parts[-1] = parts[-1].pluralize
+				parts.map{|c| c.underscore.downcase}.join("_") + "_path"
+			end
+
+			def self.edit_path(cls)				
+				"edit_" + show_or_update_or_delete_path(cls)
+			end
+
+			##############################################
+			##
+			##
+			##
+			##############################################
+
+
+			## given something like : shopping/product
+			## will return something like: Shopping::Product
+			def self.path_to_model(path)
+				path.split("/").map{|c| c = c.capitalize}.join("::").constantize
+			end
+
+			## given something like :Shopping::Product
+			## will return something like shopping/products
+			def self.model_to_path(cls)
+				parts = cls.to_s.split("::").map{|c| c = c.to_s.downcase}
+				parts[-1] = parts[-1].pluralize
+				parts.join("/")
+			end
+
+			##the the path for the request_phase of the omniauth call.
+			def self.omniauth_request_path(resource,provider)
+				resource_or_scope = resource.nil? ? ":res" : 
+				resource_pluralized(resource)
+				"#{omniauth_prefix_path}/#{resource_or_scope}/#{provider}"
+			end
+
+			##the omniauth prefix = mount_path/omniauth
+			def self.omniauth_prefix_path
+				"#{Auth.configuration.mount_path}/omniauth"
+			end
+
+			##the path for the callback is the same for all models.
+			def self.common_callback_path(provider)
+				"#{omniauth_prefix_path}/#{provider}/callback"
+			end
+
+			def self.resource_pluralized(resource)
+				resource.to_s.pluralize.underscore.gsub('/', '_')
+			end
+
+			##the path prefix for all the devise modules.
+			def self.resource_path(resource)	
+				"#{Auth.configuration.mount_path}/#{resource_pluralized resource}"
+			end
+
+			##the absolute path that is returned by the omniauth url helper
+			##devise takes care of prepending the resource and the mount prefix.
+			def self.omniauth_failure_absolute_path
+				"omniauth/failed"
+			end
+
+			##this is the path that is used in the routes.rb file, to build
+			##the actual route.
+			##keeps :res as a wildcard for the required resource.
+			def self.omniauth_failure_route_path(resource_or_scope)
+				resource_or_scope = resource_or_scope.nil? ? ":res" : resource_pluralized(resource_or_scope.class.name)
+				"#{Auth.configuration.mount_path}/#{resource_or_scope}/#{omniauth_failure_absolute_path}"
+			end
+
+			##refresh auth token path
+			#def self.refresh_auth_token_path(resource_or_scope)
+			#	resource_or_scope = resource_or_scope.nil? ? ":res" : resource_pluralized(resource_or_scope.class.name)
+			#	"#{Auth.configuration.mount_path}/#{resource_or_scope}/refresh_token"
+			#end
+
+
+		end
+	end
+
+end

data/lib/auth/partials.rb

@@ -0,0 +1,12 @@
+module Auth
+	module Partials
+		# a helper method to get the name of the additional login param new otp partial.
+		# used in the auth/views/registrations/create.js.erb,
+		# because there resolving to a nil value in case the additional_login_param_new_otp_partial is not defined, throws an error, even if the if condition for an additional login param is not entered, since its a js.erb.
+		# so the solution was to return a default value as the sign up success invalid content html erb. 
+		# this will never be actually hit, but the js erb checks whether the partial exists, even if the if condition where that statement lies is never even reached.
+		def self.additional_login_param_new_otp_partial(resource)
+			Auth.configuration.auth_resources[resource.class.to_s.capitalize][:additional_login_param_new_otp_partial] or 'auth/modals/sign_up_success_inactive_content.html.erb'
+		end
+	end
+end

data/lib/auth/rails/routes.rb

@@ -0,0 +1,169 @@
+module ActionDispatch::Routing
+  class Mapper
+
+  	##@param app_route_resources[Hash] -> 
+  	##key:resource[String] -> the name of the resource for which omniauth routes are to be generated.
+  	##value:opts[Hash] -> the options specifying the views, controllers etc for omniauth.
+  	##expected to be present in the preinitializer in the routes of the target app.
+	def mount_routes(app_route_resources)
+
+	      resources :search, :controller => "auth/search" do 
+	      	collection do 
+	      		get 'authenticated_user_search', :action => 'authenticated_user_search', :as => "authenticated_user"
+	      	end
+	      end
+
+	      resources :admin_create_users, :controller => "auth/admin_create_users"
+
+	  	  resources :clients, :controller => "auth/clients"
+		  resources :profiles, :controller => "auth/profiles" do 
+		  	collection do 
+		  		## :resource will be something like users.
+		  		post ':resource/set_proxy_user', :action => 'set_proxy_resource', :as => "set_proxy_resource"
+		  		get 'credential_exists', :action => 'credential_exists'
+		  		post ':resource/get_user_id', :action => 'get_user_id'
+		  		put ':resource/update', :action => 'update'
+		  		
+		  	end
+		  end
+		  
+		 if Auth.configuration.otp_controller
+			 get "#{Auth.configuration.mount_path}/:resource/otp_verification_result", :action => "otp_verification_result", :controller => "#{Auth.configuration.otp_controller}", :as => "otp_verification_result"
+			  get "#{Auth.configuration.mount_path}/:resource/verify_otp", :action => "verify_otp", :controller => "#{Auth.configuration.otp_controller}", :as => "verify_otp"
+			  get "#{Auth.configuration.mount_path}/:resource/send_sms_otp", :action => "send_sms_otp", :controller => "#{Auth.configuration.otp_controller}", :as => "send_sms_otp"
+			  get "#{Auth.configuration.mount_path}/:resource/resend_sms_otp", :action => "resend_sms_otp", :controller => "#{Auth.configuration.otp_controller}", :as => "resend_sms_otp"
+		  end
+
+
+			["cart_item","cart","payment","product","discount"].each do |model|
+
+				if Auth.configuration.send("#{model}_controller")
+
+					scope_path = "/"
+			 	 	as_prefix = nil
+			 	 	collection = nil
+
+			 	 	Auth.configuration.send("#{model}_class").underscore.pluralize.scan(/(?<scope_path>.+?)\/(?<collection>[A-Za-z_]+)$/) do 
+
+			 	 		if Regexp.last_match[:scope_path]
+			 	 			scope_path = scope_path +  Regexp.last_match[:scope_path]
+			 	 			## this is done so that the route helper defined inside the engine views also work.
+			 	 			as_prefix =  Regexp.last_match[:scope_path]
+			 	 		end
+			 	 		collection = Regexp.last_match[:collection]
+
+			 	 	end
+
+			 	 	if collection
+				 	 	scope :path => scope_path, :as => as_prefix do
+				 	 		#puts "As prefix is: #{as_prefix}" 
+				 	 		#puts "scope path is: #{scope_path}"
+				 	 		controller_name = Auth.configuration.send("#{model}_controller")
+				 	 		
+			 	 			resources collection.to_sym, controller: controller_name do
+			 	 				collection do 
+			 	 				## for the option to create multiple cart items at one time.
+				 	 				if model == "cart_item"
+				 	 					post 'create_multiple', :action => 'create_multiple'
+				 	 				end
+			 	 				end
+
+			 	 			end
+				 	 		
+					    	
+					    	##A ROUTE HAS BEEN ADDED IN THE DAUGHTER APP FOR THE POST -> TO THE PAYMENTS_UPDATE FOR PAYUMONEY.
+					    	##refer payumoney_controller_concern.rb
+					    end
+					end
+
+				end
+
+			end
+
+
+		  
+		  app_route_resources.each do |resource,opts| 
+
+		  	  #puts "resource is : #{resource}"
+		  	  #puts "opts are: #{opts}"
+			  # ensure objects exist to simplify attr checks
+			  opts[:controllers] ||= {}
+			  opts[:skip]        ||= []
+			  
+
+			  # check for ctrl overrides, fall back to defaults
+			  sessions_ctrl          = opts[:controllers][:sessions] || "auth/sessions"
+			  registrations_ctrl     = opts[:controllers][:registrations] || "auth/registrations"
+			  passwords_ctrl         = opts[:controllers][:passwords] || "auth/passwords"
+			  confirmations_ctrl     = opts[:controllers][:confirmations] || "auth/confirmations"
+			  omniauth_ctrl          = opts[:controllers][:omniauth_callbacks] || "auth/omniauth_callbacks"
+			  unlocks_ctrl 			 = opts[:controllers][:unlocks] || "auth/unlocks"
+
+			  # define devise controller mappings
+			  controllers = {:sessions           => sessions_ctrl,
+			                 :registrations      => registrations_ctrl,
+			                 :passwords          => passwords_ctrl,
+			                 :confirmations      => confirmations_ctrl,
+			             	 :unlocks  			 => unlocks_ctrl
+			             	}
+
+			  # remove any unwanted devise modules
+			  opts[:skip].each{|item| controllers.delete(item)}
+
+			  resource_as_pluralized_string = Auth::OmniAuth::Path.resource_pluralized(resource)
+
+			  devise_for resource_as_pluralized_string.to_sym,
+			    :class_name  => resource,
+			    :module      => :devise,
+			    :path        => "#{Auth::OmniAuth::Path.resource_path(resource)}",
+			    :controllers => controllers,
+			    :skip        => opts[:skip] + [:omniauth_callbacks]
+
+
+			  resource_class = Object.const_get resource
+			
+              #################################################################
+              ##
+              ## OMNIAUTH PATHS
+              ##
+              #################################################################
+
+			  if !(opts[:skip].include? :omniauthable)
+
+					resource_class.omniauth_providers.each do |provider|
+						
+						omniauth_request_path = Auth::OmniAuth::Path.omniauth_request_path(nil,provider)
+
+						common_callback_path = Auth::OmniAuth::Path.common_callback_path(provider)
+
+						if !Rails.application.routes.url_helpers.method_defined?("#{provider}_omniauth_authorize_path".to_sym)
+							puts "calling route for provider: #{provider}"
+							match "#{omniauth_request_path}", controller: omniauth_ctrl, action: "passthru", via: [:get,:post], as: "#{provider}_omniauth_authorize"
+						end
+
+						if !Rails.application.routes.url_helpers.method_defined?("#{provider}_omniauth_callback_path".to_sym)
+							match "#{common_callback_path}", controller: omniauth_ctrl, action: "omni_common", via: [:get,:post], as: "#{provider}_omniauth_callback"
+						end
+					end
+
+					oauth_failure_route_path = Auth::OmniAuth::Path.omniauth_failure_route_path(nil)
+
+					if !Rails.application.routes.url_helpers.method_defined?("omniauth_failure_path".to_sym)
+
+						match "#{oauth_failure_route_path}", controller: omniauth_ctrl, action: "failure", via:[:get,:post], as: "omniauth_failure"
+					end
+			  end
+
+			  #################################################################
+			  ##
+			  ## RESOURCE_PROFILE PATHS
+			  ##
+			  #################################################################
+
+			  #match "#{omniauth_request_path}", controller: omniauth_ctrl, action: "passthru", via: [:get,:post], as: "#{provider}_omniauth_authorize"
+
+		  end
+	  end
+  end
+end
+

data/lib/auth/search/main.rb

@@ -0,0 +1,97 @@
+module Auth
+	module Search
+		module Main
+			## this def, returns a hash with the structure for the basic ngram query.
+			## the query_string is left blank, and you should merge this in through any def that wants to perform an ngram query.
+			## @return[Hash]
+			def self.base_ngram_query
+				{
+					body: {
+						query: {
+							filtered: 
+							{
+								query: {
+									match: {
+										_all: {
+											query: "",
+											operator: "and"
+										}
+									}
+								},
+								filter: {
+									match_all:{
+
+									}
+								}
+							}
+						}
+					}
+				}
+			end
+
+			## @param[Hash] : This is expected to contain the following:
+			## @query_string : the query supplied by the user
+			## @resource_id : a resource_id with which to filter search results, if its not provided, no filter is used on the search results
+			## @size : if not provided a default size of 20 is used
+			## this def will use the #base_ngram_query hash and merge in a filter for the resource_id.
+			
+			## 'Public' Resources
+			##  if the public field is present, don't add any resource_id filter.
+			##  if the public field is not present, then add the resource_id filter if the resource_id is provided.
+
+			
+			## @return[Array] response: an array of mongoid search result objects. 
+			def self.search(args)	
+				args = args.deep_symbolize_keys
+				return [] unless args[:query_string]
+				query = base_ngram_query
+				
+				## set all the required values.
+				query[:size] = args[:size] || 20
+	
+				query[:body][:query][:filtered][:query][:match][:_all][:query] = args[:query_string]
+				if args[:resource_id]
+					query[:body][:query][:filtered][:filter] = {
+							
+								bool: {
+									should: [
+										{
+											bool: {
+												must: [
+													{
+														term: {
+															public: "no"
+														}
+													},
+													{
+														term: {
+															resource_id: args[:resource_id]
+														}
+													}
+												]
+											}
+										},
+										{
+											term: {
+												public: "yes"
+											}
+										}
+									]
+								}
+							
+						}
+				else
+					## if a resource id is not provided then
+					## it means that the resource is admin,
+					## and they should be able to access and see
+					## any resource
+					## so in that case we leave the query
+					## as is.
+				end
+
+				#puts JSON.pretty_generate(query)
+				Mongoid::Elasticsearch.search(query,{:wrapper => :load}).results
+			end
+		end
+	end
+end

data/lib/auth/sidekiq_up.rb

@@ -0,0 +1,16 @@
+=begin
+require "sidekiq/api"
+module Auth
+	module SidekiqUp
+		## @param job_description[String]: a json representation of whatever job / arguments you wanted to pass into sidekiq, it is used to log an error in case sidekiq is down.
+		## the determination of sidekiq begin down is done by checking if the queues hash is empty.
+		## @return : yields the block called with this method in case the queues are not empty, otherwise the result of calling Rails.logger.error
+		def self.sidekiq_running(job_description)
+			stats = Sidekiq::Stats.new
+			yield
+			#yield unless stats.queues.empty?
+			#Rails.logger.error("sidekiq could not do job because sidekiq was not started: #{job_description}") if stats.queues.empty?
+		end
+	end
+end
+=end