voluntary 0.0.1

data/app/helpers/wizard_helper.rb

@@ -0,0 +1,27 @@
+module WizardHelper
+  def section_header(wizard_step)
+    wizard_step_index = wizard_steps.index(wizard_step) + 1
+    
+    content = ["#{wizard_step_index} / #{wizard_steps.length}"] 
+    content << t("stories.steps.#{wizard_step}.title")
+    content << (future_step?(wizard_step) ? t('general.not_available') : '')
+    
+    content.join(' ')
+  end
+  
+  def step_pane(wizard_step)
+    return if future_step?(wizard_step)  
+    
+    partial_path = wizard_step == :initialization ? 'form' : "steps/#{wizard_step}"
+    
+    if @presenter.respond_to?(wizard_step)
+      @step_presenter = @presenter.send(wizard_step) 
+    else
+      @step_presenter = nil
+    end
+    
+    render_product_specific_partial_if_available(
+      resource, "#{controller_name}/#{partial_path}"
+    )
+  end
+end

data/app/models/area.rb

@@ -0,0 +1,19 @@
+class Area < ActiveRecord::Base
+  include Applicat::Mvc::Model::Resource::Base
+  include Applicat::Mvc::Model::Tree
+  include Applicat::Mvc::Model::Tokenable
+  
+  has_and_belongs_to_many :users
+  has_and_belongs_to_many :projects
+  
+  validates :name, presence: true, uniqueness: true
+  
+  attr_accessible :name
+  
+  extend FriendlyId
+  
+  friendly_id :name, :use => :slugged
+  
+  def products
+  end
+end

data/app/models/area_user.rb

@@ -0,0 +1,19 @@
+class AreaUser < ActiveRecord::Base
+  self.table_name = 'areas_users'
+  
+  belongs_to :area
+  belongs_to :user
+  
+  after_create :increment_area_users_count
+  after_destroy :decrement_area_users_count
+  
+  private
+  
+  def increment_area_users_count
+    area.users_count.increment!
+  end
+  
+  def decrement_area_users_count
+    area.users_count.decrement!
+  end
+end

data/app/models/candidature.rb

@@ -0,0 +1,35 @@
+class Candidature < ActiveRecord::Base
+  include StateMachines::Candidature
+  
+  belongs_to :vacancy
+  belongs_to :offeror, class_name: 'User'
+  belongs_to :user
+
+  has_many :comments, as: :commentable, dependent: :destroy
+
+  scope :accepted, where(state: 'accepted')
+
+  validates :vacancy_id, presence: true
+  validates :offeror_id, presence: true
+  validates :user_id, presence: true, uniqueness: { scope: :vacancy_id }
+  #validates :name, presence: true, uniqueness: { scope: :vacancy_id }
+  validates :text, presence: true
+  
+  attr_accessible :vacancy_id, :name, :text
+  
+  #extend FriendlyId
+  #friendly_id :name, use: :slugged
+  
+  before_validation :set_offeror
+  
+  # association shortcuts
+  def project
+    vacancy.project
+  end
+  
+  private
+  
+  def set_offeror
+    self.offeror_id = vacancy.project.user_id
+  end
+end

data/app/models/comment.rb

@@ -0,0 +1,16 @@
+class Comment < ActiveRecord::Base
+  has_ancestry
+  
+  belongs_to :commentable, polymorphic: true
+  belongs_to :user
+  
+  validates :commentable_type, presence: true
+  validates :commentable_id, presence: true
+  validates :user_id, presence: true
+  validates :name, presence: true
+  validates :text, presence: true
+  
+  attr_accessible :commentable_type, :commentable_id, :parent_id, :name, :text
+  
+  COMMENTABLE_TYPES = ['project', 'vacancy', 'candidature']
+end

data/app/models/history_tracker.rb

@@ -0,0 +1,3 @@
+class HistoryTracker
+  include Mongoid::History::Tracker
+end

data/app/models/mongo_db_document.rb

@@ -0,0 +1,11 @@
+class MongoDbDocument < ActiveRecord::Base
+  has_many :comments, as: :commentable, dependent: :destroy
+  
+  validates :mongo_db_object_id, presence: true, uniqueness: { scope: :klass_name }
+  validates :klass_name, presence: true
+  validates :name, presence: true
+  
+  def mongo_db_object
+    klass_name.constantize.find(mongo_db_object_id)
+  end
+end

data/app/models/organization.rb

@@ -0,0 +1,19 @@
+class Organization < ActiveRecord::Base
+  include Applicat::Mvc::Model::Resource::Base
+  #include Applicat::Mvc::Model::Tree
+  include Applicat::Mvc::Model::Tokenable
+  
+  belongs_to :user
+  
+  has_many :projects
+  
+  validates :name, presence: true, uniqueness: true
+  
+  attr_accessible :name
+  
+  extend FriendlyId
+  
+  friendly_id :name, :use => :slugged
+  
+  PARENT_TYPES = ['user']
+end

data/app/models/page.rb

@@ -0,0 +1,30 @@
+class Page
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Mongoid::History::Trackable
+  include Mongoid::Slug
+  
+  include StateMachines::Page
+  
+  field :user_id, type: Integer
+  field :name, type: String
+  field :text, type: String
+  field :state, type: String
+  
+  index({ name: 1 }, { unique: true })
+  
+  attr_accessible :name, :text
+  
+  scope :active, where(state: 'active')
+  
+  validates :user_id, presence: true
+  validates :name, presence: true, uniqueness: true
+  validates :text, presence: true
+  
+  track_history on: [:user_id, :name, :text, :state]
+  slug :name
+  
+  # belongs_to (SQL)
+  def user; user_id ? User.find(user_id) : nil; end
+  def user=(value); self.user_id = value.id; end
+end

data/app/models/product.rb

@@ -0,0 +1,99 @@
+class Product
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  
+  field :_id, type: String, default: -> { name.to_s.parameterize }
+  field :user_id, type: Integer
+  field :name, type: String, localize: true
+  field :text, type: String, localize: true
+  field :area_ids, type: Array, default: []
+  field :state, type: String
+  
+  attr_accessible :name, :text, :area_ids
+  
+  validates :user_id, presence: true
+  validates :name, presence: true, uniqueness: true
+  validates :area_ids, presence: true
+  
+  validate :english_name_available?
+  validate :existing_model_file?
+  
+  index({ name: 1 }, { unique: true })
+  
+  before_validation :set_type
+  
+  # active record compatibility
+  # just belongs_to reflections for cucumber's factory steps
+  def self.reflections
+    struct = OpenStruct.new(values: [])
+    
+    # sql belongs_to relations
+    struct.values << OpenStruct.new(name: 'user', options: {})
+    
+    ::Product.relations.each do |relation_name, relation|
+      # select only belongs_to relations
+      next unless relation_name == relation_name.singularize
+      
+      # automatically include mongo db's belongs_to relations
+      struct.values << OpenStruct.new(name: relation_name, options: {})
+    end
+    
+    struct
+  end
+  
+  def self.stories(id, user, page)
+    collection = if id == 'no-name'
+      Story.exists(_type: false)
+    else
+      product = Product.find(id)
+      
+      begin
+        product.story_class.for_user(user)
+      rescue NotImplementedError
+        product.story_class
+      end
+    end
+    
+    collection.where(:users_without_tasks_ids.ne => user.id)#.page(page).per(1)
+  end
+  
+  # belongs_to (SQL)
+  def user; User.find(offeror_id); end
+  def user=(value); self.user_id = value.id; end
+  
+  # has_many (SQL)
+  def areas; Area.where(id: area_ids); end
+  
+  private
+  
+  def english_name_available?
+    unless attributes['name']['en'].present?
+      errors[:name] << I18n.t(
+        'activerecord.errors.models.product.attributes.name.missing_english_name'
+      )
+    end
+  end
+  
+  def existing_model_file?
+    unless (get_type.constantize rescue false)
+      errors[:name] << I18n.t(
+        'activerecord.errors.models.product.attributes.name.missing_model_file'
+      )
+    end
+  end
+
+  def get_type
+    if name == 'Product'
+      'Product'
+    else
+      [
+        'Product', name.gsub(' - ', '_').gsub('-', '_').gsub(' ', '_').classify
+      ].join('::')
+    end
+  end
+  
+  def set_type
+    # TODO: check with a better internet connection a better regex on rubular.com
+    self._type = get_type
+  end
+end

data/app/models/product/new_product.rb

@@ -0,0 +1,3 @@
+class Product::NewProduct < Product
+  
+end

data/app/models/product/project_management.rb

@@ -0,0 +1,29 @@
+module Product::ProjectManagement
+  extend ActiveSupport::Concern 
+  
+  included do
+    has_many :stories, dependent: :nullify
+  end
+  
+  module ClassMethods
+    def stories(id, user, page)
+      collection = if id == 'no-name'
+        Story.exists(_type: false)
+      else
+        product = Product.find(id)
+        
+        begin
+          product.story_class.for_user(user)
+        rescue NotImplementedError
+          product.story_class
+        end
+      end
+      
+      collection.where(:users_without_tasks_ids.ne => user.id)#.page(page).per(1)
+    end
+  end
+    
+  def projects; Project.where(product_id: id); end
+  
+  def story_class; "#{self.class.name}::Story".constantize rescue Story; end
+end

data/app/models/profession.rb

@@ -0,0 +1,13 @@
+class Profession < ActiveRecord::Base
+  include Applicat::Mvc::Model::Resource::Base
+  
+  has_many :users
+  
+  validates :name, presence: true, uniqueness: true
+  
+  attr_accessible :name
+  
+  extend FriendlyId
+  
+  friendly_id :name, :use => :slugged
+end

data/app/models/project.rb

@@ -0,0 +1,66 @@
+class Project < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :organization
+  
+  has_many :project_users, dependent: :destroy
+  has_many :vacancies, dependent: :destroy
+  has_many :roles, through: :project_users
+  has_many :comments, as: :commentable, dependent: :destroy
+  
+  has_and_belongs_to_many :users
+  has_and_belongs_to_many :areas
+  
+  accepts_nested_attributes_for :areas, allow_destroy: true
+  
+  validates :user_id, presence: true
+  validates :name, presence: true, uniqueness: true
+  validates :text, presence: true
+  validates :area_ids, presence: true
+  
+  attr_accessible :organization_id, :product_id, :name, :text, :url, :area_ids
+  
+  extend FriendlyId
+  
+  before_validation :include_areas_of_product
+  after_create :create_project_user
+  after_destroy :destroy_non_active_records
+  
+  friendly_id :name, use: :slugged
+  
+  PARENT_TYPES = ['area', 'product', 'user']
+  
+  # belongs_to (Mongo DB)
+  def product
+    product_id.blank? ? nil : Product.find(product_id)
+  end
+    
+  # has_many (Mongo DB)
+  def story_class
+    if product_id.present?
+      "#{product.class.name}::Story".constantize rescue Story
+    else
+      Story
+    end
+  end
+   
+  def stories; story_class.where(project_id: id); end
+  
+  private
+  
+  def include_areas_of_product
+    self.area_ids ||= []
+    
+    if product
+      self.area_ids += product.areas.map(&:id)
+      self.area_ids.uniq!
+    end
+  end
+  
+  def create_project_user
+    ProjectUser.create(project_id: id, user_id: user_id)
+  end
+  
+  def destroy_non_active_records
+    stories.all.map(&:destroy)
+  end
+end

data/app/models/project_user.rb

@@ -0,0 +1,13 @@
+class ProjectUser < ActiveRecord::Base#
+  self.table_name = 'projects_users'
+  
+  belongs_to :project
+  belongs_to :vacancy
+  belongs_to :user
+  belongs_to :role
+  
+  validates :project_id, presence: true
+  validates :user_id, presence: true, uniqueness: { scope: [:project_id, :vacancy_id] }
+  
+  attr_accessible :project_id, :vacancy_id, :user_id, :role_id
+end

data/app/models/result.rb

@@ -0,0 +1,55 @@
+class Result
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  #include Mongoid::History::Trackable
+  
+  include Model::MongoDb::Customizable
+  include Model::MongoDb::Commentable
+  
+  #embedded_in :task
+  belongs_to :task
+  
+  # cached associations
+  belongs_to :story
+  
+  field :offeror_id, type: Integer
+  field :user_id, type: Integer
+  field :name, type: String
+  field :text, type: String
+  field :state, type: String
+  
+  attr_accessible :task_id, :name, :text
+  
+  validates :task_id, presence: true
+  validates :story_id, presence: true
+  validates :offeror_id, presence: true
+  validates :text, presence: true
+  
+  after_initialize :cache_associations
+  before_validation :cache_associations
+  after_create :set_tasks_result_association
+  after_destroy :unset_tasks_result_association
+  
+  #track_history on: [:name, :text, :state], scope: :task
+  
+  # belongs_to (SQL)
+  def offeror; offeror_id ? User.find(offeror_id) : nil; end
+  def offeror=(value); self.offeror_id = value.id; end
+  
+  def user; user_id ? User.find(user_id) : nil; end
+  def user=(value); self.user_id = value.id; end
+  
+  private
+  
+  def cache_associations
+    self.story_id = task.story_id if task_id.present? && (task rescue nil)
+    self.offeror_id = task.offeror_id if task_id.present? && (task rescue nil)
+  end
+  
+  def cache_product_association
+    self.product_id = task.product_id if task_id.present? && (task rescue nil)
+  end
+  
+  def set_tasks_result_association; task.update_attribute(:result_id, id); end
+  def unset_tasks_result_association; task.update_attribute(:result_id, nil); end
+end