def init(cursor):
from trytond.modules import get_module_info
sql_file = os.path.join(os.path.dirname(__file__), 'init.sql')
with open(sql_file) as fp:
for line in fp.read().split(';'):
if (len(line) > 0) and (not line.isspace()):
cursor.execute(line)
ir_module = Table('ir_module_module')
ir_module_dependency = Table('ir_module_module_dependency')
for module in ('ir', 'res', 'webdav'):
state = 'uninstalled'
if module in ('ir', 'res'):
state = 'to install'
info = get_module_info(module)
insert = ir_module.insert([
ir_module.create_uid, ir_module.create_date, ir_module.name,
ir_module.state
], [[0, Now(), module, state]])
cursor.execute(*insert)
cursor.execute('SELECT last_insert_rowid()')
module_id, = cursor.fetchone()
for dependency in info.get('depends', []):
insert = ir_module_dependency.insert([
ir_module_dependency.create_uid,
ir_module_dependency.create_date,
ir_module_dependency.module, ir_module_dependency.name
], [[0, Now(), module_id, dependency]])
cursor.execute(*insert)
def table_query():
pool = Pool()
Move = pool.get('stock.move')
Location = pool.get('stock.location')
move = Move.__table__()
product_id = Transaction().context.get('product')
warehouse_id = Transaction().context.get('warehouse', -1)
warehouse_query = Location.search([
('parent', 'child_of', [warehouse_id]),
], query=True, order=[])
date_column = Coalesce(move.effective_date, move.planned_date
).as_('date')
return move.select(
Max(move.id).as_('id'),
Literal(0).as_('create_uid'),
Now().as_('create_date'),
Literal(None).as_('write_uid'),
Literal(None).as_('write_date'),
date_column,
where=(move.product == product_id)
& (move.from_location.in_(warehouse_query)
| move.to_location.in_(warehouse_query))
& (Coalesce(move.effective_date, move.planned_date) != Null),
group_by=(date_column, move.product))
def resets(dbname):
with Transaction().new_cursor():
cursor = Transaction().cursor
table = Table('ir_cache')
with Cache._resets_lock:
Cache._resets.setdefault(dbname, set())
for name in Cache._resets[dbname]:
cursor.execute(
*table.select(table.name, where=table.name == name))
if cursor.fetchone():
# It would be better to insert only
cursor.execute(
*table.update([table.timestamp], [Now()],
where=table.name == name))
else:
cursor.execute(*table.insert(
[table.timestamp, table.name], [[Now(), name]]))
Cache._resets[dbname].clear()
cursor.commit()
def test_select_function(self):
query = Now().select()
self.assertEqual(str(query), 'SELECT * FROM NOW() AS "a"')
self.assertEqual(query.params, ())
def test_join_function(self):
t1 = Table('t1')
join = Join(t1, Now())
with AliasManager():
self.assertEqual(str(join), '"t1" AS "a" INNER JOIN NOW() AS "b"')
self.assertEqual(join.params, ())
def load_module_graph(graph, pool, update=None, lang=None):
if lang is None:
lang = [config.get('database', 'language')]
if update is None:
update = []
modules_todo = []
models_to_update_history = set()
cursor = Transaction().cursor
modules = [x.name for x in graph]
cursor.execute(*ir_module.select(
ir_module.name, ir_module.state, where=ir_module.name.in_(modules)))
module2state = dict(cursor.fetchall())
for package in graph:
module = package.name
if module not in MODULES:
continue
logger.info(module)
classes = pool.setup(module)
package_state = module2state.get(module, 'uninstalled')
if (is_module_to_install(module, update)
or package_state in ('to install', 'to upgrade')):
if package_state not in ('to install', 'to upgrade'):
if package_state == 'installed':
package_state = 'to upgrade'
elif package_state != 'to remove':
package_state = 'to install'
for child in package.childs:
module2state[child.name] = package_state
for type in classes.keys():
for cls in classes[type]:
logger.info('%s:register %s', module, cls.__name__)
cls.__register__(module)
for model in classes['model']:
if hasattr(model, '_history'):
models_to_update_history.add(model.__name__)
# Instanciate a new parser for the package:
tryton_parser = convert.TrytondXmlHandler(
pool=pool, module=module, module_state=package_state)
for filename in package.info.get('xml', []):
filename = filename.replace('/', os.sep)
logger.info('%s:loading %s', module, filename)
# Feed the parser with xml content:
with tools.file_open(OPJ(module, filename)) as fp:
tryton_parser.parse_xmlstream(fp)
modules_todo.append((module, list(tryton_parser.to_delete)))
for filename in iglob('%s/%s/*.po' %
(package.info['directory'], 'locale')):
filename = filename.replace('/', os.sep)
lang2 = os.path.splitext(os.path.basename(filename))[0]
if lang2 not in lang:
continue
logger.info('%s:loading %s', module,
filename[len(package.info['directory']) + 1:])
Translation = pool.get('ir.translation')
Translation.translation_import(lang2, module, filename)
if package_state == 'to remove':
continue
cursor.execute(*ir_module.select(
ir_module.id, where=(ir_module.name == package.name)))
try:
module_id, = cursor.fetchone()
cursor.execute(
*ir_module.update([ir_module.state], ['installed'],
where=(ir_module.id == module_id)))
except TypeError:
cursor.execute(*ir_module.insert([
ir_module.create_uid, ir_module.create_date,
ir_module.name, ir_module.state
], [[0, Now(), package.name, 'installed']]))
module2state[package.name] = 'installed'
cursor.commit()
for model_name in models_to_update_history:
model = pool.get(model_name)
if model._history:
logger.info('history:update %s', model.__name__)
model._update_history_table()
# Vacuum :
while modules_todo:
(module, to_delete) = modules_todo.pop()
convert.post_import(pool, module, to_delete)
cursor.commit()