wordjelly-auth 1.0.4 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a718a6cf6f3777261fd7e238201e3136394bd580
-  data.tar.gz: 85aa506e330312e5b1bfe0ed8d2e5e501e97685e
+  metadata.gz: 19a46d7a74a79c55717dd9c3eb1e9a9bfa2f59b0
+  data.tar.gz: 43690d96180781c8c12bfb818bf5c7a61e8fb59e
 SHA512:
-  metadata.gz: 59aca114451a99d6ea926a7fa4765fc73c2b7208471845d3fb4e57dbf8bb8848d57a7c85ee3f00931304dc668913081df3be92d21c19358d9def6aa398142613
-  data.tar.gz: 583172d9e331b87c85addebb0cc2f943ad776494776423c2c3f320cad3d70ef112307adbd34664767c806eb537d71b57913a698dff833595fc52b45e588441ec
+  metadata.gz: bf2eb9ea412904b566efaad965adfcb8fe32409ea337187b6ec5985d57c99e9a93d6f8be165f128bc0a6e034b3ae2b948929acc08dcbe0ed154b9fedbb65d061
+  data.tar.gz: 3f428c140567a30d25e20722caed25b7e09b18b24d2f875cebef0acf204705a8b782093b483b6c0a9f4781df46f4e6b19f92ed5895cf312cdcd37c462e2366d5

data/app/controllers/auth/clients_controller.rb

@@ -24,6 +24,11 @@ module Auth
       respond_with @client
     end
 
+    ## how are we going to get the client id exactly?
+    ## that's the basic problem
+    ## thereafter we can do the rest.
+    
+
     # GET /clients/new
     def new
       #@client = Client.new
@@ -86,6 +91,9 @@ module Auth
 
       ## if the resource_signed_in is an admin, just return
       ## otherwise if the user's id is not the same as the id passed in, then throw a not_found.
+      ## this means that only if the guy is an admin , then this can work.
+      ## otherwise it cannot work
+      ## i think this has to be done from the web app.
       def verify_client_belongs_to_user
         return if @resource_for_web_app.is_admin?
         not_found("client does not belong to user") if @resource_for_web_app.id.to_s != params[:id]

data/app/controllers/auth/profiles_controller.rb

@@ -11,12 +11,13 @@ class Auth::ProfilesController < Auth::ApplicationController
 	before_action :initialize_vars, TCONDITIONS
 	before_action :is_admin_user, :only => [:set_proxy_user]
 	
-	
 	def initialize_vars
+		puts "---------------------------------------------------"
 		@resource_params = {}
 		@profile_resource = nil
 		@all_params = permitted_params.deep_symbolize_keys
 		
+		
 	  	if collection = @all_params[:resource]
 	  		
 	  		if Auth.configuration.auth_resources[collection.singularize.capitalize]

data/app/helpers/auth/clients_helper.rb

@@ -1,4 +1,6 @@
 module Auth
   module ClientsHelper
+
+
   end
 end

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

@@ -117,6 +117,23 @@ module Auth::Concerns::Shopping::ProductConcern
 
 	module ClassMethods
 
+		## so we have completed the rolling n minutes.
+		def add_to_previous_rolling_n_minutes(minutes,origin_epoch,cycle_to_add)
+
+			## get all the minutes less than that.
+			rolling_n_minutes_less_than_that = minutes.keys.select{|c| c < origin_epoch}			
+
+			end_min = rolling_n_minutes_less_than_that.size < Auth.configuration.rolling_minutes ? rolling_n_minutes_less_than_that.size : Auth.configuration.rolling_minutes
+
+			end_min = end_min - 1
+
+			end_min = end_min > 0 ? end_min : 0
+			rolling_n_minutes_less_than_that[0..end_min].each do |epoch|
+				minutes[epoch].cycles << cycle_to_add
+			end
+
+		end
+
 		## minutes : {epoch => minute object}
 		def schedule_cycles(minutes,location_id,conditions = {})
 
@@ -124,44 +141,42 @@ module Auth::Concerns::Shopping::ProductConcern
 
 			products = Auth.configuration.product_class.constantize.where(conditions) if !conditions.blank?
 
-
-			minutes.keys.each do |minute|
-				#puts "doing minute: #{minute}"
+			minutes.keys.each do |epoch|
+				
 				products.each do |product|
-					#puts "doing product: #{product}"
+				
 					all_cycles_valid = true
 					product.cycles.each do |cycle|
-						#puts "doing cycle : #{cycle}"
-						all_cycles_valid = cycle.requirements_satisfied(minute + cycle.time_since_prev_cycle.minutes*60,location_id)
-						#puts "all cycles valid becomes ------------------------------------------------------------- #{all_cycles_valid.to_s}"				
+				
+						all_cycles_valid = cycle.requirements_satisfied(epoch + cycle.time_since_prev_cycle.minutes*60,location_id)
+								
 					end
+
+					## just because the cycles are valid, it means we have workers, but how many?
+					## that also has to be returned by the cycle validity statements
+
 					if all_cycles_valid == true
+						cycle_chain = []
 						product.cycles.each do |cycle|
-							minute_at_which_to_add = minute + cycle.time_since_prev_cycle.minutes*60
-							#puts "minute at which to add is: #{minute_at_which_to_add}"
-							#puts minutes.keys.to_s
-							if minutes[minute_at_which_to_add]
+							epoch_at_which_to_add = epoch + cycle.time_since_prev_cycle.minutes*60
+							cycle_to_add = cycle.dup
+							cycle_to_add.origin_epoch = epoch_at_which_to_add
+							cycle_to_add.cycle_chain = cycle_chain
+							if minutes[epoch_at_which_to_add]
+								
+								add_to_previous_rolling_n_minutes(minutes,epoch_at_which_to_add,cycle_to_add)
 
-								minutes[minute_at_which_to_add].cycles << cycle
-
-								#puts "these are the cycles---------"
-								#puts minutes[minute_at_which_to_add].cycles.to_s
+								minutes[epoch_at_which_to_add].cycles << cycle_to_add
 
+								cycle_chain << cycle_to_add.id.to_s
 							else
-								raise "necessary minute not in range."
+								#raise "necessary minute not in range."
 							end
 						end
 					end
 				end
 			end
-
-			#puts minutes.to_s
-			
 			minutes
-
 		end
-
 	end
-
 end
-

data/app/models/auth/work/cycle.rb

@@ -2,6 +2,11 @@ class Auth::Work::Cycle
 		
 	include Mongoid::Document
 
+	## for aggs.
+	attr_accessor :cycle_index
+
+	field :origin_epoch
+
 	embedded_in :minutes, :class_name => "Auth::Work::Minute", :polymorphic => true
 
 	embedded_in :products, :class_name => Auth.configuration.product_class, :polymorphic => true
@@ -9,11 +14,24 @@ class Auth::Work::Cycle
 	embeds_many :templates, :class_name => "Auth::Work::Template"
 
 	## each cycle will have a limit
-	field :capacity, type: Integer
+	field :capacity, type: Integer, default: 0
+
+	## there will have to be another field, saying workers who can do it, and entities who can do it.
+	field :workers_available, type: Array
+
 
 	## it will have a list of workers to whom it is assigned
 	field :workers_assigned, type: Array
+
 	
+	## the available entities, these are set at the time of creating the minutes.
+	field :entities_available, type: Array
+
+
+	## the entities assigned, finally.
+	field :entities_assigned, type: Array
+
+
 	## it has to have a priority score
 	field :priority, type: Float
 
@@ -36,9 +54,11 @@ class Auth::Work::Cycle
 =end
 	field :requirements, type: Hash
 
-
 	field :cycle_code, type: String
 
+	## the ids of the related cycles.
+	field :cycle_chain, type: Array
+
 	before_save do |document|
 		document.cycle_code = BSON::ObjectId.new.to_s unless document.cycle_code
 	end
@@ -70,81 +90,134 @@ class Auth::Work::Cycle
 	end
 
 	def requirements_satisfied(epoch,location_id)
-		#begin
-			#puts "came to requirements satisfied"
-			Auth.configuration.location_class.constantize.all.each do |l|
-				puts l.attributes.to_s
-			end
-			location = Auth.configuration.location_class.constantize.find(location_id)
-			
-			#puts "location found :#{location}"
-			#puts "epoch : #{epoch}, and location id: #{location_id}"
-			time_for_query = Time.at(epoch)
-			applicable_schedules = Auth::Work::Schedule.collection.find({
-				"$and" => [
-					{
-						"location_id" => location_id
-					},
-					{
-						"start_time" => {
-							"$lte" => time_for_query
-						}
-					},
-					{
-						"end_time" => {
-							"$gte" => time_for_query
-						}
+		
+		#puts "came to requirements satisfied"
+		Auth.configuration.location_class.constantize.all.each do |l|
+			puts l.attributes.to_s
+		end
+		location = Auth.configuration.location_class.constantize.find(location_id)
+		
+		#puts "location found :#{location}"
+		#puts "epoch : #{epoch}, and location id: #{location_id}"
+		time_for_query = Time.at(epoch)
+		applicable_schedules = Auth::Work::Schedule.collection.find({
+			"$and" => [
+				{
+					"location_id" => location_id
+				},
+				{
+					"start_time" => {
+						"$lte" => time_for_query
 					}
-				]
-			})
-			
+				},
+				{
+					"end_time" => {
+						"$gte" => time_for_query
+					}
+				}
+			]
+		})
+		
 
 
-			#puts "applicable schedules:"
-			#puts applicable_schedules.to_s
+		#puts "applicable schedules:"
+		#puts applicable_schedules.to_s
 
-			applicable_schedules = applicable_schedules.to_a
+		applicable_schedules = applicable_schedules.to_a
 
-			return false if (applicable_schedules.blank? || applicable_schedules.size == 0)
-			
-			#puts "there are applicable schedules"
+		return false if (applicable_schedules.blank? || applicable_schedules.size == 0)
+		
+		#puts "there are applicable schedules"
 
-			req = self.requirements.deep_dup
-			#puts "req are:"
-			#puts req.to_s
-			
-			applicable_schedules.map!{|c| c = Mongoid::Factory.from_db(Auth::Work::Schedule,c)}
+		req = self.requirements.deep_dup
+		#puts "req are:"
+		#puts req.to_s
+		
+		applicable_schedules.map!{|c| c = Mongoid::Factory.from_db(Auth::Work::Schedule,c)}
 
-			applicable_schedules.each do |schedule|
-				
-				schedule_for_object = schedule.for_object_class.constantize.find(schedule.for_object_id)
-				
-				#puts "schedule for object is: #{schedule_for_object}"
+		## here basically suppose you have n applicable schedules.
+		## you need to combine them into cycle categories and see how many combinations you get out of it.
 
-				## so here the thing is that it can have many cycle types.
+		available_resources = {}
 
-				schedule_for_object.cycle_types.keys.each do |type|
-					req[type] = req[type] - 1 if req[type]
-				end
-					
-				#puts "req is: #{req}"
+		applicable_schedules.each do |schedule|
+			
+			schedule_for_object = schedule.for_object_class.constantize.find(schedule.for_object_id)
+			
+			schedule_for_object.cycle_types.keys.each do |type|
+				#req[type] = req[type] - 1 if req[type]
+				available_resources[type] = 0 unless available_resources[type]
+				available_resources[type]+=1
+			end
 
+		end
+		
+		## now we have certain type counts necessary for this cycle.
+		## now how to return the available capacity.
+		#k = req.values.uniq
+		#return true if ((k[0] == 0) && (k.size == 1))
+		#return false
+
+		## so how to split into multiples ?
+		## just do it sequentially.
+		failed = false
+		while failed == false
+			self.requirements.keys.each do |req|
+				failed = true unless available_resources[req]
+				break unless available_resources[req]
+				failed = true if available_resources[req] < self.requirements[req]
+				break if available_resources[req] < self.requirements[req]
+				available_resources[req] -= self.requirements[req]
 			end
-				
-			k = req.values.uniq
+			self.capacity+=1 if failed == false
+		end
+	
+		## now this becomes the cycle capacity.
+		## but only for the origin minute.
+		
+		return self.capacity > 0
 
+	end
 
-			return true if ((k[0] == 0) && (k.size == 1))
-			return false
 
-		#rescue
+	###########################################################
+	##
+	##
+	## BOOKINGS.
+	##
+	##
+	###########################################################
+
+	
 
-		#	raise "location id provided to cycle does not exist"
+	def after_book
+		Auth::Work::Minute.get_affected_minutes(self.start_time,self.end_time,self.workers_assigned,self.entities_assigned).each do |minute|
 		
-		#end
+			## each cycle has its index as cycle_index
+			## this is used to update the cycles.
+		
+		end
+	end
 
+	def book
+		after_book
 	end
 
+	
+	## so the search criteria is 
+	## where entity_ids == [n1,n2,n3], or worker_ids= [y1,y2,y3]
+	## range is such that
+	## if (end time or start time) of any cycle is (from this minute -> time of end of this cycle)
+	## or if start time <= this minute, and end time is  >= minute of end of this cycle.  
+	## for any of those cycles -> if priority is applicable, then block, and block all related chains.
+	## how to block the related chains ?
+	## a cycle has to store all its related chain ids, and also its 30 minute references.
+	## so that's it.
+	## this is something to execute tomorrow.
+
+	## so plan for today
+	## 
+
 end
 
 

data/app/models/auth/work/minute.rb

@@ -3,4 +3,128 @@ class Auth::Work::Minute
 	embeds_many :cycles, :class_name => "Auth::Work::Cycle", :as => :minute_cycles
 	field :time, type: Time
 	field :geom, type: Array
+		
+	## returns all minutes which have affected cycles , only containing the affected cycles.
+	def self.get_affected_minutes(cycle_start_time,cycle_end_time,cycle_workers_assigned,cycle_entities_assigned)
+		response = Auth::Work::Minute.collection.aggregate([
+			{
+				"$match" => {
+					"cycles" => {
+						"$elemMatch" => {
+							"$and" => [
+								{
+									"$or" => [
+										{
+											"start_time" => {
+												"$gte" => cycle_start_time,
+												"$lte" => cycle_end_time 
+											}
+										},
+										{
+											"end_time" => {
+												"$gte" => cycle_start_time,
+												"$lte" => cycle_end_time
+											}
+										},
+										{
+											"$and" => [
+												{
+													"start_time" => {
+														"$lte" => cycle_start_time
+													}
+												},
+												{
+													"end_time" => {
+														"$gte" => cycle_end_time
+													}
+												}
+											]
+										}
+									]
+								},
+								{
+									"$or" => [
+										{
+											"workers_available" => {
+												"$in" => cycle_workers_assigned
+											}
+										},
+										{
+											"entities_available" => {
+												"$in" => cycle_entities_assigned
+											}
+										}
+									]
+								}
+							]
+						}
+					}
+				}
+			},
+			{
+				"$unwind" => "cycles",
+				"includeArrayIndex" => "cycle_index"
+			},
+			{
+				"$match" => {
+					"$and" => [
+						{
+							"$or" => [
+								{
+									"cycles.start_time" => {
+										"$gte" => cycle_start_time,
+										"$lte" => cycle_end_time 
+									}
+								},
+								{
+									"cycles.end_time" => {
+										"$gte" => cycle_start_time,
+										"$lte" => cycle_end_time
+									}
+								},
+								{
+									"$and" => [
+										{
+											"cycles.start_time" => {
+												"$lte" => cycle_start_time
+											}
+										},
+										{
+											"cycles.end_time" => {
+												"$gte" => cycle_end_time
+											}
+										}
+									]
+								}
+							]
+						},
+						{
+							"$or" => [
+								{
+									"cycles.workers_available" => {
+										"$in" => cycle_workers_assigned
+									}
+								},
+								{
+									"cycles.entities_available" => {
+										"$in" => cycle_entities_assigned
+									}
+								}
+							]
+						}
+					]
+				}
+			},
+			{
+				"$group" => {
+					"_id" => "$_id",
+					"cycles" => {
+						"$push" => "$cycles"
+					}
+				}
+			}
+		])
+		response
+	end
+
 end