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 }