class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
expense_alias_prefix = fields.Char('Default Alias Name for Expenses')
use_mailgateway = fields.Boolean(string='Let your employees record expenses by email')
module_sale_management = fields.Boolean(string="Customer Billing")
@api.model
def get_values(self):
res = super(ResConfigSettings, self).get_values()
res.update(
expense_alias_prefix=self.env.ref('hr_expense.mail_alias_expense').alias_name,
use_mailgateway=self.env['ir.config_parameter'].sudo().get_param('hr_expense.use_mailgateway'),
)
return res
@api.multi
def set_values(self):
super(ResConfigSettings, self).set_values()
self.env.ref('hr_expense.mail_alias_expense').write({'alias_name': self.expense_alias_prefix})
self.env['ir.config_parameter'].sudo().set_param('hr_expense.use_mailgateway', self.use_mailgateway)
@api.onchange('use_mailgateway')
def _onchange_use_mailgateway(self):
if not self.use_mailgateway:
self.expense_alias_prefix = False
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 = "Stage of case"
_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 channel 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.")
probability = fields.Float(
'Probability (%)',
required=True,
default=10.0,
help=
"This percentage depicts the default/average probability of the Case for this stage to be a success"
)
on_change = fields.Boolean(
'Change Probability Automatically',
help=
"Setting this stage will change the probability automatically on the opportunity."
)
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='Team',
ondelete='set null',
help=
'Specific team that uses this stage. Other teams will not be able to see or use this stage.'
)
legend_priority = fields.Text(
'Priority Management Explanation',
translate=True,
help=
'Explanation text to help users using the star and priority mechanism on stages or issues that are in 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.'
)
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
module_account_accountant = fields.Boolean(string='Account Accountant')
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 LeadTest(models.Model):
_name = "base.automation.lead.test"
_description = "Action 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 Notification(models.Model):
_name = 'mail.notification'
_table = 'mail_message_res_partner_needaction_rel'
_rec_name = 'res_partner_id'
_log_access = False
_description = 'Message Notifications'
mail_message_id = fields.Many2one(
'mail.message', 'Message', index=True, ondelete='cascade', required=True)
res_partner_id = fields.Many2one(
'res.partner', 'Needaction Recipient', index=True, ondelete='cascade', required=True)
is_read = fields.Boolean('Is Read', index=True)
is_email = fields.Boolean('Sent by Email', index=True)
email_status = fields.Selection([
('ready', 'Ready to Send'),
('sent', 'Sent'),
('bounce', 'Bounced'),
('exception', 'Exception')], 'Email Status',
default='ready', index=True)
@api.model_cr
def init(self):
self._cr.execute('SELECT indexname FROM pg_indexes WHERE indexname = %s', ('mail_notification_res_partner_id_is_read_email_status_mail_message_id',))
if not self._cr.fetchone():
self._cr.execute('CREATE INDEX mail_notification_res_partner_id_is_read_email_status_mail_message_id ON mail_message_res_partner_needaction_rel (res_partner_id, is_read, email_status, mail_message_id)')
class SaleLayoutCategory(models.Model):
_name = 'sale.layout_category'
_order = 'sequence, id'
name = fields.Char('Name', required=True, translate=True)
sequence = fields.Integer('Sequence', required=True, default=10)
subtotal = fields.Boolean('Add subtotal', default=True)
pagebreak = fields.Boolean('Add pagebreak')
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 BooleanAggregate(models.Model):
_name = 'test_read_group.aggregate.boolean'
_order = 'key DESC'
key = fields.Integer()
bool_and = fields.Boolean(default=False, group_operator='bool_and')
bool_or = fields.Boolean(default=False, group_operator='bool_or')
bool_array = fields.Boolean(default=False, group_operator='array_agg')
class report_paperformat(models.Model):
_name = "report.paperformat"
_description = "Allows customization of a report."
name = fields.Char('Name', required=True)
default = fields.Boolean('Default paper format ?')
format = fields.Selection(
[('A0', 'A0 5 841 x 1189 mm'), ('A1', 'A1 6 594 x 841 mm'),
('A2', 'A2 7 420 x 594 mm'), ('A3', 'A3 8 297 x 420 mm'),
('A4', 'A4 0 210 x 297 mm, 8.26 x 11.69 inches'),
('A5', 'A5 9 148 x 210 mm'), ('A6', 'A6 10 105 x 148 mm'),
('A7', 'A7 11 74 x 105 mm'), ('A8', 'A8 12 52 x 74 mm'),
('A9', 'A9 13 37 x 52 mm'), ('B0', 'B0 14 1000 x 1414 mm'),
('B1', 'B1 15 707 x 1000 mm'), ('B2', 'B2 17 500 x 707 mm'),
('B3', 'B3 18 353 x 500 mm'), ('B4', 'B4 19 250 x 353 mm'),
('B5', 'B5 1 176 x 250 mm, 6.93 x 9.84 inches'),
('B6', 'B6 20 125 x 176 mm'), ('B7', 'B7 21 88 x 125 mm'),
('B8', 'B8 22 62 x 88 mm'), ('B9', 'B9 23 33 x 62 mm'),
('B10', ':B10 16 31 x 44 mm'), ('C5E', 'C5E 24 163 x 229 mm'),
('Comm10E', 'Comm10E 25 105 x 241 mm, U.S. '
'Common 10 Envelope'), ('DLE', 'DLE 26 110 x 220 mm'),
('Executive', 'Executive 4 7.5 x 10 inches, '
'190.5 x 254 mm'), ('Folio', 'Folio 27 210 x 330 mm'),
('Ledger', 'Ledger 28 431.8 x 279.4 mm'),
('Legal', 'Legal 3 8.5 x 14 inches, '
'215.9 x 355.6 mm'),
('Letter', 'Letter 2 8.5 x 11 inches, '
'215.9 x 279.4 mm'), ('Tabloid', 'Tabloid 29 279.4 x 431.8 mm'),
('custom', 'Custom')],
'Paper size',
default='A4',
help="Select Proper Paper size")
margin_top = fields.Float('Top Margin (mm)', default=40)
margin_bottom = fields.Float('Bottom Margin (mm)', default=20)
margin_left = fields.Float('Left Margin (mm)', default=7)
margin_right = fields.Float('Right Margin (mm)', default=7)
page_height = fields.Integer('Page height (mm)', default=False)
page_width = fields.Integer('Page width (mm)', default=False)
orientation = fields.Selection([('Landscape', 'Landscape'),
('Portrait', 'Portrait')],
'Orientation',
default='Landscape')
header_line = fields.Boolean('Display a header line', default=False)
header_spacing = fields.Integer('Header spacing', default=35)
dpi = fields.Integer('Output DPI', required=True, default=90)
report_ids = fields.One2many('ir.actions.report',
'paperformat_id',
'Associated reports',
help="Explicitly associated reports")
@api.constrains('format')
def _check_format_or_page(self):
if self.filtered(lambda x: x.format != 'custom' and
(x.page_width or x.page_height)):
raise ValidationError(
_('Error ! You cannot select a format AND specific page width/height.'
))
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
lock_confirmed_po = fields.Boolean(
"Lock Confirmed Orders",
default=lambda self: self.env.user.company_id.po_lock == 'lock')
po_lock = fields.Selection(related='company_id.po_lock',
string="Purchase Order Modification *")
po_order_approval = fields.Boolean(
"Order Approval",
default=lambda self: self.env.user.company_id.po_double_validation ==
'two_step')
po_double_validation = fields.Selection(
related='company_id.po_double_validation',
string="Levels of Approvals *")
po_double_validation_amount = fields.Monetary(
related='company_id.po_double_validation_amount',
string="Minimum Amount",
currency_field='company_currency_id')
company_currency_id = fields.Many2one(
'res.currency',
related='company_id.currency_id',
readonly=True,
help='Utility field to express amount currency')
default_purchase_method = fields.Selection(
[
('purchase', 'Ordered quantities'),
('receive', 'Delivered quantities'),
],
string="Bill Control",
default_model="product.template",
help="This default value is applied to any new product created. "
"This can be changed in the product detail form.",
default="receive")
module_purchase_requisition = fields.Boolean("Purchase Agreements")
group_warning_purchase = fields.Boolean(
"Warnings", implied_group='purchase.group_warning_purchase')
module_stock_dropshipping = fields.Boolean("Dropshipping")
group_manage_vendor_price = fields.Boolean(
"Vendor Pricelists",
implied_group="purchase.group_manage_vendor_price")
module_account_3way_match = fields.Boolean(
"3-way matching: purchases, receptions and bills")
is_installed_sale = fields.Boolean(string="Is the Sale Module Installed")
group_analytic_account_for_purchases = fields.Boolean(
'Analytic accounting for purchases',
implied_group='purchase.group_analytic_accounting')
@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
def set_values(self):
super(ResConfigSettings, self).set_values()
self.po_lock = 'lock' if self.lock_confirmed_po else 'edit'
self.po_double_validation = 'two_step' if self.po_order_approval else 'one_step'
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 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 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 AccountPartnerLedger(models.TransientModel):
_inherit = "account.common.partner.report"
_name = "account.report.partner.ledger"
_description = "Account Partner Ledger"
amount_currency = fields.Boolean("With Currency", help="It adds the currency column on report if the currency differs from the company currency.")
reconciled = fields.Boolean('Reconciled Entries')
def _print_report(self, data):
data = self.pre_print_report(data)
data['form'].update({'reconciled': self.reconciled, 'amount_currency': self.amount_currency})
return self.env.ref('account.action_report_partnerledger').report_action(self, data=data)
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')
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',
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 FinancialYearOpeningWizard(models.TransientModel):
_name = 'account.financial.year.op'
company_id = fields.Many2one(comodel_name='res.company', required=True)
opening_move_posted = fields.Boolean(
string='Opening Move Posted', compute='_compute_opening_move_posted')
opening_date = fields.Date(
string='Opening Date',
required=True,
related='company_id.account_opening_date',
help=
"Date from which the accounting is managed in GECOERP. It is the date of the opening entry."
)
fiscalyear_last_day = fields.Integer(
related="company_id.fiscalyear_last_day",
required=True,
help=
"The last day of the month will be taken if the chosen day doesn't exist."
)
fiscalyear_last_month = fields.Selection(
selection=[(1, 'January'), (2, 'February'), (3, 'March'), (4, 'April'),
(5, 'May'), (6, 'June'), (7, 'July'), (8, 'August'),
(9, 'September'), (10, 'October'), (11, 'November'),
(12, 'December')],
related="company_id.fiscalyear_last_month",
required=True,
help=
"The last day of the month will be taken if the chosen day doesn't exist."
)
account_setup_fy_data_done = fields.Boolean(
string='Financial year setup marked as done',
compute="_compute_setup_marked_done")
@api.depends('company_id.account_setup_fy_data_done')
def _compute_setup_marked_done(self):
for record in self:
record.account_setup_fy_data_done = record.company_id.account_setup_fy_data_done
@api.depends('company_id.account_opening_move_id')
def _compute_opening_move_posted(self):
for record in self:
record.opening_move_posted = record.company_id.opening_move_posted(
)
def mark_as_done(self):
""" Forces fiscal year setup state to 'done'."""
self.company_id.account_setup_fy_data_done = True
def unmark_as_done(self):
""" Forces fiscal year setup state to 'undone'."""
self.company_id.account_setup_fy_data_done = False
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
module_hr_timesheet = fields.Boolean("Timesheets")
module_rating_project = fields.Boolean(string="Rating on Tasks")
module_project_forecast = fields.Boolean(string="Forecasts")
group_subtask_project = fields.Boolean(
"Sub-tasks", implied_group="project.group_subtask_project")
project_time_mode_id = fields.Many2one(
'product.uom',
related='company_id.project_time_mode_id',
string='Project Time Unit',
help="This will set the unit of measure used in projects and tasks.\n"
"If you use the timesheet linked to projects, don't "
"forget to setup the right unit of measure in your employees.")
class AccountAssetCategory(models.Model):
_name = 'account.asset.category'
_description = 'Asset category'
active = fields.Boolean(default=True)
name = fields.Char(required=True, index=True, string="Asset Type")
account_analytic_id = fields.Many2one('account.analytic.account', string='Analytic Account')
account_asset_id = fields.Many2one('account.account', string='Asset Account', required=True, domain=[('internal_type','=','other'), ('deprecated', '=', False)], help="Account used to record the purchase of the asset at its original price.")
account_depreciation_id = fields.Many2one('account.account', string='Depreciation Entries: Asset Account', required=True, domain=[('internal_type','=','other'), ('deprecated', '=', False)], help="Account used in the depreciation entries, to decrease the asset value.")
account_depreciation_expense_id = fields.Many2one('account.account', string='Depreciation Entries: Expense Account', required=True, domain=[('internal_type','=','other'), ('deprecated', '=', False)], oldname='account_income_recognition_id', help="Account used in the periodical entries, to record a part of the asset as expense.")
journal_id = fields.Many2one('account.journal', string='Journal', required=True)
company_id = fields.Many2one('res.company', string='Company', required=True, default=lambda self: self.env['res.company']._company_default_get('account.asset.category'))
method = fields.Selection([('linear', 'Linear'), ('degressive', 'Degressive')], string='Computation Method', required=True, default='linear',
help="Choose the method to use to compute the amount of depreciation lines.\n"
" * Linear: Calculated on basis of: Gross Value / Number of Depreciations\n"
" * Degressive: Calculated on basis of: Residual Value * Degressive Factor")
method_number = fields.Integer(string='Number of Depreciations', default=5, help="The number of depreciations needed to depreciate your asset")
method_period = fields.Integer(string='Period Length', default=1, help="State here the time between 2 depreciations, in months", required=True)
method_progress_factor = fields.Float('Degressive Factor', default=0.3)
method_time = fields.Selection([('number', 'Number of Entries'), ('end', 'Ending Date')], string='Time Method', required=True, default='number',
help="Choose the method to use to compute the dates and number of entries.\n"
" * Number of Entries: Fix the number of entries and the time between 2 depreciations.\n"
" * Ending Date: Choose the time between 2 depreciations and the date the depreciations won't go beyond.")
method_end = fields.Date('Ending date')
prorata = fields.Boolean(string='Prorata Temporis', help='Indicates that the first depreciation entry for this asset have to be done from the purchase date instead of the first of January')
open_asset = fields.Boolean(string='Auto-confirm Assets', help="Check this if you want to automatically confirm the assets of this category when created by invoices.")
group_entries = fields.Boolean(string='Group Journal Entries', help="Check this if you want to group the generated entries by categories.")
type = fields.Selection([('sale', 'Sale: Revenue Recognition'), ('purchase', 'Purchase: Asset')], required=True, index=True, default='purchase')
@api.onchange('account_asset_id')
def onchange_account_asset(self):
if self.type == "purchase":
self.account_depreciation_id = self.account_asset_id
elif self.type == "sale":
self.account_depreciation_expense_id = self.account_asset_id
@api.onchange('type')
def onchange_type(self):
if self.type == 'sale':
self.prorata = True
self.method_period = 1
else:
self.method_period = 12
@api.onchange('method_time')
def _onchange_method_time(self):
if self.method_time != 'number':
self.prorata = False
class AccountJournal(models.Model):
_inherit = 'account.journal'
journal_user = fields.Boolean(
'Use in Point of Sale',
help=
"Check this box if this journal define a payment method that can be used in a point of sale."
)
amount_authorized_diff = fields.Float(
'Amount Authorized Difference',
help=
"This field depicts the maximum difference allowed between the ending balance and the theoretical cash when "
"closing a session, for non-POS managers. If this maximum is reached, the user will have an error message at "
"the closing of his session saying that he needs to contact his manager."
)
@api.model
def search(self, args, offset=0, limit=None, order=None, count=False):
session_id = self.env.context.get('pos_session_id', False)
if session_id:
session = self.env['pos.session'].browse(session_id)
if session:
args += [('id', 'in', session.config_id.journal_ids.ids)]
return super(AccountJournal, self).search(args=args,
offset=offset,
limit=limit,
order=order,
count=count)
@api.onchange('type')
def onchange_type(self):
if self.type not in ['bank', 'cash']:
self.journal_user = False
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 HrContract(models.Model):
"""
Employee contract allows to add different values in fields.
Fields are used in salary rule computation.
"""
_inherit = 'hr.contract'
tds = fields.Float(string='TDS',
digits=dp.get_precision('Payroll'),
help='Amount for Tax Deduction at Source')
driver_salay = fields.Boolean(
string='Driver Salary',
help='Check this box if you provide allowance for driver')
medical_insurance = fields.Float(
string='Medical Insurance',
digits=dp.get_precision('Payroll'),
help='Deduction towards company provided medical insurance')
voluntary_provident_fund = fields.Float(
string='Voluntary Provident Fund (%)',
digits=dp.get_precision('Payroll'),
help=
'VPF is a safe option wherein you can contribute more than the PF ceiling of 12% that has been mandated by the government and VPF computed as percentage(%)'
)
house_rent_allowance_metro_nonmetro = fields.Float(
string='House Rent Allowance (%)',
digits=dp.get_precision('Payroll'),
help=
'HRA is an allowance given by the employer to the employee for taking care of his rental or accommodation expenses for metro city it is 50% and for non metro 40%. \nHRA computed as percentage(%)'
)
supplementary_allowance = fields.Float(string='Supplementary Allowance',
digits=dp.get_precision('Payroll'))
class EventQuestion(models.Model):
_name = 'event.question'
_rec_name = 'title'
_order = 'sequence,id'
title = fields.Char(required=True, translate=True)
event_type_id = fields.Many2one('event.type', 'Event Type', ondelete='cascade')
event_id = fields.Many2one('event.event', 'Event', ondelete='cascade')
answer_ids = fields.One2many('event.answer', 'question_id', "Answers", required=True, copy=True)
sequence = fields.Integer(default=10)
is_individual = fields.Boolean('Ask each attendee',
help="If True, this question will be asked for every attendee of a reservation. If "
"not it will be asked only once and its value propagated to every attendees.")
@api.constrains('event_type_id', 'event_id')
def _constrains_event(self):
if any(question.event_type_id and question.event_id for question in self):
raise UserError(_('Question should belong to either event category or event but not both'))
@api.model
def create(self, vals):
event_id = vals.get('event_id', False)
if event_id:
event = self.env['event.event'].browse([event_id])
if event.event_type_id.use_questions and event.event_type_id.question_ids:
vals['answer_ids'] = vals.get('answer_ids', []) + [(0, 0, {
'name': answer.name,
'sequence': answer.sequence,
}) for answer in event.event_type_id.question_ids.filtered(lambda question: question.title == vals.get('title')).mapped('answer_ids')]
return super(EventQuestion, self).create(vals)
class HrPayslipRun(models.Model):
_inherit = 'hr.payslip.run'
_description = 'Payslip Batches'
available_advice = fields.Boolean(
string='Made Payment Advice?',
help=
'If this box is checked which means that Payment Advice exists for current batch',
readonly=False,
copy=False)
@api.multi
def draft_payslip_run(self):
super(HrPayslipRun, self).draft_payslip_run()
self.write({'available_advice': False})
@api.multi
def create_advice(self):
for run in self:
if run.available_advice:
raise UserError(
_("Payment advice already exists for %s, 'Set to Draft' to create a new advice."
) % (run.name, ))
company = self.env.user.company_id
advice = self.env['hr.payroll.advice'].create({
'batch_id':
run.id,
'company_id':
company.id,
'name':
run.name,
'date':
run.date_end,
'bank_id':
company.partner_id.bank_ids
and company.partner_id.bank_ids[0].bank_id.id or False
})
for slip in run.slip_ids:
# TODO is it necessary to interleave the calls ?
slip.action_payslip_done()
if not slip.employee_id.bank_account_id or not slip.employee_id.bank_account_id.acc_number:
raise UserError(
_('Please define bank account for the %s employee') %
(slip.employee_id.name))
payslip_line = self.env['hr.payslip.line'].search(
[('slip_id', '=', slip.id), ('code', '=', 'NET')], limit=1)
if payslip_line:
self.env['hr.payroll.advice.line'].create({
'advice_id':
advice.id,
'name':
slip.employee_id.bank_account_id.acc_number,
'ifsc_code':
slip.employee_id.bank_account_id.bank_bic or '',
'employee_id':
slip.employee_id.id,
'bysal':
payslip_line.total
})
self.write({'available_advice': True})
class WebsitePublishedMixin(models.AbstractModel):
_name = "website.published.mixin"
website_published = fields.Boolean('Visible in Website', copy=False)
website_url = fields.Char(
'Website URL',
compute='_compute_website_url',
help='The full URL to access the document through the website.')
@api.multi
def _compute_website_url(self):
for record in self:
record.website_url = '#'
@api.multi
def website_publish_button(self):
self.ensure_one()
if self.env.user.has_group(
'website.group_website_publisher') and self.website_url != '#':
return self.open_website_url()
return self.write({'website_published': not self.website_published})
def open_website_url(self):
return {
'type': 'ir.actions.act_url',
'url': self.website_url,
'target': 'self',
}
class ResConfigSettings(models.TransientModel):
_inherit = 'res.config.settings'
po_lead = fields.Float(related='company_id.po_lead')
use_po_lead = fields.Boolean(
string="Security Lead Time for Purchase",
oldname='default_new_po_lead',
help=
"Margin of error for vendor lead times. When the system generates Purchase Orders for reordering products,they will be scheduled that many days earlier to cope with unexpected vendor delays."
)
@api.onchange('use_po_lead')
def _onchange_use_po_lead(self):
if not self.use_po_lead:
self.po_lead = 0.0
def get_values(self):
res = super(ResConfigSettings, self).get_values()
res.update(use_po_lead=self.env['ir.config_parameter'].sudo().
get_param('purchase.use_po_lead'))
return res
def set_values(self):
super(ResConfigSettings, self).set_values()
self.env['ir.config_parameter'].sudo().set_param(
'purchase.use_po_lead', self.use_po_lead)
class EventType(models.Model):
_inherit = 'event.type'
use_questions = fields.Boolean('Questions to Attendees')
question_ids = fields.One2many(
'event.question', 'event_type_id',
string='Questions', copy=True)
class SaleQuoteTemplate(models.Model):
_name = "sale.quote.template"
_description = "Sale Quotation Template"
name = fields.Char('Quotation Template', required=True)
website_description = fields.Html('Description', translate=html_translate, sanitize_attributes=False)
quote_line = fields.One2many('sale.quote.line', 'quote_id', 'Quotation Template Lines', copy=True)
note = fields.Text('Terms and conditions')
options = fields.One2many('sale.quote.option', 'template_id', 'Optional Products Lines', copy=True)
number_of_days = fields.Integer('Quotation Duration',
help='Number of days for the validity date computation of the quotation')
require_payment = fields.Selection([
(0, 'Online Signature'),
(1, 'Online Payment')], default=0, string='Confirmation Mode',
help="Choose how you want to confirm an order to launch the delivery process. You can either "
"request a digital signature or an upfront payment. With a digital signature, you can "
"request the payment when issuing the invoice.")
mail_template_id = fields.Many2one(
'mail.template', 'Confirmation Mail',
domain=[('model', '=', 'sale.order')],
help="This e-mail template will be sent on confirmation. Leave empty to send nothing.")
active = fields.Boolean(default=True, help="If unchecked, it will allow you to hide the quotation template without removing it.")
@api.multi
def open_template(self):
self.ensure_one()
return {
'type': 'ir.actions.act_url',
'target': 'self',
'url': '/quote/template/%d' % self.id
}
class HrPayrollAdviceLine(models.Model):
'''
Bank Advice Lines
'''
_name = 'hr.payroll.advice.line'
_description = 'Bank Advice Lines'
advice_id = fields.Many2one('hr.payroll.advice', string='Bank Advice')
name = fields.Char('Bank Account No.', required=True)
ifsc_code = fields.Char(string='IFSC Code')
employee_id = fields.Many2one('hr.employee',
string='Employee',
required=True)
bysal = fields.Float(string='By Salary',
digits=dp.get_precision('Payroll'))
debit_credit = fields.Char(string='C/D', default='C')
company_id = fields.Many2one('res.company',
related='advice_id.company_id',
string='Company',
store=True)
ifsc = fields.Boolean(related='advice_id.neft', string='IFSC')
@api.onchange('employee_id')
def onchange_employee_id(self):
self.name = self.employee_id.bank_account_id.acc_number
self.ifsc_code = self.employee_id.bank_account_id.bank_bic or ''
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)
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.write({
'enabled': self.auth_oauth_google_enabled,
'client_id': self.auth_oauth_google_client_id,
})
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.')