145 lines
4.1 KiB
Ruby
145 lines
4.1 KiB
Ruby
class OrderPdf < RenderPDF
|
|
|
|
attr_reader :order
|
|
|
|
def initialize(order, options = {})
|
|
@order = order
|
|
@orders = order
|
|
super(options)
|
|
end
|
|
|
|
def nice_table(name, data, dimrows = [])
|
|
down_or_page 25
|
|
text name, size: 10, style: :bold
|
|
table data, width: bounds.width, cell_style: {size: 8, overflow: :shrink_to_fit} do |table|
|
|
# borders
|
|
table.cells.borders = [:bottom]
|
|
table.cells.padding_top = 2
|
|
table.cells.padding_bottom = 4
|
|
table.cells.border_color = 'dddddd'
|
|
table.rows(0).border_color = '666666'
|
|
|
|
# dim rows which were ordered but not received
|
|
dimrows.each do |ri|
|
|
table.row(ri).text_color = '999999'
|
|
table.row(ri).columns(0..-1).font_style = nil
|
|
end
|
|
|
|
yield table if block_given?
|
|
end
|
|
end
|
|
|
|
protected
|
|
|
|
# Return price for order_article.
|
|
#
|
|
# This is a separate method so that plugins can override it.
|
|
#
|
|
# @param article [OrderArticle]
|
|
# @return [Number] Price to show
|
|
# @see https://github.com/foodcoops/foodsoft/issues/445
|
|
def order_article_price(order_article)
|
|
order_article.price.fc_price
|
|
end
|
|
|
|
def order_article_price_per_unit(order_article)
|
|
"#{number_to_currency(order_article_price(order_article))} / #{order_article.article.unit}"
|
|
end
|
|
|
|
def group_order_article_quantity_with_tolerance(goa)
|
|
goa.tolerance > 0 ? "#{goa.quantity} + #{goa.tolerance}" : "#{goa.quantity}"
|
|
end
|
|
|
|
def group_order_article_result(goa)
|
|
number_with_precision goa.result, strip_insignificant_zeros: true
|
|
end
|
|
|
|
def group_order_articles(ordergroup)
|
|
GroupOrderArticle.
|
|
includes(:group_order).
|
|
where(group_orders: {order_id: @orders, ordergroup_id: ordergroup})
|
|
end
|
|
|
|
def order_articles
|
|
OrderArticle.
|
|
ordered.
|
|
includes(article: :supplier).
|
|
includes(group_order_articles: {group_order: :ordergroup}).
|
|
where(order: @orders).
|
|
order('suppliers.name, articles.name, groups.name').
|
|
preload(:article_price)
|
|
end
|
|
|
|
def ordergroups(offset = nil, limit = nil)
|
|
result = GroupOrder.
|
|
ordered.
|
|
where(order: @orders).
|
|
group('groups.id').
|
|
offset(offset).
|
|
limit(limit).
|
|
pluck('groups.name', 'SUM(group_orders.price)', 'ordergroup_id')
|
|
|
|
result.map do |item|
|
|
[item.first || stock_ordergroup_name] + item[1..-1]
|
|
end
|
|
end
|
|
|
|
def each_order_article(&block)
|
|
order_articles.each(&block)
|
|
end
|
|
|
|
def each_ordergroup(&block)
|
|
ordergroups.each(&block)
|
|
end
|
|
|
|
def each_ordergroup_batch(batch_size)
|
|
offset = 0
|
|
|
|
while true
|
|
go_records = ordergroups(offset, batch_size)
|
|
|
|
break unless go_records.any?
|
|
|
|
group_ids = go_records.map(&:third)
|
|
|
|
# get quantity for each article and ordergroup
|
|
goa_records = group_order_articles(group_ids)
|
|
.group('group_order_articles.order_article_id, group_orders.ordergroup_id')
|
|
.pluck('group_order_articles.order_article_id', 'group_orders.ordergroup_id', 'SUM(COALESCE(group_order_articles.result, group_order_articles.quantity))')
|
|
|
|
# transform the flat list of results in a hash (with the article as key), which contains an array for all ordergroups
|
|
results = goa_records.group_by(&:first).transform_values do |value|
|
|
grouped_value = value.group_by(&:second)
|
|
group_ids.map do |group_id|
|
|
number_with_precision grouped_value[group_id].try(:first).try(:third), strip_insignificant_zeros: true
|
|
end
|
|
end
|
|
|
|
yield go_records, results
|
|
offset += batch_size
|
|
end
|
|
end
|
|
|
|
def each_group_order_article_for_order_article(order_article, &block)
|
|
order_article.group_order_articles.each(&block)
|
|
end
|
|
|
|
def each_group_order_article_for_ordergroup(ordergroup, &block)
|
|
group_order_articles(ordergroup)
|
|
.includes(order_article: {article: [:supplier]})
|
|
.order('suppliers.name, articles.name')
|
|
.preload(order_article: [:article_price, :order])
|
|
.each(&block)
|
|
end
|
|
|
|
def stock_ordergroup_name
|
|
users = GroupOrder.stock.
|
|
eager_load(:updated_by).
|
|
where(order: @orders).
|
|
map(&:updated_by).
|
|
map{ |u| u.try(&:name) || '?' }
|
|
|
|
I18n.t('model.group_order.stock_ordergroup_name', user: users.uniq.sort.join(', '))
|
|
end
|
|
|
|
end
|