class BaseModuleUninstall(models.TransientModel):
_name = "base.module.uninstall"
_description = "Module Uninstallation"
show_all = fields.Boolean()
module_id = fields.Many2one('ir.module.module',
string="Module",
required=True,
domain=[
('state', 'in',
['installed', 'to upgrade', 'to install'])
])
module_ids = fields.Many2many('ir.module.module',
string="Impacted modules",
compute='_compute_module_ids')
model_ids = fields.Many2many('ir.model',
string="Impacted data models",
compute='_compute_model_ids')
def _get_modules(self):
""" Return all the modules impacted by self. """
return self.module_id.downstream_dependencies(self.module_id)
@api.depends('module_id', 'show_all')
def _compute_module_ids(self):
for wizard in self:
modules = wizard._get_modules()
wizard.module_ids = modules if wizard.show_all else modules.filtered(
'application')
def _get_models(self):
""" Return the models (ir.model) to consider for the impact. """
return self.env['ir.model'].search([('transient', '=', False)])
@api.depends('module_ids')
def _compute_model_ids(self):
ir_models = self._get_models()
ir_models_xids = ir_models._get_external_ids()
for wizard in self:
if wizard.module_id:
module_names = set(wizard._get_modules().mapped('name'))
def lost(model):
xids = ir_models_xids.get(model.id, ())
return xids and all(
xid.split('.')[0] in module_names for xid in xids)
# find the models that have all their XIDs in the given modules
self.model_ids = ir_models.filtered(lost).sorted('name')
@api.onchange('module_id')
def _onchange_module_id(self):
# if we select a technical module, show technical modules by default
if not self.module_id.application:
self.show_all = True
@api.multi
def action_uninstall(self):
modules = self.mapped('module_id')
return modules.button_immediate_uninstall()
class GroupsImplied(models.Model):
_inherit = 'res.groups'
implied_ids = fields.Many2many('res.groups', 'res_groups_implied_rel', 'gid', 'hid',
string='Inherits', help='Users of this group automatically inherit those groups')
trans_implied_ids = fields.Many2many('res.groups', string='Transitively inherits',
compute='_compute_trans_implied')
@api.depends('implied_ids.trans_implied_ids')
def _compute_trans_implied(self):
# Compute the transitive closure recursively. Note that the performance
# is good, because the record cache behaves as a memo (the field is
# never computed twice on a given group.)
for g in self:
g.trans_implied_ids = g.implied_ids | g.mapped('implied_ids.trans_implied_ids')
@api.model
def create(self, values):
user_ids = values.pop('users', None)
group = super(GroupsImplied, self).create(values)
if user_ids:
# delegate addition of users to add implied groups
group.write({'users': user_ids})
return group
@api.multi
def write(self, values):
res = super(GroupsImplied, self).write(values)
if values.get('users') or values.get('implied_ids'):
# add all implied groups (to all users of each group)
for group in self:
vals = {'users': list(pycompat.izip(repeat(4), group.with_context(active_test=False).users.ids))}
super(GroupsImplied, group.trans_implied_ids).write(vals)
return res
class ProductTemplate(models.Model):
_inherit = "product.template"
taxes_id = fields.Many2many('account.tax',
'product_taxes_rel',
'prod_id',
'tax_id',
string='Customer Taxes',
domain=[('type_tax_use', '=', 'sale')])
supplier_taxes_id = fields.Many2many('account.tax',
'product_supplier_taxes_rel',
'prod_id',
'tax_id',
string='Vendor Taxes',
domain=[('type_tax_use', '=',
'purchase')])
property_account_income_id = fields.Many2one(
'account.account',
company_dependent=True,
string="Income Account",
oldname="property_account_income",
domain=[('deprecated', '=', False)],
help=
"Keep this field empty to use the default value from the product category."
)
property_account_expense_id = fields.Many2one(
'account.account',
company_dependent=True,
string="Expense Account",
oldname="property_account_expense",
domain=[('deprecated', '=', False)],
help=
"The expense is accounted for when a vendor bill is validated, except in anglo-saxon accounting with perpetual inventory valuation in which case the expense (Cost of Goods Sold account) is recognized at the customer invoice validation. If the field is empty, it uses the one defined in the product category."
)
@api.multi
def _get_product_accounts(self):
return {
'income':
self.property_account_income_id
or self.categ_id.property_account_income_categ_id,
'expense':
self.property_account_expense_id
or self.categ_id.property_account_expense_categ_id
}
@api.multi
def _get_asset_accounts(self):
res = {}
res['stock_input'] = False
res['stock_output'] = False
return res
@api.multi
def get_product_accounts(self, fiscal_pos=None):
accounts = self._get_product_accounts()
if not fiscal_pos:
fiscal_pos = self.env['account.fiscal.position']
return fiscal_pos.map_accounts(accounts)
class Discussion(models.Model):
_name = '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')
messages = fields.One2many('test_new_api.message', 'discussion')
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 BaseLanguageExport(models.TransientModel):
_name = "base.language.export"
@api.model
def _get_languages(self):
langs = self.env['res.lang'].search([('translatable', '=', True)])
return [(NEW_LANG_KEY, _('New Language (Empty translation template)'))] + \
[(lang.code, lang.name) for lang in langs]
name = fields.Char('File Name', readonly=True)
lang = fields.Selection(_get_languages,
string='Language',
required=True,
default=NEW_LANG_KEY)
format = fields.Selection([('csv', 'CSV File'), ('po', 'PO File'),
('tgz', 'TGZ Archive')],
string='File Format',
required=True,
default='csv')
modules = fields.Many2many('ir.module.module',
'rel_modules_langexport',
'wiz_id',
'module_id',
string='Apps To Export',
domain=[('state', '=', 'installed')])
data = fields.Binary('File', readonly=True)
state = fields.Selection(
[('choose', 'choose'),
('get', 'get')], # choose language or get the file
default='choose')
@api.multi
def act_getfile(self):
this = self[0]
lang = this.lang if this.lang != NEW_LANG_KEY else False
mods = sorted(this.mapped('modules.name')) or ['all']
with contextlib.closing(io.BytesIO()) as buf:
tools.trans_export(lang, mods, buf, this.format, self._cr)
out = base64.encodestring(buf.getvalue())
filename = 'new'
if lang:
filename = tools.get_iso_codes(lang)
elif len(mods) == 1:
filename = mods[0]
extension = this.format
if not lang and extension == 'po':
extension = 'pot'
name = "%s.%s" % (filename, extension)
this.write({'state': 'get', 'data': out, 'name': name})
return {
'type': 'ir.actions.act_window',
'res_model': 'base.language.export',
'view_mode': 'form',
'view_type': 'form',
'res_id': this.id,
'views': [(False, 'form')],
'target': 'new',
}
class MultiLine(models.Model):
_name = 'test_new_api.multi.line'
multi = fields.Many2one('test_new_api.multi', ondelete='cascade')
name = fields.Char()
partner = fields.Many2one('res.partner')
tags = fields.Many2many('test_new_api.multi.tag')
class AccountReportGeneralLedger(models.TransientModel):
_inherit = "account.common.account.report"
_name = "account.report.general.ledger"
_description = "General Ledger Report"
initial_balance = fields.Boolean(
string='Include Initial Balances',
help=
'If you selected date, this field allow you to add a row to display the amount of debit/credit/balance that precedes the filter you\'ve set.'
)
sortby = fields.Selection([('sort_date', 'Date'),
('sort_journal_partner', 'Journal & Partner')],
string='Sort by',
required=True,
default='sort_date')
journal_ids = fields.Many2many('account.journal',
'account_report_general_ledger_journal_rel',
'account_id',
'journal_id',
string='Journals',
required=True)
def _print_report(self, data):
data = self.pre_print_report(data)
data['form'].update(self.read(['initial_balance', 'sortby'])[0])
if data['form'].get(
'initial_balance') and not data['form'].get('date_from'):
raise UserError(_("You must define a Start Date"))
records = self.env[data['model']].browse(data.get('ids', []))
return self.env.ref(
'account.action_report_general_ledger').with_context(
landscape=True).report_action(records, data=data)
class HolidaysSummaryDept(models.TransientModel):
_name = 'hr.holidays.summary.dept'
_description = 'HR Leaves Summary Report By Department'
date_from = fields.Date(string='From',
required=True,
default=lambda *a: time.strftime('%Y-%m-01'))
depts = fields.Many2many('hr.department',
'summary_dept_rel',
'sum_id',
'dept_id',
string='Department(s)')
holiday_type = fields.Selection([('Approved', 'Approved'),
('Confirmed', 'Confirmed'),
('both', 'Both Approved and Confirmed')],
string='Leave Type',
required=True,
default='Approved')
@api.multi
def print_report(self):
self.ensure_one()
[data] = self.read()
if not data.get('depts'):
raise UserError(
_('You have to select at least one Department. And try again.')
)
departments = self.env['hr.department'].browse(data['depts'])
datas = {'ids': [], 'model': 'hr.department', 'form': data}
return self.env.ref(
'hr_holidays.action_report_holidayssummary').with_context(
from_transient_model=True).report_action(departments,
data=datas)
class BaseLanguageInstall(models.TransientModel):
_inherit = "base.language.install"
website_ids = fields.Many2many('website', string='Websites to translate')
@api.model
def default_get(self, fields):
defaults = super(BaseLanguageInstall, self).default_get(fields)
website_id = self._context.get('params', {}).get('website_id')
if website_id:
if 'website_ids' not in defaults:
defaults['website_ids'] = []
defaults['website_ids'].append(website_id)
return defaults
@api.multi
def lang_install(self):
action = super(BaseLanguageInstall, self).lang_install()
lang = self.env['res.lang'].search([('code', '=', self.lang)], limit=1)
if self.website_ids and lang:
self.website_ids.write({'language_ids': [(4, lang.id)]})
params = self._context.get('params', {})
if 'url_return' in params:
return {
'url': params['url_return'].replace('[lang]', self.lang),
'type': 'ir.actions.act_url',
'target': 'self'
}
return action
class RestaurantPrinter(models.Model):
_name = 'restaurant.printer'
name = fields.Char('Printer Name', required=True, default='Printer', help='An internal identification of the printer')
proxy_ip = fields.Char('Proxy IP Address', help="The IP Address or hostname of the Printer's hardware proxy")
product_categories_ids = fields.Many2many('pos.category', 'printer_category_rel', 'printer_id', 'category_id', string='Printed Product Categories')
class HolidaysSummaryEmployee(models.TransientModel):
_name = 'hr.holidays.summary.employee'
_description = 'HR Leaves Summary Report By Employee'
date_from = fields.Date(string='From',
required=True,
default=lambda *a: time.strftime('%Y-%m-01'))
emp = fields.Many2many('hr.employee',
'summary_emp_rel',
'sum_id',
'emp_id',
string='Employee(s)')
holiday_type = fields.Selection([('Approved', 'Approved'),
('Confirmed', 'Confirmed'),
('both', 'Both Approved and Confirmed')],
string='Select Leave Type',
required=True,
default='Approved')
@api.multi
def print_report(self):
self.ensure_one()
[data] = self.read()
data['emp'] = self.env.context.get('active_ids', [])
employees = self.env['hr.employee'].browse(data['emp'])
datas = {'ids': [], 'model': 'hr.employee', 'form': data}
return self.env.ref(
'hr_holidays.action_report_holidayssummary').report_action(
employees, data=datas)
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.')
class StockImmediateTransfer(models.TransientModel):
_name = 'stock.immediate.transfer'
_description = 'Immediate Transfer'
pick_ids = fields.Many2many('stock.picking', 'stock_picking_transfer_rel')
def process(self):
pick_to_backorder = self.env['stock.picking']
pick_to_do = self.env['stock.picking']
for picking in self.pick_ids:
# If still in draft => confirm and assign
if picking.state == 'draft':
picking.action_confirm()
if picking.state != 'assigned':
picking.action_assign()
if picking.state != 'assigned':
raise UserError(
_("Could not reserve all requested products. Please use the \'Mark as Todo\' button to handle the reservation manually."
))
for move in picking.move_lines:
for move_line in move.move_line_ids:
move_line.qty_done = move_line.product_uom_qty
if picking._check_backorder():
pick_to_backorder |= picking
continue
pick_to_do |= picking
# Process every picking that do not require a backorder, then return a single backorder wizard for every other ones.
if pick_to_do:
pick_to_do.action_done()
if pick_to_backorder:
return pick_to_backorder.action_generate_backorder_wizard()
return False
class PosDetails(models.TransientModel):
_name = 'pos.details.wizard'
_description = 'Open Sales Details Report'
def _default_start_date(self):
""" Find the earliest start_date of the latests sessions """
# restrict to configs available to the user
config_ids = self.env['pos.config'].search([]).ids
# exclude configs has not been opened for 2 days
self.env.cr.execute(
"""
SELECT
max(start_at) as start,
config_id
FROM pos_session
WHERE config_id = ANY(%s)
AND start_at > (NOW() - INTERVAL '2 DAYS')
GROUP BY config_id
""", (config_ids, ))
latest_start_dates = [
res['start'] for res in self.env.cr.dictfetchall()
]
# earliest of the latest sessions
return latest_start_dates and min(
latest_start_dates) or fields.Datetime.now()
start_date = fields.Datetime(required=True, default=_default_start_date)
end_date = fields.Datetime(required=True, default=fields.Datetime.now)
pos_config_ids = fields.Many2many(
'pos.config',
'pos_detail_configs',
default=lambda s: s.env['pos.config'].search([]))
@api.onchange('start_date')
def _onchange_start_date(self):
if self.start_date and self.end_date and self.end_date < self.start_date:
self.end_date = self.start_date
@api.onchange('end_date')
def _onchange_end_date(self):
if self.end_date and self.end_date < self.start_date:
self.start_date = self.end_date
@api.multi
def generate_report(self):
if (not self.env.user.company_id.logo):
raise UserError(
_("You have to set a logo or a layout for your company."))
elif (not self.env.user.company_id.external_report_layout):
raise UserError(
_("You have to set your reports's header and footer layout."))
data = {
'date_start': self.start_date,
'date_stop': self.end_date,
'config_ids': self.pos_config_ids.ids
}
return self.env.ref('point_of_sale.sale_details_report').report_action(
[], data=data)
class CountryGroup(models.Model):
_description = "Country Group"
_name = 'res.country.group'
name = fields.Char(required=True, translate=True)
country_ids = fields.Many2many('res.country',
'res_country_res_country_group_rel',
'res_country_group_id',
'res_country_id',
string='Countries')
class MaintenanceTeam(models.Model):
_name = 'maintenance.team'
_description = 'Maintenance Teams'
name = fields.Char(required=True, translate=True)
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)
class MailActivityType(models.Model):
""" Activity Types are used to categorize activities. Each type is a different
kind of activity e.g. call, mail, meeting. An activity can be generic i.e.
available for all models using activities; or specific to a model in which
case res_model_id field should be used. """
_name = 'mail.activity.type'
_description = 'Activity Type'
_rec_name = 'name'
_order = 'sequence, id'
name = fields.Char('Name', required=True, translate=True)
summary = fields.Char('Summary', translate=True)
sequence = fields.Integer('Sequence', default=10)
days = fields.Integer(
'# Days',
default=0,
help=
'Number of days before executing the action. It allows to plan the action deadline.'
)
icon = fields.Char('Icon', help="Font awesome icon e.g. fa-tasks")
res_model_id = fields.Many2one(
'ir.model',
'Model',
index=True,
help='Specify a model if the activity should be specific to a model'
' and not available when managing activities for other models.')
next_type_ids = fields.Many2many('mail.activity.type',
'mail_activity_rel',
'activity_id',
'recommended_id',
string='Recommended Next Activities')
previous_type_ids = fields.Many2many('mail.activity.type',
'mail_activity_rel',
'recommended_id',
'activity_id',
string='Preceding Activities')
category = fields.Selection(
[('default', 'Other')],
default='default',
string='Category',
help=
'Categories may trigger specific behavior like opening calendar view')
class AccountBalanceReport(models.TransientModel):
_inherit = "account.common.account.report"
_name = 'account.balance.report'
_description = 'Trial Balance Report'
journal_ids = fields.Many2many('account.journal', 'account_balance_report_journal_rel', 'account_id', 'journal_id', string='Journals', required=True, default=[])
def _print_report(self, data):
data = self.pre_print_report(data)
records = self.env[data['model']].browse(data.get('ids', []))
return self.env.ref('account.action_report_trial_balance').report_action(records, data=data)
class PosConfig(models.Model):
_inherit = 'pos.config'
iface_splitbill = fields.Boolean(
string='Bill Splitting',
help='Enables Bill Splitting in the Point of Sale.')
iface_printbill = fields.Boolean(
string='Bill Printing',
help='Allows to print the Bill before payment.')
iface_orderline_notes = fields.Boolean(
string='Orderline Notes', help='Allow custom notes on Orderlines.')
floor_ids = fields.One2many(
'restaurant.floor',
'pos_config_id',
string='Restaurant Floors',
help='The restaurant floors served by this point of sale.')
printer_ids = fields.Many2many('restaurant.printer',
'pos_config_printer_rel',
'config_id',
'printer_id',
string='Order Printers')
is_table_management = fields.Boolean('Table Management')
is_order_printer = fields.Boolean('Order Printers')
module_pos_restaurant = fields.Boolean(default=True)
@api.onchange('iface_tipproduct')
def _onchange_tipproduct(self):
if self.iface_tipproduct:
self.tip_product_id = self.env.ref(
'point_of_sale.product_product_tip', False)
else:
self.tip_product_id = False
@api.onchange('module_pos_restaurant')
def _onchange_module_pos_restaurant(self):
if not self.module_pos_restaurant:
self.update({
'iface_printbill': False,
'iface_splitbill': False,
'iface_tipproduct': False,
'is_order_printer': False,
'is_table_management': False,
'iface_orderline_notes': False
})
@api.onchange('is_table_management')
def _onchange_is_table_management(self):
if not self.is_table_management:
self.floor_ids = [(5, 0, 0)]
@api.onchange('is_order_printer')
def _onchange_is_order_printer(self):
if not self.is_order_printer:
self.printer_ids = [(5, 0, 0)]
class BlogTag(models.Model):
_name = 'blog.tag'
_description = 'Blog Tag'
_inherit = ['website.seo.metadata']
_order = 'name'
name = fields.Char('Name', required=True, translate=True)
post_ids = fields.Many2many('blog.post', string='Posts')
_sql_constraints = [
('name_uniq', 'unique (name)', "Tag name already exists !"),
]
class ProductTemplate(models.Model):
_inherit = "product.template"
optional_product_ids = fields.Many2many(
'product.template',
'product_optional_rel',
'src_id',
'dest_id',
string='Optional Products',
help="Optional Products are suggested "
"whenever the customer hits *Add to Cart* (cross-sell strategy, "
"e.g. for computers: warranty, software, etc.).")
class TrackTag(models.Model):
_name = "event.track.tag"
_description = 'Track Tag'
_order = 'name'
name = fields.Char('Tag')
track_ids = fields.Many2many('event.track', string='Tracks')
color = fields.Integer(string='Color Index', default=10)
_sql_constraints = [
('name_uniq', 'unique (name)', "Tag name already exists !"),
]
class Category(models.Model):
_name = 'test_new_api.category'
name = fields.Char(required=True)
color = fields.Integer('Color Index')
parent = fields.Many2one('test_new_api.category')
root_categ = fields.Many2one(_name, compute='_compute_root_categ')
display_name = fields.Char(compute='_compute_display_name',
inverse='_inverse_display_name')
dummy = fields.Char(store=False)
discussions = fields.Many2many('test_new_api.discussion',
'test_new_api_discussion_category',
'category', 'discussion')
@api.one
@api.depends('name', 'parent.display_name') # this definition is recursive
def _compute_display_name(self):
if self.parent:
self.display_name = self.parent.display_name + ' / ' + self.name
else:
self.display_name = self.name
@api.depends('parent')
def _compute_root_categ(self):
for cat in self:
current = cat
while current.parent:
current = current.parent
cat.root_categ = current
@api.one
def _inverse_display_name(self):
names = self.display_name.split('/')
# determine sequence of categories
categories = []
for name in names[:-1]:
category = self.search([('name', 'ilike', name.strip())])
categories.append(category[0])
categories.append(self)
# assign parents following sequence
for parent, child in pycompat.izip(categories, categories[1:]):
if parent and child:
child.parent = parent
# assign name of last category, and reassign display_name (to normalize it)
self.name = names[-1].strip()
@api.multi
def read(self, fields=None, load='_classic_read'):
if self.search_count([('id', 'in', self._ids),
('name', '=', 'NOACCESS')]):
raise AccessError('Sorry')
return super(Category, self).read(fields=fields, load=load)
class IrModelFieldsAnonymizationHistory(models.Model):
_name = 'ir.model.fields.anonymization.history'
_order = "date desc"
date = fields.Datetime(required=True, readonly=True)
field_ids = fields.Many2many(
'ir.model.fields.anonymization', 'anonymized_field_to_history_rel',
'field_id', 'history_id', string='Fields', readonly=True
)
state = fields.Selection(selection=ANONYMIZATION_HISTORY_STATE, string='Status', required=True, readonly=True)
direction = fields.Selection(selection=ANONYMIZATION_DIRECTION, required=True, readonly=True)
msg = fields.Text('Message', readonly=True)
filepath = fields.Char('File path', readonly=True)
class HrPayslipEmployees(models.TransientModel):
_name = 'hr.payslip.employees'
_description = 'Generate payslips for all selected employees'
employee_ids = fields.Many2many('hr.employee', 'hr_employee_group_rel',
'payslip_id', 'employee_id', 'Employees')
@api.multi
def compute_sheet(self):
payslips = self.env['hr.payslip']
[data] = self.read()
active_id = self.env.context.get('active_id')
if active_id:
[run_data] = self.env['hr.payslip.run'].browse(active_id).read(
['date_start', 'date_end', 'credit_note'])
from_date = run_data.get('date_start')
to_date = run_data.get('date_end')
if not data['employee_ids']:
raise UserError(
_("You must select employee(s) to generate payslip(s)."))
for employee in self.env['hr.employee'].browse(data['employee_ids']):
slip_data = self.env['hr.payslip'].onchange_employee_id(
from_date, to_date, employee.id, contract_id=False)
res = {
'employee_id':
employee.id,
'name':
slip_data['value'].get('name'),
'struct_id':
slip_data['value'].get('struct_id'),
'contract_id':
slip_data['value'].get('contract_id'),
'payslip_run_id':
active_id,
'input_line_ids':
[(0, 0, x) for x in slip_data['value'].get('input_line_ids')],
'worked_days_line_ids':
[(0, 0, x)
for x in slip_data['value'].get('worked_days_line_ids')],
'date_from':
from_date,
'date_to':
to_date,
'credit_note':
run_data.get('credit_note'),
'company_id':
employee.company_id.id,
}
payslips += self.env['hr.payslip'].create(res)
payslips.compute_sheet()
return {'type': 'ir.actions.act_window_close'}
class test_uninstall_model(models.Model):
"""
This model uses different types of columns to make it possible to test
the uninstall feature of UNO, GECOERP.
"""
_name = 'test_uninstall.model'
name = fields.Char('Name')
ref = fields.Many2one('res.users', string='User')
rel = fields.Many2many('res.users', string='Users')
_sql_constraints = [
('name_uniq', 'unique (name)', 'Each name must be unique.'),
]
class AccountCommonReport(models.TransientModel):
_name = "account.common.report"
_description = "Account Common Report"
company_id = fields.Many2one('res.company',
string='Company',
readonly=True,
default=lambda self: self.env.user.company_id)
journal_ids = fields.Many2many(
'account.journal',
string='Journals',
required=True,
default=lambda self: self.env['account.journal'].search([]))
date_from = fields.Date(string='Start Date')
date_to = fields.Date(string='End Date')
target_move = fields.Selection([
('posted', 'All Posted Entries'),
('all', 'All Entries'),
],
string='Target Moves',
required=True,
default='posted')
def _build_contexts(self, data):
result = {}
result['journal_ids'] = 'journal_ids' in data['form'] and data['form'][
'journal_ids'] or False
result['state'] = 'target_move' in data['form'] and data['form'][
'target_move'] or ''
result['date_from'] = data['form']['date_from'] or False
result['date_to'] = data['form']['date_to'] or False
result['strict_range'] = True if result['date_from'] else False
return result
def _print_report(self, data):
raise NotImplementedError()
@api.multi
def check_report(self):
self.ensure_one()
data = {}
data['ids'] = self.env.context.get('active_ids', [])
data['model'] = self.env.context.get('active_model', 'ir.ui.menu')
data['form'] = self.read(
['date_from', 'date_to', 'journal_ids', 'target_move'])[0]
used_context = self._build_contexts(data)
data['form']['used_context'] = dict(used_context,
lang=self.env.context.get('lang')
or 'en_US')
return self.with_context(discard_logo_check=True)._print_report(data)
class AccountInvoiceLine(models.Model):
_inherit = 'account.invoice.line'
_order = 'invoice_id, layout_category_id, sequence, id'
sale_line_ids = fields.Many2many('sale.order.line',
'sale_order_line_invoice_rel',
'invoice_line_id',
'order_line_id',
string='Sales Order Lines',
readonly=True,
copy=False)
layout_category_id = fields.Many2one('sale.layout_category',
string='Section')
layout_category_sequence = fields.Integer(string='Layout Sequence')
class ImLivechatChannelRule(models.Model):
""" Channel Rules
Rules defining access to the channel (countries, and url matching). It also provide the 'auto pop'
option to open automatically the conversation.
"""
_name = 'im_livechat.channel.rule'
_description = 'Channel Rules'
_order = 'sequence asc'
regex_url = fields.Char('URL Regex',
help="Regular expression specifying the web pages this rule will be applied on.")
action = fields.Selection([('display_button', 'Display the button'), ('auto_popup', 'Auto popup'), ('hide_button', 'Hide the button')],
string='Action', required=True, default='display_button',
help="* 'Display the button' displays the chat button on the pages.\n"\
"* 'Auto popup' displays the button and automatically open the conversation pane.\n"\
"* 'Hide the button' hides the chat button on the pages.")
auto_popup_timer = fields.Integer('Auto popup timer', default=0,
help="Delay (in seconds) to automatically open the conversation window. Note: the selected action must be 'Auto popup' otherwise this parameter will not be taken into account.")
channel_id = fields.Many2one('im_livechat.channel', 'Channel',
help="The channel of the rule")
country_ids = fields.Many2many('res.country', 'im_livechat_channel_country_rel', 'channel_id', 'country_id', 'Country',
help="The rule will only be applied for these countries. Example: if you select 'Belgium' and 'United States' and that you set the action to 'Hide Button', the chat button will be hidden on the specified URL from the visitors located in these 2 countries. This feature requires GeoIP installed on your server.")
sequence = fields.Integer('Matching order', default=10,
help="Given the order to find a matching rule. If 2 rules are matching for the given url/country, the one with the lowest sequence will be chosen.")
def match_rule(self, channel_id, url, country_id=False):
""" determine if a rule of the given channel matches with the given url
:param channel_id : the identifier of the channel_id
:param url : the url to match with a rule
:param country_id : the identifier of the country
:returns the rule that matches the given condition. False otherwise.
:rtype : im_livechat.channel.rule
"""
def _match(rules):
for rule in rules:
if re.search(rule.regex_url or '', url):
return rule
return False
# first, search the country specific rules (the first match is returned)
if country_id: # don't include the country in the research if geoIP is not installed
domain = [('country_ids', 'in', [country_id]), ('channel_id', '=', channel_id)]
rule = _match(self.search(domain))
if rule:
return rule
# second, fallback on the rules without country
domain = [('country_ids', '=', False), ('channel_id', '=', channel_id)]
return _match(self.search(domain))
class HrSalaryEmployeeBymonth(models.TransientModel):
_name = 'hr.salary.employee.month'
_description = 'Hr Salary Employee By Month Report'
def _get_default_category(self):
return self.env['hr.salary.rule.category'].search(
[('code', '=', 'NET')], limit=1)
def _get_default_start_date(self):
year = fields.Date.from_string(fields.Date.today()).strftime('%Y')
return '{}-01-01'.format(year)
def _get_default_end_date(self):
date = fields.Date.from_string(fields.Date.today())
return date.strftime('%Y') + '-' + date.strftime(
'%m') + '-' + date.strftime('%d')
start_date = fields.Date(string='Start Date',
required=True,
default=_get_default_start_date)
end_date = fields.Date(string='End Date',
required=True,
default=_get_default_end_date)
employee_ids = fields.Many2many('hr.employee',
'payroll_year_rel',
'payroll_year_id',
'employee_id',
string='Employees',
required=True)
category_id = fields.Many2one('hr.salary.rule.category',
string='Category',
required=True,
default=_get_default_category)
@api.multi
def print_report(self):
"""
To get the date and print the report
@return: return report
"""
self.ensure_one()
data = {'ids': self.env.context.get('active_ids', [])}
res = self.read()
res = res and res[0] or {}
data.update({'form': res})
return self.env.ref(
'l10n_in_hr_payroll.action_report_hrsalarybymonth').report_action(
self, data=data)
