catarse_full 0.0.1

data/app/helpers/channels/base_helper.rb

@@ -0,0 +1,2 @@
+module Channels::BaseHelper
+end

data/app/mailers/credits_mailer.rb

@@ -0,0 +1,9 @@
+class CreditsMailer < ActionMailer::Base
+  include ERB::Util
+
+  def request_refund_from(backer)
+    @backer = backer
+    @user = backer.user
+    mail(from: "#{@user.name} <#{@user.email}>", to: ::Configuration[:email_payments], subject: I18n.t('credits_mailer.request_refund_from.subject', name: @backer.project.name))
+  end
+end

data/app/mailers/notifications_mailer.rb

@@ -0,0 +1,21 @@
+class NotificationsMailer < ActionMailer::Base
+  def notify(notification)
+    @notification = notification
+    old_locale = I18n.locale
+    I18n.locale = @notification.user.locale if I18n.locale.to_s != @notification.user.locale.to_s # we need this if to avoid stack overflow in controller
+    from_email = (@notification.mail_params && @notification.mail_params.has_key?(:from)) ? @notification.mail_params[:from] : ::Configuration['email_contact']
+    address = Mail::Address.new from_email
+    address.display_name = (@notification.mail_params && @notification.mail_params.has_key?(:display_name)) ? @notification.mail_params[:display_name] : ::Configuration[:company_name]
+    subject = I18n.t("notifications.#{@notification.notification_type.name}.subject", @notification.mail_params)
+    @header = I18n.t("notifications.#{@notification.notification_type.name}.header", @notification.mail_params)
+    m = mail({
+      from: address.format,
+      to: @notification.user.email,
+      subject: subject
+    }) do |format|
+      format.html { render @notification.notification_type.name, layout: @notification.notification_type.layout }
+    end
+    I18n.locale = old_locale if I18n.locale.to_s != @notification.user.locale.to_s
+    m
+  end
+end

data/app/models/ability.rb

@@ -0,0 +1,129 @@
+# coding: utf-8
+class Ability
+  include CanCan::Ability
+
+  def initialize(current_user, options = {})
+    current_user ||= User.new
+
+    can :read, :all
+
+    # NOTE: Update authorizations
+    can :access, :updates do |update|
+      update.project.user_id == current_user.id
+    end
+    can :see, :updates do |update|
+      !update.exclusive || !current_user.backs.confirmed.where(project_id: update.project.id).empty?
+    end
+
+    # NOTE: Project authorizations
+    can :create, :projects if current_user.persisted?
+
+    can :update, :projects, [:about, :video_url, :uploaded_image, :headline ] do |project|
+      project.user == current_user && ( project.online? || project.waiting_funds? || project.successful? || project.failed? )
+    end
+
+    can :update, :projects do |project|
+      project.user == current_user && ( project.draft? || project.rejected? )
+    end
+
+
+    # NOTE: Reward authorizations
+    can :create, :rewards do |reward|
+      reward.project.user == current_user
+    end
+
+    can [:update, :destroy], :rewards do |reward|
+      reward.backers.in_time_to_confirm.empty? && reward.backers.confirmed.empty? && reward.project.user == current_user
+    end
+
+    can [:update, :sort], :rewards, [:description, :maximum_backers] do |reward|
+      reward.project.user == current_user
+    end
+
+    can :update, :rewards, :days_to_delivery do |reward|
+      reward.project.user == current_user && !reward.project.successful? && !reward.project.failed?
+    end
+
+    # NOTE: User authorizations
+    can :set_email, :users do |user|
+      current_user.persisted?
+    end
+
+    can [:update, :credits, :manage, :update_password, :update_email], :users  do |user|
+      current_user == user
+    end
+
+    can :update, :users, :admin do |user|
+      current_user.admin
+    end
+
+
+    # NOTE: Backer authorizations
+    cannot :show, :backers
+    can :create, :backers if current_user.persisted?
+
+    can [ :request_refund, :credits_checkout, :show, :update_info], :backers do |backer|
+      backer.user == current_user
+    end
+
+    cannot :update_info, :backers, [:user_attributes, :user_id, :user, :value, :payment_service_fee, :payment_id] do |backer|
+      backer.user == current_user
+    end
+
+    # Channel authorizations
+    # Due to previous abilities, first I activate all things
+    # and in the final I deactivate unnecessary abilities.
+    can :create, :channels_subscribers if current_user.persisted?
+    can :destroy, :channels_subscribers do |cs|
+      cs.user == current_user
+    end
+
+    if current_user.trustee?
+
+      can :access, :all
+      cannot :access, :projects
+      cannot :access, :rewards
+
+      can :create, :projects
+      can :access, :projects do |project|
+        current_user.channels_projects.exists?(project)
+      end
+
+
+      can :access, :rewards do |reward|
+        current_user.channels_projects.exists?(reward.project)
+      end
+
+
+      # For the access, :all
+      # we're removing the ability to update users at all, but
+      cannot [:update, :destroy], :users
+
+      # He can update himself
+      can :update, :users do |user|
+        user == current_user
+      end
+
+      # Nobody can destroy projects.
+      cannot :destroy, :projects
+    end
+
+    # A trustee cannot access the adm/ path
+    # He can only do this if he is an admin too.
+    case options[:namespace]
+      when "Adm"
+        if current_user.trustee? && !current_user.admin?
+          cannot :access, :all
+        end
+      else
+    end
+
+
+
+    # NOTE: admin can access everything.
+    # It's the last ability to override all previous abilities.
+    can :access, :all if current_user.admin?
+
+
+  end
+end

data/app/models/authorization.rb

@@ -0,0 +1,4 @@
+class Authorization < ActiveRecord::Base
+  attr_accessible :oauth_provider, :oauth_provider_id, :uid, :user_id
+  schema_associations
+end

data/app/models/backer.rb

@@ -0,0 +1,242 @@
+require 'state_machine'
+# coding: utf-8
+class Backer < ActiveRecord::Base
+  include ActionView::Helpers::NumberHelper
+  include ActionView::Helpers::DateHelper
+
+  schema_associations
+
+  validates_presence_of :project, :user, :value
+  validates_numericality_of :value, greater_than_or_equal_to: 10.00
+  validate :reward_must_be_from_project
+  validate :value_must_be_at_least_rewards_value
+  validate :should_not_back_if_maximum_backers_been_reached, on: :create
+  validate :project_should_be_online, on: :create
+
+  scope :not_deleted, ->() { where("backers.state <> 'deleted'") }
+  scope :not_canceled, ->() { where("backers.state <> 'canceled'") }
+  scope :by_id, ->(id) { where(id: id) }
+  scope :by_state, ->(state) { where(state: state) }
+  scope :by_key, ->(key) { where(key: key) }
+  scope :by_user_id, ->(user_id) { where(user_id: user_id) }
+  scope :user_name_contains, ->(term) { joins(:user).where("unaccent(upper(users.name)) LIKE ('%'||unaccent(upper(?))||'%')", term) }
+  scope :project_name_contains, ->(term) { joins(:project).where("unaccent(upper(projects.name)) LIKE ('%'||unaccent(upper(?))||'%')", term) }
+  scope :anonymous, where(anonymous: true)
+  scope :credits, where(credits: true)
+  scope :requested_refund, where(state: 'requested_refund')
+  scope :refunded, where(state: 'refunded')
+  scope :not_anonymous, where(anonymous: false)
+  scope :confirmed, where(state: 'confirmed')
+  scope :waiting_confirmation, where(state: 'waiting_confirmation')
+  scope :not_confirmed, where("backers.state <> 'confirmed'") # used in payment engines
+  scope :in_time_to_confirm, ->() { where(state: 'waiting_confirmation') }
+  scope :pending_to_refund, ->() { where(state: 'requested_refund') }
+
+  scope :available_to_count, ->() { where("state in ('confirmed', 'requested_refund', 'refunded')") }
+  scope :available_to_display, ->() { where("state in ('confirmed', 'requested_refund', 'refunded', 'waiting_confirmation')") }
+
+  scope :can_cancel, ->() {
+    where(%Q{
+      backers.state = 'waiting_confirmation' and
+        (
+          ((
+            select count(1) as total_of_days
+            from generate_series(created_at::date, current_date, '1 day') day
+            WHERE extract(dow from day) not in (0,1)
+          )  > 4)
+          OR
+          (
+            payment_choice = 'DebitoBancario'
+            AND
+              (
+                select count(1) as total_of_days
+                from generate_series(created_at::date, current_date, '1 day') day
+                WHERE extract(dow from day) not in (0,1)
+              )  > 1)
+        )
+    })
+  }
+
+  # Backers already refunded or with requested_refund should appear so that the user can see their status on the refunds list
+  scope :can_refund, ->{
+    where(%Q{
+      backers.state IN('confirmed', 'requested_refund', 'refunded') AND
+      NOT backers.credits AND
+      EXISTS(
+        SELECT true
+          FROM projects p
+          WHERE p.id = backers.project_id and p.state = 'failed'
+      )
+    })
+  }
+
+  attr_protected :confirmed, :state
+
+  def self.between_values(start_at, ends_at)
+    return scoped unless start_at.present? && ends_at.present?
+    where("value between ? and ?", start_at, ends_at)
+  end
+
+  def self.state_names
+    self.state_machine.states.map do |state|
+      state.name if state.name != :deleted
+    end.compact!
+  end
+
+  def self.send_credits_notification
+    confirmed.joins(:project).joins(:user).find_each do |backer|
+      if backer.project.state == 'failed' && ((backer.project.expires_at + 1.month) < Time.now) && backer.user.credits >= backer.value
+        Notification.create_notification_once(:credits_warning,
+          backer.user,
+          {backer_id: backer.id},
+          backer: backer,
+          amount: backer.user.credits
+                                             )
+      end
+    end
+  end
+
+  def recommended_projects
+    user.recommended_projects.where("projects.id <> ?", project.id)
+  end
+
+  def refund_deadline
+    created_at + 180.days
+  end
+
+  def change_reward! reward
+    self.reward_id = reward
+    self.save
+  end
+
+  def can_refund?
+    confirmed? && project.finished? && !project.successful?
+  end
+
+  def reward_must_be_from_project
+    return unless reward
+    errors.add(:reward, I18n.t('backer.reward_must_be_from_project')) unless reward.project == project
+  end
+
+  def value_must_be_at_least_rewards_value
+    return unless reward
+    errors.add(:value, I18n.t('backer.value_must_be_at_least_rewards_value', minimum_value: reward.display_minimum)) unless value.to_f >= reward.minimum_value
+  end
+
+  def should_not_back_if_maximum_backers_been_reached
+    return unless reward && reward.maximum_backers && reward.maximum_backers > 0
+    errors.add(:reward, I18n.t('backer.should_not_back_if_maximum_backers_been_reached')) if reward.sold_out?
+  end
+
+  def project_should_be_online
+    return if project && project.online?
+    errors.add(:project, I18n.t('backer.project_should_be_online'))
+  end
+
+  def display_value
+    number_to_currency value
+  end
+
+  def available_rewards
+    Reward.where(project_id: self.project_id).where('minimum_value <= ?', self.value).order(:minimum_value)
+  end
+
+  def display_confirmed_at
+    I18n.l(confirmed_at.to_date) if confirmed_at
+  end
+
+  def update_current_billing_info
+    self.address_street = user.address_street
+    self.address_number = user.address_number
+    self.address_neighbourhood = user.address_neighbourhood
+    self.address_zip_code = user.address_zip_code
+    self.address_city = user.address_city
+    self.address_state = user.address_state
+    self.address_phone_number = user.phone_number
+    self.payer_document = user.cpf
+  end
+
+  def update_user_billing_info
+    user.update_attributes({
+      address_street: address_street,
+      address_number: address_number,
+      address_neighbourhood: address_neighbourhood,
+      address_zip_code: address_zip_code,
+      address_city: address_city,
+      address_state: address_state,
+      phone_number: address_phone_number,
+      cpf: payer_document
+    })
+  end
+
+  state_machine :state, initial: :pending do
+    state :pending, value: 'pending'
+    state :waiting_confirmation, value: 'waiting_confirmation'
+    state :confirmed, value: 'confirmed'
+    state :canceled, value: 'canceled'
+    state :refunded, value: 'refunded'
+    state :requested_refund, value: 'requested_refund'
+    state :refunded_and_canceled, value: 'refunded_and_canceled'
+    state :deleted, value: 'deleted'
+
+    event :push_to_trash do
+      transition all => :deleted
+    end
+
+    event :pendent do
+      transition all => :pending
+    end
+
+    event :waiting do
+      transition pending: :waiting_confirmation
+    end
+
+    event :confirm do
+      transition all => :confirmed
+    end
+
+    event :cancel do
+      transition all => :canceled
+    end
+
+    event :request_refund do
+      transition confirmed: :requested_refund, if: ->(backer){
+        backer.user.credits >= backer.value && !backer.credits
+      }
+    end
+
+    event :refund do
+      transition [:requested_refund, :confirmed] => :refunded
+    end
+
+    event :hide do
+      transition all => :refunded_and_canceled
+    end
+
+    after_transition confirmed: :requested_refund, do: :after_transition_from_confirmed_to_requested_refund
+    after_transition confirmed: :canceled, do: :after_transition_from_confirmed_to_canceled
+  end
+
+  def after_transition_from_confirmed_to_canceled
+    notify_observers :notify_backoffice_about_canceled
+  end
+
+  def after_transition_from_confirmed_to_requested_refund
+    notify_observers :notify_backoffice
+  end
+
+  # Used in payment engines
+  def price_in_cents
+    (self.value * 100).round
+  end
+
+  #==== Used on before and after callbacks
+
+  def define_key
+    self.update_attributes({ key: Digest::MD5.new.update("#{self.id}###{self.created_at}###{Kernel.rand}").to_s })
+  end
+
+  def define_payment_method
+    self.update_attributes({ payment_method: 'MoIP' })
+  end
+end

data/app/models/backer_report.rb

@@ -0,0 +1,3 @@
+class BackerReport < ActiveRecord::Base
+  # attr_accessible :title, :body
+end

data/app/models/backer_reports_for_project_owner.rb

@@ -0,0 +1,2 @@
+class BackerReportsForProjectOwner < ActiveRecord::Base
+end

data/app/models/backers_by_period.rb

@@ -0,0 +1,9 @@
+class BackersByPeriod < ActiveRecord::Base
+  def self.chart
+    self.all.reduce([]) do |memo, row|
+      memo << {name: I18n.t("adm.statistics.backers_by_week.#{row.series}"), data: {}} unless memo.last && memo.last[:name] == I18n.t("adm.statistics.backers_by_week.#{row.series}")
+      memo.last[:data][Date.today - (row[:week] * 7).days] = row[:sum]
+      memo
+    end
+  end
+end

data/app/models/category.rb

@@ -0,0 +1,17 @@
+class Category < ActiveRecord::Base
+  has_many :projects
+  validates_presence_of :name_pt
+  validates_uniqueness_of :name_pt
+
+  def self.with_projects
+    where("id IN (SELECT DISTINCT category_id FROM projects WHERE state <> 'draft' AND state <> 'rejected')")
+  end
+
+  def self.array
+    order('name_'+ I18n.locale.to_s + ' ASC').collect { |c| [c.send('name_' + I18n.locale.to_s), c.id] }
+  end
+
+  def to_s
+    self.send('name_' + I18n.locale.to_s)
+  end
+end