wordjelly-auth 0.0.1

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

@@ -0,0 +1,232 @@
+module Auth::Concerns::NotificationConcern
+		
+	extend ActiveSupport::Concern
+	include Auth::Concerns::ChiefModelConcern
+	
+	included do 
+
+		include GlobalID::Identification
+
+
+		## email subject.
+		## the subject for email notifications.
+		field :email_subject, type: String, default: "Notification from #{Auth.configuration.brand_name}"
+
+
+		## short message : displayed in notification popup
+		field :callout_message, type: String
+
+
+		## a collapse id, for gcm messages.
+		field :collapse_id, type: String
+
+
+
+		## to topics
+		## the topics to which this notification is being sent.
+		## this will only be applicable to gcm.
+		field :topics, type: Array
+
+
+
+		## resource class
+		## the class of the resource to which this notification should be sent.
+		field :resource_class, type: String
+
+
+
+		## to resource_ids
+		## hash of resource_ids to which this notification is being sent.
+		## key -> class_name 
+		## value -> array of resource ids.
+		## JSON encoded string.
+		field :resource_ids, type: String, default: JSON.generate({})
+
+
+		## a hash with query conditions determining to which resources this notification should be sent.
+		## key -> class name
+		## value -> query hash
+		## JSON encoded string.
+		field :resources_by_query, type: String, default: JSON.generate({})
+
+
+		## reply_to_email
+		## an email address to which the user can reply in case of any issues
+		field :reply_to_email, type: String
+
+
+		## reply_to_number
+		## a mobile phone number to which the user can reply in case of any issues.		
+		field :reply_to_number, type: String
+
+		## objects related to this notification.
+		## a hash of object ids, that refer to any objects that this notification deals with.
+		## key -> string[preferably the class name, but can be anything if more than two objects of the same class are used.]
+		## value -> bson::objectid of the instance of that class
+		## these can be used to refer to , or pull up objects , pertaining to this notification.
+		## eg, suppose you are sending a notification regarding an order object, then this would be a good place to store a key->value like: object_id: object.id.to_s
+		## this can later be used when sending the notification, in the email/sms etc.
+		field :objects, type: Hash, default: {}
+
+		
+		##################### RETRY COUNTS ######################
+
+		field :sms_send_count, type: Integer, default: 0
+		field :email_send_count, type: Integer, default: 0
+
+	end
+
+
+	
+
+	######################### FORMAT METHODS ####################
+
+	## returns the name of a partial to be rendered.
+	def email_partial
+		"auth/notifier/email.html.erb"
+	end
+
+
+	def format_for_sms(resource)
+
+	end
+
+	def format_for_android(resource)
+
+	end
+
+	def format_for_ios(resource)
+
+	end
+
+	def format_for_web(resource)
+
+	end
+
+	################ default max retry count ################### 
+
+	def max_retry_count
+		2
+	end
+
+	######################### SEND METHODS ####################
+
+
+	## if the notification should be sent by email or not.
+	## override in the implementing model.
+	## default is true
+	def send_by_email?(resource)
+		true
+	end
+
+
+	## if the notification should be sent by sms or not.
+	## override in the implementing model.
+	## default is true
+	def send_by_sms?(resource)
+		true
+	end
+
+	## if the notification should be sent by mobile or not.
+	## override in the implementing model.
+	## default is true
+	def send_by_mobile?(resource)
+		true
+	end
+
+
+	## if the notification should be sent by desktop or not.
+	## override in the implementing model.
+	## default is true
+	def send_by_desktop?(resource)
+		true
+	end
+
+	
+	def send_notification
+		recipients = send_to
+		recipients[:resources].map{|r|
+			send_email_background(r) if send_by_email?(r)
+			send_sms_background(r) if send_by_sms?(r) 
+			#r.send_mobile_notification(self) if send_by_mobile?(r)
+			#r.send_desktop_notification(self) if send_by_desktop?(r)
+		}
+	end
+
+	################### SEND SMS NOTIFICATION ####################
+
+
+	## defaults to just sending the sms direclty.
+	## override using a background job to actually call the send_sms method.
+	def send_sms_background(resource)
+		send_sms(resource)
+	end
+
+	## creates a notification response object using the yield block from calling this method.
+	## block passed if any must return a string as the yield.
+	def send_sms(resource)
+		if self.sms_send_count < max_retry_count
+			self.sms_send_count+=1
+			create_notification_response(yield,"sms")
+			self.save
+		end
+	end
+
+	################## SEND EMAIL NOTIFICATION  ##################
+
+	## defaults to sending the email directly.
+	## override to send email in a background job.
+	def send_email_background(resource)
+		send_email(resource)
+	end
+
+	# Auth.configuration.mailer_class.constantize.notification(resource,notification).deliver_later if resource.email
+	
+	def send_email(resource)
+		if self.email_send_count < max_retry_count
+			self.email_send_count+=1
+			create_notification_response(yield,"email")
+			self.save
+		end
+	end
+	################## NOTIFICATION RESPONSE CREATE ##############
+
+	## @response[String] : a response received after sending a notification.
+	## webhook identifier is called before_create by a callback. 
+	def create_notification_response(response,type)
+		notification_response = Auth.configuration.notification_response_class.constantize.new(notification_type: type, parent_notification_id: self.id.to_s)
+		notification_response.add_response(response)
+		notification_response.set_webhook_identifier(response)
+		notification_response.save
+	end
+
+	######################## UTILITY METHODS ##################
+
+	## @return [Array] of resource objects.
+	def get_resources
+		resources = []
+
+		JSON.parse(resource_ids).each do |class_name,ids|
+			resources << ids.map{|c|
+				class_name.capitalize.constantize.find(c)
+			}
+		end
+		JSON.parse(resources_by_query).each do |class_name,query|
+			resources << class_name.capitalize.constantize.where(query)
+		end
+		resources.flatten
+	end
+
+	def get_topics
+		topics || []
+	end
+
+	def send_to
+		{:resources => get_resources, :topics => get_topics}
+	end
+
+	def resource_class_constantized
+		self.class.name.capitalize.constantize
+	end
+
+end

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

@@ -0,0 +1,71 @@
+module Auth::Concerns::NotificationResponseConcern
+	extend ActiveSupport::Concern
+	
+
+	included do 
+		include Auth::Concerns::ChiefModelConcern
+		include Auth::Concerns::OwnerConcern
+		include GlobalID::Identification
+		field :notification_type, type: String
+		validates_presence_of :notification_type
+		## array of json responses.
+		## example from the webhook, or the initial notification send response.
+		field :responses, type: Array, default: []
+		field :parent_notification_id, type: String
+		validates_presence_of :parent_notification_id
+
+		## field to search for during the webhook callback.
+		## the webhook should search for where(:webhook_identifier => something provided by the webhook.)
+		field :webhook_identifier
+		validates_presence_of :webhook_identifier
+
+		
+	end
+
+	## the idea here is the process the response by means of a block.
+	## json response should be a string representation of a valid json object.
+	def add_response(json_response)
+		self.responses << json_response
+		yield if block_given?
+	end
+
+	## returns the parent notificatino object of this notification response.
+	def get_parent_notification
+		Auth.configuration.notification_class.constantize.find(self.parent_notification_id)
+	end
+
+
+	
+	## fixes the identifier by which this response can be identified during webhook calls.
+	## @param response[String] : the json string that contains the response that was obtained by sending the notification.
+	def set_webhook_identifier(response)
+		
+	end
+
+
+	module ClassMethods
+
+		## @param webhook_identifier[String] : an identifier by which to search for a notification response object
+		## @param params[String] : a JSON string of whatever was received from the webhook request.
+		## &block, optional block.
+		## return the notification_response object, after adding the response to it and saving it, if it was found
+		## yields the provided block after calling save.
+		## check the notification_response to see if it was successfully saved.
+		## return nil otherwise, and logs a rails error.
+		def find_and_update_notification_response(webhook_identifier,params,&block)
+			puts "webhook identifier is: #{webhook_identifier}"
+			if notification_response = Auth.configuration.notification_response_class.constantize.where(:webhook_identifier => webhook_identifier)
+		 		notification_response = notification_response.first
+		 		notification_response.add_response(params)
+		 		notification_response.save
+		 		yield(notification_response) if block_given?
+		 		notification_response
+		 	else
+		 		Rails.logger.error("webhook identifier not found: #{webhook_identifier}")
+		 	end
+		end
+
+	end
+
+end
+

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

@@ -0,0 +1,81 @@
+module Auth::Concerns::OwnerConcern
+
+	extend ActiveSupport::Concern
+	include Auth::Concerns::ChiefModelConcern
+	included do 
+
+		## resource id is not essential for the creation of a cart.
+
+		## but if a resource id is present, then a resource class must be provided.
+
+		field :resource_id, type: String
+		field :resource_class, type: String
+
+		## THERE ARE BASICALLY THREE KINDS OF USERS THAT WE MAY NEED.
+
+		## ONE : The resource that is considered as the owner of the object . this uses the resource_id and resource_class. It is got by calling get_resource on the object.
+
+		attr_accessor :owner_resource
+
+		## SIGNED_IN_RESOURCE : the resource that is currently signed in, and should be assigned to this model instance, in the controller. In the controller this can be got by calling the method currently_signed_in_resource, provided that the controller implements the token_concern.
+
+		attr_accessor :signed_in_resource
+
+
+		validates_presence_of :resource_class, if: Proc.new{|c| !c.resource_id.nil?}
+
+		## you cannot change the resource_id or owner of the object once it is set.
+		validate :resource_id_not_changed
+
+	end
+
+	module ClassMethods
+
+		## used in cart_item_controller_concern#show
+		## if the resource is nil, will look for a cart item, which has a resource of nil, otherwise will look for a cart item, with the provided resource id.
+		## 
+		def find_self(_id,resource)
+			conditions = {:_id => _id}
+			conditions[:resource_id] = resource.id.to_s if !resource.is_admin?
+			puts "conditions are:"
+			puts conditions.to_s
+			all = self.where(conditions)
+			puts "the resultant size:"
+			puts all.size.to_s
+			return all.first if all.size > 0 
+			return nil
+		end
+
+	end
+
+	## returns the resource that was associated with the object when the object was created.
+	## it basically uses the resource_id and resource_class that were saved, when creating the resource.
+	## since resources can be created without the resource_class and resource_id being provided, it may return nil if these two are not present.
+	def get_resource
+		return unless (self.resource_class && self.resource_id) 
+		unless owner_resource
+			
+			owner_resource = self.resource_class.capitalize.constantize.find(self.resource_id)
+		end
+		owner_resource
+	end
+
+	## checks if the owner of the current object is the same as the owner of the other object passed in.
+	## this is currently used in payment_concern, in a before_save validation def.
+	## this is also used in the cart_item_concern, as a before_update validation , if the parent_id is changing, where we check if the cart_item owner is the same as that of the cart.
+	def owner_matches(other_object)
+		return false unless other_object.respond_to? :resource_id
+		return false if self.resource_id != other_object.resource_id
+	end
+
+	private
+
+	def resource_id_not_changed
+	  ##this method will give you access to be able to reset the resource_id in case the admin is modifying the resource.
+	  ##need to check if that can be done?
+	  if resource_id_changed? && resource_id_was
+	      errors.add(:resource_id, "You cannot change the ownership of this entity")
+	  end
+	end
+
+end

data/app/models/auth/concerns/shopping/cart_concern.rb

@@ -0,0 +1,329 @@
+##NEED A SEPERATE MODEL THAT IMPLEMENTS IT
+module Auth::Concerns::Shopping::CartConcern
+
+	extend ActiveSupport::Concern
+	
+	include Auth::Concerns::ChiefModelConcern	
+	include Auth::Concerns::OwnerConcern
+
+	included do 
+		field :name, type: String
+		field :notes, type: String
+		
+
+		
+
+
+		## debit is calculated live, by first getting all the items already dispatched and their value, and then getting the total payments made and their value, so it infact becomes something at the validation level of the cart item.
+
+		## add cart item ids
+		attr_accessor :add_cart_item_ids
+
+
+		## remove cart item ids
+		attr_accessor :remove_cart_item_ids
+
+
+		## the total price of all the items in the cart
+		attr_accessor :cart_price
+
+		## the array of payment objects made upto now to this cart
+		attr_accessor :cart_payments
+
+		## the array of cart items in this cart.
+		attr_accessor :cart_items
+
+		## the amount the customer owes to us.
+		attr_accessor :cart_pending_balance
+
+		## the cumulative amount paid into this cart(sum of all successfull payments.)
+		attr_accessor :cart_paid_amount
+
+		## the credit the customer has pending in the cart.
+		## this is used for sequentially debiting money from the cart_paid amount.
+		attr_accessor :cart_credit
+
+		## the minimum amount payable for all the cart items in the cart that are not yet accepted
+		attr_accessor :cart_minimum_payable_amount
+
+
+		## the discount object id, passed in so that it can be rendered in the show_cart action where we provide a link to create a payment.
+		field :discount_id, type: String
+
+		attr_accessor :discount
+
+		before_destroy do |document|
+			document.prepare_cart
+			if document.cart_items.keep_if{|c| c.accepted == true}.size > 0
+				false
+			elsif document.get_cart_payments.size > 0 
+				false
+			end
+		end
+
+		
+		validate :add_or_remove_validation
+
+
+		## how to handle discount exceeds cart balance.
+		## how to handle discount origin cart id, is same as this cart.
+
+	end
+
+	
+
+	## sets all the attribute accessors of the cart.
+	## @param[Payment] : a payment object can be passed in.
+	## this is used in case there is a new payment which is calling prepare_cart. in that case the new payment has to be also added to the cart_payments. this is alwasy the case when a new payment is made with a status directly set as accepted, i.e for eg a cashier makes a payment on behalf of the customer.
+	def prepare_cart
+
+		find_cart_items
+		
+		set_cart_price
+		
+		set_cart_payments
+		
+		set_cart_paid_amount
+		
+		set_cart_pending_balance
+
+		set_cart_minimum_payable_amount
+
+		set_discount
+
+	end
+
+	################ ATTR ACCESSOR SETTERS & GETTERS ##############
+
+	## set the cart items, [Array] of cart items.
+	def find_cart_items
+		conditions = {:resource_id => get_resource.id.to_s, :parent_id => self.id.to_s}
+		self.cart_items = Auth.configuration.cart_item_class.constantize.where(conditions).order(:created_at => 'asc')
+		
+		self.cart_items
+	end
+
+	def get_cart_items
+		self.cart_items 
+	end
+
+	## => 
+	def set_cart_price
+		self.cart_price = total_value_of_all_items_in_cart = get_cart_items.map{|c| c = c.price*c.quantity}.sum
+		self.cart_price
+	end
+
+	def get_cart_price
+		self.cart_price 
+	end
+
+	
+	def set_cart_payments
+		self.cart_payments = []
+		payments_made_to_this_cart = Auth.configuration.payment_class.constantize.find_payments(get_resource,self)
+		
+		payments_made_to_this_cart.each do |payment|
+			
+			self.cart_payments << payment
+		end
+		
+		self.cart_payments	 
+	end
+
+	def get_cart_payments
+		self.cart_payments 
+	end
+
+	def set_cart_paid_amount
+		total_paid = 0
+		payments = get_cart_payments
+		price = get_cart_price
+		payments.each do |payment|
+
+			total_paid += payment.amount if (payment.payment_success)
+		end
+		self.cart_paid_amount = total_paid
+		
+		self.cart_credit = self.cart_paid_amount
+		self.cart_paid_amount
+	end
+
+	## sum total of all payments made to the cart.
+	def get_cart_paid_amount
+		self.cart_paid_amount 
+	end
+
+	
+	def set_cart_pending_balance
+		self.cart_pending_balance = get_cart_price - get_cart_paid_amount
+	end
+
+	def get_cart_pending_balance
+		self.cart_pending_balance 
+	end
+
+
+	## takes all the cart items that are not accepted, and sums their "minimum_price_required_to_accept_cart_item" methods.
+	def set_cart_minimum_payable_amount
+
+		pending_or_unaccepted_cart_items = self.cart_items.select{|c| c.accepted.nil? || c.accepted == false}
+
+		accepted_cart_items = self.cart_items.select{|c| c.accepted == true}
+
+		if pending_or_unaccepted_cart_items.size > 0
+
+			self.cart_minimum_payable_amount = pending_or_unaccepted_cart_items.map{|c| c = c.minimum_price_required_to_accept_cart_item}.inject(:+)
+
+			## it can happen that he has payed somewhere halfway between the required amount and the full price of the cart -> see the tests.
+			self.cart_minimum_payable_amount = self.cart_pending_balance if (self.cart_pending_balance < self.cart_minimum_payable_amount)
+		
+		elsif accepted_cart_items.size > 0
+
+			self.cart_minimum_payable_amount = 0
+		
+		else
+
+		end
+
+
+		## we can add more stuff here like the credit score of the user.
+		## so that is a function of the cart_owner.
+		## so everytime a cart is fully paid, it can add to the credit score of the user, and that can further titrate this..
+		## so we have discount and all this.
+	end
+
+	## will do first check if the discount id exists, and then if it requires
+	def set_discount
+		begin
+			self.discount = Auth.configuration.discount_class.constantize.find(discount_id)
+			
+		rescue => e
+			
+		end
+	end
+
+	## initially is the same as cart_paid_amount, by calling debit, we can debit from credit, the costs of various items.
+	def get_cart_credit
+		self.cart_credit 
+	end
+
+	## debits the @amount from the cart credit.
+	## returns the current credit.
+	def debit(amount)
+		#puts "want to debit: #{amount}"
+		#puts "current credit is: #{self.cart_credit}"
+		self.cart_credit-=amount
+		
+		#puts "after debiting: #{self.cart_credit}"
+		self.cart_credit
+	end
+
+	############# PAYMENT BALANCE CONVENIENCE METHODS #############
+
+	## not fully paid, there is some amount to be taken from the customer yet.
+	def has_pending
+		get_cart_pending_balance > 0
+	end
+
+	## fully paid.
+	def fully_paid
+		get_cart_pending_balance == 0
+	end
+
+	## not paid a penny.
+	def not_paid_at_all
+		get_cart_pending_balance == get_cart_price
+	end
+
+
+
+	## returns the amount that needs to be refunded to the customer from this cart.
+	## @return : 0 if the pending_balance is greater than 0,otherwise returns the pending balance.
+	def refund_amount
+		return 0 unless get_cart_pending_balance < 0
+		return get_cart_pending_balance
+	end
+
+	## just replaces the cart_items with an array of cart_item_ids
+	## replaces the cart_payments with an array of cart_payment_ids
+	## then returns a hash with these two instead of the original values.
+	## @used_in : Shopping::PaymentConcern.set_receipt.
+	def prepare_receipt
+		cart_item_ids = cart_items.map{|c| c = c.id.to_s}
+		cart_payment_ids = cart_payments.map{|c| c = c.id.to_s}
+		receipt = self.attributes.merge({:cart_items => cart_item_ids, :cart_payments => cart_payment_ids})
+		receipt
+	end
+
+	## checks if there are any items in the cart.
+	## expected that prepare_cart has been called in advance.
+	## return[Boolean] true if there is one or more items in the cart
+	## @used_in: payment_concern validation cart_not_empty
+	def has_items?
+		get_cart_items.size > 0
+	end
+
+
+	def as_json(options={})
+		super.merge({:cart_items => self.cart_items, :cart_payments => self.cart_payments, :cart_price => self.cart_price, :cart_paid_amount => self.cart_paid_amount, :cart_pending_balance => self.cart_pending_balance, :cart_credit => self.cart_credit, :cart_minimum_payable_amount => self.cart_minimum_payable_amount})
+	end
+
+	def add_or_remove_validation
+		add_or_remove(add_cart_item_ids,1) if add_cart_item_ids
+		add_or_remove(remove_cart_item_ids,-1) if remove_cart_item_ids
+	end
+
+	##adds a validation error if the cart items could not be successfully added or removed.
+	##called from the controller.
+	##TODO: you should change this to be called before_validation instead, so that all code remains in the model.
+	def add_or_remove(item_ids,add_or_remove)
+	    item_ids.map {|id|
+	      begin
+	      	  #puts "the signed in resource is:"
+	      	  #puts self.signed_in_resource
+	      	  
+		      cart_item = Auth.configuration.cart_item_class.constantize.find_self(id,self.signed_in_resource)
+		      
+		      cart_item.signed_in_resource = self.signed_in_resource
+		      	
+		      puts "Add or remove is: #{add_or_remove}"
+
+		      resp = (add_or_remove == 1) ? cart_item.set_cart_and_resource(self) : cart_item.unset_cart
+		      	
+		      puts "unset cart is:#{resp.to_s}"
+		      
+		      
+		      resp
+	  	  rescue Mongoid::Errors::DocumentNotFound => error
+	  	  	#puts "--------------------------------------------DIDNT FIND THE CART ITEM"
+	  	  	#puts error.to_s
+	  	  	#puts "--------------------------------------------"
+	  	  	true
+	  	  end
+	    }
+	    #self.errors.add(:cart_items,"some cart items could not be added or removed successfully") if ((add_remove_results.size > 1) || (add_remove_results[0] == false))  
+	   
+	end
+
+	## used in initialize vars in cart_controlller_concern.
+	## override this method to allow an admin to also interact with all the actions of the controller.
+	def self.find_cart(cart_id,resource)
+		if cart_collection = self.where(:id => cart_id, :resource_id => resource_id)
+			cart_collection.size > 0 ? cart_collection.first : nil
+		else
+			nil
+		end
+	end
+
+	## @return[Boolean] true/false : override to decide how the cart decides if it can create discount coupons for its contents or not.
+	## the current implementation returns true if all items have been fully paid for.
+	def can_create_discount_coupons?
+		#return (self.cart_items.select{|c| c.accepted.nil? || c.accepted == false}.size == 0)
+		puts "CAME TO CAN CREATE DISCOUNT COUPONS."
+		prepare_cart
+
+		self.cart_pending_balance == 0		
+
+	end
+
+end