wordjelly-auth 0.0.1

data/app/helpers/auth/shopping/products/products_helper.rb

@@ -0,0 +1,52 @@
+module Auth::Shopping::Products::ProductsHelper
+
+
+    ## @param[Auth::Shopping::Product] product
+    ## @return[Auth::Shopping::CartItem] citem 
+    def create_cart_item_from_product(product)
+        citem = Auth.configuration.cart_item_class.constantize.new
+        product.attributes.keys.each do |p_att|
+            if citem.respond_to? p_att.to_sym
+                unless (p_att == "_id" || p_att == "_type" || p_att == "resource_id" || p_att == "resource_class")  
+                    citem.send("#{p_att}=",product.send("#{p_att}"))
+                end
+            end
+        end
+        citem.product_id = product.id.to_s
+       
+        citem
+    end
+
+
+    ##########################################################
+    ##
+    ##
+    ## PATH HELPERS.
+    ##
+    ##
+    ##########################################################
+
+
+	## get /new
+	def new_product_path
+      main_app.send(Auth::OmniAuth::Path.new_path(Auth.configuration.product_class))
+    end
+
+    ## (PUT/PATCH/GET) - individual product
+    def product_path(product)
+    	
+    	main_app.send(Auth::OmniAuth::Path.show_or_update_or_delete_path(Auth.configuration.product_class),product)
+    end
+
+	
+	##/products (GET - all products /CREATE - individual product) 
+	def products_path
+    	main_app.send(Auth::OmniAuth::Path.create_or_index_path(Auth.configuration.product_class))
+    end
+
+    ##/shopping/products/:id/edit
+    def edit_product_path(product)
+    	main_app.send(Auth::OmniAuth::Path.edit_path(Auth.configuration.product_class),product)
+    end
+
+end

data/app/helpers/auth/shopping/shopping_helper.rb

@@ -0,0 +1,3 @@
+module Auth::Shopping::ShoppingHelper
+	
+end

data/app/helpers/auth/users/profiles_helper.rb

@@ -0,0 +1,12 @@
+module Auth::Users::ProfilesHelper
+
+	##@used_in: views/users/profiles/_user_data.html.erb
+	##@resource[Object]: a Devise resource
+	##@returns[Hash]: a hash with key: resource, value -> jsonified representation of whatever data you want to store for that resource 
+	def user_data(resource)
+		{resource: {:id => resource.id.to_s}}
+	end
+
+
+	
+end

data/app/jobs/otp_job.rb

@@ -0,0 +1,92 @@
+require "/home/bhargav/Github/auth/lib/auth/two_factor_otp"
+class OtpJob < ActiveJob::Base
+  include Auth::TwoFactorOtp
+  include Auth::Mailgun
+  include Auth::JobExceptionHandler
+
+  queue_as :default
+  #self.queue_adapter = Auth.configuration.queue_adapter.to_sym
+
+  ##we currently log all exceptions to redis.
+  rescue_from(StandardError) do |exception|
+  	puts exception.message
+   	puts exception.backtrace.join("\n")
+  end
+ 
+  ## expected array of arguments is: 
+  ## 0 => resource class as string
+  ## 1 => resource as json serialized, by calling JSON.generate()
+  ## 2 => job_type : either "send_sms_otp" or "verify_sms_otp"
+  ## 3 => hash of additional arguments if any
+  def perform(args)
+  	
+  	resource_class = args[0]
+  	resource_id = args[1]
+  	job_type = args[2]
+    params = (args.size == 4) ? JSON.parse(args[3]).deep_symbolize_keys : nil 
+    
+
+    ############### WEBHOOK JOBS ##########################
+
+    if job_type == "sms_webhook"
+
+      sms_webhook(params)
+
+    elsif job_type == "email_webhook"
+
+      email_webhook(params)
+
+    end
+
+    ############### JOBS THAT NEED A RESOURCE #############
+
+	  if resource_class && Auth.configuration.auth_resources[resource_class]
+		
+      resource_class = resource_class.constantize
+		  
+
+      resource = resource_class.find(resource_id)
+		
+      
+      Auth::TwoFactorOtp.resource = resource
+  		
+
+      if job_type == "send_sms_otp"
+  			
+
+        auth_gen
+  		
+
+      elsif job_type == "verify_sms_otp"
+  		
+
+      	verify(params[:otp])
+      
+
+      elsif job_type == "send_transactional_sms"
+        
+
+        notification = params[:notification_class].capitalize.constantize.find(params[:notification_id])
+        notification.send_sms(resource) do 
+          send_transactional_sms(notification.format_for_sms(resource))
+        end
+
+
+      elsif job_type == "send_email"
+      
+        notification = params[:notification_class].capitalize.constantize.find(params[:notification_id])
+        email = Auth.configuration.mailer_class.constantize.notification(resource,self)
+        email = add_webhook_identifier_to_email(email)
+      
+        notification.send_email(resource) do 
+          JSON.generate(email.message.mailgun_variables)      
+        end
+      
+        email.deliver_now
+  	
+      end
+      
+	  end
+
+  end
+end

data/app/mailers/application_mailer.rb

@@ -0,0 +1,4 @@
+class ApplicationMailer < ::ApplicationMailer
+  default from: "from@example.com"
+  layout 'mailer'
+end

data/app/mailers/auth/notifier.rb

@@ -0,0 +1,9 @@
+class Auth::Notifier < ::ApplicationMailer
+	default from: "from@example.com"
+	## make sure that anything going into this argument implements includes globalid, otherwise serialization and deserialization does not work.
+	def notification(resource,notification)
+		@resource = resource
+		@notification = Auth.configuration.notification_class.constantize.new
+		mail to: "bhargav.r.raut@gmail.com", subject:  "#{Time.now}Now with new otp job architecture.  #{Auth.configuration.brand_name}"
+	end
+end

data/app/models/auth/admin_create_user.rb

@@ -0,0 +1,3 @@
+class Auth::AdminCreateUser
+  include Mongoid::Document
+end

data/app/models/auth/client.rb

@@ -0,0 +1,52 @@
+module Auth
+  class Client
+    include Mongoid::Document
+    include MongoidVersionedAtomic::VAtomic
+    validates :redirect_urls, :url => true, if: :there_are_redirect_urls
+    validates :resource_id, presence: true
+
+    def to_param
+    	resource_id
+    end
+
+    def self.find(input)
+    	Client.where(:resource_id => input).first
+    end
+
+    field :api_key, type: String
+    field :path, type: String
+    field :redirect_urls, type: Array, default: []
+    field :resource_id, type: BSON::ObjectId, default: BSON::ObjectId.new
+    field :app_ids, type: Array, default: []
+    field :current_app_id, type: String
+    attr_accessor :add_app_id
+    attr_accessor :add_redirect_url
+    
+    
+    def contains_redirect_url?(url)
+        return self.redirect_urls.include? url
+    end
+
+    def self.find_valid_api_key(api_key)
+        c =  self.find(:api_key => api_key)
+        return c
+    end
+
+    ##USED IN DEVISE.RB -> SET_CLIENT
+    ##USED IN OMNIAUTH.RB -> CHECK_STATE
+    def self.find_valid_api_key_and_app_id(api_key,app_id)
+        c = self.where(:api_key => api_key, :app_ids => app_id).first
+        if c
+            c.current_app_id = app_id
+        end
+        return c
+    end
+
+    def there_are_redirect_urls
+        return self.redirect_urls && self.redirect_urls.size > 0
+    end
+
+    
+
+  end
+end

data/app/models/auth/concerns/activity_concern.rb

@@ -0,0 +1,112 @@
+module Auth::Concerns::ActivityConcern
+
+	extend ActiveSupport::Concern
+	include Auth::Concerns::ChiefModelConcern
+	included do 
+
+		field :user_id, 			type: BSON::ObjectId
+		field :image_url, 			type: String
+
+	end
+
+	module ClassMethods
+
+		##the default "from" is the beginning of the current month, and the default "to" is the current time.
+		##@used_in : last_n_months, get_in_range
+		##@param[Hash]  query: the "from","to" provided in the query if at all, otherwise nil, assumed that query has two keys : "from", "to", under a key called "range"
+		##@param[Integer] default_from : the default_from for the particular function that is firing this query, it is an epoch
+		##@param[Integer] default_to : the default_to for the particular function that is firing this query, it is an epoch
+		##@return[Hash] : default values for "from", "to"
+		def activities_from_to(query,default_from,default_to)
+			defaults = {"range" => {"from" => default_from, "to" => default_to}}
+			query = defaults.deep_merge(query)
+			##default from and to assigned here.
+			from = query["range"]["from"].to_i
+			to = query["range"]["to"].to_i
+			if from >= to
+				query["range"]["from"] = default_from
+				query["range"]["to"] = default_to
+			end
+			return query
+		end
+
+
+		##defaults for only.
+		##if it is empty or nil, then it becomes all attributes
+		##otherwise it becomes the intersect of all attributes and the ones specified in the only
+		##created_at had to be added here, because otherwise it throws an error saying missing_attribute in the only. I think this has something to do with the fact that it is used in the query, so it will be included in the result.
+		##@used_in: get_in_range
+		##@param[query] : the provided query, expected to be of the structure: 
+		##{"only" => [array],,,other key value pairs}
+		##@return[Hash] query : returns the query with the default values for the fields to be returned
+		def activities_fields(query)
+			defaults = {"only" => Object.const_get(name).fields.keys}
+			query = defaults.deep_merge(query)
+			only = ((Object.const_get(name).fields.keys & query["only"]) + ["created_at"])
+			query["only"] = only
+			return query
+		end
+
+		##@param[Hash] query_params: {"range" : {"from" : unix_epoch_as_string, "to" => unix_epoch_as_string}, "user_id": string, "only": [array_of_attributes_required]}
+		##"range" => optional,if nil or empty, "from" and "to" will be automatically assigned to beginning_of_current_month and current_time respectively
+		##"user_id" => required, will return empty hash if absent.
+		##@return[Hash] agg_hash: the aggregation hash
+		def last_n_months(query_params)
+			return {} unless query_params[:user_id]
+			query_params = Object.const_get(name).activities_from_to(query_params, Time.now.to_i = 12.months, Time.now.to_i)
+			
+			agg_hash = Object.const_get(name).collection.aggregate([
+					{
+						"$match" => Object.const_get(name).where(:created_at.gte => query_params["range"]["from"], :created_at.lte => query_params["range"]["to"], :user_id => query_params[:user_id]).selector
+					},
+					{
+						"$project" => {
+							month: {
+								"$month" => "$created_at"
+							}
+						}
+					},
+					{
+						"$group" => {
+							"_id" => {
+								month: "$month"
+							},
+							count: {
+								"$sum" => 1
+							}
+						}
+					}]
+				)
+
+			return agg_hash
+
+		end
+
+		##@param[Hash] query_params: {"range" : {"from" : unix_epoch_as_string, "to" => unix_epoch_as_string}, "user_id": string, "only": [array_of_attributes_required]}
+		##"range" => optional,if nil or empty, "from" and "to" will be automatically assigned to beginning_of_current_month and current_time respectively
+		##"user_id" => required, will return empty hash if absent.
+		##"only" => optional, will default to all attributes of the activity model.
+		##@return[Hash]: timestamp => activity_object hashified.
+		def get_in_range(query_params)
+			
+			## return empty hash if there is no user_id
+			return {} unless query_params[:user_id]
+			query_params = Object.const_get(name).activities_from_to(query_params, Time.now.beginning_of_month.to_i, Time.now.to_i)
+			query_params = Object.const_get(name).activities_fields(query_params)
+
+			##make the mongoid range call here.
+			activities = Object.const_get(name).where(:created_at.gte => query_params["range"]["from"], :created_at.lte => query_params["range"]["to"], :user_id => query_params["user_id"]).only(query_params["only"])
+
+			activities_hash = Hash[activities.entries.map{|c| c.created_at.to_i}.zip(activities.entries.map{|c| c.as_json})]
+
+			puts JSON.pretty_generate(activities_hash)
+			
+			return activities_hash
+		
+		end
+		
+	end
+
+
+
+end

data/app/models/auth/concerns/chief_model_concern.rb

@@ -0,0 +1,73 @@
+module Auth::Concerns::ChiefModelConcern
+
+	extend ActiveSupport::Concern
+
+	included do 
+
+
+		
+
+		include Mongoid::Document
+		include Mongoid::Timestamps
+
+		## expected to be a hash with names of callbacks and boolean values.
+		## eg: {:before_save => true, :after_save => false..}
+		## used in conjunction with the provided skip_callback?(callback_name) method to determine whether to execute the callbacks or not.
+		## so basically before saving the document, set this attr_accessor on it, and it will allow you to control if callbacks are executed or not.
+		## currently used in the after_save callback where we dont want the refund being set to accepted, and thereafter to update all other refunds as failed to cascade.
+		attr_accessor :skip_callbacks
+
+
+		field :public, type:String, default: "no"
+
+
+		def field_names_to_skip_while_making_form
+			["_id","_type.,","resource_id","resource_class","created_at","updated_at","public"]
+		end
+
+		def publicly_visible_field_names 
+			[]
+		end
+
+
+		## returns a list of attributes of tis model other than those mentioned in #FIELD_NAMES_TO_SKIP_WHILE_MAKING_FORM in this concern.
+		## this is only used in the web api.
+		## @return[Array] array_of_strings : field name.
+		def attributes_to_show
+			self.class.attribute_names.keep_if{|c| !self.field_names_to_skip_while_making_form.include? c.to_s}
+		end
+
+		## @return[Array]
+		def public_attributes_to_show
+			self.publicly_visible_field_names
+		end
+
+	end
+
+	## @param callback_name[String] : the name of the callback which you want to know if is to be skipped
+	## return[Boolean] : true or false.
+	## checks whether the attr_accessor skip_callbacks is set, and if yes, then whether the name of this callback exists in it.
+	## if both above are no, then returns false
+	## if the name exists, then return whatever is stored for the name i.e true or false.
+	## @used_in the after_save and before_save callback blocks, as the first line, basically only executes the block if this method returns false.
+	def skip_callback?(callback_name)
+		return false if (self.skip_callbacks.blank? || self.skip_callbacks[callback_name.to_sym].nil?)
+		return self.skip_callbacks[callback_name.to_sym] == true
+	end
+
+	## will iterate the superclasses of this class
+	## until it finds a class that begins with Auth::
+	## or it hits Object
+	## and then it returns that superclass whatever it is.
+	def walk_superclasses
+		my_super_class = self.class.superclass
+		while my_super_class != Object
+			break if my_super_class.to_s =~ /^Auth::/
+			my_super_class = my_super_class.superclass 
+		end
+		return my_super_class
+	end
+
+	
+
+end

data/app/models/auth/concerns/es_concern.rb

@@ -0,0 +1,21 @@
+module Auth::Concerns::EsConcern
+
+	extend ActiveSupport::Concern
+	
+	included do 
+
+		def self.create_es_index(definition)
+			definition ||= {}
+			if Auth.configuration.use_es == true
+				include Mongoid::Elasticsearch
+				elasticsearch! (
+						definition
+					)
+			end
+		end	
+
+	end
+
+
+
+end