wordjelly-auth 0.0.1

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

@@ -0,0 +1,437 @@
+##NEED A SEPERATE MODEL THAT IMPLEMENTS IT
+module Auth::Concerns::Shopping::CartItemConcern
+
+
+
+	extend ActiveSupport::Concern
+	
+	include Auth::Concerns::Shopping::ProductConcern
+	include Auth::Concerns::OwnerConcern
+	include Auth::Concerns::EsConcern	
+
+
+	included do 
+
+		INDEX_DEFINITION = {
+			index_options:  {
+			        settings:  {
+			    		index: {
+					        analysis:  {
+					            filter:  {
+					                nGram_filter:  {
+					                    type: "nGram",
+					                    min_gram: 2,
+					                    max_gram: 20,
+					                   	token_chars: [
+					                       "letter",
+					                       "digit",
+					                       "punctuation",
+					                       "symbol"
+					                    ]
+					                }
+					            },
+					            analyzer:  {
+					                nGram_analyzer:  {
+					                    type: "custom",
+					                    tokenizer:  "whitespace",
+					                    filter: [
+					                        "lowercase",
+					                        "asciifolding",
+					                        "nGram_filter"
+					                    ]
+					                },
+					                whitespace_analyzer: {
+					                    type: "custom",
+					                    tokenizer: "whitespace",
+					                    filter: [
+					                        "lowercase",
+					                        "asciifolding"
+					                    ]
+					                }
+					            }
+					        }
+				    	}
+				    },
+			        mappings: {
+			          "shopping/cart_item" => {
+			          _all:  {
+				            index_analyzer: "nGram_analyzer",
+				            search_analyzer: "whitespace_analyzer"
+				        },
+			            properties: {
+			                name: {
+			                	type: "string",
+			                	index: "not_analyzed"
+			                },
+			                price: {
+			                	type: "double"
+			                },
+			                public: {
+			                	type: "string",
+			                	index: "not_analyzed",
+			                	include_in_all: false
+			                },
+			                resource_id: {
+			                	type: "string",
+			                	index: "not_analyzed"
+			                }
+			            }
+			        }
+			    }
+			}
+		}
+		
+
+
+
+		##PERMITTED
+		##the id of the product to which this cart item refers.
+		##permitted
+		field :product_id, type: String
+
+		##the user id who is buying this product.
+		##not permitted
+		field :resource_id, type: String
+		
+		##PERMITTED
+		##the number of this product that are being added to the cart
+		##permitted
+		field :quantity, type: Integer, default: 1
+
+		##PERMITTED
+		
+		##not permitted
+		field :parent_id, type: String
+
+		##PERMITTED
+		##is it being discounted, can be from 0 -> 100 percent discount
+		##not permitted
+		field :discount, type: Float
+
+		##PERMITTED
+		##discount code to offer discounts
+		##permitted
+		field :discount_code, type: String
+
+
+		###################### product status fields ##################
+		## one of the stages mentioned below.
+		field :accepted, type: Boolean
+
+
+		################### which payment led to this cart item being accepted
+
+		field :accepted_by_payment_id, type: String
+
+		### a percentage of the total price , at which to accept the order.
+		## the current item is accepted only if (price*accept_order_at_percentage_of_price) <= available credit
+		field :accept_order_at_percentage_of_price, type: Float, default: 1.00
+
+
+		before_destroy do |document|
+			
+			if !skip_callback?("before_destroy")
+				if document.accepted == true
+					false
+				end
+			end
+		end
+
+=begin
+		after_validation do |document|
+			if !skip_callback?("after_validation")
+				document.refresh_accepted
+			end
+		end
+=end
+		before_validation do |document|
+			if !skip_callback?("before_validation")
+				document.refresh_accepted
+			end
+		end
+
+
+		before_create do |document|
+			document.assign_product_attributes
+		end
+
+		
+
+		validate :user_cannot_change_anything_if_payment_accepted
+		validate :product_id_exists?
+
+		before_save do |document|
+			document.public = "no"
+		end
+
+			
+
+	end
+
+
+	module ClassMethods
+
+		
+
+		##used in cart_item_controller_concern#index
+		## if there is a resource, will return all cart items with that resource id.
+		## if there is no resource, will return all cart items with a nil rsource.
+		def find_cart_items(options)
+			conditions = {:resource_id => nil, :parent_id => nil}
+			conditions[:resource_id] = options[:resource].id.to_s if options[:resource]
+			Auth.configuration.cart_item_class.constantize.where(conditions)
+		end
+
+	end
+
+	### this is an internal method, cannot be set by admin or anyone, it is done after validation, since it is not necessary for someone to be admin, even the user can call refresh on the record to get the new state of the acceptence.
+	## just checks if the accepted by payment id exists, and if yes, then doesnt do anything, otherwise will update the cart item status as false.
+	def refresh_accepted
+		
+		if self.accepted_by_payment_id
+
+			begin
+				payment = Auth.configuration.payment_class.constantize.find(self.accepted_by_payment_id)
+				## check if this payment status is approved or not.
+				## if the payment status is approved, then dont do anything to the cart item.(we don't retro check payment to cart item.)
+				## if the payment status is not approved, then make the cart item accepted as false.
+				if (payment.payment_status.nil? || payment.payment_status == 0)
+					self.accepted = false
+				end
+			rescue Mongoid::Errors::DocumentNotFound
+				
+				self.accepted = false
+			end
+		end
+
+		## if it doesnt have a cart, then it cannot be accepted.
+		if self.parent_id.nil?
+			self.accepted = false 
+			self.accepted_by_payment_id = nil
+		end
+
+
+		## we should ideally do this in the payment.
+		## so that it can actually do what it usually does.
+		## we can set say refresh_payment.
+		## but it may not pay for everything.
+		## but that is the only way through.
+		## so if the payment is accepted then the cart_items_accepted will not be triggered.
+		## but if we update the first payment, then we can do it.
+		## basically take the last payment and update it, force calling the set_cart_items_accepted
+		## and suppose they are not successfully accepted, then what about validation errors ?
+		## so that will have to be skipped in that case.
+	end
+	
+	## called from payment#update_cart_items_accepted
+	## sets accepted to true or false depending on whether the cart has enough credit for the item.
+	## does not SAVE.
+	def set_accepted(payment,override)
+		
+		#puts "the existing self accepted is:"
+		#puts self.accepted.to_s
+
+		if cart_has_sufficient_credit_for_item?(payment.cart) 
+			
+			## is it already accepted?
+			if self.accepted
+			
+				return true
+			else
+			
+				self.accepted = true
+			end
+		else	
+			self.accepted = false
+		end
+		
+		
+
+		
+		
+		## so that it doesnt do refresh_cart_item
+		self.skip_callbacks = {:before_validation => true}
+		
+		## this will first call validate 
+		self.validate
+
+		## if the accepted is being set as false, then it should be set like that, where it was true?
+		## 
+		self.accepted_by_payment_id = self.accepted ? payment.id.to_s : nil
+
+		
+		## if it hasnt changed, dont query and update anything.
+		
+		return true unless self.accepted_changed?
+		
+		if self.errors.full_messages.empty?
+			
+			doc_after_update = 
+
+			Auth.configuration.cart_item_class.constantize.
+			where({
+				"$and" => [
+					"accepted" => {
+						"$nin" => [self.accepted]
+					},
+					"_id" => BSON::ObjectId(self.id.to_s)
+				]
+			}).
+			find_one_and_update(
+				{
+					"$set" => {
+						"accepted" => self.accepted,
+						"accepted_by_payment_id" => self.accepted_by_payment_id
+					}
+				},
+				{
+					:return_document => :after
+				}
+			)
+
+			puts "the doc after update is:"
+			puts doc_after_update.attributes.to_s
+
+			return false unless doc_after_update
+			return false if doc_after_update.accepted != self.accepted
+			return true
+		else
+			return false
+		end
+	end
+	
+	## debits an amount from the cart equal to (item_price*accept_order_at_percentage_of_price)
+	## the #debit function returns the current cart credit.
+	## return true or false depending on whether , after debiting there is any credit left in the cart or not.
+	def cart_has_sufficient_credit_for_item?(cart)
+		puts "cart credit is: #{cart.cart_credit}"
+		cart_has_credit = cart.debit((self.accept_order_at_percentage_of_price*self.price)) >= 0
+		puts "cart has credit is: #{cart_has_credit.to_s}"
+		cart_has_credit
+	end
+
+	
+
+	## unsets the cart item , if it has not been accepted upto now.
+	## assume that a payment was made, this cart item was updated wth its id as success, but some others were not, so the payment was not saved. but this item has got accepted as true.
+	## so whether or not the payment that was made exists, we dont allow the cart to be unset.
+	## however in case the signed_in_resource is an admin -> it is allowed to unset the cart, whether the item is already accepted or not.
+	## @used_in : cart_concern # add_or_remove
+	## @return[Boolean] : result of saving the cart item.
+	def unset_cart
+		if self.signed_in_resource.is_admin?
+			self.parent_id = nil
+			self.accepted = nil
+			self.accepted_by_payment_id = nil
+		else
+			if (self.accepted.nil? || self.accepted == false)
+				self.parent_id = nil 
+				self.accepted = nil
+				self.accepted_by_payment_id = nil
+			end
+		end
+		rs = self.save
+		puts self.errors.full_messages
+		rs
+	end
+
+
+	## assigns a cart and resource, resource_id to the cart_item.
+	## @returns : true or false depending on whether the cart item was successfully saved or not.
+	## @used_in : cart_controller_concern # add_or_remove
+	def set_cart_and_resource(cart)
+		return true if self.parent_id
+		return false if (owner_matches(cart) == false)
+		self.parent_id = cart.id.to_s
+		self.accepted = nil
+		self.accepted_by_payment_id = nil
+		self.save
+	end
+
+	#######################################################
+	##
+	## VALIDATIONS
+	##
+	#######################################################
+
+	## as long as it is not the accepted_by_payment id that has gone from nil to something, if anything else in the cart_item has changed, and the user is not an admin, and there is an accepted_by_payment id, then the error will be triggered.
+	## these conditions are applicable to the gateway payment, or any other payment also.
+	## and this has happened because the same item was pushed back in.
+	def user_cannot_change_anything_if_payment_accepted
+		if !self.signed_in_resource.is_admin?
+
+			## THE USER CAN : UPDATE A PAYMENT TO MAKE THIS CART ITEM ACCEPTED / REJECTED.
+			## if the payment status is changing, let it be, because this is an internal updated.
+
+			return if self.new_record?
+
+			puts "accepted changed? #{self.accepted_changed?.to_s}"
+
+			return if self.accepted_changed? 
+
+			## THE USER CAN REMOVE THE CART ITEM FROM A CART, AS LONG AS IT HAS NOT BEEN ACCEPTED.
+			## if the item is being removed from the cart, while it has not yet been accepted.
+			return if self.parent_id_changed? && self.parent_id.nil? && (self.accepted.nil? || self.accepted == false)
+
+
+			## THE USER CAN CHANGE ANY OTHER STUFF ALSO AS LONG AS THE ACCEPTED IS NIL OR FALSE
+			return if (self.accepted.nil? || self.accepted == false)
+
+
+			## THE LAST SITUATION IS WHEN THE ITEM WAS ACCEPTED, AND NOW WE ARE UPDATING IT AS FALSE, AND ALSO THE PAYMENT ID AS NIL, THIS IS ALLOWED, BECAUSE IT IS WHAT HAPPENS IF THE ACCEPTING PAYMENT IS NIL OR ITS STATUS IS NOT APPROVED.
+
+
+
+			## otherwise, the updated_by_payment_id, changes only when we are doing a gateway payment or any payment actually.
+			self.errors.add(:quantity,"you cannot change this item since payment has already been made")
+			# if self.accepted_by_payment_id && self.changed? && !self.new_record? && !(self.accepted_by_payment_id_changed? && self.accepted_by_payment_id_was.nil?)
+		end
+	end
+
+	def product_id_exists?
+		begin
+			Auth.configuration.product_class.constantize.find(self.product_id)
+		rescue
+			self.errors.add(:product_id,"this product id does not exist")
+		end
+	end
+
+	## before creating the document assigns attributes defined in the def #product_attributes_to_assign, to the cart item.
+	def assign_product_attributes
+		begin
+			if self.product_id
+	 			if product = Auth.configuration.product_class.constantize.find(product_id)
+	 				product_attributes_to_assign.each do |attr|
+	 					## only if the present attribute is nil, then we assign it from the product.
+	 					if self.respond_to? attr.to_sym
+		 					if self.send("#{attr}").nil?
+		 						self.send("#{attr}=",product.send("#{attr}"))
+		 					end
+	 					end
+	 				end
+	 			end
+	 		end
+	 	rescue
+
+	 	end
+	end
+
+	def product_attributes_to_assign
+		["name","price"]
+	end
+
+	## this is got by multiplying the price of the cart item by the minimum_acceptable at field.
+	def minimum_price_required_to_accept_cart_item
+		price*accept_order_at_percentage_of_price
+	end
+
+	def as_indexed_json(options={})
+	 {
+	 	name: name,
+	    price: price,
+	    resource_id: resource_id,
+	    public: public
+	 }
+	end 
+
+end

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

@@ -0,0 +1,482 @@
+=begin
+
+### sample discount object:
+
+id : whatever
+product_ids : []
+count : 123
+needs_verification : true/false
+discount_percentage : 
+discount_amount :
+origin_cart_id : whatever
+pending_verification : [cart_id => date_time]
+used_by : [cart_id => date/time]
+
+other_fields will be added from owner_concern.
+
+*if both percentage and amount are present, then amount will be used.
+
+*when a payment is made => check if cart fully paid => show option to create coupons,enter discount amount/percentage,enter needs verification or not => if yes => create a discount_object with those details
+
+*now when someone finds this discount object => give link to create a cart directly with it,(there should be an action on cart_item called bulk_create => there will first create the cart items => then redirect_to create_cart => with those cart_items, and also the discount code)
+
+*now in prepare_cart =>
+if dicount_code is provided:
+
+1.  check that the code id exsits
+2.  check how many have been utilized
+3.  if verification is necessary then send a message to the verifier, or in case the cart is being proxied, then the verification is bypassed => when he updates the discount object as verified(for that user id) 
+4. if verification is not necessary , add the user to the discount object -> as those who used this.
+
+*now if no verification is needed or after verification incorporate the discount_amount in the calculation of the cart_price.
+
+*show the modified cart price.
+
+*let him make a payment, he can make with amount as 0, with cash. gateway payment is disabled if pending balance is 0.
+
+*the payment is instantly accepted if pending_balance is zero.
+
+=end
+
+module Auth::Concerns::Shopping::DiscountConcern
+
+	extend ActiveSupport::Concern
+		
+	include Auth::Concerns::ChiefModelConcern
+	include Auth::Concerns::OwnerConcern
+	
+	included do 
+
+		####################################################
+		##
+		## FIELDS
+		##
+		####################################################
+
+		## the product ids that this discount object can contain.
+		field :product_ids, type: Array, default: []
+		
+		## whether this discount object needs verification by the creator of the cart mentioned below, default is false
+		field :requires_verification, type: Boolean, default: false
+
+		## the total number of times this discount object can be used.
+		field :count, type: Integer
+		
+		## the amount in plain float that this discount object provides
+		field :discount_amount, type: Float, default: 0.0
+		
+		## the amount in percentage terms for discount, will be applied to the cart price.
+		field :discount_percentage, type: Float, default: 0.0
+		
+		## the original cart on which this discount object was created from.
+		field :cart_id, type: String
+
+		## the cart is internally set.
+		attr_accessor :cart
+		
+		field :verified, type: Array, default:[]
+
+		field :pending, type: Array, default: []
+
+		field :declined, type: Array, default: []
+			
+		## the hash of user ids who have used this discoutn code
+		## key => [String] user id
+		## value => [Integer] number of times used.
+		field :used_by_users, type: Array, default: []
+
+
+		## these attributes are used in the update action , to add the ids that should be marked as verified or declined.
+
+		attr_accessor :add_verified_ids
+
+		attr_accessor :add_declined_ids 
+		
+	#########################################################
+	##
+	## VALIDATIONS
+	##
+	#########################################################
+
+		validate :cart_exists, :unless => :admin_and_cart_id_absent
+
+		validate :one_discount_object_per_cart, if: Proc.new{|a| a.cart_id }
+
+		validate :cart_has_multiples_of_all_items, if: Proc.new{|a| a.cart_id }
+
+		validate :cart_can_create_discount_coupons, if: Proc.new { |a| a.cart_id }
+
+		validate :user_can_create_discount_coupons
+
+		validates :discount_percentage, numericality: { greater_than_or_equal_to: 0.0, less_than_or_equal_to: 100.0 }, if: Proc.new {|a| a.discount_percentage_changed?}
+
+		validates :discount_amount, numericality: {greater_than_or_equal_to: 0.0}, if: Proc.new {|a| a.discount_amount_changed?}
+
+		validate :discount_percentage_permitted, if: Proc.new {|a| a.discount_percentage_changed? && !a.admin_and_cart_id_absent}
+
+
+		## SHOULD BE TESTED.
+		## the maximum discount amount is not validated in case its an admin and the cart id is not provided
+		validate :maximum_discount_amount, if: Proc.new {|a| (a.discount_amount_changed? || a.discount_percentage_changed?) && a.cart_id}
+
+		## does not validate for product ids if the user is admin, and the cart is not present.
+		validates :product_ids, presence: true, if: Proc.new{|a| a.cart_id}
+
+		## validates for count irrespective.
+		validates :count, presence: true
+
+	#########################################################
+	##
+	##
+	## CALLBACKS
+	##
+	##
+	#########################################################
+
+		before_validation do |document|
+
+			document.set_cart
+			
+			if document.new_record?
+
+				if document.cart
+					## assign the products internally.
+					document.product_ids = document.cart.cart_items.map{|citem| citem = citem.product_id}
+
+					## assign count
+					document.count = document.cart.cart_items.first.quantity
+				else
+					## whatever was sent in the params.
+					## the count param is permitted only if the user is an admin.
+				end				
+
+			end
+
+			## if either the discount amount or percentage is nil, set it to 0.
+
+			document.discount_percentage = 0 if document.discount_percentage.nil?
+
+			document.discount_amount = 0 if document.discount_amount.nil?
+
+			## what is the maximum permissible amount?
+
+
+			## give the add verified and declined ids, default values.
+
+			document.add_verified_ids ||= []
+			document.add_declined_ids ||= []
+
+			
+
+			document.pending = document.pending - ([document.add_declined_ids + document.add_verified_ids].flatten)
+
+			document.verified = document.verified + document.add_verified_ids
+
+			document.declined = document.declined + document.add_declined_ids
+
+		end
+
+
+		## all discounts are public to be searched.
+		before_save do |document|
+			self.public = "yes"
+		end
+
+		
+
+	end
+
+	module ClassMethods
+
+		
+
+
+
+		
+		def find_discounts(options)
+			conditions = {:resource_id => nil}
+			conditions[:resource_id] = options[:resource].id.to_s if options[:resource]
+			Auth.configuration.discount_class.constantize.where(conditions)
+		end
+
+
+		
+
+		## @called_from : payment_concern.rb
+		## @param[String] payment_id 
+		## @return[BSON::Document] the document after the update or nil, in case nothing was updated.
+		def add_pending_discount(payment_id,discount_object_id)
+			Auth.configuration.discount_class.constantize.
+			where({
+				"$and" => [
+					{
+						"verified" => {
+							"$ne" => payment_id
+						}
+					},
+					{
+						"pending" => {
+							"$ne" => payment_id
+						}
+					},
+					{
+						"declined" => {
+							"$ne" => payment_id
+						}
+					},
+					{
+						"_id" => BSON::ObjectId(discount_object_id)
+					}
+				]
+			})
+			.find_one_and_update(
+				{
+					"$push" => {
+						:pending => payment_id
+					}
+				},
+				{
+					:return_document => :after	
+				}
+			)
+		end
+
+		## @called_from : payment_concern.rb
+		## @param[String] payment_id : the id of the payment
+		## @param[String] discount_object_id : the id of the discount object
+		## @return[Integer] payment_status: returns the status that should be set for the payment.
+		## @working: this def will match a discount object with the provided, id, and then filter the resulting fields to include any of the three arrays "pending","verified" or "declined" as long as they contain the payment id. It will return a payment_status that is to be set for the payment, based on teh result. If it finds that none of the arrays contain the payment id, then it will do a find and update to add the payment_id to the pending_array.
+
+		def get_payment_status(payment,discount_object_id)
+
+
+
+			results = Auth.configuration.discount_class.constantize.collection.aggregate([
+
+				{
+					"$match" => {
+					"_id" => BSON::ObjectId(discount_object_id)
+					}
+				},
+				{
+					"$project" => {
+						"verified" => {
+							"$filter" => {
+			                 	"input" => "$verified",
+			                 	"as" => "verified",
+			                 	"cond" => { 
+			                 		"$eq" => 
+			                 			[ "$$verified", payment.id.to_s 
+			                 			] 
+			                 	}
+			            	}
+						},
+						"pending" => {
+							"$filter" => {
+			                 	"input" => "$pending",
+			                 	"as" => "pending",
+			                 	"cond" => { 
+			                 		"$eq" => 
+			                 			[ "$$pending", payment.id.to_s 
+			                 			] 
+			                 	}
+			            	}
+						},
+						"declined" => {
+							"$filter" => {
+			                 	"input" => "$declined",
+			                 	"as" => "declined",
+			                 	"cond" => { 
+			                 		"$eq" => 
+			                 			[ "$$declined", payment.id.to_s 
+			                 			] 
+			                 	}
+			            	}
+						}
+					}
+				}
+
+			])
+
+			results_as_mongoid_docs = []
+
+			results.each do |r|
+				results_as_mongoid_docs << Mongoid::Factory.from_db(Auth.configuration.discount_class.constantize,r)
+			end
+
+			if results_as_mongoid_docs.empty?
+				## this discont object does not exist
+				## return 0
+				puts "------------------------there was no such discount object-----------------------------"
+				0
+			elsif !results_as_mongoid_docs[0].verified.empty?
+				## it has been verified
+				## so return 1
+				puts "it has been verified"
+				1
+			elsif !results_as_mongoid_docs[0].declined.empty?
+				## it has been declined
+				## so return 0
+				puts "it has been declined"
+				0
+			elsif !results_as_mongoid_docs[0].pending.empty?
+				## it has not yet been acted on
+				## so return nil
+				puts "it is still pending."
+				nil 
+			else
+				## it has to still be added
+				## so in this case also the payment status will remain nil
+				## but this has to indicate that it should be still added.
+				## execute a find_and_update, where the payment id is not present in any of the three arrays, and then add it to the pending array.
+				puts "came to add pending discount."
+				doc_after = self.add_pending_discount(payment.id.to_s,discount_object_id)
+				return 0 unless doc_after
+				return nil
+			end
+
+		end
+
+
+		## @called_from : payment_concern.rb
+		## decrements the count by 1
+		## if enforce_single_use is passed as false, a given user can utilize the discount any number of times.
+		## checks that the count of the discount_object is greater than one before doing this.
+		## returns the updated document after the update is complete.
+		## if the document returned afterwards is nil, then it means that the payment_status will be set as failed.
+		## otherwise, set the payment_status as 1. 
+		def use_discount(discount,payment,enforce_single_use = true)
+
+			## so we can check here if the cart has any items pending, before running this.
+			## so we can only use the discount if all cart items are accepted
+			if discount.cart_id
+				discount.cart_can_create_discount_coupons
+			end
+
+			if discount.errors.full_messages.empty?
+			
+				query_hash = {
+					:_id => discount.id.to_s,
+					:pending => {"$ne" => payment.id.to_s},
+					:declined => {"$ne" => payment.id.to_s},
+					:count => {"$gte" => 1}
+				}
+				if enforce_single_use == true
+					query_hash[:used_by_users => {"$ne" => payment.resource_id.to_s}]
+				end
+				updated_doc = Auth.configuration.discount_class.constantize.where(query_hash).find_one_and_update({
+						"$inc" => {
+							:count => -1
+						},
+						"$push" => {
+							:used_by_users => payment.resource_id.to_s
+						}
+					},
+					{
+						:return_document => :after
+					}
+				)
+
+				return 0 if updated_doc.nil?
+				return 1
+
+			else
+				return 0
+			end
+
+		end
+
+
+
+	end
+
+	#######################################################
+	##
+	##
+	## CALLBACK METHODS.
+	##
+	##
+	#######################################################
+
+	def set_cart
+		begin
+	
+			if self.cart_id
+
+				self.cart = Auth.configuration.cart_class.constantize.find(self.cart_id)
+				
+				
+				self.cart.prepare_cart
+
+			end
+
+		rescue => e
+			puts e.to_s
+		end
+	end
+
+	#######################################################
+	##
+	##
+	## VALIDATION METHODS.
+	##
+	##
+	#######################################################
+
+	def one_discount_object_per_cart
+		discount_coupons_with_cart = 
+		Auth.configuration.discount_class.constantize.where(:cart_id => self.cart_id.to_s)
+		
+		count = self.new_record? ? 0 : 1
+
+		self.errors.add(:cart,"you can only create one discount coupon per cart") if discount_coupons_with_cart.size > count
+		
+	end
+
+
+	def cart_exists
+		self.errors.add(:cart,"the cart does not exist") unless self.cart
+	end
+
+	## this should only be if a cart id is provided.
+	def cart_can_create_discount_coupons
+		set_cart unless self.cart
+		self.errors.add(:cart, "you cannot create discount coupons on this cart") unless cart.can_create_discount_coupons? 
+	end
+
+
+	def user_can_create_discount_coupons
+		self.errors.add(:cart,"you cannot create discount coupons") unless get_resource.can_create_discount_coupons?
+	end
+
+	
+	def cart_has_multiples_of_all_items
+		self.errors.add(:cart,"the cart must have equal numbers of all items") if self.cart.cart_items.select{|c| c.quantity != self.count}.size > 0
+	end
+
+
+	def discount_percentage_permitted
+		self.errors.add(:discount_percentage,"you cannot set a discount percentage") if self.discount_percentage > 0
+	end
+
+
+	def maximum_discount_amount
+		## cannot exceed the sum of all cart items prices, we mean one multiple of the cart item prices.
+		self.errors.add(:discount_amount,"the discount amount cannot exceed:") if self.discount_amount > (self.cart.cart_items.map{|c| c = c.price}.inject(:+))
+	end
+
+
+
+	## returns true if:
+	## 1. the user is an admin
+	## 2. there is no cart id.
+	def admin_and_cart_id_absent
+		#puts "signed in resource is:"
+		#puts signed_in_resource.to_s
+		#puts "is it an admin?"
+		#puts signed_in_resource.is_admin?
+		#puts "cart id is nil: #{cart_id.nil?}"
+		signed_in_resource.is_admin? && cart_id.nil?
+	end
+
+end