933 lines
35 KiB
Python
933 lines
35 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.
|
|
from __future__ import unicode_literals
|
|
from datetime import date, datetime, timedelta
|
|
from sql import Table
|
|
from trytond.pool import PoolMeta, Pool
|
|
from trytond.model import fields, ModelSQL, ModelView
|
|
from trytond.modules.product import price_digits
|
|
from trytond.pyson import Eval
|
|
from trytond.transaction import Transaction
|
|
from trytond.wizard import (
|
|
Wizard, StateView, Button, StateReport
|
|
)
|
|
from operator import attrgetter
|
|
from decimal import Decimal
|
|
from trytond.report import Report
|
|
from trytond.i18n import gettext
|
|
from .exceptions import (PayValidationError, ProductionValidationWarning,
|
|
DeleteSaleError)
|
|
from trytond.modules.sale_pos_frontend.sale import SaleSquareBox
|
|
|
|
KIND = [
|
|
('', ''),
|
|
('take_away', 'Take Away'),
|
|
('delivery', 'Delivery'),
|
|
('to_table', 'To Table')
|
|
]
|
|
|
|
OPTIONS_STATUS = [
|
|
('', ''),
|
|
('draft', 'Draft'),
|
|
('requested', 'Requested'),
|
|
('commanded', 'Commanded'),
|
|
('in_preparation', 'In Preparation'),
|
|
('dispatched', 'Dispatched'),
|
|
('delivered', 'Delivered'),
|
|
('rejected', 'Rejected'),
|
|
('cancelled', 'Cancelled'),
|
|
]
|
|
|
|
|
|
class SaleMove(ModelSQL):
|
|
"Sale - Stock Move"
|
|
__name__ = "sale.sale-stock.move"
|
|
_table = 'sale_sale-stock_move_rel'
|
|
sale = fields.Many2One('sale.sale', 'Sale',
|
|
ondelete='CASCADE', select=True, required=True)
|
|
move = fields.Many2One('stock.move', 'Stock Move',
|
|
ondelete='CASCADE', select=True, required=True)
|
|
|
|
|
|
class Sale(metaclass=PoolMeta):
|
|
__name__ = 'sale.sale'
|
|
consumer = fields.Many2One('party.consumer', 'Consumer')
|
|
table_assigned = fields.Many2One('sale.shop.table', 'Table Assigned',
|
|
domain=[
|
|
('shop', '=', Eval('shop')),
|
|
])
|
|
productions = fields.Function(fields.One2Many('production', None, 'Productions'), 'get_productions')
|
|
production_moves = fields.Many2Many('sale.sale-stock.move', 'sale', 'move', 'Production Moves')
|
|
order_status = fields.Selection(OPTIONS_STATUS, 'Order Status')
|
|
order_status_string = order_status.translated('order_status')
|
|
# delivery_time = fields.Numeric('Delivery Time (Min)', help="In Minutes")
|
|
# shipping_time = fields.DateTime('Shipping Time')
|
|
waiting_time = fields.Function(fields.Integer('Shipping Time',
|
|
help="In Minutes"), 'get_waiting_time')
|
|
order_status_time = fields.Many2One('sale.order_status.time', string='Times Order Status')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(Sale, cls).__setup__()
|
|
|
|
@staticmethod
|
|
def default_order_status():
|
|
return 'draft'
|
|
|
|
def get_waiting_time(self, name=None):
|
|
now = datetime.now()
|
|
if self.state in ('draft', 'quotation', 'confirmed', 'processing'):
|
|
delta = int((now - self.create_date).seconds / 60)
|
|
return delta
|
|
|
|
@classmethod
|
|
def mark_commanded(cls, args):
|
|
"""
|
|
This method mark as commanded all products in sale, previous
|
|
positive response of local printer
|
|
"""
|
|
Status = Pool().get('sale.order_status.time')
|
|
Line = Pool().get('sale.line')
|
|
lines_ = args.get('lines_ids', [])
|
|
|
|
if args.get('sale_id'):
|
|
sale = cls(args['sale_id'])
|
|
sales = [sale]
|
|
else:
|
|
lines = Line.browse(lines_)
|
|
sales = set(ln.sale for ln in lines)
|
|
for sale in sales:
|
|
to_write = {'order_status': 'commanded'}
|
|
now = datetime.now()
|
|
order_time = sale.order_status_time
|
|
if order_time:
|
|
Status.write([order_time], {'commanded': now})
|
|
else:
|
|
status, = Status.create([{'commanded': now, 'requested': now, 'sale': sale.id}])
|
|
to_write['order_status_time'] = status
|
|
cls.write([sale], to_write)
|
|
if args.get('lines_ids'):
|
|
lines_ids = args['lines_ids']
|
|
lines = Line.browse(lines_ids)
|
|
Line.write(list(lines), {'order_sended': True, 'status_order': 'commanded'})
|
|
|
|
@classmethod
|
|
def do(cls, sales):
|
|
if sales:
|
|
ShopTable = Pool().get('sale.shop.table')
|
|
tables = ShopTable.search([('sale', 'in', [s.id for s in sales])])
|
|
if tables:
|
|
ShopTable.write(tables, {'sale': None, 'state': 'available'})
|
|
|
|
@classmethod
|
|
def get_orders_to_command(cls, args):
|
|
# function deprecated for remove
|
|
pool = Pool()
|
|
Line = pool.get('sale.line')
|
|
shop = args['shop']
|
|
|
|
_date = str(datetime.now() - timedelta(hours=1))
|
|
fields = [
|
|
'sale.number', 'quantity', 'note',
|
|
'product.tasks.printers.shop',
|
|
'product.tasks.printers.name',
|
|
'product.tasks.printers.host',
|
|
'product.tasks.printers.interface',
|
|
'product.tasks.printers.port',
|
|
'product.tasks.printers.row_characters',
|
|
'product.tasks.name']
|
|
dom = [
|
|
("sale.shop", "=", shop),
|
|
("sale.state", "in", ("draft", "quotation")),
|
|
("status_order", "=", 'requested'),
|
|
("create_date", ">=", _date),
|
|
]
|
|
|
|
if args.get('sale_id'):
|
|
dom.append(('sale', '=', args['sale']))
|
|
lines = Line.search_read(
|
|
dom, fields_names=fields,
|
|
order=[('sale', 'ASC')])
|
|
|
|
data = {}
|
|
for line in lines:
|
|
sale_id = line['sale.']['id']
|
|
sale_number = line['sale.']['number']
|
|
qty = line['quantity']
|
|
note = line['note']
|
|
id_ = str(line['id'])
|
|
|
|
try:
|
|
data[sale_id]
|
|
except Exception:
|
|
data[sale_id] = {
|
|
'id': sale_id,
|
|
'tasks': {},
|
|
'orders': []
|
|
}
|
|
|
|
for t in line['product.']['tasks.']:
|
|
line_ = {
|
|
'quantity': qty, 'note': note,
|
|
'name': t['name'], 'line': id_,
|
|
'task': str(t['id'])}
|
|
for p in t['printers.']:
|
|
key = str(p['id'])
|
|
if p['shop'] == shop:
|
|
value = {
|
|
**line_,
|
|
'printer': p['id']
|
|
}
|
|
try:
|
|
data[sale_id]['tasks'][key]['lines'].append(line_)
|
|
except Exception:
|
|
p['device'] = p['host']
|
|
p['profile'] = ''
|
|
data[sale_id]['tasks'][key] = {
|
|
'printer': p,
|
|
'sale': sale_number,
|
|
'work_station': p['name'],
|
|
'lines': [line_]
|
|
}
|
|
|
|
for sale_id, value in data.items():
|
|
args = {
|
|
'sale_id': sale_id,
|
|
'repeat': False,
|
|
}
|
|
orders, _ = cls.get_order2print(args)
|
|
value['orders'] = orders
|
|
|
|
return list(data.values())
|
|
|
|
def get_data_for_stations(self):
|
|
# function deprecated
|
|
data_grouped_printer = {}
|
|
if not self.number:
|
|
self.set_number([self])
|
|
data_sale = self.number
|
|
shop = self.shop
|
|
line_commanded = []
|
|
for line in self.lines:
|
|
line_commanded.append(line)
|
|
qty = line.quantity
|
|
note = line.note
|
|
line_id = line.id
|
|
tasks = line.product.tasks
|
|
att_getter = attrgetter("name")
|
|
att_getter_p = attrgetter("host", "interface", "port", "row_characters")
|
|
for t in tasks:
|
|
station = t.work_station
|
|
station_id = station.id
|
|
name = att_getter(t)
|
|
value = {
|
|
'name': name, 'qty': qty, 'note': note,
|
|
'id': line_id, 'task_id': t.id}
|
|
for p in t.work_station.printers:
|
|
key = str(p.id) + '_' + str(station_id)
|
|
if p.shop == shop:
|
|
try:
|
|
data_grouped_printer[key]['lines'].append(value)
|
|
except Exception:
|
|
host, interface, port, row_characters = att_getter_p(p)
|
|
value_printer = {
|
|
'device': host,
|
|
'interface': interface,
|
|
'profile': '',
|
|
'row_characters': row_characters
|
|
}
|
|
data_grouped_printer[key] = {}
|
|
data_grouped_printer[key]['printer'] = value_printer
|
|
data_grouped_printer[key]['sale'] = data_sale
|
|
data_grouped_printer[key]['work_station'] = station.name
|
|
data_grouped_printer[key]['lines'] = [value]
|
|
# Line.write(line_commanded, {'status_order': 'commanded'})
|
|
return data_grouped_printer
|
|
|
|
@classmethod
|
|
def delete(cls, sales):
|
|
has_order_sended = any(line.order_sended for sale in sales for line in sale.lines)
|
|
if has_order_sended:
|
|
raise DeleteSaleError(
|
|
gettext('sale_pos_frontend_rest.msg_sale_delete_error'))
|
|
super(Sale, cls).delete(sales)
|
|
|
|
@classmethod
|
|
def transition_pay_(cls, sales_to_pay):
|
|
pool = Pool()
|
|
Statement = pool.get('account.statement')
|
|
StatementLine = pool.get('account.statement.line')
|
|
for sale_pay in sales_to_pay:
|
|
sale = sale_pay['sale']
|
|
journal_id = sale_pay['journal_id']
|
|
statements = Statement.search([
|
|
('journal', '=', journal_id),
|
|
('state', '=', 'draft'),
|
|
('sale_device', '=', sale.sale_device),
|
|
], order=[('date', 'DESC')])
|
|
if not statements:
|
|
raise PayValidationError(
|
|
gettext('sale_pos_frontend_rest.msg_message_error', s='A draft statement payments has not been created.'))
|
|
|
|
if not sale.number:
|
|
cls.set_number([sale])
|
|
|
|
if not sale.party.account_receivable:
|
|
raise PayValidationError(
|
|
gettext('sale_pos_frontend_rest.msg_party_not_account_receivable', s=sale.party.name))
|
|
|
|
account = sale.party.account_receivable.id
|
|
|
|
payment = StatementLine(
|
|
statement=statements[0].id,
|
|
date=date.today(),
|
|
amount=sale.total_amount,
|
|
party=sale.party.id,
|
|
account=account,
|
|
description=sale.number,
|
|
sale=sale.id,
|
|
)
|
|
payment.save()
|
|
sale.save()
|
|
cls.workflow_to_end([sale])
|
|
|
|
@classmethod
|
|
def update_consumer(cls, args, context={}):
|
|
Consumer = Pool().get('party.consumer')
|
|
fields = args['fields']
|
|
consumer = Consumer(args['id'])
|
|
for key, value in fields.items():
|
|
if hasattr(consumer, key):
|
|
Consumer.write([consumer], {key: value})
|
|
return cls._get_object(consumer)
|
|
|
|
@classmethod
|
|
def create_consumer(cls, args, context={}):
|
|
Consumer = Pool().get('party.consumer')
|
|
consumer = None
|
|
notes = ''
|
|
if args:
|
|
# fields = args['fields']
|
|
print('args....', args)
|
|
consumer, = Consumer.create([args])
|
|
# if consumer and consumer.party:
|
|
# party = consumer.party
|
|
# party.write([party], {'notes': notes})
|
|
# return cls._get_object(consumer)
|
|
|
|
return {
|
|
'id': consumer.id,
|
|
'name': consumer.name,
|
|
'phone': consumer.phone,
|
|
'address': consumer.address or '',
|
|
'notes': consumer.notes,
|
|
'delivery': consumer.delivery
|
|
}
|
|
|
|
@classmethod
|
|
def _get_object(cls, consumer):
|
|
obj_ = {
|
|
'msg': 'ok',
|
|
# 'party': None,
|
|
'consumer': {
|
|
'id': consumer.id,
|
|
'name': consumer.name,
|
|
'phone': consumer.phone,
|
|
'address': consumer.address or '',
|
|
'notes': consumer.notes or '',
|
|
},
|
|
}
|
|
if consumer.party:
|
|
obj_['party'] = consumer.party.id
|
|
return obj_
|
|
|
|
@classmethod
|
|
def _move(cls, from_location, to_location, company, product, uom,
|
|
quantity):
|
|
Move = Pool().get('stock.move')
|
|
move = Move(
|
|
product=product,
|
|
uom=uom,
|
|
quantity=quantity,
|
|
from_location=from_location,
|
|
to_location=to_location,
|
|
company=company,
|
|
currency=company.currency if company else None,
|
|
state='draft',
|
|
)
|
|
return move
|
|
|
|
@classmethod
|
|
def _explode_move_values(cls, from_location, to_location, company,
|
|
bom_io, quantity):
|
|
move = cls._move(from_location, to_location, company,
|
|
bom_io.product, bom_io.uom, quantity)
|
|
move.from_location = from_location.id if from_location else None
|
|
move.to_location = to_location.id if to_location else None
|
|
move.unit_price_required = move.on_change_with_unit_price_required()
|
|
return move
|
|
|
|
@classmethod
|
|
def _create_productions(cls, lines):
|
|
pool = Pool()
|
|
Move = Pool().get('stock.move')
|
|
Location = pool.get('stock.location')
|
|
Bom = pool.get('production.bom')
|
|
Uom = pool.get('product.uom')
|
|
for line in lines:
|
|
if hasattr(line, 'production') and line.production:
|
|
return
|
|
if line.product.producible:
|
|
boms = Bom.search([
|
|
('output_products', '=', line.product.id)
|
|
])
|
|
|
|
if not boms:
|
|
continue
|
|
raise ProductionValidationWarning(
|
|
gettext('sale_pos_frontend_rest.msg_msg_product_without_bom', product=line.product.rec_name))
|
|
|
|
else:
|
|
bom_ = boms[0]
|
|
locations = Location.search([
|
|
('type', '=', 'production'),
|
|
])
|
|
location_ = locations[0] if locations else None
|
|
if not hasattr(line, 'sale'):
|
|
return
|
|
sale = line.sale
|
|
date_ = sale.sale_date
|
|
product_ = line.product
|
|
|
|
if not (bom_ and product_ and product_.default_uom):
|
|
return
|
|
|
|
if sale.warehouse:
|
|
storage_location = sale.warehouse.storage_location
|
|
else:
|
|
storage_location = None
|
|
factor = bom_.compute_factor(product_, line.quantity or 0,
|
|
product_.default_uom)
|
|
|
|
inputs = []
|
|
for input_ in bom_.inputs:
|
|
quantity = input_.compute_quantity(factor)
|
|
move = cls._explode_move_values(storage_location,
|
|
location_, sale.company, input_, quantity)
|
|
if move:
|
|
move.planned_date = date_
|
|
move.effective_date = date_
|
|
move.save()
|
|
inputs.append(move)
|
|
quantity = Uom.compute_qty(input_.uom, line.quantity,
|
|
input_.product.default_uom, round=False)
|
|
|
|
outputs = []
|
|
for output in bom_.outputs:
|
|
quantity = output.compute_quantity(factor)
|
|
move = cls._explode_move_values(location_, storage_location,
|
|
sale.company, output, quantity)
|
|
if move:
|
|
move.planned_date = date_
|
|
move.effective_date = date_
|
|
move.unit_price = Decimal(0)
|
|
move.save()
|
|
outputs.append(move)
|
|
|
|
moves = inputs + outputs
|
|
Move.do(inputs + outputs)
|
|
sale.production_moves = moves
|
|
sale.save()
|
|
|
|
def get_productions(self, name):
|
|
productions = []
|
|
for line in self.lines:
|
|
if hasattr(line, 'production') and line.production:
|
|
productions.append(line.production)
|
|
return productions
|
|
|
|
|
|
class SaleForceDraft(Wizard):
|
|
__name__ = 'sale_pos.force_draft'
|
|
|
|
def transition_force_draft(self):
|
|
pool = Pool()
|
|
Sale = pool.get('sale.sale')
|
|
Production = pool.get('production')
|
|
ids = Transaction().context['active_ids']
|
|
stock_move_table = Table('stock_move')
|
|
cursor = Transaction().connection.cursor()
|
|
if not ids:
|
|
return 'end'
|
|
for sale in Sale.browse(ids):
|
|
stock_moves = [line.id for line in sale.production_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))
|
|
)
|
|
for p in sale.productions:
|
|
cursor = Transaction().connection.cursor()
|
|
cursor.execute("UPDATE production SET state='waiting' WHERE id in (%s)" % (p.id))
|
|
Production.draft([p])
|
|
Production.cancel([p])
|
|
Production.delete([p])
|
|
return super(SaleForceDraft, self).transition_force_draft()
|
|
|
|
|
|
class OrderStatusTime(ModelSQL, ModelView):
|
|
"Sale Order Status Time"
|
|
__name__ = 'sale.order_status.time'
|
|
_rec_name = 'sale'
|
|
|
|
sale = fields.Many2One('sale.sale', 'Sale', ondelete='CASCADE')
|
|
created = fields.DateTime('Created')
|
|
requested = fields.DateTime('Requested')
|
|
commanded = fields.DateTime('commanded')
|
|
dispatched = fields.DateTime('Dispatched')
|
|
delivered = fields.DateTime('Delivered')
|
|
rejected = fields.DateTime('Rejected')
|
|
cancelled = fields.DateTime('Cancelled')
|
|
|
|
|
|
class SaleLine(metaclass=PoolMeta):
|
|
__name__ = 'sale.line'
|
|
production = fields.Many2One('production', 'Production')
|
|
status_order = fields.Selection(OPTIONS_STATUS, 'Status Order')
|
|
without_task = fields.Boolean('Without Task')
|
|
tasks = fields.One2Many('production.task', 'line', 'Tasks')
|
|
|
|
@staticmethod
|
|
def default_status_order():
|
|
return 'draft'
|
|
|
|
@classmethod
|
|
def mark_tasks_printed(cls, args):
|
|
Task = Pool().get('production.task')
|
|
task_ids = args.get('task_ids')
|
|
tasks = Task.browse(task_ids)
|
|
Task.write(list(tasks), {'state': 'commanded'})
|
|
|
|
@classmethod
|
|
def get_data_command_and_task(cls, args):
|
|
orders = cls.get_data_command(args)
|
|
tasks = cls.get_data_tasks(args)
|
|
return {'orders': orders, 'tasks': tasks}
|
|
|
|
@classmethod
|
|
def get_data_command(cls, args):
|
|
Sale = Pool().get('sale.sale')
|
|
Printer = Pool().get('sale.pos_printer')
|
|
|
|
thirty_minutes_ago = str(datetime.now() - timedelta(minutes=30))
|
|
shop = args.get('shop')
|
|
|
|
fields_printer = [
|
|
'shop', 'name',
|
|
'host', 'interface',
|
|
'port', 'row_characters',
|
|
'categories.sequence', 'categories.category.name'
|
|
]
|
|
printers = Printer.search_read(['shop', '=', shop],
|
|
fields_names=fields_printer)
|
|
printers = {p['id']: p for p in printers}
|
|
dom = [
|
|
("sale.shop", "=", shop),
|
|
("sale.state", "in", ("draft", "quotation")),
|
|
("status_order", "=", 'requested'),
|
|
("create_date", ">=", thirty_minutes_ago),
|
|
]
|
|
if args.get('sale_id'):
|
|
dom.append(('sale', '=', args['sale_id']))
|
|
fields = [
|
|
'sale', 'product.name',
|
|
'product.template.printers',
|
|
'product.template.categories',
|
|
'quantity', 'note'
|
|
]
|
|
lines = cls.search_read(dom, fields_names=fields)
|
|
|
|
sale_ids = set(ln['sale'] for ln in lines)
|
|
fields_sales = [
|
|
'consumer.name', 'consumer.phone',
|
|
'consumer.address', 'consumer.notes',
|
|
'party.name', 'turn', 'number', 'invoice_number',
|
|
'position', 'salesman.rec_name', 'comment',
|
|
'delivery_charge', 'payment_term.name', 'delivery_amount',
|
|
'total_amount', 'shop.name', 'kind', 'table_assigned.name'
|
|
]
|
|
sales = Sale.search_read(['id', 'in', sale_ids], fields_names=fields_sales)
|
|
sales = {
|
|
s['id']: {
|
|
'id': s['id'],
|
|
'consumer': s.get('consumer.'),
|
|
'turn': s['turn'],
|
|
'number': s['invoice_number'],
|
|
'sale_number': s['number'],
|
|
'position': s.get('position', ''),
|
|
'party': s.get('party.', {}).get('name') if s.get('party.') else '',
|
|
'kind': s['kind'],
|
|
'delivery_amount': s.get('delivery_amount', 0),
|
|
'salesman': s.get('salesman.').get('rec_name') if s.get('salesman.') else '',
|
|
'comment': s.get('comment', ''),
|
|
'payment_term': s.get('payment_term.').get('name', '') if s.get('payment_term.') else '',
|
|
'delivery_charge': s.get('delivery_charge', 0),
|
|
'total_amount': str(s['total_amount']),
|
|
'shop': s.get('shop.', {}).get('name', '') if s.get('shop.') else '',
|
|
'table_assigned': s.get('table_assigned.').get('name', '') if s.get('table_assigned.') else '',
|
|
}
|
|
for s in sales
|
|
}
|
|
orders = {}
|
|
lines_mark_sended = []
|
|
for line in lines:
|
|
sale_id = line['sale']
|
|
sale = sales[sale_id]
|
|
printers_ = line['product.']['template.'].get('printers', [])
|
|
|
|
if not printers_:
|
|
lines_mark_sended.append(line['id'])
|
|
continue
|
|
|
|
value_line = {
|
|
'name': line['product.']['name'],
|
|
'quantity': str(line['quantity']),
|
|
'unit_price': int(0), # validate is this field is neccesary
|
|
'note': line['note'],
|
|
'id': line['id']
|
|
}
|
|
categories = line['product.']['template.'].get('categories')
|
|
for printer_id in printers_:
|
|
printer = printers.get(printer_id)
|
|
if not printer:
|
|
continue
|
|
|
|
key = f'{sale_id}_{printer_id}'
|
|
|
|
if key not in orders:
|
|
orders[key] = {**printer, **sale, 'lines': []}
|
|
if len(printer.get('categories.')) > 1:
|
|
orders[key]['lines'] = {
|
|
c['sequence']: {
|
|
'name': c.get('category.', {}).get('name'),
|
|
'lines': []} for c in printer['categories.']}
|
|
orders[key]['categories'] = {c['category.']['id']: c['sequence'] for c in printer['categories.']}
|
|
|
|
if isinstance(orders[key]['lines'], list):
|
|
orders[key]['lines'].append(value_line)
|
|
else:
|
|
key_id = str(orders[key]['categories'].get(categories[0], 'others'))
|
|
if key_id == 'others' and 'others' not in orders[key]['lines']:
|
|
orders[key]['lines']['others'] = {'name': 'OTROS', 'lines': []}
|
|
orders[key]['lines'][key_id]['lines'].append(value_line)
|
|
return list(orders.values())
|
|
|
|
@classmethod
|
|
def get_data_tasks(cls, args):
|
|
Task = Pool().get('production.task')
|
|
thirty_minutes_ago = str(datetime.now() - timedelta(minutes=30))
|
|
shop = args['shop']
|
|
fields = [
|
|
'sale.number', 'quantity', 'note',
|
|
'product.tasks.printers.shop',
|
|
'product.tasks.printers.name',
|
|
'product.tasks.printers.host',
|
|
'product.tasks.printers.interface',
|
|
'product.tasks.printers.port',
|
|
'product.tasks.printers.row_characters',
|
|
'product.tasks.name']
|
|
dom = [
|
|
("sale.shop", "=", shop),
|
|
("sale.state", "in", ("draft", "quotation")),
|
|
("create_date", ">=", thirty_minutes_ago),
|
|
("without_task", "!=", True),
|
|
("tasks", '=', None)
|
|
]
|
|
if args.get('sale_id'):
|
|
dom.append(('sale', '=', args['sale_id']))
|
|
lines = cls.search_read(
|
|
dom, fields_names=fields,
|
|
order=[('sale', 'ASC'), ('id', 'DESC')])
|
|
|
|
to_create = []
|
|
lines_without_tasks = []
|
|
for line in lines:
|
|
quantity = line['quantity']
|
|
note = line['note']
|
|
line_id = line['id']
|
|
sale_number = line['sale.']['number']
|
|
tasks = line['product.']['tasks.']
|
|
if not tasks:
|
|
lines_without_tasks.append(line_id)
|
|
|
|
for t in line['product.']['tasks.']:
|
|
task_id = t['id']
|
|
for p in t['printers.']:
|
|
if p['shop'] == shop:
|
|
value = {
|
|
'quantity': quantity,
|
|
'note': note,
|
|
'line': line_id,
|
|
'name': t['name'],
|
|
'sale_number': sale_number,
|
|
'task': task_id,
|
|
'state': 'pending',
|
|
'printer': p['id']}
|
|
to_create.append(value)
|
|
if lines_without_tasks:
|
|
lines_ = cls.browse(lines_without_tasks)
|
|
cls.write(list(lines_), {'without_task': True})
|
|
Task.create(to_create)
|
|
data = Task.get_tasks_to_print(args)
|
|
return data
|
|
|
|
@classmethod
|
|
def delete(cls, lines):
|
|
HistoryDelete = Pool().get('sale.line._history.delete')
|
|
lines_to_create = []
|
|
lines_to_create_append = lines_to_create.append
|
|
for line in lines:
|
|
if line.order_sended:
|
|
value = {
|
|
'line_id': line.id,
|
|
'product': line.product,
|
|
'quantity': line.quantity,
|
|
'date': line.sale.sale_date,
|
|
'order_status': line.sale.order_status,
|
|
'sale': line.sale.id,
|
|
'sale_state': line.sale.state,
|
|
'unit_price': line.unit_price,
|
|
'base_price': line.base_price,
|
|
'note': line.note,
|
|
'shop': line.sale.shop,
|
|
'salesman': line.sale.salesman,
|
|
'line_created': line.create_date
|
|
}
|
|
lines_to_create_append(value)
|
|
super(SaleLine, cls).delete(lines)
|
|
if lines_to_create:
|
|
HistoryDelete.create(lines_to_create)
|
|
|
|
|
|
class SaleLineHistoryDelete(ModelView, ModelSQL):
|
|
'Sale Line History Delete'
|
|
__name__ = 'sale.line._history.delete'
|
|
|
|
product = fields.Many2One('product.product', 'Product')
|
|
line_id = fields.Char('Line id')
|
|
order_status = fields.Char('Order Status')
|
|
sale = fields.Many2One('sale.sale', 'Sale')
|
|
sale_state = fields.Char('Sale State')
|
|
quantity = fields.Float('Quantity',
|
|
digits=(16, Eval('unit_digits', 2)))
|
|
shop = fields.Many2One('sale.shop', 'Shop')
|
|
unit_price = fields.Numeric('Unit Price', digits=price_digits)
|
|
date = fields.Date('Date')
|
|
base_price = fields.Numeric('Base Price', digits=price_digits)
|
|
note = fields.Text('Note')
|
|
salesman = fields.Many2One('company.employee', 'Salesman')
|
|
line_created = fields.DateTime('Line Created')
|
|
|
|
|
|
class SaleLineHistoryDeleteStart(ModelSQL, ModelView):
|
|
'Sale Line History Delete Start'
|
|
__name__ = 'line_history.delete_start'
|
|
|
|
company = fields.Many2One('company.company', 'Company', required=True)
|
|
start_date = fields.Date('Date', required=True)
|
|
end_date = fields.Date('Date', required=True)
|
|
shop = fields.Many2One('sale.shop', 'Shop', required=True)
|
|
|
|
@staticmethod
|
|
def default_company():
|
|
return Transaction().context.get('company')
|
|
|
|
@staticmethod
|
|
def default_shop():
|
|
return Transaction().context.get('shop')
|
|
|
|
@staticmethod
|
|
def default_end_date():
|
|
Date = Pool().get('ir.date')
|
|
return Date.today()
|
|
|
|
@staticmethod
|
|
def default_start_date():
|
|
Date = Pool().get('ir.date')
|
|
today = Date.today()
|
|
date_ = date(today.year, today.month, 1)
|
|
return date_
|
|
|
|
|
|
class SaleLineHistoryDeleteWizard(Wizard):
|
|
'Sale Line History Delete'
|
|
__name__ = 'line_history.delete_wizard'
|
|
|
|
start = StateView(
|
|
'line_history.delete_start',
|
|
'sale_pos_frontend_rest.line_history_delete_view_form',
|
|
[
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Print', 'print_', 'tryton-ok', default=True),
|
|
])
|
|
print_ = StateReport('line_history.delete_report')
|
|
|
|
def do_print_(self, action):
|
|
report_context = {
|
|
'company': self.start.company.id,
|
|
'start_date': self.start.start_date,
|
|
'end_date': self.start.end_date,
|
|
'shop': self.start.shop.id,
|
|
}
|
|
return action, report_context
|
|
|
|
def transition_print_(self):
|
|
return 'end'
|
|
|
|
|
|
class SaleLineHistoryDeleteReport(Report):
|
|
'Sale Line History Delete Report'
|
|
__name__ = 'line_history.delete_report'
|
|
|
|
@classmethod
|
|
def get_context(cls, records, header, data):
|
|
report_context = super().get_context(records, header, data)
|
|
pool = Pool()
|
|
History = pool.get('sale.line._history.delete')
|
|
Company = pool.get('company.company')
|
|
Shop = pool.get('sale.shop')
|
|
domain = [
|
|
('date', '>=', data['start_date']),
|
|
('date', '<=', data['end_date']),
|
|
]
|
|
if data['shop']:
|
|
domain.append(('shop', '=', data['shop']))
|
|
records = History.search_read(domain)
|
|
record_ids = [r['id'] for r in records]
|
|
records = cls._get_records(record_ids, 'sale.line._history.delete', data)
|
|
company = Company(data['company'])
|
|
report_context['company'] = company
|
|
report_context['shop_name'] = Shop.name
|
|
report_context['records'] = records
|
|
return report_context
|
|
|
|
|
|
class SaleSquareBoxGlobal(SaleSquareBox):
|
|
'Sale Square Box Global'
|
|
__name__ = 'sale_pos_frontend_rest.sale_square_box_global'
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(SaleSquareBoxGlobal, cls).__setup__()
|
|
cls.print_ = StateReport('sale_pos_frontend_rest.sale_square_box_global_report')
|
|
|
|
|
|
class SaleSquareBoxGlobalReport(Report):
|
|
'Square Box Global Report'
|
|
__name__ = 'sale_pos_frontend_rest.sale_square_box_global_report'
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(SaleSquareBoxGlobalReport, cls).__setup__()
|
|
|
|
@classmethod
|
|
def get_stament_cash(cls, statement):
|
|
Statement = Pool().get('account.statement')
|
|
if statement:
|
|
value = {
|
|
'statement': Statement(statement['id']),
|
|
'base': statement['total_money'] or 0,
|
|
'bills': sum(k['amount'] for k in statement['count_money.'] if float(k['bill']) >= 1000),
|
|
'coins': sum(k['amount'] for k in statement['count_money.'] if float(k['bill']) < 1000)
|
|
}
|
|
return value
|
|
|
|
@classmethod
|
|
def get_context(cls, records, header, data):
|
|
report_context = super().get_context(records, header, data)
|
|
pool = Pool()
|
|
Invoice = pool.get('account.invoice')
|
|
Company = pool.get('company.company')
|
|
Device = pool.get('sale.device')
|
|
company = Company(data['company'])
|
|
Statement = pool.get('account.statement')
|
|
Shop = pool.get('sale.shop')
|
|
# User = pool.get('res.user')
|
|
|
|
dom_statement = [
|
|
('date', '=', data['date']),
|
|
]
|
|
devices = Device.search([('shop', '=', data['shop'])])
|
|
device_ids = [d.id for d in devices]
|
|
dom_statement.append(('sale_device', 'in', device_ids))
|
|
|
|
if data['turn']:
|
|
dom_statement.append(('turn', '=', int(data['turn'])))
|
|
|
|
fields_statement = ['name', 'create_date', 'journal.kind', 'balance', 'count_money.bill', 'count_money.quantity', 'count_money.amount', 'total_money']
|
|
cash = None
|
|
statements = Statement.search_read(dom_statement, fields_names=fields_statement)
|
|
lst_statements = []
|
|
balance_statements = []
|
|
for st in statements:
|
|
kind = st['journal.']['kind']
|
|
if kind == 'cash':
|
|
cash = st
|
|
else:
|
|
balance_statements.append(st['balance'])
|
|
lst_statements.append(st)
|
|
|
|
dom_invoices = [
|
|
('company', '=', data['company']),
|
|
('invoice_date', '=', data['date']),
|
|
('type', '=', 'out'),
|
|
('shop', '=', data['shop']),
|
|
]
|
|
if data.get('turn'):
|
|
dom_invoices.append(('turn', '=', int(data['turn'])))
|
|
|
|
fields_inv = ['number', 'invoice_type', 'total_amount', 'state',
|
|
'payment_term.payment_type', 'sales.residual_amount',
|
|
'payment_term.rec_name', 'party.name', 'reference']
|
|
invoices = Invoice.search_read(dom_invoices, fields_names=fields_inv)
|
|
pos = []
|
|
electronic = []
|
|
cancelled = []
|
|
credits = []
|
|
invs = []
|
|
pos_append = pos.append
|
|
electronic_append = electronic.append
|
|
cancelled_append = cancelled.append
|
|
credits_append = credits.append
|
|
invs_append = invs.append
|
|
for invoice in invoices:
|
|
residual_amount = invoice['sales.'][0]['residual_amount']
|
|
if residual_amount > 0:
|
|
invoice['residual_amount'] = residual_amount
|
|
credits_append(residual_amount)
|
|
invs_append(invoice)
|
|
if invoice['state'] == 'cancelled':
|
|
cancelled_append((invoice['total_amount'], invoice))
|
|
elif invoice['invoice_type'] == '1':
|
|
electronic_append(invoice['total_amount'])
|
|
else:
|
|
pos_append(invoice['total_amount'])
|
|
|
|
report_context['total_sale'] = sum(pos) + sum(electronic)
|
|
report_context['pos'] = sum(pos)
|
|
report_context['electronic'] = sum(electronic)
|
|
report_context['cash'] = cls.get_stament_cash(cash)
|
|
report_context['credits'] = sum(credits)
|
|
report_context['invoice_credits'] = invs
|
|
report_context['statements'] = lst_statements
|
|
report_context['balance_statements'] = balance_statements
|
|
report_context['data'] = data
|
|
report_context['company'] = company
|
|
report_context['shop'] = Shop(data['shop'])
|
|
return report_context
|