class Order < ApplicationRecord attr_accessor :ignore_warnings, :transport_distribution # 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_many :users_ordered, :through => :ordergroups, :source => :users has_many :comments, -> { order('created_at') }, :class_name => "OrderComment" has_many :stock_changes belongs_to :invoice, optional: true belongs_to :supplier, optional: true 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' enum end_action: { no_end_action: 0, auto_close: 1, auto_close_and_send: 2, auto_close_and_send_min_quantity: 3 } enum transport_distribution: [:skip, :ordergroup, :price, :articles] # 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! before_validation :distribute_transport # Finders scope :started, -> { where('starts <= ?', Time.now) } scope :closed, -> { where(state: 'closed').order(ends: :desc) } scope :stockit, -> { where(supplier_id: nil).order(ends: :desc) } scope :recent, -> { order(starts: :desc).limit(10) } scope :stock_group_order, -> { group_orders.where(ordergroup_id: nil).first } scope :with_invoice, -> { where.not(invoice: nil) } # State related finders # Diagram for `Order.state` looks like this: # * -> open -> finished (-> received) -> closed # So orders can # 1. ...only transition in one direction (e.g. an order that has been `finished` currently cannot be reopened) # 2. ...be set to `closed` when having the `finished` state. (`received` is optional) scope :open, -> { where(state: 'open').order(ends: :desc) } scope :finished, -> { where(state: %w[finished received closed]).order(ends: :desc) } scope :finished_not_closed, -> { where(state: %w[finished received]).order(ends: :desc) } # Allow separate inputs for date and time # with workaround for https://github.com/einzige/date_time_attribute/issues/14 include DateTimeAttributeValidate date_time_attribute :starts, :boxfill, :ends def self.ransackable_attributes(auth_object = nil) %w(id state supplier_id starts boxfill ends pickup) end def self.ransackable_associations(auth_object = nil) %w(supplier articles order_articles) end def stockit? supplier_id.nil? 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 && !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" || state == "received" end def received? state == "received" end def closed? state == "closed" end def boxfill? !!FoodsoftConfig[:use_boxfill] && open? && boxfill.present? && boxfill < Time.now end def is_boxfill_useful? !!FoodsoftConfig[:use_boxfill] && !!supplier.try(:has_tolerance?) end def expired? ends.present? && ends < Time.now end # sets up first guess of dates when initializing a new object # I guess `def initialize` would work, but it's tricky http://stackoverflow.com/questions/1186400 def init_dates self.starts ||= Time.now if FoodsoftConfig[:order_schedule] # try to be smart when picking a reference day last = (DateTime.parse(FoodsoftConfig[:order_schedule][:initial]) rescue nil) last ||= Order.finished.reorder(:starts).first.try(:starts) last ||= self.starts # adjust boxfill and end date self.boxfill ||= FoodsoftDateUtil.next_occurrence last, self.starts, FoodsoftConfig[:order_schedule][:boxfill] if is_boxfill_useful? self.ends ||= FoodsoftDateUtil.next_occurrence last, self.starts, FoodsoftConfig[:order_schedule][:ends] end self end # fetch current Order scope's records and map the current user's GroupOrders in (if any) # (performance enhancement as opposed to fetching each GroupOrder separately from the view) def self.ordergroup_group_orders_map(ordergroup) orders = includes(:supplier) group_orders = GroupOrder.where(ordergroup_id: ordergroup.id, order_id: orders.map(&:id)) group_orders_hash = Hash[group_orders.collect { |go| [go.order_id, go] }] orders.map do |order| { order: order, group_order: group_orders_hash[order.id] } end end # search GroupOrder of given Ordergroup def group_order(ordergroup) group_orders.where(:ordergroup_id => ordergroup.id).first end def stock_group_order group_orders.where(:ordergroup_id => nil).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, transaction_type = nil) raise I18n.t('orders.model.error_closed') if closed? update_price_of_group_orders! transaction do # Start updating account balances charge_group_orders!(user, transaction_type) 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')) unless FoodsoftConfig[:charge_members_manually] update_attributes! state: 'closed', updated_by: user end def send_to_supplier!(user) Mailer.deliver_now_with_default_locale do Mailer.order_result_supplier(user, self) end update!(last_sent_mail: Time.now) end def do_end_action! if auto_close? finish!(created_by) elsif auto_close_and_send? finish!(created_by) send_to_supplier!(created_by) elsif auto_close_and_send_min_quantity? finish!(created_by) send_to_supplier!(created_by) if sum >= supplier.min_order_quantity.to_r end end def self.finish_ended! orders = Order.where.not(end_action: Order.end_actions[:no_end_action]).where(state: 'open').where('ends <= ?', DateTime.now) orders.each do |order| begin order.do_end_action! rescue => error ExceptionNotifier.notify_exception(error, data: { foodcoop: FoodsoftConfig.scope, order_id: order.id }) end end end protected def starts_before_ends delta = Rails.env.test? ? 1 : 0 # since Rails 4.2 tests appear to have time differences, with this validation failing errors.add(:ends, I18n.t('orders.model.error_starts_before_ends')) if ends && starts && ends <= (starts - delta) errors.add(:ends, I18n.t('orders.model.error_boxfill_before_ends')) if ends && boxfill && ends <= (boxfill - delta) errors.add(:boxfill, I18n.t('orders.model.error_starts_before_boxfill')) if boxfill && starts && boxfill <= (starts - delta) 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 || a.tolerance > 0 } unless to_be_removed_but_ordered.empty? || 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 def distribute_transport return unless group_orders.any? case transport_distribution.try(&:to_i) when Order.transport_distributions[:ordergroup] then amount = transport / group_orders.size group_orders.each do |go| go.transport = amount.ceil(2) end when Order.transport_distributions[:price] then amount = transport / group_orders.sum(:price) group_orders.each do |go| go.transport = (amount * go.price).ceil(2) end when Order.transport_distributions[:articles] then amount = transport / group_orders.includes(:group_order_articles).sum(:result) group_orders.each do |go| go.transport = (amount * go.group_order_articles.sum(:result)).ceil(2) end end end # 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(&:update_price!) end def charge_group_orders!(user, transaction_type = nil) note = transaction_note group_orders.includes(:ordergroup).each do |group_order| if group_order.ordergroup price = group_order.price * -1 # decrease! account balance group_order.ordergroup.add_financial_transaction!(price, note, user, transaction_type, nil, group_order) end end end def transaction_note I18n.t('orders.model.notice_close', name: name, ends: ends.strftime(I18n.t('date.formats.default'))) end end