voluntary 0.0.1

data/app/controllers/workflow/stories_controller.rb

@@ -0,0 +1,6 @@
+class Workflow::StoriesController < ApplicationController
+  def index
+    @product = Product.find(params[:product_id])
+    @stories = @product.stories
+  end
+end

data/app/controllers/workflow/tasks_controller.rb

@@ -0,0 +1,147 @@
+class Workflow::TasksController < ApplicationController
+  include Wizard::Controller
+  
+  wizard_steps :work, :review
+  wizard_step_per_state work: [:assigned], review: [:under_supervision] 
+  
+  before_filter :build_result, only: [:edit, :cancel, :skip, :update]
+  load_and_authorize_resource except: [:next]
+  
+  helper_method :resource
+  
+  def current_step_is_next_step_after_event
+    false
+  end
+  
+  def index
+    @story = Story.find(params[:story_id])
+    @tasks = @story.tasks
+    
+    # increase level when there are more sub items for tasks_workflow_user_index_path(@task))
+    @twitter_sidenav_level = 4
+  end
+  
+  def next
+    story = Story.find(params[:story_id])
+    task = story.next_task_for_user(current_user)
+    product_id = story.product_id.blank? ? 'no-name' : story.product_id
+    
+    if task.is_a?(String) 
+      redirect_to(
+        product_workflow_user_index_path(product_id), notice: task
+      ) and return
+    elsif task
+      redirect_to edit_task_workflow_user_index_path(task) and return  
+    else
+      redirect_to(
+        product_workflow_user_index_path(product_id), 
+        notice: I18n.t('workflow.user.tasks.next.unavailable')
+      ) and return
+    end
+  end
+  
+  def edit
+    @story = @task.story
+  end
+  
+  def cancel
+    if @task.cancel
+      notice = I18n.t(
+        "general.notifications.event_successful", 
+        event: I18n.t("tasks.general.events.cancel")
+      )
+      redirect_to(
+        tasks_workflow_user_index_path(@task.story), notice: notice
+      ) and return
+    else
+      render 'edit' and return
+    end
+  end
+
+  def skip
+    if @task.cancel
+      redirect_to(
+        next_task_workflow_user_index_path(@task.story)
+      ) and return
+    else
+      render 'edit' and return
+    end
+  end
+  
+  def update
+    if params[:event] && params[:event].keys.select{|k| ['cancel', 'skip'].include?(k)}.any?
+      send(params[:event].keys.first)
+      return
+    end
+    
+    @task.attributes = params[:task]
+    method = params[:event] ? params[:event].keys.first : 'save'
+    success = false
+    
+    if @result.valid?
+      success = if params[:next_step] == '1' || (params[:event] && params[:event][:next])
+        @task.send(step) 
+      elsif (method == 'save' && can?(:update, @task)) || can?(method.to_sym, @task)
+        @task.send(method)
+      else
+        false
+      end
+    end
+    
+    render 'edit' and return unless success
+        
+    @result.save
+    
+    if params[:event] && params[:event][:next]
+      redirect_to(
+        next_task_workflow_user_index_path(@task.story), 
+        notice: I18n.t('general.form.successfully_updated')
+      ) and return
+    end
+    
+    notice = if method == 'save'
+      I18n.t('general.form.successfully_updated')
+    else
+      I18n.t(
+        "general.notifications.event_successful", 
+        event: I18n.t("tasks.general.events.#{method}")
+      )
+    end
+    
+    if can? :edit, @task
+      redirect_to(
+        edit_task_workflow_user_index_path(@task), notice: notice
+      )
+    else
+      redirect_to(
+        tasks_workflow_user_index_path(@task.story), notice: notice
+      )
+    end
+  end
+  
+  def resource
+    @task ||= Task.find(params[:id])
+  end
+  
+  private
+  
+  def build_result
+    result_params = params[:task] ? params[:task].delete(:result_attributes) : nil
+    result_params = result_params || {}
+    
+    unless resource.result_id.present?
+      @result = resource.result_class.new(result_params.merge(task_id: resource.id))
+      @result.errors.clear
+      return
+    end
+    
+    if resource.result
+      @result = resource.result
+    elsif resource.result_id
+      # WORKAROUND: do we still need this case?
+      @result = resource.result_class.find(resource.result_id)
+    end
+    
+    result_params.each {|param,value| @result.send("#{param}=", value) }
+  end
+end

data/app/controllers/workflow/user_controller.rb

@@ -0,0 +1,6 @@
+class Workflow::UserController < ApplicationController
+  def index
+    @assigned_tasks = Task.where(user_id: current_user.id, state: 'assigned')
+    @completed_tasks = Task.complete.where(user_id: current_user.id)
+  end
+end

data/app/controllers/workflow/vacancies_controller.rb

@@ -0,0 +1,17 @@
+class Workflow::VacanciesController < ApplicationController
+  def open
+    @vacancies = Vacancy.where(state: 'open')
+  end
+  
+  def recommended
+    @vacancies = Vacancy.where(state: 'recommended') 
+  end
+  
+  def denied
+    @vacancies = Vacancy.where(state: 'denied')
+  end
+  
+  def closed
+    @vacancies = Vacancy.where(state: 'closed')
+  end
+end

data/app/controllers/workflow_controller.rb

@@ -0,0 +1,7 @@
+class WorkflowController < ApplicationController
+  before_filter :authenticate_user!
+  
+  def index
+    @twitter_sidenav_level = 2
+  end
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,65 @@
+module ApplicationHelper
+  include AutoHtml
+  
+  def self.root_model_class_name_helper(resource)
+    if resource.class.superclass.name == 'ActiveRecord::Base'
+      resource.class.name
+    elsif resource.class.superclass.name == 'Object'
+      # classes like mongo db models without a specific superclass
+      resource.class.name
+    else
+      resource.class.superclass.name
+    end
+  end
+  
+  def markdown(text)
+    text = Redcarpet::Markdown.new(Redcarpet::Render::XHTML.new(filter_html: true)).render(text)
+    
+    auto_html(text) do 
+      youtube(width: 515, height: 300)
+      dailymotion(width: 515, height: 300)
+      vimeo(width: 515, height: 300)
+      google_video(width: 515, height: 300)
+      image
+
+      redcarpet(
+        renderer: Redcarpet::Render::XHTML.new(
+          no_images: true, no_styles: true, hard_wrap: true, with_toc_data: true
+        ),
+        markdown_options: { no_intra_emphasis: true, autolink: true, fenced_code_blocks: true }
+      )
+      link :target => "_blank", :rel => "nofollow"
+    end.gsub(/(>https?:\/\/[^\<\\]+)/) do |match| 
+      truncate(match)
+    end.html_safe
+  end
+  
+  def root_model_class_name(resource)
+    ::ApplicationHelper.root_model_class_name_helper(resource)
+  end
+  
+  def directory_for_resource(resource)
+    resource.class.name.split('::').last.underscore
+  end
+  
+  def link_list(collection)
+    raw collection.map{|a| link_to a.name, a}.join(', ')
+  end
+  
+  def general_attribute?(attribute)
+    begin
+      t("activerecord.attributes.general.#{attribute}", raise: true)
+      true
+    rescue
+      false
+    end
+  end
+  
+  def attribute_translation(attribute, current_resource = nil)
+    current_resource = current_resource || resource
+    
+    t("activerecord.attributes.#{root_model_class_name(current_resource).underscore}.#{attribute}",
+      default: t("activerecord.attributes.general.#{attribute}")
+    )
+  end
+end

data/app/helpers/collection_helper.rb

@@ -0,0 +1,31 @@
+module CollectionHelper
+  def table_cell column, resource, alternative_value = nil
+    value = '-'
+    
+    if column == 'name'
+      value = resource.send(column)
+      
+      if alternative_value.is_a?(Proc)
+        return alternative_value.call(resource)
+      elsif value.blank? && alternative_value.present? 
+        value = eval("resource.#{alternative_value}")
+      elsif value.blank?
+        value = '-'
+      end
+      
+      link_to value, eval("#{root_model_class_name(resource).tableize.singularize}_path(resource)")
+    elsif column.match('_id')
+      association = nil
+      
+      begin
+        association = resource.send(column.gsub('_id', '')) 
+      rescue 
+        association = eval("resource.#{alternative_value}") if alternative_value.present?
+      end
+      
+      association ? link_to(association.name, association) : value
+    else
+      resource.send(column) 
+    end
+  end
+end

data/app/helpers/comments_helper.rb

@@ -0,0 +1,11 @@
+module CommentsHelper
+  def nested_comments(comments)
+    comments.map do |comment, sub_comments|
+      next if comment.id.blank?
+      
+      content = render(partial: 'comments/resource', locals: { resource: comment }) 
+      content += content_tag(:div, nested_comments(sub_comments), class: 'nested_comments')
+      content
+    end.join.html_safe
+  end
+end

data/app/helpers/form_helper.rb

@@ -0,0 +1,39 @@
+module FormHelper
+  def link_to_add_fields(name, f, association, options = {})
+    attributes = { 
+      "#{root_model_class_name(f.object).tableize.singularize}_id".to_sym => f.object.id
+    }
+    
+    new_object = if f.object.respond_to? "#{association.to_s.singularize}_class"
+      f.object.tasks.new(attributes)
+    else
+      f.object.send(association).new(attributes)
+    end
+    
+    id = new_object.object_id
+
+    fields = f.fields_for(association, new_object, child_index: id) do |builder|
+      render_product_specific_partial_if_available(
+        new_object, "#{controller_name}/#{association.to_s.singularize}_fields",
+        f: builder
+      )
+    end
+    
+    data = {id: id, fields: fields.gsub("\n", '')}
+    data[:target] = options[:target] if options.has_key?(:target)
+        
+    link_to(name, '#', class: 'add_fields', data: data)
+  end
+  
+  def remove_fields(f)
+    if f.object.try(:new_record?)
+      link_to t('general.remove'), '#', class: 'remove_fields'
+    else
+      f.check_box(:_destroy) + f.label(:_destroy, t('general.destroy'))
+    end
+  end
+    
+  def autocomplete_input(f, field)
+    f.input "#{field}_name", input_html: { data: {autocomplete: eval("autocomplete_#{field.to_s.tableize}_path")} }
+  end
+end

data/app/helpers/language_helper.rb

@@ -0,0 +1,15 @@
+module LanguageHelper
+  def available_language_options
+    options = []
+    
+    AVAILABLE_LANGUAGES.each do |locale, language|
+      options << [language, locale]
+    end
+    
+    options.sort_by { |o| o[0] }
+  end
+  
+  def all_language_options
+    User.languages.sort_by { |o| o[0] }
+  end
+end

data/app/helpers/layout_helper.rb

@@ -0,0 +1,24 @@
+module LayoutHelper
+  def breadcrumbs
+    result = render_navigation context: :main, renderer: :breadcrumbs_without_method_links, join_with: ' > '
+    result && result.split('<a').length > 2 ? result : ''
+  end
+  
+  def sidenav
+    result = render_navigation context: :main, renderer: :twitter_sidenav, level: @twitter_sidenav_level
+    result && result.split('<a').length > 2 ? result : ''
+  end
+  
+  def footer_navigation
+    links = []
+    
+    ['privacy-policy', 'terms-of-use', 'about-us'].each do |page_name|
+      text = t("pages.#{page_name.gsub('-', '_')}.title")
+      path = "#{controller_name}/#{params[:id]}"
+      active = path == "#{controller_name}/#{page_name}"
+      links << (active ? text : link_to(text, page_path(page_name)))
+    end
+    
+    raw links.join(' | ')
+  end
+end

data/app/helpers/product_helper.rb

@@ -0,0 +1,32 @@
+module ProductHelper
+  def render_product_specific_presenter_if_available(resource, partial_path, method, options = {})
+    if @presenter.respond_to?(method)
+      @step_presenter = @presenter.send(method) 
+    else
+      @step_presenter = nil
+    end
+    
+    render_product_specific_partial_if_available(resource, "#{partial_path}/#{method}", options)
+  end
+  
+  def render_product_specific_partial_if_available(resource, partial_path, options = {})
+    path = nil
+    partial_path = partial_path.split('/')
+    file_name = partial_path.pop
+    partial_path = partial_path.join('/')
+    
+    if resource && resource.respond_to?(:product) && resource.product
+      path = "products/types/#{directory_for_resource(resource.product)}/#{partial_path}"
+      
+      if File.exist?("#{Rails.root.to_s}/app/views/#{path}/_#{file_name}.html.erb")
+        path = [path, file_name].join('/')
+      else
+        path = nil
+      end
+    end
+
+    path = [partial_path, file_name].join('/') if path.blank?
+
+    render path, options 
+  end
+end

data/app/helpers/show_helper.rb

@@ -0,0 +1,65 @@
+module ShowHelper
+  def show_attributes(*attributes)
+    result = ''
+    
+    attributes.each {|attribute| result += show_attribute attribute}
+    
+    raw result
+  end
+  
+  def show_attribute(attribute, options = {})
+    title = options[:title] || attribute_translation(attribute)
+    value = options[:value] || resource.send(attribute)
+    
+    value.blank? ? '' : content_tag(:dt, title) + content_tag(:dd, value)
+  end
+  
+  def show_associations(*associations)
+    result = ''
+    
+    associations.each {|association| result += show_association association}
+    
+    raw result
+  end
+  
+  def show_association(association)
+    if association.to_s == association.to_s.pluralize
+      return show_attribute(
+        association,
+        title: t("#{association}.index.title"), 
+        value: raw(resource.send(association).map{|a| link_to a.name, a}.join(', '))
+      )
+    end
+    
+    title = if general_attribute?(:parent)
+      t("activerecord.attributes.general.#{association}")
+    else
+      if resource.send(association) 
+        t("activerecord.models.#{root_model_class_name(resource.send(association)).underscore}")
+      else 
+        t("activerecord.models.#{association}")
+      end
+    end
+    
+    if resource.send(association)
+      show_attribute(
+        association,
+        title: title, 
+        value: link_to(resource.send(association).try(:name), resource.send(association))
+      )  
+    else
+      ''
+    end
+  end
+  
+  def show_actions
+    result  = content_tag :dt, raw('&nbsp')
+    result += content_tag :dd, render(
+      partial: 'shared/resource/actions', locals: { 
+        type: root_model_class_name(resource).tableize, resource: resource 
+      }
+    )
+     
+    raw result
+  end
+end