389 lines
13 KiB
Ruby
389 lines
13 KiB
Ruby
class Sale < ApplicationRecord
|
|
self.primary_key = "sale_id"
|
|
|
|
#primary key - need to be unique generated for multiple shops
|
|
before_create :generate_custom_id
|
|
#before_create :generate_receipt_no
|
|
belongs_to :cashier, :optional => true
|
|
belongs_to :customer, :optional => true
|
|
has_many :sale_items
|
|
has_many :sale_discount_items
|
|
has_many :sale_discounts
|
|
has_many :sale_taxes
|
|
has_many :sale_payments
|
|
has_many :sale_orders
|
|
has_many :bookings
|
|
|
|
scope :open_invoices, -> { where("sale_status = 'new' and receipt_date BETWEEN '#{DateTime.now.utc.end_of_day}' AND '#{DateTime.now.utc.beginning_of_day}'") }
|
|
|
|
REPORT_TYPE = {
|
|
"daily" => 0,
|
|
"monthly" => 1,
|
|
"yearly" => 2
|
|
}
|
|
|
|
SALE_STATUS_COMPLETED = "completed"
|
|
|
|
def generate_invoice_from_booking(booking_id, requested_by)
|
|
booking = Booking.find(booking_id)
|
|
status = false
|
|
Rails.logger.debug "Booking -> " + booking.id.to_s
|
|
if (booking)
|
|
Rails.logger.debug "Booking -> Booking Order Count -> " + booking.booking_orders.count.to_s
|
|
#get all order attached to this booking and combine into 1 invoice
|
|
|
|
booking.booking_orders.each do |order|
|
|
if booking.sale_id
|
|
status, sale_id = generate_invoice_from_order(order.order_id, nil, booking, requested_by)
|
|
else
|
|
status, sale_id = generate_invoice_from_order(order.order_id, booking.sale_id, booking, requested_by)
|
|
end
|
|
booking.sale_id = sale_id
|
|
end
|
|
order = booking.booking_orders.take.order
|
|
link_order_sale(order.id)
|
|
return status, sale_id
|
|
end
|
|
end
|
|
|
|
def generate_invoice_from_order (order_id, sale_id, booking, requested_by)
|
|
taxable = true
|
|
#if sale_id is exsit and validate
|
|
#add order to that invoice
|
|
if (sale_id)
|
|
self.find(sale_id)
|
|
end
|
|
Rails.logger.debug "Does it have Existing Sale -> [#{self.id.to_s}] - Status [#{self.sale_status}]"
|
|
|
|
if self.sale_status == "void"
|
|
return false, "Invoice is void. Cannot be edited"
|
|
else
|
|
#if this is new sale generate_receipt_no
|
|
generate_receipt_no
|
|
order = Order.find(order_id)
|
|
|
|
#Default Tax - Values
|
|
self.tax_type = "exclusive"
|
|
|
|
# set cashier by current login
|
|
self.cashier_id = requested_by.id
|
|
self.cashier_name = requested_by.name
|
|
self.requested_by = requested_by.name
|
|
|
|
self.requested_at = DateTime.now.utc
|
|
|
|
Rails.logger.debug "Order -> #{order.id} | order_status -> #{order.status}"
|
|
if order
|
|
self.customer_id = order.customer_id
|
|
Rails.logger.debug "Order -> #{order.id} | Items Count -> #{order.order_items.count}"
|
|
|
|
order.order_items.each do |item|
|
|
add_item(item)
|
|
end
|
|
|
|
link_order_sale(order.id)
|
|
|
|
end
|
|
|
|
|
|
self.save!
|
|
|
|
#compute sales summary
|
|
compute
|
|
|
|
#Update the order items that is billed
|
|
order.update_items_status_to_billed(nil)
|
|
order.status = "billed"
|
|
order.save
|
|
|
|
booking.sale_id = self.id
|
|
booking.checkout_at = Time.now.utc
|
|
booking.checkout_by = requested_by.name
|
|
booking.save
|
|
|
|
return true, self.id
|
|
end
|
|
|
|
return false, nil
|
|
|
|
end
|
|
|
|
#This is when spilt bill is request - then we cannot link order to invoice
|
|
#Cos there will be multiple orders - and items are spilt from there.
|
|
#Unless order is spilt by then it is possible.
|
|
def generate_invoice_by_items (items, requested_by)
|
|
taxable = true
|
|
self.requested_by = requested_by
|
|
self.requested_at = DateTime.now.utc
|
|
|
|
items.each do |item|
|
|
add_item(item)
|
|
|
|
#this will result in multiple orders belonging in multiple invoices - because of spilt invoices.
|
|
link_order_sale(item.order_id, taxable)
|
|
end
|
|
|
|
#Update item status as billed
|
|
order.update_items_status_to_billed(items)
|
|
|
|
status = self.save!
|
|
return status, self.id
|
|
|
|
end
|
|
|
|
def add_item (item)
|
|
#check if the item is on promotion
|
|
|
|
#save sale_audit
|
|
sale_item = SaleItem.new
|
|
|
|
#pull
|
|
sale_item.product_code = item.item_code
|
|
sale_item.product_name = item.item_name
|
|
sale_item.remark = item.remark
|
|
|
|
sale_item.qty = item.qty
|
|
sale_item.unit_price = item.price
|
|
sale_item.taxable_price = item.price
|
|
sale_item.is_taxable = item.taxable
|
|
|
|
sale_item.price = sale_item.qty * sale_item.unit_price
|
|
|
|
self.sale_items << sale_item
|
|
end
|
|
|
|
|
|
def update_item (item)
|
|
#save sale_audit
|
|
|
|
end
|
|
|
|
def apply_item_discount (item_code, discount_type, discount_amount)
|
|
|
|
end
|
|
|
|
def apply_discount (discount_type, discount_code)
|
|
#save action to sale_audit
|
|
end
|
|
|
|
def void_sales (void_by, reason, approval_code, request_by)
|
|
#save sale_audit
|
|
self.sale_status = "void"
|
|
end
|
|
|
|
#compute - invoice total
|
|
def compute
|
|
sales_items = self.sale_items
|
|
|
|
#Computation Fields
|
|
subtotal_price = 0
|
|
total_taxable = 0
|
|
rounding_adjustment = 0
|
|
|
|
sales_items.each do |item|
|
|
#compute each item and added to total
|
|
subtotal_price = subtotal_price + item.price
|
|
total_taxable = total_taxable + item.taxable_price
|
|
end
|
|
|
|
apply_tax (total_taxable)
|
|
self.total_amount = subtotal_price
|
|
self.total_discount = total_discount
|
|
self.grand_total = (self.total_amount - self.total_discount) + self.total_tax
|
|
#compute rounding adjustment
|
|
adjust_rounding
|
|
|
|
self.save!
|
|
|
|
end
|
|
|
|
# Tax Calculate
|
|
def apply_tax(total_taxable)
|
|
#if tax is not apply create new record
|
|
# self.sale_taxes.each do |existing_tax|
|
|
# #delete existing and create new
|
|
# existing_tax.delete
|
|
# end
|
|
|
|
#if tax is not apply create new record
|
|
SaleTax.where("sale_id='#{self.sale_id}'").find_each do |existing_tax|
|
|
#delete existing and create new
|
|
existing_tax.delete
|
|
end
|
|
|
|
total_tax_amount = 0
|
|
#tax_profile - list by order_by
|
|
tax_profiles = TaxProfile.all.order("order_by asc")
|
|
|
|
# #Creat new tax records
|
|
tax_profiles.each do |tax|
|
|
sale_tax = SaleTax.new(:sale => self)
|
|
sale_tax.tax_name = tax.name
|
|
sale_tax.tax_rate = tax.rate
|
|
#include or execulive
|
|
# sale_tax.tax_payable_amount = total_taxable * tax.rate
|
|
sale_tax.tax_payable_amount = total_taxable * tax.rate / 100
|
|
#new taxable amount
|
|
total_taxable = total_taxable + sale_tax.tax_payable_amount
|
|
|
|
sale_tax.inclusive = tax.inclusive
|
|
sale_tax.save
|
|
|
|
total_tax_amount = total_tax_amount + sale_tax.tax_payable_amount
|
|
end
|
|
|
|
self.total_tax = total_tax_amount
|
|
|
|
end
|
|
|
|
|
|
private
|
|
|
|
def product_get_unit_price(item_code)
|
|
menu_item_hash =MenuItem.search_by_item_code(item_code)
|
|
if (menu_instance_code)
|
|
return menu_ item_hash[:item_instance_code], menu_item_hash[:price]
|
|
end
|
|
return nil,nil
|
|
end
|
|
|
|
def link_order_sale(order_id)
|
|
#create if it doesn't exist
|
|
saleOrder = SaleOrder.where("sale_id=? and order_id=?", self.id, order_id).take
|
|
|
|
if saleOrder.nil?
|
|
sale_order = SaleOrder.new
|
|
sale_order.create_sale_order(self.id, order_id)
|
|
end
|
|
# if (SaleOrder.where("sale_id = #{self.id} and order_id=#{order_id}").nil?)
|
|
# SaleOrder.create(:sale_id => self.id, :order_id => order_id)
|
|
# end
|
|
#dosomrting here
|
|
#puts Time.now.format(":short")
|
|
end
|
|
|
|
def adjust_rounding
|
|
self.grand_total
|
|
self.rounding_adjustment = 0.00
|
|
end
|
|
|
|
#Generate new Receipt No when it is not assigned
|
|
def generate_receipt_no
|
|
#Date-Shift-
|
|
if self.receipt_no.nil?
|
|
prefix = DateTime.now().utc
|
|
#self.receipt_no = prefix.to_s + "/" + self.shit_id.to_s + "/" + SeedGenerator.new_receipt_no().to_s
|
|
self.receipt_no = prefix.strftime("%Y%m%d") + "-" + SeedGenerator.new_receipt_no().to_s
|
|
|
|
self.receipt_date = prefix
|
|
Rails.logger.debug "Receipt No #{self.receipt_no} | Date #{ self.receipt_date.to_s}"
|
|
end
|
|
end
|
|
|
|
def self.search(search)
|
|
if search
|
|
# find(:all, :conditions => ['name LIKE ? OR contact_no LIKE ?', "%#{search}%", "%#{search}%"])
|
|
where("receipt_no LIKE ?", "%#{search}%",)
|
|
else
|
|
find(:all)
|
|
end
|
|
end
|
|
|
|
def self.daily_sales_list(from,to)
|
|
payments_total = Sale.select("CAST((CONVERT_TZ(sales.receipt_date,'+00:00','+06:30')) AS DATE) as sale_date,
|
|
SUM(case when (sale_payments.payment_method='mpu') then sale_payments.payment_amount else 0 end) as mpu_amount,
|
|
SUM(case when (sale_payments.payment_method='master') then sale_payments.payment_amount else 0 end) as master_amount,
|
|
SUM(case when (sale_payments.payment_method='visa') then sale_payments.payment_amount else 0 end) as visa_amount,
|
|
SUM(case when (sale_payments.payment_method='jcb') then sale_payments.payment_amount else 0 end) as jcb_amount,
|
|
SUM(case when (sale_payments.payment_method='paypar') then sale_payments.payment_amount else 0 end) as paypar_amount,
|
|
SUM(case when (sale_payments.payment_method='cash') then sale_payments.payment_amount else 0 end) as cash_amount,
|
|
SUM(case when (sale_payments.payment_method='credit') then sale_payments.payment_amount else 0 end) as credit_amount,
|
|
SUM(case when (sale_payments.payment_method='foc') then sale_payments.payment_amount else 0 end) as foc_amount")
|
|
.joins("join (select * from sale_payments group by sale_payments.sale_id, sale_payments.payment_method) sale_payments on sale_payments.sale_id = sales.sale_id")
|
|
.where("sale_status = ? AND sales.receipt_date between ? and ? AND total_amount != 0", 'completed', from, to)
|
|
.group("DATE_FORMAT((CONVERT_TZ(sales.receipt_date,'+00:00','+06:30')),'%Y-%m-%d')")
|
|
|
|
daily_total = Array.new
|
|
|
|
payments_total.each do |pay|
|
|
sale_date = pay.sale_date
|
|
diff_time = payments_total.first.sale_date.beginning_of_day.utc - from
|
|
diff = diff_time % 86400
|
|
from_date = sale_date.beginning_of_day.utc - diff
|
|
to_date = sale_date.end_of_day.utc - diff
|
|
|
|
total_sale = Sale.select("IFNULL(SUM(case when (sale_status='completed') then grand_total else 0 end),0) as grand_total,
|
|
IFNULL(SUM(case when (sale_status='completed') then total_discount else 0 end),0) as total_discount,
|
|
IFNULL(SUM(case when (sale_status='void') then grand_total else 0 end),0) as void_amount,
|
|
IFNULL(SUM(case when (sale_status='completed') then rounding_adjustment else 0 end),0) as rounding_adj")
|
|
.where("(sale_status = ? OR sale_status = ?) AND receipt_date between ? and ? AND total_amount != 0", 'completed', 'void', from_date, to_date)
|
|
|
|
total_sale.each do |sale|
|
|
grand_total = sale.grand_total
|
|
total_discount = sale.total_discount
|
|
void_amount = sale.void_amount
|
|
total = {:sale_date => pay.sale_date,
|
|
:mpu_amount => pay.mpu_amount,
|
|
:master_amount => pay.master_amount,
|
|
:visa_amount => pay.visa_amount,
|
|
:jcb_amount => pay.jcb_amount,
|
|
:paypar_amount => pay.paypar_amount,
|
|
:cash_amount => pay.cash_amount,
|
|
:credit_amount => pay.credit_amount,
|
|
:foc_amount => pay.foc_amount,
|
|
:total_discount => total_discount,
|
|
:grand_total => grand_total,
|
|
:void_amount => void_amount,
|
|
:rounding_adj => sale.rounding_adj}
|
|
daily_total.push(total)
|
|
end
|
|
|
|
end
|
|
return daily_total
|
|
end
|
|
|
|
def self.get_by_range_by_saleitems(from,to,status,report_type)
|
|
|
|
query = Sale.select("
|
|
mi.item_code as code,(SUM(i.qty) * i.unit_price) as grand_total,
|
|
SUM(i.qty) as total_item," +
|
|
" i.unit_price as unit_price,
|
|
mi.name as product_name,
|
|
mc.name as menu_category_name,
|
|
mc.id as menu_category_id ")
|
|
.group('mi.id')
|
|
.order("mi.menu_category_id")
|
|
|
|
query = query.joins("JOIN sale_items i ON i.sale_id = sales.sale_id
|
|
JOIN menu_items mi ON i.product_code = mi.item_code" +
|
|
" JOIN menu_categories mc ON mc.id = mi.menu_category_id
|
|
JOIN employees ea ON ea.id = sales.cashier_id")
|
|
|
|
|
|
query = query.where("receipt_date between ? and ? and sale_status=?",from,to,status)
|
|
|
|
|
|
|
|
case report_type.to_i
|
|
when REPORT_TYPE["daily"]
|
|
return query
|
|
when REPORT_TYPE["monthly"]
|
|
|
|
return query.group("MONTH(date)")
|
|
when REPORT_TYPE["yearly"]
|
|
return query.group("YEAR(date)")
|
|
end
|
|
|
|
end
|
|
|
|
private
|
|
|
|
def generate_custom_id
|
|
self.sale_id = SeedGenerator.generate_id(self.class.name, "SAL")
|
|
end
|
|
|
|
def self.get_receipt_no_list(from,to)
|
|
sale = Sale.where("sale_status=? and receipt_date between ? and ?","completed",from,to)
|
|
end
|
|
end
|