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()