def __register__(cls, module_name):
TableHandler = backend.get('TableHandler')
cursor = Transaction().connection.cursor()
super(Attachment, cls).__register__(module_name)
table = TableHandler(cls, module_name)
attachment = cls.__table__()
# Migration from 1.4 res_model and res_id merged into resource
# Reference
if table.column_exist('res_model') and \
table.column_exist('res_id'):
table.drop_constraint('res_model_res_id_name')
cursor.execute(*attachment.update(
[attachment.resource],
[Concat(Concat(attachment.resource, ','), attachment.res_id)]))
table.drop_column('res_model')
table.drop_column('res_id')
# Migration from 4.0: merge digest and collision into file_id
if table.column_exist('digest') and table.column_exist('collision'):
cursor.execute(
*attachment.update([attachment.file_id], [attachment.digest],
where=(attachment.collision == 0)
| (attachment.collision == Null)))
cursor.execute(*attachment.update(
[attachment.file_id],
[Concat(Concat(attachment.digest, '-'), attachment.collision)],
where=(attachment.collision != 0)
& (attachment.collision != Null)))
table.drop_column('digest')
table.drop_column('collision')
def _get_translation_join(self, Model, name, translation, model, table,
from_, language):
if Model.__name__ == 'ir.model':
return from_.join(translation,
'LEFT',
condition=(translation.name == Concat(
Concat(table.model, ','), name))
& (translation.res_id == -1)
& (translation.lang == language)
& (translation.type == 'model')
& (translation.fuzzy == False))
elif Model.__name__ == 'ir.model.field':
if name == 'field_description':
type_ = 'field'
else:
type_ = 'help'
return from_.join(model, 'LEFT',
condition=model.id == table.model).join(
translation,
'LEFT',
condition=(translation.name == Concat(
Concat(model.model, ','), table.name))
& (translation.res_id == -1)
& (translation.lang == language)
& (translation.type == type_)
& (translation.fuzzy == False))
else:
return from_.join(translation,
'LEFT',
condition=(translation.res_id == table.id)
& (translation.name == '%s,%s' %
(Model.__name__, name))
& (translation.lang == language)
& (translation.type == 'model')
& (translation.fuzzy == False))
def __register__(cls, module_name):
pool = Pool()
Move = pool.get('stock.move')
PurchaseLine = pool.get('purchase.line')
Purchase = pool.get('purchase.purchase')
cursor = Transaction().connection.cursor()
sql_table = cls.__table__()
move = Move.__table__()
line = PurchaseLine.__table__()
purchase = Purchase.__table__()
# Migration from 3.8: New supplier field
cursor.execute(*sql_table.select(
sql_table.supplier, where=sql_table.supplier == Null, limit=1))
if cursor.fetchone():
value = sql_table.join(
move,
condition=(Concat(
cls.__name__ + ',', sql_table.id) == move.shipment)).join(
line,
condition=(Concat(
PurchaseLine.__name__ + ',',
line.id) == move.origin)).join(
purchase,
condition=(
purchase.id == line.purchase)).select(
Max(purchase.party))
cursor.execute(*sql_table.update(columns=[sql_table.supplier],
values=[value]))
super(ShipmentInReturn, cls).__register__(module_name)
def __register__(cls, module_name):
pool = Pool()
ModelData = pool.get('ir.model.data')
model_data = ModelData.__table__()
cursor = Transaction().connection.cursor()
super(User, cls).__register__(module_name)
table = cls.__table_handler__(module_name)
# Migration from 3.0
if table.column_exist('password') and table.column_exist('salt'):
sqltable = cls.__table__()
password_hash_new = Concat(
'sha1$',
Concat(sqltable.password,
Concat('$', Coalesce(sqltable.salt, ''))))
cursor.execute(*sqltable.update(columns=[sqltable.password_hash],
values=[password_hash_new]))
table.drop_column('password')
table.drop_column('salt')
# Migration from 4.2: Remove required on name
table.not_null_action('name', action='remove')
# Migration from 5.6: Set noupdate to admin
cursor.execute(
*model_data.update([model_data.noupdate], [True],
where=(model_data.model == cls.__name__)
& (model_data.module == 'res')
& (model_data.fs_id == 'user_admin')))
def __register__(cls, module_name):
cursor = Transaction().connection.cursor()
super(Attachment, cls).__register__(module_name)
table = cls.__table_handler__(module_name)
attachment = cls.__table__()
# Migration from 4.0: merge digest and collision into file_id
if table.column_exist('digest') and table.column_exist('collision'):
cursor.execute(*attachment.update(
[attachment.file_id],
[attachment.digest],
where=(attachment.collision == 0)
| (attachment.collision == Null)))
cursor.execute(*attachment.update(
[attachment.file_id],
[Concat(Concat(attachment.digest, '-'),
attachment.collision)],
where=(attachment.collision != 0)
& (attachment.collision != Null)))
table.drop_column('digest')
table.drop_column('collision')
# Migration from 4.8: remove unique constraint
table.drop_constraint('resource_name')
def __register__(cls, module_name):
pool = Pool()
Move = pool.get('stock.move')
PurchaseLine = pool.get('purchase.line')
PurchaseRequest = pool.get('purchase.request')
SaleLine = pool.get('sale.line')
Location = pool.get('stock.location')
move = Move.__table__()
purchase_line = PurchaseLine.__table__()
purchase_request = PurchaseRequest.__table__()
sale_line = SaleLine.__table__()
location = Location.__table__()
cursor = Transaction().cursor
super(ShipmentDrop, cls).__register__(module_name)
# Migration from 3.6
cursor.execute(*location.select(Count(location.id),
where=(location.type == 'drop')))
has_drop_shipment, = cursor.fetchone()
if not has_drop_shipment:
drop_shipment = Location(name='Migration Drop Shipment',
type='drop', active=False)
drop_shipment.save()
drop_shipment_location = drop_shipment.id
move_sale_query = move.join(purchase_line,
condition=move.origin == Concat('purchase.line,',
purchase_line.id)
).join(purchase_request,
condition=purchase_request.purchase_line == purchase_line.id
).join(sale_line,
condition=sale_line.purchase_request == purchase_request.id
).select(
move.id, move.to_location, sale_line.id,
where=move.shipment.like('stock.shipment.drop,%'))
cursor.execute(*move_sale_query)
move_sales = cursor.fetchall()
for sub_move in grouped_slice(move_sales):
sub_ids = [s[0] for s in sub_move]
cursor.execute(*move.update(
columns=[move.to_location],
values=[drop_shipment_location],
where=move.id.in_(sub_ids)))
create_move = move.insert(values=move.select(
where=move.shipment.like('stock.shipment.drop,%')))
cursor.execute(*create_move)
for move_id, customer_location, line_id in move_sales:
cursor.execute(move.update(
columns=[move.origin, move.from_location,
move.to_location],
values=[Concat('sale.line,', str(line_id)),
drop_shipment_location, customer_location],
where=(move.id == move_id)))
def __register__(cls, module_name):
cursor = Transaction().connection.cursor()
sql_table = cls.__table__()
super(Address, cls).__register__(module_name)
table = cls.__table_handler__(module_name)
# Migration from 4.0: remove streetbis
if table.column_exist('streetbis'):
value = Concat(Coalesce(sql_table.street, ''),
Concat('\n', Coalesce(sql_table.streetbis, '')))
cursor.execute(*sql_table.update([sql_table.street], [value]))
table.drop_column('streetbis')
def get_lines_to_pay(cls, invoices, name):
pool = Pool()
Move = pool.get('account.move')
Line = pool.get('account.move.line')
Account = pool.get('account.account')
line = Line.__table__()
account = Account.__table__()
move = Move.__table__()
invoice = cls.__table__()
cursor = Transaction().connection.cursor()
_, origin_type = Move.origin.sql_type()
lines = super(Invoice, cls).get_lines_to_pay(invoices, name)
for sub_ids in grouped_slice(invoices):
red_sql = reduce_ids(invoice.id, sub_ids)
query = invoice.join(move,
condition=((move.origin == Concat('account.invoice,',
Cast(invoice.id, origin_type))))
).join(line, condition=(line.move == move.id)
).join(account, condition=(
(line.account == account.id) &
Case((invoice.type == 'out',
account.kind == 'receivable'),
else_=account.kind == 'payable'))).select(
invoice.id, line.id,
where=(line.maturity_date != None) & red_sql,
order_by=(invoice.id, line.maturity_date))
cursor.execute(*query)
for invoice_id, line_id in cursor.fetchall():
if line_id not in lines[invoice_id]:
lines[invoice_id].append(line_id)
return lines
def format_full_text(self, *documents, language=None):
size = max(len(documents) // 4, 1)
if len(documents) > 1:
weights = chain(
['A'] * size, ['B'] * size, ['C'] * size, repeat('D'))
else:
weights = [None]
expression = None
if language:
config_name = self._search_full_text_language(language)
else:
config_name = None
for document, weight in zip(documents, weights):
if not document:
continue
if config_name:
ts_vector = ToTsvector(config_name, document)
else:
ts_vector = ToTsvector('simple', document)
if weight:
ts_vector = Setweight(ts_vector, weight)
if expression is None:
expression = ts_vector
else:
expression = Concat(expression, ts_vector)
return expression
def __register__(cls, module_name):
pool = Pool()
Model = pool.get('ir.model')
Trigger = pool.get('ir.trigger')
model = Model.__table__()
trigger = Trigger.__table__()
table = cls.__table__()
super().__register__(module_name)
table_h = cls.__table_handler__(module_name)
cursor = Transaction().connection.cursor()
# Migration from 5.6:
# fill notification and resource
# remove required on trigger
notification = trigger.select(trigger.notification_email,
where=trigger.id == table.trigger)
resource = (trigger.join(model,
condition=trigger.model == model.id).select(
Concat(model.model, ',-1'),
where=trigger.id == table.trigger))
cursor.execute(*table.update(
[table.notification, table.resource], [notification, resource],
where=(table.trigger != Null) & (table.resource == Null)))
table_h.not_null_action('trigger', 'remove')
def __register__(cls, module_name):
pool = Pool()
StatementLine = pool.get('account.statement.line')
cursor = Transaction().cursor
sql_table = cls.__table__()
super(Move, cls).__register__(module_name)
# Migration from 3.4:
# account.statement.line origin changed to account.statement
statement_line = StatementLine.__table__()
cursor.execute(*sql_table.join(statement_line,
condition=(
Concat(StatementLine.__name__ + ',', statement_line.id)
== sql_table.origin
)
).select(sql_table.id, statement_line.statement,
order_by=(sql_table.id, statement_line.statement)))
for statement_id, values in groupby(cursor.fetchall(), itemgetter(1)):
ids = [x[0] for x in values]
for sub_ids in grouped_slice(ids):
red_sql = reduce_ids(sql_table.id, sub_ids)
cursor.execute(*sql_table.update(
columns=[sql_table.origin],
values=['account.statement,%s' % statement_id],
where=red_sql))
def __register__(cls, module_name):
TableHandler = backend.get('TableHandler')
cursor = Transaction().connection.cursor()
table = TableHandler(cls, module_name)
sql_table = cls.__table__()
super(Address, cls).__register__(module_name)
# Migration from 2.4: drop required on sequence
table.not_null_action('sequence', action='remove')
# Migration from 4.0: remove streetbis
if table.column_exist('streetbis'):
value = Concat(Coalesce(sql_table.street, ''),
Concat('\n', Coalesce(sql_table.streetbis, '')))
cursor.execute(*sql_table.update([sql_table.street], [value]))
table.drop_column('streetbis')
def __register__(cls, module_name):
cursor = Transaction().connection.cursor()
super(User, cls).__register__(module_name)
table = cls.__table_handler__(module_name)
# Migration from 3.0
if table.column_exist('password') and table.column_exist('salt'):
sqltable = cls.__table__()
password_hash_new = Concat('sha1$', Concat(sqltable.password,
Concat('$', Coalesce(sqltable.salt, ''))))
cursor.execute(*sqltable.update(
columns=[sqltable.password_hash],
values=[password_hash_new]))
table.drop_column('password')
table.drop_column('salt')
# Migration from 4.2: Remove required on name
table.not_null_action('name', action='remove')
def order_rec_name(cls, tables):
exemplary, _ = tables[None]
book = tables.get('book')
if book is None:
book = Pool().get('library.book').__table__()
tables['book'] = {None: (book, book.id == exemplary.book)}
return [Concat(book.title, exemplary.identifier)]
def _purchase_cost(cls, works):
'Compute direct purchase cost'
pool = Pool()
Currency = pool.get('currency.currency')
PurchaseLine = pool.get('purchase.line')
InvoiceLine = pool.get('account.invoice.line')
Invoice = pool.get('account.invoice')
Company = pool.get('company.company')
cursor = Transaction().connection.cursor()
table = cls.__table__()
purchase_line = PurchaseLine.__table__()
invoice_line = InvoiceLine.__table__()
invoice = Invoice.__table__()
company = Company.__table__()
amounts = defaultdict(Decimal)
work_ids = [w.id for w in works]
work2currency = {}
iline2work = {}
for sub_ids in grouped_slice(work_ids):
where = reduce_ids(table.id, sub_ids)
cursor.execute(*table.join(purchase_line,
condition=purchase_line.work == table.id
).join(invoice_line,
condition=invoice_line.origin == Concat(
'purchase.line,', purchase_line.id)
).join(invoice,
condition=invoice_line.invoice == invoice.id
).select(invoice_line.id, table.id,
where=where & ~invoice.state.in_(['draft', 'cancel'])))
iline2work.update(cursor.fetchall())
cursor.execute(*table.join(company,
condition=table.company == company.id
).select(table.id, company.currency,
where=where))
work2currency.update(cursor.fetchall())
currencies = Currency.browse(set(work2currency.values()))
id2currency = {c.id: c for c in currencies}
invoice_lines = InvoiceLine.browse(list(iline2work.keys()))
for invoice_line in invoice_lines:
invoice = invoice_line.invoice
work_id = iline2work[invoice_line.id]
currency_id = work2currency[work_id]
currency = id2currency[currency_id]
if currency != invoice.currency:
with Transaction().set_context(date=invoice.currency_date):
amount = Currency.compute(invoice.currency,
invoice_line.amount, currency)
else:
amount = invoice_line.amount
amounts[work_id] += amount
return amounts
def __register__(cls, module_name):
TableHandler = backend.get('TableHandler')
cursor = Transaction().cursor
super(Attachment, cls).__register__(module_name)
table = TableHandler(cursor, cls, module_name)
attachment = cls.__table__()
# Migration from 1.4 res_model and res_id merged into resource
# Reference
if table.column_exist('res_model') and \
table.column_exist('res_id'):
table.drop_constraint('res_model_res_id_name')
cursor.execute(*attachment.update(
[attachment.resource],
[Concat(Concat(attachment.resource, ','), attachment.res_id)]))
table.drop_column('res_model')
table.drop_column('res_id')
def __register__(cls, module_name):
TableHandler = backend.get('TableHandler')
cursor = Transaction().connection.cursor()
super(User, cls).__register__(module_name)
table = TableHandler(cls, module_name)
# Migration from 1.6
# For module dashboard
table.module_name = 'dashboard'
table.not_null_action('dashboard_layout', action='remove')
# For module calendar_scheduling
table.module_name = 'calendar_scheduling'
for field in (
'calendar_email_notification_new',
'calendar_email_notification_update',
'calendar_email_notification_cancel',
'calendar_email_notification_partstat',
):
table.not_null_action(field, action='remove')
# Migration from 2.2
table.not_null_action('menu', action='remove')
# Migration from 2.6
table.drop_column('login_try')
# Migration from 3.0
if table.column_exist('password') and table.column_exist('salt'):
sqltable = cls.__table__()
password_hash_new = Concat(
'sha1$',
Concat(sqltable.password,
Concat('$', Coalesce(sqltable.salt, ''))))
cursor.execute(*sqltable.update(columns=[sqltable.password_hash],
values=[password_hash_new]))
table.drop_column('password')
table.drop_column('salt')
# Migration from 4.2: Remove required on name
table.not_null_action('name', action='remove')
def __register__(cls, module):
table = cls.__table__()
super().__register__(module)
table_h = cls.__table_handler__(module)
cursor = Transaction().connection.cursor()
if table_h.column_exist('invoice'):
cursor.execute(*table.update(
[table.related_to],
[Concat('account.invoice,', table.invoice)],
where=table.invoice != Null))
table_h.drop_column('invoice')
def _get_invoiced_amount_timesheet(cls, works):
pool = Pool()
TimesheetWork = pool.get('timesheet.work')
TimesheetLine = pool.get('timesheet.line')
InvoiceLine = pool.get('account.invoice.line')
Company = pool.get('company.company')
Currency = pool.get('currency.currency')
cursor = Transaction().connection.cursor()
table = cls.__table__()
timesheet_work = TimesheetWork.__table__()
timesheet_line = TimesheetLine.__table__()
invoice_line = InvoiceLine.__table__()
company = Company.__table__()
amounts = {}
work2currency = {}
work_ids = [w.id for w in works]
for sub_ids in grouped_slice(work_ids):
where = reduce_ids(table.id, sub_ids)
cursor.execute(*table.join(timesheet_work,
condition=(
Concat(cls.__name__ + ',', table.id)
== timesheet_work.origin)
).join(timesheet_line,
condition=timesheet_line.work == timesheet_work.id
).join(invoice_line,
condition=timesheet_line.invoice_line == invoice_line.id
).select(table.id,
Sum(timesheet_line.duration * invoice_line.unit_price),
where=where,
group_by=table.id))
amounts.update(cursor.fetchall())
cursor.execute(*table.join(company,
condition=table.company == company.id
).select(table.id, company.currency,
where=where))
work2currency.update(cursor.fetchall())
currencies = Currency.browse(set(work2currency.itervalues()))
id2currency = {c.id: c for c in currencies}
for work in works:
currency = id2currency[work2currency[work.id]]
amount = amounts.get(work.id, 0)
if isinstance(amount, datetime.timedelta):
amount = amount.total_seconds()
amount = amount / 60 / 60
amounts[work.id] = currency.round(Decimal(str(amount)))
return amounts
def __register__(cls, module_name):
pool = Pool()
ModelData = pool.get('ir.model.data')
cursor = Transaction().cursor
model_data = ModelData.__table__()
# Migration from 3.4: translation of the account chart
cursor.execute(
*model_data.update(columns=[model_data.fs_id],
values=[Concat(model_data.fs_id, '_fr')],
where=((Position('_fr', model_data.fs_id) == 0)
& (model_data.module == 'account_be'))))
super(AccountTemplate, cls).__register__(module_name)
def __register__(cls, module_name):
cursor = Transaction().connection.cursor()
table = cls.__table_handler__(cls, module_name)
sql_table = cls.__table__()
super(Trigger, cls).__register__(module_name)
table_h = cls.__table_handler__(module_name)
# Migration from 3.4:
# change minimum_delay into timedelta minimum_time_delay
if table.column_exist('minimum_delay'):
cursor.execute(*sql_table.select(
sql_table.id, sql_table.minimum_delay,
where=sql_table.minimum_delay != Null))
for id_, delay in cursor:
delay = datetime.timedelta(hours=delay)
cursor.execute(*sql_table.update(
[sql_table.minimum_time_delay],
[delay],
where=sql_table.id == id_))
table.drop_column('minimum_delay')
# Migration from 5.4: merge action
if (table_h.column_exist('action_model')
and table_h.column_exist('action_function')):
pool = Pool()
Model = pool.get('ir.model')
model = Model.__table__()
action_model = model.select(
model.model, where=model.id == sql_table.action_model)
cursor.execute(*sql_table.update(
[sql_table.action],
[Concat(action_model, Concat(
'|', sql_table.action_function))]))
table_h.drop_column('action_model')
table_h.drop_column('action_function')
def __register__(cls, module_name):
TableHandler = backend.get('TableHandler')
cursor = Transaction().cursor
sql_table = cls.__table__()
super(Move, cls).__register__(module_name)
table = TableHandler(cursor, cls, module_name)
# Migration from 2.6: remove purchase_line
if table.column_exist('purchase_line'):
cursor.execute(*sql_table.update(
columns=[sql_table.origin],
values=[Concat('purchase.line,', sql_table.purchase_line)],
where=sql_table.purchase_line != Null))
table.drop_column('purchase_line')
def __register__(cls, module):
pool = Pool()
Party = pool.get('party.party')
Identifier = pool.get('party.identifier')
cursor = Transaction().connection.cursor()
party = Party.__table__()
address = cls.__table__()
identifier = Identifier.__table__()
super().__register__(module)
table_h = cls.__table_handler__(module)
party_h = Party.__table_handler__(module)
# Migrate from 6.2: replace siren and siret by identifier
if party_h.column_exist('siren'):
cursor.execute(
*identifier.insert([
identifier.party, identifier.type, identifier.code,
identifier.active
],
party.select(party.id,
Literal('fr_siren'),
party.siren,
party.active,
where=(party.siren != Null)
& (party.siren != ''))))
if table_h.column_exist('siret_nic'):
cursor.execute(*identifier.insert(
[
identifier.party, identifier.address, identifier.type,
identifier.code, identifier.active
],
address.join(party, condition=address.party == party.id).
select(address.party,
address.id,
Literal('fr_siret'),
Concat(party.siren, address.siret_nic),
address.active,
where=(address.siret_nic != Null)
& (address.siret_nic != '')
& (party.siren != Null)
& (party.siren != ''))))
table_h.drop_column('siret_nic')
party_h.drop_column('siren')
def clean_properties_from_4_2(cls):
from sql import Null, Table, Cast
from sql.operators import Like, Concat
TableHandler = backend.get('TableHandler')
if not TableHandler.table_exist('ir_property'):
return
property = Table('ir_property')
cursor = Transaction().connection.cursor()
cursor.execute(
*property.select(property.res, where=property.res != Null))
res_model_names = list(
set([x[0].split(',')[0] for x in cursor.fetchall()]))
to_delete = {}
for res_model_name in res_model_names:
table_name = res_model_name.replace('.', '_')
res_model = Table(table_name)
query_table = property.join(res_model,
'LEFT OUTER',
condition=(property.res == Concat(
res_model_name + ',',
Cast(res_model.id, 'VARCHAR'))))
cursor.execute(
*query_table.select(property.id,
where=Like(property.res, res_model_name +
',%') & (res_model.id == Null)))
property_ids = [x[0] for x in cursor.fetchall()]
if property_ids:
to_delete[res_model_name] = property_ids
if to_delete:
cursor.execute(*property.delete(
where=property.id.in_(sum([p
for p in to_delete.values()], []))))
for res_model_name, property_ids in to_delete.items():
if property_ids:
print '[%s] - %s Inconsistent record(s) removed' % (
res_model_name, len(property_ids))
else:
print 'Nothing to do - Exisiting property records are clean'
def _get_cost(cls, works):
pool = Pool()
Line = pool.get('timesheet.line')
Work = pool.get('timesheet.work')
transaction = Transaction()
cursor = transaction.connection.cursor()
costs = dict.fromkeys([w.id for w in works], 0)
table = cls.__table__()
work = Work.__table__()
line = Line.__table__()
# Timesheet cost
work_ids = [w.id for w in works]
for sub_ids in grouped_slice(work_ids):
red_sql = reduce_ids(table.id, sub_ids)
cursor.execute(
*table.join(work,
condition=(Concat(cls.__name__ +
',', table.id) == work.origin)).
join(line, condition=line.work == work.id).select(
table.id,
Sum(line.cost_price * line.duration),
where=red_sql,
group_by=[table.id]))
for work_id, cost in cursor:
# SQLite stores timedelta as float
if not isinstance(cost, float):
cost = cost.total_seconds()
# Convert from seconds
cost /= 60 * 60
costs[work_id] += Decimal(str(cost))
# Purchase cost
if hasattr(cls, 'purchase_lines'):
for work_id, cost in cls._purchase_cost(works).items():
costs[work_id] += cost
for work in works:
costs[work.id] = work.company.currency.round(costs[work.id])
return costs
def restore_default_party_lang_from_4_2(cls):
from trytond.transaction import Transaction
from sql import Null, Table, Cast
from sql.operators import Concat
from trytond.pool import Pool
TableHandler = backend.get('TableHandler')
if not TableHandler.table_exist('ir_property'):
return
pool = Pool()
property = Table('ir_property')
Lang = pool.get('ir.lang')
field = pool.get('ir.model.field').__table__()
lang = Lang.__table__()
cursor = Transaction().connection.cursor()
query_table = property.join(
lang,
condition=(property.value == Concat(
'ir.lang,',
Cast(lang.id,
'VARCHAR')))).join(field,
condition=((property.field == field.id)
& (field.name == 'lang')))
cursor.execute(
*query_table.select(lang.id, where=property.res == Null))
result = cursor.fetchone()
if result:
result = list(result)
default_lang = Lang(result[0])
print 'Default Language restored [%s]' % default_lang.rec_name
pool.get('party.configuration.party_lang').create([{
'party_lang':
default_lang
}])
else:
print 'No default language on party configuration found'
def _sale_line(cls, length, index, company_id=None):
pool = Pool()
Line = pool.get('sale.line')
Sale = pool.get('sale.sale')
line = Line.__table__()
sale = Sale.__table__()
return (line.join(sale, condition=line.sale == sale.id).select(
(line.id * length + index).as_('id'),
line.product.as_('product'),
Coalesce(line.actual_quantity, line.quantity).as_('quantity'),
line.unit_price.as_('unit_price'),
Concat('sale.sale,', line.sale).as_('order'),
sale.sale_date.as_('date'),
sale.company.as_('company'),
sale.currency.as_('currency'),
sale.party.as_('customer'),
sale.warehouse.as_('location'),
sale.shipment_address.as_('shipment_address'),
where=sale.state.in_(cls._sale_states())
& (sale.company == company_id),
))
sel = join2.select(t.id.as_('id'))
sel.where = And((t3.code == 34,))
expect(tuple(sql)).to(equal(tuple(sel)))
with it('must support group by'):
q = OOQuery('table')
sel = q.select([Max('field1')], group_by=['field2'])
sel2 = q.table.select(
Max(q.table.field1).as_('max_field1'),
group_by=[q.table.field2]
)
expect(str(sel._select)).to(equal(str(sel2)))
with it('must support concat'):
q = OOQuery('table')
sel = q.select([Concat('field1', Literal(' 01:00'))])
sel2 = q.table.select(Concat(q.table.field1, ' 01:00'))
expect(str(sel._select)).to(equal(str(sel2)))
with it('must support coalesce'):
q = OOQuery('table')
sel = q.select([Coalesce('field1', Literal(3))])
sel2 = q.table.select(Coalesce(q.table.field1, 3))
expect(str(sel._select)).to(equal(str(sel2)))
with it('must support greatest'):
q = OOQuery('table')
sel = q.select([Greatest('field1', 'field2')])
sel2 = q.table.select(Greatest(q.table.field1, q.table.field2))
expect(str(sel._select)).to(equal(str(sel2)))
def _measurements_move_condition(cls, table, move):
return Concat(cls.__name__ + ',', table.id) == move.shipment
def __register__(cls, module_name):
Party = Pool().get('party.party')
Model = Pool().get('ir.model')
ModelField = Pool().get('ir.model.field')
Property = Pool().get('ir.property')
PaymentProfile = Pool().get('party.payment_profile')
TableHandler = backend.get('TableHandler')
cursor = Transaction().cursor
table = TableHandler(cursor, cls, module_name)
migration_needed = False
if not table.column_exist('credit_account'):
migration_needed = True
migrate_last_four_digits = False
if not table.column_exist('last_four_digits'):
migrate_last_four_digits = True
super(PaymentTransaction, cls).__register__(module_name)
if migration_needed and not Pool.test:
# Migration
# Set party's receivable account as the credit_account on
# transactions
transaction = cls.__table__()
party = Party.__table__()
property = Property.__table__()
account_model, = Model.search([
('model', '=', 'party.party'),
])
account_receivable_field, = ModelField.search([
('model', '=', account_model.id),
('name', '=', 'account_receivable'),
('ttype', '=', 'many2one'),
])
update = transaction.update(
columns=[transaction.credit_account],
values=[
Trim(
Substring(property.value, ',.*'), 'LEADING', ','
).cast(cls.credit_account.sql_type().base)
],
from_=[party, property],
where=(
transaction.party == party.id
) & (
property.res == Concat(Party.__name__ + ',', party.id)
) & (
property.field == account_receivable_field.id
) & (
property.company == transaction.company
)
)
cursor.execute(*update)
if migrate_last_four_digits and not Pool.test:
transaction = cls.__table__()
payment_profile = PaymentProfile.__table__()
cursor.execute(*transaction.update(
columns=[transaction.last_four_digits],
values=[payment_profile.last_4_digits],
from_=[payment_profile],
where=(transaction.payment_profile == payment_profile.id)
))
