http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby-on-rails/lib/usergrid_ironhorse/query.rb ---------------------------------------------------------------------- diff --git a/sdks/ruby-on-rails/lib/usergrid_ironhorse/query.rb b/sdks/ruby-on-rails/lib/usergrid_ironhorse/query.rb deleted file mode 100644 index 6562b8f..0000000 --- a/sdks/ruby-on-rails/lib/usergrid_ironhorse/query.rb +++ /dev/null @@ -1,929 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# http://guides.rubyonrails.org/active_record_querying.html - -module Usergrid - module Ironhorse - - class Query - - RecordNotFound = ActiveRecord::RecordNotFound - - def initialize(model_class) - @model_class = model_class - @options = {} - end - - ## Initializes new record from relation while maintaining the current - ## scope. - ## - ## Expects arguments in the same format as +Base.new+. - ## - ## users = User.where(name: 'DHH') - ## user = users.new # => #<User id: nil, name: "DHH", created_at: nil, updated_at: nil> - ## - ## You can also pass a block to new with the new record as argument: - ## - ## user = users.new { |user| user.name = 'Oscar' } - ## user.name # => Oscar - #def new(*args, &block) - # scoping { @model_class.new(*args, &block) } - #end - - # Find by uuid or name - This can either be a specific uuid or name (1), a list of uuids - # or names (1, 5, 6), or an array of uuids or names ([5, 6, 10]). - # If no record can be found for all of the listed ids, then RecordNotFound will be raised. - # - # Person.find(1) # returns the object for ID = 1 - # Person.find("1") # returns the object for ID = 1 - # Person.find(1, 2, 6) # returns an array for objects with IDs in (1, 2, 6) - # Person.find([7, 17]) # returns an array for objects with IDs in (7, 17) - # Person.find([1]) # returns an array for the object with ID = 1 - # Person.where("administrator = 1").order("created_on DESC").find(1) - # - def find(*ids) - raise RecordNotFound unless ids - ids = ids.first if ids.first.is_a? Array - @records = ids.collect { |id| find_one! id } # todo: can this be optimized in one call? - #entities = @model_class.resource[ids.join '&'].get.entities - #raise RecordNotFound unless (entities.size == ids.size) - #@records = entities.collect {|entity| @model_class.model_name.constantize.new(entity.data) } - @records.size == 1 ? @records.first : @records - end - - # Finds the first record matching the specified conditions. There - # is no implied ordering so if order matters, you should specify it - # yourself. - # - # If no record is found, returns <tt>nil</tt>. - # - # Post.find_by name: 'Spartacus', rating: 4 - # Post.find_by "published_at < ?", 2.weeks.ago - def find_by(*conditions) - where(*conditions).take - end - - # Like <tt>find_by</tt>, except that if no record is found, raises - # an <tt>ActiveRecord::RecordNotFound</tt> error. - def find_by!(*conditions) - where(*conditions).take! - end - - # Gives a record (or N records if a parameter is supplied) without any implied - # order. - # - # Person.take # returns an object fetched by SELECT * FROM people - # Person.take(5) # returns 5 objects fetched by SELECT * FROM people LIMIT 5 - # Person.where(["name LIKE '%?'", name]).take - def take(limit=1) - limit(limit).to_a - end - - # Same as +take+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record - # is found. Note that <tt>take!</tt> accepts no arguments. - def take! - take or raise RecordNotFound - end - - # Find the first record (or first N records if a parameter is supplied). - # If no order is defined it will order by primary key. - # - # Person.first # returns the first object fetched by SELECT * FROM people - # Person.where(["user_name = ?", user_name]).first - # Person.where(["user_name = :u", { :u => user_name }]).first - # Person.order("created_on DESC").offset(5).first - # Person.first(3) # returns the first three objects fetched by SELECT * FROM people LIMIT 3 - def first(limit=1) - limit(limit).load.first - end - - # Same as +first+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record - # is found. Note that <tt>first!</tt> accepts no arguments. - def first! - first or raise RecordNotFound - end - - # Find the last record (or last N records if a parameter is supplied). - # If no order is defined it will order by primary key. - # - # Person.last # returns the last object fetched by SELECT * FROM people - # Person.where(["user_name = ?", user_name]).last - # Person.order("created_on DESC").offset(5).last - # Person.last(3) # returns the last three objects fetched by SELECT * FROM people. - # - # Take note that in that last case, the results are sorted in ascending order: - # - # [#<Person id:2>, #<Person id:3>, #<Person id:4>] - # - # and not: - # - # [#<Person id:4>, #<Person id:3>, #<Person id:2>] - def last(limit=1) - limit(limit).reverse_order.load.first - end - - # Same as +last+ but raises <tt>ActiveRecord::RecordNotFound</tt> if no record - # is found. Note that <tt>last!</tt> accepts no arguments. - def last! - last or raise RecordNotFound - end - - def each - to_a.each { |*block_args| yield(*block_args) } - while @response.data['cursor'] && !limit_value - next_page - to_a.each { |*block_args| yield(*block_args) } - end - end - - def next_page - @options[:cursor] = @response.data['cursor'] - @records = nil - load - self - end - - # Returns +true+ if a record exists in the table that matches the +id+ or - # conditions given, or +false+ otherwise. The argument can take six forms: - # - # * String - Finds the record with a primary key corresponding to this - # string (such as <tt>'5'</tt>). - # * Array - Finds the record that matches these +find+-style conditions - # (such as <tt>['color = ?', 'red']</tt>). - # * Hash - Finds the record that matches these +find+-style conditions - # (such as <tt>{color: 'red'}</tt>). - # * +false+ - Returns always +false+. - # * No args - Returns +false+ if the table is empty, +true+ otherwise. - # - # For more information about specifying conditions as a Hash or Array, - # see the Conditions section in the introduction to ActiveRecord::Base. - def exists?(conditions=nil) - # todo: does not yet handle all conditions described above - case conditions - when Array, Hash - pluck :uuid - !where(conditions).take.empty? - else - !!find_one(conditions) - end - end - alias_method :any?, :exists? - alias_method :many?, :exists? - - def limit(limit=1) - @options[:limit] = limit - self - end - - def offset(num) - @options[:offset] = num - self - end - - # Removes from the query the condition(s) specified in +skips+. - # - # Example: - # - # Post.order('id asc').except(:order) # discards the order condition - # Post.where('id > 10').order('id asc').except(:where) # discards the where condition but keeps the order - # - def except(*skips) - skips.each {|option| @options.delete option} - end - - # Removes any condition from the query other than the one(s) specified in +onlies+. - # - # Example: - # - # Post.order('id asc').only(:where) # discards the order condition - # Post.order('id asc').only(:where, :order) # uses the specified order - # - def only(*onlies) - @options.keys do |k| - unless onlines.include? k - @options.delete k - end - end - end - - # Allows to specify an order attribute: - # - # User.order('name') - # => SELECT "users".* FROM "users" ORDER BY name - # - # User.order('name DESC') - # => SELECT "users".* FROM "users" ORDER BY name DESC - # - # User.order('name DESC, email') - # => SELECT "users".* FROM "users" ORDER BY name DESC, email - def order(*args) - @options[:order] << args - end - - # Replaces any existing order defined on the relation with the specified order. - # - # User.order('email DESC').reorder('id ASC') # generated SQL has 'ORDER BY id ASC' - # - # Subsequent calls to order on the same relation will be appended. For example: - # - # User.order('email DESC').reorder('id ASC').order('name ASC') - # - # generates a query with 'ORDER BY name ASC, id ASC'. - def reorder(*args) - @options[:order] = args - end - - def all - @options[:conditions] = nil - self - end - - # Works in two unique ways. - # - # First: takes a block so it can be used just like Array#select. - # - # Model.all.select { |m| m.field == value } - # - # This will build an array of objects from the database for the scope, - # converting them into an array and iterating through them using Array#select. - # - # Second: Modifies the SELECT statement for the query so that only certain - # fields are retrieved: - # - # Model.select(:field) - # # => [#<Model field:value>] - # - # Although in the above example it looks as though this method returns an - # array, it actually returns a relation object and can have other query - # methods appended to it, such as the other methods in ActiveRecord::QueryMethods. - # - # The argument to the method can also be an array of fields. - # - # Model.select(:field, :other_field, :and_one_more) - # # => [#<Model field: "value", other_field: "value", and_one_more: "value">] - # - def select(*fields) - if block_given? - to_a.select { |*block_args| yield(*block_args) } - else - raise ArgumentError, 'Call this with at least one field' if fields.empty? - clone.select!(*fields) - end - end - - # Like #select, but modifies relation in place. - def select!(*fields) - @options[:select] ||= fields.join ',' - self - end - alias_method :pluck, :select! - - def reverse_order - @options[:reversed] = true - self - end - - def readonly - @options[:readonly] = true - self - end - - def to_a - load - @records - end - - def as_json(options = nil) #:nodoc: - to_a.as_json(options) - end - - # Returns size of the results (not size of the stored collection) - def size - loaded? ? @records.length : count - end - - # true if there are no records - def empty? - return @records.empty? if loaded? - - c = count - c.respond_to?(:zero?) ? c.zero? : c.empty? - end - - # true if there are any records - def any? - if block_given? - to_a.any? { |*block_args| yield(*block_args) } - else - !empty? - end - end - - # true if there is more than one record - def many? - if block_given? - to_a.many? { |*block_args| yield(*block_args) } - else - limit_value ? to_a.many? : size > 1 - end - end - - # find_all_by_ - # find_by_ - # find_first_by_ - # find_last_by_ - def method_missing(method_name, *args) - - method = method_name.to_s - - if method.end_with? '!' - method.chop! - error_on_empty = true - end - - if method.start_with? 'find_all_by_' - attribs = method.gsub /^find_all_by_/, '' - elsif method.start_with? 'find_by_' - attribs = method.gsub /^find_by_/, '' - limit(1) - elsif method.start_with? 'find_first_by_' - limit(1) - find_first = true - attribs = method.gsub /^find_first_by_/, '' - elsif method.start_with? 'find_last_by_' - limit(1) - find_last = true - attribs = method.gsub /^find_last_by_/, '' - else - super - end - - attribs = attribs.split '_and_' - conditions = {} - attribs.each { |attr| conditions[attr] = args.shift } - - where(conditions, *args) - load - raise RecordNotFound if error_on_empty && @records.empty? - return @records.first if limit_value == 1 - @records - end - - # Tries to create a new record with the same scoped attributes - # defined in the relation. Returns the initialized object if validation fails. - # - # Expects arguments in the same format as +Base.create+. - # - # ==== Examples - # users = User.where(name: 'Oscar') - # users.create # #<User id: 3, name: "oscar", ...> - # - # users.create(name: 'fxn') - # users.create # #<User id: 4, name: "fxn", ...> - # - # users.create { |user| user.name = 'tenderlove' } - # # #<User id: 5, name: "tenderlove", ...> - # - # users.create(name: nil) # validation on name - # # #<User id: nil, name: nil, ...> - def create(*args, &block) - @model_class.create(*args, &block) - end - - # Similar to #create, but calls +create!+ on the base class. Raises - # an exception if a validation error occurs. - # - # Expects arguments in the same format as <tt>Base.create!</tt>. - def create!(*args, &block) - @model_class.create!(*args, &block) - end - - # Tries to load the first record; if it fails, then <tt>create</tt> is called with the same arguments as this method. - # - # Expects arguments in the same format as +Base.create+. - # - # ==== Examples - # # Find the first user named Penélope or create a new one. - # User.where(:first_name => 'Penélope').first_or_create - # # => <User id: 1, first_name: 'Penélope', last_name: nil> - # - # # Find the first user named Penélope or create a new one. - # # We already have one so the existing record will be returned. - # User.where(:first_name => 'Penélope').first_or_create - # # => <User id: 1, first_name: 'Penélope', last_name: nil> - # - # # Find the first user named Scarlett or create a new one with a particular last name. - # User.where(:first_name => 'Scarlett').first_or_create(:last_name => 'Johansson') - # # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'> - # - # # Find the first user named Scarlett or create a new one with a different last name. - # # We already have one so the existing record will be returned. - # User.where(:first_name => 'Scarlett').first_or_create do |user| - # user.last_name = "O'Hara" - # end - # # => <User id: 2, first_name: 'Scarlett', last_name: 'Johansson'> - def first_or_create(attributes={}, &block) - result = first - unless result - attributes = @options[:hash].merge(attributes) if @options[:hash] - result = create(attributes, &block) - end - result - end - - # Like <tt>first_or_create</tt> but calls <tt>create!</tt> so an exception is raised if the created record is invalid. - # - # Expects arguments in the same format as <tt>Base.create!</tt>. - def first_or_create!(attributes={}, &block) - result = first - unless result - attributes = @options[:hash].merge(attributes) if @options[:hash] - result = create!(attributes, &block) - end - result - end - - # Like <tt>first_or_create</tt> but calls <tt>new</tt> instead of <tt>create</tt>. - # - # Expects arguments in the same format as <tt>Base.new</tt>. - def first_or_initialize(attributes={}, &block) - result = first - unless result - attributes = @options[:hash].merge(attributes) if @options[:hash] - result = @model_class.new(attributes, &block) - end - result - end - - # Destroys the records matching +conditions+ by instantiating each - # record and calling its +destroy+ method. Each object's callbacks are - # executed (including <tt>:dependent</tt> association options and - # +before_destroy+/+after_destroy+ Observer methods). Returns the - # collection of objects that were destroyed; each will be frozen, to - # reflect that no changes should be made (since they can't be - # persisted). - # - # Note: Instantiation, callback execution, and deletion of each - # record can be time consuming when you're removing many records at - # once. It generates at least one SQL +DELETE+ query per record (or - # possibly more, to enforce your callbacks). If you want to delete many - # rows quickly, without concern for their associations or callbacks, use - # +delete_all+ instead. - # - # ==== Parameters - # - # * +conditions+ - A string, array, or hash that specifies which records - # to destroy. If omitted, all records are destroyed. See the - # Conditions section in the introduction to ActiveRecord::Base for - # more information. - # - # ==== Examples - # - # Person.destroy_all("last_login < '2004-04-04'") - # Person.destroy_all(status: "inactive") - # Person.where(:age => 0..18).destroy_all - def destroy_all(conditions=nil) - if conditions - where(conditions).destroy_all - else - to_a.each {|object| object.destroy} - @records - end - end - - # Destroy an object (or multiple objects) that has the given id. The object is instantiated first, - # therefore all callbacks and filters are fired off before the object is deleted. This method is - # less efficient than ActiveRecord#delete but allows cleanup methods and other actions to be run. - # - # This essentially finds the object (or multiple objects) with the given id, creates a new object - # from the attributes, and then calls destroy on it. - # - # ==== Parameters - # - # * +id+ - Can be either an Integer or an Array of Integers. - # - # ==== Examples - # - # # Destroy a single object - # Foo.destroy(1) - # - # # Destroy multiple objects - # foos = [1,2,3] - # Foo.destroy(foos) - def destroy(id) - if id.is_a?(Array) - id.map {|one_id| destroy(one_id)} - else - find(id).destroy - end - end - - # Deletes the records matching +conditions+ without instantiating the records - # first, and hence not calling the +destroy+ method nor invoking callbacks. This - # is a single SQL DELETE statement that goes straight to the database, much more - # efficient than +destroy_all+. Be careful with relations though, in particular - # <tt>:dependent</tt> rules defined on associations are not honored. Returns the - # number of rows affected. - # - # Post.delete_all("person_id = 5 AND (category = 'Something' OR category = 'Else')") - # Post.delete_all(["person_id = ? AND (category = ? OR category = ?)", 5, 'Something', 'Else']) - # Post.where(:person_id => 5).where(:category => ['Something', 'Else']).delete_all - # - # Both calls delete the affected posts all at once with a single DELETE statement. - # If you need to destroy dependent associations or call your <tt>before_*</tt> or - # +after_destroy+ callbacks, use the +destroy_all+ method instead. - # - # If a limit scope is supplied, +delete_all+ raises an ActiveRecord error: - # - # Post.limit(100).delete_all - # # => ActiveRecord::ActiveRecordError: delete_all doesn't support limit scope - def delete_all(conditions=nil) - raise ActiveRecordError.new("delete_all doesn't support limit scope") if self.limit_value - - if conditions - where(conditions).delete_all - else - pluck :uuid - response = load - response.each {|entity| entity.delete} # todo: can this be optimized into one call? - response.size - end - end - - # Deletes the row with a primary key matching the +id+ argument, using a - # SQL +DELETE+ statement, and returns the number of rows deleted. Active - # Record objects are not instantiated, so the object's callbacks are not - # executed, including any <tt>:dependent</tt> association options or - # Observer methods. - # - # You can delete multiple rows at once by passing an Array of <tt>id</tt>s. - # - # Note: Although it is often much faster than the alternative, - # <tt>#destroy</tt>, skipping callbacks might bypass business logic in - # your application that ensures referential integrity or performs other - # essential jobs. - # - # ==== Examples - # - # # Delete a single row - # Foo.delete(1) - # - # # Delete multiple rows - # Foo.delete([2,3,4]) - def delete(id_or_array) - if id_or_array.is_a? Array - id_or_array.each {|id| @model_class.resource[id].delete} # todo: can this be optimized into one call? - else - @model_class.resource[id_or_array].delete - end - end - - # Updates all records with details given if they match a set of conditions supplied, limits and order can - # also be supplied. This method sends a single update straight to the database. It does not instantiate - # the involved models and it does not trigger Active Record callbacks or validations. - # - # ==== Parameters - # - # * +updates+ - hash of attribute updates - # - # ==== Examples - # - # # Update all customers with the given attributes - # Customer.update_all wants_email: true - # - # # Update all books with 'Rails' in their title - # Book.where('title LIKE ?', '%Rails%').update_all(author: 'David') - # - # # Update all books that match conditions, but limit it to 5 ordered by date - # Book.where('title LIKE ?', '%Rails%').order(:created).limit(5).update_all(:author => 'David') - def update_all(updates) - raise ArgumentError, "Empty list of attributes to change" if updates.blank? - raise ArgumentError, "updates must be a Hash" unless updates.is_a? Hash - run_update(updates) - end - - # Looping through a collection of records from the database - # (using the +all+ method, for example) is very inefficient - # since it will try to instantiate all the objects at once. - # - # In that case, batch processing methods allow you to work - # with the records in batches, thereby greatly reducing memory consumption. - # - # The #find_each method uses #find_in_batches with a batch size of 1000 (or as - # specified by the +:batch_size+ option). - # - # Person.all.find_each do |person| - # person.do_awesome_stuff - # end - # - # Person.where("age > 21").find_each do |person| - # person.party_all_night! - # end - # - # You can also pass the +:start+ option to specify - # an offset to control the starting point. - def find_each(options = {}) - find_in_batches(options) do |records| - records.each { |record| yield record } - end - end - - # Yields each batch of records that was found by the find +options+ as - # an array. The size of each batch is set by the +:batch_size+ - # option; the default is 1000. - # - # You can control the starting point for the batch processing by - # supplying the +:start+ option. This is especially useful if you - # want multiple workers dealing with the same processing queue. You can - # make worker 1 handle all the records between id 0 and 10,000 and - # worker 2 handle from 10,000 and beyond (by setting the +:start+ - # option on that worker). - # - # It's not possible to set the order. That is automatically set to - # ascending on the primary key ("id ASC") to make the batch ordering - # work. This also mean that this method only works with integer-based - # primary keys. You can't set the limit either, that's used to control - # the batch sizes. - # - # Person.where("age > 21").find_in_batches do |group| - # sleep(50) # Make sure it doesn't get too crowded in there! - # group.each { |person| person.party_all_night! } - # end - # - # # Let's process the next 2000 records - # Person.all.find_in_batches(start: 2000, batch_size: 2000) do |group| - # group.each { |person| person.party_all_night! } - # end - def find_in_batches(options={}) - options.assert_valid_keys(:start, :batch_size) - - raise "Not yet implemented" # todo - - start = options.delete(:start) || 0 - batch_size = options.delete(:batch_size) || 1000 - - while records.any? - records_size = records.size - primary_key_offset = records.last.id - - yield records - - break if records_size < batch_size - - if primary_key_offset - records = relation.where(table[primary_key].gt(primary_key_offset)).to_a - else - raise "Primary key not included in the custom select clause" - end - end - end - - # Updates an object (or multiple objects) and saves it to the database, if validations pass. - # The resulting object is returned whether the object was saved successfully to the database or not. - # - # ==== Parameters - # - # * +id+ - This should be the id or an array of ids to be updated. - # * +attributes+ - This should be a hash of attributes or an array of hashes. - # - # ==== Examples - # - # # Updates one record - # Person.update(15, user_name: 'Samuel', group: 'expert') - # - # # Updates multiple records - # people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } } - # Person.update(people.keys, people.values) - def update(id, attributes) - if id.is_a?(Array) - id.map.with_index { |one_id, idx| update(one_id, attributes[idx]) } - else - object = find(id) - object.update_attributes(attributes) - object - end - end - - ## todo: scoping - ## Scope all queries to the current scope. - ## - ## Comment.where(:post_id => 1).scoping do - ## Comment.first # SELECT * FROM comments WHERE post_id = 1 - ## end - ## - ## Please check unscoped if you want to remove all previous scopes (including - ## the default_scope) during the execution of a block. - #def scoping - # previous, @model_class.current_scope = @model_class.current_scope, self - # yield - #ensure - # klass.current_scope = previous - #end - - - # #where accepts conditions in one of several formats. - # - # === string - # - # A single string, without additional arguments, is used in the where clause of the query. - # - # Client.where("orders_count = '2'") - # # SELECT * where orders_count = '2'; - # - # Note that building your own string from user input may expose your application - # to injection attacks if not done properly. As an alternative, it is recommended - # to use one of the following methods. - # - # === array - # - # If an array is passed, then the first element of the array is treated as a template, and - # the remaining elements are inserted into the template to generate the condition. - # Active Record takes care of building the query to avoid injection attacks, and will - # convert from the ruby type to the database type where needed. Elements are inserted - # into the string in the order in which they appear. - # - # User.where(["name = ? and email = ?", "Joe", "[email protected]"]) - # # SELECT * WHERE name = 'Joe' AND email = '[email protected]'; - # - # Alternatively, you can use named placeholders in the template, and pass a hash as the - # second element of the array. The names in the template are replaced with the corresponding - # values from the hash. - # - # User.where(["name = :name and email = :email", { name: "Joe", email: "[email protected]" }]) - # # SELECT * WHERE name = 'Joe' AND email = '[email protected]'; - # - # This can make for more readable code in complex queries. - # - # Lastly, you can use sprintf-style % escapes in the template. This works slightly differently - # than the previous methods; you are responsible for ensuring that the values in the template - # are properly quoted. The values are passed to the connector for quoting, but the caller - # is responsible for ensuring they are enclosed in quotes in the resulting SQL. After quoting, - # the values are inserted using the same escapes as the Ruby core method <tt>Kernel::sprintf</tt>. - # - # User.where(["name = '%s' and email = '%s'", "Joe", "[email protected]"]) - # # SELECT * WHERE name = 'Joe' AND email = '[email protected]'; - # - # If #where is called with multiple arguments, these are treated as if they were passed as - # the elements of a single array. - # - # User.where("name = :name and email = :email", { name: "Joe", email: "[email protected]" }) - # # SELECT * WHERE name = 'Joe' AND email = '[email protected]'; - # - # When using strings to specify conditions, you can use any operator available from - # the database. While this provides the most flexibility, you can also unintentionally introduce - # dependencies on the underlying database. If your code is intended for general consumption, - # test with multiple database backends. - # - # === hash - # - # #where will also accept a hash condition, in which the keys are fields and the values - # are values to be searched for. - # - # Fields can be symbols or strings. Values can be single values, arrays, or ranges. - # - # User.where({ name: "Joe", email: "[email protected]" }) - # # SELECT * WHERE name = 'Joe' AND email = '[email protected]' - # - # User.where({ name: ["Alice", "Bob"]}) - # # SELECT * WHERE name IN ('Alice', 'Bob') - # - # User.where({ created_at: (Time.now.midnight - 1.day)..Time.now.midnight }) - # # SELECT * WHERE (created_at BETWEEN '2012-06-09 07:00:00.000000' AND '2012-06-10 07:00:00.000000') - # - # In the case of a belongs_to relationship, an association key can be used - # to specify the model if an ActiveRecord object is used as the value. - # - # author = Author.find(1) - # - # # The following queries will be equivalent: - # Post.where(:author => author) - # Post.where(:author_id => author) - # - # === empty condition - # - # If the condition returns true for blank?, then where is a no-op and returns the current relation. - # - def where(opts, *rest) - return self if opts.blank? - case opts - when Hash - @options[:hash] = opts # keep around for first_or_create stuff... - opts.each do |k,v| - # todo: can we support IN and BETWEEN syntax as documented above? - v = "'#{v}'" if v.is_a? String - query_conditions << "#{k} = #{v}" - end - when String - query_conditions << opts - when Array - query = opts.shift.gsub '?', "'%s'" - query = query % opts - query_conditions << query - end - self - end - - - protected - - - def limit_value - @options[:limit] - end - - def query_conditions - @options[:conditions] ||= [] - end - - def loaded? - !!@records - end - - def reversed? - !!@options[:reversed] - end - - def find_one(id_or_name=nil) - begin - entity = @model_class.resource[id_or_name].query(nil, limit: 1).entity - @model_class.model_name.constantize.new(entity.data) if entity - rescue RestClient::ResourceNotFound - nil - end - end - - def find_one!(id_or_name=nil) - find_one(id_or_name) or raise RecordNotFound - end - - # Server-side options: - # Xql string Query in the query language - # type string Entity type to return - # Xreversed string Return results in reverse order - # connection string Connection type (e.g., "likes") - # start string First entity's UUID to return - # cursor string Encoded representation of the query position for paging - # Xlimit integer Number of results to return - # permission string Permission type - # Xfilter string Condition on which to filter - def query_options - # todo: support more options? - options = {} - options.merge!({:limit => limit_value.to_json}) if limit_value - options.merge!({:skip => @options[:skip].to_json}) if @options[:skip] - options.merge!({:reversed => reversed?.to_json}) if reversed? - options.merge!({:order => @options[:order]}) if @options[:order] - options.merge!({:cursor => @options[:cursor]}) if @options[:cursor] - options - end - - def create_query - select = @options[:select] || '*' - where = ('where ' + query_conditions.join(' and ')) unless query_conditions.blank? - "select #{select} #{where}" - end - - def run_query - @model_class.resource.query(create_query, query_options) - end - - def run_update(attributes) - @model_class.resource.update_query(attributes, create_query, query_options) - end - - def load - return if loaded? - begin - @response = run_query - if (!@options[:select] or @options[:select] == '*') - @records = @response.entities.collect {|r| @model_class.model_name.constantize.new(r.data)} - else # handle list - selects = @options[:select].split ',' - @records = @response.entities.collect do |r| - data = {} - (0..selects.size).each do |i| - data[selects[i]] = r[i] - end - @model_class.model_name.constantize.new(data) - end - end - rescue RestClient::ResourceNotFound - @records = [] - end - end - end - end -end
http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby-on-rails/lib/usergrid_ironhorse/user_context.rb ---------------------------------------------------------------------- diff --git a/sdks/ruby-on-rails/lib/usergrid_ironhorse/user_context.rb b/sdks/ruby-on-rails/lib/usergrid_ironhorse/user_context.rb deleted file mode 100644 index b7a0804..0000000 --- a/sdks/ruby-on-rails/lib/usergrid_ironhorse/user_context.rb +++ /dev/null @@ -1,96 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - -module Usergrid - module Ironhorse - module UserContext - - # returns user if logged in, nil otherwise - # if session is passed, stores user_id and auth_token in the session - # and sets User as current_user - def authenticate(username, password, session=nil) - application = Usergrid::Application.new Usergrid::Ironhorse::Base.settings[:application_url] - begin - application.login username, password - user = new application.current_user.data - if session - session[:usergrid_user_id] = user.id - session[:usergrid_auth_token] = user.current_auth_token - set_thread_context(session) - Thread.current[:usergrid_current_user] = user - end - user - rescue - Rails.logger.info $! - raise $! - end - end - - # clears auth from session and thread - def clear_authentication(session) - session[:usergrid_user_id] = nil - session[:usergrid_auth_token] = nil - clear_thread_context(session) - end - - # allows admin actions to be done in a block - def as_admin(&block) - save_auth_token = Thread.current[:usergrid_auth_token] - begin - unless Base.settings[:auth_token] - resource = RestClient::Resource.new Base.settings[:application_url] - response = resource['token'].post grant_type: 'client_credentials', client_id: Base.settings[:client_id], client_secret: Base.settings[:client_secret] - Base.settings[:auth_token] = MultiJson.load(response)['access_token'] - end - Thread.current[:usergrid_auth_token] = Base.settings[:auth_token] - yield block - ensure - Thread.current[:usergrid_auth_token] = save_auth_token - end - end - - # sets auth for current thread - def set_thread_context(session) - Thread.current[:usergrid_user_id] = session[:usergrid_user_id] - Thread.current[:usergrid_auth_token] = session[:usergrid_auth_token] - Thread.current[:usergrid_current_user] = nil - end - alias_method :set_context, :set_thread_context - - # clears auth from current thread - def clear_thread_context - Thread.current[:usergrid_user_id] = nil - Thread.current[:usergrid_auth_token] = nil - Thread.current[:usergrid_current_user] = nil - end - alias_method :clear_context, :clear_thread_context - - # returns the auth token for the current thread - def current_auth_token - Thread.current[:usergrid_auth_token] - end - - # does a find and return - def current_user - unless Thread.current[:usergrid_current_user] - Thread.current[:usergrid_current_user] = find(Thread.current[:usergrid_user_id]) if Thread.current[:usergrid_user_id] - end - Thread.current[:usergrid_current_user] - end - - end - end -end http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby-on-rails/lib/usergrid_ironhorse/version.rb ---------------------------------------------------------------------- diff --git a/sdks/ruby-on-rails/lib/usergrid_ironhorse/version.rb b/sdks/ruby-on-rails/lib/usergrid_ironhorse/version.rb deleted file mode 100644 index 990b730..0000000 --- a/sdks/ruby-on-rails/lib/usergrid_ironhorse/version.rb +++ /dev/null @@ -1,21 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - -module Usergrid - module Ironhorse - VERSION = '0.1.2' - end -end http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby-on-rails/spec/spec_helper.rb ---------------------------------------------------------------------- diff --git a/sdks/ruby-on-rails/spec/spec_helper.rb b/sdks/ruby-on-rails/spec/spec_helper.rb deleted file mode 100644 index 2cee2c2..0000000 --- a/sdks/ruby-on-rails/spec/spec_helper.rb +++ /dev/null @@ -1,93 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -require 'simplecov' -require 'test/unit' -require 'rspec' -require 'yaml' -require 'securerandom' -require_relative '../lib/usergrid_ironhorse' - -ENV["RAILS_ENV"] ||= 'test' -Dir[Pathname.new(File.dirname(__FILE__)).join("support/**/*.rb")].each { |f| require f } - -RSpec.configure do |config| - config.mock_with :rspec - config.expect_with :stdlib - config.expect_with :rspec -end - -LOG = Logger.new(STDOUT) -RestClient.log=LOG - -SimpleCov.at_exit do - SimpleCov.result.format! - #index = File.join(SimpleCov.coverage_path, 'index.html') - #`open #{index}` if File.exists?(index) -end -SimpleCov.start - - -SPEC_SETTINGS = YAML::load_file(File.join File.dirname(__FILE__), 'spec_settings.yaml') -Usergrid::Ironhorse::Base.configure! nil, nil - -def login_management - management = Usergrid::Resource.new(SPEC_SETTINGS[:api_url]).management - management.login SPEC_SETTINGS[:organization][:username], SPEC_SETTINGS[:organization][:password] - management -end - -# ensure we are correctly setup (management login & organization) -management = login_management - -begin - management.create_organization(SPEC_SETTINGS[:organization][:name], - SPEC_SETTINGS[:organization][:username], - SPEC_SETTINGS[:organization][:username], - "#{SPEC_SETTINGS[:organization][:username]}@email.com", - SPEC_SETTINGS[:organization][:password]) - LOG.info "created organization with user #{SPEC_SETTINGS[:organization][:username]}@email.com" -rescue - if MultiJson.load($!.response)['error'] == "duplicate_unique_property_exists" - LOG.debug "test organization exists" - else - raise $! - end -end - -def create_random_application - management = login_management - organization = management.organization SPEC_SETTINGS[:organization][:name] - app_name = "_test_app_#{SecureRandom.hex}" - organization.create_application app_name - management.application SPEC_SETTINGS[:organization][:name], app_name -end - -def delete_application(application) - management = login_management - application.auth_token = management.auth_token - application.delete rescue nil # not implemented on server yet -end - -def create_random_user(application, login=false) - random = SecureRandom.hex - user_hash = {username: "username_#{random}", - password: random, - email: "#{random}@email.com", - name: "#{random} name" } - entity = application['users'].post(user_hash).entity - application.login user_hash[:username], user_hash[:password] if login - entity -end http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby-on-rails/spec/spec_settings.yaml ---------------------------------------------------------------------- diff --git a/sdks/ruby-on-rails/spec/spec_settings.yaml b/sdks/ruby-on-rails/spec/spec_settings.yaml deleted file mode 100644 index 815ba43..0000000 --- a/sdks/ruby-on-rails/spec/spec_settings.yaml +++ /dev/null @@ -1,20 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -:api_url: http://localhost:8080 -:organization: - :name: test-organization - :username: test - :password: test http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby-on-rails/spec/support/active_model_lint.rb ---------------------------------------------------------------------- diff --git a/sdks/ruby-on-rails/spec/support/active_model_lint.rb b/sdks/ruby-on-rails/spec/support/active_model_lint.rb deleted file mode 100644 index 267be05..0000000 --- a/sdks/ruby-on-rails/spec/support/active_model_lint.rb +++ /dev/null @@ -1,33 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - -# spec/support/active_model_lint.rb -# adapted from rspec-rails: http://github.com/rspec/rspec-rails/blob/master/spec/rspec/rails/mocks/mock_model_spec.rb - -shared_examples_for "ActiveModel" do - include ActiveModel::Lint::Tests - - # to_s is to support ruby-1.9 - ActiveModel::Lint::Tests.public_instance_methods.map{|m| m.to_s}.grep(/^test/).each do |m| - example m.sub('_',' ') do - send m - end - end - - def model - subject - end -end http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby-on-rails/spec/usergrid_ironhorse/base_spec.rb ---------------------------------------------------------------------- diff --git a/sdks/ruby-on-rails/spec/usergrid_ironhorse/base_spec.rb b/sdks/ruby-on-rails/spec/usergrid_ironhorse/base_spec.rb deleted file mode 100644 index 4aa1da6..0000000 --- a/sdks/ruby-on-rails/spec/usergrid_ironhorse/base_spec.rb +++ /dev/null @@ -1,452 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - -describe Usergrid::Ironhorse::Base do - - it_should_behave_like 'ActiveModel' - - class User < Usergrid::Ironhorse::Base - extend Usergrid::Ironhorse::UserContext - end - - before :all do - @application = create_random_application - Foo.configure!(@application.url, @application.auth_token) - @user = create_random_user @application, true - @foo = (@application.create_entity 'foos', name: 'foo42', answer: 42).entity - end - - after :all do - @foo.delete - @user.delete - #delete_application @application # not supported on server yet - end - - class Foo < Usergrid::Ironhorse::Base; end - Foo.validates :name, :presence => true - - class Bar < Usergrid::Ironhorse::Base; end - - describe 'subclasses should be able to' do - - it "do tasks as admin when requested" do - organization = @foo.management.organization SPEC_SETTINGS[:organization][:name] - organization.logout - - # should fail under current user's context - expect { - organization.create_application "_test_app_#{SecureRandom.hex}" - }.to raise_error RestClient::Unauthorized - - # should succeed under admin context - User.as_admin do - organization.create_application "_test_app_#{SecureRandom.hex}" - end - end - - it "do tasks as admin if require_login is false" do - organization = @foo.management.organization SPEC_SETTINGS[:organization][:name] - organization.logout - - # should fail under current user's context - expect { - organization.create_application "_test_app_#{SecureRandom.hex}" - }.to raise_error RestClient::Unauthorized - - # should succeed once require_login is false - User.settings[:require_login] = false - organization.create_application "_test_app_#{SecureRandom.hex}" - User.settings[:require_login] = true - end - - it 'be created and destroyed' do - foo = Foo.create name: 'foo man' - foo.persisted?.should be_true - foo.name.should eq 'foo man' - foo = Foo.find_by_name 'foo man' - foo.should_not be_nil - foo.destroy.should be_true - foo.persisted?.should be_false - foo = Foo.find_by_name 'foo man' - foo.should be_nil - end - - it 'be changed and saved' do - foo = Foo.find_by_name @foo.name - foo.answer.should eq @foo.answer - foo.number = 43 - foo.changed?.should be_true - foo.number.should == 43 - foo.save! - foo = Foo.find_by_name @foo.name - foo.number.should == 43 - end - - it 'be reloaded' do - foo = Foo.find @foo.uuid - foo.answer = 44 - foo.changed?.should be_true - foo.answer.should == 44 - foo.reload - foo.answer.should == 42 - end - - it 'be found using find_by_name' do - foo = Foo.find_by_name @foo.name - foo.uuid.should_not be_nil - foo.name.should eq @foo.name - foo.should be_a Foo - foo.persisted?.should be_true - end - - it 'be found using find_by_name!' do - foo = Foo.find_by_name! @foo.name - foo.uuid.should_not be_nil - foo.name.should eq @foo.name - foo.should be_a Foo - foo.persisted?.should be_true - end - - it 'throw a RecordNotFound when find_by_name! misses' do - expect { Foo.find_by_name! 'name3' }.to raise_error(ActiveRecord::RecordNotFound) - end - - it 'add a validation' do - foo = Foo.new - foo.valid?.should be_false - foo.name = 'joe' - foo.valid?.should be_true - end - - it 'fail to save an invalid record and save the errors' do - foo = Foo.new - foo.save.should be_false - foo.persisted?.should be_false - foo.errors.count.should == 1 - foo.errors.get(:name).first.should eq "can't be blank" - end - - it 'fail to create an invalid record and save the errors' do - foo = Foo.create - foo.persisted?.should be_false - foo.errors.count.should == 1 - foo.errors.get(:name).first.should eq "can't be blank" - end - - it 'fail to save! an invalid record' do - expect { Foo.new.save! }.to raise_error(ActiveRecord::RecordNotSaved) - end - - it 'fail to create! an invalid record' do - expect { Foo.create! }.to raise_error(ActiveRecord::RecordNotSaved) - end - - it 'retrieve first' do - foo2 = Foo.create! name: 'foo2' - foo = Foo.first - foo.uuid.should eq @foo.uuid - foo2.destroy - end - - it 'retrieve last' do - foo2 = Foo.create! name: 'foo2' - foo = Foo.last - foo.uuid.should eq foo2.uuid - foo2.destroy - end - - it 'take multiple' do - foo2 = Foo.create! name: 'foo2' - foos = Foo.take(2) - foos.size.should == 2 - foos.first.uuid.should_not be_nil - foo2.destroy - end - - it 'find multiple by id' do - foo2 = Foo.create name: 'foo2' - foos = Foo.find @foo.uuid, foo2.uuid - foos.size.should == 2 - foos.first.uuid.should eq @foo.uuid - foos.last.uuid.should eq foo2.uuid - foo2.destroy - end - - it 'find multiple by name' do - foo2 = Foo.create! name: 'foo2' - foos = Foo.find @foo.name, foo2.name - foos.size.should == 2 - foos.first.uuid.should eq @foo.uuid - foos.last.uuid.should eq foo2.uuid - foo2.destroy - end - - it 'check exists?(string)' do - Foo.exists?(@foo.name).should be_true - end - - it 'check not exists?(string)' do - Foo.exists?('asdfasdf').should be_false - end - - it 'check exists?(Array)' do - Foo.exists?(['name = ?', @foo.name]).should be_true - end - - it 'check not exists?(Array)' do - Foo.exists?(['name = ?', 'asdfasdf']).should be_false - end - - it 'check exists?(Hash)' do - Foo.exists?(name: @foo.name).should be_true - end - - it 'check not exists?(Hash)' do - Foo.exists?(name: 'asfasdf').should be_false - end - - it 'check exists?(nil)' do - Foo.exists?.should be_true - end - - it 'check not exists?(nil)' do - Bar.exists?.should be_false - end - - it 'perform first_or_create where found' do - foo = Foo.where(name: @foo.name).first_or_create - foo.uuid.should eq @foo.uuid - end - - it 'perform first_or_create where not found' do - foo = Foo.where(name: 'foo2').first_or_create(number: 42) - foo.name.should eq 'foo2' - foo.number.should == 42 - foo.destroy - end - - it 'perform first_or_create! where found' do - foo = Foo.where(name: @foo.name).first_or_create! - foo.uuid.should eq @foo.uuid - end - - it 'perform first_or_create! where not found' do - expect { Foo.where(nuumber: 'foo2').first_or_create! }.to raise_error(ActiveRecord::RecordNotSaved) - end - - it 'perform first_or_initialize where found' do - foo = Foo.where(name: @foo.name).first_or_initialize(xxx: 42) - foo.uuid.should eq @foo.uuid - foo.xxx.should be_nil - end - - it 'perform first_or_initialize where not found' do - foo = Foo.where(name: 'foo2').first_or_initialize(number: 42) - foo.name.should eq 'foo2' - foo.number.should == 42 - foo.persisted?.should be_false - end - - it "should destroy by id" do - foo = Foo.create! name: 'foo' - Foo.destroy(foo.id) - foo = Foo.find_by_name 'foo' - foo.should be_nil - end - - it "should destroy by ids" do - foo = Foo.create! name: 'foo' - foo2 = Foo.create! name: 'foo2' - Foo.destroy([foo.id, foo2.id]) - Foo.find_by_name('foo').should be_nil - Foo.find_by_name('foo2').should be_nil - end - - it "should destroy_all" do - foo = Foo.create! name: 'foo', number: 42 - foo2 = Foo.create! name: 'foo2', number: 42 - Foo.destroy_all(number: 42) - Foo.find_by_name('foo').should be_nil - Foo.find_by_name('foo2').should be_nil - end - - it "should delete by id" do - foo = Foo.create! name: 'foo' - Foo.delete(foo.id) - foo = Foo.find_by_name 'foo' - foo.should be_nil - end - - it "should delete by ids" do - foo = Foo.create! name: 'foo' - foo2 = Foo.create! name: 'foo2' - Foo.delete([foo.id, foo2.id]) - Foo.find_by_name('foo').should be_nil - Foo.find_by_name('foo2').should be_nil - end - - it "should delete_all" do - foo = Foo.create! name: 'foo', number: 42 - foo2 = Foo.create! name: 'foo2', number: 42 - Foo.delete_all(number: 42) - Foo.find_by_name('foo').should be_nil - Foo.find_by_name('foo2').should be_nil - end - - it "should update one" do - foo = Foo.create! name: 'foo', number: 42 - Foo.update foo.uuid, { number: 43 } - foo.reload.number.should == 43 - foo.destroy - end - - it "should update multiple" do - foo = Foo.create! name: 'foo', number: 42 - foo2 = Foo.create! name: 'foo2', number: 42 - updates = { foo.uuid => {number: 43}, foo2.uuid => {number: 44}} - Foo.update(updates.keys, updates.values) - foo.reload.number.should == 43 - foo2.reload.number.should == 44 - foo.destroy - foo2.destroy - end - - it "should update_all" do - foo = Foo.create! name: 'foo', number: 43 - Foo.where(number: 43).update_all({number: 44}) - Foo.find_by_number(44).should_not be_nil - foo.destroy - end - - it "should fail on unaccessible mass assignment" do - Foo.attr_accessible :name - foo = Foo.create! name: 'foo', number: 43 - foo.number.should_not eq 43 - foo.update_attributes number: 44, foo: 'bar' - foo.number.should_not eq 44 - foo.destroy - Foo._accessible_attributes = nil - end - - it "should fail on protected mass assignment" do - Foo.attr_protected :number - foo = Foo.create! name: 'foo', number: 43 - foo.number.should_not eq 43 - foo.update_attributes number: 44, foo: 'bar' - foo.number.should_not eq 44 - foo.destroy - Foo._protected_attributes = nil - end - - it "should be able to page through results" do - bars = (1..15).collect do |i| - Bar.create! name: "name_#{i}", value: "value_#{i+1}" - end - query = Bar.all - page = query.to_a # first page - page.count.should eq 10 - page = query.next_page # second page - count = 10 - page.each do |bar| - bars[count].name.should eq bar.name - count += 1 - end - count.should eq bars.count - bars.each {|bar| bar.delete} - end - - it "should iterate past page boundaries" do - bars = (1..15).collect do |i| - Bar.create! name: "name_#{i}", value: "value_#{i+1}" - end - count = 0 - Bar.all.each do |bar| - bars[count].name.should eq bar.name - count += 1 - end - count.should eq bars.count - bars.each {|bar| bar.delete} - end - - it "should honor limit" do - bars = (1..15).collect do |i| - Bar.create! name: "name_#{i}", value: "value_#{i+1}" - end - count = 0 - Bar.limit(13).each do |bar| - bars[count].name.should eq bar.name - count += 1 - end - count.should eq 13 - bars.each {|bar| bar.delete} - end - - it "perform as admin only when requested if require_login is true" do - - organization = @foo.management.organization SPEC_SETTINGS[:organization][:name] - - creds = nil - User.as_admin do - creds = organization.credentials - end - - Usergrid::Ironhorse::Base.settings[:client_id] = creds.data.credentials.client_id - Usergrid::Ironhorse::Base.settings[:client_secret] = creds.data.credentials.client_secret - Usergrid::Ironhorse::Base.settings[:auth_token] = nil - User.clear_thread_context - organization.logout - User.settings[:require_login] = true - - # should fail (login is required) - expect { - organization.create_application "_test_app_#{SecureRandom.hex}" - }.to raise_error RestClient::Unauthorized - - # should succeed under admin context - User.as_admin do - organization.create_application "_test_app_#{SecureRandom.hex}" - end - - Usergrid::Ironhorse::Base.settings[:client_id] = nil - Usergrid::Ironhorse::Base.settings[:client_secret] = nil - end - - it "perform as admin if require_login is false" do - - organization = @foo.management.organization SPEC_SETTINGS[:organization][:name] - organization.logout - - creds = nil - User.as_admin do - creds = organization.credentials - end - - Usergrid::Ironhorse::Base.settings[:client_id] = creds.data.credentials.client_id - Usergrid::Ironhorse::Base.settings[:client_secret] = creds.data.credentials.client_secret - Usergrid::Ironhorse::Base.settings[:auth_token] = nil - User.clear_thread_context - organization.logout - - User.settings[:require_login] = false - - # should succeed - organization.create_application "_test_app_#{SecureRandom.hex}" - - Usergrid::Ironhorse::Base.settings[:client_id] = nil - Usergrid::Ironhorse::Base.settings[:client_secret] = nil - end - end -end http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby-on-rails/usergrid_ironhorse.gemspec ---------------------------------------------------------------------- diff --git a/sdks/ruby-on-rails/usergrid_ironhorse.gemspec b/sdks/ruby-on-rails/usergrid_ironhorse.gemspec deleted file mode 100644 index 430c5c1..0000000 --- a/sdks/ruby-on-rails/usergrid_ironhorse.gemspec +++ /dev/null @@ -1,44 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -# -*- encoding: utf-8 -*- -lib = File.expand_path('../lib', __FILE__) -$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) -require 'usergrid_ironhorse/version' - -Gem::Specification.new do |gem| - gem.name = "usergrid_ironhorse" - gem.version = Usergrid::Ironhorse::VERSION - gem.authors = ["Scott Ganyo"] - gem.email = ["[email protected]"] - gem.description = %q{Rails ActiveModel gem to access Usergrid / Apigee App Services} - gem.summary = %q{Usergrid_ironhorse enables simple ActiveModel access to Apigee's App Services - (aka Usergrid) REST API for Rails developers.} - gem.homepage = "https://github.com/scottganyo/usergrid_ironhorse"; - - gem.files = `git ls-files`.split($/) - gem.executables = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) } - gem.test_files = gem.files.grep(%r{^(test|spec|features)/}) - gem.require_paths = ["lib"] - - gem.add_dependency 'usergrid_iron', '0.9.1' - gem.add_dependency 'activemodel', '~> 3.2' - gem.add_dependency 'activerecord', '~> 3.2' - gem.add_dependency 'i18n' - - gem.add_development_dependency 'rake' - gem.add_development_dependency 'rspec' - gem.add_development_dependency 'simplecov' -end http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/.gitignore ---------------------------------------------------------------------- diff --git a/sdks/ruby/.gitignore b/sdks/ruby/.gitignore deleted file mode 100644 index 30b994d..0000000 --- a/sdks/ruby/.gitignore +++ /dev/null @@ -1,18 +0,0 @@ -*.gem -*.rbc -.bundle -.config -.yardoc -Gemfile.lock -InstalledFiles -_yardoc -coverage -doc/ -lib/bundler/man -pkg -rdoc -spec/reports -test/tmp -test/version_tmp -tmp -.idea \ No newline at end of file http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/.rspec ---------------------------------------------------------------------- diff --git a/sdks/ruby/.rspec b/sdks/ruby/.rspec deleted file mode 100644 index c99d2e7..0000000 --- a/sdks/ruby/.rspec +++ /dev/null @@ -1 +0,0 @@ ---require spec_helper http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/.rvmrc ---------------------------------------------------------------------- diff --git a/sdks/ruby/.rvmrc b/sdks/ruby/.rvmrc deleted file mode 100644 index 55148ad..0000000 --- a/sdks/ruby/.rvmrc +++ /dev/null @@ -1,2 +0,0 @@ -rvm_gemset_create_on_use_flag=1 -rvm gemset use 'usergrid_iron' http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/Gemfile ---------------------------------------------------------------------- diff --git a/sdks/ruby/Gemfile b/sdks/ruby/Gemfile deleted file mode 100644 index 9a6d84d..0000000 --- a/sdks/ruby/Gemfile +++ /dev/null @@ -1,19 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -source 'https://rubygems.org' - -# Specify your gem's dependencies in usergrid_iron.gemspec -gemspec http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/LICENSE ---------------------------------------------------------------------- diff --git a/sdks/ruby/LICENSE b/sdks/ruby/LICENSE deleted file mode 100644 index ae1e83e..0000000 --- a/sdks/ruby/LICENSE +++ /dev/null @@ -1,14 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/README.md ---------------------------------------------------------------------- diff --git a/sdks/ruby/README.md b/sdks/ruby/README.md deleted file mode 100644 index 2f6c594..0000000 --- a/sdks/ruby/README.md +++ /dev/null @@ -1,268 +0,0 @@ -# Ruby SDK - -Usergrid_iron enables simple, low-level Ruby access to Apigee's App Services (aka Usergrid) -REST API with minimal dependencies. - -## Installation - -### Project -Add the gem to your project's Gemfile: - - gem 'usergrid_iron' - -Then rebuild your bundle: - - $ bundle - -### Stand-alone script -Just manually install the gem: - - $ gem install usergrid_iron - - -## Usage - -### Prerequisite -You'll want to be at least a little bit familiar with Usergrid / Apigee's App Services before you jump in here - but it easy and it's great! Start here: - - App Services docs: <http://apigee.com/docs/usergrid/> - Open source stack: <https://github.com/apigee/usergrid-stack> - -Awesome. Let's go! - -### Getting started with the Usergrid_iron SDK is simple! - -#### Let's start with the basics. -For this example, we'll assume you've already set up an organization, application, and user - -just fill in your own values in the code below. - -```ruby -require 'usergrid_iron' - -# fill in your values here! -usergrid_api = 'http://localhost:8080' -organization = '' -application = '' -username = '' -password = '' - -# create the base application resource -# (this is a RestClient.resource) -application = Usergrid::Application.new "#{usergrid_api}/#{organization}/#{application}" - -# login (note: not required for sandbox) -application.login username, password - -# create and store a new dog on the server -# (the "response" is an enhanced RestClient.response) -response = application.create_dog breed: 'Black Mouth Cur', name: 'Old Yeller' - -# the response has returned the entity data -# response.entity wraps it in an easy-to-use object -dog = response.entity - -# it's persistent now, so it has a unique id -uuid = dog.uuid - -# we can retrieve the dog by UUID using Hash syntax and calling get() -# (all dogs are stored in the "dogs" collection) -response = application["dogs"][uuid].get -same_dog = response.entity - -# we could also retrieve the dog by name -# we could also use path ('/') syntax instead of nested Hash -# and we can even skip get() - entity() will do it for us -same_dog = application["dogs/#{dog.name}"].entity - -# is it our dog? well, he knows his name! -# (and we can retrieve its values by dot or Hash) -puts "My dog's name is: #{same_dog.name} and his breed is #{same_dog['breed']}" -``` - -Well that was really easy. More comments than code! :) - -#### Let's try something slightly more complex. -Let's say you've registered for an organization, but you don't have an application yet -(or want to create a new one to work on). No worries, just fill in your organization and -superuser credentials below, and follow along! -(Better yet: If you used the Usergrid launcher and let it initialize your database, -you shouldn't need to do anything!) - -```ruby - require 'usergrid_iron' - - usergrid_api = 'http://localhost:8080' - org_name = 'test-organization' - username = 'test' - password = 'test' - app_name = 'dog_sitter' - - ## first, let's get that setup out of the way... ## - - # get a management context & login the superuser - management = Usergrid::Management.new usergrid_api - management.login username, password - - # get the organization context & create a new application - organization = management.organization org_name - new_application = organization.create_application app_name - - # create an user for our application - new_application.create_user username: 'username', password: 'password' - - # login to our new application as our new user - application = organization.application app_name - application.login 'username', 'password' - - - ## now we can play with the puppies! ## - - # we can start with our dog again - application.create_dog breed: 'Black Mouth Cur', name: 'Old Yeller' - - # but this time let's create several more dogs all at once - application.create_dogs [ - { breed: 'Catalan sheepdog', name: 'Einstein' }, - { breed: 'Cocker Spaniel', name: 'Lady' }, - { breed: 'Mixed', name: 'Benji' }] - - # retrieve all the dogs (well, the first 'page' anyway) and tell them hi! - # note: we're calling collection() instead of entity() because we have several - dogs = application['dogs'].collection - - # you can iterate a collection just like an array - dogs.each do |dog| - puts "Hello, #{dog.name}!" - end - - # Let's get Benji ("Benji, come!"), but this time we'll retrieve by query - response = dogs.query "select * where name = 'Benji'" - - # we could call "response.collection.first" - # but there's a shortcut: entity() will also return the first - benji = response.entity - - # modify Benji's attributes & save to the server - benji.location = 'home' # use attribute access - benji['breed'] = 'American Cocker Spaniel' # or access attributes like a Hash - benji.save - - # now query for the dogs that are home (should just be Benji) - dogs = application['dogs'].query("select * where location = 'home'").collection - if dogs.size == 1 && dogs.first.location == 'home' - puts "Benji's home!" - end - -``` - -Whew. That's enough for now. But looking for a specific feature? Check out the [rspecs](http://github.com/scottganyo/usergrid_iron/tree/master/spec/usergrid/core), -there are examples of nearly everything! - - -## Contributing - -We welcome your enhancements! - -1. Fork it -2. Create your feature branch (`git checkout -b my-new-feature`) -3. Write some broken rspecs. -4. Fix the rspecs with your new code. -3. Commit your changes (`git commit -am 'Added some feature'`) -4. Push your changes to the upstream branch (`git push origin my-new-feature`) -5. Create new Pull Request - -We've got 100% rspec coverage and we're looking to keep it that way! -In order to run the tests, check out the Usergrid open source project -(https://github.com/apigee/usergrid-stack), build, and launch it locally. - -(Note: If you change your local Usergrid setting from the default, be sure to update -usergrid_iron/spec/spec_settings.yaml to match.) - - -## Release notes - -### 0.9.2 -* New features - 1. delete_query (batch delete by query) - -### 0.9.1 -* New features - 1. may now login using credentials: application.login_credentials() or organization.login_credentials() - -### 0.9.0 -* Backend changes - 1. login function now uses POST instead of GET - -### 0.0.9 -* Backend changes - 1. made Resource::response accessor public to support ugc - -### 0.0.8 -* Bug fixes - 1. better handling of paging - -### 0.0.7 -* Bug fixes - 1. multiple_entities? should check data['list'] - -### 0.0.6 -* New features - 1. iterators can now optionally cross page boundaries, eg. `collection.follow_cursor.each` - 2. added facebook_login(fb_access_token) method to application - -### 0.0.5 -* New features - 1. added create_* method for application -* Backend changes - 1. eliminated serialization of reserved attributes -* Incompatible changes - 1. deprecated `Application::create_user username, password, ...`, use `create_user username: 'user', password: 'password'` - -### 0.0.4 -* New features - 1. empty? check for collection - 2. update queries (batch update) -* Backend changes - 1. Additional data sanity checks - 2. Additional flexibility in concat_urls - 3. Cleanup - -### 0.0.3 -* New features - 1. Support for lists returned when making parameterized queries: - <pre>select username, email whereâ¦</pre> - or replacement queries: - <pre>select { user:username, email:email } where⦠-* Incompatible changes - 1. Application.create_user parameter change from: - <pre>create_user(username, name, email, password, invite=false)</pre> - to: - <pre>create_user(username, password, email=nil, name=nil, invite=false)</pre> -* Backend changes - 1. Replaced json_pure dependency with multi_json - - -## Notes - -The following features are not currently implemented on the server: - -* delete organization -* delete application -* delete user - - -## License -Licensed to the Apache Software Foundation (ASF) under one or more -contributor license agreements. See the NOTICE file distributed with -this work for additional information regarding copyright ownership. -the ASF licenses this file to You under the Apache License, Version 2.0 -(the "License"); you may not use this file except in compliance with -the License. You may obtain a copy of the License at - - http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -See the License for the specific language governing permissions and -limitations under the License. http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/Rakefile ---------------------------------------------------------------------- diff --git a/sdks/ruby/Rakefile b/sdks/ruby/Rakefile deleted file mode 100644 index bc86b58..0000000 --- a/sdks/ruby/Rakefile +++ /dev/null @@ -1,22 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -#!/usr/bin/env rake -require "bundler/gem_tasks" - -require 'rspec/core/rake_task' -RSpec::Core::RakeTask.new(:spec) - -RSpec::Core::RakeTask.new("spec:coverage") http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/bin/autospec ---------------------------------------------------------------------- diff --git a/sdks/ruby/bin/autospec b/sdks/ruby/bin/autospec deleted file mode 100755 index 64dcb9c..0000000 --- a/sdks/ruby/bin/autospec +++ /dev/null @@ -1,16 +0,0 @@ -#!/usr/bin/env ruby -# -# This file was generated by Bundler. -# -# The application 'autospec' is installed as part of a gem, and -# this file is here to facilitate running it. -# - -require 'pathname' -ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile", - Pathname.new(__FILE__).realpath) - -require 'rubygems' -require 'bundler/setup' - -load Gem.bin_path('rspec-core', 'autospec') http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/bin/htmldiff ---------------------------------------------------------------------- diff --git a/sdks/ruby/bin/htmldiff b/sdks/ruby/bin/htmldiff deleted file mode 100755 index c70e238..0000000 --- a/sdks/ruby/bin/htmldiff +++ /dev/null @@ -1,16 +0,0 @@ -#!/usr/bin/env ruby -# -# This file was generated by Bundler. -# -# The application 'htmldiff' is installed as part of a gem, and -# this file is here to facilitate running it. -# - -require 'pathname' -ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile", - Pathname.new(__FILE__).realpath) - -require 'rubygems' -require 'bundler/setup' - -load Gem.bin_path('diff-lcs', 'htmldiff') http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/bin/ldiff ---------------------------------------------------------------------- diff --git a/sdks/ruby/bin/ldiff b/sdks/ruby/bin/ldiff deleted file mode 100755 index 8e3524a..0000000 --- a/sdks/ruby/bin/ldiff +++ /dev/null @@ -1,16 +0,0 @@ -#!/usr/bin/env ruby -# -# This file was generated by Bundler. -# -# The application 'ldiff' is installed as part of a gem, and -# this file is here to facilitate running it. -# - -require 'pathname' -ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile", - Pathname.new(__FILE__).realpath) - -require 'rubygems' -require 'bundler/setup' - -load Gem.bin_path('diff-lcs', 'ldiff') http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/bin/restclient ---------------------------------------------------------------------- diff --git a/sdks/ruby/bin/restclient b/sdks/ruby/bin/restclient deleted file mode 100755 index 4d7bdcf..0000000 --- a/sdks/ruby/bin/restclient +++ /dev/null @@ -1,16 +0,0 @@ -#!/usr/bin/env ruby -# -# This file was generated by Bundler. -# -# The application 'restclient' is installed as part of a gem, and -# this file is here to facilitate running it. -# - -require 'pathname' -ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile", - Pathname.new(__FILE__).realpath) - -require 'rubygems' -require 'bundler/setup' - -load Gem.bin_path('rest-client', 'restclient') http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/bin/rspec ---------------------------------------------------------------------- diff --git a/sdks/ruby/bin/rspec b/sdks/ruby/bin/rspec deleted file mode 100755 index 0c86b5c..0000000 --- a/sdks/ruby/bin/rspec +++ /dev/null @@ -1,16 +0,0 @@ -#!/usr/bin/env ruby -# -# This file was generated by Bundler. -# -# The application 'rspec' is installed as part of a gem, and -# this file is here to facilitate running it. -# - -require 'pathname' -ENV['BUNDLE_GEMFILE'] ||= File.expand_path("../../Gemfile", - Pathname.new(__FILE__).realpath) - -require 'rubygems' -require 'bundler/setup' - -load Gem.bin_path('rspec-core', 'rspec') http://git-wip-us.apache.org/repos/asf/usergrid/blob/867060fa/sdks/ruby/lib/usergrid/core/application.rb ---------------------------------------------------------------------- diff --git a/sdks/ruby/lib/usergrid/core/application.rb b/sdks/ruby/lib/usergrid/core/application.rb deleted file mode 100644 index 9cc85c4..0000000 --- a/sdks/ruby/lib/usergrid/core/application.rb +++ /dev/null @@ -1,84 +0,0 @@ -# Licensed to the Apache Software Foundation (ASF) under one or more -# contributor license agreements. See the NOTICE file distributed with -# this work for additional information regarding copyright ownership. -# The ASF licenses this file to You under the Apache License, Version 2.0 -# (the "License"); you may not use this file except in compliance with -# the License. You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -module Usergrid - class Application < Resource - - def initialize(url, options={}) - org_name = url.split('/')[-2] - api_url = url[0..url.index(org_name)-2] - super url, api_url, options - end - - # note: collection_name s/b plural, but the server will change it if not - def create_entity(collection_name, entity_data) - self[collection_name].post entity_data - end - alias_method :create_entities, :create_entity - - # allow create_something(hash_or_array) method - def method_missing(method, *args, &block) - method_s = method.to_s - if method_s.start_with? 'create_' - entity = method_s.split('_')[1] - return _create_user *args if entity == 'user' && args[0].is_a?(String) # backwards compatibility - create_entity entity, *args - elsif method_s.end_with? 's' # shortcut for retrieving collections - self[method].query(*args) - else - super method, args, block - end - end - - def counter_names - self['counters'].get.data.data - end - - # other_params: 'start_time' (ms), 'end_time' (ms), 'resolution' (minutes) - def counter(name, other_params={}) - options = other_params.merge({counter: name}) - self['counters'].get({params: options}) - end - - # login with Facebook token. matching user will be created in usergrid as needed. - # usergrid auth token automatically set in auth header for future requests - def facebook_login(access_token) - params = { fb_access_token: access_token } - response = self['auth/facebook'].get({ params: params }) - self.auth_token = response.data['access_token'] - user_uuid = response.data['user']['uuid'] - @current_user = self["/users/#{user_uuid}"].get.entity - response - end - - def login_credentials(client_id, client_secret) - response = self['token'].post grant_type: 'client_credentials', client_id: client_id, client_secret: client_secret - self.auth_token = response.data['access_token'] - end - - private - - def _create_user(username, password, email=nil, name=nil, invite=false) - LOG.warn "create_user(username, password, ...) is deprecated" - user_hash = { username: username, - password: password, - email: email, - name: name, - invite: invite } - create_entity 'users', user_hash - end - - end -end
