def set(cls, menu_id):
user = Transaction().user
cls.create([{
'menu': menu_id,
'user': user,
}])
def transition_import_icd10(self):
pool = Pool()
Group = pool.get('galeno.disease.group')
Category = pool.get('galeno.disease.category')
Disease = pool.get('galeno.disease')
Procedure = pool.get('galeno.procedure')
cursor = Transaction().connection.cursor()
lang = self.start.language.code
path = 'galeno_base_data/data/diseases/groups_' + lang + '.csv'
with file_open(path, mode='r', encoding='utf-8') as group_file:
fieldnames = ['code', 'name', 'description', 'information']
reader = csv.DictReader(group_file,
delimiter='|',
fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
group = Group()
for field in row:
if row[field] == '':
value = None
else:
value = row[field]
setattr(group, field, value)
group.core = True
group.save()
path = 'galeno_base_data/data/diseases/categories_' + lang + '.csv'
with file_open(path, mode='r', encoding='utf-8') as category_file:
fieldnames = ['code', 'name', 'parent']
reader = csv.DictReader(category_file,
delimiter='|',
fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
if row['parent'] != '':
parent, = Category.search([('code', '=', row['parent'])])
else:
parent = None
category = Category()
category.code = row['code']
category.name = row['name']
category.parent = parent
category.core = True
category.save()
groups = {}
categories = {}
for group in Group.search([]):
groups[group.code] = group
for category in Category.search([]):
categories[category.code] = category
to_save = []
path = 'galeno_base_data/data/diseases/diseases_' + lang + '.csv'
with file_open(path, mode='r', encoding='utf-8') as disease_file:
fieldnames = [
'code', 'name', 'category', 'groups', 'chromosome', 'protein',
'gene', 'information', 'active'
]
reader = csv.DictReader(disease_file,
delimiter='|',
fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
disease = Disease()
for field in row:
if row[field] == '':
value = None
else:
if field == 'active':
value = bool(row[field])
elif field == 'category':
value = categories[row[field]]
elif field == 'groups':
value = []
for group_code in row[field].split(','):
value.append(groups[group_code].id)
else:
value = row[field]
setattr(disease, field, value)
disease.core = True
to_save.append(disease)
Disease.save(to_save)
table = Procedure.__table__()
columns = [table.code, table.name, table.core]
values = []
path = 'galeno_base_data/data/procedures/procedures_' + lang + '.csv'
with file_open(path, mode='r', encoding='utf-8') as procedure_file:
fieldnames = ['code', 'name']
reader = csv.DictReader(procedure_file,
delimiter='|',
fieldnames=fieldnames)
next(reader) # Skip header
for row in reader:
record = []
for field in row:
if row[field] == '':
value = None
else:
value = row[field]
record.append(value)
record.append(True)
values.append(record)
cursor.execute(*table.insert(columns, values))
Procedure.save(to_save)
return 'succeed'
def close(cls, periods):
pool = Pool()
Product = pool.get('product.product')
Location = pool.get('stock.location')
Move = pool.get('stock.move')
Date = pool.get('ir.date')
transaction = Transaction()
connection = transaction.connection
database = transaction.database
# XXX: A move in the period could be inserted before the lock
# from a different transaction. It will not be taken in the pbl
# computation but it is quite rare because only past periods are
# closed.
database.lock(connection, Move._table)
if database.has_select_for():
move = Move.__table__()
query = move.select(Literal(1), for_=For('UPDATE', nowait=True))
with connection.cursor() as cursor:
cursor.execute(*query)
locations = Location.search([
('type', 'not in', ['warehouse', 'view']),
],
order=[])
today = Date.today()
recent_date = max(period.date for period in periods)
if recent_date >= today:
raise PeriodCloseError(gettext('stock.msg_period_close_date'))
if Move.search([('state', '=', 'assigned'),
[
'OR',
[
('effective_date', '=', None),
('planned_date', '<=', recent_date),
],
('effective_date', '<=', recent_date),
]]):
raise PeriodCloseError(
gettext('stock.msg_period_close_assigned_move'))
for grouping in cls.groupings():
Cache = cls.get_cache(grouping)
to_create = []
for period in periods:
with Transaction().set_context(
stock_date_end=period.date,
stock_date_start=None,
stock_assign=False,
forecast=False,
stock_destinations=None,
):
pbl = Product.products_by_location(
[l.id for l in locations], grouping=grouping)
for key, quantity in pbl.items():
values = {
'location': key[0],
'period': period.id,
'internal_quantity': quantity,
}
for i, field in enumerate(grouping, 1):
values[field] = key[i]
to_create.append(values)
if to_create:
Cache.create(to_create)
def transition_recall(self):
pool = Pool()
Invoice = pool.get('account.invoice')
invoice = Invoice(Transaction().context['active_id'])
invoice.call_deposit(self.start.account, self.start.description)
return 'end'
def __register__(cls, module_name):
# Upgrade to release 3.0
# Move existing ICU EGC records to the generic gnuhealth.patient.ecg
# model
super(ECG, cls).__register__(module_name)
cursor = Transaction().cursor
TableHandler = backend.get('TableHandler')
if TableHandler.table_exist(cursor, 'gnuhealth_icu_ecg'):
table = TableHandler(cursor, cls, module_name)
# Retrieve IDs from ECGs at ICU
cursor.execute('select id,name from gnuhealth_icu_ecg')
icu_ecg_ids = cursor.fetchall()
# Traverse each record on the icu_ecg table
for icu_ecg in icu_ecg_ids:
registration = str(icu_ecg[1])
# Get the patient ID related to the registration
cursor.execute(
'select patient FROM \
gnuhealth_inpatient_registration \
where id = %s', registration)
patient_id = cursor.fetchone()
cursor.execute(
'select name, ecg_date, lead, axis, rate,\
rhythm, pacemaker, pr, qrs, qt, st_segment, twave_inversion, \
interpretation, ecg_strip FROM gnuhealth_icu_ecg where \
name = %s and id = %s', (registration, icu_ecg[0]))
ecg = cursor.fetchone()
(name, ecg_date, lead, axis, rate, rhythm, \
pacemaker, pr, qrs, qt, st_segment, twave_inversion, \
interpretation, ecg_strip) = ecg
# Insert the values on the new ECG table
cursor.execute('insert into gnuhealth_patient_ecg \
(name, inpatient_registration_code, ecg_date, lead, axis, \
rate,rhythm,pacemaker, pr, qrs, qt, st_segment, \
twave_inversion, interpretation, ecg_strip) \
VALUES (%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s,%s)' ,
(patient_id, registration, ecg_date, lead, axis, rate, \
rhythm, pacemaker, pr, qrs, qt, st_segment, \
twave_inversion, interpretation, ecg_strip))
# Rename obsolete table gnuhealth_icu_ecg
# Once we know everything is OK we can drop it
cursor.execute('alter table gnuhealth_icu_ecg rename \
to old_icu_ecg')
def test0030create_moves(self):
'Test create_moves'
with Transaction().start(DB_NAME, USER, context=CONTEXT):
category, = self.category.create([{
'name': 'Test create_moves',
}])
unit, = self.uom.search([('name', '=', 'Unit')])
template, = self.template.create([{
'name': 'Test create_moves',
'type': 'goods',
'category': category.id,
'cost_price_method': 'fixed',
'default_uom': unit.id,
'list_price': Decimal('1'),
'cost_price': Decimal(0),
}])
product, = self.product.create([{
'template': template.id,
}])
customer, = self.location.search([('code', '=', 'CUS')])
warehouse, = self.location.search([('code', '=', 'WH')])
storage, = self.location.search([('code', '=', 'STO')])
company, = self.company.search([
('rec_name', '=', 'Dunder Mifflin'),
])
self.user.write([self.user(USER)], {
'main_company': company.id,
'company': company.id,
})
today = datetime.date.today()
forecast, = self.forecast.create([{
'warehouse':
warehouse.id,
'destination':
customer.id,
'from_date':
today + relativedelta(months=1, day=1),
'to_date':
today + relativedelta(months=1, day=20),
'company':
company.id,
'lines': [
(
'create',
[{
'product': product.id,
'quantity': 10,
'uom': unit.id,
'minimal_quantity': 2,
}],
),
],
}])
self.forecast.confirm([forecast])
self.forecast.create_moves([forecast])
line, = forecast.lines
self.assertEqual(line.quantity_executed, 0)
self.assertEqual(len(line.moves), 5)
self.assertEqual(sum(move.quantity for move in line.moves), 10)
self.forecast.delete_moves([forecast])
line, = forecast.lines
self.assertEqual(len(line.moves), 0)
self.move.create([{
'from_location':
storage.id,
'to_location':
customer.id,
'product':
product.id,
'uom':
unit.id,
'quantity':
2,
'planned_date':
today + relativedelta(months=1, day=5),
'company':
company.id,
'currency':
company.currency.id,
'unit_price':
Decimal('1'),
}])
line, = forecast.lines
self.assertEqual(line.quantity_executed, 2)
self.forecast.create_moves([forecast])
line, = forecast.lines
self.assertEqual(line.quantity_executed, 2)
self.assertEqual(len(line.moves), 4)
self.assertEqual(sum(move.quantity for move in line.moves), 8)
def load_module_graph(graph, pool, update=None, lang=None):
# Prevent to import backend when importing module
from trytond.cache import Cache
from trytond.ir.lang import get_parent_language
if lang is None:
lang = [config.get('database', 'language')]
if update is None:
update = []
modules_todo = []
models_to_update_history = set()
# Load also parent languages
lang = set(lang)
for code in list(lang):
while code:
lang.add(code)
code = get_parent_language(code)
transaction = Transaction()
with transaction.connection.cursor() as cursor:
modules = [x.name for x in graph]
module2state = dict()
for sub_modules in tools.grouped_slice(modules):
cursor.execute(*ir_module.select(ir_module.name, ir_module.state,
where=ir_module.name.in_(list(sub_modules))))
module2state.update(cursor.fetchall())
modules = set(modules)
for node in graph:
module = node.name
if module not in MODULES:
continue
logger.info(module)
classes = pool.fill(module, modules)
if update:
pool.setup(classes)
package_state = module2state.get(module, 'not activated')
if (is_module_to_install(module, update)
or (update
and package_state in ('to activate', 'to upgrade'))):
if package_state not in ('to activate', 'to upgrade'):
if package_state == 'activated':
package_state = 'to upgrade'
elif package_state != 'to remove':
package_state = 'to activate'
for child in node:
module2state[child.name] = package_state
for type in list(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 module
tryton_parser = convert.TrytondXmlHandler(
pool, module, package_state, modules, lang)
for filename in node.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), 'rb') as fp:
tryton_parser.parse_xmlstream(fp)
modules_todo.append((module, list(tryton_parser.to_delete)))
load_translations(pool, node, lang)
if package_state == 'to remove':
continue
cursor.execute(*ir_module.select(ir_module.id,
where=(ir_module.name == module)))
try:
module_id, = cursor.fetchone()
cursor.execute(*ir_module.update([ir_module.state],
['activated'], 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, CurrentTimestamp(), module, 'activated'],
]))
module2state[module] = 'activated'
# Avoid clearing cache to prevent dead lock on ir.cache table
Cache.rollback(transaction)
transaction.commit()
# Clear transaction cache to update default_factory
transaction.cache.clear()
if not update:
pool.setup()
else:
# Remove unknown models and fields
Model = pool.get('ir.model')
Model.clean()
ModelField = pool.get('ir.model.field')
ModelField.clean()
transaction.commit()
pool.setup_mixin(modules)
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)
logger.info('all modules loaded')
def get_balance_period(self, ids, names):
if not ids:
return {}
res={}
fiscalyear_obj = self.pool.get('ekd.fiscalyear')
type_balance = self.browse(ids[0]).account.type_balance
period_obj = self.pool.get('ekd.period')
context = Transaction().context
if context.get('current_period'):
period_id = period_obj.browse(context.get('current_period'))
current_period = context.get('current_period')
elif context.get('current_date'):
current_period = period_obj.search([
('company','=',context.get('company')),
('start_date','<=',context.get('current_date')),
('end_date','>=',context.get('current_date')),
], limit=1)
cr = Transaction().cursor
cr.execute('SELECT id, account, balance_dt, balance_ct, '\
'debit, credit, '\
' balance_dt-balance_ct+debit-credit as balance_end, '\
' balance_dt+debit as balance_dt_end, '\
' balance_ct+credit as balance_ct_end '\
'FROM ekd_balances_party_period '\
'WHERE period=%s AND account in ('%(current_period)+','.join(map(str,ids))+')')
for amount_id, account, balance_dt, balance_ct,\
debit, credit, balance_end,\
balance_dt_end, balance_ct_end in cr.fetchall():
# SQLite uses float for SUM
if not isinstance(balance_dt, Decimal):
balance_dt = Decimal(str(balance_dt))
if not isinstance(balance_ct, Decimal):
balance_ct = Decimal(str(balance_ct))
if not isinstance(balance_dt_end, Decimal):
balance_dt = Decimal(str(balance_dt_end))
if not isinstance(balance_ct_end, Decimal):
balance_ct = Decimal(str(balance_ct_end))
if not isinstance(debit, Decimal):
debit = Decimal(str(debit))
if not isinstance(credit, Decimal):
credit = Decimal(str(credit))
for name in names:
res.setdefault(name, {})
res[name].setdefault(account, Decimal('0.0'))
amount_balance= Decimal('0.0')
if name == 'balance_dt_end':
if type_balance == 'active':
res[name][account] = balance_end
#elif type_balance == 'passive':
# res[name][account] = balance_end
elif type_balance == 'both':
if balance_end > 0:
res[name][account] = balance_end
if name == 'balance_ct_end':
if type_balance == 'passive':
res[name][account] = -balance_end
elif type_balance == 'both':
if balance_end < 0:
res[name][account] = -balance_end
elif name == 'balance_end':
res[name][account] = balance_end
elif name == 'balance':
res[name][account] = balance_dt-balance_ct
elif name == 'debit':
res[name][account] = debit
elif name == 'credit':
res[name][account] = credit
return res
def get_balance_year(self, ids, names):
if not ids:
return {}
res={}
fiscalyear_obj = self.pool.get('ekd.fiscalyear')
period_obj = self.pool.get('ekd.period')
context = Transaction().context
if context.get('current_period'):
period_id = period_object.browse(context.get('current_period'))
start_month = period_id.start_date.strftime('%m')
end_month = period_id.end_date.strftime('%m')
fiscalyear = period_id.fiscalyear.id
if start_month == end_month:
current_period = context.get('current_period').strftime('%m')
else:
begin_period = False
for month in _MOUNTH:
if start_month == month:
current_period.append(month)
begin_period = True
elif begin_period:
current_period.append(month)
elif end_month == month:
current_period.append(month)
break
else:
if context.get('current_fiscalyear'):
fiscalyear = context.get('current_fiscalyear')
else:
fiscalyear = fiscalyear_obj.search([
('company','=',context.get('company')),
('state','=','current')
], limit=1)
current_period = datetime.datetime.now().strftime('%m')
if isinstance(current_period, list):
field_debit = []
field_credit = []
for month in current_period:
field_debit.append("debit_%s"%(month))
field_credit.append("credit_%s"%(month))
field_debits = []
field_credits = []
for month in _MOUNTH:
if month == start_month:
break
field_debits.append("debit_%s"%(month))
field_credits.append("credit_%s"%(month))
else:
field_debit = "debit_%s"%(current_period)
field_credit = "credit_%s"%(current_period)
field_debits = []
field_credits = []
for month in _MOUNTH:
if month == current_period:
break
field_debits.append("debit_%s"%(month))
field_credits.append("credit_%s"%(month))
cr = Transaction().cursor
if isinstance(current_period, list):
cr.execute('SELECT id, balance_dt+'+'+'.join(field_debits)+','\
'balance_ct+'+'+'.join(field_credits)+','\
'+'.join(field_debit)+' as debit,'\
'+'.join(field_credit)+' as credit'\
'FROM ekd_balances_party_period'\
'WHERE fiscalyear=%s AND account in ('+','.join(map(str,ids))+')'%(field_debit,field_credit,fiscalyear))
else:
cr.execute('SELECT id, balance_dt+'+'+'.join(field_debits)+','\
'balance_ct+'+'+'.join(field_credits)+','\
'%s, %s'\
'FROM ekd_balances_party_period'\
'WHERE fiscalyear=%s AND account in ('+','.join(map(str,ids))+')'%(field_debit,field_credit,fiscalyear))
for id, balance_dt, balance_ct, debit, credit in cr.fetchall():
# SQLite uses float for SUM
if not isinstance(balance_dt, Decimal):
balance_dt = Decimal(str(balance_dt))
if not isinstance(balance_ct, Decimal):
balance_ct = Decimal(str(balance_ct))
if not isinstance(debit, Decimal):
debit = Decimal(str(debit))
if not isinstance(credit, Decimal):
credit = Decimal(str(credit))
for name in names:
res.setdefault(name, {})
res[name].setdefault(balance.id, Decimal('0.0'))
amount_balance= Decimal('0.0')
if not balance.amount:
continue
if name == 'balance_dt_end':
res[name][balance.id] = balance_end
elif name == 'balance_ct_end':
res[name][balance.id] = balance_end
elif name == 'balance_end':
res[name][balance.id] = balance_end
elif name == 'balance':
res[name][balance.id] = balance_dt-balance_ct
elif name == 'debit':
res[name][balance.id] = debit
elif name == 'credit':
res[name][balance.id] = credit
return res
def default_currency(self):
return Transaction().context.get('currency')
def get_company(self, ids, name):
res={}
context = Transaction().context
res = {}.fromkeys(ids, context.get('company'))
return res
def execute(cls, ids, data):
with Transaction().set_context(address_with_party=True):
return super(Letter, cls).execute(ids, data)
def generate_internal_shipment(self):
"""
Generate internal shipments to meet order points defined on
non-warehouse location.
"""
order_point_obj = self.pool.get('stock.order_point')
uom_obj = self.pool.get('product.uom')
product_obj = self.pool.get('product.product')
date_obj = self.pool.get('ir.date')
user_obj = self.pool.get('res.user')
user_record = user_obj.browse(Transaction().user)
today = date_obj.today()
# fetch quantities on order points
op_ids = order_point_obj.search([
('type', '=', 'internal'),
])
order_points = order_point_obj.browse(op_ids)
id2product = {}
location_ids = []
for op in order_points:
id2product[op.product.id] = op.product
location_ids.append(op.storage_location.id)
with Transaction().set_context(stock_date_end=today):
pbl = product_obj.products_by_location(location_ids,
list(id2product.iterkeys()),
with_childs=True)
# Create a list of move to create
moves = {}
for op in order_points:
qty = pbl.get((op.storage_location.id, op.product.id), 0)
if qty < op.min_quantity:
key = (op.storage_location.id, op.provisioning_location.id,
op.product.id)
moves[key] = op.max_quantity - qty
# Compare with existing draft shipments
shipment_ids = self.search([
('state', '=', 'draft'),
[
'OR',
('planned_date', '<=', today),
('planned_date', '=', False),
],
])
for shipment in self.browse(shipment_ids):
for move in shipment.moves:
key = (shipment.to_location.id, shipment.from_location.id,
move.product.id)
if key not in moves:
continue
quantity = uom_obj.compute_qty(
move.uom, move.quantity,
id2product[move.product.id].default_uom)
moves[key] = max(0, moves[key] - quantity)
# Group moves by {from,to}_location
shipments = {}
for key, qty in moves.iteritems():
from_location, to_location, product = key
shipments.setdefault((from_location, to_location), []).append(
(product, qty))
# Create shipments and moves
for shipment, moves in shipments.iteritems():
from_location, to_location = shipment
values = {
'from_location': from_location,
'to_location': to_location,
'planned_date': today,
'moves': [],
}
for move in moves:
product, qty = move
values['moves'].append(('create', {
'from_location':
from_location,
'to_location':
to_location,
'product':
product,
'quantity':
qty,
'uom':
id2product[product].default_uom.id,
'company':
user_record.company.id,
}))
self.create(values)
def default_configure(self, data):
Channel = Pool().get('sale.channel')
channel = Channel(Transaction().context.get('active_id'))
return {'channel_source': channel.source}
def default_period():
pool = Pool()
Period = pool.get('account.period')
company = Transaction().context.get('company')
return Period.find(company, exception=False)
def default_state(self):
return Transaction().context.get('state') or 'draft'
def test0040complete(self):
'''
Test complete.
'''
with Transaction().start(DB_NAME, USER, context=CONTEXT):
category, = self.category.create([{
'name': 'Test complete',
}])
unit, = self.uom.search([('name', '=', 'Unit')])
template, = self.template.create([{
'name': 'Test complete',
'type': 'goods',
'category': category.id,
'cost_price_method': 'fixed',
'default_uom': unit.id,
'list_price': Decimal('1'),
'cost_price': Decimal(0),
}])
product, = self.product.create([{
'template': template.id,
}])
customer, = self.location.search([('code', '=', 'CUS')])
supplier, = self.location.search([('code', '=', 'SUP')])
warehouse, = self.location.search([('code', '=', 'WH')])
storage, = self.location.search([('code', '=', 'STO')])
company, = self.company.search([
('rec_name', '=', 'Dunder Mifflin'),
])
self.user.write([self.user(USER)], {
'main_company': company.id,
'company': company.id,
})
today = datetime.date.today()
moves = self.move.create([{
'from_location':
supplier.id,
'to_location':
storage.id,
'product':
product.id,
'uom':
unit.id,
'quantity':
10,
'effective_date': (today + relativedelta(months=-1, day=1)),
'company':
company.id,
'currency':
company.currency.id,
'unit_price':
Decimal('1'),
}, {
'from_location':
storage.id,
'to_location':
customer.id,
'product':
product.id,
'uom':
unit.id,
'quantity':
5,
'effective_date': (today + relativedelta(months=-1, day=15)),
'company':
company.id,
'currency':
company.currency.id,
'unit_price':
Decimal('1'),
}])
self.move.do(moves)
forecast, = self.forecast.create([{
'warehouse':
warehouse.id,
'destination':
customer.id,
'from_date':
today + relativedelta(months=1, day=1),
'to_date':
today + relativedelta(months=1, day=20),
'company':
company.id,
}])
with Transaction().set_context(active_id=forecast.id):
session_id, _, _ = self.forecast_complete.create()
forecast_complete = self.forecast_complete(session_id)
forecast_complete.ask.from_date = (
today + relativedelta(months=-1, day=1))
forecast_complete.ask.to_date = (
today + relativedelta(months=-1, day=20))
forecast_complete.transition_complete()
self.assertEqual(len(forecast.lines), 1)
forecast_line, = forecast.lines
self.assertEqual(forecast_line.product, product)
self.assertEqual(forecast_line.uom, unit)
self.assertEqual(forecast_line.quantity, 5)
self.assertEqual(forecast_line.minimal_quantity, 1)
def fields_view_get(cls, view_id=None, view_type='form'):
'''
Return a view definition.
If view_id is None the first one will be used of view_type.
The definition is a dictionary with keys:
- model: the model name
- type: the type of the view
- view_id: the id of the view
- arch: the xml description of the view
- fields: a dictionary with the definition of each field in the view
- field_childs: the name of the childs field for tree
'''
key = (cls.__name__, view_id, view_type)
result = cls._fields_view_get_cache.get(key)
if result:
return result
result = {'model': cls.__name__}
pool = Pool()
View = pool.get('ir.ui.view')
view = None
inherit_view_id = None
if view_id:
view = View(view_id)
else:
domain = [
('model', '=', cls.__name__),
[
'OR',
('inherit', '=', None),
('inherit.model', '!=', cls.__name__),
],
]
views = View.search(domain)
views = filter(lambda v: v.rng_type == view_type, views)
if views:
view = views[0]
if view:
if view.inherit:
inherit_view_id = view.id
view = view.inherit
view_id = view.id
# if a view was found
if view:
result['type'] = view.rng_type
result['view_id'] = view_id
result['arch'] = view.arch
result['field_childs'] = view.field_childs
# Check if view is not from an inherited model
if view.model != cls.__name__:
Inherit = pool.get(view.model)
result['arch'] = Inherit.fields_view_get(
result['view_id'])['arch']
view_id = inherit_view_id
# get all views which inherit from (ie modify) this view
views = View.search([
'OR',
[
('inherit', '=', view_id),
('model', '=', cls.__name__),
],
[
('id', '=', view_id),
('inherit', '!=', None),
],
])
raise_p = False
while True:
try:
views.sort(key=lambda x: cls._modules_list.index(x.module
or None))
break
except ValueError:
if raise_p:
raise
# There is perhaps a new module in the directory
ModelView._reset_modules_list()
raise_p = True
parser = etree.XMLParser(remove_comments=True)
tree = etree.fromstring(result['arch'], parser=parser)
for view in views:
if view.domain:
if not PYSONDecoder({
'context': Transaction().context
}).decode(view.domain):
continue
if not view.arch or not view.arch.strip():
continue
tree_inherit = etree.fromstring(view.arch, parser=parser)
tree = _inherit_apply(tree, tree_inherit)
result['arch'] = etree.tostring(tree,
encoding='utf-8').decode('utf-8')
# otherwise, build some kind of default view
else:
if view_type == 'form':
res = cls.fields_get()
xml = '''<?xml version="1.0"?>''' \
'''<form string="%s" col="4">''' % (cls.__doc__,)
for i in res:
if i in ('create_uid', 'create_date', 'write_uid',
'write_date', 'id', 'rec_name'):
continue
if res[i]['type'] not in ('one2many', 'many2many'):
xml += '<label name="%s"/>' % (i, )
xml += '<field name="%s"/>' % (i, )
if res[i]['type'] == 'text':
xml += "<newline/>"
else:
xml += '<field name="%s" colspan="4"/>' % (i, )
xml += "</form>"
elif view_type == 'tree':
field = 'id'
if cls._rec_name in cls._fields:
field = cls._rec_name
xml = '''<?xml version="1.0"?>''' \
'''<tree string="%s"><field name="%s"/></tree>''' \
% (cls.__doc__, field)
else:
xml = ''
result['type'] = view_type
result['arch'] = xml
result['field_childs'] = None
result['view_id'] = 0
# Update arch and compute fields from arch
parser = etree.XMLParser(remove_blank_text=True)
tree = etree.fromstring(result['arch'], parser)
xarch, xfields = cls._view_look_dom_arch(tree, result['type'],
result['field_childs'])
result['arch'] = xarch
result['fields'] = xfields
cls._fields_view_get_cache.set(key, result)
return result
def migrate_property(model_name,
field_names,
ValueModel,
value_names,
parent=None,
fields=None):
"Migrate property from model_name.field_name to ValueModel.value_name"
pool = Pool()
Field = pool.get('ir.model.field')
Model = pool.get('ir.model')
if not backend.TableHandler.table_exist('ir_property'):
return
cursor = Transaction().connection.cursor()
field = Field.__table__()
model = Model.__table__()
table = ValueModel.__table__()
if fields is None:
fields = []
if isinstance(field_names, str):
field_names = [field_names]
if isinstance(value_names, str):
value_names = [value_names]
def split_value(value):
return value.split(',')[1]
cast_funcs = {
'numeric': lambda v: Decimal(split_value(v)) if v else None,
'integer': lambda v: int(split_value(v)) if v else None,
'float': lambda v: float(split_value(v)) if v else None,
'char': lambda v: split_value(v) if v else None,
'selection': lambda v: split_value(v) if v else None,
'many2one': lambda v: int(split_value(v)) if v else None,
'reference': lambda v: v,
}
casts = []
queries = []
for field_name, value_name in zip(field_names, value_names):
value_field = getattr(ValueModel, value_name)
casts.append(cast_funcs[value_field._type])
property_ = Table('ir_property')
columns = [
Literal(None).as_(f)
if f != value_name else property_.value.as_(value_name)
for f in value_names
]
if parent:
columns.append(property_.res.as_(parent))
where = property_.res.like(model_name + ',%')
else:
where = property_.res == Null
columns.extend([Column(property_, f).as_(f) for f in fields])
query = property_.join(field,
condition=property_.field == field.id).join(
model,
condition=field.model == model.id).select(
*columns,
where=where
& (field.name == field_name)
& (model.model == model_name))
queries.append(query)
union = Union(*queries)
columns = [Max(Column(union, f)).as_(f) for f in value_names]
if parent:
columns.append(Column(union, parent).as_(parent))
pcolumns = [Column(union, parent)]
else:
pcolumns = []
vcolumns = [Column(union, f).as_(f) for f in fields]
cursor.execute(
*union.select(*(columns + vcolumns), group_by=pcolumns + vcolumns))
columns = [Column(table, f) for f in value_names]
if parent:
pcolumns = [Column(table, parent)]
else:
pcolumns = []
vcolumns = [Column(table, f) for f in fields]
values = []
l = len(value_names)
for row in cursor.fetchall():
value = [c(v) for v, c in zip(row, casts)]
if parent:
value.append(int(row[l].split(',')[1]) if row[l] else None)
i = 1
else:
i = 0
value.extend(row[l + i:])
values.append(value)
if (values and not (
# No property defined
len(values) == 1 and all(x is None
for x in values[0][:len(columns)]))):
# Delete previous migrated values
cursor.execute(*table.delete())
cursor.execute(
*table.insert(columns + pcolumns + vcolumns, values=values))
def _view_look_dom_arch(cls, tree, type, field_children=None):
pool = Pool()
ModelAccess = pool.get('ir.model.access')
FieldAccess = pool.get('ir.model.field.access')
encoder = PYSONEncoder()
for xpath, attribute, value in cls.view_attributes():
for element in tree.xpath(xpath):
element.set(attribute, encoder.encode(value))
fields_width = {}
tree_root = tree.getroottree().getroot()
# Find field without read access
fread_accesses = FieldAccess.check(cls.__name__,
cls._fields.keys(),
'read',
access=True)
fields_to_remove = list(x for x, y in fread_accesses.iteritems()
if not y)
# Find relation field without read access
for name, field in cls._fields.iteritems():
if not ModelAccess.check_relation(cls.__name__, name, mode='read'):
fields_to_remove.append(name)
for name, field in cls._fields.iteritems():
for field_to_remove in fields_to_remove:
if field_to_remove in field.depends:
fields_to_remove.append(name)
# Remove field without read access
for field in fields_to_remove:
xpath = (
'//field[@name="%(field)s"] | //label[@name="%(field)s"]'
' | //page[@name="%(field)s"] | //group[@name="%(field)s"]'
' | //separator[@name="%(field)s"]') % {
'field': field
}
for i, element in enumerate(tree.xpath(xpath)):
if type == 'tree' or element.tag == 'page':
parent = element.getparent()
parent.remove(element)
elif type == 'form':
element.tag = 'label'
colspan = element.attrib.get('colspan')
element.attrib.clear()
element.attrib['id'] = 'hidden %s-%s' % (field, i)
if colspan is not None:
element.attrib['colspan'] = colspan
if type == 'tree':
ViewTreeWidth = pool.get('ir.ui.view_tree_width')
viewtreewidth_ids = ViewTreeWidth.search([
('model', '=', cls.__name__),
('user', '=', Transaction().user),
])
for viewtreewidth in ViewTreeWidth.browse(viewtreewidth_ids):
if viewtreewidth.width > 0:
fields_width[viewtreewidth.field] = viewtreewidth.width
fields_def = cls.__view_look_dom(tree_root,
type,
fields_width=fields_width)
if field_children:
fields_def.setdefault(field_children, {'name': field_children})
if field_children in cls._fields:
field = cls._fields[field_children]
if hasattr(field, 'field'):
fields_def.setdefault(field.field, {'name': field.field})
for field_name in fields_def.keys():
if field_name in cls._fields:
field = cls._fields[field_name]
else:
continue
for depend in field.depends:
fields_def.setdefault(depend, {'name': depend})
if 'active' in cls._fields:
fields_def.setdefault('active', {'name': 'active'})
arch = etree.tostring(tree, encoding='utf-8',
pretty_print=False).decode('utf-8')
fields2 = cls.fields_get(fields_def.keys())
for field in fields_def:
if field in fields2:
fields2[field].update(fields_def[field])
return arch, fields2
def _load_modules(update):
global res
transaction = Transaction()
with transaction.set_context(_no_trigger=True), \
transaction.connection.cursor() as cursor:
# Migration from 3.6: remove double module
old_table = 'ir_module_module'
new_table = 'ir_module'
if backend.TableHandler.table_exist(old_table):
backend.TableHandler.table_rename(old_table, new_table)
# Migration from 4.0: rename installed to activated
cursor.execute(*ir_module.select(ir_module.name,
where=ir_module.state.in_(('installed', 'uninstalled'))))
if cursor.fetchone():
cursor.execute(*ir_module.update(
[ir_module.state], ['activated'],
where=ir_module.state == 'installed'))
cursor.execute(*ir_module.update(
[ir_module.state], ['not activated'],
where=ir_module.state == 'uninstalled'))
if update:
cursor.execute(*ir_module.select(ir_module.name,
where=ir_module.state.in_(('activated', 'to activate',
'to upgrade', 'to remove'))))
else:
cursor.execute(*ir_module.select(ir_module.name,
where=ir_module.state.in_(('activated', 'to upgrade',
'to remove'))))
module_list = [name for (name,) in cursor.fetchall()]
graph = None
while graph is None:
module_list += update
try:
graph = create_graph(module_list)
except MissingDependenciesException as e:
if not activatedeps:
raise
update += e.missings
load_module_graph(graph, pool, update, lang)
Configuration = pool.get('ir.configuration')
Configuration(1).check()
if update:
cursor.execute(*ir_module.select(ir_module.name,
where=(ir_module.state == 'to remove')))
fetchall = cursor.fetchall()
if fetchall:
for (mod_name,) in fetchall:
# TODO check if ressource not updated by the user
cursor.execute(*ir_model_data.select(
ir_model_data.model, ir_model_data.db_id,
where=(ir_model_data.module == mod_name),
order_by=ir_model_data.id.desc))
for rmod, rid in cursor.fetchall():
Model = pool.get(rmod)
Model.delete([Model(rid)])
Transaction().connection.commit()
cursor.execute(*ir_module.update([ir_module.state],
['not activated'],
where=(ir_module.state == 'to remove')))
Transaction().connection.commit()
res = False
Module = pool.get('ir.module')
Module.update_list()
# Need to commit to unlock SQLite database
transaction.commit()
def __view_look_dom(cls,
element,
type,
fields_width=None,
fields_attrs=None):
pool = Pool()
Translation = pool.get('ir.translation')
ModelData = pool.get('ir.model.data')
Button = pool.get('ir.model.button')
User = pool.get('res.user')
if fields_width is None:
fields_width = {}
if not fields_attrs:
fields_attrs = {}
else:
fields_attrs = copy.deepcopy(fields_attrs)
def set_view_ids(element):
view_ids = []
if element.get('view_ids'):
for view_id in element.get('view_ids').split(','):
try:
view_ids.append(int(view_id))
except ValueError:
view_ids.append(ModelData.get_id(*view_id.split('.')))
element.attrib['view_ids'] = ','.join(map(str, view_ids))
return view_ids
def get_relation(field):
if hasattr(field, 'model_name'):
return field.model_name
elif hasattr(field, 'get_target'):
return field.get_target().__name__
def get_views(relation, view_ids, mode):
Relation = pool.get(relation)
views = {}
if field._type in ['one2many', 'many2many']:
# Prefetch only the first view to prevent infinite loop
if view_ids:
for view_id in view_ids:
view = Relation.fields_view_get(view_id=view_id)
views[str(view_id)] = view
break
else:
for view_type in mode:
views[view_type] = (Relation.fields_view_get(
view_type=view_type))
break
return views
for attr in ('name', 'icon'):
if not element.get(attr):
continue
fields_attrs.setdefault(element.get(attr), {})
if element.tag == 'field' and type in ['tree', 'form']:
for attr in ('name', 'icon'):
fname = element.get(attr)
if not fname:
continue
view_ids = set_view_ids(element)
if type != 'form':
continue
field = cls._fields[fname]
relation = get_relation(field)
if not relation:
continue
mode = (element.attrib.pop('mode', None)
or 'tree,form').split(',')
views = get_views(relation, view_ids, mode)
element.attrib['mode'] = ','.join(mode)
fields_attrs[fname].setdefault('views', {}).update(views)
if type == 'tree' and element.get('name') in fields_width:
element.set('width', str(fields_width[element.get('name')]))
encoder = PYSONEncoder()
if element.tag == 'button':
button_name = element.attrib['name']
if button_name in cls._buttons:
states = cls._buttons[button_name]
else:
states = {}
groups = set(User.get_groups())
button_groups = Button.get_groups(cls.__name__, button_name)
if button_groups and not groups & button_groups:
states = states.copy()
states['readonly'] = True
element.set('states', encoder.encode(states))
change = cls.__change_buttons[button_name]
if change:
element.set('change', encoder.encode(list(change)))
if not is_instance_method(cls, button_name):
element.set('type', 'class')
else:
element.set('type', 'instance')
# translate view
if Transaction().language != 'en_US':
for attr in ('string', 'sum', 'confirm', 'help'):
if element.get(attr):
trans = Translation.get_source(cls.__name__, 'view',
Transaction().language,
element.get(attr))
if trans:
element.set(attr, trans)
# Set header string
if element.tag in ('form', 'tree', 'graph'):
element.set(
'string',
cls.view_header_get(element.get('string') or '',
view_type=element.tag))
if element.tag == 'tree' and element.get('sequence'):
fields_attrs.setdefault(element.get('sequence'), {})
if element.tag == 'calendar':
for attr in ('dtstart', 'dtend'):
if element.get(attr):
fields_attrs.setdefault(element.get(attr), {})
for field in element:
fields_attrs = cls.__view_look_dom(field,
type,
fields_width=fields_width,
fields_attrs=fields_attrs)
return fields_attrs
def execute(cls, ids, data):
with Transaction().set_context({
'html_report_ids': ids,
'html_report_data': data,
}):
return super().execute(ids, data)
def analytic_accounts_domain(cls):
context = Transaction().context.copy()
context['context'] = context
return PYSONDecoder(context).decode(PYSONEncoder().encode(
cls.analytic_accounts.domain))
def _deactivate_extension(cls):
connection = Transaction().connection
cursor = connection.cursor()
cursor.execute('DROP EXTENSION "unaccent"')
connection.commit()
cls._clear_unaccent_cache()
def default_start(self, fields):
Invoice = Pool().get('account.invoice')
Journal = Pool().get('account.journal')
Date = Pool().get('ir.date')
fecha_actual = Date.today()
default = {}
journals = Journal.search([('type', '=', 'expense')])
for j in journals:
journal = j
invoice = Invoice(Transaction().context.get('active_id'))
invoice.set_number()
#invoice.create_move()
pool = Pool()
Taxes = pool.get('account.tax')
taxes_1 = Taxes.search([('type', '=', 'percentage')])
if invoice.type == 'in_invoice':
default['type'] = 'in_withholding'
if invoice.reference:
default['number_w'] = invoice.reference
default['account'] = j.id
default['withholding_address'] = invoice.invoice_address.id
default['description'] = invoice.description
default['reference'] = invoice.number
default['comment'] = invoice.comment
default['company'] = invoice.company.id
default['party'] = invoice.party.id
default['currency'] = invoice.currency.id
default['journal'] = journal.id
default['taxes'] = []
if invoice.taxes:
default['base_imponible'] = invoice.taxes[0].base
default['iva'] = invoice.taxes[0].amount
else:
self.raise_user_error('Verifique los impuestos de la factura')
default['withholding_date'] = fecha_actual
if invoice.party.impuesto_iva and invoice.party.impuestos_renta:
pool = Pool()
Tax = pool.get('account.tax')
w_iva = invoice.party.impuesto_iva
w_renta = invoice.party.impuestos_renta
amount_i = Tax.compute([w_iva], invoice.taxes[0].amount, 1)
amount_r = Tax.compute([w_renta], invoice.taxes[0].base, 1)
for value in amount_i:
amount_w_i = value['amount']
for value in amount_r:
amount_w_r = value['amount']
print "Valores ", amount_w_i, amount_w_r
taxes = {
'tax': w_iva.id,
'manual': True,
'base': invoice.taxes[0].amount,
'amount': amount_w_i,
'tipo': 'IVA',
}
default['taxes'].append(taxes)
taxes = {
'tax': w_renta.id,
'manual': True,
'base': invoice.taxes[0].base,
'amount': amount_w_r,
'tipo': 'RENTA',
}
default['taxes'].append(taxes)
return default
else:
return self.raise_user_error(
'No ha configurado los impuestos de retencion del proveedor')
def getControllerName():
if Transaction().language in ('es', 'es_419'):
return 'Formulario genérico - XLS'
else:
return 'Generic Form - XLS'
def end(self):
model = Transaction().context.get('active_model')
if model == 'account.move.line':
return 'reload'
def default_company():
return Transaction().context.get('company')
def get(cls):
user = Transaction().user
favorites = cls.search([
('user', '=', user),
])
return [(f.menu.id, f.menu.rec_name, f.menu.icon) for f in favorites]
