user_plane 0.0.15

data/app/models/user/identities/facebook.rb

@@ -0,0 +1,5 @@
+module User::Identities
+  class Facebook < OAuth
+
+  end
+end

data/app/models/user/identities/github.rb

@@ -0,0 +1,5 @@
+module User::Identities
+  class Github < OAuth
+
+  end
+end

data/app/models/user/identities/id_token.rb

@@ -0,0 +1,7 @@
+class User::Identities::IdToken < ActiveRecord::Base
+  include TokenSegment
+
+  belongs_to  :identity, polymorphic: true
+  has_token   :key
+
+end

data/app/models/user/identities/o_auth.rb

@@ -0,0 +1,67 @@
+module User
+  module Identities
+
+    # The class methods have been moved into a separate module so that they
+    # could be added as association extensions if necessary.
+    module OauthBuildCreateAndFind
+
+      def find_identity sign_in
+        find_from_omniauth(sign_in[:oauth_data])
+      end
+
+      def build_identity sign_up
+        identity = initialize_from_omniauth(sign_up[:oauth_data])
+        sign_up.account.oauth_identities << identity
+
+        identity
+      end
+
+      def initialize_from_omniauth ominauth_data
+        identity_provider = provider_from_ominauth(ominauth_data)
+        identity_provider.new(ominauth_data: ominauth_data)
+      end
+
+      def find_from_omniauth ominauth_data
+        identity_provider = provider_from_ominauth(ominauth_data)
+        identity_provider.find_by(uid: ominauth_data[:uid])
+      end
+
+      def find_or_build_from_omniauth ominauth_data
+        find_from_omniauth(ominauth_data) || initialize_from_omniauth(ominauth_data)
+      end
+
+    private
+      def provider_from_ominauth ominauth_data
+        User::Identities.const_get(ominauth_data[:provider].camelize)
+      end
+    end
+
+    class OAuth < Identity
+      # Base class for omniauth-based user authentication
+
+      self.inheritance_column = :provider
+      include SupportSegment::StiHelpers
+      extend OauthBuildCreateAndFind
+
+      belongs_to      :account,  class_name: 'User::Account'
+      has_one         :id_token, as: :identity
+
+      validates :uid, presence: true,
+                      uniqueness: {scope: :provider}
+
+      def self.callback
+        OAuthCallback.new(self.name.underscore.to_sym)
+      end
+
+      before_validation do
+        self.build_id_token
+      end
+
+      def ominauth_data= new_ominauth_data
+        self.uid = new_ominauth_data[:uid]
+        self.handle = new_ominauth_data[:info][:name]
+      end
+    end
+
+  end
+end

data/app/models/user/identities/o_auth_endpoint.rb

@@ -0,0 +1,28 @@
+module User::Identities
+  class OAuthEndpoint
+    extend ActiveModel::Naming
+
+    attr_accessor :provider
+
+    def initialize provider
+      @provider = provider
+    end
+
+    def to_param
+      provider
+    end
+
+    def to_model
+      self
+    end
+
+    def persisted?
+      true
+    end
+
+    def self.model_name
+      ActiveModel::Name.new(self, nil, "OAuthEndpoint")
+    end
+
+  end
+end

data/app/models/user/identities/twitter.rb

@@ -0,0 +1,5 @@
+module User::Identities
+  class Twitter < OAuth
+
+  end
+end

data/app/models/user/identity.rb

@@ -0,0 +1,26 @@
+module User
+  class Identity < ActiveRecord::Base
+    self.abstract_class = true
+
+    def serialize
+      # TODO: create the token when it's missing
+      id_token.key
+    end
+
+    def self.deserialize id_token
+      token = Identities::IdToken.find_by_key(id_token)
+      token ? token.identity : nil
+    end
+
+    def self.deserialize! id_token
+      identity = deserialize(id_token)
+      if identity
+        raise User::AccountSuspended unless identity.account.suspensions.empty?
+        identity
+      else
+        raise ActiveRecord::RecordNotFound
+      end
+    end
+
+  end
+end

data/app/models/user/reset_password.rb

@@ -0,0 +1,59 @@
+module User
+  class ResetPassword < UserPlane::Command
+    include ActiveModel::Validations::Callbacks
+
+    attribute :password
+    attribute :password_confirmation
+
+    attr_accessor :code
+    attr_accessor :verification
+    attr_accessor :identity
+
+    validates :password, :password_confirmation, presence: true
+    validate {|r| r.errors.add(:code, 'is not valid') unless r.verification}
+    validates :verification, presence: true,
+                             receiver: {map_attributes: {created_at: :code,
+                                                         base:       :code,
+                                                         spent_at:   :code}}
+    validates :identity, receiver: {map_attributes: {password: :password,
+                                                     password_confirmation: :password_confirmation}}
+
+    def to_param
+      self.code
+    end
+
+    def persisted?
+      verification && verification.persisted?
+    end
+
+    def code= token
+      @code = token
+
+      password_reset_query = User::Identities::EmailVerification.password_reset.where(token: code)
+      if @identity = User::Identities::Email.joins(:verifications).merge(password_reset_query).first
+        @verification = identity.verifications.detect {|v| v.token == code}
+      else
+        raise ActiveRecord::RecordNotFound
+      end
+    end
+
+    def verification= verification
+      return unless verification
+      @code = verification.token
+      @verification = verification
+      @identity = verification.email
+    end
+
+    before_validation do
+      if verification
+        identity.attributes = {password: password,
+                               password_confirmation: password_confirmation}
+        verification.spend
+      end
+    end
+
+    action do
+      identity.save
+    end
+  end
+end

data/app/models/user/send_password_reset.rb

@@ -0,0 +1,25 @@
+module User
+  class SendPasswordReset < UserPlane::Command
+    attribute :email
+    attr_accessor :code
+    attr_accessor :identity
+    attr_accessor :verification
+
+    def email= address
+      @identity = User::Identities::Email.find_by_address(address)
+      @email = address
+    end
+
+    def persisited?
+      verification ? verification.persisted? : false
+    end
+
+    action do
+      if identity
+        @verification ||= identity.reset_password!
+        @code ||= verification.token
+      end
+    end
+    
+  end
+end

data/app/models/user/send_sign_up_invite.rb

@@ -0,0 +1,27 @@
+module User
+  class SendSignUpInvite < UserPlane::Command
+    include ActiveModel::Validations::Callbacks
+
+    attribute :recipient
+    attribute :invite
+    attribute :stack
+    attribute :sender
+
+    validates :invite, receiver: {map_attributes: {recipient: :recipient}}
+    validates :stack,  receiver: {map_attributes: {remaining_invites: :remaining_invites}}
+
+    before_validation do
+      # The stack can be provided directly if other models have a stack of invites
+      @stack ||= sender.invites_stack
+      @invite ||= stack.invites.build(recipient: recipient, sender: sender)
+    end
+
+    def persisited?
+      invite ? invite.persisted? : false
+    end
+
+    action do
+      invite.save
+    end
+  end
+end

data/app/models/user/sign_in.rb

@@ -0,0 +1,42 @@
+module User
+  class SignIn < UserPlane::Command
+    include ActiveModel::Validations::Callbacks
+
+    model_name.instance_variable_set(:@route_key, 'user_sign_in')
+
+    attribute :email
+    attribute :password
+    attribute :oauth_data
+    attribute :strategy
+    attr_accessor :ominauth_error
+
+    attribute :identity
+
+    validates :ominauth_error, absence: true
+
+
+    validate do |command|
+      if identity = command.identity 
+        unless identity.account.suspensions.empty?
+          command.errors.add(:base, :suspended)
+        end
+      elsif strategy = command.strategy
+        sign_in_error = :"unknown_#{strategy.model_name.singular}"
+        command.errors.add(:base, sign_in_error)
+      else
+        raise "Please choose a strategy to perform the sign in"
+      end
+    end
+
+    def sign_in_with strategy
+      @strategy = strategy
+      @identity = strategy.find_identity(self) if identity.nil?
+      self
+    end
+
+    action do
+      @identity
+    end
+
+  end
+end

data/app/models/user/sign_up.rb

@@ -0,0 +1,47 @@
+module User
+  class SignUp < UserPlane::Command
+    include ActiveModel::Validations::Callbacks
+
+    attribute :user_name
+    
+    attribute :email
+    attribute :password
+    attribute :password_confirmation
+    
+    attribute :account
+    attribute :identity
+
+    attribute :oauth_data
+
+    # Validate command receivers
+    validates :identity, receiver: {map_attributes: {address:  :email,
+                                                     password: :password,
+                                                     password_confirmation: :password_confirmation,
+                                                     uid: :account}}
+    validates :account,        receiver: {map_attributes: {name:       :user_name,
+                                                           identities: :email_or_omniauth}}
+
+    def sign_up_with sign_up_strategy
+      @identity = sign_up_strategy.build_identity(self) if identity.nil?
+      self
+    end
+
+    def account
+      @account ||= new_account
+    end
+
+    action do
+      ActiveRecord::Base.transaction do
+        raise ActiveRecord::Rollback unless account.save
+      end
+    end
+
+  private
+
+    def new_account
+      Account.new(name: user_name)
+    end
+
+  end
+
+end

data/app/models/user/sign_up_invites.rb

@@ -0,0 +1,5 @@
+module User::SignUpInvites
+  def self.table_name_prefix
+    'user_sign_up_invites_'
+  end
+end

data/app/models/user/sign_up_invites/invite.rb

@@ -0,0 +1,46 @@
+module User::SignUpInvites
+  class Invite < ActiveRecord::Base
+    include TokenSegment
+
+
+    belongs_to      :stack
+    belongs_to      :sender, class_name: 'User::Account'
+    belongs_to      :account, class_name: 'User::Account'
+    has_token       :code
+
+    validates :recipient, email: true
+
+    # Once an invite has been associated with an account it cannot be reused
+    validate on: :update do |r|
+      if account_id_changed?
+        previous, current = account_id_change
+        r.errors.add(:base, :redeemed) unless previous.nil?
+      end
+    end
+
+    # Returns a Null invite
+    def self.find_by_code code
+      find_by(code: code) || Null.new(code)      
+    end
+
+  end
+
+  # A Null invite is an invite-like object created when the invite code is not
+  # valid. It will 
+  Null = Struct.new(:code) do
+    include ActiveModel::Validations
+    include NullObjectPersistable
+
+    mimics_persistence_from Invite
+    validate {|r| r.errors.add(:base, :invalid) }
+
+    def method_missing method_name, *arguments
+      return nil if [:stack, :sender, :recipient].include? method_name
+      super 
+    end
+
+    def persisted?
+      true
+    end
+  end
+end

data/app/models/user/sign_up_invites/stack.rb

@@ -0,0 +1,22 @@
+class User::SignUpInvites::Stack < ActiveRecord::Base
+  belongs_to :owner,  polymorphic: true
+  has_many :invites, before_add: :decrement_remaining_invites
+  after_initialize :set_remaining_invites
+
+  # FIXME: the validation above should be enough, but doesn't seem to take effect
+  # validates :remaining_invites, numericality: {greater_than_or_equal: 0}
+  validate do |record|
+    record.errors.add(:remaining_invites, :greater_than_or_equal, value: 0) unless (record.remaining_invites >= 0)
+  end 
+
+private
+
+  def decrement_remaining_invites invite
+    self.remaining_invites -= 1 
+  end
+
+  def set_remaining_invites
+    self.remaining_invites ||= 0
+  end
+
+end

data/app/models/user/sign_up_with_invite.rb

@@ -0,0 +1,45 @@
+# set_callback :invite_set, :after, :set_email_from_invite
+module User
+  class SignUpWithInvite < SignUp
+    attribute :invite
+    attr_accessor :code
+
+
+    define_callbacks :invite_set
+
+    validates :invite, receiver: {map_attributes: {created_at: :invite,
+                                                   base:       :invite,
+                                                   spent:      :invite}}
+
+    validate do |command|
+      # Enforces the need of an invite if the account does not exist
+      if command.account.new_record?
+        command.errors.add_on_blank(:invite) if command.invite.nil?
+      else
+        command.errors.add(:base, :exists)
+      end
+    end
+
+    def to_param
+      self.code
+    end
+
+    def persisted?
+      invite && invite.persisted?
+    end
+
+    def code= code
+      self.invite = SignUpInvites::Invite.find_by_code(code)
+    end
+
+    def invite= invite
+      @code = invite.code
+      run_callbacks(:invite_set) {@invite = invite}
+    end
+
+    before_validation do
+      account.invite = invite
+    end
+
+  end
+end