2052 lines
76 KiB
Python
2052 lines
76 KiB
Python
# This file is part of Tryton. The COPYRIGHT file at the top level of
|
|
# this repository contains the full copyright notices and license terms.
|
|
import math
|
|
import calendar
|
|
from decimal import Decimal
|
|
from datetime import datetime, date, timedelta
|
|
from itertools import chain
|
|
from sql import Null, Table, With
|
|
from sql.operators import NotIn
|
|
from sql.aggregate import Sum, Count
|
|
from sql.conditionals import Case, Coalesce
|
|
|
|
from trytond.model import ModelView, fields
|
|
from trytond.pool import PoolMeta, Pool
|
|
from trytond.transaction import Transaction
|
|
from trytond.pyson import Bool, Eval, Not
|
|
from trytond.wizard import (
|
|
Wizard, StateView, StateAction, StateReport, StateTransition, Button
|
|
)
|
|
from trytond.report import Report
|
|
from trytond.i18n import gettext
|
|
from .exceptions import (
|
|
ProductMissingTaxError, ImportSalesError, SaleDeleteError,
|
|
SaleForceDraftError, SaleDeviceError, DraftStatementError,
|
|
PartyMissingAccount
|
|
)
|
|
from trytond.model.exceptions import AccessError
|
|
from trytond.modules.sale.exceptions import SaleValidationError
|
|
|
|
_ZERO = Decimal('0.00')
|
|
TODAY = date.today()
|
|
STATES = {
|
|
'readonly': Eval('state').in_(['processing', 'done', 'cancel']),
|
|
}
|
|
|
|
|
|
class Sale(metaclass=PoolMeta):
|
|
__name__ = 'sale.sale'
|
|
self_pick_up = fields.Boolean('Self Pick Up', states=STATES, depends=['state'],
|
|
help='The goods are picked up by the customer before the sale, so no '
|
|
'shipment is created.')
|
|
pos_create_date = fields.DateTime('Create Date', readonly=True)
|
|
invoice_number = fields.Char('Invoice Number', states={'readonly': True})
|
|
invoice_date = fields.Date('Invoice Date')
|
|
invoice = fields.Many2One('account.invoice', 'Invoice')
|
|
sale_device = fields.Many2One('sale.device', 'Sale Device',
|
|
domain=[('shop', '=', Eval('shop'))], depends=['shop'], states=STATES)
|
|
position = fields.Char('Position', states=STATES)
|
|
pre_sale = fields.Boolean('Pre-Sale', help="This option for pre-sale, change method of invoice to shipment")
|
|
shipment_date = fields.Date('Shipment Date', states=STATES)
|
|
turn = fields.Integer('Turn', states=STATES)
|
|
reservation = fields.Boolean('Reservation')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(Sale, cls).__setup__()
|
|
cls.party.states['readonly'] = Bool(Eval('invoice_number'))
|
|
cls.state_string = super(Sale, cls).state.translated('state')
|
|
for fname in cls.self_pick_up.on_change:
|
|
if fname not in cls.shop.on_change:
|
|
cls.shop.on_change.add(fname)
|
|
if fname not in cls.party.on_change:
|
|
cls.party.on_change.add(fname)
|
|
|
|
cls._buttons.update({
|
|
'wizard_generate_invoice': {
|
|
'invisible': Eval('state').in_(['done', 'processing', 'cancel', 'transferred']),
|
|
'readonly': Not(Bool(Eval('lines'))),
|
|
},
|
|
'wizard_generate_shipment': {
|
|
'invisible': Eval('shipment_state').in_(['sent', 'exception']),
|
|
'readonly': Not(Bool(Eval('lines'))),
|
|
},
|
|
})
|
|
|
|
@classmethod
|
|
def search_rec_name(cls, name, clause):
|
|
_, operator, value = clause
|
|
if operator.startswith('!') or operator.startswith('not '):
|
|
bool_op = 'AND'
|
|
else:
|
|
bool_op = 'OR'
|
|
domain = [
|
|
bool_op,
|
|
('number', operator, value),
|
|
('reference', operator, value),
|
|
('description', operator, value),
|
|
('invoice.number', operator, value),
|
|
]
|
|
return domain
|
|
|
|
@classmethod
|
|
def process(cls, sales):
|
|
configuration = Pool().get('sale.configuration')(1)
|
|
for sale in sales:
|
|
if sale.invoices:
|
|
invoice = sale.invoices[0]
|
|
if invoice.state in ('posted', 'paid'):
|
|
continue
|
|
if hasattr(configuration, 'password_force_assign') and configuration.password_force_assign and sale.shipment_state == 'none':
|
|
cls.validate_stock(sale)
|
|
cls.process_pos(sale)
|
|
super(Sale, cls).process(sales)
|
|
|
|
@classmethod
|
|
def validate_stock(cls, sale):
|
|
Product = Pool().get('product.product')
|
|
product_ids = {l.product.id: l.quantity for l in sale.lines}
|
|
today = date.today()
|
|
with Transaction().set_context({'stock_date_end': today, 'locations': [sale.warehouse.id]}):
|
|
products = Product.search([
|
|
('id', 'in', product_ids.keys()),
|
|
])
|
|
for product in products:
|
|
if product.quantity <= product_ids[product.id]:
|
|
raise SaleValidationError(gettext('sale_pos.msg_product_quantity', s=product.rec_name))
|
|
|
|
def get_tax_amount(self):
|
|
# Esto es necesario para impuestos de Licores y Cigarrillos
|
|
values = self._get_taxes().values()
|
|
res = sum((v['amount'] for v in values), Decimal(0))
|
|
Tax = Pool().get('account.tax')
|
|
taxes_update = Tax.search([
|
|
('type', '=', 'fixed'),
|
|
('group.kind', '=', 'sale'),
|
|
('amount', '=', 0),
|
|
])
|
|
taxes_update_ids = [t.id for t in taxes_update]
|
|
taxes_update_id = None
|
|
if taxes_update_ids:
|
|
taxes_update_id = taxes_update_ids[0]
|
|
amounts = []
|
|
if taxes_update_id:
|
|
for l in self.lines:
|
|
classification_tax = any(t.classification_tax == '02' for t in l.taxes)
|
|
if not l.product or (not hasattr(l.product, 'extra_tax') or not l.product.extra_tax or not classification_tax):
|
|
continue
|
|
raw_val = Decimal(float(l.product.extra_tax) * l.quantity)
|
|
val = self.currency.round(raw_val)
|
|
amounts.append(val)
|
|
return res + sum(amounts)
|
|
|
|
def create_invoice(self):
|
|
'Create and return an invoice'
|
|
pool = Pool()
|
|
Invoice = pool.get('account.invoice')
|
|
if self.invoice_method == 'manual':
|
|
return
|
|
|
|
invoice_lines = []
|
|
sales = [self]
|
|
for sale in sales:
|
|
for line in sale.lines:
|
|
if self.total_amount < 0 and line.quantity > 0:
|
|
continue
|
|
if self.total_amount > 0 and line.quantity < 0:
|
|
continue
|
|
invoice_lines.append(line.get_invoice_line())
|
|
invoice_lines = list(chain(*invoice_lines))
|
|
if not invoice_lines:
|
|
return
|
|
|
|
sale = sales[0]
|
|
invoice = self._get_invoice_sale()
|
|
if self.invoice_type:
|
|
invoice.authorization = self._get_authorization(sale)
|
|
invoice.invoice_type = self.invoice_type
|
|
if getattr(invoice, 'lines', None):
|
|
invoice_lines = list(invoice.lines) + invoice_lines
|
|
invoice.lines = invoice_lines
|
|
invoice.turn = self._get_turn()
|
|
invoice.shop = self.shop
|
|
if invoice.shop and invoice.shop.tax_exempt:
|
|
for line in invoice.lines:
|
|
if not line.product.account_category.account_other_income:
|
|
raise AccessError(
|
|
gettext('sale_shop.msg_dont_account_other_income',
|
|
product=line.product.rec_name))
|
|
line.account = line.product.account_category.account_other_income
|
|
|
|
invoice.save()
|
|
Invoice.update_taxes([invoice])
|
|
self.copy_resources_to(invoice)
|
|
return invoice
|
|
|
|
def _get_invoice_sale(self):
|
|
invoice = super(Sale, self)._get_invoice_sale()
|
|
config = Pool().get('sale.configuration')(1)
|
|
if hasattr(config, 'invoice_date_from_statement') and config.invoice_date_from_statement:
|
|
invoice.invoice_date = self.sale_date
|
|
invoice.accounting_date = self.sale_date
|
|
else:
|
|
invoice_date = self.invoice_date
|
|
if not invoice_date:
|
|
invoice_date = Pool().get('ir.date').today()
|
|
self.invoice_date = invoice_date
|
|
self.save()
|
|
invoice.invoice_date = invoice_date
|
|
invoice.accounting_date = invoice_date
|
|
return invoice
|
|
|
|
def _get_authorization(self, sale):
|
|
authorization_id = None
|
|
if sale.untaxed_amount_cache >= 0:
|
|
if sale.invoice_type == 'P' and sale.shop.pos_authorization:
|
|
authorization_id = sale.shop.pos_authorization.id
|
|
elif sale.invoice_type == 'M' and sale.shop.manual_authorization:
|
|
authorization_id = sale.shop.manual_authorization.id
|
|
elif sale.invoice_type == 'C' and sale.shop.computer_authorization:
|
|
authorization_id = sale.shop.computer_authorization.id
|
|
elif sale.invoice_type in ['1', '2', '3'] and sale.shop.electronic_authorization:
|
|
authorization_id = sale.shop.electronic_authorization.id
|
|
elif sale.shop.debit_note_electronic_authorization and sale.invoice_type == '92':
|
|
authorization_id = sale.shop.debit_note_electronic_authorization.id
|
|
else:
|
|
if sale.shop.credit_note_electronic_authorization and sale.invoice_type in ['91', 'N']:
|
|
authorization_id = sale.shop.credit_note_electronic_authorization.id
|
|
return authorization_id
|
|
|
|
@classmethod
|
|
def process_pos(cls, sale):
|
|
if not sale:
|
|
return
|
|
if sale.invoices:
|
|
invoice = sale.invoices[0]
|
|
if invoice.number and invoice.state != 'draft':
|
|
return sale
|
|
pool = Pool()
|
|
Date = pool.get('ir.date')
|
|
# We need to keep that sequence for invoices been taked from shop
|
|
# configuration instead fiscalyear, because some countries sequences
|
|
# are setted by shop
|
|
number = None
|
|
invoice = sale.create_invoice()
|
|
sale.set_invoice_state()
|
|
sequence = sale.get_sequence(sale)
|
|
if not sale.invoice_number and sale.invoice_method == 'order':
|
|
if sequence:
|
|
number = sequence.get()
|
|
cls.write([sale], {
|
|
'invoice_number': number,
|
|
})
|
|
else:
|
|
number = sale.invoice_number
|
|
position = sale.position if sale.position else None
|
|
sale_kind = None
|
|
if hasattr(sale, 'kind') and sale.kind:
|
|
sale_kind = sale.kind
|
|
if invoice:
|
|
sale.invoice = invoice.id
|
|
to_write = {
|
|
'shop': sale.shop.id,
|
|
'number': number,
|
|
'reference': sale.reference or sale.number,
|
|
'position': position,
|
|
'turn': sale.turn,
|
|
}
|
|
|
|
if sale_kind:
|
|
to_write['sale_kind'] = sale_kind
|
|
if sale.invoice_type:
|
|
pass
|
|
invoice.write([invoice], to_write)
|
|
sale.save()
|
|
return sale
|
|
|
|
@classmethod
|
|
def cancel(cls, sales):
|
|
pool = Pool()
|
|
Invoice = pool.get('account.invoice')
|
|
Journal = pool.get('account.journal')
|
|
super(Sale, cls).cancel(sales)
|
|
journals = Journal.search([
|
|
('type', '=', 'revenue'),
|
|
])
|
|
if journals:
|
|
journal = journals[0]
|
|
else:
|
|
return
|
|
for sale in sales:
|
|
if not sale.number or not sale.invoice_number:
|
|
continue
|
|
sale_invoices = list(sale.invoices)
|
|
if not sale.invoices:
|
|
invoice, = Invoice.create([{
|
|
'party': sale.party.id,
|
|
'account': sale.party.account_receivable.id,
|
|
'invoice_date': sale.invoice_date or sale.sale_date,
|
|
'payment_term': sale.payment_term.id,
|
|
'salesman': sale.salesman and sale.salesman.id,
|
|
'journal': journal.id,
|
|
'invoice_address': sale.invoice_address.id,
|
|
'number': sale.invoice_number,
|
|
'reference': sale.number
|
|
}])
|
|
sale_invoices.append(invoice)
|
|
Invoice.cancel(sale_invoices)
|
|
|
|
@staticmethod
|
|
def default_party():
|
|
User = Pool().get('res.user')
|
|
user = User(Transaction().user)
|
|
return user.shop.party.id if user.shop and user.shop.party else None
|
|
|
|
@fields.depends('invoice_method', 'pre_sale')
|
|
def on_change_pre_sale(self):
|
|
if self.pre_sale:
|
|
self.invoice_method = 'shipment'
|
|
else:
|
|
self.invoice_method = 'order'
|
|
|
|
@classmethod
|
|
def create(cls, vlist):
|
|
now = datetime.now()
|
|
vlist = [x.copy() for x in vlist]
|
|
for vals in vlist:
|
|
vals['pos_create_date'] = now
|
|
return super(Sale, cls).create(vlist)
|
|
|
|
@classmethod
|
|
def delete(cls, sales):
|
|
for sale in sales:
|
|
if sale.invoice_number:
|
|
raise SaleDeleteError(
|
|
gettext('sale_pos.msg_delete_invoice_number',
|
|
sale=sale.rec_name,
|
|
s=sale.invoice_number))
|
|
super(Sale, cls).delete(sales)
|
|
|
|
@classmethod
|
|
def process_sale_pos(cls, sale):
|
|
# We must set directly state and amounts cache because is faster
|
|
# 'state': 'confirmed',
|
|
cls.write([sale], {
|
|
'state': 'processing',
|
|
'untaxed_amount_cache': sale.untaxed_amount,
|
|
'tax_amount_cache': sale.tax_amount,
|
|
'total_amount_cache': sale.total_amount
|
|
})
|
|
|
|
sale = cls.process_pos(sale)
|
|
return sale
|
|
|
|
@classmethod
|
|
def update_state(cls, sales):
|
|
for sale in sales:
|
|
if not sale.is_done():
|
|
continue
|
|
|
|
@classmethod
|
|
def do_stock_moves(cls, sales):
|
|
for sale in sales:
|
|
if sale.shipment_state == "none":
|
|
sale.create_shipment('out')
|
|
sale.set_shipment_state()
|
|
|
|
@classmethod
|
|
def post_invoices(cls, sale):
|
|
pool = Pool()
|
|
Date = pool.get('ir.date')
|
|
Invoice = pool.get('account.invoice')
|
|
invoice = None
|
|
if sale.invoice:
|
|
invoice = sale.invoice
|
|
else:
|
|
if sale.invoices:
|
|
invoice = sale.invoices[0]
|
|
|
|
if invoice:
|
|
if invoice.payment_term.id != sale.payment_term.id:
|
|
invoice.payment_term = sale.payment_term
|
|
|
|
# _invoice_date = sale.invoice_date or Date.today()
|
|
# if invoice.state == 'draft':
|
|
# if not getattr(invoice, 'invoice_date', False):
|
|
# invoice.invoice_date = _invoice_date
|
|
# if not getattr(invoice, 'accounting_date', False):
|
|
# invoice.accounting_date = _invoice_date or date.today()
|
|
invoice.save()
|
|
if hasattr(sale.shop, 'workflow_invoice') \
|
|
and sale.shop.workflow_invoice == 'validated':
|
|
Invoice.validate_invoice([invoice])
|
|
return
|
|
Invoice.process_invoice([invoice])
|
|
if invoice.state == 'posted' and sale.residual_amount <= 0:
|
|
try:
|
|
cls.do_reconcile([sale])
|
|
except:
|
|
pass
|
|
|
|
@classmethod
|
|
def do_reconcile(cls, sales):
|
|
Reconciliation = Pool().get('account.move.reconciliation')
|
|
Config = Pool().get('sale.configuration')
|
|
account_advance = Config(1).advance_account.id if Config(1).advance_account else None
|
|
for sale in sales:
|
|
reconcile_lines = []
|
|
advance_lines = []
|
|
account_reconcile_id = None
|
|
invoice_id = None
|
|
invoice_ = None
|
|
if not sale.payments or not sale.number:
|
|
continue
|
|
try:
|
|
for invoice in sale.invoices:
|
|
if invoice.state == 'paid' or not invoice.move:
|
|
continue
|
|
invoice.process([invoice])
|
|
invoice_id = invoice.id
|
|
invoice_ = invoice
|
|
|
|
account_reconcile_id = invoice.account.id
|
|
for line in invoice.payment_lines:
|
|
if not line.reconciliation and line.account.id == account_reconcile_id:
|
|
reconcile_lines.append(line)
|
|
for ml in invoice.move.lines:
|
|
if ml.account.id == account_reconcile_id:
|
|
reconcile_lines.append(ml)
|
|
break
|
|
if invoice_:
|
|
for st_line in sale.payments:
|
|
if st_line.account.id == invoice_.account.id:
|
|
st_line.invoice = invoice_id
|
|
st_line.save()
|
|
elif st_line.move and st_line.move.state != 'posted':
|
|
st_line.move.post([st_line.move])
|
|
if not st_line.move:
|
|
st_line.create_move()
|
|
|
|
for ml in st_line.move.lines:
|
|
if not ml.reconciliation and ml.account.id == account_reconcile_id:
|
|
reconcile_lines.append(ml)
|
|
if account_advance and not ml.reconciliation and ml.account.id == account_advance:
|
|
advance_lines.append(ml)
|
|
if advance_lines:
|
|
invoice_.create_cross_advance(advance_lines)
|
|
amount_reconcile = sum(r.debit-r.credit for r in reconcile_lines)
|
|
if reconcile_lines and amount_reconcile == 0:
|
|
Reconciliation.create([{
|
|
'lines': [('add', reconcile_lines)],
|
|
'date': TODAY,
|
|
}])
|
|
invoice_.process([invoice_])
|
|
sale_write = {'state': 'done'}
|
|
if invoice.state == 'paid':
|
|
sale_write['invoice_state'] = 'paid'
|
|
sale.write([sale], sale_write)
|
|
except Exception as e:
|
|
print('error: ', e)
|
|
print('Warning: Sale number not processed %s' % sale.number)
|
|
|
|
@classmethod
|
|
def workflow_to_end(cls, sales):
|
|
sale = sales[0]
|
|
_sale = cls.process_sale_pos(sale)
|
|
if _sale:
|
|
sale = _sale
|
|
cls.post_invoices(sale)
|
|
try:
|
|
cls.do_stock_moves([sale])
|
|
cls.do_reconcile([sale])
|
|
cls.update_state([sale])
|
|
except Exception as e:
|
|
print(e)
|
|
|
|
@classmethod
|
|
@ModelView.button
|
|
def wizard_generate_invoice(cls, sales):
|
|
cls.quote(sales)
|
|
cls.workflow_to_end(sales)
|
|
|
|
@classmethod
|
|
@ModelView.button
|
|
def wizard_generate_shipment(cls, sales):
|
|
cls.do_stock_moves(sales)
|
|
|
|
@classmethod
|
|
def copy(cls, sales, default=None):
|
|
if default is None:
|
|
default = {}
|
|
default['invoice'] = None
|
|
default['invoice_number'] = None
|
|
default['invoice_date'] = None
|
|
if sales:
|
|
sale = sales[0]
|
|
if sale.invoice and sale.invoice.number:
|
|
default['reference'] = sale.invoice.number
|
|
default['invoice_number'] = None
|
|
return super(Sale, cls).copy(sales, default)
|
|
|
|
def get_sequence(self, sale):
|
|
sequence = None
|
|
if sale.untaxed_amount_cache >= 0:
|
|
if sale.invoice_type == 'C' and sale.shop.computer_authorization:
|
|
sequence = sale.shop.computer_authorization.sequence
|
|
elif sale.invoice_type == 'P' and sale.shop.pos_authorization:
|
|
sequence = sale.shop.pos_authorization.sequence
|
|
elif sale.invoice_type == 'M' and sale.shop.manual_authorization:
|
|
sequence = sale.shop.manual_authorization.sequence
|
|
elif sale.invoice_type in ['1','2','3'] and sale.shop.electronic_authorization:
|
|
sequence = sale.shop.electronic_authorization.sequence
|
|
elif sale.shop.invoice_sequence:
|
|
sequence = sale.shop.invoice_sequence
|
|
else:
|
|
if sale.shop.credit_note_electronic_authorization and sale.invoice_type in ['91', 'N']:
|
|
sequence = sale.shop.credit_note_electronic_authorization.sequence
|
|
elif sale.shop.debit_note_electronic_authorization and sale.invoice_type == '92':
|
|
sequence = sale.shop.debit_note_electronic_authorization.sequence
|
|
else:
|
|
if sale.shop.credit_note_sequence:
|
|
sequence = sale.shop.credit_note_sequence
|
|
return sequence
|
|
|
|
def create_shipment(self, shipment_type):
|
|
if self.self_pick_up:
|
|
return self.create_moves_without_shipment(shipment_type)
|
|
return super(Sale, self).create_shipment(shipment_type)
|
|
|
|
def create_moves_without_shipment(self, shipment_type):
|
|
pool = Pool()
|
|
Move = pool.get('stock.move')
|
|
|
|
if self.shipment_method != 'order':
|
|
return
|
|
moves = {}
|
|
for line in self.lines:
|
|
move = line.get_move(shipment_type)
|
|
if move:
|
|
moves[line.id] = move
|
|
to_create = []
|
|
for m in moves:
|
|
moves[m].state = 'draft'
|
|
to_create.append(moves[m]._save_values)
|
|
|
|
Move.create(to_create)
|
|
Move.do(self.moves)
|
|
self.set_shipment_state()
|
|
|
|
# WTF
|
|
# @fields.depends('lines', 'currency', 'party')
|
|
# def on_change_lines(self):
|
|
# '''
|
|
# Overrides this method completely if the sale is self pick up to improve
|
|
# performance: Computes untaxed, total and tax amounts from the already
|
|
# computed values in sale lines.
|
|
# '''
|
|
#
|
|
# self.untaxed_amount = Decimal('0.0')
|
|
# self.tax_amount = Decimal('0.0')
|
|
# self.total_amount = Decimal('0.0')
|
|
#
|
|
# if self.lines:
|
|
# self.untaxed_amount = reduce(lambda x, y: x + y,
|
|
# [(getattr(l, 'amount', None) or Decimal(0))
|
|
# for l in self.lines if l.type == 'line'], Decimal(0)
|
|
# )
|
|
# self.total_amount = reduce(lambda x, y: x + y,
|
|
# [(getattr(l, 'amount_w_tax', None) or Decimal(0))
|
|
# for l in self.lines if l.type == 'line'], Decimal(0)
|
|
# )
|
|
# if self.currency:
|
|
# self.untaxed_amount = self.currency.round(self.untaxed_amount)
|
|
# self.total_amount = self.currency.round(self.total_amount)
|
|
# self.tax_amount = self.total_amount - self.untaxed_amount
|
|
# if self.currency:
|
|
# self.tax_amount = self.currency.round(self.tax_amount)
|
|
|
|
def get_invoice_number(self, name=None):
|
|
if self.invoices:
|
|
return self.invoices[0].number
|
|
|
|
@classmethod
|
|
def dash_on_change_party(cls, args, ctx={}):
|
|
if args.get('party'):
|
|
Party = Pool().get('party.party')
|
|
party = Party(args.get('party')['id'])
|
|
address = party.address_get(type='invoice')
|
|
return {
|
|
'invoice_address': {'id': address.id, 'name': address.name},
|
|
'shipment_address': None
|
|
}
|
|
|
|
def _get_turn(self):
|
|
Statement = Pool().get('account.statement')
|
|
if not self.sale_device:
|
|
return
|
|
statements = Statement.search([
|
|
('state', '=', 'draft'),
|
|
('sale_device', '=', self.sale_device.id),
|
|
('turn', '!=', None),
|
|
], order=[('create_date', 'DESC')])
|
|
if statements:
|
|
return statements[0].turn
|
|
|
|
|
|
class SaleLine(metaclass=PoolMeta):
|
|
__name__ = 'sale.line'
|
|
|
|
# @fields.depends('unit_price', 'unit_price_full', 'product', 'quantity')
|
|
# def on_change_unit_price_full(self, name=None):
|
|
# pool = Pool()
|
|
# Tax = pool.get('account.tax')
|
|
# if self.product and self.unit_price_full and self.product.template.customer_taxes_used:
|
|
# res = Tax.reverse_compute(self.unit_price_full,
|
|
# self.product.template.customer_taxes_used)
|
|
# self.unit_price = res
|
|
|
|
@classmethod
|
|
def dash_on_change_line(cls, args, ctx):
|
|
if not args.get('quantity') or not args.get('product'):
|
|
return {}
|
|
|
|
Line = Pool().get('sale.line')
|
|
Sale = Pool().get('sale.sale')
|
|
Product = Pool().get('product.product')
|
|
PriceListLine = Pool().get('product.price_list.line')
|
|
product_id = args['product']['id']
|
|
product = Product(product_id)
|
|
company_id = ctx.get('company')
|
|
|
|
with Transaction().set_context(ctx):
|
|
unit_price = product.list_price
|
|
|
|
if args.get('quantity'):
|
|
quantity = int(args.get('quantity'))
|
|
else:
|
|
quantity = 1
|
|
|
|
if ctx.get('price_list'):
|
|
price_list_id = ctx.get('price_list')['id']
|
|
else:
|
|
price_list_id = None
|
|
|
|
percent_commission = 0
|
|
if price_list_id:
|
|
price_lines = PriceListLine.search([
|
|
('price_list', '=', price_list_id),
|
|
('product', '=', product_id),
|
|
])
|
|
if price_lines:
|
|
price_line = price_lines[0]
|
|
unit_price = float(unit_price)
|
|
unit_price = Decimal(eval(price_line.formula))
|
|
percent_commission = price_line.price_list.percent_commission
|
|
|
|
sale = Sale(company=company_id)
|
|
taxes_ids = [t.id for t in product.customer_taxes_used]
|
|
line = Line(
|
|
sale=sale.id,
|
|
type='line',
|
|
taxes=taxes_ids,
|
|
unit_price=unit_price,
|
|
quantity=quantity,
|
|
product=product.id,
|
|
)
|
|
|
|
res = cls.get_price_with_tax([line], ['amount_w_tax', 'unit_price_w_tax'])
|
|
|
|
res = {
|
|
'unit_price_w_tax': math.ceil(res['unit_price_w_tax'][None]),
|
|
'amount_w_tax': math.ceil(res['amount_w_tax'][None]),
|
|
'unit_price': math.ceil(unit_price),
|
|
'taxes': [[('add'), taxes_ids]],
|
|
'unit': product.template.default_uom.id,
|
|
'type': 'line',
|
|
}
|
|
if percent_commission:
|
|
res['commission_amount'] = round((((unit_price) * quantity) * percent_commission), 0)
|
|
return res
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(SaleLine, cls).__setup__()
|
|
|
|
# Allow edit product, quantity and unit in lines without parent sale
|
|
# for fname in ('product', 'quantity', 'unit'):
|
|
# field = getattr(cls, fname)
|
|
# if field.states.get('readonly'):
|
|
# del field.states['readonly']
|
|
|
|
@staticmethod
|
|
def default_sale():
|
|
if Transaction().context.get('sale'):
|
|
return Transaction().context.get('sale')
|
|
return None
|
|
|
|
# @fields.depends('sale')
|
|
# def on_change_product(self):
|
|
# Sale = Pool().get('sale.sale')
|
|
#
|
|
# if not self.sale:
|
|
# sale_id = Transaction().context.get('sale')
|
|
# if sale_id:
|
|
# self.sale = Sale(sale_id)
|
|
# super(SaleLine, self).on_change_product()
|
|
|
|
@fields.depends('sale')
|
|
def on_change_with_amount(self):
|
|
if not self.sale:
|
|
self.sale = Transaction().context.get('sale')
|
|
return super(SaleLine, self).on_change_with_amount()
|
|
|
|
def get_from_location(self, name):
|
|
res = super(SaleLine, self).get_from_location(name)
|
|
if self.sale.self_pick_up:
|
|
if self.warehouse and self.quantity >= 0:
|
|
return self.warehouse.storage_location.id
|
|
return res
|
|
|
|
def get_to_location(self, name):
|
|
res = super(SaleLine, self).get_to_location(name)
|
|
if self.sale.self_pick_up:
|
|
if self.warehouse and self.quantity < 0:
|
|
return self.warehouse.storage_location.id
|
|
return res
|
|
|
|
def compute_price_w_tax(self, line):
|
|
Tax = Pool().get('account.tax')
|
|
res = line.unit_price * Decimal(line.quantity)
|
|
|
|
if line.taxes and line.unit_price:
|
|
tax_list = Tax.compute(line.taxes,
|
|
line.unit_price or Decimal('0.0'), 1)
|
|
res = sum([t['amount'] for t in tax_list], Decimal('0.0'))
|
|
res = (res + line.unit_price) * Decimal(line.quantity)
|
|
if line.product.extra_tax:
|
|
res += line.product.extra_tax * Decimal(line.quantity)
|
|
res = res.quantize(
|
|
Decimal(1) / 10 ** self.__class__.unit_price.digits[1])
|
|
return res
|
|
|
|
|
|
class SaleForceDraft(Wizard):
|
|
'Sale Force Draft'
|
|
__name__ = 'sale_pos.force_draft'
|
|
start_state = 'force_draft'
|
|
force_draft = StateTransition()
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(SaleForceDraft, cls).__setup__()
|
|
|
|
def transition_force_draft(self):
|
|
sale_table = Table('sale_sale')
|
|
invoice_table = Table('account_invoice')
|
|
move_table = Table('account_move')
|
|
stock_move_table = Table('stock_move')
|
|
Sale = Pool().get('sale.sale')
|
|
MoveLine = Pool().get('account.move.line')
|
|
Date = Pool().get('ir.date')
|
|
|
|
cursor = Transaction().connection.cursor()
|
|
ids = Transaction().context['active_ids']
|
|
if not ids:
|
|
return 'end'
|
|
sales = Sale.browse(ids)
|
|
|
|
for sale in sales:
|
|
# if sale.sale_date != Date.today():
|
|
# return 'end'
|
|
|
|
# The payments must be delete
|
|
for pay in sale.payments:
|
|
if pay.statement.state != 'draft':
|
|
return 'end'
|
|
if pay.move:
|
|
self.unreconcile_move(pay.move)
|
|
pay.invoice = None
|
|
pay.save()
|
|
pay.move.delete([pay.move])
|
|
pay.delete([pay])
|
|
|
|
# The invoices must be delete
|
|
for invoice in sale.invoices:
|
|
if (hasattr(invoice, 'cufe') and invoice.cufe) or \
|
|
hasattr(invoice, 'electronic_state') and \
|
|
invoice.electronic_state == 'submitted':
|
|
raise SaleForceDraftError(
|
|
gettext('sale_pos.msg_with_electronic_invoice'))
|
|
if invoice.move:
|
|
move = invoice.move
|
|
MoveLine.check_journal_period_modify(move.period, move.journal)
|
|
if invoice.state == 'paid':
|
|
self.unreconcile_move(invoice.move)
|
|
if invoice.move:
|
|
cursor.execute(*move_table.update(
|
|
columns=[move_table.state],
|
|
values=['draft'],
|
|
where=move_table.id == invoice.move.id)
|
|
)
|
|
cursor.execute(*move_table.delete(
|
|
where=move_table.id == invoice.move.id)
|
|
)
|
|
cursor.execute(*invoice_table.update(
|
|
columns=[invoice_table.state, invoice_table.number],
|
|
values=['validate', None],
|
|
where=invoice_table.id == invoice.id)
|
|
)
|
|
cursor.execute(*invoice_table.delete(
|
|
where=invoice_table.id == invoice.id)
|
|
)
|
|
|
|
if sale.id:
|
|
cursor.execute(*sale_table.update(
|
|
columns=[sale_table.state, sale_table.shipment_state, sale_table.invoice_state],
|
|
values=['draft', 'none', 'none'],
|
|
where=sale_table.id == sale.id)
|
|
)
|
|
# The stock moves must be delete
|
|
stock_moves = [m.id for line in sale.lines for m in line.moves]
|
|
if stock_moves:
|
|
cursor.execute(*stock_move_table.update(
|
|
columns=[stock_move_table.state],
|
|
values=['draft'],
|
|
where=stock_move_table.id.in_(stock_moves)
|
|
))
|
|
|
|
cursor.execute(*stock_move_table.delete(
|
|
where=stock_move_table.id.in_(stock_moves))
|
|
)
|
|
return 'end'
|
|
|
|
def unreconcile_move(self, move):
|
|
Reconciliation = Pool().get('account.move.reconciliation')
|
|
reconciliations = [l.reconciliation for l in move.lines if l.reconciliation]
|
|
if reconciliations:
|
|
Reconciliation.delete(reconciliations)
|
|
|
|
|
|
class SaleUpdateDateStart(ModelView):
|
|
'Sale Update Date Start'
|
|
__name__ = 'sale_pos.sale_update_date.start'
|
|
new_date = fields.Date('New Date', required=True)
|
|
|
|
|
|
class SaleUpdateDate(Wizard):
|
|
'Sale Update Date'
|
|
__name__ = 'sale_pos.sale_update_date'
|
|
start = StateView('sale_pos.sale_update_date.start',
|
|
'sale_pos.sale_update_date_start_view_form', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Ok', 'accept', 'tryton-ok', default=True),
|
|
])
|
|
accept = StateTransition()
|
|
|
|
def transition_accept(self):
|
|
sale = Table('sale_sale')
|
|
id_ = Transaction().context['active_id']
|
|
cursor = Transaction().connection.cursor()
|
|
if id_:
|
|
cursor.execute(*sale.update(
|
|
columns=[sale.sale_date],
|
|
values=[self.start.new_date],
|
|
where=sale.id == id_)
|
|
)
|
|
return 'end'
|
|
|
|
|
|
class SaleDetailedStart(ModelView):
|
|
'Sale Detailed Start'
|
|
__name__ = 'sale_pos.sale_detailed.start'
|
|
start_date = fields.Date('Start Date', required=True)
|
|
end_date = fields.Date('End Date', required=True)
|
|
company = fields.Many2One('company.company',
|
|
'Company', required=True)
|
|
salesman = fields.Many2One('company.employee', 'Salesman')
|
|
party = fields.Many2One('party.party', 'Party')
|
|
product = fields.Many2One('product.product', 'Product')
|
|
shop = fields.Many2One('sale.shop', 'Shop')
|
|
|
|
@staticmethod
|
|
def default_company():
|
|
return Transaction().context.get('company')
|
|
|
|
|
|
class SaleDetailed(Wizard):
|
|
'Sale Detailed'
|
|
__name__ = 'sale_pos.sale_detailed'
|
|
start = StateView('sale_pos.sale_detailed.start',
|
|
'sale_pos.sale_detailed_start_view_form', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Print', 'print_', 'tryton-ok', default=True),
|
|
])
|
|
print_ = StateAction('sale_pos.report_sale_detailed')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(SaleDetailed, cls).__setup__()
|
|
|
|
def do_print_(self, action):
|
|
salesman_id = None
|
|
party_id = None
|
|
product_id = None
|
|
shop_id = None
|
|
if self.start.salesman:
|
|
salesman_id = self.start.salesman.id
|
|
if self.start.shop:
|
|
shop_id = self.start.shop.id
|
|
if self.start.party:
|
|
party_id = self.start.party.id
|
|
if self.start.product:
|
|
product_id = self.start.product.id
|
|
data = {
|
|
'company': self.start.company.id,
|
|
'start_date': self.start.start_date,
|
|
'end_date': self.start.end_date,
|
|
'salesman': salesman_id,
|
|
'party': party_id,
|
|
'product': product_id,
|
|
'shop': shop_id,
|
|
}
|
|
return action, data
|
|
|
|
def transition_print_(self):
|
|
return 'end'
|
|
|
|
|
|
class SaleDetailedReport(Report):
|
|
__name__ = 'sale_pos.report_sale_detailed'
|
|
|
|
@classmethod
|
|
def get_context(cls, records, header, data):
|
|
from operator import itemgetter
|
|
report_context = super().get_context(records, header, data)
|
|
pool = Pool()
|
|
Invoice = pool.get('account.invoice')
|
|
InvoiceLine = pool.get('account.invoice.line')
|
|
Company = pool.get('company.company')
|
|
Product = pool.get('product.product')
|
|
|
|
invoice_dom = [
|
|
('invoice_date', '>=', data['start_date']),
|
|
('invoice_date', '<=', data['end_date']),
|
|
('company', '=', data['company']),
|
|
('type', '=', 'out'),
|
|
('state', 'in', ['posted', 'paid', 'validated', 'transferred']),
|
|
]
|
|
|
|
if data['salesman']:
|
|
invoice_dom.append(
|
|
('salesman', '=', data['salesman'])
|
|
)
|
|
if data['shop']:
|
|
invoice_dom.append(
|
|
('shop', '=', data['shop'])
|
|
)
|
|
if data['party']:
|
|
invoice_dom.append(
|
|
('party', '=', data['party'])
|
|
)
|
|
|
|
fields_inv = [
|
|
'id', 'number', 'invoice_date', 'state', 'payment_term.name',
|
|
'shop.name', 'party.name', 'invoice_type'
|
|
]
|
|
|
|
invoices = Invoice.search_read(invoice_dom, fields_names=fields_inv,
|
|
order=[('invoice_date', 'ASC')]
|
|
)
|
|
line_dom = [
|
|
('product', '!=', None),
|
|
('type', '=', 'line'),
|
|
]
|
|
if data['product']:
|
|
line_dom.append(('product', '=', data['product']))
|
|
|
|
invoices_ids = {inv['id']: inv for inv in invoices}
|
|
line_dom.append(('invoice', 'in', invoices_ids.keys()))
|
|
fields_lines = [
|
|
'id', 'product.name', 'product.code', 'unit.symbol', 'quantity', 'invoice',
|
|
'product.last_cost', 'product.cost_price', 'unit_price',
|
|
'product.account_category.name', 'taxes'
|
|
]
|
|
|
|
config = pool.get('sale.configuration')(1)
|
|
products_exception = []
|
|
if hasattr(config, 'tip_product') and config.tip_product and config.exclude_tip_and_delivery:
|
|
products_exception.append(config.tip_product.id)
|
|
if hasattr(config, 'delivery_product') and config.delivery_product and config.exclude_tip_and_delivery:
|
|
products_exception.append(config.delivery_product.id)
|
|
|
|
if len(products_exception) > 0:
|
|
line_dom.append(('product', 'not in', products_exception))
|
|
|
|
lines = InvoiceLine.search_read(line_dom, fields_names=fields_lines)
|
|
untaxed_amount = []
|
|
total_amount = []
|
|
untaxed_amount_append = untaxed_amount.append
|
|
total_amount_append = total_amount.append
|
|
get_prices_taxed = Product.get_prices_taxed
|
|
dgetter = itemgetter(
|
|
'invoice', 'unit_price', 'quantity', 'product.', 'taxes'
|
|
)
|
|
pt_getter = itemgetter(
|
|
'id', 'name', 'cost_price', 'last_cost', 'account_category.'
|
|
)
|
|
for line in lines:
|
|
invoice, unit_price, qty, product, taxes = dgetter(line)
|
|
product_id, name, cost_price, last_cost, category = pt_getter(product)
|
|
line.update(invoices_ids[invoice])
|
|
cost_price = cost_price or last_cost or 0
|
|
amount = round(qty * float(unit_price), 2)
|
|
utility = unit_price - cost_price
|
|
|
|
cost_taxed, sale_price_taxed = get_prices_taxed(
|
|
product_id, cost_price, unit_price, taxes
|
|
)
|
|
amount_taxed = float(sale_price_taxed) * qty
|
|
|
|
line.update({
|
|
'amount': amount,
|
|
'cost_price': cost_price,
|
|
'product': name,
|
|
'code':product['code'],
|
|
'amount_taxed': amount_taxed,
|
|
'total_cost': float(cost_taxed) * qty,
|
|
'utility': float(utility) * qty,
|
|
'utility_rate': (utility / cost_price) if cost_price else 0,
|
|
'sale_price_taxed': sale_price_taxed,
|
|
'cost_price_taxed': cost_taxed,
|
|
'category': category['name'],
|
|
'shop': line['shop.']['name'] if line.get('shop.') else '',
|
|
})
|
|
untaxed_amount_append(amount)
|
|
total_amount_append(amount_taxed)
|
|
report_context['records'] = lines
|
|
report_context['untaxed_amount'] = sum(untaxed_amount)
|
|
report_context['total_amount'] = sum(total_amount)
|
|
report_context['company'] = Company(data['company'])
|
|
return report_context
|
|
|
|
|
|
class SaleIncomeDailyStart(ModelView):
|
|
'Sale Income Daily Start'
|
|
__name__ = 'sale_pos.sale_income_daily.start'
|
|
company = fields.Many2One('company.company', 'Company', required=True)
|
|
date = fields.Date('Date', required=True)
|
|
shop = fields.Many2One('sale.shop', 'Shop')
|
|
user = fields.Many2One('res.user', 'User')
|
|
# journal = fields.Many2One('account.statement.journal', 'Journal')
|
|
|
|
@staticmethod
|
|
def default_company():
|
|
return Transaction().context.get('company')
|
|
|
|
@staticmethod
|
|
def default_shop():
|
|
return Transaction().context.get('shop')
|
|
|
|
@staticmethod
|
|
def default_user():
|
|
return Transaction().user
|
|
|
|
@staticmethod
|
|
def default_date():
|
|
Date = Pool().get('ir.date')
|
|
return Date.today()
|
|
|
|
|
|
class SaleIncomeDaily(Wizard):
|
|
'Sale Income Daily'
|
|
__name__ = 'sale_pos.sale_income_daily'
|
|
start = StateView('sale_pos.sale_income_daily.start',
|
|
'sale_pos.sale_income_daily_start_view_form', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Print', 'print_', 'tryton-ok', default=True),
|
|
])
|
|
print_ = StateReport('sale_pos.sale_income_daily_report')
|
|
|
|
def do_print_(self, action):
|
|
shop_id, user_id = None, None
|
|
if self.start.user:
|
|
user_id = self.start.user.id
|
|
if self.start.shop:
|
|
shop_id = self.start.shop.id
|
|
report_context = {
|
|
'company': self.start.company.id,
|
|
'date': self.start.date,
|
|
'user': user_id,
|
|
'shop': shop_id,
|
|
}
|
|
return action, report_context
|
|
|
|
def transition_print_(self):
|
|
return 'end'
|
|
|
|
|
|
class SaleIncomeDailyReport(Report):
|
|
'Income Daily Report'
|
|
__name__ = 'sale_pos.sale_income_daily_report'
|
|
|
|
@classmethod
|
|
def get_context(cls, records, header, data):
|
|
report_context = super().get_context(records, header, data)
|
|
pool = Pool()
|
|
Invoice = pool.get('account.invoice')
|
|
Voucher = pool.get('account.voucher')
|
|
Company = pool.get('company.company')
|
|
company = Company(data['company'])
|
|
Statement = pool.get('account.statement')
|
|
Shop = pool.get('sale.shop')
|
|
User = pool.get('res.user')
|
|
records = []
|
|
devices = []
|
|
statements_ = {}
|
|
advances = []
|
|
total_advances = []
|
|
advances_cash = []
|
|
advances_electronic = []
|
|
total_statements = []
|
|
statement_cash = []
|
|
statement_electronic = []
|
|
advances_voucher = []
|
|
total_payments = []
|
|
payments = []
|
|
payments_voucher = []
|
|
payments_cash = []
|
|
payments_electronic = []
|
|
|
|
dom_statement = [
|
|
('date', '=', data['date']),
|
|
]
|
|
if data['shop']:
|
|
dom_statement.append(('sale_device.shop.id', '=', data['shop']))
|
|
statements = Statement.search(dom_statement)
|
|
user_id = Transaction().user
|
|
user = User(user_id)
|
|
|
|
for statement in statements:
|
|
st_amount = sum(l.amount for l in statement.lines)
|
|
to_add = {
|
|
'journal': statement.journal.name,
|
|
'turn': statement.turn,
|
|
'total_amount': st_amount,
|
|
}
|
|
if statement.sale_device.id not in statements_.keys():
|
|
statements_[statement.sale_device.id] = {
|
|
'name': statement.sale_device.name,
|
|
'total': [st_amount],
|
|
'records': [to_add]
|
|
}
|
|
else:
|
|
statements_[statement.sale_device.id]['total'].append(st_amount)
|
|
statements_[statement.sale_device.id]['records'].append(to_add)
|
|
total_statements.append(st_amount)
|
|
|
|
for l in statement.lines:
|
|
if l.statement.journal.kind == 'cash':
|
|
statement_cash.append(l.amount)
|
|
else:
|
|
statement_electronic.append(l.amount)
|
|
|
|
dom_vouchers = [
|
|
('move', '!=', None),
|
|
('move.post_date', '=', data['date']),
|
|
]
|
|
if data['user']:
|
|
dom_vouchers.append(
|
|
('create_uid', '=', data['user']),
|
|
)
|
|
vouchers = Voucher.search(dom_vouchers)
|
|
for v in vouchers:
|
|
cash = 0
|
|
electronic = 0
|
|
for l in v.lines:
|
|
if v.voucher_type == 'receipt':
|
|
if v.payment_mode.payment_type == 'cash':
|
|
advances_cash.append(l.amount)
|
|
cash = l.amount
|
|
else:
|
|
advances_electronic.append(l.amount)
|
|
electronic = l.amount
|
|
advances_voucher.append(l.amount)
|
|
advances.append({
|
|
'number': l.voucher.number,
|
|
'reference': l.detail,
|
|
'party': l.party.name if l.party else l.voucher.party.name,
|
|
'total_amount': l.amount,
|
|
'payment_mode': l.voucher.payment_mode.name,
|
|
'cash': cash,
|
|
'electronic': electronic,
|
|
})
|
|
total_advances.append(l.amount)
|
|
if v.voucher_type == 'payment':
|
|
amount_ = l.amount * (-1)
|
|
if v.payment_mode.payment_type == 'cash':
|
|
payments_cash.append(amount_)
|
|
cash = amount_
|
|
else:
|
|
payments_electronic.append(amount_)
|
|
electronic = amount_
|
|
payments_voucher.append(amount_)
|
|
payments.append({
|
|
'number': l.voucher.number,
|
|
'reference': l.detail,
|
|
'party': l.party.name if l.party else l.voucher.party.name,
|
|
'total_amount': amount_,
|
|
'payment_mode': l.voucher.payment_mode.name,
|
|
'cash': cash,
|
|
'electronic': electronic,
|
|
})
|
|
total_payments.append(amount_)
|
|
|
|
dom_invoices = [
|
|
('company', '=', data['company']),
|
|
('invoice_date', '=', data['date']),
|
|
('number', '!=', None),
|
|
# ('state', 'in', ['posted', 'paid', 'canceled', 'validated']),
|
|
('type', '=', 'out'),
|
|
]
|
|
shop_names = ''
|
|
if data['shop']:
|
|
shop_names = Shop(data['shop']).name
|
|
dom_invoices.append(
|
|
('shop', '=', data['shop'])
|
|
)
|
|
else:
|
|
shops = Shop.search([])
|
|
for s in shops:
|
|
shop_names += s.name + ', '
|
|
|
|
invoices = Invoice.search(dom_invoices, order=[('number', 'ASC')])
|
|
invoices_number = []
|
|
total_invoices_cash = []
|
|
total_invoices_electronic = []
|
|
total_invoices_credit = []
|
|
total_invoices_paid = []
|
|
devices = {}
|
|
total_invoices_amount = []
|
|
for invoice in invoices:
|
|
invoices_number.append(invoice.number)
|
|
cash = 0
|
|
electronic = 0
|
|
credit = 0
|
|
total_invoices_amount.append(invoice.total_amount)
|
|
if not invoice.sales:
|
|
continue
|
|
sale = invoice.sales[0]
|
|
device_id = sale.sale_device.id
|
|
if not sale.payments:
|
|
total_invoices_credit.append(invoice.amount_to_pay)
|
|
credit = invoice.amount_to_pay
|
|
else:
|
|
for p in sale.payments:
|
|
if p.statement.date == data['date']:
|
|
if p.statement.journal.kind == 'cash':
|
|
cash += p.amount
|
|
total_invoices_cash.append(p.amount)
|
|
else:
|
|
electronic += p.amount
|
|
total_invoices_electronic.append(p.amount)
|
|
total_invoices_paid.append(p.amount)
|
|
paid = cash + electronic
|
|
inv = {
|
|
'number': invoice.number,
|
|
'reference': invoice.reference,
|
|
'party': invoice.party.name,
|
|
'total_amount': invoice.total_amount,
|
|
'credit': credit,
|
|
'cash': cash,
|
|
'electronic': electronic,
|
|
'paid': paid,
|
|
'state': invoice.state_string,
|
|
'sale_device': sale.sale_device.name,
|
|
}
|
|
records.append(inv)
|
|
try:
|
|
devices[device_id]['total'].append(invoice.total_amount)
|
|
devices[device_id]['cash'].append(cash)
|
|
devices[device_id]['electronic'].append(electronic)
|
|
devices[device_id]['credit'].append(credit)
|
|
devices[device_id]['paid'].append(paid)
|
|
except:
|
|
devices[device_id] = {
|
|
'name': sale.sale_device.name,
|
|
'total': [invoice.total_amount],
|
|
'credit': [credit],
|
|
'cash': [cash],
|
|
'electronic': [electronic],
|
|
'paid': [paid],
|
|
}
|
|
|
|
advances_cash_ = sum(advances_cash)
|
|
advances_electronic_ = sum(advances_electronic)
|
|
statement_cash_ = sum(statement_cash)
|
|
statement_electronic_ = sum(statement_electronic)
|
|
payments_cash_ = sum(payments_cash)
|
|
payments_electronic_ = sum(payments_electronic)
|
|
|
|
report_context['records'] = records
|
|
report_context['devices'] = devices.values()
|
|
report_context['advances'] = advances
|
|
report_context['statements'] = statements_.values()
|
|
report_context['date'] = data['date']
|
|
report_context['company'] = company.party.name
|
|
report_context['shop'] = shop_names
|
|
report_context['user'] = user.name
|
|
report_context['print_date'] = datetime.now()
|
|
report_context['statement_cash'] = statement_cash_
|
|
report_context['statement_electronic'] = statement_electronic_
|
|
report_context['total_invoices_amount'] = sum(total_invoices_amount)
|
|
report_context['total_invoices_cash'] = sum(total_invoices_cash)
|
|
report_context['total_invoices_electronic'] = sum(total_invoices_electronic)
|
|
report_context['total_invoices_credit'] = sum(total_invoices_credit)
|
|
report_context['total_invoices_paid'] = sum(total_invoices_paid)
|
|
report_context['total_advances'] = sum(total_advances)
|
|
report_context['advances_cash'] = advances_cash_
|
|
report_context['advances_electronic'] = advances_electronic_
|
|
report_context['advances_voucher'] = sum(advances_voucher)
|
|
report_context['total_statements'] = sum(total_statements)
|
|
report_context['start_invoice'] = min(invoices_number) if invoices_number else ''
|
|
report_context['end_invoice'] = max(invoices_number) if invoices_number else ''
|
|
report_context['total_cash'] = advances_cash_ + statement_cash_
|
|
report_context['total_electronic'] = advances_electronic_ + statement_electronic_
|
|
report_context['total_payments'] = sum(total_payments)
|
|
report_context['payments_voucher'] = sum(payments_voucher)
|
|
report_context['payments_cash'] = payments_cash_
|
|
report_context['payments_electronic'] = payments_electronic_
|
|
report_context['payments'] = payments
|
|
return report_context
|
|
|
|
|
|
class SaleByKindStart(ModelView):
|
|
'Sale by Kind Start'
|
|
__name__ = 'sale_pos.sale_by_kind.start'
|
|
company = fields.Many2One('company.company', 'Company', required=True)
|
|
start_date = fields.Date('Start Date', required=True)
|
|
end_date = fields.Date('End Date', required=True)
|
|
start_time = fields.Time('Start Time')
|
|
end_time = fields.Time('End Time')
|
|
shop = fields.Many2One('sale.shop', 'Shop')
|
|
payment_terms = fields.Many2Many('account.invoice.payment_term', None,
|
|
None, 'Payment Term')
|
|
kind = fields.Selection([
|
|
('', ''),
|
|
('delivery', 'Delivery'),
|
|
('take_away', 'Take Away'),
|
|
('to_table', 'To Table'),
|
|
('catering', 'Catering'),
|
|
], 'Kind Order',)
|
|
party = fields.Many2One('party.party', 'Party')
|
|
detailed_by_party = fields.Boolean('Detailed By Party')
|
|
including_tax = fields.Boolean('Including Tax')
|
|
|
|
@staticmethod
|
|
def default_company():
|
|
return Transaction().context.get('company')
|
|
|
|
@staticmethod
|
|
def default_shop():
|
|
return Transaction().context.get('shop')
|
|
|
|
@staticmethod
|
|
def default_date():
|
|
Date = Pool().get('ir.date')
|
|
return Date.today()
|
|
|
|
|
|
class SaleByKind(Wizard):
|
|
'Sale By Kind'
|
|
__name__ = 'sale_pos.sale_by_kind'
|
|
start = StateView('sale_pos.sale_by_kind.start',
|
|
'sale_pos.sale_by_kind_start_form', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Print', 'print_', 'tryton-ok', default=True),
|
|
])
|
|
print_ = StateReport('sale_pos.sale_by_kind_report')
|
|
|
|
def do_print_(self, action):
|
|
shop_id = None
|
|
if self.start.shop:
|
|
shop_id = self.start.shop.id
|
|
payment_terms = None
|
|
if self.start.payment_terms:
|
|
payment_terms = [p.id for p in self.start.payment_terms]
|
|
|
|
report_context = {
|
|
'company': self.start.company.id,
|
|
'start_date': self.start.start_date,
|
|
'end_date': self.start.end_date,
|
|
'start_time': self.start.start_time,
|
|
'end_time': self.start.end_time,
|
|
'shop': shop_id,
|
|
'payment_terms': payment_terms,
|
|
'party': self.start.party,
|
|
'kind': self.start.kind,
|
|
'detailed': self.start.detailed_by_party,
|
|
'including_tax': self.start.including_tax,
|
|
}
|
|
return action, report_context
|
|
|
|
def transition_print_(self):
|
|
return 'end'
|
|
|
|
|
|
class SaleByKindReport(Report):
|
|
'Sale by Kind Report'
|
|
__name__ = 'sale_pos.sale_by_kind_report'
|
|
|
|
@classmethod
|
|
def get_query(cls, data):
|
|
pool = Pool()
|
|
Shop = pool.get('sale.shop')
|
|
Invoice = pool.get('account.invoice')
|
|
Line = pool.get('account.invoice.line')
|
|
Party = pool.get('party.party')
|
|
InvoiceTax = pool.get('account.invoice.tax')
|
|
|
|
tables = {}
|
|
tables['invoice'] = invoice = Invoice.__table__()
|
|
tables['shop'] = shop = Shop.__table__()
|
|
tables['party'] = party = Party.__table__()
|
|
tables['invoicetax'] = invoicetax = InvoiceTax.__table__()
|
|
tables['invoice.line'] = line = Line.__table__()
|
|
|
|
columns_invoicetax = [
|
|
invoice.id.as_('invoice'),
|
|
Sum(Coalesce(invoicetax.amount, 0)).as_('amount'),
|
|
]
|
|
query = invoice.join(
|
|
invoicetax, 'LEFT',
|
|
condition=invoice.id == invoicetax.invoice).select(
|
|
*columns_invoicetax,
|
|
group_by=(invoice.id)
|
|
)
|
|
withs = {}
|
|
withs['with_invoicetax'] = with_invoicetax = With(query=query)
|
|
|
|
columns = [
|
|
invoice.shop.as_('shop_id'),
|
|
shop.name.as_('shop'),
|
|
]
|
|
group_by = (invoice.shop, shop.name)
|
|
|
|
from_item = invoice.join(
|
|
shop, condition=shop.id == invoice.shop
|
|
).join(party, condition=party.id == invoice.party
|
|
).join(
|
|
with_invoicetax, 'LEFT',
|
|
condition=invoice.id == with_invoicetax.invoice
|
|
)
|
|
|
|
return from_item, tables, columns, group_by, withs
|
|
|
|
@classmethod
|
|
def _where(cls, tables, data):
|
|
invoice = tables['invoice']
|
|
where = invoice.state.in_(['posted', 'paid', 'validated'])
|
|
where &= invoice.invoice_date >= data['start_date']
|
|
where &= invoice.invoice_date <= data['end_date']
|
|
where &= invoice.company == data['company']
|
|
where &= invoice.type == 'out'
|
|
|
|
if data.get('start_time') and data.get('end_time'):
|
|
start_date = datetime.combine(
|
|
data['start_date'], data['start_time']) + timedelta(hours=5)
|
|
end_date = datetime.combine(
|
|
data['end_date'], data['end_time']) + timedelta(hours=5)
|
|
|
|
where &= invoice.create_date <= end_date
|
|
where &= invoice.create_date >= start_date
|
|
if data.get('shop'):
|
|
where &= invoice.shop == data['shop']
|
|
|
|
if data.get('party'):
|
|
where &= invoice.party == data['party']
|
|
if data.get('payment_terms'):
|
|
where &= invoice.payment_term.in_(data['payment_terms'])
|
|
if data.get('kind'):
|
|
where &= invoice.sale_kind == data['kind']
|
|
return where
|
|
|
|
@classmethod
|
|
def set_detailed_query(cls, tables, columns, group_by):
|
|
party = tables['party']
|
|
columns.extend([
|
|
party.id.as_('party_id'),
|
|
party.name.as_('party'),
|
|
])
|
|
group_by += (party.id, party.name)
|
|
|
|
return columns, group_by
|
|
|
|
@classmethod
|
|
def get_columns_kind(cls, tables, withs, type):
|
|
invoice = tables['invoice']
|
|
line = tables['invoice.line']
|
|
invoicetax = withs['with_invoicetax']
|
|
condition_case_other = ((invoice.sale_kind == '') | (invoice.sale_kind == Null))
|
|
kinds = ['to_table', 'take_away', 'delivery', 'catering', 'others']
|
|
columns_count = []
|
|
columns_line_amount = []
|
|
columns_invoice_amount = []
|
|
for k in kinds:
|
|
if k != 'others':
|
|
columns_count.extend([Sum(Case((invoice.sale_kind == k, 1), else_=0)).as_('sales_'+k)])
|
|
columns_line_amount.extend([Sum(Case((invoice.sale_kind == k, (line.quantity*line.unit_price)), else_=0)).as_('amount_'+k)])
|
|
columns_invoice_amount.extend([Sum(Case((invoice.sale_kind == k, (invoice.untaxed_amount_cache + invoicetax.amount)), else_=0)).as_('amount_'+k)])
|
|
else:
|
|
columns_count.extend([Sum(Case((condition_case_other, 1), else_=0)).as_('sales_'+k)])
|
|
columns_line_amount.extend([Sum(Case((condition_case_other, (line.quantity*line.unit_price)), else_=0)).as_('amount_'+k)])
|
|
columns_invoice_amount.extend([Sum(Case((condition_case_other, (invoice.untaxed_amount_cache + invoicetax.amount)), else_=0)).as_('amount_'+k)])
|
|
|
|
if type == 'count':
|
|
return columns_count
|
|
elif type == 'line_amount':
|
|
return columns_line_amount
|
|
else:
|
|
return columns_invoice_amount
|
|
|
|
@classmethod
|
|
def get_context(cls, records, header, data):
|
|
report_context = super().get_context(records, header, data)
|
|
pool = Pool()
|
|
|
|
Company = pool.get('company.company')
|
|
company = Company(data['company'])
|
|
|
|
config = pool.get('sale.configuration')(1)
|
|
products_exception = []
|
|
if hasattr(config, 'tip_product') and config.tip_product and config.exclude_tip_and_delivery:
|
|
products_exception.append(config.tip_product.id)
|
|
if hasattr(config, 'delivery_product') and config.delivery_product and config.exclude_tip_and_delivery:
|
|
products_exception.append(config.delivery_product.id)
|
|
|
|
from_item, tables, columns, group_by, withs = cls.get_query(data)
|
|
invoice = tables['invoice']
|
|
columns.extend([Count(invoice.number).as_('sales_total')])
|
|
|
|
if data.get('detailed'):
|
|
columns, group_by = cls.set_detailed_query(
|
|
tables, columns, group_by)
|
|
|
|
columns.extend(cls.get_columns_kind(tables, withs, 'count'))
|
|
if data.get('including_tax'):
|
|
invoicetax = withs['with_invoicetax']
|
|
columns.extend(cls.get_columns_kind(tables, withs, 'invoice_amount'))
|
|
columns.extend([
|
|
Sum(invoice.untaxed_amount_cache + invoicetax.amount).as_('amount_total')
|
|
])
|
|
|
|
query = from_item.select(
|
|
*columns,
|
|
where=cls._where(tables, data),
|
|
group_by=group_by, with_=withs.values()
|
|
)
|
|
records, totals = cls.get_values(query, {}, {}, data['detailed'])
|
|
|
|
if not data.get('including_tax'):
|
|
from_item, tables, columns, group_by, withs = cls.get_query(data)
|
|
where = cls._where(tables, data)
|
|
line = tables['invoice.line']
|
|
invoice = tables['invoice']
|
|
from_item = from_item.join(line, condition=line.invoice == invoice.id)
|
|
if len(products_exception) > 0:
|
|
where &= NotIn(line.product, products_exception)
|
|
columns.extend([Sum(line.quantity*line.unit_price).as_('amount_total')])
|
|
|
|
if data.get('detailed'):
|
|
columns, group_by = cls.set_detailed_query(
|
|
tables, columns, group_by)
|
|
|
|
columns.extend(cls.get_columns_kind(tables, withs, 'line_amount'))
|
|
query = from_item.select(
|
|
*columns,
|
|
where=where,
|
|
group_by=group_by,
|
|
with_=withs.values())
|
|
records, totals = cls.get_values(
|
|
query, records,
|
|
totals, data.get('detailed'))
|
|
report_context['records'] = records.values()
|
|
report_context['company'] = company.rec_name
|
|
report_context['total'] = totals if len(totals) > 1 else None
|
|
report_context['data'] = data
|
|
return report_context
|
|
|
|
@classmethod
|
|
def get_values(cls, query, records, totals, detailed):
|
|
cursor = Transaction().connection.cursor()
|
|
cursor.execute(*query)
|
|
columns = list(cursor.description)
|
|
result = cursor.fetchall()
|
|
for row in result:
|
|
key = row[0]
|
|
# key = str(row[0]) + '_' + str(row[2])
|
|
if detailed:
|
|
key = str(row[0]) + '_' + str(row[3])
|
|
row_dict = {}
|
|
for i, col in enumerate(columns):
|
|
if col.name.startswith('sales') or col.name.startswith('amount'):
|
|
try:
|
|
totals[col.name] += row[i]
|
|
except:
|
|
totals[col.name] = row[i]
|
|
row_dict[col.name] = row[i]
|
|
try:
|
|
records[key].update(row_dict)
|
|
except:
|
|
records[key] = row_dict
|
|
return records, totals
|
|
|
|
|
|
class PortfolioPaymentsStart(ModelView):
|
|
'Portfolio Payments Start'
|
|
__name__ = 'sale_pos.portfolio_payments.start'
|
|
company = fields.Many2One('company.company', 'Company', required=True)
|
|
start_date = fields.Date('Start Date', required=True)
|
|
end_date = fields.Date('End Date', required=True)
|
|
user = fields.Many2One('res.user', 'User')
|
|
salesman = fields.Many2One('company.employee', 'Salesman')
|
|
is_post_date = fields.Boolean('Is Post Date')
|
|
|
|
@staticmethod
|
|
def default_company():
|
|
return Transaction().context.get('company')
|
|
|
|
@staticmethod
|
|
def default_start_date():
|
|
today_ = date.today()
|
|
# before_month = today_ - timedelta(month=1)
|
|
month = today_.month
|
|
day = today_.day
|
|
year = today_.year
|
|
if month == 1:
|
|
old_month = 12
|
|
else:
|
|
old_month = month - 1
|
|
_, end_day = calendar.monthrange(year, old_month)
|
|
return date(year, old_month, end_day)
|
|
|
|
@staticmethod
|
|
def default_end_date():
|
|
return date.today()
|
|
|
|
|
|
class PortfolioPayments(Wizard):
|
|
'Portfolio Payments'
|
|
__name__ = 'sale_pos.portfolio_payments'
|
|
start = StateView('sale_pos.portfolio_payments.start',
|
|
'sale_pos.portfolio_payments_start_view_form', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Ok', 'print_', 'tryton-ok', default=True),
|
|
])
|
|
print_ = StateReport('sale_pos.portfolio_payments_report')
|
|
|
|
def do_print_(self, action):
|
|
data = {
|
|
'start_date': self.start.start_date,
|
|
'end_date': self.start.end_date,
|
|
'company': self.start.company.id,
|
|
'company_name': self.start.company.rec_name,
|
|
'is_post_date': self.start.is_post_date,
|
|
}
|
|
if self.start.user:
|
|
data['user'] = self.start.user.id
|
|
|
|
if self.start.salesman:
|
|
data['salesman'] = self.start.salesman.id
|
|
return action, data
|
|
|
|
def transition_print_(self):
|
|
return 'end'
|
|
|
|
|
|
class PortfolioPaymentsReport(Report):
|
|
'Portfolio Payments Report'
|
|
__name__ = 'sale_pos.portfolio_payments_report'
|
|
|
|
@classmethod
|
|
def get_context(cls, records, header, data):
|
|
report_context = super().get_context(records, header, data)
|
|
pool = Pool()
|
|
VoucherLine = pool.get('account.voucher.line')
|
|
today = date.today()
|
|
dom_search = [
|
|
|
|
('voucher.company', '=', data['company']),
|
|
('voucher.state', '=', 'posted'),
|
|
('voucher.voucher_type', '=', 'receipt'),
|
|
]
|
|
if not data['is_post_date']:
|
|
dom_search.append([
|
|
('voucher.date', '>=', data['start_date']),
|
|
('voucher.date', '<=', data['end_date']), ]
|
|
)
|
|
else:
|
|
dom_search.append([
|
|
('voucher.move.post_date', '>=', data['start_date']),
|
|
('voucher.move.post_date', '<=', data['end_date']), ]
|
|
)
|
|
if data.get('user'):
|
|
dom_search.append(
|
|
('create_uid', '=', data['user']),
|
|
)
|
|
voucher_lines = []
|
|
for line in VoucherLine.search(dom_search):
|
|
voucher = line.voucher
|
|
move_line = line.move_line
|
|
if not move_line:
|
|
continue
|
|
origin = move_line.move_origin
|
|
expiration_date = move_line.maturity_date
|
|
expiration_days = (today - expiration_date).days \
|
|
if expiration_date else None
|
|
if origin and origin.__name__ == 'account.invoice':
|
|
shop = origin.shop.rec_name if origin.shop else ''
|
|
salesman = origin.salesman.rec_name if origin.salesman else ''
|
|
salesman_id = origin.salesman.id if origin.salesman else None
|
|
number = origin.number
|
|
invoice_date = origin.invoice_date
|
|
invoice_amount = origin.total_amount
|
|
invoice_balance = origin.amount_to_pay
|
|
else:
|
|
shop = ''
|
|
salesman = ''
|
|
salesman_id = ''
|
|
number = move_line.reference
|
|
invoice_date = ''
|
|
invoice_amount = move_line.amount
|
|
invoice_balance = None
|
|
|
|
values = {
|
|
'number': voucher.number,
|
|
'shop': shop,
|
|
'salesman': salesman,
|
|
'salesman_id': salesman_id,
|
|
'party_id': voucher.party.id_number_full,
|
|
'party_name': voucher.party.name,
|
|
'date': voucher.date,
|
|
'payment_mode': voucher.payment_mode.rec_name,
|
|
'check_number': voucher.check_number,
|
|
'payment_amount': line.amount,
|
|
'invoice_number': number,
|
|
'invoice_date': invoice_date,
|
|
'expiration_date': expiration_date,
|
|
'invoice_amount': invoice_amount,
|
|
'invoice_balance': invoice_balance,
|
|
'expiration_days': expiration_days,
|
|
'state': voucher.state_string,
|
|
}
|
|
if voucher.state == 'posted':
|
|
values['post_date'] = voucher.move.post_date
|
|
if data.get('salesman'):
|
|
if data['salesman'] == values['salesman_id']:
|
|
voucher_lines.append(values)
|
|
else:
|
|
voucher_lines.append(values)
|
|
|
|
report_context['records'] = voucher_lines
|
|
report_context['company'] = data['company_name']
|
|
report_context['sum_amount'] = sum([obj['payment_amount'] for obj in voucher_lines])
|
|
return report_context
|
|
|
|
|
|
class SalesCostsStart(ModelView):
|
|
'Sales Costs Start'
|
|
__name__ = 'sale_pos.sales_costs.start'
|
|
company = fields.Many2One('company.company', 'Company', required=True)
|
|
start_date = fields.Date('Start Date', required=True)
|
|
end_date = fields.Date('End Date', required=True)
|
|
shop = fields.Many2One('sale.shop', 'Shop')
|
|
|
|
@staticmethod
|
|
def default_company():
|
|
return Transaction().context.get('company')
|
|
|
|
|
|
class SalesCosts(Wizard):
|
|
'Sales Costs'
|
|
__name__ = 'sale_pos.sales_costs'
|
|
start = StateView('sale_pos.sales_costs.start',
|
|
'sale_pos.sales_costs_start_view_form', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Print', 'print_', 'tryton-print', default=True),
|
|
])
|
|
print_ = StateReport('sale_pos.sales_costs_report')
|
|
|
|
def do_print_(self, action):
|
|
shop_id = None
|
|
if self.start.shop:
|
|
shop_id = self.start.shop.id
|
|
data = {
|
|
'company': self.start.company.id,
|
|
'start_date': self.start.start_date,
|
|
'end_date': self.start.end_date,
|
|
'shop': shop_id,
|
|
}
|
|
return action, data
|
|
|
|
def transition_print_(self):
|
|
return 'end'
|
|
|
|
|
|
class SalesCostsReport(Report):
|
|
__name__ = 'sale_pos.sales_costs_report'
|
|
|
|
@classmethod
|
|
def get_line(cls, line, date_, number, origin):
|
|
return {
|
|
'date': date_,
|
|
'move': number,
|
|
'party': line.party.name if line.party else '',
|
|
'reference': line.reference,
|
|
'description': line.description,
|
|
'origin': origin,
|
|
'debit': line.debit,
|
|
'credit': line.credit,
|
|
}
|
|
|
|
@classmethod
|
|
def get_context(cls, records, header, data):
|
|
report_context = super().get_context(records, header, data)
|
|
pool = Pool()
|
|
# Invoice = pool.get('account.invoice')
|
|
InvoiceLine = pool.get('account.invoice.line')
|
|
Company = pool.get('company.company')
|
|
Shop = pool.get('sale.shop')
|
|
company = Company(data['company'])
|
|
shop_name = ''
|
|
if data['shop']:
|
|
shop = Shop(data['shop'])
|
|
shop_name = shop.name
|
|
|
|
dom = [
|
|
('invoice.invoice_date', '>=', data['start_date']),
|
|
('invoice.invoice_date', '<=', data['end_date']),
|
|
('invoice.move', '!=', None),
|
|
('invoice_type', '=', 'out'),
|
|
('type', '=', 'line'),
|
|
]
|
|
if data['shop']:
|
|
dom.append(('invoice.shop', '=', data['shop']))
|
|
|
|
lines = InvoiceLine.search_read(dom, fields_names=[
|
|
'product', 'product.rec_name', 'product.code', 'quantity',
|
|
'unit_price', 'unit.symbol', 'product.cost_price'
|
|
])
|
|
|
|
records = {}
|
|
total_cost = []
|
|
total_income = []
|
|
append_cost = total_cost.append
|
|
append_income = total_income.append
|
|
for line in lines:
|
|
qty, unit_price = line['quantity'], line['unit_price']
|
|
cost_price = line['product.']['cost_price']
|
|
income_amount = qty * float(unit_price)
|
|
cost_amount = qty * float(cost_price)
|
|
append_cost(cost_amount)
|
|
append_income(income_amount)
|
|
try:
|
|
rec_product = records[line['product']]
|
|
rec_product['qty'].append(qty)
|
|
rec_product['income_amount'].append(income_amount)
|
|
rec_product['cost_amount'].append(cost_amount)
|
|
except:
|
|
code, name = line['product.']['code'], line['product.']['rec_name']
|
|
records[line['product']] = {
|
|
'code': code,
|
|
'name': name,
|
|
'category': '',
|
|
'uom': line['unit.']['symbol'],
|
|
'qty': [qty],
|
|
'cost_price': cost_price,
|
|
'income_amount': [income_amount],
|
|
'cost_amount': [cost_amount],
|
|
}
|
|
|
|
report_context['shop'] = shop_name
|
|
report_context['company'] = company
|
|
report_context['records'] = records.values()
|
|
report_context['total_cost'] = total_cost
|
|
report_context['total_income'] = total_income
|
|
return report_context
|
|
|
|
|
|
class WizardSalePayment(metaclass=PoolMeta):
|
|
__name__ = 'sale.payment'
|
|
|
|
def transition_pay_(self):
|
|
res = super(WizardSalePayment, self).transition_pay_()
|
|
Sale = Pool().get('sale.sale')
|
|
active_id = Transaction().context.get('active_id', False)
|
|
sale = Sale(active_id)
|
|
if self.start.do_invoice:
|
|
Sale.workflow_to_end([sale])
|
|
return res
|
|
|
|
|
|
class SalesAuditStart(ModelView):
|
|
'Sales Audit Start'
|
|
__name__ = 'sale_pos.sales_audit.start'
|
|
start_date = fields.Date('Start Date', required=True)
|
|
end_date = fields.Date('End Date', required=True)
|
|
company = fields.Many2One('company.company', 'Company', required=True)
|
|
shop = fields.Many2One('sale.shop', 'Shop', required=True)
|
|
|
|
@staticmethod
|
|
def default_company():
|
|
return Transaction().context.get('company')
|
|
|
|
|
|
class SalesAudit(Wizard):
|
|
'Sale Detailed'
|
|
__name__ = 'sale_pos.sales_audit'
|
|
start = StateView('sale_pos.sales_audit.start',
|
|
'sale_pos.sales_audit_start_view_form', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Print', 'print_', 'tryton-ok', default=True),
|
|
])
|
|
print_ = StateAction('sale_pos.sales_audit_report')
|
|
|
|
def do_print_(self, action):
|
|
data = {
|
|
'company': self.start.company.id,
|
|
'start_date': self.start.start_date,
|
|
'end_date': self.start.end_date,
|
|
'shop': self.start.shop.id,
|
|
}
|
|
return action, data
|
|
|
|
def transition_print_(self):
|
|
return 'end'
|
|
|
|
|
|
class SalesAuditReport(Report):
|
|
__name__ = 'sale_pos.sales_audit_report'
|
|
|
|
@classmethod
|
|
def get_context(cls, records, header, data):
|
|
report_context = super().get_context(records, header, data)
|
|
pool = Pool()
|
|
Invoice = pool.get('account.invoice')
|
|
Sale = pool.get('sale.sale')
|
|
Company = pool.get('company.company')
|
|
Product = pool.get('product.product')
|
|
Shop = pool.get('sale.shop')
|
|
shop = Shop(data['shop'])
|
|
|
|
sales_dom = [
|
|
('sale_date', '>=', data['start_date']),
|
|
('sale_date', '<=', data['end_date']),
|
|
('company', '=', data['company']),
|
|
('shop', '=', data['shop'])
|
|
# ('state', 'in', ['posted', 'paid', 'validated']),
|
|
]
|
|
sales = Sale.search(sales_dom, order=[('sale_date', 'ASC')])
|
|
records = []
|
|
append_rec = records.append
|
|
for rec in sales:
|
|
ship_number = ""
|
|
ship_date = ""
|
|
ship_state = ""
|
|
inv_number = ""
|
|
inv_date = ""
|
|
inv_state = ""
|
|
move = ""
|
|
move_date = ""
|
|
sale_cost = []
|
|
if rec.shipments:
|
|
ship = rec.shipments[0]
|
|
ship_number = ship.number
|
|
ship_date = ship.effective_date
|
|
ship_state = ship.state
|
|
elif rec.shipment_returns:
|
|
ship = rec.shipment_returns[0]
|
|
ship_number = ship.number
|
|
ship_date = ship.effective_date
|
|
ship_state = ship.state
|
|
|
|
if rec.invoices:
|
|
inv = rec.invoices[0]
|
|
inv_number = inv.number
|
|
inv_date = inv.invoice_date
|
|
inv_state = inv.state_string
|
|
if inv.move:
|
|
move = inv.move.number
|
|
move_date = inv.move.date
|
|
for ln in inv.move.lines:
|
|
if ln.account.code[0] == '6':
|
|
sale_cost.append(ln.debit - ln.credit)
|
|
res = {
|
|
'sale': rec.number,
|
|
'party': rec.party.name,
|
|
'reference': rec.reference,
|
|
'untaxed_amount': rec.untaxed_amount_cache,
|
|
'paid': rec.paid_amount,
|
|
'sale_date': rec.sale_date,
|
|
'state': rec.state_string,
|
|
'ship_number': ship_number,
|
|
'ship_date': ship_date,
|
|
'ship_state': ship_state,
|
|
'inv_number': inv_number,
|
|
'inv_date': inv_date,
|
|
'inv_state': inv_state,
|
|
'account_move': move,
|
|
'move_date': move_date,
|
|
'sale_cost': sale_cost,
|
|
}
|
|
print(' sale cost ...', sale_cost)
|
|
append_rec(res)
|
|
|
|
report_context['records'] = records
|
|
report_context['shop'] = shop.name
|
|
report_context['company'] = Company(data['company'])
|
|
return report_context
|
|
|
|
|
|
class DeleteSalesDraft(Wizard):
|
|
'Delete Sales Draft'
|
|
__name__ = 'sale_pos.delete_sales_draft'
|
|
start_state = 'delete_sales_draft'
|
|
delete_sales_draft = StateTransition()
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(DeleteSalesDraft, cls).__setup__()
|
|
|
|
def transition_delete_sales_draft(self):
|
|
cursor = Transaction().connection.cursor()
|
|
Sale = Pool().get('sale.sale')
|
|
sales = Sale.search(['AND',
|
|
['OR', [
|
|
('state', '=', 'draft'),
|
|
('invoice_number', '=', ''),
|
|
('lines', '=', None),
|
|
('payments', '=', None)
|
|
], [
|
|
('state', '=', 'draft'),
|
|
('invoice_number', '=', None),
|
|
('lines', '=', None),
|
|
('payments', '=', None)
|
|
],
|
|
]])
|
|
sales_delete = []
|
|
sales_cancel = []
|
|
for sale in sales:
|
|
if sale.lines:
|
|
continue
|
|
if sale.payments:
|
|
continue
|
|
if sale.number:
|
|
sales_cancel.append(sale)
|
|
else:
|
|
sales_delete.append(str(sale.id))
|
|
Sale.cancel(sales_cancel)
|
|
if len(sales_delete) > 1:
|
|
cursor.execute("DELETE from sale_sale WHERE \
|
|
id in (%s)" % (', '.join(sales_delete)))
|
|
return 'end'
|