catarse_full 0.0.1

data/app/models/project_total.rb

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

data/app/models/projects_by_period.rb

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

data/app/models/projects_for_home.rb

@@ -0,0 +1,11 @@
+class ProjectsForHome < Project
+  self.table_name = 'projects_for_home'
+
+  scope :recommends, -> { where(origin: 'recommended') }
+  scope :recents, -> { where(origin: 'recents') }
+  scope :expiring, -> { where(origin: 'expiring') }
+
+  def to_partial_path
+    "projects/project"
+  end
+end

data/app/models/reward.rb

@@ -0,0 +1,70 @@
+# coding: utf-8
+require 'rails_autolink'
+class Reward < ActiveRecord::Base
+  include ActionView::Helpers::NumberHelper
+  include ActionView::Helpers::TextHelper
+  include ActionView::Helpers::UrlHelper
+  include RankedModel
+
+  include ERB::Util
+  schema_associations
+
+  ranks :row_order, with_same: :project_id
+  has_paper_trail
+
+  validates_presence_of :minimum_value, :description, :days_to_delivery
+  validates_numericality_of :minimum_value, greater_than_or_equal_to: 10.00
+  validates_numericality_of :maximum_backers, only_integer: true, greater_than: 0, allow_nil: true
+  scope :remaining, where("maximum_backers IS NULL OR (maximum_backers IS NOT NULL AND (SELECT COUNT(*) FROM backers WHERE state = 'confirmed' AND reward_id = rewards.id) < maximum_backers)")
+  scope :sort_asc, order('id ASC')
+
+  def has_modification?
+    versions.count > 1
+  end
+
+  def sold_out?
+    maximum_backers and (backers.confirmed.count + backers.in_time_to_confirm.count) >= maximum_backers
+  end
+
+  def remaining
+    return nil unless maximum_backers
+    maximum_backers - (backers.confirmed.count + backers.in_time_to_confirm.count)
+  end
+
+  def display_deliver_prevision
+    I18n.l((project.expires_at + days_to_delivery.days), format: :prevision)
+  rescue
+    days_to_delivery
+  end
+
+  def display_remaining
+    I18n.t('reward.display_remaining', remaining: remaining, maximum: maximum_backers).html_safe
+  end
+
+  def name
+    "<div class='reward_minimum_value'>#{minimum_value > 0 ? display_minimum+'+' : I18n.t('reward.dont_want')}</div><div class='reward_description'>#{h description}</div>#{'<div class="sold_out">' + I18n.t('reward.sold_out') + '</div>' if sold_out?}<div class='clear'></div>".html_safe
+  end
+  
+  def display_minimum
+    number_to_currency minimum_value
+  end
+
+  def short_description
+    truncate description, length: 35
+  end
+
+  def medium_description
+    truncate description, length: 65
+  end
+
+  def last_description
+    if versions.present?
+      reward = versions.last.reify(has_one: true)
+      auto_link(simple_format(reward.description), html: {target: :_blank})
+    end
+  end
+
+  def display_description
+    auto_link(simple_format(description), html: {target: :_blank})
+  end
+end

data/app/models/state.rb

@@ -0,0 +1,13 @@
+class State < ActiveRecord::Base
+  validates_presence_of :name, :acronym
+  validates_uniqueness_of :name, :acronym
+  def self.array
+    return @array if @array
+    @array = []
+    self.order(:name).all.each do |state|
+      @array << [state.name, state.acronym]
+    end
+    @array.push(['Outro / Other', 'outro / other'])
+    @array
+  end
+end

data/app/models/statistics.rb

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

data/app/models/subscriber_report.rb

@@ -0,0 +1,3 @@
+class SubscriberReport < ActiveRecord::Base
+  belongs_to :channel
+end

data/app/models/unsubscribe.rb

@@ -0,0 +1,10 @@
+class Unsubscribe < ActiveRecord::Base
+  schema_associations
+
+  attr_accessor :subscribed
+
+  def self.updates_unsubscribe project_id
+    notification_type ||= NotificationType.where(name: 'updates').first
+    self.find_or_initialize_by_project_id_and_notification_type_id(project_id, notification_type.id) if notification_type
+  end
+end

data/app/models/update.rb

@@ -0,0 +1,57 @@
+class Update < ActiveRecord::Base
+  extend CatarseAutoHtml
+
+  schema_associations
+  has_many :notifications, dependent: :destroy
+  validates_presence_of :user_id, :project_id, :comment, :comment_html
+  before_save -> {self.comment = comment.gsub(/^\s+/, "")}
+
+  catarse_auto_html_for field: :comment, video_width: 560, video_height: 340
+
+  scope :visible_to, ->(user) {
+    user_id = (user.present? ? user.id : nil)
+
+    return  if user.present? && user.admin?
+
+    where(
+      "not exclusive
+      or exists(select true from backers b where b.user_id = :user_id and b.state = 'confirmed' and b.project_id = updates.project_id)
+      or exists(select true from projects p where p.user_id = :user_id and p.id = updates.project_id)",
+      { user_id: user_id }
+    )
+  }
+
+  def email_comment_html
+    auto_html(comment) do
+      html_escape map: {
+        '&' => '&amp;',
+        '>' => '&gt;',
+        '<' => '&lt;',
+        '"' => '"'
+      }
+      email_image width: 513
+      redcloth target: :_blank
+      link target: :_blank
+    end
+  end
+
+  def notify_backers
+    project.subscribed_users.each do |user|
+      Rails.logger.info "[User #{user.id}] - Creating notification for #{user.name}"
+      Notification.create_notification_once :updates, user,
+        {update_id: self.id, user_id: user.id},
+        update_number: self.project.updates.count,
+        project_name: project.name,
+        project_owner: project.user.display_name,
+        project_owner_email: project.user.email,
+        from: project.user.email,
+        display_name: project.user.display_name,
+        update_title: title,
+        update: self,
+        from: project.user.email,
+        display_name: project.user.display_name,
+        update_comment: email_comment_html
+    end
+  end
+
+end

data/app/models/user.rb

@@ -0,0 +1,250 @@
+# coding: utf-8
+
+
+class User < ActiveRecord::Base
+  # Include default devise modules. Others available are:
+  # :token_authenticatable, :encryptable, :confirmable, :lockable, :timeoutable and :omniauthable
+  # :validatable
+  devise :database_authenticatable, :registerable,
+    :recoverable, :rememberable, :trackable, :omniauthable
+  begin
+    # NOTE: Sync normal users on mailchimp
+    sync_with_mailchimp subscribe_data: ->(user) {
+                          { EMAIL: user.email, FNAME: user.name,
+                          CITY: (user.address_city||'outro / other'), STATE: (user.address_state||'outro / other') }
+                        },
+                        list_id: Configuration[:mailchimp_list_id],
+                        subscribe_when: ->(user) { user.newsletter_changed? && user.newsletter },
+                        unsubscribe_when: ->(user) { user.newsletter_changed? && !user.newsletter },
+                        unsubscribe_email: ->(user) { user.email }
+
+  rescue Exception => e
+    Rails.logger.info "-----> #{e.inspect}"
+  end
+
+  delegate  :display_name, :display_image, :short_name, :display_image_html,
+    :medium_name, :display_credits, :display_total_of_backs,
+    to: :decorator
+  # Setup accessible (or protected) attributes for your model
+  attr_accessible :email,
+    :password,
+    :password_confirmation,
+    :remember_me,
+    :name,
+    :nickname,
+    :image_url,
+    :uploaded_image,
+    :bio,
+    :newsletter,
+    :full_name,
+    :address_street,
+    :address_number,
+    :address_complement,
+    :address_neighbourhood,
+    :address_city,
+    :address_state,
+    :address_zip_code,
+    :phone_number,
+    :cpf,
+    :state_inscription,
+    :locale,
+    :twitter,
+    :facebook_link,
+    :other_link,
+    :moip_login
+
+  mount_uploader :uploaded_image, UserUploader
+
+  validates_length_of :bio, maximum: 140
+
+  validates_presence_of :email
+  validates_uniqueness_of :email, :allow_blank => true, :if => :email_changed?, :message => I18n.t('activerecord.errors.models.user.attributes.email.taken')
+  validates_format_of :email, :with => Devise.email_regexp, :allow_blank => true, :if => :email_changed?
+
+  validates_presence_of :password, :if => :password_required?
+  validates_confirmation_of :password, :if => :password_confirmation_required?
+  validates_length_of :password, :within => Devise.password_length, :allow_blank => true
+
+  schema_associations
+  has_many :oauth_providers, through: :authorizations
+  has_many :backs, class_name: "Backer"
+  has_one :user_total
+  has_and_belongs_to_many :recommended_projects, join_table: :recommendations, class_name: 'Project'
+
+
+  # Channels relation
+  has_and_belongs_to_many :channels, join_table: :channels_trustees
+  has_and_belongs_to_many :subscriptions, join_table: :channels_subscribers, class_name: 'Channel'
+  has_many :channels_projects, through: :channels, source: :projects
+  has_many :channels_subscribers
+
+  accepts_nested_attributes_for :unsubscribes, allow_destroy: true rescue puts "No association found for name 'unsubscribes'. Has it been defined yet?"
+
+  scope :backers, -> {
+    where("id IN (
+      SELECT DISTINCT user_id
+      FROM backers
+      WHERE backers.state <> ALL(ARRAY['pending'::character varying::text, 'canceled'::character varying::text]))")
+  }
+
+  scope :who_backed_project, ->(project_id) {
+    where("id IN (SELECT user_id FROM backers WHERE backers.state = 'confirmed' AND project_id = ?)", project_id)
+  }
+
+  scope :subscribed_to_updates, -> {
+     where("id NOT IN (
+       SELECT user_id
+       FROM unsubscribes
+       WHERE project_id IS NULL
+       AND notification_type_id = (SELECT id from notification_types WHERE name = 'updates'))")
+   }
+
+  scope :subscribed_to_project, ->(project_id) {
+    who_backed_project(project_id).
+    where("id NOT IN (SELECT user_id FROM unsubscribes WHERE project_id = ?)", project_id)
+  }
+
+  scope :by_email, ->(email){ where('email ~* ?', email) }
+  scope :by_payer_email, ->(email) {
+    where('EXISTS(
+      SELECT true
+      FROM backers
+      JOIN payment_notifications ON backers.id = payment_notifications.backer_id
+      WHERE backers.user_id = users.id AND payment_notifications.extra_data ~* ?)', email)
+  }
+  scope :by_name, ->(name){ where('users.name ~* ?', name) }
+  scope :by_id, ->(id){ where(id: id) }
+  scope :by_key, ->(key){ where('EXISTS(SELECT true FROM backers WHERE backers.user_id = users.id AND backers.key ~* ?)', key) }
+  scope :has_credits, joins(:user_total).where('user_totals.credits > 0')
+  scope :order_by, ->(sort_field){ order(sort_field) }
+
+  def self.backer_totals
+    connection.select_one(
+      self.scoped.
+      joins(:user_total).
+      select('
+        count(DISTINCT user_id) as users,
+        count(*) as backers,
+        sum(user_totals.sum) as backed,
+        sum(user_totals.credits) as credits').
+      to_sql
+    ).reduce({}){|memo,el| memo.merge({ el[0].to_sym => BigDecimal.new(el[1] || '0') }) }
+  end
+
+  def has_facebook_authentication?
+    oauth = OauthProvider.find_by_name 'facebook'
+    authorizations.where(oauth_provider_id: oauth.id).present? if oauth
+  end
+
+  def decorator
+    @decorator ||= UserDecorator.new(self)
+  end
+
+  def admin?
+    admin
+  end
+
+  # NOTE: Checking if the user has CHANNELS
+  # If the user has some channels, this method returns TRUE
+  # Otherwise, it's FALSE
+  def trustee?
+    !self.channels.size.zero?
+  end
+
+  def credits
+    user_total ? user_total.credits : 0.0
+  end
+
+  def total_backed_projects
+    user_total ? user_total.total_backed_projects : 0
+  end
+
+  def facebook_id
+    auth = authorizations.joins(:oauth_provider).where("oauth_providers.name = 'facebook'").first
+    auth.uid if auth
+  end
+
+  def to_param
+    return "#{self.id}" unless self.display_name
+    "#{self.id}-#{self.display_name.parameterize}"
+  end
+
+  def self.create_with_omniauth(auth, current_user = nil)
+    omniauth_email = (auth["info"]["email"] rescue nil)
+    omniauth_email = (auth["extra"]["user_hash"]["email"] rescue nil) unless omniauth_email
+    if current_user
+      u = current_user
+    elsif omniauth_email && u = User.find_by_email(omniauth_email)
+    else
+      u = new do |user|
+        user.name = auth["info"]["name"]
+        user.email = omniauth_email
+        user.nickname = auth["info"]["nickname"]
+        user.bio = (auth["info"]["description"][0..139] rescue nil)
+        user.locale = I18n.locale.to_s
+        user.image_url = "https://graph.facebook.com/#{auth['uid']}/picture?type=large" if auth["provider"] == "facebook"
+      end
+    end
+    provider = OauthProvider.where(name: auth['provider']).first
+    u.authorizations.build(uid: auth['uid'], oauth_provider_id: provider.id) if provider
+    u.save!
+    u
+  end
+
+  def total_backs
+    backs.confirmed.not_anonymous.count
+  end
+
+  def updates_subscription
+    unsubscribes.updates_unsubscribe(nil)
+  end
+
+  def project_unsubscribes
+    backed_projects.map do |p|
+      unsubscribes.updates_unsubscribe(p.id)
+    end
+  end
+
+  def backed_projects
+    Project.backed_by(self.id)
+  end
+
+  def backs_text
+    if total_backed_projects == 2
+      I18n.t('user.backs_text.two')
+    elsif total_backed_projects > 1
+      I18n.t('user.backs_text.many', total: (total_backed_projects-1))
+    else
+      I18n.t('user.backs_text.one')
+    end
+  end
+
+  def twitter_link
+    "http://twitter.com/#{self.twitter}"
+  end
+
+  def fix_twitter_user
+    self.twitter.gsub!(/@/, '') if self.twitter
+  end
+
+  def fix_facebook_link
+    if !self.facebook_link.blank?
+      self.facebook_link = ('http://' + self.facebook_link) unless self.facebook_link[/^https?:\/\//]
+    end
+  end
+
+  # Returns a Gravatar URL associated with the email parameter, uses local avatar if available
+  def gravatar_url
+    return unless email
+    "https://gravatar.com/avatar/#{Digest::MD5.new.update(email)}.jpg?default=#{::Configuration[:base_url]}/assets/user.png"
+  end
+
+  def password_required?
+    !persisted? || !password.nil? || !password_confirmation.nil?
+  end
+
+  def password_confirmation_required?
+    !new_record?
+  end
+
+end

data/app/models/user_total.rb

@@ -0,0 +1,3 @@
+class UserTotal < ActiveRecord::Base
+  self.primary_key = :id
+end

data/app/observers/backer_observer.rb

@@ -0,0 +1,61 @@
+class BackerObserver < ActiveRecord::Observer
+  observe :backer
+
+  def after_create(backer)
+    backer.define_key
+    backer.define_payment_method
+  end
+
+  def before_save(backer)
+    Notification.create_notification_once(:payment_slip,
+      backer.user,
+      {backer_id: backer.id},
+      backer: backer,
+      project_name: backer.project.name) if backer.payment_choice_was.nil? && backer.payment_choice == 'BoletoBancario'
+
+    if backer.confirmed? and backer.confirmed_at.nil?
+      backer.confirmed_at = Time.now
+      Notification.create_notification_once(:confirm_backer,
+        backer.user,
+        {backer_id: backer.id},
+        backer: backer,
+        project_name: backer.project.name)
+
+      Notification.create_notification_once(:project_owner_backer_confirmed,
+        backer.project.user,
+        {backer_id: backer.id},
+        backer: backer,
+        project_name: backer.project.name)
+
+      if (Time.now > backer.project.expires_at  + 7.days) && (user = User.where(email: ::Configuration[:email_payments]).first)
+        Notification.create_notification_once(:backer_confirmed_after_project_was_closed,
+          user,
+          {backer_id: backer.id},
+          backer: backer,
+          project_name: backer.project.name)
+      end
+    end
+  end
+
+  def after_save(backer)
+    Notification.create_notification_once(:project_success,
+      backer.project.user,
+      {project_id: backer.project.id},
+      project: backer.project) if backer.project.reached_goal?
+  end
+
+  def notify_backoffice(backer)
+    CreditsMailer.request_refund_from(backer).deliver
+  end
+
+  def notify_backoffice_about_canceled(backer)
+    user = User.where(email: Configuration[:email_payments]).first
+    if user.present?
+      Notification.create_notification_once(:backer_canceled_after_confirmed,
+        user,
+        {backer_id: backer.id},
+        backer: backer)
+    end
+  end
+
+end