catarse_full 0.0.1

data/app/controllers/adm/reports/backer_reports_controller.rb

@@ -0,0 +1,6 @@
+class Adm::Reports::BackerReportsController < Adm::Reports::BaseController
+  def end_of_association_chain
+    super.where(project_id: params[:project_id])
+  end
+end
+

data/app/controllers/adm/reports/base_controller.rb

@@ -0,0 +1,6 @@
+class Adm::Reports::BaseController < Adm::BaseController
+  inherit_resources
+  responders :csv
+  respond_to :csv
+  actions :index
+end

data/app/controllers/adm/statistics_controller.rb

@@ -0,0 +1,6 @@
+class Adm::StatisticsController < Adm::BaseController
+  inherit_resources
+  defaults  resource_class: Statistics
+  menu I18n.t("adm.statistics.index.menu") => Rails.application.routes.url_helpers.adm_statistics_path
+  actions :index
+end

data/app/controllers/adm/users_controller.rb

@@ -0,0 +1,26 @@
+class Adm::UsersController < Adm::BaseController
+  inherit_resources
+  menu I18n.t("adm.users.index.menu") => Rails.application.routes.url_helpers.adm_users_path
+  before_filter :set_title
+  before_filter :set_totals
+
+  has_scope :by_id, :by_name, :by_email, :by_payer_email, :by_key, :has_credits, :has_credits_difference, only: :index
+
+  protected
+  def set_totals
+    totals = end_of_association_chain.backer_totals
+    @total_users = totals[:users].to_i
+    @total_backs = totals[:backs]
+    @total_backed = totals[:backed]
+    @total_credits = totals[:credits]
+  end
+
+  def set_title
+    @title = t("adm.users.index.title")
+  end
+
+  def collection
+    @users ||= apply_scopes(end_of_association_chain).order_by(params[:order_by] || 'coalesce(user_totals.sum, 0) DESC').includes(:user_total).page(params[:page])
+  end
+end
+

data/app/controllers/application_controller.rb

@@ -0,0 +1,118 @@
+# coding: utf-8
+require 'uservoice_sso'
+class ApplicationController < ActionController::Base
+  layout :use_catarse_boostrap
+  protect_from_forgery
+
+  before_filter :redirect_user_back_after_login, unless: :devise_controller?
+
+  rescue_from CanCan::Unauthorized do |exception|
+    session[:return_to] = request.env['REQUEST_URI']
+    message = exception.message
+
+    if current_user.nil?
+      redirect_to new_user_registration_path, alert: I18n.t('devise.failure.unauthenticated')
+    elsif request.env["HTTP_REFERER"]
+      redirect_to :back, alert: message
+    else
+      redirect_to root_path, alert: message
+    end
+  end
+
+  helper_method :namespace, :fb_admins, :render_facebook_sdk, :render_facebook_like, :render_twitter, :display_uservoice_sso
+
+  before_filter :set_locale
+  before_filter :force_http
+
+  # TODO: Change this way to get the opendata
+  before_filter do
+    @fb_admins = [100000428222603, 547955110]
+  end
+
+  # We use this method only to make stubing easier
+  # and remove FB templates from acceptance tests
+  def render_facebook_sdk
+    render_to_string(partial: 'layouts/facebook_sdk').html_safe
+  end
+
+  def render_twitter options={}
+    render_to_string(partial: 'layouts/twitter', locals: options).html_safe
+  end
+
+  def render_facebook_like options={}
+    render_to_string(partial: 'layouts/facebook_like', locals: options).html_safe
+  end
+
+  def display_uservoice_sso
+    if current_user && ::Configuration[:uservoice_subdomain] && ::Configuration[:uservoice_sso_key]
+      Uservoice::Token.generate({
+        guid: current_user.id, email: current_user.email, display_name: current_user.display_name,
+        url: user_url(current_user), avatar_url: current_user.display_image
+      })
+    end
+  end
+
+  private
+  def fb_admins
+    @fb_admins.join(',')
+  end
+
+  def fb_admins_add(ids)
+    case ids.class
+    when Array
+      ids.each {|id| @fb_admins << ids.to_i}
+    else
+      @fb_admins << ids.to_i
+    end
+  end
+
+  def namespace
+    names = self.class.to_s.split('::')
+    return "null" if names.length < 2
+    names[0..(names.length-2)].map(&:downcase).join('_')
+  end
+
+  def set_locale
+    if params[:locale]
+      I18n.locale = params[:locale]
+      current_user.update_attribute :locale, params[:locale] if current_user && params[:locale] != current_user.locale
+    elsif request.method == "GET"
+      new_locale = (current_user.locale if current_user) || I18n.default_locale
+      begin
+        return redirect_to params.merge(locale: new_locale, only_path: true)
+      rescue ActionController::RoutingError
+        logger.info "Could not redirect with params #{params.inspect} in set_locale"
+      end
+    end
+  end
+
+  def use_catarse_boostrap
+    devise_controller? ? 'catarse_bootstrap' : 'application'
+  end
+
+  def redirect_back_or_default(default)
+    redirect_to(session[:return_to] || default)
+    session[:return_to] = nil
+  end
+
+  def after_sign_in_path_for(resource_or_scope)
+    return_to = session[:return_to]
+    session[:return_to] = nil
+    (return_to || root_path)
+  end
+
+  def render_404
+    render file: "#{Rails.root}/public/404.html", status: 404, layout: false
+  end
+
+  def force_http
+    redirect_to(protocol: 'http', host: ::Configuration[:base_domain]) if request.ssl?
+  end
+
+  def redirect_user_back_after_login
+    if request.env['REQUEST_URI'].present? && !request.xhr?
+      session[:return_to] = request.env['REQUEST_URI']
+    end
+  end
+
+end

data/app/controllers/channels/adm/projects_controller.rb

@@ -0,0 +1,36 @@
+class Channels::Adm::ProjectsController < Adm::BaseController
+  menu I18n.t('channels.adm.menu') => Rails.application.routes.url_helpers.adm_projects_path
+
+  
+  has_scope :by_id, :pg_search, :user_name_contains, :order_table, :by_state
+  has_scope :between_created_at, using: [ :start_at, :ends_at ], allow_blank: true
+  has_scope :order_table do |controller, scope, value|
+  value.present? ? scope.order_table(value) : scope.order('created_at DESC')
+  end
+
+
+
+  before_filter do
+    @channel        =  Channel.find_by_permalink!(request.subdomain.to_s)
+    @total_projects =  @channel.projects.size 
+  end
+
+  [:approve, :reject, :push_to_draft].each do |name|
+    define_method name do
+      @project    = @channel.projects.find(params[:id])
+      @project.send("#{name.to_s}!")
+      redirect_to :back
+    end
+  end
+
+  protected
+    def begin_of_association_chain
+      @channel
+    end
+
+    def collection
+      @projects = apply_scopes(@channel.projects.page(params[:page]))
+    end
+  
+
+end

data/app/controllers/channels/adm/reports/subscriber_reports_controller.rb

@@ -0,0 +1,7 @@
+class Channels::Adm::Reports::SubscriberReportsController < Adm::Reports::BaseController
+
+  private
+  def begin_of_association_chain
+    Channel.find_by_permalink!(request.subdomain.to_s)
+  end
+end

data/app/controllers/channels/adm/statistics_controller.rb

@@ -0,0 +1,13 @@
+class Channels::Adm::StatisticsController < Adm::BaseController
+  menu I18n.t('channels.adm.statistics_menu') => Rails.application.routes.url_helpers.adm_statistics_path
+
+  actions :index
+
+  before_filter do
+    @channel = Channel.find_by_permalink!(request.subdomain.to_s)
+  end
+
+  def index
+    @total_subscribers = @channel.subscribers.count
+  end
+end

data/app/controllers/channels/base_controller.rb

@@ -0,0 +1,6 @@
+class Channels::BaseController < ApplicationController
+  skip_before_filter :set_locale
+  before_filter do
+    I18n.locale = 'pt'
+  end
+end

data/app/controllers/channels/channels_subscribers_controller.rb

@@ -0,0 +1,35 @@
+class Channels::ChannelsSubscribersController < Channels::BaseController
+  inherit_resources
+  load_and_authorize_resource
+  actions :index, :create, :destroy
+
+  # we skid the set_locale because we are using the index method to create a record
+  skip_before_filter :set_locale
+
+  def create
+    begin
+      create! do |success,failure|
+        success.html{
+          flash[:notice] = I18n.t('channels_subscribers.created')
+          return redirect_to root_path }
+      end
+    rescue PG::Error, ActiveRecord::RecordNotUnique => e
+      return redirect_to root_path
+    end
+  end
+  alias_method :index, :create
+
+  def destroy
+    destroy! do |success,failure|
+      success.html{
+        flash[:notice] = I18n.t('channels_subscribers.deleted')
+        return redirect_to root_path
+      }
+    end
+  end
+
+  prepend_before_filter do
+    params[:channels_subscriber] = { channel_id: Channel.find_by_permalink!(request.subdomain).id, user_id: current_user.id } if current_user
+  end
+end
+

data/app/controllers/channels/profiles_controller.rb

@@ -0,0 +1,11 @@
+class Channels::ProfilesController < Channels::BaseController
+  inherit_resources
+  defaults resource_class: Channel, finder: :find_by_permalink! 
+  actions :show
+  custom_actions resource: [:how_it_works]
+
+
+
+  before_filter{ params[:id] = request.subdomain }
+
+end

data/app/controllers/channels/projects_controller.rb

@@ -0,0 +1,22 @@
+class Channels::ProjectsController < ProjectsController
+  belongs_to :channel, finder: :find_by_permalink!, param: :profile_id
+
+
+  # Inheriting from the original Projects controller
+  # With one addition: we include the project into the current channel
+  before_filter only: [:create] { params[:project][:channels] = [@channel] }
+  after_filter only: [:create] { notify_trustees }
+
+  prepend_before_filter{ params[:profile_id] = request.subdomain }
+
+
+
+
+  # After a project submission through a channel, notify all channel's trustees
+  protected
+    def notify_trustees
+
+    end
+end
+
+

data/app/controllers/explore_controller.rb

@@ -0,0 +1,6 @@
+class ExploreController < ApplicationController
+  def index
+    @title = t('explore.title')
+    @categories = Category.with_projects.order(:name_pt).all
+  end
+end

data/app/controllers/omniauth_callbacks_controller.rb

@@ -0,0 +1,28 @@
+class OmniauthCallbacksController < Devise::OmniauthCallbacksController
+  skip_before_filter :set_locale
+
+  def self.add_providers
+    OauthProvider.all.each do |p|
+      define_method p.name.downcase do 
+        omniauth = request.env['omniauth.auth']
+        @user = User.
+          select('users.*').
+          joins('JOIN authorizations ON authorizations.user_id = users.id').
+          joins('JOIN oauth_providers ON oauth_providers.id = authorizations.oauth_provider_id').
+          where("authorizations.uid = :uid AND oauth_providers.name = :provider", {uid: omniauth[:uid], provider: p.name}).
+          first || User.create_with_omniauth(omniauth, current_user)
+
+        flash[:notice] = I18n.t("devise.omniauth_callbacks.success", kind: p.name.capitalize)
+        sign_in @user, event: :authentication
+        if @user.email
+          redirect_to(session[:return_to] || root_path)
+          session[:return_to] = nil
+        else
+          render 'users/set_email'
+        end
+
+      end
+    end
+  end
+  add_providers
+end

data/app/controllers/passwords_controller.rb

@@ -0,0 +1,21 @@
+class PasswordsController < Devise::PasswordsController
+
+  def update
+    self.resource = resource_class.reset_password_by_token(resource_params)
+
+    if resource.errors.empty?
+      resource.unlock_access! if unlockable?(resource)
+      flash_message = resource.active_for_authentication? ? :updated : :updated_not_active
+      set_flash_message(:notice, flash_message) if is_navigational_format?
+      sign_in(resource_name, resource)
+      respond_with resource, :location => after_resetting_password_path_for(resource)
+    else
+      if resource.errors[:password]
+        return respond_with resource
+      end
+
+      flash[:notice] = I18n.t('devise.failure.password_token')
+      redirect_to new_password_path(resource_name)
+    end
+  end
+end

data/app/controllers/projects/backers_controller.rb

@@ -0,0 +1,85 @@
+class Projects::BackersController < ApplicationController
+  inherit_resources
+  actions :index, :show, :new, :update_info, :review, :create
+  skip_before_filter :force_http, only: [:create, :update_info]
+  skip_before_filter :verify_authenticity_token, only: [:moip]
+  has_scope :available_to_count, :waiting_confirmation, type: :boolean
+  has_scope :page, default: 1
+  load_and_authorize_resource except: [:index]
+  belongs_to :project
+
+  def update_info
+    resource.update_attributes(params[:backer])
+    resource.update_user_billing_info
+    render json: {message: 'updated'}
+  end
+
+  def index
+    render collection
+  end
+
+  def show
+    @title = t('projects.backers.show.title')
+    session[:thank_you_backer_id] = nil
+  end
+
+  def new
+    unless parent.online?
+      flash[:failure] = t('projects.back.cannot_back')
+      return redirect_to :root
+    end
+
+    @create_url = ::Configuration[:secure_review_host] ?
+      project_backers_url(@project, {host: ::Configuration[:secure_review_host], protocol: 'https'}) :
+      project_backers_path(@project)
+
+    @title = t('projects.backers.new.title', name: @project.name)
+    @backer = @project.backers.new(user: current_user)
+    empty_reward = Reward.new(minimum_value: 0, description: t('projects.backers.new.no_reward'))
+    @rewards = [empty_reward] + @project.rewards.order(:minimum_value)
+
+    # Select
+    if params[:reward_id] && (@selected_reward = @project.rewards.find params[:reward_id]) && !@selected_reward.sold_out?
+      @backer.reward = @selected_reward
+      @backer.value = "%0.0f" % @selected_reward.minimum_value
+    end
+  end
+
+  def create
+    @title = t('projects.backers.create.title')
+    @backer.user = current_user
+    @backer.reward_id = nil if params[:backer][:reward_id].to_i == 0
+    create! do |success,failure|
+      failure.html do
+        flash[:failure] = t('projects.backers.review.error')
+        return redirect_to new_project_backer_path(@project)
+      end
+      success.html do
+        resource.update_current_billing_info
+        flash[:notice] = nil
+        session[:thank_you_backer_id] = @backer.id
+        return render :create
+      end
+    end
+    @thank_you_id = @project.id
+  end
+
+  def credits_checkout
+    if current_user.credits < @backer.value
+      flash[:failure] = t('projects.backers.checkout.no_credits')
+      return redirect_to new_project_backer_path(@backer.project)
+    end
+
+    unless @backer.confirmed?
+      @backer.update_attributes({ payment_method: 'Credits' })
+      @backer.confirm!
+    end
+    flash[:success] = t('projects.backers.checkout.success')
+    redirect_to project_backer_path(project_id: parent.id, id: resource.id)
+  end
+
+  protected
+  def collection
+    @backers ||= apply_scopes(end_of_association_chain).available_to_display.order("confirmed_at DESC").per(10)
+  end
+end