wordjelly-auth 1.2.5 → 1.2.6

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

@@ -89,9 +89,7 @@ module Auth::Concerns::Shopping::PlaceConcern
 			}
 		}
 		
-		before_save do |document|
-			document.public = "no"
-		end
+		
 
 		field :nearest_address, type: String
 

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

@@ -7,92 +7,40 @@ module Auth::Concerns::Shopping::ProductConcern
 	include Auth::Concerns::EsConcern
 	
 
-
 	included do 
-	
 		
-
 		embeds_many :cycles, :class_name => "Auth::Work::Cycle", :as => :product_cycles
 
 		embeds_many :instructions, :class_name => "Auth::Work::Instruction", :as => :product_instructions
 					
-		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: {
-				         	Auth::OmniAuth::Path.pathify(Auth.configuration.product_class) => {
-					            properties: {
-					            	_all_fields: {
-					            		type: "text",
-					            		analyzer: "nGram_analyzer",
-						            	search_analyzer: "whitespace_analyzer"
-					            	},
-					                name: {
-					                	type: "keyword",
-					                	copy_to: "_all_fields"
-					                },
-					                price: {
-					                	type: "double",
-					                	copy_to: "_all_fields"
-					                },
-					                public: {
-					                	type: "keyword"
-					                },
-					                resource_id: {
-					                	type: "keyword",
-					                	copy_to: "_all_fields"
-					                },
-					                bundle_name: {
-					                	type: "text",
-					                	copy_to: "_all_fields",
-					                	fields: {
-					                		raw: {
-					                			type: "keyword"
-					                		}
-					                	}    		
-					                }
-					            }
-				        }
+		INDEX_DEFINITION = 
+		{
+			index_options:  
+				{
+				settings:  
+					{
+				    		index: Auth::Concerns::EsConcern::AUTOCOMPLETE_INDEX_SETTINGS
+					},
+				mappings: 
+					{
+				        Auth::OmniAuth::Path.pathify(Auth.configuration.product_class) => Auth::Concerns::EsConcern::AUTOCOMPLETE_INDEX_MAPPINGS.deep_merge(
+				        		{
+				        			properties: {
+				        				bundle_name: {
+				        					type: "text",
+				        					fields: {
+				        						raw: {
+				        							type: "keyword"
+				        						}
+				        					}
+				        				}
+				        			}
+				        		}
+				        	)
 				    }
 				}
-			}
+		}
+
 		#include MongoidVersionedAtomic::VAtomic	
 		field :price, type: BigDecimal
 		field :name, type: String
@@ -120,133 +68,82 @@ module Auth::Concerns::Shopping::ProductConcern
 		## 
 		field :bundle_name, type: String
 
-		## all products are public to be searched.
+			
 		before_save do |document|
 			self.public = "yes"
 		end
 
-		## forget it.
-
 	end
 
-	
-
 
 	def as_indexed_json(options={})
-	 {
-	 	name: name,
-	 	bundle_name: bundle_name,
-	    price: price,
-	    resource_id: resource_id,
-	    public: public
-	 }
+	 super.merge({bundle_name: bundle_name})
 	end 
+	
+	## 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}			
 
-	module ClassMethods
-
-		## @return[SearchResult]
-		def bundle_autocomplete_aggregation(query)
-			query[:body][:aggregations] = {
-				bundle_names: {
-					terms: {
-						field: "bundle_name.raw"
-					}
-				}
-			}
-			
-			result = Auth.configuration.product_class.constantize.es.search query
-
-			puts "these are the aggs."
-			puts result.raw_response.to_s
-			#mash = Hashie::Mash.new result		
-			#has_more_results = false if mash.aggregations.bundle_names["buckets"].size == 0
-			#mash.aggregations.bundle_names["buckets"].each do |bucket|
-			#		puts "this is the bucket: "
-			#		puts bucket.to_s
-					#after = bucket["key"]["symptom_thing"]
-					#doc_count = bucket["doc_count"]
-					#create_symptom(after,doc_count)
-					#puts "created #{counter} symptoms"
-					#counter+=1
-			#end
-=begin
-			mash = Hashie::Mash.new symptom_co_occurrence_query
-				has_more_results = false if mash.aggregations.my_buckets["buckets"].size == 0
-				mash.aggregations.my_buckets["buckets"].each do |bucket|
-					after = bucket["key"]["symptom_thing"]
-					doc_count = bucket["doc_count"]
-					create_symptom(after,doc_count)
-					puts "created #{counter} symptoms"
-					counter+=1
-				end
-=end
-		end
+		end_min = rolling_n_minutes_less_than_that.size < Auth.configuration.rolling_minutes ? rolling_n_minutes_less_than_that.size : Auth.configuration.rolling_minutes
 
-		## so we have completed the rolling n minutes.
-		def add_to_previous_rolling_n_minutes(minutes,origin_epoch,cycle_to_add)
+		end_min = end_min - 1
 
-			## get all the minutes less than that.
-			rolling_n_minutes_less_than_that = minutes.keys.select{|c| c < origin_epoch}			
+		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_min = rolling_n_minutes_less_than_that.size < Auth.configuration.rolling_minutes ? rolling_n_minutes_less_than_that.size : Auth.configuration.rolling_minutes
+	end
 
-			end_min = end_min - 1
+	## adds the relevant cycles to the minutes, and returns the hash that came in.
+	## does not save the minutes, after adding the cycles to them.
+	##@return[Hash] {epoch => minute object}
+	def schedule_cycles(minutes,location_id,conditions = {})
 
-			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
+		products = Auth.configuration.product_class.constantize.all if conditions.blank?
 
-		end
+		products = Auth.configuration.product_class.constantize.where(conditions) if !conditions.blank?
 
-		## adds the relevant cycles to the minutes, and returns the hash that came in.
-		## does not save the minutes, after adding the cycles to them.
-		##@return[Hash] {epoch => minute object}
-		def schedule_cycles(minutes,location_id,conditions = {})
+		minutes.keys.each do |epoch|
+			
+			products.each do |product|
+			
+				all_cycles_valid = true
+				product.cycles.each do |cycle|
 
-			products = Auth.configuration.product_class.constantize.all if conditions.blank?
+					all_cycles_valid = cycle.requirements_satisfied(epoch + cycle.time_since_prev_cycle.minutes*60,location_id)
+							
+				end
 
-			products = Auth.configuration.product_class.constantize.where(conditions) if !conditions.blank?
 
-			minutes.keys.each do |epoch|
-				
-				products.each do |product|
-				
-					all_cycles_valid = true
+				if all_cycles_valid == true
+					cycle_chain = []
 					product.cycles.each do |cycle|
-
-						all_cycles_valid = cycle.requirements_satisfied(epoch + cycle.time_since_prev_cycle.minutes*60,location_id)
-								
-					end
+						epoch_at_which_to_add = epoch + cycle.time_since_prev_cycle.minutes*60
+						cycle_to_add = cycle.dup
+						cycle_to_add.start_time = epoch_at_which_to_add
+						cycle_to_add.end_time = cycle_to_add.start_time + cycle_to_add.duration
+						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)
 
 
-					if all_cycles_valid == true
-						cycle_chain = []
-						product.cycles.each do |cycle|
-							epoch_at_which_to_add = epoch + cycle.time_since_prev_cycle.minutes*60
-							cycle_to_add = cycle.dup
-							cycle_to_add.start_time = epoch_at_which_to_add
-							cycle_to_add.end_time = cycle_to_add.start_time + cycle_to_add.duration
-							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[epoch_at_which_to_add].cycles << cycle_to_add
 
 
-								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."
-							end
+							cycle_chain << cycle_to_add.id.to_s
+						else
+							#raise "necessary minute not in range."
 						end
 					end
 				end
 			end
-			minutes
 		end
+		minutes
 	end
+	
 end

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

@@ -11,73 +11,11 @@ module Auth::Concerns::UserConcern
 
 		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"
-						                    ]
-						                }
-						            }
-						        }
-					    	}
+				        settings:  {
+				    		index: Auth::Concerns::EsConcern::AUTOCOMPLETE_INDEX_SETTINGS
 					    },
 				        mappings: {
-				          Auth::OmniAuth::Path.pathify(Auth.configuration.auth_resources.keys.first) => {
-				            properties: {
-				            	_all_fields:  {
-					          		type: "text",
-						            analyzer: "nGram_analyzer",
-						            search_analyzer: "whitespace_analyzer"
-						        },
-				                name: {
-				                	type: "text",
-				                	copy_to: "_all_fields"
-				                },
-				                email: {
-				                	type: "keyword",
-				                	copy_to: "_all_fields"
-				                },
-				                additional_login_param: {
-				                	type: "keyword",
-				                	copy_to: "_all_fields"
-				                },
-				                public: {
-				                	type: "keyword"
-				                },
-				                resource_id: {
-				                	type: "keyword",
-				                	copy_to: "_all_fields"
-				                }
-				            }
-				        }
+				          Auth::OmniAuth::Path.pathify(Auth.configuration.user_class) => Auth::Concerns::EsConcern::AUTOCOMPLETE_INDEX_MAPPINGS
 				    }
 				}
 			}
@@ -608,6 +546,8 @@ module Auth::Concerns::UserConcern
 	## this is needed in 
 	def as_json(options={})
 		
+		## basically here the problem is that if the user himself is searching for his own record, then it is trying to return the authentication token.
+		## 
 		
 		json = {:nothing => true}
 		
@@ -617,7 +557,8 @@ module Auth::Concerns::UserConcern
 			 		
 			 		json = {}
 		     		json[:es] = self.client_authentication[self.m_client.current_app_id]
-		     		json[:authentication_token] = self.authentication_token
+		     		json[:authentication_token] = self.	authentication_token
+
 		     		unless options[:show_id].nil?
 		     			json[:id] = self.id.to_s
 		     			json[:admin] = self.admin.to_s

data/app/models/auth/shopping/bar_code.rb

@@ -0,0 +1,71 @@
+class Auth::Shopping::BarCode
+	include Mongoid::Document
+	field :resource_id, type: String
+	field :resource_class, type: String
+	field :assigned_to_object_id, type: String
+	field :assigned_to_object_class, type: String
+	field :bar_code_tag, type: String
+	index({ bar_code_tag: 1 }, { unique: true, name: "bar_code_tag_index" })
+		
+	## we do this to delet a reference to an object from a bar code.
+	def self.clear_object(bar_code_tag)
+		returned_document = collection.where(:bar_code_tag => bar_code_tag).find_one_and_update(
+			{
+				"$set" => {
+					"resource_id" => nil,
+					"resource_class" => nil,
+					"assigned_to_object_id" => nil,
+					"assigned_to_object_class" => nil
+				}
+			},
+			{
+				:return_document => :after
+			}
+		)
+		true if returned_document.assigned_to_object_id == nil
+	end
+
+	## the object here must be implementing the bar code concern.
+	## what if another bar code has this object on it?
+	## now two barcodes refer to the same object, and we have no way of catching that
+	## so the 
+	def self.upsert_and_assign_object(object)
+		returned_document = collection.where(
+			"$or" => [
+						{
+							:bar_code_tag => bar_code_tag
+						},
+						{
+							:assigned_to_object_id => object.id.to_s,
+							:assigned_to_object_class => object.class.name.to_s
+						}
+					]
+			).find_one_and_update(
+			{
+				"setOnInsert" => {
+					"resource_id" => object.resource_id,
+					"resource_class" => object.resource_class,
+					"assigned_to_object_id" => object.id.to_s,
+					"assigned_to_object_class" => object.assigned_to_object_class,
+					"bar_code_tag" => object.bar_code_tag	
+				}
+			},
+			{
+				:returned_document => :after,
+				:upsert => true
+			}
+		)
+		
+		false unless returned_document
+
+		false if returned_document.assigned_to_object_id != object.id.to_s
+
+		false if returned_document.bar_code_tag != object.bar_code_tag
+
+		## as long as all this is satisfied, it means that there is either already this bar code assigned to this object, or 
+
+		true
+
+	end
+
+end