class Configuration(ModelSingleton, ModelSQL, ModelView, MultiValueMixin): 'Product Configuration' __name__ = 'product.configuration' default_cost_price_method = fields.MultiValue(default_cost_price_method) get_cost_price_methods = get_cost_price_methods product_sequence = fields.Many2One( 'ir.sequence', "Variant Sequence", domain=[ ('sequence_type', '=', Id('product', 'sequence_type_product')), ], help="Used to generate the last part of the product code.") template_sequence = fields.Many2One( 'ir.sequence', "Product Sequence", domain=[ ('sequence_type', '=', Id('product', 'sequence_type_template')), ], help="Used to generate the first part of the product code.") @classmethod def default_default_cost_price_method(cls, **pattern): return cls.multivalue_model( 'default_cost_price_method').default_default_cost_price_method()
def __setup__(cls): super(Complaint, cls).__setup__() cls._order.insert(0, ('date', 'DESC')) cls._error_messages.update({ 'delete_draft': ('Complaint "%s" must be in draft ' 'to be deleted.'), }) cls._transitions |= set(( ('draft', 'waiting'), ('waiting', 'draft'), ('waiting', 'approved'), ('waiting', 'rejected'), ('approved', 'done'), ('draft', 'cancelled'), ('waiting', 'cancelled'), ('done', 'draft'), ('cancelled', 'draft'), )) cls._buttons.update({ 'cancel': { 'invisible': ~Eval('state').in_(['draft', 'waiting']), }, 'draft': { 'invisible': ~Eval('state').in_( ['waiting', 'done', 'cancelled']), 'icon': If(Eval('state').in_(['done', 'cancelled']), 'tryton-clear', 'tryton-go-previous'), }, 'wait': { 'invisible': ~Eval('state').in_(['draft']), }, 'approve': { 'invisible': (~Eval('state').in_(['waiting']) & Eval('context', {}).get('groups', []).contains( Id('sale', 'group_sale_admin'))), }, 'reject': { 'invisible': (~Eval('state').in_(['waiting']) & Eval('context', {}).get('groups', []).contains( Id('sale', 'group_sale_admin'))), }, 'process': { 'invisible': ~Eval('state').in_(['approved']), }, }) origin_domain = [] for model, domain in cls._origin_domains().iteritems(): origin_domain = If(Eval('origin_model') == model, domain, origin_domain) cls.origin.domain = [origin_domain] actions_domains = cls._actions_domains() actions_domain = [('action', 'in', actions_domains.pop(None))] for model, actions in actions_domains.iteritems(): actions_domain = If(Eval('origin_model') == model, [('action', 'in', actions)], actions_domain) cls.actions.domain = [actions_domain]
class Plan(ModelSQL, ModelView): 'Commission Plan' __name__ = 'commission.plan' name = fields.Char('Name', required=True, translate=True) commission_product = fields.Many2One('product.product', 'Commission Product', required=True, domain=[ ('type', '=', 'service'), ('default_uom', '=', Id('product', 'uom_unit')), ('template.type', '=', 'service'), ('template.default_uom', '=', Id('product', 'uom_unit')), ]) commission_method = fields.Selection([ ('posting', 'On Posting'), ('payment', 'On Payment'), ], 'Commission Method', help='When the commission is due') lines = fields.One2Many('commission.plan.line', 'plan', 'Lines') @staticmethod def default_commission_method(): return 'posting' def get_context_formula(self, amount, product): return { 'names': { 'amount': amount, }, } def compute(self, amount, product, pattern=None): 'Compute commission amount for the amount' def parents(categories): for category in categories: while category: yield category category = category.parent if pattern is None: pattern = {} if product: pattern['categories'] = [ c.id for c in parents(product.categories_all) ] pattern['product'] = product.id else: pattern['categories'] = [] pattern['product'] = None context = self.get_context_formula(amount, product) for line in self.lines: if line.match(pattern): return line.get_amount(**context)
class Configuration(ModelSingleton, ModelSQL, ModelView, CompanyMultiValueMixin): 'Configuration' __name__ = 'lims.administrative.task.configuration' task_sequence = fields.MultiValue( fields.Many2One('ir.sequence', 'Task Sequence', required=True, domain=[ ('sequence_type', '=', Id('lims_administrative_task', 'seq_type_task')), ('company', 'in', [Eval('context', {}).get('company', -1), None]), ])) email_responsible_subject = fields.Char( 'Subject of the task' ' assignment email', help='In the text will be added suffix with the task number') @classmethod def multivalue_model(cls, field): pool = Pool() if field == 'task_sequence': return pool.get('lims.administrative.task.configuration.sequence') return super().multivalue_model(field) @classmethod def default_task_sequence(cls, **pattern): return cls.multivalue_model('task_sequence').default_task_sequence()
def __setup__(cls): super(Invoice, cls).__setup__() cls._buttons.update({ 'cancel': { 'invisible': (~Eval('state').in_(['draft', 'validated']) & ~((Eval('state') == 'posted') & Eval('type').in_(['in_invoice', 'in_credit_note']))), }, 'draft': { 'invisible': (~Eval('state').in_(['cancel', 'validated']) | ((Eval('state') == 'cancel') & Eval('cancel_move'))), 'icon': If( Eval('state') == 'cancel', 'tryton-clear', 'tryton-go-previous'), }, 'validate_invoice': { 'invisible': Eval('state') != 'draft', }, 'post': { 'invisible': ~Eval('state').in_(['draft', 'validated']), 'readonly': Eval('state') == 'draft', }, 'pay': { 'invisible': Eval('state') != 'posted', 'readonly': ~Eval('groups', []).contains(Id('account', 'group_account')), }, })
class Configuration(metaclass=PoolMeta): __name__ = 'lims.configuration' analysis_sheet_sequence = fields.MultiValue( fields.Many2One('ir.sequence', 'Analysis Sheet Sequence', required=True, domain=[ ('sequence_type', '=', Id('lims_analysis_sheet', 'seq_type_analysis_sheet')), ('company', 'in', [Eval('context', {}).get('company', -1), None]), ])) planification_update_draft_sheet = fields.Boolean( 'Update draft sheets when planning analyzes') @staticmethod def default_planification_update_draft_sheet(): return False @classmethod def default_analysis_sheet_sequence(cls, **pattern): return cls.multivalue_model( 'analysis_sheet_sequence').default_analysis_sheet_sequence() @classmethod def multivalue_model(cls, field): pool = Pool() if field == 'analysis_sheet_sequence': return pool.get('lims.configuration.sequence') return super().multivalue_model(field)
class BoxType(ModelSQL, ModelView): "Carrier Box Type" __name__ = 'carrier.box_type' #: Name of the box. name = fields.Char('Name', required=True) #: Same as `carrier.carrier_cost_method`. carrier_cost_method = fields.Selection([(None, '')], 'Carrier Cost Method') #: Code of the box. code = fields.Char('Code') #: Length of the box. length = fields.Float('Length') #: Width of the box. width = fields.Float('Width') #: Height of the box. height = fields.Float('Height') #: Measuring unit of length, height and width. distance_unit = fields.Many2One('product.uom', 'Distance Unit', states={ 'required': Or(Bool(Eval('length')), Bool(Eval('width')), Bool(Eval('height'))) }, domain=[('category', '=', Id('product', 'uom_cat_length'))], depends=['length', 'width', 'height'])
class Assign(Wizard): 'Assign Production' __name__ = 'production.assign' start = StateTransition() failed = StateView('production.assign.failed', 'production.assign_failed_view_form', [ Button('Force Assign', 'force', 'tryton-forward', states={ 'invisible': ~Id('stock', 'group_stock_force_assignment').in_( Eval('context', {}).get('groups', [])), }), Button('OK', 'end', 'tryton-ok', True), ]) force = StateTransition() def transition_start(self): pool = Pool() Production = pool.get('production') if Production.assign_try( [Production(Transaction().context['active_id'])]): return 'end' else: return 'failed' def transition_force(self): pool = Pool() Production = pool.get('production') Production.assign_force( [Production(Transaction().context['active_id'])]) return 'end'
class Configuration(metaclass=PoolMeta): __name__ = 'purchase.configuration' purchase_request_quotation_sequence = fields.MultiValue( fields.Many2One('ir.sequence', 'Purchase Request Quotation Sequence', required=True, domain=[ ('company', 'in', [Eval('context', {}).get('company', -1), None]), ('sequence_type', '=', Id('purchase_request_quotation', 'sequence_type_purchase_request_quotation')), ])) @classmethod def multivalue_model(cls, field): pool = Pool() if field == 'purchase_request_quotation_sequence': return pool.get('purchase.configuration.sequence') return super(Configuration, cls).multivalue_model(field) @classmethod def default_purchase_request_quotation_sequence(cls, **pattern): return cls.multivalue_model( 'purchase_request_quotation_sequence' ).default_purchase_request_quotation_sequence()
class Configuration(metaclass=PoolMeta): __name__ = 'stock.configuration' shipment_drop_sequence = fields.MultiValue( fields.Many2One('ir.sequence', "Drop Shipment Sequence", required=True, domain=[ ('company', 'in', [Eval('context', {}).get('company', -1), None]), ('sequence_type', '=', Id('sale_supply_drop_shipment', 'sequence_type_shipment_drop')), ])) @classmethod def multivalue_model(cls, field): pool = Pool() if field == 'shipment_drop_sequence': return pool.get('stock.configuration.sequence') return super(Configuration, cls).multivalue_model(field) @classmethod def default_shipment_drop_sequence(cls, **pattern): return cls.multivalue_model( 'shipment_drop_sequence').default_shipment_drop_sequence()
class LabWorkYearSequence(metaclass=PoolMeta): __name__ = 'lims.lab.workyear.sequence' project_study_plan_sequence = fields.Many2One('ir.sequence.strict', 'Study plan Projects Sequence', depends=['company'], domain=[ ('sequence_type', '=', Id('lims_project_study_plan', 'seq_type_stp_project')), ('company', 'in', [Eval('company', -1), None]), ])
def __setup__(cls): super(Invoice, cls).__setup__() cls._buttons.update({ 'pay_using_payment_transaction': { 'invisible': Eval('state') != 'posted', 'readonly': ~Eval('groups', []).contains(Id('account', 'group_account')), }, })
class ConfigurationDefaultLotSequence(ModelSQL, ValueMixin): "Product Configuration Default Lot Sequence" __name__ = 'product.configuration.default_lot_sequence' default_lot_sequence = fields.Many2One('ir.sequence', "Default Lot Sequence", domain=[ ('sequence_type', '=', Id('stock_lot', 'sequence_type_stock_lot')), ])
class Configuration(metaclass=PoolMeta): __name__ = 'product.configuration' default_lot_sequence = fields.MultiValue( fields.Many2One('ir.sequence', "Default Lot Sequence", domain=[ ('sequence_type', '=', Id('stock_lot', 'sequence_type_stock_lot')), ]))
def view_attributes(cls): return super(Template, cls).view_attributes() + [ ('//page[@id="esale"]', 'states', { 'invisible': Or( Not(Bool(Eval('salable', False))), ~Eval('context', {}).get('groups', []).contains( Id('esale', 'group_esale'))), }), ('//page[@id="esale"]/notebook/page[@id="general"]', 'states', { 'invisible': Not(Bool(Eval('esale_available'))), }), ]
class ConfigurationSequence(ModelSQL, CompanyValueMixin): 'Configuration Sequence' __name__ = 'lims.configuration.sequence' planification_sequence = fields.Many2One( 'ir.sequence', 'Planification Sequence', depends=['company'], domain=[ ('sequence_type', '=', Id('lims', 'seq_type_planification')), ('company', 'in', [Eval('company', -1), None]), ]) referral_sequence = fields.Many2One('ir.sequence', 'Referral Sequence', depends=['company'], domain=[ ('sequence_type', '=', Id('lims', 'seq_type_referral')), ('company', 'in', [Eval('company', -1), None]), ]) @classmethod def default_planification_sequence(cls): pool = Pool() ModelData = pool.get('ir.model.data') try: return ModelData.get_id('lims.planification', 'seq_planification') except KeyError: return None @classmethod def default_referral_sequence(cls): pool = Pool() ModelData = pool.get('ir.model.data') try: return ModelData.get_id('lims.referral', 'seq_referral') except KeyError: return None
def __setup__(cls): super().__setup__() cls.project_invoice_method.selection.append( ('timesheet', 'On Timesheet')) cls.product.domain = [ cls.product.domain, If( Eval('invoice_method') == 'timesheet', ('default_uom_category', '=', Id('product', 'uom_cat_time')), ()), ] if 'invoice_method' not in cls.product.depends: cls.product.depends.append('invoice_method')
class JournalSequence(ModelSQL, CompanyValueMixin): "Journal Sequence" __name__ = 'account.journal.sequence' journal = fields.Many2One('account.journal', "Journal", ondelete='CASCADE', select=True, context={ 'company': Eval('company', -1), }, depends={'company'}) sequence = fields.Many2One('ir.sequence', "Sequence", domain=[ ('sequence_type', '=', Id('account', 'sequence_type_account_journal')), ('company', 'in', [Eval('company', -1), None]), ], depends={'company'}) @classmethod def __register__(cls, module_name): exist = backend.TableHandler.table_exist(cls._table) super(JournalSequence, cls).__register__(module_name) if not exist: cls._migrate_property([], [], []) @classmethod def _migrate_property(cls, field_names, value_names, fields): field_names.append('sequence') value_names.append('sequence') fields.append('company') migrate_property('account.journal', field_names, cls, value_names, parent='journal', fields=fields) @classmethod def default_sequence(cls): pool = Pool() ModelData = pool.get('ir.model.data') try: return ModelData.get_id('account', 'sequence_account_journal') except KeyError: return None
class Configuration(ModelSingleton, ModelSQL, ModelView): 'Quality configuration' __name__ = 'lims.quality.configuration' sample_location = fields.Many2One('stock.location', 'Sample Location', domain=[('type', '=', 'storage')]) quality_sequence = fields.Many2One('ir.sequence', 'Quality Sequence', required=True, domain=[ ('sequence_type', '=', Id('lims_quality_control', 'sequence_type_quality')), ])
def __setup__(cls): super(Invoice, cls).__setup__() cls._error_messages.update({ 'deposit_not_enough': ('The account "%(account)s" for party "%(party)s" ' 'has not enough deposit.'), }) cls._buttons.update({ 'recall_deposit': { 'invisible': Eval('state') != 'draft', 'readonly': ~Eval('groups', []).contains(Id('account', 'group_account')), }, })
def __setup__(cls): super(Invoice, cls).__setup__() cls._buttons.update({ 'pay_using_payment_transaction': { 'invisible': Or( Eval('state') != 'posted', Eval('type') == 'in', ), 'readonly': ~Eval('groups', []).contains( Id('account', 'group_account')), }, }) cls.__rpc__.update({ 'capture_and_pay_using_transaction': RPC( readonly=False, instantiate=0 ), })
class LabWorkYear(metaclass=PoolMeta): __name__ = 'lims.lab.workyear' project_study_plan_sequence = fields.MultiValue(fields.Many2One( 'ir.sequence.strict', 'Study plan Projects Sequence', required=True, domain=[ ('sequence_type', '=', Id('lims_project_study_plan', 'seq_type_stp_project')), ('company', 'in', [Eval('context', {}).get('company', -1), None]), ])) @classmethod def multivalue_model(cls, field): pool = Pool() if field == 'project_study_plan_sequence': return pool.get('lims.lab.workyear.sequence') return super().multivalue_model(field)
class Configuration( ModelSingleton, ModelSQL, ModelView, CompanyMultiValueMixin): 'Production Configuration' __name__ = 'production.configuration' production_sequence = fields.MultiValue(fields.Many2One( 'ir.sequence', "Production Sequence", required=True, domain=[ ('company', 'in', [Eval('context', {}).get('company', -1), None]), ('sequence_type', '=', Id('production', 'sequence_type_production')), ])) @classmethod def default_production_sequence(cls, **pattern): return cls.multivalue_model( 'production_sequence').default_production_sequence()
class Configuration(metaclass=PoolMeta): __name__ = 'account.configuration' landed_cost_sequence = fields.MultiValue( fields.Many2One('ir.sequence', "Landed Cost Sequence", required=True, domain=[ ('company', 'in', [Eval('context', {}).get('company', -1), None]), ('sequence_type', '=', Id('account_stock_landed_cost', 'sequence_type_landed_cost')), ])) @classmethod def default_landed_cost_sequence(cls, **pattern): return cls.multivalue_model( 'landed_cost_sequence').default_landed_cost_sequence()
class ConfigurationSequence(metaclass=PoolMeta): __name__ = 'sale.configuration.sequence' sample_label_sequence = fields.Many2One('ir.sequence', 'Label Sequence', depends=['company'], domain=[ ('sequence_type', '=', Id('lims_sale_industry', 'seq_type_sample_label')), ('company', 'in', [Eval('company', -1), None]), ]) @classmethod def default_sample_label_sequence(cls): pool = Pool() ModelData = pool.get('ir.model.data') try: return ModelData.get_id('lims_sale_industry', 'sample_label_sequence') except KeyError: return None
class ConfigurationSequence(metaclass=PoolMeta): __name__ = 'lims.configuration.sequence' sample_in_custody_sequence = fields.Many2One('ir.sequence', 'Sample in Custody Sequence', depends=['company'], domain=[ ('sequence_type', '=', Id('lims_project_study_plan', 'seq_type_sample_in_custody')), ('company', 'in', [Eval('company', -1), None]), ]) @classmethod def default_sample_in_custody_sequence(cls): pool = Pool() ModelData = pool.get('ir.model.data') try: return ModelData.get_id('lims.project.sample_in_custody', 'seq_sample_in_custody') except KeyError: return None
class ConfigurationLandedCostSequence(ModelSQL, CompanyValueMixin): "Account Configuration Landed Cost Sequence" __name__ = 'account.configuration.landed_cost_sequence' landed_cost_sequence = fields.Many2One( 'ir.sequence', "Landed Cost Sequence", required=True, domain=[ ('company', 'in', [Eval('company', -1), None]), ('sequence_type', '=', Id('account_stock_landed_cost', 'sequence_type_landed_cost')), ], depends=['company']) @classmethod def __register__(cls, module_name): exist = backend.TableHandler.table_exist(cls._table) super(ConfigurationLandedCostSequence, cls).__register__(module_name) if not exist: cls._migrate_property([], [], []) @classmethod def _migrate_property(cls, field_names, value_names, fields): field_names.append('landed_cost_sequence') value_names.append('landed_cost_sequence') fields.append('company') migrate_property('account.configuration', field_names, cls, value_names, fields=fields) @classmethod def default_landed_cost_sequence(cls, **pattern): pool = Pool() ModelData = pool.get('ir.model.data') try: return ModelData.get_id('account_stock_landed_cost', 'sequence_landed_cost') except KeyError: return None
class Configuration(metaclass=PoolMeta): __name__ = 'account.configuration' asset_sequence = fields.MultiValue( fields.Many2One('ir.sequence', "Asset Reference Sequence", required=True, domain=[ ('company', 'in', [Eval('context', {}).get('company', -1), None]), ('sequence_type', '=', Id('account_asset', 'sequence_type_asset')), ])) asset_bymonthday = fields.MultiValue(asset_bymonthday) asset_bymonth = fields.MultiValue(asset_bymonth) asset_frequency = fields.MultiValue(asset_frequency) get_asset_frequencies = get_asset_selection('frequency') @classmethod def multivalue_model(cls, field): pool = Pool() if field in {'asset_bymonthday', 'asset_bymonth'}: return pool.get('account.configuration.asset_date') return super(Configuration, cls).multivalue_model(field) @classmethod def default_asset_sequence(cls, **pattern): return cls.multivalue_model('asset_sequence').default_asset_sequence() @classmethod def default_asset_bymonthday(cls, **pattern): return cls.multivalue_model( 'asset_bymonthday').default_asset_bymonthday() @classmethod def default_asset_bymonth(cls, **pattern): return cls.multivalue_model('asset_bymonth').default_asset_bymonth() @classmethod def default_asset_frequency(cls, **pattern): return cls.multivalue_model( 'asset_frequency').default_asset_frequency()
class ConfigurationSequence(ModelSQL, CompanyValueMixin): "Purchase Configuration Sequence" __name__ = 'purchase.configuration.sequence' purchase_sequence = fields.Many2One('ir.sequence', "Purchase Sequence", required=True, domain=[ ('company', 'in', [Eval('company', -1), None]), ('sequence_type', '=', Id('purchase', 'sequence_type_purchase')), ]) @classmethod def __register__(cls, module_name): exist = backend.TableHandler.table_exist(cls._table) super(ConfigurationSequence, cls).__register__(module_name) if not exist: cls._migrate_property([], [], []) @classmethod def _migrate_property(cls, field_names, value_names, fields): field_names.append('purchase_sequence') value_names.append('purchase_sequence') fields.append('company') migrate_property('purchase.configuration', field_names, cls, value_names, fields=fields) @classmethod def default_purchase_sequence(cls): pool = Pool() ModelData = pool.get('ir.model.data') try: return ModelData.get_id('purchase', 'sequence_purchase') except KeyError: return None
class Configuration(ModelSingleton, ModelSQL, ModelView, CompanyMultiValueMixin): 'Purchase Configuration' __name__ = 'purchase.configuration' purchase_sequence = fields.MultiValue( fields.Many2One('ir.sequence', "Purchase Sequence", required=True, domain=[ ('company', 'in', [Eval('context', {}).get('company', -1), None]), ('sequence_type', '=', Id('purchase', 'sequence_type_purchase')), ])) purchase_invoice_method = fields.MultiValue(purchase_invoice_method) get_purchase_invoice_method = get_purchase_methods('invoice_method') purchase_process_after = fields.TimeDelta( "Process Purchase after", help="The grace period during which confirmed purchase " "can still be reset to draft.\n" "Applied only if a worker queue is activated.") @classmethod def multivalue_model(cls, field): pool = Pool() if field == 'purchase_invoice_method': return pool.get('purchase.configuration.purchase_method') if field == 'purchase_sequence': return pool.get('purchase.configuration.sequence') return super(Configuration, cls).multivalue_model(field) @classmethod def default_purchase_sequence(cls, **pattern): return cls.multivalue_model( 'purchase_sequence').default_purchase_sequence() @classmethod def default_purchase_invoice_method(cls, **pattern): return cls.multivalue_model( 'purchase_invoice_method').default_purchase_invoice_method()