voluntary 0.0.1

data/app/models/role.rb

@@ -0,0 +1,8 @@
+class Role < ActiveRecord::Base
+  has_many :users, through: :user_roles
+  has_many :projects, through: :project_users
+  
+  scope :public, where(public: true)
+  
+  attr_accessible :name, :public
+end

data/app/models/role/admin.rb

@@ -0,0 +1,2 @@
+class Role::Admin < Role
+end

data/app/models/role/master.rb

@@ -0,0 +1,2 @@
+class Role::Master < Role
+end

data/app/models/role/project_owner.rb

@@ -0,0 +1,2 @@
+class Role::ProjectOwner < Role
+end

data/app/models/role/user.rb

@@ -0,0 +1,2 @@
+class Role::User < Role
+end

data/app/models/state_machines/candidature.rb

@@ -0,0 +1,42 @@
+module StateMachines::Candidature
+  def self.included(base)
+    base.extend ClassMethods
+    
+    base.class_eval do
+      attr_accessor :current_user
+      
+      const_set 'STATES', [:new, :accepted, :denied]
+      const_set 'EVENTS', [:accept, :deny, :quit]
+      
+      state_machine :state, initial: :new do
+        event :accept do
+          transition [:new, :denied] => :accepted
+        end
+        
+        state :accepted do
+          validate :candidatures_limit_not_reached
+        end
+        
+        event :deny do
+          transition :new => :denied
+        end
+        
+        event :quit do
+          transition :accepted => :denied
+        end
+      end
+      
+      private
+      
+      # state validations
+      def candidatures_limit_not_reached
+        if vacancy.limit == vacancy.candidatures.where(state: 'accepted').count
+          errors[:state] << I18n.t('activerecord.errors.models.vacancy.attributes.limit.reached')
+        end
+      end
+    end
+  end
+  
+  module ClassMethods
+  end
+end

data/app/models/state_machines/page.rb

@@ -0,0 +1,18 @@
+module StateMachines::Page
+  def self.included(base)
+    base.extend ClassMethods
+    
+    base.class_eval do
+      attr_accessor :current_user
+      
+      const_set 'STATES', [:active]
+      const_set 'EVENTS', []
+      
+      state_machine :state, initial: :active do
+      end
+    end
+  end
+  
+  module ClassMethods
+  end
+end

data/app/models/state_machines/story.rb

@@ -0,0 +1,51 @@
+module StateMachines::Story
+  def self.included(base)
+    base.extend ClassMethods
+    
+    base.class_eval do
+      include Model::MongoDb::StateVersionAttributes
+      
+      attr_accessor :current_user
+      
+      const_set 'STATES', [:new, :tasks_defined, :active, :completed, :closed]
+      const_set 'EVENTS', [:initialization, :setup_tasks, :activate, :complete]
+      
+      state_machine :state, initial: :new do
+        event :initialization do
+          transition :new => :initialized
+        end
+        
+        event :setup_tasks do
+          transition :initialized => :tasks_defined  
+        end
+        
+        state :tasks_defined do
+          validates_associated :tasks
+          validate :presence_of_tasks
+        end
+        
+        event :activate do
+          transition [:tasks_defined, :completed] => :active
+        end
+        
+        event :complete do
+          transition :active => :completed
+        end
+        
+        event :close do
+          transition :completed => :closed
+        end
+      end
+      
+      private
+      
+      def presence_of_tasks
+        unless tasks.any?
+          errors[:base] << I18n.t(
+            'activerecord.errors.models.story.attributes.base.missing_tasks'
+          )
+        end
+      end
+    end
+  end
+end

data/app/models/state_machines/task.rb

@@ -0,0 +1,46 @@
+module StateMachines::Task
+  def self.included(base)
+    base.extend ClassMethods
+    
+    base.class_eval do
+      include Model::MongoDb::StateVersionAttributes
+      
+      attr_accessor :current_user
+      
+      const_set 'STATES', [:new, :assigned, :under_supervision, :completed]
+      const_set 'EVENTS', [:assign, :cancel, :review, :follow_up, :complete]
+      
+      state_machine :state, initial: :new do
+        event :assign do
+          transition :new => :assigned
+        end
+        
+        state :assigned do
+          validates :user_id, presence: true
+        end
+        
+        event :cancel do 
+          transition :assigned => :new
+        end
+       
+        event :review do
+          transition :assigned => :under_supervision
+        end
+        
+        state :under_supervision do
+          # TODO: move logic of Workflow::TasksController#update here
+          #validates_associated :result
+        end
+       
+        event :follow_up do 
+          transition [:under_supervision, :completed] => :assigned
+        end
+        
+        event :complete do
+          # TODO: complete the story through observer
+          transition :under_supervision => :completed
+        end
+      end
+    end
+  end
+end

data/app/models/state_machines/vacancy.rb

@@ -0,0 +1,41 @@
+module StateMachines::Vacancy
+  def self.included(base)
+    base.extend ClassMethods
+    
+    base.class_eval do
+      attr_accessor :current_user
+      
+      const_set 'STATES', [:open, :recommended, :denied, :closed]
+      const_set 'EVENTS', [:accept_recommendation, :deny_recommendation, :close, :reopen]
+      
+      state_machine :state, initial: :new do
+        event :recommend do
+          transition :new => :recommended 
+        end
+        
+        event :accept_recommendation do
+          transition :recommended => :open  
+        end
+        
+        event :deny_recommendation do
+          transition :recommended => :denied  
+        end
+        
+        event :do_open do
+          transition :new => :open 
+        end
+        
+        event :close do
+          transition :open => :closed
+        end
+        
+        event :reopen do
+          transition [:denied, :closed] => :open
+        end
+      end
+    end
+  end
+  
+  module ClassMethods
+  end
+end

data/app/models/story.rb

@@ -0,0 +1,82 @@
+class Story
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Mongoid::Slug
+  
+  include Model::MongoDb::Customizable
+  include StateMachines::Story
+  include Model::MongoDb::Commentable
+  
+  has_many :tasks, dependent: :destroy
+  
+  # cached associations
+  has_many :results
+  
+  accepts_nested_attributes_for :tasks, allow_destroy: true, reject_if: ->(t) { t['name'].blank? && t['text'].blank? }
+  
+  field :project_id, type: Integer
+  field :offeror_id, type: Integer
+  field :name, type: String
+  field :text, type: String
+  field :state, type: String
+  field :users_without_tasks_ids, type: Array
+  
+  slug :name
+  
+  attr_accessible :project_id, :name, :text, :tasks_attributes
+  
+  scope :active, where(state: 'active')
+  
+  validates :project_id, presence: true
+  validates :offeror_id, presence: true
+  validates :name, presence: true, uniqueness: { scope: :project_id }
+  validates :text, presence: true
+  
+  after_initialize :cache_associations
+  before_validation :cache_associations 
+
+  PARENT_TYPES = ['project']
+  
+  def self.for_user(user)
+    raise NotImplementedError
+  end
+  
+  # belongs_to (SQL)
+  def offeror; offeror_id ? User.find(offeror_id) : nil; end
+  def offeror=(value); self.offeror_id = value.id; end
+  
+  def project; project_id ? Project.find(project_id) : nil; end
+  def project=(value); self.project_id = value.id; end
+  
+  def next_task_for_user(user)
+    return nil if (users_without_tasks_ids || []).include?(user.id)
+    
+    task = tasks.assigned.where(user_id: user.id).first
+    
+    return task if task
+    
+    task = tasks.current.unassigned.where(:unassigned_user_ids.ne => user.id).first
+    
+    if task
+      task.user_id = user.id
+    
+      return task.errors.full_messages.join('<br/>') unless task.assign
+    else
+      self.users_without_tasks_ids ||= []
+      self.users_without_tasks_ids << user.id
+      save
+    end
+    
+    task
+  end
+  
+  private
+  
+  def cache_associations
+    self.offeror_id = project.user_id if project_id.present? && (project rescue nil)
+  end
+  
+  def cache_product_association
+    self.product_id = project.product_id if project_id.present? && (project rescue nil)
+  end
+end

data/app/models/task.rb

@@ -0,0 +1,85 @@
+class Task
+  include Mongoid::Document
+  include Mongoid::Timestamps
+  include Mongoid::Slug
+  #include Mongoid::History::Trackable
+  
+  include Model::MongoDb::Customizable
+  include Model::MongoDb::Commentable
+  include StateMachines::Task
+  
+  belongs_to :story
+  belongs_to :result, dependent: :destroy
+  
+  accepts_nested_attributes_for :result, allow_destroy: true
+  
+  field :offeror_id, type: Integer
+  field :user_id, type: Integer
+  field :author_id, type: Integer
+  field :name, type: String
+  field :text, type: String
+  field :state, type: String
+  field :unassigned_user_ids, type: Array
+  
+  slug :name
+   
+  attr_accessible :story_id, :name, :text, :result_attributes
+  
+  scope :current, where(state: 'new')
+  scope :unassigned, where(user_id: nil)
+  scope :assigned, ne(user_id: nil)
+  scope :complete, where(state: 'completed')
+  scope :incomplete, ne(state: 'completed')
+  
+  validates :story_id, presence: true
+  validates :offeror_id, presence: true
+  validates :name, presence: true, uniqueness: { scope: :story_id }
+  validates :text, presence: true, if: ->(t) { t.class.name == 'Task' }
+  validate :reserved_words_exclusion
+  
+  after_initialize :cache_associations
+  before_validation :cache_associations  
+    
+  #track_history on: [:user_id, :name, :text, :state]
+    
+  PARENT_TYPES = ['story']
+
+  # 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
+  
+  def author; author_id ? User.find(author_id) : nil; end
+  def author=(value); self.author_id = value.id; end
+  
+  def result_class
+    if product_id.present?
+      "#{product.class.name}::Result".constantize rescue Result
+    else
+      Result
+    end
+  end
+  
+  private
+  
+  def reserved_words_exclusion
+    current_slug = to_param
+    
+    if ['new', 'edit', 'next'].include?(current_slug)
+      message = I18n.t(
+        'activerecord.errors.models.general.attributes.name.reserved_word_included'
+      )
+      errors[:name] << message unless errors[:name].include? message
+    end
+  end
+  
+  def cache_associations
+    self.offeror_id = story.offeror_id if story_id.present? && (story rescue nil)
+  end
+  
+  def cache_product_association
+    self.product_id = story.product_id if story_id.present? && (story rescue nil)
+  end
+end

data/app/models/user.rb

@@ -0,0 +1,95 @@
+class User < ActiveRecord::Base
+  include ::Applicat::Mvc::Model::Resource::Base
+  
+  belongs_to :main_role, class_name: 'Role'
+  belongs_to :profession
+  
+  has_and_belongs_to_many :roles, join_table: 'users_roles'
+  has_and_belongs_to_many :areas
+  has_and_belongs_to_many :projects
+  
+  has_many :offeror_vacancies, source: :offeror, class_name: 'Vacancy'
+  has_many :offeror_candidatures, source: :offeror, class_name: 'Candidature'
+  has_many :candidatures
+  
+  accepts_nested_attributes_for :areas, allow_destroy: true
+  
+  serialize :foreign_languages
+  
+  validates :name, presence: true, uniqueness: true
+  validates :first_name, presence: true
+  validates :last_name, presence: true
+  validates :language, presence: true
+  validates :country, presence: true
+  validates :interface_language, presence: true
+        
+  attr_accessible :name, :password, :password_confirmation, :text, :language, :first_name, :last_name, 
+                  :salutation, :marital_status, :family_status, :date_of_birth, :place_of_birth, :citizenship, 
+                  :email, :country, :language, :interface_language, :foreign_language_tokens, :profession_id, 
+                  :employment_relationship, :area_tokens,
+                  # preferences
+                  :main_role_id
+       
+  # :timeoutable, :token_authenticatable, :lockable,
+  # :lock_strategy => :none, :unlock_strategy => :nones
+  devise :database_authenticatable, :registerable,# :confirmable,
+         :recoverable, :rememberable, :trackable, :validatable 
+  
+  extend FriendlyId
+  
+  friendly_id :name, use: :slugged     
+  
+  after_create :set_main_role
+                  
+  PARENT_TYPES = ['area', 'project']
+  
+  def self.languages(query = nil)
+    options = []
+    
+    AVAILABLE_LANGUAGES.merge(OTHER_LANGUAGES).each do |locale, language|
+      next if query && !language.downcase.match(query.downcase)
+      
+      if query
+        options << { id: locale, name: language }
+      else
+        options << [language, locale]
+      end
+    end
+    
+    options
+  end
+  
+  def languages
+    (foreign_languages || []) + [language]
+  end
+  
+  def foreign_language_tokens=(tokens)
+    self.foreign_languages = tokens.split(',')
+  end
+  
+  def foreign_language_tokens
+    options = []
+    
+    User.languages.each do |language|
+      next unless (foreign_languages  || []).include?(language.second)
+        
+      options << { id: language.second, name: language.first } 
+    end
+    
+    options
+  end
+  
+  def area_tokens=(tokens)
+    self.area_ids = Area.ids_from_tokens(tokens)
+  end
+  
+  def area_tokens
+    areas
+  end
+  
+  private
+  
+  def set_main_role
+    self.update_attribute :main_role_id, Role.find_or_create_by_name('User').id
+  end
+end