parse-stack 1.4.3 → 1.5.1

data/lib/parse/model/associations/has_one.rb

@@ -0,0 +1,69 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative '../pointer'
+require_relative 'collection_proxy'
+require_relative 'pointer_collection_proxy'
+require_relative 'relation_collection_proxy'
+# a given Parse Pointer. The key of the property is implied to be the
+# name of the class/parse table that contains the foreign associated record.
+# All belongs to relationship column types have the special data type of :pointer.
+module Parse
+  module Associations
+
+    module HasOne
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+
+        # has one are not property but instance scope methods
+        def has_one(key, scope = nil, **opts)
+
+          opts.reverse_merge!({as: key, field: parse_class.columnize, scope_only: false})
+          klassName = opts[:as].to_parse_class
+          foreign_field = opts[:field].to_sym
+          ivar = :"@_has_one_#{key}"
+
+          if self.method_defined?(key)
+            puts "Creating has_one :#{key} association. Will overwrite existing method #{self}##{key}."
+          end
+
+          define_method(key) do |*args, &block|
+            return nil if @id.nil?
+            query = Parse::Query.new(klassName, limit: 1)
+            query.where(foreign_field => self) unless opts[:scope_only] == true
+
+            if scope.is_a?(Proc)
+              # any method not part of Query, gets delegated to the instance object
+              instance = self
+              query.define_singleton_method(:method_missing) { |m, *args, &block| instance.send(m, *args, &block) }
+              query.define_singleton_method(:i) { instance }
+
+              if scope.arity.zero?
+                query.instance_exec(&scope)
+                query.conditions(*args) if args.present?
+              else
+                query.instance_exec(*args,&scope)
+              end
+              instance = nil # help clean up ruby gc
+            elsif args.present?
+              query.conditions(*args)
+            end
+            # query.define_singleton_method(:method_missing) do |m, *args, &block|
+            #   self.first.send(m, *args, &block)
+            # end
+            return query.first if block.nil?
+            block.call(query.first)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/parse/model/associations/pointer_collection_proxy.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support'
 require 'active_support/inflector'
@@ -21,8 +24,8 @@ module Parse
     # If they are not, and it is a hash, we check to see if it is a Parse hash.
     def add(*items)
       notify_will_change! if items.count > 0
-      items.flatten.parse_pointers.each do |item|
-        collection.push(item)
+      items.flatten.parse_objects.each do |item|
+        collection.push(item) if item.is_a?(Parse::Pointer)
       end
       @collection
     end
@@ -30,20 +33,20 @@ module Parse
     # removes items from the collection
     def remove(*items)
       notify_will_change! if items.count > 0
-      items.flatten.parse_pointers.each do |item|
+      items.flatten.parse_objects.each do |item|
         collection.delete item
       end
       @collection
     end
-    
+
     def add!(*items)
       super(items.flatten.parse_pointers)
     end
-    
+
     def add_unique!(*items)
       super(items.flatten.parse_pointers)
     end
-    
+
     def remove!(*items)
       super(items.flatten.parse_pointers)
     end
@@ -66,6 +69,10 @@ module Parse
       collection.parse_pointers.as_json
     end
 
+    def parse_pointers
+      collection.parse_pointers
+    end
+
   end
 
 end

data/lib/parse/model/associations/relation_collection_proxy.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/inflector'
 require 'active_support/core_ext/object'
@@ -66,7 +69,7 @@ module Parse
     # is adding it to the @additions array and making sure it is
     # removed from the @removals array.
     def add(*items)
-      items = items.flatten.parse_pointers
+      items = items.flatten.parse_objects
       return @collection if items.empty?
 
       notify_will_change!
@@ -86,7 +89,7 @@ module Parse
     # The process of removing is deleting it from the @removals array,
     # and adding it to the @additions array.
     def remove(*items)
-      items = items.flatten.parse_pointers
+      items = items.flatten.parse_objects
       return @collection if items.empty?
       notify_will_change!
       additions_will_change!

data/lib/parse/model/bytes.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_support'
 require 'active_support/core_ext/object'
 require_relative "model"
@@ -7,6 +10,7 @@ require 'base64'
 module Parse
 
   class Bytes < Model
+    ATTRIBUTES = {__type: :string, base64: :string }.freeze
     attr_accessor :base64
     def parse_class; TYPE_BYTES; end;
     def parse_class; self.class.parse_class; end;
@@ -18,7 +22,7 @@ module Parse
     end
 
     def attributes
-      {__type: :string, base64: :string }.freeze
+      ATTRIBUTES
     end
 
     # takes a string and base64 encodes it
@@ -35,7 +39,7 @@ module Parse
       if a.is_a?(String)
       @bytes = a
       elsif a.is_a?(Hash)
-        @bytes = a["base64".freeze] || @bytes
+        @bytes = a["base64"] || @bytes
       end
     end
 

data/lib/parse/model/classes/installation.rb

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+require_relative '../object'
+
+module Parse
+
+  class Installation < Parse::Object
+    parse_class Parse::Model::CLASS_INSTALLATION
+
+    property :gcm_sender_id, :string, field: :GCMSenderId
+    property :app_identifier
+    property :app_name
+    property :app_version
+    property :badge, :integer
+    property :channels, :array
+    property :device_token
+    property :device_token_last_modified, :integer
+    property :device_type
+    property :installation_id
+    property :locale_identifier
+    property :parse_version
+    property :push_type
+    property :time_zone
+
+  end
+
+end

data/lib/parse/model/classes/role.rb

@@ -0,0 +1,20 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+require_relative '../object'
+require_relative 'user'
+module Parse
+
+  class Role < Parse::Object
+    parse_class Parse::Model::CLASS_ROLE
+    property :name
+
+    has_many :roles, through: :relation
+    has_many :users, through: :relation
+
+    before_save do
+      acl.everyone true, false
+    end
+
+  end
+
+end

data/lib/parse/model/classes/session.rb

@@ -0,0 +1,26 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+require_relative '../object'
+
+module Parse
+  class Session < Parse::Object
+    parse_class Parse::Model::CLASS_SESSION
+    property :created_with, :object
+    property :expires_at, :date
+    property :installation_id
+    property :restricted, :boolean
+    property :session_token
+
+    belongs_to :user
+
+    def self.session(token)
+      response = client.fetch_session(token)
+      if response.success?
+        reutrn Parse::Session.build response.result
+      end
+      nil
+    end
+
+  end
+
+end

data/lib/parse/model/classes/user.rb

@@ -0,0 +1,185 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# The User class provided by Parse with the required fields. You may
+# add mixings to this class to add the app specific properties
+require_relative '../object'
+module Parse
+
+  class UsernameMissingError < StandardError; end; # 200
+  class PasswordMissingError < StandardError; end; # 201
+  class UsernameTakenError < StandardError; end; # 202
+  class EmailTakenError < StandardError; end; # 203
+  class EmailMissing < StandardError; end; # 204
+
+  class User < Parse::Object
+
+    parse_class Parse::Model::CLASS_USER
+    attr_accessor :session_token
+    property :auth_data, :object
+    property :email
+    property :password
+    property :username
+
+    before_save do
+      # You cannot specify user ACLs.
+      self.clear_attribute_change!(:acl)
+    end
+
+    def anonymous?
+      anonymous_id.nil?
+    end
+
+    def anonymous_id
+      auth_data['anonymous']['id'] if auth_data.present? && auth_data["anonymous"].is_a?(Hash)
+    end
+
+    def link_auth_data!(service_name, **data)
+      response = client.set_service_auth_data(id, service_name, data)
+      apply_attributes!(response.result) if response.success?
+      response.success?
+    end
+
+    def unlink_auth_data!(service_name)
+      response = client.set_service_auth_data(id, service_name, nil)
+      apply_attributes!(response.result) if response.success?
+      response.success?
+    end
+
+    # So that apply_attributes! works with session_token for login
+    def session_token_set_attribute!(token, track = false)
+      @session_token = token.to_s
+    end
+    alias_method :sessionToken_set_attribute!, :session_token_set_attribute!
+
+    def logged_in?
+      self.session_token.present?
+    end
+
+    def request_password_reset
+      return false if email.nil?
+      Parse::User.request_password_reset(email)
+    end
+
+    def signup!(passwd = nil)
+      self.password = passwd || password
+      if username.blank?
+        raise Parse::UsernameMissingError, "Signup requires an username."
+      end
+
+      if password.blank?
+        raise Parse::PasswordMissingError, "Signup requires a password."
+      end
+
+      signup_attrs = attribute_updates
+      signup_attrs.except! *Parse::Properties::BASE_FIELD_MAP.flatten
+
+      # first signup the user, then save any additional attributes
+      response = client.create_user signup_attrs
+
+      if response.success?
+        apply_attributes! response.result
+        return true
+      end
+
+      case response.code
+      when Parse::Response::ERROR_USERNAME_MISSING
+        raise Parse::UsernameMissingError, response
+      when Parse::Response::ERROR_PASSWORD_MISSING
+        raise Parse::PasswordMissingError, response
+      when Parse::Response::ERROR_USERNAME_TAKEN
+        raise Parse::UsernameTakenError, response
+      when Parse::Response::ERROR_EMAIL_TAKEN
+        raise Parse::EmailTakenError, response
+      end
+      raise response
+    end
+
+    def login!(passwd = nil)
+      self.password = passwd || self.password
+      response = client.login(username.to_s, password.to_s)
+      apply_attributes! response.result
+      self.session_token.present?
+    end
+
+    def logout
+      return true if self.session_token.blank?
+      client.logout session_token
+      self.session_token = nil
+      true
+    rescue => e
+      false
+    end
+
+    def session_token=(token)
+      @session = nil
+      @session_token = token
+    end
+
+    def session
+      if @session.blank? && @session_token.present?
+        response = client.fetch_session(@session_token)
+        @session ||= Parse::Session.new(response.result)
+      end
+      @session
+    end
+
+    def self.create(body, **opts)
+      response = client.create_user(body, opts: opts)
+      if response.success?
+        return Parse::User.build response.result
+      end
+
+      case response.code
+      when Parse::Response::ERROR_USERNAME_MISSING
+        raise Parse::UsernameMissingError, response
+      when Parse::Response::ERROR_PASSWORD_MISSING
+        raise Parse::PasswordMissingError, response
+      when Parse::Response::ERROR_USERNAME_TAKEN
+        raise Parse::UsernameTakenError, response
+      when Parse::Response::ERROR_EMAIL_TAKEN
+        raise Parse::EmailTakenError, response
+      end
+      raise response
+    end
+
+    # method will signup or login a user given the third-party authentication data
+    def self.autologin_service(service_name, auth_data, body: {})
+      body = body.merge({authData: {service_name => auth_data} })
+      self.create(body)
+    end
+
+    def self.signup(username, password, email = nil, body: {})
+      body = body.merge({username: username, password: password })
+      body[:email] = email if email.present?
+      self.create(body)
+    end
+
+    def self.login(username, password)
+      response = client.login(username.to_s, password.to_s)
+      response.success? ? Parse::User.build(response.result) : nil
+    end
+
+    def self.request_password_reset(email)
+      email = email.email if email.is_a?(Parse::User)
+      return false if email.blank?
+      response = client.reset_password(email)
+      response.success?
+    end
+
+    def self.session(token)
+      self.session! token
+    rescue InvalidSessionTokenError => e
+      nil
+    end
+
+    def self.session!(token)
+      # support Parse::Session objects
+      token = token.session_token if token.respond_to?(:session_token)
+      response = client.current_user(token)
+      response.success? ? Parse::User.build(response.result) : nil
+    end
+
+  end
+
+end

data/lib/parse/model/core/actions.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support'
 require 'active_support/inflector'
@@ -14,8 +17,8 @@ require_relative '../../client/request'
 # hash request format Parse needs in order to modify relational information for classes.
 module Parse
   class RelationAction
-    ADD = "AddRelation".freeze
-    REMOVE = "RemoveRelation".freeze
+    ADD = "AddRelation"
+    REMOVE = "RemoveRelation"
     attr_accessor :polarity, :key, :objects
     # provide the column name of the field, polarity (true = add, false = remove) and the
     # list of objects.
@@ -153,7 +156,7 @@ module Parse
         op_hash = { field => op_hash }.as_json
       end
 
-      response = client.update_object(parse_class, id, op_hash )
+      response = client.update_object(parse_class, id, op_hash, session_token: _session_token )
       if response.error?
         puts "[#{parse_class}:#{field} Operation] #{response.error}"
       end
@@ -243,7 +246,7 @@ module Parse
           warn "[#{parse_class}] warning: #{msg}"
         end
       end
-      response = client.update_object(parse_class, id, attribute_updates)
+      response = client.update_object(parse_class, id, attribute_updates, session_token: _session_token)
       if response.success?
         result = response.result
         # Because beforeSave hooks can change the fields we are saving, any items that were
@@ -263,28 +266,38 @@ module Parse
 
     # create this object in Parse
     def create
-      res = client.create_object(parse_class, attribute_updates )
-      unless res.error?
-        result = res.result
-        @id = result["objectId"] || @id
-        @created_at = result["createdAt"] || @created_at
-        #if the object is created, updatedAt == createdAt
-        @updated_at = result["updatedAt"] || result["createdAt"] || @updated_at
-        # Because beforeSave hooks can change the fields we are saving, any items that were
-        # changed, are returned to us and we should apply those locally to be in sync.
-        set_attributes!(result)
+      run_callbacks :create do
+        res = client.create_object(parse_class, attribute_updates, session_token: _session_token)
+        unless res.error?
+          result = res.result
+          @id = result[Parse::Model::OBJECT_ID] || @id
+          @created_at = result["createdAt"] || @created_at
+          #if the object is created, updatedAt == createdAt
+          @updated_at = result["updatedAt"] || result["createdAt"] || @updated_at
+          # Because beforeSave hooks can change the fields we are saving, any items that were
+          # changed, are returned to us and we should apply those locally to be in sync.
+          set_attributes!(result)
+        end
+        puts "Error creating #{self.parse_class}: #{res.error}" if res.error?
+        res.success?
       end
-      puts "Error creating #{self.parse_class}: #{res.error}" if res.error?
-      res.success?
+    end
+
+    def _session_token
+      if @_session_token.respond_to?(:session_token)
+        @_session_token = @_session_token.session_token
+      end
+      @_session_token
     end
 
     # saves the object. If the object has not changed, it is a noop. If it is new,
     # we will create the object. If the object has an id, we will update the record.
     # You can define before and after :save callbacks
     # autoraise: set to true will automatically raise an exception if the save fails
-    def save(autoraise: false)
+    def save(autoraise: false, session: nil)
       return true unless changed?
       success = false
+      @_session_token = session
       run_callbacks :save do
         #first process the create/update action if any
         #then perform any relation changes that need to be performed
@@ -311,21 +324,23 @@ module Parse
         end
 
       end #callbacks
+      @_session_token = nil
       success
     end
 
     # shortcut for raising an exception of saving this object failed.
-    def save!
-      save(autoraise: true)
+    def save!(session: nil)
+      save(autoraise: true, session: session)
     end
 
     # only destroy the object if it has an id. You can setup before and after
     #callback hooks on :destroy
-    def destroy
+    def destroy(session: nil)
       return false if new?
+      @_session_token = session
       success = false
       run_callbacks :destroy do
-        res = client.delete_object parse_class, id
+        res = client.delete_object parse_class, id, session_token: _session_token
         success = res.success?
         if success
           @id = nil
@@ -335,6 +350,7 @@ module Parse
         end
         # Your create action methods here
       end
+      @_session_token = nil
       success
     end
 
@@ -386,16 +402,14 @@ module Parse
       raise "Unable to update relations for a new object." if new?
       # get all the relational changes (both additions and removals)
       additions, removals = relation_change_operations
-      # removal_response = client.update_object(parse_class, id, removals)
-      # addition_response = client.update_object(parse_class, id, additions)
+
       responses = []
       # Send parallel Parse requests for each of the items to update.
       # since we will have multiple responses, we will track it in array
       [removals, additions].threaded_each do |ops|
         next if ops.empty? #if no operations to be performed, then we are done
-        responses << client.update_object(parse_class, @id, ops)
+        responses << client.update_object(parse_class, @id, ops, session_token: _session_token)
       end
-      #response = client.update_object(parse_class, id, relation_updates)
       # check if any of them ended up in error
       has_error = responses.any? { |response| response.error? }
       # if everything was ok, find the last response to be returned and update
@@ -410,7 +424,7 @@ module Parse
     def set_attributes!(hash, dirty_track = false)
       return unless hash.is_a?(Hash)
       hash.each do |k,v|
-        next if k == "objectId".freeze || k == "id".freeze
+        next if k == Parse::Model::OBJECT_ID || k == Parse::Model::ID
         method = "#{k}_set_attribute!"
         send(method, v, dirty_track) if respond_to?(method)
       end