voluntary_ranking 0.0.1

data/app/models/ranking_item.rb

@@ -0,0 +1,30 @@
+class RankingItem < ActiveRecord::Base
+  include Concerns::Model::BaseRankingItem
+  
+  attr_accessible :ranking_id, :thing, :thing_id, :best, :stars
+  
+  has_many :user_ranking_items, dependent: :destroy
+  
+  validates :thing_id, presence: true, uniqueness: { scope: :ranking_id }
+  
+  acts_as_list scope: :ranking_id
+  
+  def update_position
+    other_ranking_item = RankingItem.where(
+      'ranking_id = ? AND stars_sum >= ? AND id <> ?', ranking_id, stars_sum, id
+    ).order('position DESC').first
+  
+    if other_ranking_item
+      if RankingItem.where(ranking_id: ranking_id).count >= other_ranking_item.position + 1
+        #puts "update_position.1.1 (#{thing.name} with #{stars_sum}): #{other_ranking_item.position + 1}"
+        insert_at other_ranking_item.position + 1
+      else
+        #puts "update_position.1.2 (#{thing.name} with #{stars_sum}): #{other_ranking_item.position}"
+        insert_at other_ranking_item.position
+      end
+    else
+      #puts "update_position.2 (#{thing.name} with #{stars_sum}): 1"
+      insert_at 1
+    end
+  end
+end

data/app/models/user_ranking_item.rb

@@ -0,0 +1,136 @@
+class UserRankingItem < ActiveRecord::Base
+  include Concerns::Model::BaseRankingItem
+  
+  attr_accessible :ranking, :ranking_id, :thing, :thing_id, :best, :stars
+  
+  belongs_to :user
+  belongs_to :ranking_item, counter_cache: true
+  
+  validates :user_id, presence: true
+  validates :ranking_item_id, presence: true, uniqueness: { scope: [:user_id] }
+  validates :stars, presence: true
+  validate :stars_and_best
+  
+  after_validation :copy_validation_errors_from_ranking_item # or before?
+  after_create :add_stars_to_ranking_item
+  after_update :remove_or_add_stars_to_ranking_item, if: 'stars_changed?'
+  
+  after_destroy :destroy_ranking_item, if: 'UserRankingItem.where(ranking_item_id: ranking_item_id).count == 0'
+  
+  acts_as_list scope: [:user_id, :ranking_id]
+  
+  def self.position_for_user_by_stars(user_id, ranking_id, user_ranking_item_id, stars)
+    ranking_items = where(user_id: user_id, ranking_id: ranking_id)
+    ranking_items_count = ranking_items.count
+    ranking_items = ranking_items.where('id <> ?', user_ranking_item_id) if user_ranking_item_id.present?
+    
+    if stars.to_i >= 3
+      ranking_items.order('stars ASC, position DESC').where('stars >= ?', stars).first.try(:position).to_i + 1 || 1
+    else
+      item = ranking_items.order('stars DESC, position ASC').where('stars <= ?', stars).first
+      
+      if item.present?
+        if user_ranking_item_id.present? && item.stars < stars
+          item.position - 1
+        else
+          item.position
+        end
+      else
+        position = ranking_items.order('stars ASC, position DESC').where('stars >= ?', stars).first.try(:position).to_i + 1
+        
+        position -= 1 if user_ranking_item_id.present? && position > ranking_items_count
+
+        position
+      end
+    end
+  end
+  
+  def move_to_top_of_page(page)
+    item_on_top_of_page = user.ranking_items.where(ranking_id: ranking_id).order('position').paginate(page: page, per_page: 10).first
+    self.stars = item_on_top_of_page.stars
+    self.best = item_on_top_of_page.best
+    insert_at(item_on_top_of_page.position)
+  end
+  
+  def set_position(value)
+    item = UserRankingItem.where(
+      'ranking_id = :ranking_id AND position = :position', ranking_id: ranking_id, position: value
+    ).first
+    
+    self.stars = item.stars; self.best = item.best;
+    
+    insert_at(value)
+    
+    reload
+  end
+  
+  def update_stars(stars)
+    self.stars = stars
+    self.best = stars >= 3
+    save!
+    insert_at UserRankingItem.position_for_user_by_stars(user_id, ranking.id, id, stars)
+  end
+  
+  private
+  
+  def copy_validation_errors_from_ranking_item
+    return if self.ranking_item.blank? || self.ranking_item.valid?
+    
+    self.ranking_item.errors.each do |field, ranking_item_errors| 
+      ranking_item_errors = [ranking_item_errors] unless ranking_item_errors.is_a?(Array)
+      
+      ranking_item_errors.each do |error| 
+        unless attributes.has_key?(field.to_s)
+          field = :base
+          error = "#{field.to_s.humanize}: #{error}" 
+        end
+        
+        self.errors[field] << error unless self.errors[field].include? error
+      end
+    end
+  end
+  
+  def stars_and_best
+    if self.stars >= 3 && !self.best
+      self.errors[:best] << 'Item cannot be worst with more stars than 3.'
+    elsif self.stars <= 2 && self.best
+      self.errors[:best] << 'Item cannot be best with less stars than 3.'
+    end
+  end
+  
+  def destroy_ranking_item
+    ranking_item.destroy
+  end
+  
+  def add_stars_to_ranking_item
+    ranking_item.stars_sum += stars
+    
+    if ranking_item.stars_sum == 0
+      ranking_item.stars = 0
+    else
+      ranking_item.stars = (ranking_item.stars_sum / ranking_item.user_ranking_items_count).round
+    end
+    
+    ranking_item.save
+    ranking_item.update_position
+  end
+  
+  def remove_or_add_stars_to_ranking_item
+    if stars > stars_was
+      #puts "remove_or_add_stars_to_ranking_item.1: #{ranking_item.stars_sum} += (#{stars} - #{stars_was})"
+      ranking_item.stars_sum += (stars - stars_was)
+    else
+      #puts "remove_or_add_stars_to_ranking_item.2: #{ranking_item.stars_sum} -= (#{stars_was} - #{stars})"
+      ranking_item.stars_sum -= (stars_was - stars)
+    end
+    
+    if ranking_item.stars_sum == 0
+      ranking_item.stars = 0
+    else
+      ranking_item.stars = (ranking_item.stars_sum / ranking_item.user_ranking_items_count).round
+    end
+    
+    ranking_item.save
+    ranking_item.update_position
+  end
+end

data/app/serializers/argument_serializer.rb

@@ -0,0 +1,11 @@
+class ArgumentSerializer < ActiveModel::Serializer
+  attributes :id, :topic_id, :topic_name, :thing_id, :thing_name, :value
+
+  def thing_name
+    object.thing.try(:name)
+  end
+  
+  def topic_name
+    object.topic.try(:name)
+  end
+end

data/app/serializers/base_ranking_item_serializer.rb

@@ -0,0 +1,23 @@
+class BaseRankingItemSerializer < ActiveModel::Serializer
+  attributes :id, :position, :thing_id, :thing_name, :best, :stars, :ranking_adjective, :ranking_negative_adjective, :ranking_topic, :ranking_scope
+
+  def thing_name
+    object.thing.name
+  end
+  
+  def ranking_adjective
+    object.ranking.adjective
+  end
+  
+  def ranking_negative_adjective
+    object.ranking.negative_adjective
+  end
+  
+  def ranking_topic
+    object.ranking.topic
+  end
+  
+  def ranking_scope
+    object.ranking.scope
+  end
+end

data/app/serializers/ranking_item_serializer.rb

@@ -0,0 +1,2 @@
+class RankingItemSerializer < BaseRankingItemSerializer
+end

data/app/serializers/user_ranking_item_serializer.rb

@@ -0,0 +1,7 @@
+class UserRankingItemSerializer < BaseRankingItemSerializer
+  attributes :user_name
+  
+  def user_name
+    object.user.name
+  end
+end

data/config/locales/en.yml

@@ -0,0 +1,10 @@
+en:
+  activerecord:
+    models:
+      movie: Movie
+      
+    attributes:
+      general:
+        name: Name 
+        parent: Parent
+        user_id: User

data/config/locales/resources/ranking/en.yml

@@ -0,0 +1,10 @@
+en:
+  activerecord:
+    errors:
+      models:
+        ranking:
+          attributes:
+            base: 
+              one_ranking_per_topic_scope_and_one_of_the_adjectives: Only one ranking per topic, scope and one of the adjectives allowed!
+            name:
+              unwanted_special_characters_included: Name must not include slash.

data/config/routes.rb

@@ -0,0 +1,41 @@
+Rails.application.routes.draw do
+  get '/products/ranking' => 'product/ranking#index'
+  
+  namespace :api, defaults: {format: 'json'} do
+    scope module: :v1, path: 'v1' do
+      # TODO: remove manual routing when get rid of this resource using root UsersController
+      resources :argument_topics, only: [] do
+        collection do
+          get :autocomplete
+        end  
+      end
+      
+      resources :arguments
+      
+      resources :rankings
+      
+      get '/rankings/attributes/:attribute/autocomplete', to: 'rankings#autocomplete_attribute'
+      
+      resources :ranking_items
+      
+      resources :things, only: [:show] do
+        collection do
+          get :autocomplete
+          get :suggest
+        end  
+      end
+      
+      get '/things/:left_thing_name/vs/:right_thing_name/arguments', to: 'things/arguments#comparison'
+      get '/things/:thing_name/is_one_of_the/:adjective/:topic/:scope', to: 'ranking_items#show'
+      
+      resources :user_ranking_items do
+        member do
+          put :move_to_page
+          put :move
+        end
+      end
+      
+      resources :users
+    end
+  end
+end

data/db/migrate/20130817115303_add_ranking_product.rb

@@ -0,0 +1,50 @@
+class AddRankingProduct < ActiveRecord::Migration
+  def up
+    Product::Ranking.create(name: 'Ranking', text: 'Ranking')
+    
+    create_table :rankings, force:  true do |t|
+      t.string :adjective # best
+      t.string :topic
+      t.string :scope
+      t.string :negative_adjective # worst
+      t.timestamps
+    end
+    
+    create_table :ranking_items, force:  true do |t|
+      t.integer :position
+      t.integer :ranking_id
+      t.integer :thing_id
+      t.boolean :best
+      t.integer :user_ranking_items_count, default: 0
+      t.integer :stars_sum, default: 0
+      t.integer :stars, default: 0
+      t.timestamps
+    end
+    
+    add_index :ranking_items, [:ranking_id, :thing_id], unique: true
+    add_index :ranking_items, [:ranking_id, :stars_sum]
+    add_index :ranking_items, [:ranking_id, :position]
+    
+    create_table :user_ranking_items, force:  true do |t|
+      t.integer :user_id
+      t.integer :ranking_item_id
+      t.integer :position
+      t.boolean :best
+      t.integer :stars, default: 0
+      t.integer :ranking_id # cache column
+      t.integer :thing_id # cache column
+      t.timestamps
+    end
+    
+    add_index :user_ranking_items, [:user_id, :ranking_id, :thing_id], unique: true
+    add_index :user_ranking_items, [:user_id, :ranking_id, :position]
+  end
+  
+  def down
+    Product::Ranking.first.destroy
+    
+    [:rankings, :ranking_items, :user_ranking_items].each do |table|
+      drop_table table
+    end
+  end
+end

data/db/migrate/20140926102943_create_arguments.rb

@@ -0,0 +1,20 @@
+class CreateArguments < ActiveRecord::Migration
+  def change
+    create_table :argument_topics do |t|
+      t.string :name
+      t.text :text
+      t.timestamps
+    end
+    
+    add_index :argument_topics, :name, unique: true
+    
+    create_table :arguments do |t|
+      t.integer :topic_id
+      t.integer :thing_id
+      t.string :value
+      t.timestamps
+    end
+    
+    add_index :arguments, [:topic_id, :thing_id], unique: true
+  end
+end

data/lib/concerns/controller/base_ranking_items_controller.rb

@@ -0,0 +1,10 @@
+module Concerns
+  module Controller
+    module BaseRankingItemsController
+      extend ActiveSupport::Concern
+    
+      #def ranking; @ranking ||= Ranking.find_or_create_by_params(params); end
+      def ranking; @ranking ||= Ranking.find_by_params(params) end
+    end
+  end
+end

data/lib/concerns/model/base_ranking_item.rb

@@ -0,0 +1,29 @@
+module Concerns
+  module Model
+    module BaseRankingItem
+      extend ActiveSupport::Concern
+      
+      included do
+        belongs_to :ranking
+        belongs_to :thing
+        
+        validates :ranking_id, presence: true
+        validates :thing_id, presence: true
+        
+        #pusherable "#{Rails.env}_channel"
+        
+        def thing=(thing)
+          thing.save if thing.new_record?
+          
+          self.thing_id = thing.id
+          
+          if self.respond_to?(:ranking_item_id) && self.ranking.present?
+            self.ranking_item ||= self.ranking.items.find_or_create_by_thing_id(thing_id)
+          end
+          
+          thing
+        end
+      end
+    end 
+  end
+end

data/lib/concerns/model/user/ranking.rb

@@ -0,0 +1,48 @@
+module Concerns
+  module Model
+    module User
+      module Ranking
+        module AddThingToUserList
+          def << *args
+            thing = args.first
+            proxy_association.owner.user_list_items.create!(list: thing.class.list, thing: thing)
+            self
+          end
+          
+          alias_method :create, :<<
+        end
+      
+        extend ActiveSupport::Concern
+        
+        included do
+          has_many :rankings, through: :ranking_items, dependent: :destroy
+          has_many :ranking_items, class_name: 'UserRankingItem', dependent: :destroy
+          has_many :things, extend: AddThingToUserList
+          
+          def add_ranking_item(attributes)
+            ranking = ::Ranking.find_or_create_by_params(attributes)
+            thing = Thing.find_or_create_by(name: attributes[:thing_name])
+            ranking_item_attributes = { 
+              thing_id: thing.id, best: attributes[:best], stars: attributes[:stars]
+            }
+            ranking_item = ranking.items.where(thing_id: ranking_item_attributes[:thing_id]).first_or_create
+            
+            user_ranking_item = ranking_items.new(
+              ranking_item_attributes.merge(ranking_id: ranking.id)
+            )
+            user_ranking_item.ranking_item_id = ranking_item.id
+           
+            position = UserRankingItem.position_for_user_by_stars id, ranking.id, nil, attributes[:stars]
+            
+            begin
+              user_ranking_item.insert_at(position)
+            rescue ActiveRecord::RecordInvalid
+            end
+              
+            user_ranking_item
+          end
+        end
+      end
+    end
+  end
+end