class AccountTaxTemplatePython(models.Model):
_inherit = 'account.tax.template'
amount_type = fields.Selection(selection_add=[('code', 'Python Code')])
python_compute = fields.Text(string='Python Code', default="result = price_unit * 0.10",
help="Compute the amount of the tax by setting the variable 'result'.\n\n"
":param base_amount: float, actual amount on which the tax is applied\n"
":param price_unit: float\n"
":param quantity: float\n"
":param product: product.product recordset singleton or None\n"
":param partner: res.partner recordset singleton or None")
python_applicable = fields.Text(string='Applicable Code', default="result = True",
help="Determine if the tax will be applied by setting the variable 'result' to True or False.\n\n"
":param price_unit: float\n"
":param quantity: float\n"
":param product: product.product recordset singleton or None\n"
":param partner: res.partner recordset singleton or None")
def _get_tax_vals(self, company, tax_template_to_tax):
""" This method generates a dictionnary of all the values for the tax that will be created.
"""
self.ensure_one()
res = super(AccountTaxTemplatePython, self)._get_tax_vals(company, tax_template_to_tax)
res['python_compute'] = self.python_compute
res['python_applicable'] = self.python_applicable
return res
class res_company(models.Model):
_inherit = "res.company"
gengo_private_key = fields.Char(string="Gengo Private Key",
copy=False,
groups="base.group_system")
gengo_public_key = fields.Text(string="Gengo Public Key",
copy=False,
groups="base.group_user")
gengo_comment = fields.Text(
string="Comments",
groups="base.group_user",
help=
"This comment will be automatically be enclosed in each an every request sent to Gengo"
)
gengo_auto_approve = fields.Boolean(
string="Auto Approve Translation ?",
groups="base.group_user",
default=True,
help="Jobs are Automatically Approved by Gengo.")
gengo_sandbox = fields.Boolean(
string="Sandbox Mode",
help=
"Check this box if you're using the sandbox mode of Gengo, mainly used for testing purpose."
)
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
gengo_private_key = fields.Char(string="Gengo Private Key", related="company_id.gengo_private_key", readonly=False)
gengo_public_key = fields.Text(string="Gengo Public Key", related="company_id.gengo_public_key", readonly=False)
gengo_comment = fields.Text(string="Comments", related="company_id.gengo_comment",
help="This comment will be automatically be enclosed in each an every request sent to Gengo")
gengo_auto_approve = fields.Boolean(string="Auto Approve Translation ?", related="company_id.gengo_auto_approve", readonly=False,
help="Jobs are Automatically Approved by Gengo.")
gengo_sandbox = fields.Boolean(string="Sandbox Mode", related="company_id.gengo_sandbox", readonly=False,
help="Check this box if you're using the sandbox mode of Gengo, mainly used for testing purpose.")
class pos_cache(models.Model):
_name = 'pos.cache'
_description = 'Point of Sale Cache'
cache = fields.Binary(attachment=True)
product_domain = fields.Text(required=True)
product_fields = fields.Text(required=True)
config_id = fields.Many2one('pos.config',
ondelete='cascade',
required=True)
compute_user_id = fields.Many2one('res.users',
'Cache compute user',
required=True)
@api.model
def refresh_all_caches(self):
self.env['pos.cache'].search([]).refresh_cache()
def refresh_cache(self):
for cache in self:
Product = self.env['product.product'].with_user(
cache.compute_user_id.id)
products = Product.search(cache.get_product_domain())
prod_ctx = products.with_context(
pricelist=cache.config_id.pricelist_id.id,
display_default_code=False,
lang=cache.compute_user_id.lang)
res = prod_ctx.read(cache.get_product_fields())
cache.write({
'cache':
base64.encodestring(json.dumps(res).encode('utf-8')),
})
@api.model
def get_product_domain(self):
return literal_eval(self.product_domain)
@api.model
def get_product_fields(self):
return literal_eval(self.product_fields)
@api.model
def get_cache(self, domain, fields):
if not self.cache or domain != self.get_product_domain(
) or fields != self.get_product_fields():
self.product_domain = str(domain)
self.product_fields = str(fields)
self.refresh_cache()
return json.loads(base64.decodestring(self.cache).decode('utf-8'))
class AccountingAssertTest(models.Model):
_name = "accounting.assert.test"
_description = 'Accounting Assert Test'
_order = "sequence"
name = fields.Char(string='Test Name',
required=True,
index=True,
translate=True)
desc = fields.Text(string='Test Description', index=True, translate=True)
code_exec = fields.Text(string='Python code',
required=True,
default=CODE_EXEC_DEFAULT)
active = fields.Boolean(default=True)
sequence = fields.Integer(default=10)
class LunchCashMove(models.Model):
""" Two types of cashmoves: payment (credit) or order (debit) """
_name = 'lunch.cashmove'
_description = 'Lunch Cashmove'
_order = 'date desc'
currency_id = fields.Many2one(
'res.currency', default=lambda self: self.env.company.currency_id)
user_id = fields.Many2one('res.users',
'User',
default=lambda self: self.env.uid)
date = fields.Date('Date',
required=True,
default=fields.Date.context_today)
amount = fields.Float('Amount', required=True)
description = fields.Text('Description')
def name_get(self):
return [(cashmove.id,
'%s %s' % (_('Lunch Cashmove'), '#%d' % cashmove.id))
for cashmove in self]
@api.model
def get_wallet_balance(self, user, include_config=True):
result = float_round(sum(
move['amount']
for move in self.env['lunch.cashmove.report'].search_read([(
'user_id', '=', user.id)], ['amount'])),
precision_digits=2)
if include_config:
result += user.company_id.lunch_minimum_threshold
return result
class Rating(models.Model):
_inherit = 'rating.rating'
# Add this related field to mail.message for performance reason
website_published = fields.Boolean(related='message_id.website_published',
store=True,
readonly=False)
# Adding information for comment a rating message
publisher_comment = fields.Text("Publisher Comment")
publisher_id = fields.Many2one('res.partner',
'Commented by',
ondelete='set null',
readonly=True)
publisher_datetime = fields.Datetime("Commented on", readonly=True)
def write(self, values):
if values.get('publisher_comment'):
if not self.env.user.has_group("website.group_website_publisher"):
raise exceptions.AccessError(
_("Only the publisher of the website can change the rating comment"
))
if not values.get('publisher_datetime'):
values['publisher_datetime'] = fields.Datetime.now()
if not values.get('publisher_id'):
values['publisher_id'] = self.env.user.partner_id.id
return super(Rating, self).write(values)
class LunchLocation(models.Model):
_name = 'lunch.location'
_description = 'Lunch Locations'
name = fields.Char('Location Name', required=True)
address = fields.Text('Address')
company_id = fields.Many2one('res.company', default=lambda self: self.env.company)
class grant_badge_wizard(models.TransientModel):
""" Wizard allowing to grant a badge to a user"""
_name = 'gamification.badge.user.wizard'
_description = 'Gamification User Badge Wizard'
user_id = fields.Many2one("res.users", string='User', required=True)
badge_id = fields.Many2one("gamification.badge", string='Badge', required=True)
comment = fields.Text('Comment')
def action_grant_badge(self):
"""Wizard action for sending a badge to a chosen user"""
BadgeUser = self.env['gamification.badge.user']
uid = self.env.uid
for wiz in self:
if uid == wiz.user_id.id:
raise exceptions.UserError(_('You can not grant a badge to yourself.'))
#create the badge
BadgeUser.create({
'user_id': wiz.user_id.id,
'sender_id': uid,
'badge_id': wiz.badge_id.id,
'comment': wiz.comment,
})._send_badge()
return True
class test_model(models.Model):
_name = 'test_converter.test_model'
_description = 'Test Converter Model'
char = fields.Char()
integer = fields.Integer()
float = fields.Float()
numeric = fields.Float(digits=(16, 2))
many2one = fields.Many2one('test_converter.test_model.sub',
group_expand='_gbf_m2o')
binary = fields.Binary(attachment=False)
date = fields.Date()
datetime = fields.Datetime()
selection_str = fields.Selection(
[
('A', u"Qu'il n'est pas arrivé à Toronto"),
('B', u"Qu'il était supposé arriver à Toronto"),
('C', u"Qu'est-ce qu'il fout ce maudit pancake, tabernacle ?"),
('D', u"La réponse D"),
],
string=u"Lorsqu'un pancake prend l'avion à destination de Toronto et "
u"qu'il fait une escale technique à St Claude, on dit:")
html = fields.Html()
text = fields.Text()
# `base` module does not contains any model that implement the functionality
# `group_expand`; test this feature here...
@api.model
def _gbf_m2o(self, subs, domain, order):
sub_ids = subs._search([], order=order, access_rights_uid=SUPERUSER_ID)
return subs.browse(sub_ids)
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 Partner(models.Model):
_inherit = 'res.partner'
_check_company_auto = True
property_stock_customer = fields.Many2one(
'stock.location',
string="Customer Location",
company_dependent=True,
check_company=True,
domain=
"['|', ('company_id', '=', False), ('company_id', '=', allowed_company_ids[0])]",
help=
"The stock location used as destination when sending goods to this contact."
)
property_stock_supplier = fields.Many2one(
'stock.location',
string="Vendor Location",
company_dependent=True,
check_company=True,
domain=
"['|', ('company_id', '=', False), ('company_id', '=', allowed_company_ids[0])]",
help=
"The stock location used as source when receiving goods from this contact."
)
picking_warn = fields.Selection(WARNING_MESSAGE,
'Stock Picking',
help=WARNING_HELP,
default='no-message')
picking_warn_msg = fields.Text('Message for Stock Picking')
class ConverterTest(models.Model):
_name = 'web_editor.converter.test'
_description = 'Web Editor Converter Test'
# disable translation export for those brilliant field labels and values
_translate = False
char = fields.Char()
integer = fields.Integer()
float = fields.Float()
numeric = fields.Float(digits=(16, 2))
many2one = fields.Many2one('web_editor.converter.test.sub')
binary = fields.Binary(attachment=False)
date = fields.Date()
datetime = fields.Datetime()
selection_str = fields.Selection(
[
('A', "Qu'il n'est pas arrivé à Toronto"),
('B', "Qu'il était supposé arriver à Toronto"),
('C', "Qu'est-ce qu'il fout ce maudit pancake, tabernacle ?"),
('D', "La réponse D"),
],
string=u"Lorsqu'un pancake prend l'avion à destination de Toronto et "
u"qu'il fait une escale technique à St Claude, on dit:")
html = fields.Html()
text = fields.Text()
class DeliveryCarrier(models.Model):
_name = 'delivery.carrier'
_inherit = ['delivery.carrier', 'website.published.multi.mixin']
website_description = fields.Text(
related='product_id.description_sale',
string='Description for Online Quotations',
readonly=False)
class SaleOrder(models.Model):
_inherit = "sale.order"
date = fields.Date()
recipients_of_email = fields.Many2many(comodel_name='res.partner',
relation='customer',
column1='partner_id',
column2='partner_name',
string="Recipients of the Email")
subject = fields.Text('Subject')
email_content = fields.Text('Email Content')
@api.model
def send_email_from_customer(self):
today_date = date.today()
current_date = str(today_date)
obj = self.env['sale.order'].search([('state', 'in', ('sale', 'done'))
])
if obj:
context = self._context
current_uid = context.get('uid')
current_login_user = self.env['res.users'].browse(current_uid)
for order in obj:
email_to = []
order_date = str(order.date)
if order and current_date == order_date:
for record in order.recipients_of_email:
if record.email:
email_to.append(record)
if email_to:
mail = {
'subject': order.subject,
'email_from': order.partner_id.email,
'recipient_ids':
[(6, 0, [v.id for v in email_to])],
'body_html': order.email_content,
}
if mail:
mail_create = current_login_user.env[
'mail.mail'].create(mail)
if mail_create:
mail_create.send()
self.mail_id = mail_create
class AccountTaxPython(models.Model):
_inherit = "account.tax"
amount_type = fields.Selection(selection_add=[('code', 'Python Code')])
python_compute = fields.Text(string='Python Code', default="result = price_unit * 0.10",
help="Compute the amount of the tax by setting the variable 'result'.\n\n"
":param base_amount: float, actual amount on which the tax is applied\n"
":param price_unit: float\n"
":param quantity: float\n"
":param company: res.company recordset singleton\n"
":param product: product.product recordset singleton or None\n"
":param partner: res.partner recordset singleton or None")
python_applicable = fields.Text(string='Applicable Code', default="result = True",
help="Determine if the tax will be applied by setting the variable 'result' to True or False.\n\n"
":param price_unit: float\n"
":param quantity: float\n"
":param company: res.company recordset singleton\n"
":param product: product.product recordset singleton or None\n"
":param partner: res.partner recordset singleton or None")
def _compute_amount(self, base_amount, price_unit, quantity=1.0, product=None, partner=None):
self.ensure_one()
if product and product._name == 'product.template':
product = product.product_variant_id
if self.amount_type == 'code':
company = self.env.company
localdict = {'base_amount': base_amount, 'price_unit':price_unit, 'quantity': quantity, 'product':product, 'partner':partner, 'company': company}
safe_eval(self.python_compute, localdict, mode="exec", nocopy=True)
return localdict['result']
return super(AccountTaxPython, self)._compute_amount(base_amount, price_unit, quantity, product, partner)
def compute_all(self, price_unit, currency=None, quantity=1.0, product=None, partner=None, is_refund=False, handle_price_include=True):
taxes = self.filtered(lambda r: r.amount_type != 'code')
company = self.env.company
if product and product._name == 'product.template':
product = product.product_variant_id
for tax in self.filtered(lambda r: r.amount_type == 'code'):
localdict = self._context.get('tax_computation_context', {})
localdict.update({'price_unit': price_unit, 'quantity': quantity, 'product': product, 'partner': partner, 'company': company})
safe_eval(tax.python_applicable, localdict, mode="exec", nocopy=True)
if localdict.get('result', False):
taxes += tax
return super(AccountTaxPython, taxes).compute_all(price_unit, currency, quantity, product, partner, is_refund=is_refund, handle_price_include=handle_price_include)
class Related(models.Model):
_name = 'test_new_api.related'
_description = 'Test New API Related'
name = fields.Char()
# related fields with a single field
related_name = fields.Char(related='name', string='A related on Name', readonly=False)
related_related_name = fields.Char(related='related_name', string='A related on a related on Name', readonly=False)
message = fields.Many2one('test_new_api.message')
message_name = fields.Text(related="message.body", related_sudo=False, string='Message Body')
message_currency = fields.Many2one(related="message.author", string='Message Author')
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 ResCountry(models.Model):
_inherit = 'res.country'
street_format = fields.Text(
help="Format to use for streets belonging to this country.\n\n"
"You can use the python-style string pattern with all the fields of the street "
"(for example, use '%(street_name)s, %(street_number)s' if you want to display "
"the street name, followed by a comma and the house number)"
"\n%(street_name)s: the name of the street"
"\n%(street_number)s: the house number"
"\n%(street_number2)s: the door number",
default='%(street_number)s/%(street_number2)s %(street_name)s', required=True)
class KarmaRank(models.Model):
_name = 'gamification.karma.rank'
_description = 'Rank based on karma'
_inherit = 'image.mixin'
_order = 'karma_min'
name = fields.Text(string='Rank Name', translate=True, required=True)
description = fields.Html(
string='Description',
translate=html_translate,
sanitize_attributes=False,
)
description_motivational = fields.Html(
string='Motivational',
translate=html_translate,
sanitize_attributes=False,
help="Motivational phrase to reach this rank")
karma_min = fields.Integer(string='Required Karma',
help='Minimum karma needed to reach this rank')
user_ids = fields.One2many('res.users',
'rank_id',
string='Users',
help="Users having this rank")
@api.model_create_multi
def create(self, values_list):
res = super(KarmaRank, self).create(values_list)
users = self.env['res.users'].sudo().search([('karma', '>', 0)])
users._recompute_rank()
return res
def write(self, vals):
if 'karma_min' in vals:
previous_ranks = self.env['gamification.karma.rank'].search(
[], order="karma_min DESC").ids
low = min(vals['karma_min'], self.karma_min)
high = max(vals['karma_min'], self.karma_min)
res = super(KarmaRank, self).write(vals)
if 'karma_min' in vals:
after_ranks = self.env['gamification.karma.rank'].search(
[], order="karma_min DESC").ids
if previous_ranks != after_ranks:
users = self.env['res.users'].sudo().search([('karma', '>', 0)
])
else:
users = self.env['res.users'].sudo().search([
('karma', '>=', low), ('karma', '<=', high)
])
users._recompute_rank()
return res
class Stage(models.Model):
""" Model for case stages. This models the main stages of a document
management flow. Main CRM objects (leads, opportunities, project
issues, ...) will now use only stages, instead of state and stages.
Stages are for example used to display the kanban view of records.
"""
_name = "crm.stage"
_description = "CRM Stages"
_rec_name = 'name'
_order = "sequence, name, id"
@api.model
def default_get(self, fields):
""" Hack : when going from the pipeline, creating a stage with a sales team in
context should not create a stage for the current Sales Team only
"""
ctx = dict(self.env.context)
if ctx.get('default_team_id') and not ctx.get('crm_team_mono'):
ctx.pop('default_team_id')
return super(Stage, self.with_context(ctx)).default_get(fields)
name = fields.Char('Stage Name', required=True, translate=True)
sequence = fields.Integer('Sequence',
default=1,
help="Used to order stages. Lower is better.")
is_won = fields.Boolean('Is Won Stage?')
requirements = fields.Text(
'Requirements',
help=
"Enter here the internal requirements for this stage (ex: Offer sent to customer). It will appear as a tooltip over the stage's name."
)
team_id = fields.Many2one(
'crm.team',
string='Sales Team',
ondelete='set null',
help=
'Specific team that uses this stage. Other teams will not be able to see or use this stage.'
)
fold = fields.Boolean(
'Folded in Pipeline',
help=
'This stage is folded in the kanban view when there are no records in that stage to display.'
)
# This field for interface only
team_count = fields.Integer('team_count', compute='_compute_team_count')
def _compute_team_count(self):
for stage in self:
stage.team_count = self.env['crm.team'].search_count([])
class BaseImportModule(models.TransientModel):
""" Import Module """
_name = "base.import.module"
_description = "Import Module"
module_file = fields.Binary(string='Module .ZIP file',
required=True,
attachment=False)
state = fields.Selection([('init', 'init'), ('done', 'done')],
string='Status',
readonly=True,
default='init')
import_message = fields.Text()
force = fields.Boolean(
string='Force init',
help=
"Force init mode even if installed. (will update `noupdate='1'` records)"
)
def import_module(self):
self.ensure_one()
IrModule = self.env['ir.module.module']
zip_data = base64.decodestring(self.module_file)
fp = BytesIO()
fp.write(zip_data)
res = IrModule.import_zipfile(fp, force=self.force)
self.write({'state': 'done', 'import_message': res[0]})
context = dict(self.env.context, module_name=res[1])
# Return wizard otherwise it will close wizard and will not show result message to user.
return {
'name': 'Import Module',
'view_mode': 'form',
'target': 'new',
'res_id': self.id,
'res_model': 'base.import.module',
'type': 'ir.actions.act_window',
'context': context,
}
def action_module_open(self):
self.ensure_one()
return {
'domain': [('name', 'in', self.env.context.get('module_name',
[]))],
'name': 'Modules',
'view_mode': 'tree,form',
'res_model': 'ir.module.module',
'view_id': False,
'type': 'ir.actions.act_window',
}
class ProjectTaskType(models.Model):
_name = 'project.task.type'
_description = 'Task Stage'
_order = 'sequence, id'
def _get_default_project_ids(self):
default_project_id = self.env.context.get('default_project_id')
return [default_project_id] if default_project_id else None
name = fields.Char(string='Stage Name', required=True, translate=True)
description = fields.Text(translate=True)
sequence = fields.Integer(default=1)
project_ids = fields.Many2many('project.project', 'project_task_type_rel', 'type_id', 'project_id', string='Projects',
default=_get_default_project_ids)
legend_blocked = fields.Char(
'Red Kanban Label', default=lambda s: _('Blocked'), translate=True, required=True,
help='Override the default value displayed for the blocked state for kanban selection, when the task or issue is in that stage.')
legend_done = fields.Char(
'Green Kanban Label', default=lambda s: _('Ready for Next Stage'), translate=True, required=True,
help='Override the default value displayed for the done state for kanban selection, when the task or issue is in that stage.')
legend_normal = fields.Char(
'Grey Kanban Label', default=lambda s: _('In Progress'), translate=True, required=True,
help='Override the default value displayed for the normal state for kanban selection, when the task or issue is in that stage.')
mail_template_id = fields.Many2one(
'mail.template',
string='Email Template',
domain=[('model', '=', 'project.task')],
help="If set an email will be sent to the customer when the task or issue reaches this step.")
fold = fields.Boolean(string='Folded in Kanban',
help='This stage is folded in the kanban view when there are no records in that stage to display.')
rating_template_id = fields.Many2one(
'mail.template',
string='Rating Email Template',
domain=[('model', '=', 'project.task')],
help="If set and if the project's rating configuration is 'Rating when changing stage', then an email will be sent to the customer when the task reaches this step.")
auto_validation_kanban_state = fields.Boolean('Automatic kanban status', default=False,
help="Automatically modify the kanban state when the customer replies to the feedback for this stage.\n"
" * A good feedback from the customer will update the kanban state to 'ready for the new stage' (green bullet).\n"
" * A medium or a bad feedback will set the kanban state to 'blocked' (red bullet).\n")
def unlink(self):
stages = self
default_project_id = self.env.context.get('default_project_id')
if default_project_id:
shared_stages = self.filtered(lambda x: len(x.project_ids) > 1 and default_project_id in x.project_ids.ids)
tasks = self.env['project.task'].with_context(active_test=False).search([('project_id', '=', default_project_id), ('stage_id', 'in', self.ids)])
if shared_stages and not tasks:
shared_stages.write({'project_ids': [(3, default_project_id)]})
stages = self.filtered(lambda x: x not in shared_stages)
return super(ProjectTaskType, stages).unlink()
class WebsiteResPartner(models.Model):
_name = 'res.partner'
_inherit = ['res.partner', 'website.seo.metadata']
website_description = fields.Html('Website Partner Full Description',
strip_style=True,
translate=html_translate)
website_short_description = fields.Text(
'Website Partner Short Description', translate=True)
def _compute_website_url(self):
super(WebsiteResPartner, self)._compute_website_url()
for partner in self:
partner.website_url = "/partners/%s" % slug(partner)
class WebsiteTwitterTweet(models.Model):
_name = 'website.twitter.tweet'
_description = 'Website Twitter'
website_id = fields.Many2one('website',
string='Website',
ondelete='cascade')
screen_name = fields.Char(string='Screen Name')
tweet = fields.Text(string='Tweets')
# Twitter IDs are 64-bit unsigned ints, so we need to store them in
# unlimited precision NUMERIC columns, which can be done with a
# float field. Used digits=(0,0) to indicate unlimited.
# Using VARCHAR would work too but would have sorting problems.
tweet_id = fields.Float(string='Tweet ID', digits=(0, 0)) # Twitter
class IrActionsActUrl(models.Model):
_name = 'ir.actions.act_url'
_description = 'Action URL'
_table = 'ir_act_url'
_inherit = 'ir.actions.actions'
_sequence = 'ir_actions_id_seq'
_order = 'name'
name = fields.Char(string='Action Name', translate=True)
type = fields.Char(default='ir.actions.act_url')
url = fields.Text(string='Action URL', required=True)
target = fields.Selection([('new', 'New Window'), ('self', 'This Window')],
string='Action Target',
default='new',
required=True)
class BadgeUser(models.Model):
"""User having received a badge"""
_name = 'gamification.badge.user'
_description = 'Gamification User Badge'
_order = "create_date desc"
_rec_name = "badge_name"
user_id = fields.Many2one('res.users', string="User", required=True, ondelete="cascade", index=True)
sender_id = fields.Many2one('res.users', string="Sender", help="The user who has send the badge")
badge_id = fields.Many2one('gamification.badge', string='Badge', required=True, ondelete="cascade", index=True)
challenge_id = fields.Many2one('gamification.challenge', string='Challenge originating', help="If this badge was rewarded through a challenge")
comment = fields.Text('Comment')
badge_name = fields.Char(related='badge_id.name', string="Badge Name", readonly=False)
level = fields.Selection(
[('bronze', 'Bronze'), ('silver', 'Silver'), ('gold', 'Gold')],
string='Badge Level', related="badge_id.level", store=True, readonly=True)
def _send_badge(self):
"""Send a notification to a user for receiving a badge
Does not verify constrains on badge granting.
The users are added to the owner_ids (create badge_user if needed)
The stats counters are incremented
:param ids: list(int) of badge users that will receive the badge
"""
template = self.env.ref('gamification.email_template_badge_received')
for badge_user in self:
self.env['mail.thread'].message_post_with_template(
template.id,
model=badge_user._name,
res_id=badge_user.id,
composition_mode='mass_mail',
# `website_forum` triggers `_cron_update` which triggers this method for template `Received Badge`
# for which `badge_user.user_id.partner_id.ids` equals `[8]`, which is then passed to `self.env['mail.compose.message'].create(...)`
# which expects a command list and not a list of ids. In master, this wasn't doing anything, at the end composer.partner_ids was [] and not [8]
# I believe this line is useless, it will take the partners to which the template must be send from the template itself (`partner_to`)
# The below line was therefore pointless.
# partner_ids=badge_user.user_id.partner_id.ids,
)
return True
@api.model
def create(self, vals):
self.env['gamification.badge'].browse(vals['badge_id']).check_granting()
return super(BadgeUser, self).create(vals)
class HrDepartureWizard(models.TransientModel):
_name = 'hr.departure.wizard'
_description = 'Departure Wizard'
@api.model
def default_get(self, fields):
res = super(HrDepartureWizard, self).default_get(fields)
if (not fields
or 'employee_id' in fields) and 'employee_id' not in res:
if self.env.context.get('active_id'):
res['employee_id'] = self.env.context['active_id']
return res
departure_reason = fields.Selection([('fired', 'Fired'),
('resigned', 'Resigned'),
('retired', 'Retired')],
string="Departure Reason",
default="fired")
departure_description = fields.Text(string="Additional Information")
plan_id = fields.Many2one(
'hr.plan',
default=lambda self: self.env['hr.plan'].search([], limit=1))
employee_id = fields.Many2one('hr.employee',
string='Employee',
required=True)
def action_register_departure(self):
employee = self.employee_id
employee.departure_reason = self.departure_reason
employee.departure_description = self.departure_description
if not employee.user_id.partner_id:
return
for activity_type in self.plan_id.plan_activity_type_ids:
self.env['mail.activity'].create({
'res_id':
employee.user_id.partner_id.id,
'res_model_id':
self.env['ir.model']._get('res.partner').id,
'activity_type_id':
activity_type.activity_type_id.id,
'summary':
activity_type.summary,
'user_id':
activity_type.get_responsible_id(employee).id,
})
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 IrLogging(models.Model):
_name = 'ir.logging'
_description = 'Logging'
_order = 'id DESC'
# The _log_access fields are defined manually for the following reasons:
#
# - The entries in ir_logging are filled in with sql queries bypassing the orm. As the --log-db
# cli option allows to insert ir_logging entries into a remote database, the one2many *_uid
# fields make no sense in the first place but we will keep it for backward compatibility.
#
# - Also, when an ir_logging entry is triggered by the orm (when using --log-db) at the moment
# it is making changes to the res.users model, the ALTER TABLE will aquire an exclusive lock
# on res_users, preventing the ir_logging INSERT to be processed, hence the ongoing module
# install/update will hang forever as the orm is blocked by the ir_logging query that will
# never occur.
create_uid = fields.Integer(string='Created by', readonly=True)
create_date = fields.Datetime(string='Created on', readonly=True)
write_uid = fields.Integer(string='Last Updated by', readonly=True)
write_date = fields.Datetime(string='Last Updated on', readonly=True)
name = fields.Char(required=True)
type = fields.Selection([('client', 'Client'), ('server', 'Server')],
required=True,
index=True)
dbname = fields.Char(string='Database Name', index=True)
level = fields.Char(index=True)
message = fields.Text(required=True)
path = fields.Char(required=True)
func = fields.Char(string='Function', required=True)
line = fields.Char(required=True)
def init(self):
super(IrLogging, self).init()
self._cr.execute(
"select 1 from information_schema.constraint_column_usage where table_name = 'ir_logging' and constraint_name = 'ir_logging_write_uid_fkey'"
)
if self._cr.rowcount:
# DROP CONSTRAINT unconditionally takes an ACCESS EXCLUSIVE lock
# on the table, even "IF EXISTS" is set and not matching; disabling
# the relevant trigger instead acquires SHARE ROW EXCLUSIVE, which
# still conflicts with the ROW EXCLUSIVE needed for an insert
self._cr.execute(
"ALTER TABLE ir_logging DROP CONSTRAINT ir_logging_write_uid_fkey"
)
