429 lines
14 KiB
Python
429 lines
14 KiB
Python
#This file is part systemlogics_modula module for Tryton.
|
|
#The COPYRIGHT file at the top level of this repository contains
|
|
#the full copyright notices and license terms.
|
|
from trytond.pool import Pool
|
|
from trytond.model import ModelView, ModelSQL, fields, Unique
|
|
from trytond.wizard import Wizard, StateTransition, StateView, Button
|
|
from trytond.pyson import Eval
|
|
from trytond.transaction import Transaction
|
|
from trytond.rpc import RPC
|
|
from itertools import groupby
|
|
from xml.dom.minidom import parseString
|
|
import genshi
|
|
import genshi.template
|
|
import os
|
|
import operator
|
|
import logging
|
|
import datetime
|
|
import tempfile
|
|
|
|
__all__ = ['SystemLogicsModula', 'SystemLogicsModulaEXPOrdiniFile',
|
|
'SystemLogicsModulaImportEXPOrdiniFile',
|
|
'SystemLogicsModulaImportEXPOrdiniFileStart',
|
|
'SystemLogicsModulaImportEXPOrdiniFileProcessStart',
|
|
'SystemLogicsModulaImportEXPOrdiniFileProcess']
|
|
|
|
loader = genshi.template.TemplateLoader(
|
|
os.path.join(os.path.dirname(__file__), 'template'),
|
|
auto_reload=True)
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class SystemLogicsModula(ModelSQL, ModelView):
|
|
'SystemLogics Modula'
|
|
__name__ = 'systemlogics.modula'
|
|
name = fields.Char('Name', required=True)
|
|
dbhost = fields.Selection([
|
|
# ('odbc', 'ODBC'),
|
|
# ('ascii', 'ASCII'),
|
|
('xml', 'XML'),
|
|
# ('excel', 'Excel'),
|
|
], 'DB Host', required=True)
|
|
warehouse = fields.Many2One('stock.location', "Warehouse",
|
|
domain=[('type', '=', 'warehouse')],
|
|
help='System Logics Warehouse', required=True)
|
|
path = fields.Char('Path',
|
|
states={
|
|
'invisible': ~Eval('dbhost').in_(['xml']),
|
|
'required': Eval('dbhost').in_(['xml']),
|
|
},
|
|
depends=['dbhost'], required=True)
|
|
active = fields.Boolean('Active', select=True)
|
|
not_completed = fields.Char('Not completed',
|
|
help='Not completed message')
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(SystemLogicsModula, cls).__setup__()
|
|
cls.__rpc__.update({
|
|
'export_ordini_file': RPC(readonly=False),
|
|
'export_ordini_file_process': RPC(readonly=False),
|
|
})
|
|
|
|
@staticmethod
|
|
def default_dbhost():
|
|
return 'xml'
|
|
|
|
@classmethod
|
|
def default_warehouse(cls):
|
|
Location = Pool().get('stock.location')
|
|
locations = Location.search(cls.warehouse.domain)
|
|
if locations:
|
|
return locations[0].id
|
|
|
|
@staticmethod
|
|
def default_path():
|
|
return os.path.dirname(__file__)
|
|
|
|
@staticmethod
|
|
def default_active():
|
|
return True
|
|
|
|
@classmethod
|
|
def check_xml_record(cls, records, values):
|
|
return True
|
|
|
|
@classmethod
|
|
def imp_ordini(self, shipments, template='IMP_ORDINI_OUT', type_='P'):
|
|
Location = Pool().get('stock.location')
|
|
shipments_ordini = []
|
|
for shipment in shipments:
|
|
if shipment.__name__ in [
|
|
'stock.shipment.in', 'stock.shipment.out.return']:
|
|
if shipment.state not in ['received', 'done']:
|
|
continue
|
|
else:
|
|
if shipment.state != 'assigned':
|
|
continue
|
|
|
|
if not hasattr(shipment, 'warehouse'):
|
|
warehouse = Transaction().context.get('stock_warehouse')
|
|
if not warehouse:
|
|
warehouse, = Location.search(
|
|
[('type', '=', 'warehouse')], limit=1)
|
|
shipment.warehouse = warehouse
|
|
shipments_ordini.append(shipment)
|
|
|
|
if not shipments_ordini:
|
|
return
|
|
|
|
grouped_shipments = groupby(shipments_ordini, operator.attrgetter('warehouse'))
|
|
for warehouse, shipments in grouped_shipments:
|
|
systemlogics = self.search([
|
|
('name', '=', 'IMP_ORDINI'),
|
|
('warehouse', '=', warehouse),
|
|
], limit=1)
|
|
if not systemlogics:
|
|
logger.warning(
|
|
'Configure a IMP_ORDINI related with "%s" warehouse.' % (
|
|
warehouse.name))
|
|
return
|
|
|
|
systemlogic, = systemlogics
|
|
|
|
if not os.path.isdir(systemlogic.path):
|
|
logger.warning(
|
|
'Directory "%s" not exist (ID: %s)' % (
|
|
systemlogic.path,
|
|
systemlogic.id,
|
|
))
|
|
return
|
|
|
|
ordini = getattr(self, 'imp_ordini_%s' % systemlogic.dbhost)
|
|
ordini(systemlogic, shipments, template, type_)
|
|
|
|
@classmethod
|
|
def imp_ordini_odbc(self, systemlogic, shipments, template, type_):
|
|
logger.error('IMP_ORDINI ODBC not supported')
|
|
|
|
@classmethod
|
|
def imp_ordini_ascii(self, systemlogic, shipments, template, type_):
|
|
logger.error('IMP_ORDINI ASCII not supported')
|
|
|
|
@classmethod
|
|
def imp_ordini_excel(self, systemlogic, shipments, template, type_):
|
|
logger.error('IMP_ORDINI EXCEL not supported')
|
|
|
|
@classmethod
|
|
def imp_ordini_xml(self, systemlogic, shipments, template, type_):
|
|
tmpl = loader.load('%s.xml' % template)
|
|
|
|
dbname = Transaction().database.name
|
|
|
|
xml = tmpl.generate(systemlogic=systemlogic, shipments=shipments,
|
|
type_=type_, datetime=datetime).render()
|
|
|
|
with tempfile.NamedTemporaryFile(
|
|
dir=systemlogic.path,
|
|
prefix='%s-%s-' % (dbname,
|
|
datetime.datetime.now().strftime("%Y%m%d-%H%M%S")),
|
|
suffix='.xml', delete=False) as temp:
|
|
temp.write(xml.encode('utf-8'))
|
|
logger.info('Generated XML %s' % (temp.name))
|
|
temp.close()
|
|
|
|
@classmethod
|
|
def imp_articoli(self, products):
|
|
Location = Pool().get('stock.location')
|
|
|
|
warehouse = Transaction().context.get('stock_warehouse')
|
|
if not warehouse:
|
|
warehouse, = Location.search(
|
|
[('type', '=', 'warehouse')], limit=1)
|
|
else:
|
|
warehouse = Location(warehouse)
|
|
|
|
systemlogics = self.search([
|
|
('name', '=', 'IMP_ARTICOLI'),
|
|
('warehouse', '=', warehouse),
|
|
], limit=1)
|
|
if not systemlogics:
|
|
logger.warning(
|
|
'Configure a IMP_ARTICOLI related with "%s" warehouse.' % (
|
|
warehouse.name))
|
|
return
|
|
|
|
systemlogic, = systemlogics
|
|
|
|
if not os.path.isdir(systemlogic.path):
|
|
logger.warning(
|
|
'Directory "%s" not exist (ID: %s)' % (
|
|
systemlogic.path,
|
|
systemlogic.id,
|
|
))
|
|
return
|
|
|
|
articoli = getattr(self, 'imp_articoli_%s' % systemlogic.dbhost)
|
|
articoli(systemlogic, products)
|
|
|
|
@classmethod
|
|
def imp_articoli_odbc(self, products):
|
|
logger.error('IMP_ARTICOLI ODBC not supported')
|
|
|
|
@classmethod
|
|
def imp_articoli_ascii(self, products):
|
|
logger.error('IMP_ARTICOLI ASCII not supported')
|
|
|
|
@classmethod
|
|
def imp_articoli_excel(self, products):
|
|
logger.error('IMP_ARTICOLI EXCEL not supported')
|
|
|
|
@classmethod
|
|
def imp_articoli_xml(self, systemlogic, products):
|
|
tmpl = loader.load('IMP_ARTICOLI.xml')
|
|
|
|
dbname = Transaction().database.name
|
|
|
|
xml = tmpl.generate(products=products).render()
|
|
|
|
with tempfile.NamedTemporaryFile(
|
|
dir=systemlogic.path,
|
|
prefix='%s-%s-' % (dbname,
|
|
datetime.datetime.now().strftime("%Y%m%d-%H%M%S")),
|
|
suffix='.xml', delete=False) as temp:
|
|
temp.write(xml.encode('utf-8'))
|
|
logger.info('Generated XML %s' % (temp.name))
|
|
temp.close()
|
|
|
|
@classmethod
|
|
def export_ordini_file(cls, args=None):
|
|
EXPOrdiniFile = Pool().get('systemlogics.modula.exp.ordini.file')
|
|
|
|
logger.info('Start read SystemLogics Module files')
|
|
vlist = []
|
|
to_remove = []
|
|
for modula in cls.search([('name', '=', 'EXP_ORDINI')]):
|
|
try:
|
|
filenames = os.listdir(modula.path)
|
|
except OSError as e:
|
|
logger.warning('Error reading path: %s' % e)
|
|
continue
|
|
|
|
for filename in filenames:
|
|
fullname = '%s/%s' % (modula.path, filename)
|
|
|
|
try:
|
|
content = open(fullname, 'r').read()
|
|
except IOError as e:
|
|
logger.warning('Error reading file %s: %s' % (fullname, e))
|
|
continue
|
|
|
|
values = {}
|
|
values['name'] = filename
|
|
values['modula'] = modula.id
|
|
values['content'] = content
|
|
values['state'] = 'pending'
|
|
vlist.append(values)
|
|
to_remove.append(fullname)
|
|
|
|
if vlist:
|
|
EXPOrdiniFile.create(vlist)
|
|
# Do commit before remove files
|
|
Transaction().commit()
|
|
|
|
for filename in to_remove:
|
|
try:
|
|
os.remove(filename)
|
|
except OSError:
|
|
pass
|
|
logger.info('Loaded SystemLogics Module %s files' % (len(to_remove)))
|
|
|
|
@classmethod
|
|
def export_ordini_file_process(cls, args=None):
|
|
EXPOrdiniFile = Pool().get('systemlogics.modula.exp.ordini.file')
|
|
|
|
to_process = EXPOrdiniFile.search([('state', '=', 'pending')])
|
|
for process in to_process:
|
|
EXPOrdiniFile.process([process])
|
|
Transaction().cursor.commit()
|
|
|
|
logger.info('Loaded SystemLogics Module process'
|
|
' %s files' % (len(to_process)))
|
|
|
|
|
|
class SystemLogicsModulaEXPOrdiniFile(ModelSQL, ModelView):
|
|
'SystemLogics Modula EXP Ordini File'
|
|
__name__ = 'systemlogics.modula.exp.ordini.file'
|
|
name = fields.Char('Name', required=True)
|
|
modula = fields.Many2One('systemlogics.modula', "Systemlogics Modula",
|
|
required=True)
|
|
content = fields.Text('Content', readonly=True)
|
|
state = fields.Selection([
|
|
('pending', 'Pending'),
|
|
('in_progress', 'In progress'),
|
|
('failed', 'Failed'),
|
|
('done', 'Done'),
|
|
], 'State', readonly=True)
|
|
|
|
@classmethod
|
|
def __setup__(cls):
|
|
super(SystemLogicsModulaEXPOrdiniFile, cls).__setup__()
|
|
t = cls.__table__()
|
|
cls._buttons.update({
|
|
'process': {
|
|
'invisible': ~Eval('state').in_(['pending', 'failed']),
|
|
},
|
|
'fail': {
|
|
'invisible': Eval('state').in_(['done', 'failed']),
|
|
},
|
|
})
|
|
|
|
@classmethod
|
|
def default_state(cls):
|
|
return 'pending'
|
|
|
|
@classmethod
|
|
@ModelView.button
|
|
def process(cls, ordini_files):
|
|
''''
|
|
Read EXP ORDINI file
|
|
1- Try to done a move (RIG_HOSTINF is ID move)
|
|
2- Try to packed shipment if all moves are done
|
|
'''
|
|
pool = Pool()
|
|
Move = pool.get('stock.move')
|
|
Shipment = pool.get('stock.shipment.out')
|
|
EXPOrdiniFile = pool.get('systemlogics.modula.exp.ordini.file')
|
|
|
|
EXPOrdiniFile.write(ordini_files, {'state': 'in_progress'})
|
|
|
|
to_do = []
|
|
done_ordini_files = []
|
|
fail_ordini_files = []
|
|
shipments = set()
|
|
for ofile in ordini_files:
|
|
try:
|
|
dom = parseString(ofile.content)
|
|
except:
|
|
fail_ordini_files.append(ofile)
|
|
continue
|
|
|
|
quantities = {}
|
|
move_ids = []
|
|
for o in dom.getElementsByTagName('EXP_ORDINI_RIGHE'):
|
|
id_ = int(o.getElementsByTagName(
|
|
'RIG_HOSTINF')[0].firstChild.data)
|
|
move_ids.append(id_)
|
|
quantities[int(id_)] = float(
|
|
o.getElementsByTagName('RIG_QTAE')
|
|
[0].firstChild.data.replace(',', '.'))
|
|
|
|
for move in Move.search([('id', 'in', move_ids)]):
|
|
# TODO process shipment out and internal
|
|
if (not move.shipment
|
|
or move.shipment.__name__ != 'stock.shipment.out'):
|
|
continue
|
|
if (quantities[move.id] == move.quantity
|
|
and move.shipment.state == 'assigned'):
|
|
to_do.append(move)
|
|
shipments.add(move.shipment)
|
|
done_ordini_files.append(ofile)
|
|
|
|
if to_do:
|
|
Move.do(to_do) # TODO try/except move error
|
|
|
|
to_package = []
|
|
for shipment in shipments:
|
|
inventory_moves_done = True
|
|
for move in shipment.inventory_moves:
|
|
if move.state != 'done':
|
|
inventory_moves_done = False
|
|
break
|
|
if inventory_moves_done:
|
|
to_package.append(shipment)
|
|
|
|
if to_package:
|
|
Shipment.pack(to_package)
|
|
|
|
if done_ordini_files:
|
|
cls.write(done_ordini_files, {'state': 'done'})
|
|
if fail_ordini_files:
|
|
cls.write(fail_ordini_files, {'state': 'failed'})
|
|
|
|
@classmethod
|
|
@ModelView.button
|
|
def fail(cls, ordini_files):
|
|
cls.write(ordini_files, {'state': 'failed'})
|
|
|
|
|
|
class SystemLogicsModulaImportEXPOrdiniFileStart(ModelView):
|
|
'SystemLogcics Modula Import EXP Ordini File Start'
|
|
__name__ = 'systemlogics.modula.import.exp.ordini.file.start'
|
|
|
|
|
|
class SystemLogicsModulaImportEXPOrdiniFile(Wizard):
|
|
'SystemLogics Modula Import EXP Ordini File'
|
|
__name__ = "systemlogics.modula.import.exp.ordini.file"
|
|
start = StateView('systemlogics.modula.import.exp.ordini.file.start',
|
|
'systemlogics_modula.systemlogics_modula_import_exp_ordini_file_start', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Import', 'import_', 'tryton-ok', default=True),
|
|
])
|
|
import_ = StateTransition()
|
|
|
|
def transition_import_(self):
|
|
SystemLogicsModula = Pool().get('systemlogics.modula')
|
|
SystemLogicsModula.export_ordini_file()
|
|
return 'end'
|
|
|
|
|
|
class SystemLogicsModulaImportEXPOrdiniFileProcessStart(ModelView):
|
|
'SystemLogcics Modula Import EXP Ordini File Process Start'
|
|
__name__ = 'systemlogics.modula.import.exp.ordini.file.process.start'
|
|
|
|
|
|
class SystemLogicsModulaImportEXPOrdiniFileProcess(Wizard):
|
|
'SystemLogics Modula Import EXP Ordini File'
|
|
__name__ = "systemlogics.modula.import.exp.ordini.file.process"
|
|
start = StateView('systemlogics.modula.import.exp.ordini.file.process.start',
|
|
'systemlogics_modula.systemlogics_modula_import_exp_ordini_file_process_start', [
|
|
Button('Cancel', 'end', 'tryton-cancel'),
|
|
Button('Process', 'process', 'tryton-ok', default=True),
|
|
])
|
|
process = StateTransition()
|
|
|
|
def transition_process(self):
|
|
SystemLogicsModula = Pool().get('systemlogics.modula')
|
|
SystemLogicsModula.export_ordini_file_process()
|
|
return 'end'
|