trollied 0.1.0

data/app/controllers/notes_controller.rb

@@ -0,0 +1,121 @@
+class NotesController < ApplicationController
+  # Prevents the following error from showing up, common in Rails engines
+  # A copy of ApplicationController has been removed from the module tree but is still active!
+  unloadable
+
+  before_filter :get_order
+  before_filter :get_note, :except => [:new, :index, :create]
+
+  # GET /notes
+  # GET /notes.xml
+  def index
+    # TODO: add permission check of admin mechanism
+    # TODO: add pagination
+
+    @notes = @order.notes
+
+    respond_to do |format|
+      format.html # index.html.erb
+      # format.xml  { render :xml => @line_items }
+    end
+  end
+
+  # GET /notes/1
+  # GET /notes/1.xml
+  def show
+    respond_to do |format|
+      format.html # show.html.erb
+      # format.xml  { render :xml => @line_item }
+    end
+  end
+
+  # GET /notes/new
+  # GET /notes/new.xml
+  def new
+    @order.notes.new
+
+    respond_to do |format|
+      format.html # new.html.erb
+      # format.js { render :layout => false } # needs to come after html for IE to work
+      # format.xml  { render :xml => @line_item }
+    end
+  end
+
+  # GET /notes/1/edit
+  def edit
+  end
+
+  # POST /notes
+  # POST /notes.xml
+  def create
+    note_params = params[:note] || params[:order_note] || Hash.new
+
+    @note = @order.notes.new(note_params) 
+
+    respond_to do |format|
+      if @note.save
+        flash[:notice] = t('notes.controllers.created')
+        # we redirect to purchasable_item object in the new purchasable_item version
+        # assumes controller name is tableized version of class
+        format.html { redirect_to url_for_order_or_trolley }
+        # TODO: adjust :location accordingly for being a nested route
+        # format.xml  { render :xml => @line_item, :status => :created, :location => @line_item }
+      else
+        format.html { render :action => "new" }
+        # format.xml  { render :xml => @line_item.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # PUT /notes/1
+  # PUT /notes/1.xml
+  def update
+    respond_to do |format|
+      note_params = params[:note] || params[:order_note]
+      if @note.update_attributes(note_params)
+        flash[:notice] = t('notes.controllers.updated')
+        format.html { redirect_to url_for_order_or_trolley }
+        # format.xml  { head :ok }
+      else
+        format.html { render :action => "edit" }
+        # format.xml  { render :xml => @line_item.errors, :status => :unprocessable_entity }
+      end
+    end
+  end
+
+  # DELETE /notes/1
+  # DELETE /notes/1.xml
+  def destroy
+    @order ||= @note.order
+    return_to = @order ? url_for_order_or_trolley : { :action => :index }
+
+    @note.destroy
+
+    respond_to do |format|
+      flash[:notice] = t('notes.controllers.deleted')
+      format.html { redirect_to return_to }
+      # format.xml  { head :ok }
+    end
+  end
+
+  protected
+
+  def get_note
+    @note ||= if @order
+              if params[:id].present?
+                @order.notes.find(params[:id])
+              end
+            elsif params[:id].present?
+              Note.find(params[:id])
+            end
+  end
+
+  def get_order
+    @order = if params[:order_id].present?
+               Order.find(params[:order_id])
+             elsif params[:id].present?
+               @note = Note.find(params[:id]) 
+               @note.order
+             end
+  end
+end

data/app/controllers/orders_controller.rb

@@ -0,0 +1,210 @@
+class OrdersController < ApplicationController
+  # Prevents the following error from showing up, common in Rails engines
+  # A copy of ApplicationController has been removed from the module tree but is still active!
+  unloadable
+
+  before_filter :get_user, :only => [:index]
+  before_filter :get_trolley
+  before_filter :get_order, :except => [:new, :index, :create]
+
+  # GET /orders
+  # GET /orders.xml
+   def index
+     # TODO: add permission check of admin mechanism
+
+     # 'all' will return what you expect, i.e. orders for all states
+     # other valid values are specific state names
+     # default should be set depending on rights of current_user
+     # we'll start with an assumption of staff view
+     # as a user's trolley lists their own current orders by default
+     @state = params[:state].present? ? params[:state] : 'in_process'
+     params[:state] = @state
+
+     @conditions = set_up_conditions_based_on_params
+
+     options = { :page => params[:page],
+       :per_page => 5,
+       :conditions => @conditions }
+
+     @orders = Order.paginate(options)
+
+     respond_to do |format|
+       format.html # index.html.erb
+       # format.xml  { render :xml => @line_items }
+     end
+   end
+
+   # GET /orders/1
+   # GET /orders/1.xml
+   def show
+     respond_to do |format|
+       format.html # show.html.erb
+       # format.xml  { render :xml => @line_item }
+     end
+   end
+
+   # GET /orders/new
+   # GET /orders/new.xml
+   def new
+     @trolley ||= current_user ? current_user.trolley : raise # trolley not found
+
+     @trolley.orders.new
+
+     respond_to do |format|
+       format.html # new.html.erb
+       # format.js { render :layout => false } # needs to come after html for IE to work
+       # format.xml  { render :xml => @line_item }
+     end
+   end
+
+   # GET /orders/1/edit
+   def edit
+   end
+
+   # POST /orders
+   # POST /orders.xml
+   def create
+     order_params = params[:order] || params[:trolley_order] || Hash.new
+
+     @order = @trolley.orders.new(order_params) 
+
+     respond_to do |format|
+       if @order.save
+         flash[:notice] = t('orders.controllers.created')
+         # we redirect to purchasable_item object in the new purchasable_item version
+         # assumes controller name is tableized version of class
+         format.html { redirect_to url_for_trolley }
+         # TODO: adjust :location accordingly for being a nested route
+         # format.xml  { render :xml => @line_item, :status => :created, :location => @line_item }
+       else
+         format.html { render :action => "new" }
+         # format.xml  { render :xml => @line_item.errors, :status => :unprocessable_entity }
+       end
+     end
+   end
+
+   # PUT /orders/1
+   # PUT /orders/1.xml
+   def update
+     respond_to do |format|
+       order_params = params[:order] || params[:trolley_order]
+       if @order.update_attributes(order_params)
+         flash[:notice] = t('orders.controllers.updated')
+         format.html { redirect_to @order }
+         # format.xml  { head :ok }
+       else
+         format.html { render :action => "edit" }
+         # format.xml  { render :xml => @line_item.errors, :status => :unprocessable_entity }
+       end
+     end
+   end
+
+   # DELETE /orders/1
+   # DELETE /orders/1.xml
+   def destroy
+     @trolley ||= @order.trolley
+     return_to = @trolley ? url_for_trolley : { :action => :index }
+
+     @order.destroy
+
+     respond_to do |format|
+       flash[:notice] = t('orders.controllers.deleted')
+       format.html { redirect_to return_to }
+       # format.xml  { head :ok }
+     end
+   end
+
+   # additional actions that correspond to order_status events
+   %w(checkout cancel fulfilled_without_acceptance finish).each do |event|
+     code = Proc.new { 
+       @order.send("#{event}!")
+       @trolley ||= @order.trolley
+
+       flash[:notice] = t("orders.controllers.change_to_#{event}")
+       redirect_to url_for_trolley
+     }
+
+     define_method(event, &code)
+   end
+
+   private
+   # accepts line_item.locale or line_item.id for lookup
+   # line_item.locale should be unique within the scope of @purchasable_item
+   def get_order
+     @order = if @trolley
+                         if params[:id].present?
+                           @trolley.orders.find(params[:id])
+                         else
+                           @trolley.selected_order
+                         end
+                       elsif params[:id].present?
+                         Order.find(params[:id])
+                       end
+   end
+
+   def get_trolley
+     @trolley = if params[:trolley_id].present?
+                  Trolley.find(params[:trolley_id])
+                elsif @user
+                  @user.trolley
+                end
+   end
+
+   def get_user
+     @user = if params[:user_id].present? || params[:user].present?
+               id = params[:user_id].present? ? params[:user_id] : params[:user]
+               User.find(id)
+             end
+   end
+
+   # validate and add them as conditions
+   def add_date_clause_and_var_for(name, clauses_array, clauses_hash)
+     if params[name].present?
+       value = params[name]
+       var_name = "@" + name.to_s
+
+       instance_variable_set(var_name, value)
+
+       begin
+         Date.parse(value)
+         operator = ">="
+         operator = "<=" if name == :until
+
+         clauses_array << "created_at #{operator} :#{name}"
+         clauses_hash[name] = value
+       rescue
+         instance_variable_set(var_name, nil)
+       end
+     end
+   end
+
+   def default_conditions_hash
+     { :workflow_state => @state }
+   end
+
+   def set_up_conditions_based_on_params
+     conditions_clauses = Array.new
+     conditions_hash = default_conditions_hash
+
+     # handle date range
+     add_date_clause_and_var_for(:from, conditions_clauses, conditions_hash)
+     add_date_clause_and_var_for(:until, conditions_clauses, conditions_hash)
+
+     # user is a little funnier because trolley is what has the direct user relation
+     # so trolley is really what will give us a user's orders
+     conditions_hash[:trolley_id] = @trolley.id if @trolley
+
+     if conditions_clauses.size > 0
+       conditions_hash.each do |k,v|
+         conditions_clauses << "#{k} = :#{k}" unless conditions_clauses.join.include?(':' + k.to_s)
+       end
+     end
+
+     conditions = if conditions_clauses.size == 0
+                    conditions_hash
+                  else
+                    [conditions_clauses.join(" AND "), conditions_hash]
+                  end
+     
+   end
+end

data/app/controllers/trolleys_controller.rb

@@ -0,0 +1,26 @@
+class TrolleysController < ApplicationController
+  # Prevents the following error from showing up, common in Rails engines
+  # A copy of ApplicationController has been removed from the module tree but is still active!
+  unloadable
+
+  before_filter :get_trollied_user
+  before_filter :get_trolley
+
+  # list orders
+  def show
+    respond_to do |format|
+      format.html # index.html.erb
+    end
+  end
+  
+  protected
+
+  def get_trollied_user
+    @trollied_user = User.find(params[:user_id])
+  end
+
+  def get_trolley
+    @trolley = @trollied_user.trolley
+  end
+
+end

data/app/helpers/gets_trollied_helper.rb

@@ -0,0 +1,31 @@
+# include this to gain helpers for shopping trolley
+module GetsTrolliedHelper
+  include HasTrolleyControllerHelpers::UrlFor
+
+  # wrapped in a div to allow for styling the form to be inline
+  def button_to_place_in_trolley(purchasable_item)
+    "<div class=\"add-to-trolley\">" +
+      button_to(t('gets_trollied_helper.add_to_trolley'),
+                :controller => :line_items,
+                :action => :create,
+                purchasable_item.class.as_foreign_key_sym => purchasable_item) +
+      "</div>"
+  end
+
+  # TODO: trolley link
+
+  def in_trolley_status_or_button_to_place_in_trolley(purchasable_item)
+    html = String.new
+    if current_user && current_user != false &&
+        current_user.respond_to?(:trolley) &&
+        current_user.trolley.has_active_order_for?(purchasable_item)
+      html = "<div class=\"in-trolley\">" +
+        t('gets_trollied_helper.in_trolley') +
+        "</div>"
+    else
+      html = button_to_place_in_trolley(purchasable_item)
+    end
+    html
+  end
+
+end

data/app/helpers/line_items_helper.rb

@@ -0,0 +1,5 @@
+module LineItemsHelper
+  def link_to_purchasable_in(line_item)
+    link_to line_item.description_for_purchasing, line_item.purchasable_item
+  end
+end

data/app/helpers/orders_helper.rb

@@ -0,0 +1,184 @@
+module OrdersHelper
+  # implement in your application
+  def link_to_profile_for(user)
+    link_to user.trolley_user_display_name, url_for_trolley(:user => user)
+  end
+
+  def link_to_orders_for(user)
+    link_to(user.trolley_user_display_name, :user => user)
+  end
+
+  def can_delete_line_item?(order)
+    (params[:controller] == 'orders' &&
+     order.workflow_state == 'in_process') ||
+      order.state_ok_to_delete_line_item?
+  end
+
+  # override the method can_trigger_...? methods with your own security checks
+  def can_trigger_fulfilled_without_acceptance?
+    params[:controller] == 'orders'
+  end
+
+  def can_trigger_finish?
+    params[:controller] == 'orders'
+  end
+
+  def order_button_for(action, order)
+    options = { :confirm => t('orders.order.are_you_sure'),
+      :class => 'order-button' }
+
+    options[:method] = 'delete' if action.to_s == 'destroy'
+
+    button_to(t("orders.order.#{action}"),
+              { :controller => :orders,
+                :action => action,
+                :id => order },
+              options)
+  end
+
+  # define button_to methods for each possible event name for Order
+  Order.workflow_event_names.each do |event_name|
+    code = lambda { |order|
+      order_button_for(event_name.to_s, order)
+    }
+
+    define_method("button_to_#{event_name}", &code)
+  end
+
+  # special case
+  def button_to_clear(order)
+    order_button_for('destroy', order)
+  end
+
+  # single definition helper for format of displaying number of something
+  def show_count_for(number)
+    " (#{number})"
+  end
+
+  def link_to_state_unless_current(state, count)
+    link_to_unless_current(t("orders.index.#{state}") + show_count_for(count),
+                           :state => state,
+                           :user => @user,
+                           :trolley => @trolley,
+                           :from => @from,
+                           :until => @until)
+  end
+
+  # returns a list of links to order states
+  # that have orders in their state
+  # with number of orders in a given state indicated
+  def state_links
+    html = '<ul id="state-links" class="horizontal-list">'
+
+    states_count = 1
+
+    states = Order.workflow_spec.state_names.sort_by { |s| I18n.t("orders.index.#{s.to_s}") }
+
+    states.each do |state|
+      adjusted_conditions = adjust_value_in_conditions_for(:workflow_state, state.to_s, @conditions)
+
+      with_state_count = Order.count(:conditions => adjusted_conditions)
+
+      if with_state_count > 0
+        classes = 'state-link'
+        classes += ' first' if states_count == 1
+
+        if state == :in_process && @state == state.to_s
+          html += content_tag('li',
+                              t("orders.index.#{state}") + show_count_for(with_state_count),
+                              :class => classes)
+        else
+          html += content_tag('li',
+                              link_to_state_unless_current(state, with_state_count),
+                              :class => classes)
+          
+        end
+        states_count += 1
+      end
+    end
+
+    html += '</ul>'
+  end
+
+  def order_date_value(direction)
+    return String.new unless @conditions
+
+    new_conditions = drop_key_from_conditions(:from, @conditions)
+    new_conditions = drop_key_from_conditions(:until, new_conditions)
+
+    value = Order.find(:first,
+                       :select => 'created_at',
+                       :order => "created_at #{direction}",
+                       :conditions => new_conditions)
+
+    value.created_at.to_s(:db).split('\s')[0]
+  end
+
+  def oldest_order_value
+    default_date_value('asc')
+  end
+
+  def newest_order_value
+    default_date_value('desc')
+  end
+
+  def orders_state_headline
+    html = t("orders.helpers.#{@state}_orders")
+    
+    if @from
+      html += ' ' + t('orders.helpers.from') + ' '
+      html += @from
+    end
+    
+    if @until
+      html += ' ' + t('orders.helpers.until') + ' '
+      html += @until
+    end
+
+    if @user
+      html += ' ' + t('orders.helpers.by') + ' '
+      html += @user.trolley_user_display_name
+    end
+
+    html
+  end
+
+  def clear_extra_params
+    if @user || @from || @until
+      clear_link = link_to(t("orders.helpers.clear_params"),
+                           :state => @state,
+                           :user => nil,
+                           :trolley => nil,
+                           :from => nil,
+                           :until => nil)
+
+      clear_link = ' [ ' + clear_link + ' ]'
+      content_tag('span', clear_link, :class => 'clear-params')
+    end
+  end
+
+  private
+  
+  def adjust_value_in_conditions_for(key, value, conditions)
+    new_conditions_hash = Hash.new
+    if conditions.is_a?(Array)
+      new_conditions_hash = conditions[1]
+    else
+      new_conditions_hash = conditions
+    end
+
+    new_conditions_hash.delete(:key)
+    
+    new_conditions_hash[key] = value unless value == nil
+
+    new_conditions = conditions.is_a?(Array) ? [conditions[0], new_conditions_hash] : new_conditions_hash
+  end
+
+  def drop_key_from_conditions(key, conditions)
+    adjust_value_in_conditions_for(key, nil, conditions)
+  end
+
+  def url_for_options_for_orders_index
+    { :controller => 'orders', :action => 'index' }
+  end
+end

data/app/models/line_item.rb

@@ -0,0 +1,14 @@
+class LineItem < ActiveRecord::Base
+  belongs_to :order
+  belongs_to :purchasable_item, :polymorphic => true
+
+  delegate :description_for_purchasing, :to => :purchasable_item
+
+  delegate :user, :to => :order
+
+  # needs to be unique to orders that are current (but not unique to orders generally)
+  # validates_uniqueness_of :order_id, :scope => [:purchasable_item_type, :purchasable_item_id]
+  def validate
+    errors.add(:order, I18n.t('line_item.already_in_order')) if !order.current? && !order.in_process? && order.contains?(purchasable_item)
+  end
+end

data/app/models/note.rb

@@ -0,0 +1,15 @@
+# simple model for adding notes by either staff or ordering user to an order
+# note is body attribute
+class Note < ActiveRecord::Base
+  belongs_to :order
+  belongs_to :user
+
+  after_create :alert_order
+
+  private
+  
+  def alert_order
+    order.new_note(self)
+  end
+end
+

data/app/models/order.rb

@@ -0,0 +1,29 @@
+class Order < ActiveRecord::Base
+  belongs_to :trolley
+  has_many :line_items, :dependent => :destroy
+  has_many :notes, :dependent => :destroy
+
+  # has user by its relation to trolley
+  delegate :user, :to => :trolley
+
+  include OrderStatus
+  
+  # convenience method to add new line item based on item_to_order
+  def add(purchasable_item)
+    line_items.create!(:purchasable_item => purchasable_item)
+  end
+
+  # do any of this order's line_items contain the purchasable_item?
+  def contains?(purchasable_item)
+    return false if line_items.size == 0
+    
+    line_items.each do |line_item|
+      return true if line_item.purchasable_item == purchasable_item
+    end
+    false
+  end
+
+  def may_note?
+    in_process? || ready? || user_review?
+  end
+end

data/app/models/trolley.rb

@@ -0,0 +1,51 @@
+class Trolley < ActiveRecord::Base
+  belongs_to :user
+  has_many :orders
+
+  # get specified order (or first, if not specified)
+  # or create one if none exists
+  def selected_order(position = 1)
+    index = position - 1
+    
+    orders[index] || orders.create!
+  end
+
+  # TODO: STUB: implement way to determine
+  # correct order given an purchasable_item
+  def correct_order(purchasable_item)
+    orders.with_state_current.first || orders.create!
+  end
+
+  # add item or array of items to trolley
+  def add(*items_to_order)
+    # get order
+    items_to_order.each do |item|
+      selected_order.add(item)
+    end
+  end
+
+  # do any of this trolley's orders contain the purchasable_item?
+  # TODO: when status is added to orders, limit by option for checking status
+  def contains?(purchasable_item, state = nil)
+    within_orders = state ? orders.send("with_state_#{state}") : orders
+
+    these_contain?(within_orders, purchasable_item)
+  end
+
+  def these_contain?(within_orders, purchasable_item)
+    return false if within_orders.size == 0
+
+    within_orders.each do |order|
+      return true if order.contains?(purchasable_item)
+    end
+    false
+  end
+
+  # active is defined as either current or in_process order
+  def has_active_order_for?(purchasable_item)
+    within_orders = orders.with_state_current + orders.with_state_in_process + orders.with_state_ready
+
+    these_contain?(within_orders, purchasable_item)
+  end
+
+end

data/app/views/line_items/_form.html.erb

@@ -0,0 +1,8 @@
+<%= form.error_messages %>
+<%= hidden_field_tag :user, @user.id  %>
+
+<! -- display details, so user can confirm -->
+
+
+<%= form.submit @button_text %>
+