iugusdk 1.0.0.alpha.0

data/app/controllers/iugu/omniauth_callbacks_controller.rb

@@ -0,0 +1,23 @@
+class Iugu::OmniauthCallbacksController < Devise::OmniauthCallbacksController
+
+  def method_missing(provider)
+    if !User.omniauth_providers.index(provider).nil?
+      if current_user 
+        current_user.find_or_create_social(env["omniauth.auth"])
+        redirect_to after_sign_in_path_for( current_user )
+      else
+        if user = User.find_or_create_by_social(env["omniauth.auth"])
+          select_account user
+          sign_in user
+          redirect_to after_sign_in_path_for( user )
+        else
+          redirect_to (env["omniauth.origin"] || root_path), :notice => I18n.t('errors.messages.email_already_in_use')
+        end 
+      end
+    end
+  end
+  
+  def passthru
+    render :status => 404, :text => "Not found. Authentication passthru."
+  end
+end

data/app/controllers/iugu/passwords_controller.rb

@@ -0,0 +1,2 @@
+class Iugu::PasswordsController < Devise::PasswordsController
+end

data/app/controllers/iugu/profile_controller.rb

@@ -0,0 +1,44 @@
+class Iugu::ProfileController < Iugu::SettingsController
+  
+  def index
+    @user = current_user
+    @social_accounts = @user.social_accounts
+    render 'iugu/settings/profile'
+  end
+
+  def update
+    @user = current_user
+    @social_accounts = @user.social_accounts
+    if @user.update_attributes(params[:user])
+      flash[:notice] = I18n.t('iugu.notices.user_update')
+    else
+      flash[:error] = @user.errors.full_messages
+    end
+    render 'iugu/settings/profile'
+  end
+
+  def destroy
+    (user = current_user).destroy
+    redirect_to(profile_settings_path, :notice => I18n.t("iugu.user_destruction_in") + user.destruction_job.run_at.to_s)
+  end
+
+  def cancel_destruction
+    current_user.cancel_destruction
+    redirect_to(profile_settings_path, :notice => I18n.t("iugu.user_destruction_undone"))
+  end
+
+  def destroy_social
+    begin
+      if social_account = current_user.social_accounts.where(:id => params[:id]).first.unlink
+        notice = I18n.t("iugu.social_unlinked")
+      else
+        notice = I18n.t("errors.messages.only_social_and_no_email")
+      end
+    rescue
+      notice = I18n.t("errors.messages.not_found")
+    end
+    flash[:social] = notice
+    redirect_to profile_settings_path
+  end
+
+end

data/app/controllers/iugu/registrations_controller.rb

@@ -0,0 +1,3 @@
+class Iugu::RegistrationsController < Devise::RegistrationsController
+end
+

data/app/controllers/iugu/sessions_controller.rb

@@ -0,0 +1,2 @@
+class Iugu::SessionsController < Devise::SessionsController
+end

data/app/controllers/iugu/settings_controller.rb

@@ -0,0 +1,11 @@
+class Iugu::SettingsController < ApplicationController
+
+  before_filter :authenticate_user!, :except => :add_social
+
+  layout IuguSDK.default_layout
+
+  def index
+    redirect_to :profile_settings, :notice => flash[:notice]
+  end
+
+end

data/app/controllers/iugu/unlocks_controller.rb

@@ -0,0 +1,2 @@
+class Iugu::UnlocksController < Devise::UnlocksController
+end

data/app/mailers/iugu_mailer.rb

@@ -0,0 +1,16 @@
+class IuguMailer < Devise::Mailer
+
+  default from: "Kupz <equipe@kupz.com.br>",
+          reply_to: "Kupz <atendimento@kupz.com.br>"
+
+  def template_paths
+    "iugu/mailer"
+  end
+
+  def invitation(user_invitation)
+    @user_invitation = user_invitation
+    mail(to: @user_invitation.email, :subject => "Convite para sua conta") do |format|
+      format.html { render "iugu/mailer/invitation" }
+    end
+  end
+end

data/app/models/account.rb

@@ -0,0 +1,53 @@
+class Account < ActiveRecord::Base
+  # Validators
+
+  has_many :account_users, :dependent => :destroy, :include => [:roles,:account]
+  has_many :account_domains, :dependent => :destroy
+  has_many :users, :through => :account_users
+  handle_asynchronously :destroy, :queue => Proc.new { |p| "account_#{p.id}_destroy" },
+                        :run_at => Proc.new { DateTime.now + IuguSDK::delay_account_exclusion }
+
+  validates :subdomain, :uniqueness => true
+  validate :subdomain_blacklist
+
+  def self.get_from_domain(domain)
+    AccountDomain.verified.find_by_url(domain).try(:account) || Account.find_by_subdomain(domain.gsub(".#{IuguSDK::application_main_host}",""))
+  end
+  
+
+  def destruction_job
+    Delayed::Job.find_by_queue("account_#{id}_destroy")
+  end
+
+  def destroying?
+    !!destruction_job
+  end
+
+  def cancel_destruction
+    destruction_job.try(:destroy) unless destruction_job.try(:locked_at)
+  end
+
+  def valid_user_for_account?( user )
+    user = user.try(:id) if user.is_a? Object
+    users.exists? user
+  end
+
+  def is?(role, user)
+    account_users.find_by_user_id(user.id).is?(role.to_s)
+  end
+
+  def name
+    (super.blank? ? "#{I18n.t('iugu.account')} ##{id}" : super)
+  end
+
+  private
+
+  def subdomain_blacklist
+    if subdomain
+      IuguSDK::custom_domain_invalid_prefixes.each do |invalid_prefix|
+        errors.add(:subdomain, "Subdomain blacklisted") if subdomain == invalid_prefix
+      end
+    end
+  end
+
+end

data/app/models/account_domain.rb

@@ -0,0 +1,69 @@
+require 'resolv'
+require 'uri'
+class AccountDomain < ActiveRecord::Base
+  belongs_to :account
+  validates :url, :account_id, :presence => true
+  validate :validate_pattern, :validate_blacklist
+
+  scope :verified, where(:verified => true)
+
+  def normalize_host
+    begin
+      normalized_url = url
+      normalized_url = normalized_url.gsub('www.','')
+      normalized_url = normalized_url.gsub('http://','')
+      normalized_url = normalized_url.gsub('https://','')
+      normalized_url = 'http://' + normalized_url
+      URI.parse(normalized_url).host
+    rescue
+      nil
+    end
+  end
+
+  def calculate_token
+    url = normalize_host
+    Digest::SHA1.hexdigest( "#{id}#{url}" )[8..24]
+  end
+
+  def verify
+    url = normalize_host
+    ref_id = self.calculate_token
+    checked=false
+    begin
+      Socket.gethostbyname( "#{ref_id}.#{url}" )
+      checked=true
+    rescue SocketError
+    end
+    begin
+      response = Net::HTTP.start(url, 80) {|http| http.head("/#{ref_id}.html") }
+      checked = true if response.code == "200"
+    rescue
+    end
+    AccountDomain.where(:url => self.url).update_all(:verified => false) if checked == true
+    update_attribute(:verified, checked)
+    checked
+  end
+
+  def set_primary
+    AccountDomain.where(:account_id => account_id).update_all(:primary => false)
+    update_attribute(:primary, true)
+  end
+
+  private
+
+  def validate_pattern
+    if url
+      errors.add(:url, "Invalid Pattern") unless url.match /^([a-z0-9]*\.)*[a-z0-9]*$/
+    end
+  end
+
+  def validate_blacklist
+    if url
+      IuguSDK::custom_domain_invalid_hosts.each do |invalid_host|
+        errors.add(:url, "Domain on Blacklist") if url == invalid_host
+      end
+    end
+  end
+  
+  
+end

data/app/models/account_role.rb

@@ -0,0 +1,24 @@
+class AccountRole < ActiveRecord::Base
+  belongs_to :account_user
+  validate :valid_role?
+
+  validates_uniqueness_of :name, :scope => :account_user_id, :allow_nil => false
+  validates_presence_of :account_user
+
+  before_destroy do
+    false if only_owner?
+  end
+
+  def self.roles
+    APP_ROLES['roles']
+  end
+
+  private
+  def valid_role?
+    errors.add(:name, "errors.messages.invalid_role") unless APP_ROLES['roles'].include? name
+  end
+
+  def only_owner?
+    self.name == APP_ROLES['owner_role'] && AccountRole.joins(:account_user).where('account_users.account_id = ? AND name = ?', account_user.account_id, :owner).count <= 1
+  end
+end

data/app/models/account_user.rb

@@ -0,0 +1,55 @@
+class AccountUser < ActiveRecord::Base
+  has_many :roles, :class_name => "AccountRole", :dependent => :destroy
+  belongs_to :user
+  belongs_to :account
+
+  after_create :add_default_roles
+
+  validates_presence_of :user
+  validates_presence_of :account
+
+  handle_asynchronously :destroy, :queue => Proc.new { |p| "account_user_#{p.id}_destroy" },
+                        :run_at => Proc.new { DateTime.now + IuguSDK::delay_account_user_exclusion }
+
+
+  def destruction_job
+    Delayed::Job.find_by_queue("account_user_#{id}_destroy")
+  end 
+
+  def destroying?
+    !!destruction_job
+  end 
+
+  def cancel_destruction
+    destruction_job.try(:destroy) unless destruction_job.try(:locked_at)
+  end 
+
+  # Write tests for this
+  def add_default_roles
+    roles.create( { :name => APP_ROLES[ "owner_role" ] } )
+    roles.create( { :name => APP_ROLES[ "admin_role" ] } ) if APP_ROLES[ "owner_role" ] != APP_ROLES[ "admin_role" ]
+  end
+
+  def set_roles(new_roles)
+    if new_roles.nil?
+      roles.destroy_all
+    else
+      valid = true
+      new_roles.each do |new_role|
+        valid = false unless APP_ROLES['roles'].include? new_role
+      end
+      return false unless valid 
+      roles.destroy_all
+      new_roles.each do |new_role|
+        roles.create( :name => new_role )
+      end
+    end
+    true
+  end
+
+  def is?(role)
+    role = APP_ROLES[ "owner_role" ] if role.to_s == "owner"
+    role = APP_ROLES[ "admin_role" ] if role.to_s == "admin"
+    roles.exists?(:name => role)
+  end
+end

data/app/models/available_language.rb

@@ -0,0 +1,10 @@
+class AvailableLanguage
+  def self.all
+    begin
+      YAML.load_file("#{Rails.root.to_s}/config/available_language.yml")['locales']
+    rescue
+      ["en"]
+    end
+  end
+  
+end

data/app/models/social_account.rb

@@ -0,0 +1,14 @@
+class SocialAccount < ActiveRecord::Base
+
+  belongs_to :user
+
+  def unlink
+    if self.user.social_accounts.count == 1 && (self.user.email.blank? || self.user.encrypted_password.blank?)
+      errors.add(:base, "only_social_and_no_email")
+      false
+    else
+      self.destroy
+    end
+  end
+
+end

data/app/models/user.rb

@@ -0,0 +1,107 @@
+class User < ActiveRecord::Base
+  # Include default devise modules. Others available are:
+  # :token_authenticatable, :trackable, :validatable,
+  # :lockable and :timeoutable 
+  
+  has_many :account_users, :dependent => :destroy, :include => [:roles,:account]
+  has_many :accounts, :through => :account_users
+  has_many :social_accounts, :dependent => :destroy
+
+  handle_asynchronously :destroy, :queue => Proc.new { |p| "user_#{p.id}_destroy" },
+                        :run_at => Proc.new { DateTime.now + IuguSDK::delay_user_exclusion }
+
+  devise :database_authenticatable, :registerable, :confirmable,
+         :recoverable, :rememberable, :validatable, :omniauthable
+
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :email, :password, :password_confirmation, :remember_me, :locale, :name, :birthdate
+
+  after_create :create_account_for_user
+
+  validates :email, :email => true
+
+  def destruction_job
+    Delayed::Job.find_by_queue("user_#{id}_destroy")
+  end
+
+  def destroying?
+    !!destruction_job
+  end
+
+  def cancel_destruction
+    destruction_job.try(:destroy) unless destruction_job.try(:locked_at)
+  end
+
+  def is?(role, account)
+    account.account_users.find_by_user_id(self.id).is?(role.to_s)
+  end
+
+  def has_social?
+    !social_accounts.empty?
+  end
+
+  def find_or_create_social(auth)
+    social_accounts.where("provider = ? AND social_id = ?", auth["provider"], auth["uid"]).first || create_social(auth)
+  end
+
+  def self.find_or_create_by_social(auth)
+    social_account = SocialAccount.where("provider = ? AND social_id = ?", auth["provider"], auth["uid"]).first
+    unless user = social_account.try(:user)
+      user = User.new
+      if auth["extra"]["raw_info"]["email"]
+        return false if !User.where(:email => auth["extra"]["raw_info"]["email"]).empty?
+        user.email = auth["extra"]["raw_info"]["email"]
+      end
+      user.skip_confirmation!
+      user.save(:validate => false)
+      social_account = user.create_social(auth)
+    end
+    social_account.update_attribute( 'token' , auth['credentials']['token'] )
+    user
+  end
+
+  def create_social(auth)
+    social_accounts.create! do |social_account|
+      social_account.provider = auth["provider"]
+      social_account.social_id = auth["uid"]
+      social_account.token = auth["credentials"]["token"]
+      social_account.user_id = self.id
+    end
+  end
+
+  def devise_mailer
+    IuguMailer
+  end
+
+  def accountable?
+    !!!@skip_account_creation
+  end
+
+  def skip_create_account!
+    @skip_account_creation = true
+  end
+
+  def default_account( account_id=nil )
+    account_id = account_id.id if account_id.is_a? Account
+    self.accounts.where( [ "accounts.id = ?", account_id] ).first || self.accounts.first
+  end
+
+  private
+
+  def email_required?
+    !has_social?
+  end
+
+  #def self.reconfirmable
+  #  true
+  #end
+
+  @reconfirmable = true
+  
+  def create_account_for_user
+    if accountable?
+      new_account = Account.create({})
+      account_user = new_account.account_users.create( { :user => self } )
+    end
+  end
+end