class SkillType(models.Model):
_name = 'hr.skill.type'
_description = "Skill Type"
name = fields.Char(required=True)
skill_ids = fields.One2many('hr.skill', 'skill_type_id', string="Skills", ondelete='cascade')
skill_level_ids = fields.One2many('hr.skill.level', 'skill_type_id', string="Levels", ondelete='cascade')
class Employee(models.Model):
_inherit = 'hr.employee'
resume_line_ids = fields.One2many('hr.resume.line',
'employee_id',
string="Resumé lines")
employee_skill_ids = fields.One2many('hr.employee.skill',
'employee_id',
string="Skills")
@api.model_create_multi
def create(self, vals_list):
res = super(Employee, self).create(vals_list)
resume_lines_values = []
for employee in res:
line_type = self.env.ref('hr_skills.resume_type_experience',
raise_if_not_found=False)
resume_lines_values.append({
'employee_id':
employee.id,
'name':
employee.company_id.name or '',
'date_start':
employee.create_date.date(),
'description':
employee.job_title or '',
'line_type_id':
line_type and line_type.id,
})
self.env['hr.resume.line'].create(resume_lines_values)
return res
class EventEvent(models.Model):
""" Override Event model to add optional questions when buying tickets. """
_inherit = 'event.event'
question_ids = fields.One2many('event.question',
'event_id',
'Questions',
copy=True)
general_question_ids = fields.One2many('event.question',
'event_id',
'General Questions',
domain=[('is_individual', '=',
False)])
specific_question_ids = fields.One2many('event.question',
'event_id',
'Specific Questions',
domain=[('is_individual', '=',
True)])
@api.onchange('event_type_id')
def _onchange_type(self):
super(EventEvent, self)._onchange_type()
if self.event_type_id.use_questions and self.event_type_id.question_ids:
self.question_ids = [(5, 0, 0)] + [
(0, 0, {
'title': question.title,
'sequence': question.sequence,
'is_individual': question.is_individual,
}) for question in self.event_type_id.question_ids
]
class One2ManyMultiple(models.Model):
_name = 'export.one2many.multiple'
_description = 'Export One To Many Multiple'
parent_id = fields.Many2one('export.one2many.recursive')
const = fields.Integer(default=36)
child1 = fields.One2many('export.one2many.child.1', 'parent_id')
child2 = fields.One2many('export.one2many.child.2', 'parent_id')
class EmployeePublic(models.Model):
_inherit = 'hr.employee.public'
resume_line_ids = fields.One2many('hr.resume.line',
'employee_id',
string="Resumé lines")
employee_skill_ids = fields.One2many('hr.employee.skill',
'employee_id',
string="Skills")
class AccountMoveLine(models.Model):
_inherit = 'account.move.line'
repair_line_ids = fields.One2many('repair.line',
'invoice_line_id',
readonly=True,
copy=False)
repair_fee_ids = fields.One2many('repair.fee',
'invoice_line_id',
readonly=True,
copy=False)
class ModuleCategory(models.Model):
_name = "ir.module.category"
_description = "Application"
_order = 'name'
@api.depends('module_ids')
def _compute_module_nr(self):
cr = self._cr
cr.execute(
'SELECT category_id, COUNT(*) \
FROM ir_module_module \
WHERE category_id IN %(ids)s \
OR category_id IN (SELECT id \
FROM ir_module_category \
WHERE parent_id IN %(ids)s) \
GROUP BY category_id', {'ids': tuple(self.ids)})
result = dict(cr.fetchall())
for cat in self.filtered('id'):
cr.execute('SELECT id FROM ir_module_category WHERE parent_id=%s',
(cat.id, ))
cat.module_nr = sum([result.get(c, 0) for (c, ) in cr.fetchall()],
result.get(cat.id, 0))
name = fields.Char(string='Name',
required=True,
translate=True,
index=True)
parent_id = fields.Many2one('ir.module.category',
string='Parent Application',
index=True)
child_ids = fields.One2many('ir.module.category',
'parent_id',
string='Child Applications')
module_nr = fields.Integer(string='Number of Apps',
compute='_compute_module_nr')
module_ids = fields.One2many('ir.module.module',
'category_id',
string='Modules')
description = fields.Text(string='Description', translate=True)
sequence = fields.Integer(string='Sequence')
visible = fields.Boolean(string='Visible', default=True)
exclusive = fields.Boolean(string='Exclusive')
xml_id = fields.Char(string='External ID', compute='_compute_xml_id')
def _compute_xml_id(self):
xml_ids = defaultdict(list)
domain = [('model', '=', self._name), ('res_id', 'in', self.ids)]
for data in self.env['ir.model.data'].sudo().search_read(
domain, ['module', 'name', 'res_id']):
xml_ids[data['res_id']].append("%s.%s" %
(data['module'], data['name']))
for cat in self:
cat.xml_id = xml_ids.get(cat.id, [''])[0]
class ModelActiveField(models.Model):
_name = 'test_new_api.model_active_field'
_description = 'A model with active field'
active = fields.Boolean(default=True)
parent_id = fields.Many2one('test_new_api.model_active_field')
children_ids = fields.One2many('test_new_api.model_active_field', 'parent_id')
all_children_ids = fields.One2many('test_new_api.model_active_field', 'parent_id',
context={'active_test': False})
active_children_ids = fields.One2many('test_new_api.model_active_field', 'parent_id',
context={'active_test': True})
parent_active = fields.Boolean(string='Active Parent', related='parent_id.active', store=True)
class LunchProductCategory(models.Model):
""" Category of the product such as pizza, sandwich, pasta, chinese, burger... """
_name = 'lunch.product.category'
_inherit = 'image.mixin'
_description = 'Lunch Product Category'
name = fields.Char('Product Category', required=True)
company_id = fields.Many2one('res.company', default=lambda self: self.env.company)
currency_id = fields.Many2one('res.currency', related='company_id.currency_id')
topping_label_1 = fields.Char('Extra 1 Label', required=True, default='Extras')
topping_label_2 = fields.Char('Extra 2 Label', required=True, default='Beverages')
topping_label_3 = fields.Char('Extra 3 Label', required=True, default='Extra Label 3')
topping_ids_1 = fields.One2many('lunch.topping', 'category_id', domain=[('topping_category', '=', 1)], ondelete='cascade')
topping_ids_2 = fields.One2many('lunch.topping', 'category_id', domain=[('topping_category', '=', 2)], ondelete='cascade')
topping_ids_3 = fields.One2many('lunch.topping', 'category_id', domain=[('topping_category', '=', 3)], ondelete='cascade')
topping_quantity_1 = fields.Selection([
('0_more', 'None or More'),
('1_more', 'One or More'),
('1', 'Only One')], 'Extra 1 Quantity', default='0_more', required=True)
topping_quantity_2 = fields.Selection([
('0_more', 'None or More'),
('1_more', 'One or More'),
('1', 'Only One')], 'Extra 2 Quantity', default='0_more', required=True)
topping_quantity_3 = fields.Selection([
('0_more', 'None or More'),
('1_more', 'One or More'),
('1', 'Only One')], 'Extra 3 Quantity', default='0_more', required=True)
product_count = fields.Integer(compute='_compute_product_count', help="The number of products related to this category")
def _compute_product_count(self):
product_data = self.env['lunch.product'].read_group([('category_id', 'in', self.ids)], ['category_id'], ['category_id'])
data = {product['category_id'][0]: product['category_id_count'] for product in product_data}
for category in self:
category.product_count = data.get(category.id, 0)
@api.model
def create(self, vals):
for topping in vals.get('topping_ids_2', []):
topping[2].update({'topping_category': 2})
for topping in vals.get('topping_ids_3', []):
topping[2].update({'topping_category': 3})
return super(LunchProductCategory, self).create(vals)
def write(self, vals):
for topping in vals.get('topping_ids_2', []):
topping_values = topping[2]
if topping_values:
topping_values.update({'topping_category': 2})
for topping in vals.get('topping_ids_3', []):
topping_values = topping[2]
if topping_values:
topping_values.update({'topping_category': 3})
return super(LunchProductCategory, self).write(vals)
class SaleOrderLine(models.Model):
_inherit = "sale.order.line"
name_short = fields.Char(compute="_compute_name_short")
linked_line_id = fields.Many2one('sale.order.line', string='Linked Order Line', domain="[('order_id', '!=', order_id)]", ondelete='cascade')
option_line_ids = fields.One2many('sale.order.line', 'linked_line_id', string='Options Linked')
def get_sale_order_line_multiline_description_sale(self, product):
description = super(SaleOrderLine, self).get_sale_order_line_multiline_description_sale(product)
if self.linked_line_id:
description += "\n" + _("Option for: %s") % self.linked_line_id.product_id.display_name
if self.option_line_ids:
description += "\n" + '\n'.join([_("Option: %s") % option_line.product_id.display_name for option_line in self.option_line_ids])
return description
@api.depends('product_id.display_name')
def _compute_name_short(self):
""" Compute a short name for this sale order line, to be used on the website where we don't have much space.
To keep it short, instead of using the first line of the description, we take the product name without the internal reference.
"""
for record in self:
record.name_short = record.product_id.with_context(display_default_code=False).display_name
def get_description_following_lines(self):
return self.name.splitlines()[1:]
class SlidePartnerRelation(models.Model):
_inherit = 'slide.slide.partner'
user_input_ids = fields.One2many('survey.user_input', 'slide_partner_id',
'Certification attempts')
survey_quizz_passed = fields.Boolean(
'Certification Quizz Passed',
compute='_compute_survey_quizz_passed',
store=True)
@api.depends('partner_id', 'user_input_ids.quizz_passed')
def _compute_survey_quizz_passed(self):
passed_user_inputs = self.env['survey.user_input'].sudo().search([
('slide_partner_id', 'in', self.ids), ('quizz_passed', '=', True)
])
passed_slide_partners = passed_user_inputs.mapped('slide_partner_id')
for record in self:
record.survey_quizz_passed = record in passed_slide_partners
@api.model_create_multi
def create(self, vals_list):
res = super(SlidePartnerRelation, self).create(vals_list)
completed = res.filtered('survey_quizz_passed')
if completed:
completed.write({'completed': True})
return res
def _write(self, vals):
res = super(SlidePartnerRelation, self)._write(vals)
if vals.get('survey_quizz_passed'):
self.sudo().write({'completed': True})
return res
class EventType(models.Model):
_inherit = 'event.type'
@api.model
def _get_default_event_ticket_ids(self):
product = self.env.ref('event_sale.product_product_event',
raise_if_not_found=False)
if not product:
return False
return [(0, 0, {
'name': _('Registration'),
'product_id': product.id,
'price': 0,
})]
use_ticketing = fields.Boolean('Ticketing')
event_ticket_ids = fields.One2many('event.event.ticket',
'event_type_id',
string='Tickets',
default=_get_default_event_ticket_ids)
@api.onchange('name')
def _onchange_name(self):
if self.name:
self.event_ticket_ids.filtered(
lambda ticket: ticket.name == _('Registration')).update(
{'name': _('Registration for %s') % self.name})
class RatingParentMixin(models.AbstractModel):
_name = 'rating.parent.mixin'
_description = "Rating Parent Mixin"
_rating_satisfaction_days = False # Number of last days used to compute parent satisfaction. Set to False to include all existing rating.
rating_ids = fields.One2many('rating.rating', 'parent_res_id', string='Ratings', domain=lambda self: [('parent_res_model', '=', self._name)], auto_join=True)
rating_percentage_satisfaction = fields.Integer("Rating Satisfaction", compute="_compute_rating_percentage_satisfaction", store=False, help="Percentage of happy ratings")
@api.depends('rating_ids.rating', 'rating_ids.consumed')
def _compute_rating_percentage_satisfaction(self):
# build domain and fetch data
domain = [('parent_res_model', '=', self._name), ('parent_res_id', 'in', self.ids), ('rating', '>=', 1), ('consumed', '=', True)]
if self._rating_satisfaction_days:
domain += [('write_date', '>=', fields.Datetime.to_string(fields.datetime.now() - timedelta(days=self._rating_satisfaction_days)))]
data = self.env['rating.rating'].read_group(domain, ['parent_res_id', 'rating'], ['parent_res_id', 'rating'], lazy=False)
# get repartition of grades per parent id
default_grades = {'great': 0, 'okay': 0, 'bad': 0}
grades_per_parent = dict((parent_id, dict(default_grades)) for parent_id in self.ids) # map: {parent_id: {'great': 0, 'bad': 0, 'ok': 0}}
for item in data:
parent_id = item['parent_res_id']
rating = item['rating']
if rating >= RATING_LIMIT_SATISFIED:
grades_per_parent[parent_id]['great'] += item['__count']
elif rating > RATING_LIMIT_OK:
grades_per_parent[parent_id]['okay'] += item['__count']
else:
grades_per_parent[parent_id]['bad'] += item['__count']
# compute percentage per parent
for record in self:
repartition = grades_per_parent.get(record.id)
record.rating_percentage_satisfaction = repartition['great'] * 100 / sum(repartition.values()) if sum(repartition.values()) else -1
class CrmTeam(models.Model):
_inherit = 'crm.team'
pos_config_ids = fields.One2many('pos.config',
'crm_team_id',
string="Point of Sales")
pos_sessions_open_count = fields.Integer(
string='Open POS Sessions', compute='_compute_pos_sessions_open_count')
pos_order_amount_total = fields.Float(
string="Session Sale Amount",
compute='_compute_pos_order_amount_total')
def _compute_pos_sessions_open_count(self):
for team in self:
team.pos_sessions_open_count = self.env[
'pos.session'].search_count([('config_id.crm_team_id',
'=', team.id),
('state', '=', 'opened')])
def _compute_pos_order_amount_total(self):
for team in self:
team.pos_order_amount_total = sum(
self.env['report.pos.order'].search([
('session_id', 'in',
team.pos_config_ids.mapped('session_ids').filtered(
lambda s: s.state == 'opened').ids)
]).mapped('price_total'))
class ThemeAttachment(models.Model):
_name = 'theme.ir.attachment'
_description = 'Theme Attachments'
name = fields.Char(required=True)
key = fields.Char(required=True)
url = fields.Char()
copy_ids = fields.One2many('ir.attachment',
'theme_template_id',
'Attachment using a copy of me',
copy=False,
readonly=True)
def _convert_to_base_model(self, website, **kwargs):
self.ensure_one()
new_attach = {
'key': self.key,
'public': True,
'res_model': 'ir.ui.view',
'type': 'url',
'name': self.name,
'url': self.url,
'website_id': website.id,
'theme_template_id': self.id,
}
return new_attach
class ThemePage(models.Model):
_name = 'theme.website.page'
_description = 'Website Theme Page'
url = fields.Char()
view_id = fields.Many2one('theme.ir.ui.view',
required=True,
ondelete="cascade")
website_indexed = fields.Boolean('Page Indexed', default=True)
copy_ids = fields.One2many('website.page',
'theme_template_id',
'Page using a copy of me',
copy=False,
readonly=True)
def _convert_to_base_model(self, website, **kwargs):
self.ensure_one()
view_id = self.view_id.copy_ids.filtered(
lambda x: x.website_id == website)
if not view_id:
# inherit_id not yet created, add to the queue
return False
new_page = {
'url': self.url,
'view_id': view_id.id,
'website_indexed': self.website_indexed,
'theme_template_id': self.id,
}
return new_page
class ThemeMenu(models.Model):
_name = 'theme.website.menu'
_description = 'Website Theme Menu'
name = fields.Char(required=True, translate=True)
url = fields.Char(default='')
page_id = fields.Many2one('theme.website.page', ondelete='cascade')
new_window = fields.Boolean('New Window')
sequence = fields.Integer()
parent_id = fields.Many2one('theme.website.menu',
index=True,
ondelete="cascade")
copy_ids = fields.One2many('website.menu',
'theme_template_id',
'Menu using a copy of me',
copy=False,
readonly=True)
def _convert_to_base_model(self, website, **kwargs):
self.ensure_one()
page_id = self.page_id.copy_ids.filtered(
lambda x: x.website_id == website)
parent_id = self.copy_ids.filtered(lambda x: x.website_id == website)
new_menu = {
'name': self.name,
'url': self.url,
'page_id': page_id and page_id.id or False,
'new_window': self.new_window,
'sequence': self.sequence,
'parent_id': parent_id and parent_id.id or False,
'theme_template_id': self.id,
}
return new_menu
class AccountAnalyticGroup(models.Model):
_name = 'account.analytic.group'
_description = 'Analytic Categories'
_parent_store = True
_rec_name = 'complete_name'
name = fields.Char(required=True)
description = fields.Text(string='Description')
parent_id = fields.Many2one(
'account.analytic.group',
string="Parent",
ondelete='cascade',
domain=
"['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
parent_path = fields.Char(index=True)
children_ids = fields.One2many('account.analytic.group',
'parent_id',
string="Childrens")
complete_name = fields.Char('Complete Name',
compute='_compute_complete_name',
store=True)
company_id = fields.Many2one('res.company',
string='Company',
default=lambda self: self.env.company)
@api.depends('name', 'parent_id.complete_name')
def _compute_complete_name(self):
for group in self:
if group.parent_id:
group.complete_name = '%s / %s' % (
group.parent_id.complete_name, group.name)
else:
group.complete_name = group.name
class ResPartner(models.Model):
_inherit = 'res.partner'
wishlist_ids = fields.One2many('product.wishlist',
'partner_id',
string='Wishlist',
domain=[('active', '=', True)])
class ChooseDestinationLocation(models.TransientModel):
_name = 'stock.package.destination'
_description = 'Stock Package Destination'
picking_id = fields.Many2one('stock.picking', required=True)
move_line_ids = fields.Many2many('stock.move.line',
'Products',
compute='_compute_move_line_ids',
required=True)
location_dest_id = fields.Many2one('stock.location',
'Destination location',
required=True)
filtered_location = fields.One2many(comodel_name='stock.location',
compute='_filter_location')
@api.depends('picking_id')
def _compute_move_line_ids(self):
for destination in self:
destination.move_line_ids = destination.picking_id.move_line_ids.filtered(
lambda l: l.qty_done > 0 and not l.result_package_id)
@api.depends('move_line_ids')
def _filter_location(self):
for destination in self:
destination.filtered_location = destination.move_line_ids.mapped(
'location_dest_id')
def action_done(self):
# set the same location on each move line and pass again in _put_in_pack
for line in self.move_line_ids:
line.location_dest_id = self.location_dest_id
return self.picking_id.put_in_pack()
class BaseModel(models.Model):
_name = 'test_performance.base'
_description = 'Test Performance Base'
name = fields.Char()
value = fields.Integer(default=0)
value_pc = fields.Float(compute="_value_pc", store=True)
value_ctx = fields.Float(compute="_value_ctx")
partner_id = fields.Many2one('res.partner', string='Customer')
line_ids = fields.One2many('test_performance.line', 'base_id')
total = fields.Integer(compute="_total", store=True)
tag_ids = fields.Many2many('test_performance.tag')
@api.depends('value')
def _value_pc(self):
for record in self:
record.value_pc = float(record.value) / 100
@api.depends_context('key')
def _value_ctx(self):
self.env.cr.execute('SELECT 42') # one dummy query per batch
for record in self:
record.value_ctx = self.env.context.get('key')
@api.depends('line_ids.value')
def _total(self):
for record in self:
record.total = sum(line.value for line in record.line_ids)
class Event(models.Model):
_inherit = 'event.event'
event_ticket_ids = fields.One2many('event.event.ticket',
'event_id',
string='Event Ticket',
copy=True)
@api.onchange('event_type_id')
def _onchange_type(self):
super(Event, self)._onchange_type()
if self.event_type_id.use_ticketing:
self.event_ticket_ids = [(5, 0, 0)] + [(0, 0, {
'name':
self.name and _('Registration for %s') % self.name
or ticket.name,
'product_id':
ticket.product_id.id,
'price':
ticket.price,
}) for ticket in self.event_type_id.event_ticket_ids]
def _is_event_registrable(self):
if super(Event, self)._is_event_registrable():
self.ensure_one()
return all(
self.event_ticket_ids.with_context(
active_test=False).mapped(lambda t: t.product_id.active))
else:
return False
class SaleOrderLine(models.Model):
_inherit = "sale.order.line"
purchase_line_ids = fields.One2many('purchase.order.line', 'sale_line_id')
def _get_qty_procurement(self, previous_product_uom_qty):
# People without purchase rights should be able to do this operation
purchase_lines_sudo = self.sudo().purchase_line_ids
if purchase_lines_sudo.filtered(lambda r: r.state != 'cancel'):
qty = 0.0
for po_line in purchase_lines_sudo.filtered(
lambda r: r.state != 'cancel'):
qty += po_line.product_uom._compute_quantity(
po_line.product_qty,
self.product_uom,
rounding_method='HALF-UP')
return qty
else:
return super(SaleOrderLine, self)._get_qty_procurement(
previous_product_uom_qty=previous_product_uom_qty)
def _compute_is_mto(self):
super(SaleOrderLine, self)._compute_is_mto()
for line in self:
if not line.display_qty_widget or line.is_mto:
continue
product_routes = line.route_id or (
line.product_id.route_ids +
line.product_id.categ_id.total_route_ids)
for pull_rule in product_routes.mapped('rule_ids'):
if pull_rule.picking_type_id.sudo().default_location_src_id.usage == 'supplier' and\
pull_rule.picking_type_id.sudo().default_location_dest_id.usage == 'customer':
line.is_mto = True
break
class ResCompany(models.Model):
_inherit = 'res.company'
resource_calendar_ids = fields.One2many('resource.calendar', 'company_id',
'Working Hours')
resource_calendar_id = fields.Many2one('resource.calendar',
'Default Working Hours',
ondelete='restrict')
@api.model
def _init_data_resource_calendar(self):
self.search([('resource_calendar_id', '=', False)
])._create_resource_calendar()
def _create_resource_calendar(self):
for company in self:
company.resource_calendar_id = self.env[
'resource.calendar'].create({
'name': _('Standard 40 hours/week'),
'company_id': company.id
}).id
@api.model
def create(self, values):
company = super(ResCompany, self).create(values)
if not company.resource_calendar_id:
company.sudo()._create_resource_calendar()
# calendar created from form view: no company_id set because record was still not created
if not company.resource_calendar_id.company_id:
company.resource_calendar_id.company_id = company.id
return company
class AccountMove(models.Model):
_inherit = 'account.move'
repair_ids = fields.One2many('repair.order',
'invoice_id',
readonly=True,
copy=False)
class AccountJournal(models.Model):
_inherit = 'account.journal'
pos_payment_method_ids = fields.One2many(
'pos.payment.method',
'cash_journal_id',
string='Point of Sale Payment Methods')
class Product(models.Model):
_inherit = "product.product"
website_id = fields.Many2one(related='product_tmpl_id.website_id',
readonly=False)
product_variant_image_ids = fields.One2many('product.image',
'product_variant_id',
string="Extra Variant Images")
website_url = fields.Char(
'Website URL',
compute='_compute_product_website_url',
help='The full URL to access the document through the website.')
@api.depends_context('lang')
@api.depends('product_tmpl_id.website_url',
'product_template_attribute_value_ids')
def _compute_product_website_url(self):
for product in self:
attributes = ','.join(
str(x)
for x in product.product_template_attribute_value_ids.ids)
product.website_url = "%s#attr=%s" % (
product.product_tmpl_id.website_url, attributes)
def website_publish_button(self):
self.ensure_one()
return self.product_tmpl_id.website_publish_button()
def open_website_url(self):
self.ensure_one()
res = self.product_tmpl_id.open_website_url()
res['url'] = self.website_url
return res
def _get_images(self):
"""Return a list of records implementing `image.mixin` to
display on the carousel on the website for this variant.
This returns a list and not a recordset because the records might be
from different models (template, variant and image).
It contains in this order: the main image of the variant (if set), the
Variant Extra Images, and the Template Extra Images.
"""
self.ensure_one()
variant_images = list(self.product_variant_image_ids)
if self.image_variant_1920:
# if the main variant image is set, display it first
variant_images = [self] + variant_images
else:
# If the main variant image is empty, it will fallback to template
# image, in this case insert it after the other variant images, so
# that all variant images are first and all template images last.
variant_images = variant_images + [self]
# [1:] to remove the main image from the template, we only display
# the template extra images here
return variant_images + self.product_tmpl_id._get_images()[1:]
class AttachmentHost(models.Model):
_name = 'test_new_api.attachment.host'
_description = 'Attachment Host'
attachment_ids = fields.One2many(
'test_new_api.attachment', 'res_id', auto_join=True,
domain=lambda self: [('res_model', '=', self._name)],
)
class Discussion(models.Model):
_name = 'test_new_api.discussion'
_description = 'Test New API Discussion'
name = fields.Char(string='Title', required=True,
help="General description of what this discussion is about.")
moderator = fields.Many2one('res.users')
categories = fields.Many2many('test_new_api.category',
'test_new_api_discussion_category', 'discussion', 'category')
participants = fields.Many2many('res.users', context={'active_test': False})
messages = fields.One2many('test_new_api.message', 'discussion', copy=True)
message_concat = fields.Text(string='Message concatenate')
important_messages = fields.One2many('test_new_api.message', 'discussion',
domain=[('important', '=', True)])
very_important_messages = fields.One2many(
'test_new_api.message', 'discussion',
domain=lambda self: self._domain_very_important())
emails = fields.One2many('test_new_api.emailmessage', 'discussion')
important_emails = fields.One2many('test_new_api.emailmessage', 'discussion',
domain=[('important', '=', True)])
def _domain_very_important(self):
"""Ensure computed O2M domains work as expected."""
return [("important", "=", True)]
@api.onchange('name')
def _onchange_name(self):
# test onchange modifying one2many field values
if self.env.context.get('generate_dummy_message') and self.name == '{generate_dummy_message}':
# update body of existings messages and emails
for message in self.messages:
message.body = 'not last dummy message'
for message in self.important_messages:
message.body = 'not last dummy message'
# add new dummy message
message_vals = self.messages._add_missing_default_values({'body': 'dummy message', 'important': True})
self.messages |= self.messages.new(message_vals)
self.important_messages |= self.messages.new(message_vals)
@api.onchange('moderator')
def _onchange_moderator(self):
self.participants |= self.moderator
@api.onchange('messages')
def _onchange_messages(self):
self.message_concat = "\n".join(["%s:%s" % (m.name, m.body) for m in self.messages])
class ResUsers(models.Model):
_inherit = 'res.users'
resource_ids = fields.One2many('resource.resource', 'user_id', 'Resources')
resource_calendar_id = fields.Many2one('resource.calendar',
'Default Working Hours',
related='resource_ids.calendar_id',
readonly=False)