hunk.code_window:         states={'draft': [('readonly', False)]},
           help="If its checked, indicates that all payslips generated from here are refund payslips.")
       payslip_count = fields.Integer(compute='_compute_payslip_count')
       def _compute_payslip_count(self):
           for payslip_run in self:
               payslip_run.payslip_count = len(self.slip_ids)
  
hunk.labels: keep keep add keep keep keep keep
hunk.after_edit:     company_id = fields.Many2one('res.company', string='Company', readonly=True, required=True,
           default=lambda self: self.env['res.company']._company_default_get())
  
hunk.file_path: addons/hr_payroll/models/hr_payslip.py
hunk.type: add
file: # -*- coding:utf-8 -*-
  # Part of Odoo. See LICENSE file for full copyright and licensing details.
  
  import babel
  from datetime import date, datetime, time
  from dateutil.relativedelta import relativedelta
  from pytz import timezone
  
  from odoo import api, fields, models, tools, _
  from odoo.addons import decimal_precision as dp
  from odoo.addons.hr_payroll.models.browsable_object import BrowsableObject, InputLine, WorkedDays, Payslips
  from odoo.exceptions import UserError, ValidationError
  from odoo.tools import float_round
  
  
  class HrPayslip(models.Model):
      _name = 'hr.payslip'
      _description = 'Pay Slip'
  
      struct_id = fields.Many2one('hr.payroll.structure', string='Structure',
          readonly=True, states={'draft': [('readonly', False)], 'verify': [('readonly', False)]},
          help='Defines the rules that have to be applied to this payslip, accordingly '
               'to the contract chosen. If you let empty the field contract, this field isn\'t '
               'mandatory anymore and thus the rules applied will be all the rules set on the '
               'structure of all contracts of the employee valid for the chosen period')
      name = fields.Char(string='Payslip Name', readonly=True, required=True,
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      number = fields.Char(string='Reference', readonly=True, copy=False,
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      employee_id = fields.Many2one('hr.employee', string='Employee', required=True, readonly=True,
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      date_from = fields.Date(string='From', readonly=True, required=True,
          default=lambda self: fields.Date.to_string(date.today().replace(day=1)), states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      date_to = fields.Date(string='To', readonly=True, required=True,
          default=lambda self: fields.Date.to_string((datetime.now() + relativedelta(months=+1, day=1, days=-1)).date()),
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      # this is chaos: 4 states are defined, 3 are used ('verify' isn't) and 5 exist ('confirm' seems to have existed)
      state = fields.Selection([
          ('draft', 'Draft'),
          ('verify', 'Waiting'),
          ('done', 'Done'),
          ('cancel', 'Rejected'),
      ], string='Status', index=True, readonly=True, copy=False, default='draft',
          help="""* When the payslip is created the status is \'Draft\'
                  \n* If the payslip is under verification, the status is \'Waiting\'.
                  \n* If the payslip is confirmed then status is set to \'Done\'.
                  \n* When user cancel payslip the status is \'Rejected\'.""")
      line_ids = fields.One2many('hr.payslip.line', 'slip_id', string='Payslip Lines', readonly=True,
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      company_id = fields.Many2one('res.company', string='Company', readonly=True, copy=False, required=True,
          default=lambda self: self.env['res.company']._company_default_get(),
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      worked_days_line_ids = fields.One2many('hr.payslip.worked_days', 'payslip_id',
          string='Payslip Worked Days', copy=True, readonly=True,
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      input_line_ids = fields.One2many('hr.payslip.input', 'payslip_id', string='Payslip Inputs',
          readonly=True, states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      paid = fields.Boolean(string='Made Payment Order ? ', readonly=True, copy=False,
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      note = fields.Text(string='Internal Note', readonly=True, states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      contract_id = fields.Many2one('hr.contract', string='Contract', readonly=True,
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]})
      credit_note = fields.Boolean(string='Credit Note', readonly=True,
          states={'draft': [('readonly', False)], 'verify': [('readonly', False)]},
          help="Indicates this payslip has a refund of another")
      payslip_run_id = fields.Many2one('hr.payslip.run', string='Batche Name', readonly=True,
          copy=False, states={'draft': [('readonly', False)], 'verify': [('readonly', False)]}, ondelete='cascade')
      compute_date = fields.Date('Computed On')
  
      basic_wage = fields.Monetary(compute='_compute_basic_net')
      net_wage = fields.Monetary(compute='_compute_basic_net')
      currency_id = fields.Many2one(related='contract_id.currency_id')
  
      @api.multi
      def _compute_basic_net(self):
          for payslip in self:
              payslip.basic_wage = payslip.get_salary_line_total('BASIC')
              payslip.net_wage = payslip.get_salary_line_total('NET')
  
      @api.constrains('date_from', 'date_to')
      def _check_dates(self):
          if any(self.filtered(lambda payslip: payslip.date_from > payslip.date_to)):
              raise ValidationError(_("Payslip 'Date From' must be earlier 'Date To'."))
  
      @api.multi
      def action_payslip_draft(self):
          return self.write({'state': 'draft'})
  
      @api.multi
      def action_payslip_done(self):
          self.compute_sheet()
          return self.write({'state': 'done'})
  
      @api.multi
      def action_payslip_cancel(self):
          if self.filtered(lambda slip: slip.state == 'done'):
              raise UserError(_("Cannot cancel a payslip that is done."))
          return self.write({'state': 'cancel'})
  
      @api.multi
      def refund_sheet(self):
          for payslip in self:
              copied_payslip = payslip.copy({'credit_note': True, 'name': _('Refund: ') + payslip.name})
              copied_payslip.compute_sheet()
              copied_payslip.action_payslip_done()
          formview_ref = self.env.ref('hr_payroll.view_hr_payslip_form', False)
          treeview_ref = self.env.ref('hr_payroll.view_hr_payslip_tree', False)
          return {
              'name': ("Refund Payslip"),
              'view_mode': 'tree, form',
              'view_id': False,
              'view_type': 'form',
              'res_model': 'hr.payslip',
              'type': 'ir.actions.act_window',
              'target': 'current',
              'domain': "[('id', 'in', %s)]" % copied_payslip.ids,
              'views': [(treeview_ref and treeview_ref.id or False, 'tree'), (formview_ref and formview_ref.id or False, 'form')],
              'context': {}
          }
  
      @api.model
      def create(self, vals):
          res = super(HrPayslip, self).create(vals)
          if not res.payslip_run_id:
              self.env['hr.payslip.run'].create({
                  'name': res.name,
                  'date_start': res.date_from,
                  'date_end': res.date_to,
                  'slip_ids': [(4, res.id)],
                  'state': 'close',
              })
          return res
  
      @api.multi
      def unlink(self):
          if any(self.filtered(lambda payslip: payslip.state not in ('draft', 'cancel'))):
              raise UserError(_('You cannot delete a payslip which is not draft or cancelled!'))
          return super(HrPayslip, self).unlink()
  
      @api.multi
      def compute_sheet(self):
          for payslip in self:
              number = payslip.number or self.env['ir.sequence'].next_by_code('salary.slip')
              # delete old payslip lines
              payslip.line_ids.unlink()
              lines = [(0, 0, line) for line in payslip._get_payslip_lines(payslip.contract_id)]
              payslip.write({'line_ids': lines, 'number': number, 'state': 'verify', 'compute_date': fields.Date.today()})
          return True
  
      @api.model
      def get_worked_day_lines(self, contract, date_from, date_to):
          """
          @param contract: Browse record of contracts
          @return: returns a list of dict containing the worked days that should be applied for the given contract between date_from and date_to
          """
          res = []
          # fill only if the contract as a working schedule linked
          if contract.resource_calendar_id:
              day_from = datetime.combine(max(fields.Date.from_string(date_from), contract.date_start), time.min)
              day_to = datetime.combine(min(fields.Date.from_string(date_to), contract.date_end or date.max), time.max)
  
              calendar = contract.resource_calendar_id
  
              benefit_types = self.env['hr.benefit.type'].search([('code', '!=', False)])
              for benefit_type in benefit_types:
                  hours = contract.employee_id.get_benefit_days_data(benefit_type, day_from, day_to, calendar=calendar)['hours']
                  if hours:
                      line = {
                          'name': benefit_type.name,
                          'sequence': benefit_type.sequence,
                          'code': benefit_type.code,
                          'number_of_days': hours / calendar.hours_per_day, # n_days returned by benefit_days_data doesn't make sense for extra work
                          'number_of_hours': hours,
                      }
                      res.append(line)
  
          return res
  
      def _get_base_local_dict(self):
          return {
              'float_round': float_round
          }
  
      # YTI TODO: pass recordset as argument
      @api.model
      def _get_payslip_lines(self, contracts):
          # YTI TODO: Move into browsable_object.py ?
          def _sum_salary_rule_category(localdict, category, amount):
              if category.parent_id:
                  localdict = _sum_salary_rule_category(localdict, category.parent_id, amount)
              localdict['categories'].dict[category.code] = category.code in localdict['categories'].dict and localdict['categories'].dict[category.code] + amount or amount
              return localdict
  
          self.ensure_one()
          #we keep a dict with the result because a value can be overwritten by another rule with the same code
          result_dict = {}
          rules_dict = {}
          worked_days_dict = {}
          inputs_dict = {}
          blacklist = []
  
          for code in self.worked_days_line_ids.mapped('code'):
              worked_days_dict[code] = self.worked_days_line_ids.filtered(lambda l: l.code == code)
          for code in self.input_line_ids.mapped('code'):
              inputs_dict[code] = self.input_line_ids.filtered(lambda l: l.code == code)
  
          categories = BrowsableObject(self.employee_id.id, {}, self.env)
          inputs = InputLine(self.employee_id.id, inputs_dict, self.env)
          worked_days = WorkedDays(self.employee_id.id, worked_days_dict, self.env)
          payslips = Payslips(self.employee_id.id, self, self.env)
          rules = BrowsableObject(self.employee_id.id, rules_dict, self.env)
  
          baselocaldict = {**self._get_base_local_dict(), **{'categories': categories, 'rules': rules, 'payslip': payslips, 'worked_days': worked_days, 'inputs': inputs}}
          #get the ids of the structures on the contracts and their parent id as well
          if len(contracts) == 1 and self.struct_id:
              structures = self.struct_id._get_parent_structure()
          else:
              structures = contracts.get_all_structures()
          #get the rules of the structure and thier children
          rule_ids = structures.get_all_rules()
          #run the rules by sequence
          sorted_rule_ids = [id for id, sequence in sorted(rule_ids, key=lambda x:x[1])]
          sorted_rules = self.env['hr.salary.rule'].browse(sorted_rule_ids)
  
          for contract in contracts:
              employee = contract.employee_id
              localdict = dict(baselocaldict, employee=employee, contract=contract)
              for rule in sorted_rules:
                  key = rule.code + '-' + str(contract.id)
                  localdict['result'] = None
                  localdict['result_qty'] = 1.0
                  localdict['result_rate'] = 100
                  #check if the rule can be applied
                  if rule._satisfy_condition(localdict) and rule.id not in blacklist:
                      #compute the amount of the rule
                      amount, qty, rate = rule._compute_rule(localdict)
                      #check if there is already a rule computed with that code
                      previous_amount = rule.code in localdict and localdict[rule.code] or 0.0
                      #set/overwrite the amount computed for this rule in the localdict
                      tot_rule = amount * qty * rate / 100.0
                      localdict[rule.code] = tot_rule
                      rules_dict[rule.code] = rule
                      #sum the amount for its salary category
                      localdict = _sum_salary_rule_category(localdict, rule.category_id, tot_rule - previous_amount)
                      #create/overwrite the rule in the temporary results
                      result_dict[key] = {
                          'sequence': rule.sequence,
                          'code': rule.code,
                          'name': rule.name,
                          'note': rule.note,
                          'salary_rule_id': rule.id,
                          'contract_id': contract.id,
                          'employee_id': contract.employee_id.id,
                          'amount': amount,
                          'quantity': qty,
                          'rate': rate,
                      }
                  else:
                      #blacklist this rule and its children
                      blacklist += [id for id, seq in rule._recursive_search_of_rules()]
  
          return list(result_dict.values())
  
      @api.onchange('employee_id', 'contract_id', 'date_from', 'date_to')
      def onchange_employee(self):
  
          if (not self.employee_id) or (not self.date_from) or (not self.date_to):
              return
  
          employee = self.employee_id
          date_from = self.date_from
          date_to = self.date_to
          
          self.company_id = employee.company_id
  
          if not self.contract_id: # Add a default contract if not already defined
              contracts = employee._get_contracts(date_from, date_to)
  
              if not contracts or not contracts[0].struct_id:
                  return
              self.contract_id = contracts[0]
              self.struct_id = contracts[0].struct_id
  
  
          #computation of the salary worked days
          worked_days_line_ids = self.get_worked_day_lines(self.contract_id, date_from, date_to)
          worked_days_lines = self.worked_days_line_ids.browse([])
          for r in worked_days_line_ids:
              worked_days_lines += worked_days_lines.new(r)
          self.worked_days_line_ids = worked_days_lines
  
      @api.onchange('struct_id')
      def _onchange_struct_id(self):
          ttyme = datetime.combine(fields.Date.from_string(self.date_from), time.min)
          locale = self.env.context.get('lang') or 'en_US'
          payslip_name = self.struct_id.payslip_name or _('Salary Slip')
          self.name = '%s - %s - %s' % (payslip_name, self.employee_id.name, tools.ustr(babel.dates.format_date(date=ttyme, format='MMMM-y', locale=locale)))
  
      def get_salary_line_total(self, code):
          self.ensure_one()
          line = self.line_ids.filtered(lambda line: line.code == code)
          if line:
              return line[0].total
          else:
              return 0.0
  
      @api.multi
      def action_print_payslip(self):
          return {
              'name': 'Payslip',
              'type': 'ir.actions.act_url',
              'url': '/print/payslips?list_ids=%(list_ids)s' % {'list_ids': ','.join(str(x) for x in self.ids)},
          }
  
  
  class HrPayslipLine(models.Model):
      _name = 'hr.payslip.line'
      _description = 'Payslip Line'
      _order = 'contract_id, sequence, code'
  
      name = fields.Char(required=True, translate=True)
      note = fields.Text(string='Description')
      sequence = fields.Integer(required=True, index=True, default=5,
                                help='Use to arrange calculation sequence')
      code = fields.Char(required=True,
                         help="The code of salary rules can be used as reference in computation of other rules. "
                         "In that case, it is case sensitive.")
      slip_id = fields.Many2one('hr.payslip', string='Pay Slip', required=True, ondelete='cascade')
      salary_rule_id = fields.Many2one('hr.salary.rule', string='Rule', required=True)
      contract_id = fields.Many2one('hr.contract', string='Contract', required=True, index=True)
      employee_id = fields.Many2one('hr.employee', string='Employee', required=True)
      rate = fields.Float(string='Rate (%)', digits=dp.get_precision('Payroll Rate'), default=100.0)
      amount = fields.Float(digits=dp.get_precision('Payroll'))
      quantity = fields.Float(digits=dp.get_precision('Payroll'), default=1.0)
      total = fields.Float(compute='_compute_total', string='Total', digits=dp.get_precision('Payroll'), store=True)
  
      amount_select = fields.Selection(related='salary_rule_id.amount_select', readonly=True)
      amount_fix = fields.Float(related='salary_rule_id.amount_fix', readonly=True)
      amount_percentage = fields.Float(related='salary_rule_id.amount_percentage', readonly=True)
      appears_on_payslip = fields.Boolean(related='salary_rule_id.appears_on_payslip', readonly=True)
      category_id = fields.Many2one(related='salary_rule_id.category_id', readonly=True, store=True)
      register_id = fields.Many2one(related='salary_rule_id.register_id', readonly=True, store=True)
  
      @api.depends('quantity', 'amount', 'rate')
      def _compute_total(self):
          for line in self:
              line.total = float(line.quantity) * line.amount * line.rate / 100
  
      @api.model_create_multi
      def create(self, vals_list):
          for values in vals_list:
              if 'employee_id' not in values or 'contract_id' not in values:
                  payslip = self.env['hr.payslip'].browse(values.get('slip_id'))
                  values['employee_id'] = values.get('employee_id') or payslip.employee_id.id
                  values['contract_id'] = values.get('contract_id') or payslip.contract_id and payslip.contract_id.id
                  if not values['contract_id']:
                      raise UserError(_('You must set a contract to create a payslip line.'))
          return super(HrPayslipLine, self).create(vals_list)
  
  
  class HrPayslipWorkedDays(models.Model):
      _name = 'hr.payslip.worked_days'
      _description = 'Payslip Worked Days'
      _order = 'payslip_id, sequence'
  
      name = fields.Char(string='Description', required=True)
      payslip_id = fields.Many2one('hr.payslip', string='Pay Slip', required=True, ondelete='cascade', index=True)
      sequence = fields.Integer(required=True, index=True, default=10)
      code = fields.Char(required=True, help="The code that can be used in the salary rules")
      number_of_days = fields.Float(string='Number of Days')
      number_of_hours = fields.Float(string='Number of Hours')
      contract_id = fields.Many2one(related='payslip_id.contract_id', string='Contract', required=True,
          help="The contract for which applied this worked days")
  
  
  class HrPayslipInput(models.Model):
      _name = 'hr.payslip.input'
      _description = 'Payslip Input'
      _order = 'payslip_id, sequence'
  
      name = fields.Char(string='Description', required=True)
      payslip_id = fields.Many2one('hr.payslip', string='Pay Slip', required=True, ondelete='cascade', index=True)
      sequence = fields.Integer(required=True, index=True, default=10)
      code = fields.Char(required=True, help="The code that can be used in the salary rules")
      amount = fields.Float(help="It is used in computation. For e.g. A rule for sales having "
                                 "1% commission of basic salary for per product can defined in expression "
                                 "like result = inputs.SALEURO.amount * contract.wage*0.01.")
      contract_id = fields.Many2one(related='payslip_id.contract_id', string='Contract', required=True,
          help="The contract for which applied this input")
  
  
  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'),
          ('verify', 'Verify'),
          ('close', 'Done'),
      ], 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.")
      payslip_count = fields.Integer(compute='_compute_payslip_count')
  
      def _compute_payslip_count(self):
          for payslip_run in self:
              payslip_run.payslip_count = len(self.slip_ids)
  
      @api.multi
      def draft_payslip_run(self):
          return self.write({'state': 'draft'})
  
      @api.multi
      def close_payslip_run(self):
          self.mapped('slip_ids').filtered(lambda payslip: payslip.state != 'done').action_payslip_done()
          return self.write({'state': 'close'})
  
      def action_open_payslips(self):
          self.ensure_one()
          return {
              "type": "ir.actions.act_window",
              "res_model": "hr.payslip",
              "views": [[False, "tree"], [False, "form"]],
              "domain": [['id', 'in', self.slip_ids.ids]],
              "name": "Payslips",
          }
  