foodcoops / foodsoft / 473

pending completion

Build # 473

Build Type

Pull #278

travis-ci

Committed by

wvengen

Commit Message

<a href="https://github.com/foodcoops/foodsoft/commit/<a class=hub.com/foodcoops/foodsoft/commit/29f317732a348fd9488d37c439d4b16f8f205054">29f317732<a href="https://github.com/foodcoops/foodsoft/commit/29f317732a348fd9488d37c439d4b16f8f205054">&quot;&gt;reload app config before each test

(complements </a><a class="double-link" href="https://github.com/foodcoops/foodsoft/commit/<a class="double-link" href="https://github.com/foodcoops/foodsoft/commit/21bef8e304d05025b72b39e790abc7e8a4f4f5e1">21bef8e30</a>">21bef8e30</a><a href="https://github.com/foodcoops/foodsoft/commit/29f317732a348fd9488d37c439d4b16f8f205054">)

Pull Request Pull Request #278: use minimal app_config for tests

Run Details

6 of 6 new or added lines in 1 file covered. (100.0%)

1624 of 2222 relevant lines covered (73.09%)

36.45 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

81.75

/app/models/order.rb

# encoding: utf-8
#
class Order < ActiveRecord::Base

  attr_accessor :ignore_warnings

  # Associations
  has_many :order_articles, :dependent => :destroy
  has_many :articles, :through => :order_articles
  has_many :group_orders, :dependent => :destroy
  has_many :ordergroups, :through => :group_orders
  has_one :invoice
  has_many :comments, -> { order('created_at') }, :class_name => "OrderComment"
  has_many :stock_changes
  belongs_to :supplier
  belongs_to :updated_by, :class_name => 'User', :foreign_key => 'updated_by_user_id'
  belongs_to :created_by, :class_name => 'User', :foreign_key => 'created_by_user_id'

  # Validations
  validates_presence_of :starts
  validate :starts_before_ends, :include_articles
  validate :keep_ordered_articles

  # Callbacks
  after_save :save_order_articles, :update_price_of_group_orders

  # Finders
  scope :open, -> { where(state: 'open').order('ends DESC') }
  scope :finished, -> { where("orders.state = 'finished' OR orders.state = 'closed'").order('ends DESC') }
  scope :finished_not_closed, -> { where(state: 'finished').order('ends DESC') }
  scope :closed, -> { where(state: 'closed').order('ends DESC') }
  scope :stockit, -> { where(supplier_id: 0).order('ends DESC') }

  scope :recent, -> { order('starts DESC').limit(10) }

  def stockit?
    supplier_id == 0
  end

  def name
    stockit? ? I18n.t('orders.model.stock') : supplier.name
  end

  def articles_for_ordering
    if stockit?
      # make sure to include those articles which are no longer available
      # but which have already been ordered in this stock order
      StockArticle.available.includes(:article_category).
        order('article_categories.name, articles.name').reject{ |a|
        a.quantity_available <= 0 and not a.ordered_in_order?(self)
      }.group_by { |a| a.article_category.name }
    else
      supplier.articles.available.group_by { |a| a.article_category.name }
    end
  end

  def supplier_articles
    if stockit?
      StockArticle.undeleted.reorder('articles.name')
    else
      supplier.articles.undeleted.reorder('articles.name')
    end
  end

  # Save ids, and create/delete order_articles after successfully saved the order
  def article_ids=(ids)
    @article_ids = ids
  end

  def article_ids
    @article_ids ||= order_articles.map { |a| a.article_id.to_s }
  end

  # Returns an array of article ids that lead to a validation error.
  def erroneous_article_ids
    @erroneous_article_ids ||= []
  end

  def open?
    state == "open"
  end

  def finished?
    state == "finished"
  end

  def closed?
    state == "closed"
  end

  def expired?
    !ends.nil? && ends < Time.now
  end

  # search GroupOrder of given Ordergroup
  def group_order(ordergroup)
    group_orders.where(:ordergroup_id => ordergroup.id).first
  end

  # Returns OrderArticles in a nested Array, grouped by category and ordered by article name.
  # The array has the following form:
  # e.g: [["drugs",[teethpaste, toiletpaper]], ["fruits" => [apple, banana, lemon]]]
  def articles_grouped_by_category
    @articles_grouped_by_category ||= order_articles.
        includes([:article_price, :group_order_articles, :article => :article_category]).
        order('articles.name').
        group_by { |a| a.article.article_category.name }.
        sort { |a, b| a[0] <=> b[0] }
  end

  def articles_sort_by_category
    order_articles.includes(:article).order('articles.name').sort do |a,b|
      a.article.article_category.name <=> b.article.article_category.name
    end
  end

  # Returns the defecit/benefit for the foodcoop
  # Requires a valid invoice, belonging to this order
  #FIXME: Consider order.foodcoop_result
  def profit(options = {})
    markup = options[:without_markup] || false
    if invoice
      groups_sum = markup ? sum(:groups_without_markup) : sum(:groups)
      groups_sum - invoice.net_amount
    end
  end

  # Returns the all round price of a finished order
  # :groups returns the sum of all GroupOrders
  # :clear returns the price without tax, deposit and markup
  # :gross includes tax and deposit. this amount should be equal to suppliers bill
  # :fc, guess what...
  def sum(type = :gross)
    total = 0
    if type == :net || type == :gross || type == :fc
      for oa in order_articles.ordered.includes(:article, :article_price)
        quantity = oa.units * oa.price.unit_quantity
        case type
          when :net
            total += quantity * oa.price.price
          when :gross
            total += quantity * oa.price.gross_price
          when :fc
            total += quantity * oa.price.fc_price
        end
      end
    elsif type == :groups || type == :groups_without_markup
      for go in group_orders.includes(group_order_articles: {order_article: [:article, :article_price]})
        for goa in go.group_order_articles
          case type
            when :groups
              total += goa.result * goa.order_article.price.fc_price
            when :groups_without_markup
              total += goa.result * goa.order_article.price.gross_price
          end
        end
      end
    end
    total
  end

  # Finishes this order. This will set the order state to "finish" and the end property to the current time.
  # Ignored if the order is already finished.
  def finish!(user)
    unless finished?
      Order.transaction do
        # set new order state (needed by notify_order_finished)
        update_attributes!(:state => 'finished', :ends => Time.now, :updated_by => user)

        # Update order_articles. Save the current article_price to keep price consistency
        # Also save results for each group_order_result
        # Clean up
        order_articles.includes(:article).each do |oa|
          oa.update_attribute(:article_price, oa.article.article_prices.first)
          oa.group_order_articles.each do |goa|
            goa.save_results!
            # Delete no longer required order-history (group_order_article_quantities) and
            # TODO: Do we need articles, which aren't ordered? (units_to_order == 0 ?)
            #    A: Yes, we do - for redistributing articles when the number of articles
            #       delivered changes, and for statistics on popular articles. Records
            #       with both tolerance and quantity zero can be deleted.
            #goa.group_order_article_quantities.clear
          end
        end

        # Update GroupOrder prices
        group_orders.each(&:update_price!)

        # Stats
        ordergroups.each(&:update_stats!)

        # Notifications
        Resque.enqueue(UserNotifier, FoodsoftConfig.scope, 'finished_order', self.id)
      end
    end
  end

  # Sets order.status to 'close' and updates all Ordergroup.account_balances
  def close!(user)
    raise I18n.t('orders.model.error_closed') if closed?
    transaction_note = I18n.t('orders.model.notice_close', :name => name,
                              :ends => ends.strftime(I18n.t('date.formats.default')))

    gos = group_orders.includes(:ordergroup)              # Fetch group_orders
    gos.each { |group_order| group_order.update_price! }  # Update prices of group_orders

    transaction do                                        # Start updating account balances
      for group_order in gos
        price = group_order.price * -1                    # decrease! account balance
        group_order.ordergroup.add_financial_transaction!(price, transaction_note, user)
      end

      if stockit?                                         # Decreases the quantity of stock_articles
        for oa in order_articles.includes(:article)
          oa.update_results!                              # Update units_to_order of order_article
          stock_changes.create! :stock_article => oa.article, :quantity => oa.units_to_order*-1
        end
      end

      self.update_attributes! :state => 'closed', :updated_by => user, :foodcoop_result => profit
    end
  end

  # Close the order directly, without automaticly updating ordergroups account balances
  def close_direct!(user)
    raise I18n.t('orders.model.error_closed') if closed?
    comments.create(user: user, text: I18n.t('orders.model.close_direct_message'))
    update_attributes! state: 'closed', updated_by: user
  end

  protected

  def starts_before_ends
    errors.add(:ends, I18n.t('orders.model.error_starts_before_ends')) if (ends && starts && ends <= starts)
  end

  def include_articles
    errors.add(:articles, I18n.t('orders.model.error_nosel')) if article_ids.empty?
  end

  def keep_ordered_articles
    chosen_order_articles = order_articles.where(article_id: article_ids)
    to_be_removed = order_articles - chosen_order_articles
    to_be_removed_but_ordered = to_be_removed.select { |a| a.quantity > 0 or a.tolerance > 0 }
    unless to_be_removed_but_ordered.empty? or ignore_warnings
      errors.add(:articles, I18n.t(stockit? ? 'orders.model.warning_ordered_stock' : 'orders.model.warning_ordered'))
      @erroneous_article_ids = to_be_removed_but_ordered.map { |a| a.article_id }
    end
  end

  def save_order_articles
    # fetch selected articles
    articles_list = Article.find(article_ids)
    # create new order_articles
    (articles_list - articles).each { |article| order_articles.create(:article => article) }
    # delete old order_articles
    articles.reject { |article| articles_list.include?(article) }.each do |article|
      order_articles.detect { |order_article| order_article.article_id == article.id }.destroy
    end
  end

  private

  # Updates the "price" attribute of GroupOrders or GroupOrderResults
  # This will be either the maximum value of a current order or the actual order value of a finished order.
  def update_price_of_group_orders
    group_orders.each { |group_order| group_order.update_price! }
  end

end


1	# encoding: utf-8
2	#
3	class Order < ActiveRecord::Base	1✔
4
5	attr_accessor :ignore_warnings	1✔
6
7	# Associations
8	has_many :order_articles, :dependent => :destroy	1✔
9	has_many :articles, :through => :order_articles	1✔
10	has_many :group_orders, :dependent => :destroy	1✔
11	has_many :ordergroups, :through => :group_orders	1✔
12	has_one :invoice	1✔
13	has_many :comments, -> { order('created_at') }, :class_name => "OrderComment"	20✔
14	has_many :stock_changes	1✔
15	belongs_to :supplier	1✔
16	belongs_to :updated_by, :class_name => 'User', :foreign_key => 'updated_by_user_id'	1✔
17	belongs_to :created_by, :class_name => 'User', :foreign_key => 'created_by_user_id'	1✔
18
19	# Validations
20	validates_presence_of :starts	1✔
21	validate :starts_before_ends, :include_articles	1✔
22	validate :keep_ordered_articles	1✔
23
24	# Callbacks
25	after_save :save_order_articles, :update_price_of_group_orders	1✔
26
27	# Finders
28	scope :open, -> { where(state: 'open').order('ends DESC') }	17✔
29	scope :finished, -> { where("orders.state = 'finished' OR orders.state = 'closed'").order('ends DESC') }	170✔
30	scope :finished_not_closed, -> { where(state: 'finished').order('ends DESC') }	7✔
31	scope :closed, -> { where(state: 'closed').order('ends DESC') }	1✔
32	scope :stockit, -> { where(supplier_id: 0).order('ends DESC') }	1✔
33
34	scope :recent, -> { order('starts DESC').limit(10) }	1✔
35
36	def stockit?	1✔
37	supplier_id == 0	105✔
38	end
39
40	def name	1✔
41	stockit? ? I18n.t('orders.model.stock') : supplier.name	48✔
42	end
43
44	def articles_for_ordering	1✔
45	if stockit?	×
46	# make sure to include those articles which are no longer available
47	# but which have already been ordered in this stock order
48	StockArticle.available.includes(:article_category).
49	order('article_categories.name, articles.name').reject{ \|a\|
50	a.quantity_available <= 0 and not a.ordered_in_order?(self)	×
51	}.group_by { \|a\| a.article_category.name }	×
52	else
53	supplier.articles.available.group_by { \|a\| a.article_category.name }	×
54	end
55	end
56
57	def supplier_articles	1✔
58	if stockit?	1✔
59	StockArticle.undeleted.reorder('articles.name')	×
60	else
61	supplier.articles.undeleted.reorder('articles.name')	1✔
62	end
63	end
64
65	# Save ids, and create/delete order_articles after successfully saved the order
66	def article_ids=(ids)	1✔
67	@article_ids = ids	52✔
68	end
69
70	def article_ids	1✔
71	@article_ids \|\|= order_articles.map { \|a\| a.article_id.to_s }	249✔
72	end
73
74	# Returns an array of article ids that lead to a validation error.
75	def erroneous_article_ids	1✔
76	@erroneous_article_ids \|\|= []	×
77	end
78
79	def open?	1✔
80	state == "open"	247✔
81	end
82
83	def finished?	1✔
84	state == "finished"	803✔
85	end
86
87	def closed?	1✔
88	state == "closed"	39✔
89	end
90
91	def expired?	1✔
92	!ends.nil? && ends < Time.now	×
93	end
94
95	# search GroupOrder of given Ordergroup
96	def group_order(ordergroup)	1✔
97	group_orders.where(:ordergroup_id => ordergroup.id).first	6✔
98	end
99
100	# Returns OrderArticles in a nested Array, grouped by category and ordered by article name.
101	# The array has the following form:
102	# e.g: [["drugs",[teethpaste, toiletpaper]], ["fruits" => [apple, banana, lemon]]]
103	def articles_grouped_by_category	1✔
104	@articles_grouped_by_category \|\|= order_articles.
105	includes([:article_price, :group_order_articles, :article => :article_category]).
106	order('articles.name').
107	group_by { \|a\| a.article.article_category.name }.	13✔
108	sort { \|a, b\| a[0] <=> b[0] }	13✔
109	end
110
111	def articles_sort_by_category	1✔
112	order_articles.includes(:article).order('articles.name').sort do \|a,b\|	×
113	a.article.article_category.name <=> b.article.article_category.name	×
114	end
115	end
116
117	# Returns the defecit/benefit for the foodcoop
118	# Requires a valid invoice, belonging to this order
119	#FIXME: Consider order.foodcoop_result
120	def profit(options = {})	1✔
121	markup = options[:without_markup] \|\| false	25✔
122	if invoice	25✔
123	groups_sum = markup ? sum(:groups_without_markup) : sum(:groups)	×
124	groups_sum - invoice.net_amount	×
125	end
126	end
127
128	# Returns the all round price of a finished order
129	# :groups returns the sum of all GroupOrders
130	# :clear returns the price without tax, deposit and markup
131	# :gross includes tax and deposit. this amount should be equal to suppliers bill
132	# :fc, guess what...
133	def sum(type = :gross)	1✔
134	total = 0	59✔
135	if type == :net \|\| type == :gross \|\| type == :fc	59✔
136	for oa in order_articles.ordered.includes(:article, :article_price)	47✔
137	quantity = oa.units * oa.price.unit_quantity	43✔
138	case type	43✔
139	when :net
140	total += quantity * oa.price.price	15✔
141	when :gross
142	total += quantity * oa.price.gross_price	17✔
143	when :fc
144	total += quantity * oa.price.fc_price	11✔
145	end
146	end
147	elsif type == :groups \|\| type == :groups_without_markup
148	for go in group_orders.includes(group_order_articles: {order_article: [:article, :article_price]})	12✔
149	for goa in go.group_order_articles	24✔
150	case type	24✔
151	when :groups
152	total += goa.result * goa.order_article.price.fc_price	24✔
153	when :groups_without_markup
154	total += goa.result * goa.order_article.price.gross_price	×
155	end
156	end
157	end
158	end
159	total	59✔
160	end
161
162	# Finishes this order. This will set the order state to "finish" and the end property to the current time.
163	# Ignored if the order is already finished.
164	def finish!(user)	1✔
165	unless finished?	31✔
166	Order.transaction do	31✔
167	# set new order state (needed by notify_order_finished)
168	update_attributes!(:state => 'finished', :ends => Time.now, :updated_by => user)	31✔
169
170	# Update order_articles. Save the current article_price to keep price consistency
171	# Also save results for each group_order_result
172	# Clean up
173	order_articles.includes(:article).each do \|oa\|	31✔
174	oa.update_attribute(:article_price, oa.article.article_prices.first)	132✔
175	oa.group_order_articles.each do \|goa\|	132✔
176	goa.save_results!	62✔
177	# Delete no longer required order-history (group_order_article_quantities) and
178	# TODO: Do we need articles, which aren't ordered? (units_to_order == 0 ?)
179	# A: Yes, we do - for redistributing articles when the number of articles
180	# delivered changes, and for statistics on popular articles. Records
181	# with both tolerance and quantity zero can be deleted.
182	#goa.group_order_article_quantities.clear
183	end
184	end
185
186	# Update GroupOrder prices
187	group_orders.each(&:update_price!)	31✔
188
189	# Stats
190	ordergroups.each(&:update_stats!)	31✔
191
192	# Notifications
193	Resque.enqueue(UserNotifier, FoodsoftConfig.scope, 'finished_order', self.id)	31✔
194	end
195	end
196	end
197
198	# Sets order.status to 'close' and updates all Ordergroup.account_balances
199	def close!(user)	1✔
200	raise I18n.t('orders.model.error_closed') if closed?	1✔
201	transaction_note = I18n.t('orders.model.notice_close', :name => name,	1✔
202	:ends => ends.strftime(I18n.t('date.formats.default')))
203
204	gos = group_orders.includes(:ordergroup) # Fetch group_orders	1✔
205	gos.each { \|group_order\| group_order.update_price! } # Update prices of group_orders	1✔
206
207	transaction do # Start updating account balances	1✔
208	for group_order in gos	1✔
209	price = group_order.price * -1 # decrease! account balance	×
210	group_order.ordergroup.add_financial_transaction!(price, transaction_note, user)	×
211	end
212
213	if stockit? # Decreases the quantity of stock_articles	1✔
214	for oa in order_articles.includes(:article)	×
215	oa.update_results! # Update units_to_order of order_article	×
216	stock_changes.create! :stock_article => oa.article, :quantity => oa.units_to_order*-1	×
217	end
218	end
219
220	self.update_attributes! :state => 'closed', :updated_by => user, :foodcoop_result => profit	1✔
221	end
222	end
223
224	# Close the order directly, without automaticly updating ordergroups account balances
225	def close_direct!(user)	1✔
226	raise I18n.t('orders.model.error_closed') if closed?	×
227	comments.create(user: user, text: I18n.t('orders.model.close_direct_message'))	×
228	update_attributes! state: 'closed', updated_by: user	×
229	end
230
231	protected	1✔
232
233	def starts_before_ends	1✔
234	errors.add(:ends, I18n.t('orders.model.error_starts_before_ends')) if (ends && starts && ends <= starts)	84✔
235	end
236
237	def include_articles	1✔
238	errors.add(:articles, I18n.t('orders.model.error_nosel')) if article_ids.empty?	84✔
239	end
240
241	def keep_ordered_articles	1✔
242	chosen_order_articles = order_articles.where(article_id: article_ids)	84✔
243	to_be_removed = order_articles - chosen_order_articles	84✔
244	to_be_removed_but_ordered = to_be_removed.select { \|a\| a.quantity > 0 or a.tolerance > 0 }	84✔
245	unless to_be_removed_but_ordered.empty? or ignore_warnings	84✔
246	errors.add(:articles, I18n.t(stockit? ? 'orders.model.warning_ordered_stock' : 'orders.model.warning_ordered'))	×
247	@erroneous_article_ids = to_be_removed_but_ordered.map { \|a\| a.article_id }	×
248	end
249	end
250
251	def save_order_articles	1✔
252	# fetch selected articles
253	articles_list = Article.find(article_ids)	81✔
254	# create new order_articles
255	(articles_list - articles).each { \|article\| order_articles.create(:article => article) }	810✔
256	# delete old order_articles
257	articles.reject { \|article\| articles_list.include?(article) }.each do \|article\|	270✔
258	order_articles.detect { \|order_article\| order_article.article_id == article.id }.destroy	×
259	end
260	end
261
262	private	1✔
263
264	# Updates the "price" attribute of GroupOrders or GroupOrderResults
265	# This will be either the maximum value of a current order or the actual order value of a finished order.
266	def update_price_of_group_orders	1✔
267	group_orders.each { \|group_order\| group_order.update_price! }	147✔
268	end
269
270	end
271

foodcoops / foodsoft / 473

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous