class LeadTest(models.Model):
_name = "base.automation.lead.test"
_description = "Automated Rule Test"
name = fields.Char(string='Subject', required=True, index=True)
user_id = fields.Many2one('res.users', string='Responsible')
state = fields.Selection([('draft', 'New'), ('cancel', 'Cancelled'), ('open', 'In Progress'),
('pending', 'Pending'), ('done', 'Closed')],
string="Status", readonly=True, default='draft')
active = fields.Boolean(default=True)
partner_id = fields.Many2one('res.partner', string='Partner')
date_action_last = fields.Datetime(string='Last Action', readonly=True)
customer = fields.Boolean(related='partner_id.customer', readonly=True, store=True)
line_ids = fields.One2many('base.automation.line.test', 'lead_id')
priority = fields.Boolean()
deadline = fields.Boolean(compute='_compute_deadline', store=True)
is_assigned_to_admin = fields.Boolean(string='Assigned to admin user')
@api.depends('priority')
def _compute_deadline(self):
for record in self:
if not record.priority:
record.deadline = False
else:
record.deadline = fields.Datetime.from_string(record.create_date) + relativedelta.relativedelta(days=3)
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
security_lead = fields.Float(related='company_id.security_lead',
string="Security Lead Time",
readonly=False)
group_route_so_lines = fields.Boolean(
"Order-Specific Routes",
implied_group='sale_stock.group_route_so_lines')
group_display_incoterm = fields.Boolean(
"Incoterms", implied_group='sale_stock.group_display_incoterm')
use_security_lead = fields.Boolean(
string="Security Lead Time for Sales",
config_parameter='sale_stock.use_security_lead',
oldname='default_new_security_lead',
help=
"Margin of error for dates promised to customers. Products will be scheduled for delivery that many days earlier than the actual promised date, to cope with unexpected delays in the supply chain."
)
default_picking_policy = fields.Selection(
[('direct', 'Ship products as soon as available, with back orders'),
('one', 'Ship all products at once')],
"Picking Policy",
default='direct',
default_model="sale.order",
required=True)
@api.onchange('use_security_lead')
def _onchange_use_security_lead(self):
if not self.use_security_lead:
self.security_lead = 0.0
class ProductTemplate(models.Model):
_inherit = 'product.template'
available_in_pos = fields.Boolean(
string='Available in POS',
help='Check if you want this product to appear in the Point of Sale.',
default=False)
to_weight = fields.Boolean(
string='To Weigh With Scale',
help=
"Check if the product should be weighted using the hardware scale integration."
)
pos_categ_id = fields.Many2one('pos.category',
string='Point of Sale Category',
help="Category used in the Point of Sale.")
@api.multi
def unlink(self):
product_ctx = dict(self.env.context or {}, active_test=False)
if self.with_context(product_ctx).search_count([('id', 'in', self.ids),
('available_in_pos',
'=', True)]):
if self.env['pos.session'].sudo().search_count([('state', '!=',
'closed')]):
raise UserError(
_('You cannot delete a product saleable in point of sale while a session is still opened.'
))
return super(ProductTemplate, self).unlink()
@api.onchange('sale_ok')
def _onchange_sale_ok(self):
if not self.sale_ok:
self.available_in_pos = False
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
module_account_accountant = fields.Boolean(string='Account')
module_l10n_fr_hr_payroll = fields.Boolean(string='French Payroll')
module_l10n_be_hr_payroll = fields.Boolean(string='Belgium Payroll')
module_l10n_in_hr_payroll = fields.Boolean(string='Indian Payroll')
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
group_mass_mailing_campaign = fields.Boolean(
string="Mass Mailing Campaigns",
implied_group='mass_mailing.group_mass_mailing_campaign',
help=
"""This is useful if your marketing campaigns are composed of several emails"""
)
mass_mailing_outgoing_mail_server = fields.Boolean(
string="Specific Mail Server",
config_parameter='mass_mailing.outgoing_mail_server',
help=
'Use a specific mail server in priority. Otherwise Swerp relies on the first outgoing mail server available (based on their sequencing) as it does for normal mails.'
)
mass_mailing_mail_server_id = fields.Many2one(
'ir.mail_server',
string='Mail Server',
config_parameter='mass_mailing.mail_server_id')
show_blacklist_buttons = fields.Boolean(
string="Show blacklist buttons on unsubscribe page",
config_parameter='mass_mailing.show_blacklist_buttons',
help=
"""Allow the recipient to manage himself his state in the blacklist via the unsubscription page."""
)
@api.onchange('mass_mailing_outgoing_mail_server')
def _onchange_mass_mailing_outgoing_mail_server(self):
if not self.mass_mailing_outgoing_mail_server:
self.mass_mailing_mail_server_id = False
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
module_project_forecast = fields.Boolean(string="Forecasts")
module_hr_timesheet = fields.Boolean(string="Task Logs")
group_subtask_project = fields.Boolean("Sub-tasks", implied_group="project.group_subtask_project")
group_project_rating = fields.Boolean("Use Rating on Project", implied_group='project.group_project_rating')
class res_company(models.Model):
_inherit = "res.company"
gengo_private_key = fields.Text(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'
sale_tax_id = fields.Many2one('account.tax',
string="Default Sale Tax",
related='company_id.account_sale_tax_id',
readonly=False)
module_pos_mercury = fields.Boolean(
string="Integrated Card Payments",
help=
"The transactions are processed by Vantiv. Set your Vantiv credentials on the related payment journal."
)
pos_sales_price = fields.Boolean(
"Multiple Product Prices",
config_parameter='point_of_sale.pos_sales_price')
pos_pricelist_setting = fields.Selection(
[('percentage',
'Multiple prices per product (e.g. customer segments, currencies)'),
('formula',
'Price computed from formulas (discounts, margins, roundings)')],
string="POS Pricelists",
config_parameter='point_of_sale.pos_pricelist_setting')
@api.onchange('pos_sales_price')
def _onchange_pos_sales_price(self):
if not self.pos_sales_price:
self.pos_pricelist_setting = False
if self.pos_sales_price and not self.pos_pricelist_setting:
self.pos_pricelist_setting = 'percentage'
@api.onchange('pos_pricelist_setting')
def _onchange_pos_pricelist_setting(self):
self.sale_pricelist_setting_sync(self.pos_pricelist_setting)
if self.pos_pricelist_setting == 'percentage':
self.update({
'group_product_pricelist': True,
'group_sale_pricelist': True,
'group_pricelist_item': False,
})
elif self.pos_pricelist_setting == 'formula':
self.update({
'group_product_pricelist': False,
'group_sale_pricelist': True,
'group_pricelist_item': True,
})
else:
self.update({
'group_product_pricelist': False,
'group_sale_pricelist': False,
'group_pricelist_item': False,
})
def pos_pricelist_setting_sync(self, sale_pricelist_setting):
if sale_pricelist_setting == 'fixed':
self.pos_sales_price = False
self.pos_pricelist_setting = False
else:
self.pos_sales_price = True
self.pos_pricelist_setting = sale_pricelist_setting
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
module_event_sale = fields.Boolean("Tickets")
module_website_event_track = fields.Boolean("Tracks and Agenda")
module_website_event_questions = fields.Boolean("Registration Survey")
module_event_barcode = fields.Boolean("Barcode")
module_website_event_sale = fields.Boolean("Online Ticketing")
class Company(models.Model):
_inherit = "res.company"
l10n_ch_isr_preprinted_account = fields.Boolean(
string='Preprinted account',
compute='_compute_l10n_ch_isr',
inverse='_set_l10n_ch_isr')
l10n_ch_isr_preprinted_bank = fields.Boolean(
string='Preprinted bank',
compute='_compute_l10n_ch_isr',
inverse='_set_l10n_ch_isr')
l10n_ch_isr_print_bank_location = fields.Boolean(
string='Print bank location',
default=False,
help=
'Boolean option field indicating whether or not the alternate layout (the one printing bank name and address) must be used when generating an ISR.'
)
l10n_ch_isr_scan_line_left = fields.Float(
string='Scan line horizontal offset (mm)',
compute='_compute_l10n_ch_isr',
inverse='_set_l10n_ch_isr')
l10n_ch_isr_scan_line_top = fields.Float(
string='Scan line vertical offset (mm)',
compute='_compute_l10n_ch_isr',
inverse='_set_l10n_ch_isr')
def _compute_l10n_ch_isr(self):
get_param = self.env['ir.config_parameter'].sudo().get_param
for company in self:
company.l10n_ch_isr_preprinted_account = bool(
get_param('l10n_ch.isr_preprinted_account', default=False))
company.l10n_ch_isr_preprinted_bank = bool(
get_param('l10n_ch.isr_preprinted_bank', default=False))
company.l10n_ch_isr_scan_line_top = float(
get_param('l10n_ch.isr_scan_line_top', default=0))
company.l10n_ch_isr_scan_line_left = float(
get_param('l10n_ch.isr_scan_line_left', default=0))
def _set_l10n_ch_isr(self):
set_param = self.env['ir.config_parameter'].sudo().set_param
for company in self:
set_param("l10n_ch.isr_preprinted_account",
company.l10n_ch_isr_preprinted_account)
set_param("l10n_ch.isr_preprinted_bank",
company.l10n_ch_isr_preprinted_bank)
set_param("l10n_ch.isr_scan_line_top",
company.l10n_ch_isr_scan_line_top)
set_param("l10n_ch.isr_scan_line_left",
company.l10n_ch_isr_scan_line_left)
def _get_invoice_reference_types(self):
""" Overridden to allow using ISR number as payment reference automatically.
"""
return super()._get_invoice_reference_types() + [
('ch_isr', _("Swiss ISR Number"))
]
class StockMoveLine(models.Model):
_inherit = 'stock.move.line'
workorder_id = fields.Many2one('mrp.workorder', 'Work Order')
production_id = fields.Many2one('mrp.production', 'Production Order')
lot_produced_id = fields.Many2one('stock.production.lot',
'Finished Lot/Serial Number')
lot_produced_qty = fields.Float(
'Quantity Finished Product',
digits=dp.get_precision('Product Unit of Measure'),
help="Informative, not used in matching")
done_wo = fields.Boolean(
'Done for Work Order',
default=True,
help=
"Technical Field which is False when temporarily filled in in work order"
) # TDE FIXME: naming
done_move = fields.Boolean('Move Done',
related='move_id.is_done',
readonly=False,
store=True) # TDE FIXME: naming
def _get_similar_move_lines(self):
lines = super(StockMoveLine, self)._get_similar_move_lines()
if self.move_id.production_id:
finished_moves = self.move_id.production_id.move_finished_ids
finished_move_lines = finished_moves.mapped('move_line_ids')
lines |= finished_move_lines.filtered(
lambda ml: ml.product_id == self.product_id and
(ml.lot_id or ml.lot_name) and ml.done_wo == self.done_wo)
if self.move_id.raw_material_production_id:
raw_moves = self.move_id.raw_material_production_id.move_raw_ids
raw_moves_lines = raw_moves.mapped('move_line_ids')
raw_moves_lines |= self.move_id.active_move_line_ids
lines |= raw_moves_lines.filtered(
lambda ml: ml.product_id == self.product_id and
(ml.lot_id or ml.lot_name) and ml.done_wo == self.done_wo)
return lines
@api.multi
def write(self, vals):
for move_line in self:
if move_line.move_id.production_id and 'lot_id' in vals:
move_line.production_id.move_raw_ids.mapped('move_line_ids')\
.filtered(lambda r: r.done_wo and not r.done_move and r.lot_produced_id == move_line.lot_id)\
.write({'lot_produced_id': vals['lot_id']})
production = move_line.move_id.production_id or move_line.move_id.raw_material_production_id
if production and move_line.state == 'done' and any(
field in vals
for field in ('lot_id', 'location_id', 'qty_done')):
move_line._log_message(production, move_line,
'mrp.track_production_move_template',
vals)
return super(StockMoveLine, self).write(vals)
class MaintenanceStage(models.Model):
""" Model for case stages. This models the main stages of a Maintenance Request management flow. """
_name = 'maintenance.stage'
_description = 'Maintenance Stage'
_order = 'sequence, id'
name = fields.Char('Name', required=True, translate=True)
sequence = fields.Integer('Sequence', default=20)
fold = fields.Boolean('Folded in Maintenance Pipe')
done = fields.Boolean('Request Done')
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_priority = fields.Char(
string='Starred Explanation', translate=True,
help='Explanation text to help users using the star on tasks or issues in this stage.')
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")
@api.multi
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 EventType(models.Model):
_inherit = 'event.type'
website_track = fields.Boolean('Tracks on Website')
website_track_proposal = fields.Boolean('Tracks Proposals on Website')
@api.onchange('website_menu')
def _onchange_website_menu(self):
if not self.website_menu:
self.website_track = False
self.website_track_proposal = False
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
crm_alias_prefix = fields.Char('Default Alias Name for Leads')
generate_lead_from_alias = fields.Boolean(
'Manual Assignation of Emails',
config_parameter='crm.generate_lead_from_alias')
group_use_lead = fields.Boolean(string="Leads",
implied_group='crm.group_use_lead')
module_crm_phone_validation = fields.Boolean("Phone Formatting")
module_crm_reveal = fields.Boolean(
"Create Leads/Opportunities from your website's traffic")
def _find_default_lead_alias_id(self):
alias = self.env.ref('crm.mail_alias_lead_info', False)
if not alias:
alias = self.env['mail.alias'].search(
[('alias_model_id.model', '=', 'crm.lead'),
('alias_force_thread_id', '=', False),
('alias_parent_model_id.model', '=', 'crm.team'),
('alias_parent_thread_id', '=', False),
('alias_defaults', '=', '{}')],
limit=1)
return alias
@api.onchange('group_use_lead')
def _onchange_group_use_lead(self):
""" Reset alias / leads configuration if leads are not used """
if not self.group_use_lead:
self.generate_lead_from_alias = False
@api.onchange('generate_lead_from_alias')
def _onchange_generate_lead_from_alias(self):
self.crm_alias_prefix = (self.crm_alias_prefix or 'info'
) if self.generate_lead_from_alias else False
@api.model
def get_values(self):
res = super(ResConfigSettings, self).get_values()
alias = self._find_default_lead_alias_id()
res.update(crm_alias_prefix=alias.alias_name if alias else False, )
return res
@api.multi
def set_values(self):
super(ResConfigSettings, self).set_values()
alias = self._find_default_lead_alias_id()
if alias:
alias.write({'alias_name': self.crm_alias_prefix})
else:
self.env['mail.alias'].with_context(
alias_model_name='crm.lead',
alias_parent_model_name='crm.team').create(
{'alias_name': self.crm_alias_prefix})
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
gengo_private_key = fields.Text(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 AccountAnalyticTag(models.Model):
_name = 'account.analytic.tag'
_description = 'Analytic Tags'
name = fields.Char(string='Analytic Tag', index=True, required=True)
color = fields.Integer('Color Index')
active = fields.Boolean(
default=True,
help="Set active to false to hide the Analytic Tag without removing it."
)
active_analytic_distribution = fields.Boolean('Analytic Distribution')
analytic_distribution_ids = fields.One2many(
'account.analytic.distribution', 'tag_id', string="Analytic Accounts")
company_id = fields.Many2one('res.company', string='Company')
class Route(models.Model):
_name = 'stock.location.route'
_description = "Inventory Routes"
_order = 'sequence'
name = fields.Char('Route', required=True, translate=True)
active = fields.Boolean('Active', default=True, help="If the active field is set to False, it will allow you to hide the route without removing it.")
sequence = fields.Integer('Sequence', default=0)
rule_ids = fields.One2many('stock.rule', 'route_id', 'Rules', copy=True)
product_selectable = fields.Boolean('Applicable on Product', default=True, help="When checked, the route will be selectable in the Inventory tab of the Product form.")
product_categ_selectable = fields.Boolean('Applicable on Product Category', help="When checked, the route will be selectable on the Product Category.")
warehouse_selectable = fields.Boolean('Applicable on Warehouse', help="When a warehouse is selected for this route, this route should be seen as the default route when products pass through this warehouse.")
supplied_wh_id = fields.Many2one('stock.warehouse', 'Supplied Warehouse')
supplier_wh_id = fields.Many2one('stock.warehouse', 'Supplying Warehouse')
company_id = fields.Many2one(
'res.company', 'Company',
default=lambda self: self.env['res.company']._company_default_get('stock.location.route'), index=True,
help='Leave this field empty if this route is shared between all companies')
product_ids = fields.Many2many('product.template', 'stock_route_product', 'route_id', 'product_id', 'Products', copy=False)
categ_ids = fields.Many2many('product.category', 'stock_location_route_categ', 'route_id', 'categ_id', 'Product Categories', copy=False)
warehouse_ids = fields.Many2many('stock.warehouse', 'stock_route_warehouse', 'route_id', 'warehouse_id', 'Warehouses', copy=False)
@api.onchange('warehouse_selectable')
def _onchange_warehouse_selectable(self):
if not self.warehouse_selectable:
self.warehouse_ids = [(5, 0, 0)]
def toggle_active(self):
for route in self:
route.with_context(active_test=False).rule_ids.filtered(lambda ru: ru.active == route.active).toggle_active()
super(Route, self).toggle_active()
def view_product_ids(self):
return {
'name': _('Products'),
'view_type': 'form',
'view_mode': 'tree,form',
'res_model': 'product.template',
'type': 'ir.actions.act_window',
'domain': [('route_ids', 'in', self.ids)],
}
def view_categ_ids(self):
return {
'name': _('Product Categories'),
'view_type': 'form',
'view_mode': 'tree,form',
'res_model': 'product.category',
'type': 'ir.actions.act_window',
'domain': [('route_ids', 'in', self.ids)],
}
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
module_stock_dropshipping = fields.Boolean("Dropshipping")
is_installed_sale = fields.Boolean(string="Is the Sale Module Installed")
@api.multi
def get_values(self):
res = super(ResConfigSettings, self).get_values()
res.update(is_installed_sale=self.env['ir.module.module'].search([
('name', '=', 'sale'), ('state', '=', 'installed')
]).id, )
return res
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
l10n_ch_isr_preprinted_account = fields.Boolean(string='Preprinted account',
related="company_id.l10n_ch_isr_preprinted_account", readonly=False)
l10n_ch_isr_preprinted_bank = fields.Boolean(string='Preprinted bank',
related="company_id.l10n_ch_isr_preprinted_bank", readonly=False)
l10n_ch_isr_print_bank_location = fields.Boolean(string="Print bank on ISR",
related="company_id.l10n_ch_isr_print_bank_location", readonly=False,
required=True)
l10n_ch_isr_scan_line_left = fields.Float(string='Horizontal offset',
related="company_id.l10n_ch_isr_scan_line_left", readonly=False)
l10n_ch_isr_scan_line_top = fields.Float(string='Vertical offset',
related="company_id.l10n_ch_isr_scan_line_top", readonly=False)
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
country_code = fields.Char(string="Company Country code",
related='company_id.country_id.code',
readonly=True)
account_check_printing_layout = fields.Selection(
related='company_id.account_check_printing_layout',
string="Check Layout",
readonly=False,
help=
"Select the format corresponding to the check paper you will be printing your checks on.\n"
"In order to disable the printing feature, select 'None'.")
account_check_printing_date_label = fields.Boolean(
related='company_id.account_check_printing_date_label',
string="Print Date Label",
readonly=False,
help=
"This option allows you to print the date label on the check as per CPA. Disable this if your pre-printed check includes the date label."
)
account_check_printing_multi_stub = fields.Boolean(
related='company_id.account_check_printing_multi_stub',
string='Multi-Pages Check Stub',
readonly=False,
help=
"This option allows you to print check details (stub) on multiple pages if they don't fit on a single page."
)
account_check_printing_margin_top = fields.Float(
related='company_id.account_check_printing_margin_top',
string='Check Top Margin',
readonly=False,
help=
"Adjust the margins of generated checks to make it fit your printer's settings."
)
account_check_printing_margin_left = fields.Float(
related='company_id.account_check_printing_margin_left',
string='Check Left Margin',
readonly=False,
help=
"Adjust the margins of generated checks to make it fit your printer's settings."
)
account_check_printing_margin_right = fields.Float(
related='company_id.account_check_printing_margin_right',
string='Check Right Margin',
readonly=False,
help=
"Adjust the margins of generated checks to make it fit your printer's settings."
)
class Product(models.Model):
_inherit = "product.product"
website_id = fields.Many2one(related='product_tmpl_id.website_id',
readonly=False)
# website_price deprecated, directly use _get_combination_info instead
website_price = fields.Float('Website price',
compute='_website_price',
digits=dp.get_precision('Product Price'))
# website_public_price deprecated, directly use _get_combination_info instead
website_public_price = fields.Float(
'Website public price',
compute='_website_price',
digits=dp.get_precision('Product Price'))
# website_price_difference deprecated, directly use _get_combination_info instead
website_price_difference = fields.Boolean('Website price difference',
compute='_website_price')
def _website_price(self):
for product in self:
res = product._get_combination_info_variant()
product.website_price = res.get('price')
product.website_public_price = res.get('list_price')
product.website_price_difference = res.get('has_discounted_price')
@api.multi
def website_publish_button(self):
self.ensure_one()
return self.product_tmpl_id.website_publish_button()
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
@api.model
def get_uri(self):
return "%s/auth_oauth/signin" % (
self.env['ir.config_parameter'].get_param('web.base.url'))
auth_oauth_google_enabled = fields.Boolean(
string='Allow users to sign in with Google')
auth_oauth_google_client_id = fields.Char(string='Client ID')
server_uri_google = fields.Char(string='Server uri')
@api.model
def get_values(self):
res = super(ResConfigSettings, self).get_values()
google_provider = self.env.ref('auth_oauth.provider_google', False)
google_provider and res.update(
auth_oauth_google_enabled=google_provider.enabled,
auth_oauth_google_client_id=google_provider.client_id,
server_uri_google=self.get_uri(),
)
return res
def set_values(self):
super(ResConfigSettings, self).set_values()
google_provider = self.env.ref('auth_oauth.provider_google', False)
google_provider and google_provider.write(
{
'enabled': self.auth_oauth_google_enabled,
'client_id': self.auth_oauth_google_client_id,
})
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 HrPayslipRun(models.Model):
_name = 'hr.payslip.run'
_description = 'Payslip Batches'
name = fields.Char(required=True, readonly=True, states={'draft': [('readonly', False)]})
slip_ids = fields.One2many('hr.payslip', 'payslip_run_id', string='Payslips', readonly=True,
states={'draft': [('readonly', False)]})
state = fields.Selection([
('draft', 'Draft'),
('close', 'Close'),
], string='Status', index=True, readonly=True, copy=False, default='draft')
date_start = fields.Date(string='Date From', required=True, readonly=True,
states={'draft': [('readonly', False)]}, default=lambda self: fields.Date.to_string(date.today().replace(day=1)))
date_end = fields.Date(string='Date To', required=True, readonly=True,
states={'draft': [('readonly', False)]},
default=lambda self: fields.Date.to_string((datetime.now() + relativedelta(months=+1, day=1, days=-1)).date()))
credit_note = fields.Boolean(string='Credit Note', readonly=True,
states={'draft': [('readonly', False)]},
help="If its checked, indicates that all payslips generated from here are refund payslips.")
@api.multi
def draft_payslip_run(self):
return self.write({'state': 'draft'})
@api.multi
def close_payslip_run(self):
return self.write({'state': 'close'})
@api.multi
def unlink(self):
if any(self.filtered(lambda payslip_run: payslip_run.state not in ('draft'))):
raise UserError(_('You cannot delete a payslip batch which is not draft!'))
if any(self.mapped('slip_ids').filtered(lambda payslip: payslip.state not in ('draft','cancel'))):
raise UserError(_('You cannot delete a payslip which is not draft or cancelled!'))
return super(HrPayslipRun, self).unlink()
class PosConfig(models.Model):
_inherit = 'pos.config'
iface_discount = fields.Boolean(
string='Order Discounts',
help='Allow the cashier to give discounts on the whole order.')
discount_pc = fields.Float(string='Discount Percentage',
help='The default discount percentage')
discount_product_id = fields.Many2one(
'product.product',
string='Discount Product',
domain="[('available_in_pos', '=', True), ('sale_ok', '=', True)]",
help='The product used to model the discount.')
@api.onchange('module_pos_discount')
def _onchange_module_pos_discount(self):
if self.module_pos_discount:
self.discount_product_id = self.env.ref(
'point_of_sale.product_product_consumable',
raise_if_not_found=False)
if not self.discount_product_id or not self.discount_product_id.available_in_pos or not self.discount_product_id.sale_ok:
domain = [('available_in_pos', '=', True),
('sale_ok', '=', True)]
self.discount_product_id = self.env['product.product'].search(
domain, limit=1)
self.discount_pc = 10.0
else:
self.discount_product_id = False
self.discount_pc = 0.0
class HrEmployee(models.Model):
_inherit = "hr.employee"
goal_ids = fields.One2many('gamification.goal', string='Employee HR Goals', compute='_compute_employee_goals')
badge_ids = fields.One2many(
'gamification.badge.user', string='Employee Badges', compute='_compute_employee_badges',
help="All employee badges, linked to the employee either directly or through the user"
)
has_badges = fields.Boolean(compute='_compute_employee_badges')
# necessary for correct dependencies of badge_ids and has_badges
direct_badge_ids = fields.One2many(
'gamification.badge.user', 'employee_id',
help="Badges directly linked to the employee")
@api.depends('user_id.goal_ids.challenge_id.category')
def _compute_employee_goals(self):
for employee in self:
employee.goal_ids = self.env['gamification.goal'].search([
('user_id', '=', employee.user_id.id),
('challenge_id.category', '=', 'hr'),
])
@api.depends('direct_badge_ids', 'user_id.badge_ids.employee_id')
def _compute_employee_badges(self):
for employee in self:
badge_ids = self.env['gamification.badge.user'].search([
'|', ('employee_id', '=', employee.id),
'&', ('employee_id', '=', False),
('user_id', '=', employee.user_id.id)
])
employee.has_badges = bool(badge_ids)
employee.badge_ids = badge_ids
class Digest(models.Model):
_inherit = 'digest.digest'
kpi_website_sale_total = fields.Boolean('eCommerce Sales')
kpi_website_sale_total_value = fields.Monetary(
compute='_compute_kpi_website_sale_total_value')
def _compute_kpi_website_sale_total_value(self):
if not self.env.user.has_group(
'sales_team.group_sale_salesman_all_leads'):
raise AccessError(
_("Do not have access, skip this data for user's digest email")
)
for record in self:
start, end, company = record._get_kpi_compute_parameters()
confirmed_website_sales = self.env['sale.order'].search([
('confirmation_date', '>=', start),
('confirmation_date', '<', end),
('state', 'not in', ['draft', 'cancel', 'sent']),
('team_id.team_type', '=', 'website'),
('company_id', '=', company.id)
])
record.kpi_website_sale_total_value = sum(
confirmed_website_sales.mapped('amount_total'))
def compute_kpis_actions(self, company, user):
res = super(Digest, self).compute_kpis_actions(company, user)
res['kpi_website_sale_total'] = 'website.backend_dashboard&menu_id=%s' % self.env.ref(
'website.menu_website_configuration').id
return res
class Digest(models.Model):
_inherit = 'digest.digest'
kpi_project_task_opened = fields.Boolean('Open Tasks')
kpi_project_task_opened_value = fields.Integer(
compute='_compute_project_task_opened_value')
def _compute_project_task_opened_value(self):
if not self.env.user.has_group('project.group_project_user'):
raise AccessError(
_("Do not have access, skip this data for user's digest email")
)
for record in self:
start, end, company = record._get_kpi_compute_parameters()
record.kpi_project_task_opened_value = self.env[
'project.task'].search_count([('stage_id.fold', '=', False),
('create_date', '>=', start),
('create_date', '<', end),
('company_id', '=', company.id)])
def compute_kpis_actions(self, company, user):
res = super(Digest, self).compute_kpis_actions(company, user)
res['kpi_project_task_opened'] = 'project.open_view_project_all&menu_id=%s' % self.env.ref(
'project.menu_main_pm').id
return res
class MaintenanceTeam(models.Model):
_name = 'maintenance.team'
_description = 'Maintenance Teams'
name = fields.Char(required=True, translate=True)
active = fields.Boolean(default=True)
company_id = fields.Many2one('res.company', string='Company',
default=lambda self: self.env.user.company_id)
member_ids = fields.Many2many('res.users', 'maintenance_team_users_rel', string="Team Members")
color = fields.Integer("Color Index", default=0)
request_ids = fields.One2many('maintenance.request', 'maintenance_team_id', copy=False)
equipment_ids = fields.One2many('maintenance.equipment', 'maintenance_team_id', copy=False)
# For the dashboard only
todo_request_ids = fields.One2many('maintenance.request', string="Requests", copy=False, compute='_compute_todo_requests')
todo_request_count = fields.Integer(string="Number of Requests", compute='_compute_todo_requests')
todo_request_count_date = fields.Integer(string="Number of Requests Scheduled", compute='_compute_todo_requests')
todo_request_count_high_priority = fields.Integer(string="Number of Requests in High Priority", compute='_compute_todo_requests')
todo_request_count_block = fields.Integer(string="Number of Requests Blocked", compute='_compute_todo_requests')
todo_request_count_unscheduled = fields.Integer(string="Number of Requests Unscheduled", compute='_compute_todo_requests')
@api.one
@api.depends('request_ids.stage_id.done')
def _compute_todo_requests(self):
self.todo_request_ids = self.request_ids.filtered(lambda e: e.stage_id.done==False)
self.todo_request_count = len(self.todo_request_ids)
self.todo_request_count_date = len(self.todo_request_ids.filtered(lambda e: e.schedule_date != False))
self.todo_request_count_high_priority = len(self.todo_request_ids.filtered(lambda e: e.priority == '3'))
self.todo_request_count_block = len(self.todo_request_ids.filtered(lambda e: e.kanban_state == 'blocked'))
self.todo_request_count_unscheduled = len(self.todo_request_ids.filtered(lambda e: not e.schedule_date))
@api.one
@api.depends('equipment_ids')
def _compute_equipment(self):
self.equipment_count = len(self.equipment_ids)
