class ModelViewRPC(ModelView):
'ModelView RPC'
__name__ = 'test.modelview.rpc'
selection = fields.Selection([('a', 'A')], 'Selection')
computed_selection = fields.Selection(
'get_selection', 'Computed Selection')
function_selection = fields.Function(
fields.Selection('get_function_selection', 'Function Selection'),
'function_selection_getter')
reference = fields.Reference('Reference', selection=[('a', 'A')])
computed_reference = fields.Reference(
'Computed reference', selection='get_reference')
function_reference = fields.Function(
fields.Reference('Function Reference',
selection='get_function_reference'),
'function_reference_getter')
integer = fields.Integer('Integer')
float = fields.Float('Float')
char = fields.Char('Char')
@fields.depends('selection')
def on_change_with_integer(self):
pass
@fields.depends('reference')
def on_change_float(self):
pass
@fields.depends('integer')
def autocomplete_char(self):
pass
@classmethod
def get_selection(cls):
pass
@classmethod
def get_function_selection(cls):
pass
@classmethod
def get_reference(cls):
pass
@classmethod
def get_function_reference(cls):
pass
class DocumentPaymentLine(ModelSQL, ModelView):
"Documents Payment Line"
_name='ekd.document.line.payment'
_description=__doc__
doc_payment = fields.Many2One('ekd.document', 'Document Payment', ondelete="CASCADE")
doc_base = fields.Many2One('ekd.document.head.request', 'Document Base')
amount_payment = fields.Numeric('Amount Payment', digits=(16,2))
line_request = fields.Many2One('ekd.document.line.request', 'Line Request of money')
line_ref = fields.Reference(selection='get_line_ref', string='Ref.')
type_transaction = fields.Selection([
('income_cash','Income in Cash'),
('expense_cash','Expense in Cash'),
('return_cash','Return in Cash'),
('income_bank','Income in Bank'),
('expense_bank','Expense in Bank'),
('return_bank','Return in Bank')
], 'Type Transaction')
state = fields.Selection([
('deleted','Deleted'),
('done','Done'),
('payment','Payment'),
('wait_bank','Waiting Confirm Bank')
], 'State')
def get_line_ref(self):
dictions_obj = self.pool.get('ir.dictions')
res = []
diction_ids = dictions_obj.search([
('model', '=', 'ekd.document.line.payment'),
('pole', '=', 'line_ref'),
])
for diction in dictions_obj.browse(diction_ids):
res.append([diction.key, diction.value])
return res
class ReferenceContext(ModelSQL):
"Reference Context"
__name__ = 'test.reference_context'
target = fields.Reference("Reference", selection=[
(None, ''),
('test.reference_context.target', "Target"),
], context={'test': 'foo'})
class Product_TariffCode(ModelSQL, ModelView):
'Product - Tariff Code'
__name__ = 'product-customs.tariff.code'
product = fields.Reference('Product',
selection=[
('product.template', 'Template'),
('product.category', 'Category'),
],
required=True,
select=True)
tariff_code = fields.Many2One('customs.tariff.code',
'Tariff Code',
required=True,
ondelete='CASCADE')
sequence = fields.Integer('Sequence')
@classmethod
def __setup__(cls):
super(Product_TariffCode, cls).__setup__()
cls._order.insert(0, ('sequence', 'ASC'))
def get_rec_name(self, name):
return self.tariff_code.rec_name
@classmethod
def search_rec_name(cls, name, clause):
return [('tariff_code.rec_name', ) + tuple(clause[1:])]
@staticmethod
def order_sequence(tables):
table, _ = tables[None]
return [table.sequence == Null, table.sequence]
class Reference(ModelSQL):
'Reference'
__name__ = 'test.reference'
reference = fields.Reference('Reference', selection=[
(None, ''),
('test.reference.target', 'Target'),
])
class TrainingSubscriptionHistory(ModelSQL, ModelView):
"Subscription History"
__name__ = "training.subscription.history"
_rec_name = 'date'
@classmethod
def get_model(cls):
cr = Transaction().cursor
cr.execute('''\
SELECT
m.model,
m.name
FROM
ir_model m
ORDER BY
m.name
''')
return cr.fetchall()
date = fields.DateTime('Date', readonly=True)
log = fields.Char('Result', readonly=True)
subscription = fields.Many2One('training.subscription',
'Subscription', ondelete='CASCADE', readonly=True)
document = fields.Reference('Created Document', selection='get_model',
readonly=True)
@staticmethod
def default_date():
return datetime.now()
class ExportData(ModelSQL):
"Export Data"
__name__ = 'test.export_data'
boolean = fields.Boolean('Boolean')
integer = fields.Integer('Integer')
float = fields.Float('Float')
numeric = fields.Numeric('Numeric')
char = fields.Char('Char')
text = fields.Text('Text')
date = fields.Date('Date')
datetime = fields.DateTime('DateTime')
timedelta = fields.TimeDelta('TimeDelta')
selection = fields.Selection([
(None, ''),
('select1', 'Select 1'),
('select2', 'Select 2'),
], 'Selection')
many2one = fields.Many2One('test.export_data.target', 'Many2One')
many2many = fields.Many2Many('test.export_data.relation', 'many2many',
'target', 'Many2Many')
one2many = fields.One2Many('test.export_data.target', 'one2many',
'One2Many')
reference = fields.Reference('Reference', [
(None, ''),
('test.export_data.target', 'Target'),
])
class PartyEvent(ModelSQL, ModelView):
_name = "ekd.party.event"
name = fields.Char('Events', size=64, required=True)
som = fields.Many2One('ekd.party.som', 'State of Mind')
description = fields.Text('Description')
planned_cost = fields.Float('Planned Cost')
planned_revenue = fields.Float('Planned Revenue')
probability = fields.Float('Probability (0.50)')
document = fields.Reference('Document', '_links_get')
party = fields.Many2One('party.party', 'Party', select=True)
date = fields.DateTime('Date')
user = fields.Many2One('res.user', 'User')
channel = fields.Many2One('ekd.party.channel', 'Channel')
party_type = fields.Selection([('customer', 'Customer'),
('retailer', 'Retailer'),
('prospect', 'Commercial Prospect')],
'Party Relation')
type = fields.Selection([('sale', 'Sale Opportunity'),
('purchase', 'Purchase Offer'),
('prospect', 'Prospect Contact')],
'Type of Event')
event_ical = fields.Char('iCal id', size=64)
_order = 'date desc'
def default_date(self):
return time.strftime('%Y-%m-%d %H:%M:%S')
def _links_get(self):
request_link_obj = self.pool.get('res.request.link')
ids = request_link_obj.search([])
request_links = request_link_obj.browse(ids)
return [(x.model, x.name) for x in request_links]
class ReferenceRequired(ModelSQL):
'Reference Required'
__name__ = 'test.reference_required'
reference = fields.Reference('Reference', selection=[
(None, ''),
('test.reference.target', 'Target'),
], required=True)
class ImportDataReference(ModelSQL):
"Import Data Reference"
__name__ = 'test.import_data.reference'
reference = fields.Reference('Reference', [
(None, ''),
('test.import_data.reference.selection', 'Test'),
])
class ChannelException(ModelSQL, ModelView):
"""
Channel Exception model
"""
__name__ = 'channel.exception'
origin = fields.Reference(
"Origin", selection='models_get', select=True, readonly=True
)
log = fields.Text('Exception Log', readonly=True)
channel = fields.Many2One(
"sale.channel", "Channel", required=True, readonly=True
)
is_resolved = fields.Boolean("Is Resolved ?", select=True)
@staticmethod
def default_is_resolved():
return False
@classmethod
def models_get(cls):
'''
Return valid models allowed for origin
'''
return [
('sale.sale', 'Sale'),
('sale.line', 'Sale Line'),
]
class CountSearch(ModelView):
"Stock Inventory Count"
__name__ = 'stock.inventory.count.search'
search = fields.Reference(
"Search", [
('product.product', "Product"),
],
required=True,
domain=[
If(
Eval('search_model') == 'product.product', [
('type', '=', 'goods'),
('consumable', '=', False),
], [])
],
depends=['search_model'],
help="The item that's counted.")
search_model = fields.Function(
fields.Selection('get_search_models', "Search Model"),
'on_change_with_search_model')
@classmethod
def default_search(cls):
return 'product.product,-1'
@classmethod
def get_search_models(cls):
return cls.fields_get(['search'])['search']['selection']
@fields.depends('search')
def on_change_with_search_model(self, name=None):
if self.search:
return self.search.__name__
class Template(metaclass=PoolMeta):
__name__ = 'product.template'
classification = fields.Reference('Classification',
selection='get_classification',
domain=[
('selectable', '=', True),
],
states={
'readonly': ~Eval('active', True),
},
depends=['active'])
@classmethod
def _get_classification(cls):
'Return list of Model names for classification Reference'
return []
@classmethod
def get_classification(cls):
pool = Pool()
Model = pool.get('ir.model')
models = cls._get_classification()
models = Model.search([
('model', 'in', models),
])
return [(None, '')] + [(m.model, m.name) for m in models]
class One2ManyReferenceTarget(ModelSQL):
'One2Many Reference Target'
__name__ = 'test.one2many_reference.target'
name = fields.Char('Name', required=True)
origin = fields.Reference('Origin', [
(None, ''),
('test.one2many_reference', 'One2Many Reference'),
])
class ModelSQLRead(ModelSQL):
"ModelSQL to test read"
__name__ = 'test.modelsql.read'
name = fields.Char("Name")
target = fields.Many2One('test.modelsql.read.target', "Target")
targets = fields.One2Many('test.modelsql.read.target', 'parent', "Targets")
reference = fields.Reference(
"Reference", [(None, ""), ('test.modelsql.read.target', "Target")])
class CopyOne2ManyReferenceTarget(ModelSQL):
"Copy One2Many ReferenceTarget"
__name__ = 'test.copy.one2many_reference.target'
name = fields.Char('Name')
one2many = fields.Reference('One2Many', [
(None, ''),
('test.copy.one2many_reference', 'One2Many'),
])
class Package(ModelSQL, ModelView):
'Stock Package'
__name__ = 'stock.package'
_rec_name = 'code'
code = fields.Char('Code', select=True, readonly=True, required=True)
type = fields.Many2One('stock.package.type', 'Type', required=True)
shipment = fields.Reference('Shipment', selection='get_shipment',
select=True)
moves = fields.One2Many('stock.move', 'package', 'Moves',
domain=[
('shipment', '=', Eval('shipment')),
('to_location.type', 'in', ['customer', 'supplier']),
],
add_remove=[
('package', '=', None),
],
depends=['shipment'])
parent = fields.Many2One('stock.package', 'Parent', select=True,
ondelete='CASCADE', domain=[('shipment', '=', Eval('shipment'))],
depends=['shipment'])
children = fields.One2Many('stock.package', 'parent', 'Children',
domain=[('shipment', '=', Eval('shipment'))],
depends=['shipment'])
@staticmethod
def _get_shipment():
'Return list of Model names for shipment Reference'
return [
'stock.shipment.out',
'stock.shipment.in.return',
]
@classmethod
def get_shipment(cls):
pool = Pool()
Model = pool.get('ir.model')
models = cls._get_shipment()
models = Model.search([
('model', 'in', models),
])
return [(None, '')] + [(m.model, m.name) for m in models]
@classmethod
def create(cls, vlist):
pool = Pool()
Sequence = pool.get('ir.sequence')
Config = pool.get('stock.configuration')
vlist = [v.copy() for v in vlist]
config = Config(1)
for values in vlist:
values['code'] = Sequence.get_id(config.package_sequence)
return super(Package, cls).create(vlist)
@classmethod
def validate(cls, packages):
super(Package, cls).validate(packages)
cls.check_recursion(packages)
class Reference(ModelSQL):
'Reference'
__name__ = 'test.reference'
name = fields.Char('Name', required=True)
reference = fields.Reference('Reference',
selection=[
(None, ''),
('test.reference.target', 'Target'),
])
class Many2ManyReferenceRelation(ModelSQL):
'Many2Many Relation'
__name__ = 'test.many2many_reference.relation'
origin = fields.Reference('Origin', [
(None, ''),
('test.many2many_reference', 'Many2Many Reference'),
])
target = fields.Many2One('test.many2many_reference.target',
'Reference Target')
class ChannelException(ModelSQL, ModelView):
"""
Channel Exception model
"""
__name__ = 'channel.exception'
origin = fields.Reference("Origin",
selection='models_get',
select=True,
readonly=True)
log = fields.Text('Exception Log', readonly=True)
channel = fields.Many2One("sale.channel",
"Channel",
required=True,
readonly=True)
is_resolved = fields.Boolean("Is Resolved ?", select=True)
@classmethod
def __setup__(cls):
"""
Setup the class before adding to pool
"""
super(ChannelException, cls).__setup__()
cls._buttons.update({
'resolve_exception_button': {
'readonly': Bool(Eval('is_resolved')),
},
})
@classmethod
@ModelView.button
def resolve_exception_button(cls, exceptions):
"""
Method called from a button to resolve exceptions
:param channels: List of active records of exceptions
"""
for exception in exceptions:
if exception.is_resolved:
continue
exception.is_resolved = True
exception.save()
@staticmethod
def default_is_resolved():
return False
@classmethod
def models_get(cls):
'''
Return valid models allowed for origin
'''
return [
('sale.sale', 'Sale'),
('sale.line', 'Sale Line'),
]
class CopyMany2ManyReferenceRelation(ModelSQL):
"Copy Many2ManyReference Relation"
__name__ = 'test.copy.many2many_reference.rel'
name = fields.Char('Name')
many2many = fields.Reference('Many2Many', [
(None, ''),
('test.copy.many2many_reference', 'Many2Many'),
])
many2many_target = fields.Many2One('test.copy.many2many_reference.target',
'Many2ManyReference Target')
class TestAccess(ModelSQL):
'Test Access'
__name__ = 'test.access'
field1 = fields.Char('Field 1')
field2 = fields.Char('Field 2')
relate = fields.Many2One('test.access.relate', "Relate")
reference = fields.Reference("Reference", [
(None, ""),
('test.access.relate', "Reference"),
])
class InvoiceEdiReference(ModelSQL, ModelView):
'Account Invoice Reference'
__name__ = 'invoice.edi.reference'
type_ = fields.Selection([('DQ', 'Shipment'), ('ON', 'Purchase'),
('CT', 'Contract'), ('IV', 'Invoice'),
('AAK', 'Expedition'),
('ALO', 'Confirmed Reception'), ('move', 'Move'),
('LI', 'Line Number'),
('SNR', 'Medical Record')], 'Reference Code')
value = fields.Char('Reference')
line_number = fields.Char('Line Number')
origin = fields.Reference('Reference', selection='get_resource')
edi_invoice = fields.Many2One('invoice.edi',
'Edi Invoice',
ondelete='CASCADE')
edi_invoice_line = fields.Many2One('invoice.edi.line',
'Edi Invoice Line',
ondelete='CASCADE')
@classmethod
def get_resource(cls):
'Return list of Model names for resource Reference'
return [(None, ''), ('stock.shipment.in', 'Shipment'),
('purchase.purchase', 'Purchase'),
('account.invoice', 'Invoice'), ('stock.move', 'Move')]
def read_message(self, message):
if message:
message.pop(0)
type_ = message.pop(0) if message else ''
value = message.pop(0) if message else ''
self.type_ = type_
self.value = value
def search_reference(self):
model = None
if self.type_ == 'DQ':
model = 'stock.shipment.in'
elif self.type_ == 'ON':
model = 'purchase.purchase'
elif self.type_ == 'IV':
model = 'account.invoice'
if self.type_ == 'move':
model = 'stock.move'
if not model:
return
Model = Pool().get(model)
res = Model.search([('number', '=', self.value)], limit=1)
self.origin = None
if res != []:
self.origin = res[0]
class ModelViewChangedValues(ModelView):
'ModelView Changed Values'
__name__ = 'test.modelview.changed_values'
name = fields.Char('Name')
target = fields.Many2One('test.modelview.changed_values.target', 'Target')
ref_target = fields.Reference('Target Reference', [
('test.modelview.changed_values.target', 'Target'),
])
targets = fields.One2Many('test.modelview.changed_values.target', 'model',
'Targets')
m2m_targets = fields.Many2Many('test.modelview.changed_values.target',
None, None, 'Targets')
class ProjectWork(ModelSQL, ModelView):
"Tasks Work"
_name = "ekd.project.tasks.works"
_description = __doc__
name = fields.Char('Work summary', size=128)
date = fields.DateTime('Date')
task = fields.Many2One('ekd.project.tasks', 'Task', required=True)
hours = fields.Float('Time Spent')
employee = fields.Many2One('company.employee', 'Done by', required=True)
model_ref = fields.Reference(string='Reference by model', selection=_MODEL_WORKS, required=True)
notes = fields.Text('Notes')
class AssetRevision(ModelSQL, ModelView):
"Asset Revision"
__name__ = 'account.asset.revision'
currency = fields.Function(
fields.Many2One('currency.currency', "Currency"),
'on_change_with_currency')
value = Monetary("Asset Value",
currency='currency',
digits='currency',
required=True)
residual_value = Monetary("Residual Value",
currency='currency',
digits='currency',
required=True)
end_date = fields.Date("End Date", required=True)
origin = fields.Reference("Origin", selection='get_origins', select=True)
description = fields.Char("Description")
asset = fields.Many2One('account.asset',
"Asset",
select=True,
required=True)
@classmethod
def __setup__(cls):
super().__setup__()
cls.__access__.add('asset')
@fields.depends('asset', '_parent_asset.currency')
def on_change_with_currency(self, name=None):
if self.asset and self.asset.currency:
return self.asset.currency.id
@fields.depends('origin', 'value', 'asset', '_parent_asset.value')
def on_change_origin(self, name=None):
pool = Pool()
InvoiceLine = pool.get('account.invoice.line')
if isinstance(self.origin, InvoiceLine) and self.origin.id >= 0:
self.value = self.asset.value + self.origin.amount
@staticmethod
def _get_origin():
"Return list of Model names for origin Reference"
return ['account.invoice.line']
@classmethod
def get_origins(cls):
pool = Pool()
IrModel = pool.get('ir.model')
get_name = IrModel.get_name
models = cls._get_origin()
return [(None, '')] + [(m, get_name(m)) for m in models]
class ReferenceDomainValidation(ModelSQL):
"Reference Domain Validation"
__name__ = 'test.reference_domainvalidation'
reference = fields.Reference("Reference", selection=[
(None, ''),
('test.reference.target', "Target"),
('test.reference_domainvalidation.target', "Domain Target"),
],
domain={
'test.reference_domainvalidation.target': [
('value', '>', 5),
],
})
class ReferenceDomainValidationPYSON(ModelSQL):
"Reference Domain Validation"
__name__ = 'test.reference_domainvalidation_pyson'
reference = fields.Reference("Reference", selection=[
(None, ''),
('test.reference.target', "Target"),
('test.reference_domainvalidation.target', "Domain Target"),
],
domain={
'test.reference_domainvalidation.target': [
('value', '>', Eval('value')),
],
},
depends=['value'])
value = fields.Integer("Value")
class ModelStorageEvalEnvironment(ModelStorage_):
"Model for EvalEnvironment"
__name__ = 'test.modelstorage.eval_environment'
char = fields.Char("Name")
reference = fields.Reference("Reference", [
('test.modelstorage.eval_environment', "Reference"),
])
multiselection = fields.MultiSelection([
('value1', "Value1"),
('value2', "Value2"),
], "MultiSelection")
many2one = fields.Many2One('test.modelstorage.eval_environment',
"Many2One")
one2many = fields.One2Many('test.modelstorage.eval_environment',
'many2one', "One2Many")
class Activity(ModelSQL, ModelView):
"Activity"
__name__ = 'ir.activity'
type = fields.Char('Type', select=True)
object_record = fields.Reference('Object Record', selection='get_models')
target_record = fields.Reference(
'Target Record', selection='get_models', select=True)
actor = fields.Function(fields.JSON('Actor'), getter='get_actor')
@classmethod
def get_models(cls):
"""
Return all models
"""
Model = Pool().get('ir.model')
return [(model.model, model.name) for model in Model.search([])]
def get_actor(self, name):
return {
'id': self.create_uid.id,
'display_string': self.create_uid.name,
'email': self.create_uid.email
}
