class PayslipLinesContributionRegister(models.TransientModel):
_name = 'payslip.lines.contribution.register'
_description = 'PaySlip Lines by Contribution Registers'
date_from = fields.Date(string='Date From',
required=True,
default=datetime.now().strftime('%Y-%m-01'))
date_to = fields.Date(
string='Date To',
required=True,
default=str(datetime.now() +
relativedelta.relativedelta(months=+1, day=1, days=-1))
[:10])
@api.multi
def print_report(self):
active_ids = self.env.context.get('active_ids', [])
datas = {
'ids': active_ids,
'model': 'hr.contribution.register',
'form': self.read()[0]
}
return self.env.ref(
'hr_payroll.action_contribution_register').report_action(
[], data=datas)
class CrossoveredBudget(models.Model):
_name = "crossovered.budget"
_description = "Budget"
_inherit = ['mail.thread']
name = fields.Char('Budget Name',
required=True,
states={'done': [('readonly', True)]})
creating_user_id = fields.Many2one('res.users',
'Responsible',
default=lambda self: self.env.user)
date_from = fields.Date('Start Date',
required=True,
states={'done': [('readonly', True)]})
date_to = fields.Date('End Date',
required=True,
states={'done': [('readonly', True)]})
state = fields.Selection([('draft', 'Draft'), ('cancel', 'Cancelled'),
('confirm', 'Confirmed'),
('validate', 'Validated'), ('done', 'Done')],
'Status',
default='draft',
index=True,
required=True,
readonly=True,
copy=False,
track_visibility='always')
crossovered_budget_line = fields.One2many(
'crossovered.budget.lines',
'crossovered_budget_id',
'Budget Lines',
states={'done': [('readonly', True)]},
copy=True)
company_id = fields.Many2one('res.company',
'Company',
required=True,
default=lambda self: self.env['res.company'].
_company_default_get('account.budget.post'))
@api.multi
def action_budget_confirm(self):
self.write({'state': 'confirm'})
@api.multi
def action_budget_draft(self):
self.write({'state': 'draft'})
@api.multi
def action_budget_validate(self):
self.write({'state': 'validate'})
@api.multi
def action_budget_cancel(self):
self.write({'state': 'cancel'})
@api.multi
def action_budget_done(self):
self.write({'state': 'done'})
class CrmPartnerReportAssign(models.Model):
""" CRM Lead Report """
_name = "crm.partner.report.assign"
_auto = False
_description = "CRM Partner Report"
partner_id = fields.Many2one('res.partner', 'Partner', required=False, readonly=True)
grade_id = fields.Many2one('res.partner.grade', 'Grade', readonly=True)
activation = fields.Many2one('res.partner.activation', 'Activation', index=True)
user_id = fields.Many2one('res.users', 'User', readonly=True)
date_review = fields.Date('Latest Partner Review')
date_partnership = fields.Date('Partnership Date')
country_id = fields.Many2one('res.country', 'Country', readonly=True)
team_id = fields.Many2one('crm.team', 'Sales Channel', oldname='section_id', readonly=True)
nbr_opportunities = fields.Integer('# of Opportunity', readonly=True, oldname='opp')
turnover = fields.Float('Turnover', readonly=True)
date = fields.Date('Invoice Account Date', readonly=True)
_depends = {
'account.invoice.report': ['date', 'partner_id', 'price_total', 'state', 'type'],
'crm.lead': ['partner_assigned_id'],
'res.partner': ['activation', 'country_id', 'date_partnership', 'date_review',
'grade_id', 'parent_id', 'team_id', 'user_id'],
}
@api.model_cr
def init(self):
"""
CRM Lead Report
@param cr: the current row, from the database cursor
"""
tools.drop_view_if_exists(self._cr, 'crm_partner_report_assign')
self._cr.execute("""
CREATE OR REPLACE VIEW crm_partner_report_assign AS (
SELECT
coalesce(i.id, p.id - 1000000000) as id,
p.id as partner_id,
(SELECT country_id FROM res_partner a WHERE a.parent_id=p.id AND country_id is not null limit 1) as country_id,
p.grade_id,
p.activation,
p.date_review,
p.date_partnership,
p.user_id,
p.team_id,
(SELECT count(id) FROM crm_lead WHERE partner_assigned_id=p.id) AS nbr_opportunities,
i.price_total as turnover,
i.date
FROM
res_partner p
left join account_invoice_report i
on (i.partner_id=p.id and i.type in ('out_invoice','out_refund') and i.state in ('open','paid'))
)""")
class ProductMargin(models.TransientModel):
_name = 'product.margin'
_description = 'Product Margin'
from_date = fields.Date('From', default=time.strftime('%Y-01-01'))
to_date = fields.Date('To', default=time.strftime('%Y-12-31'))
invoice_state = fields.Selection([
('paid', 'Paid'),
('open_paid', 'Open and Paid'),
('draft_open_paid', 'Draft, Open and Paid'),
],
'Invoice State',
index=True,
required=True,
default="open_paid")
@api.multi
def action_open_window(self):
self.ensure_one()
context = dict(self.env.context or {})
def ref(module, xml_id):
proxy = self.env['ir.model.data']
return proxy.get_object_reference(module, xml_id)
model, search_view_id = ref('product', 'product_search_form_view')
model, graph_view_id = ref('product_margin',
'view_product_margin_graph')
model, form_view_id = ref('product_margin', 'view_product_margin_form')
model, tree_view_id = ref('product_margin', 'view_product_margin_tree')
context.update(invoice_state=self.invoice_state)
if self.from_date:
context.update(date_from=self.from_date)
if self.to_date:
context.update(date_to=self.to_date)
views = [(tree_view_id, 'tree'), (form_view_id, 'form'),
(graph_view_id, 'graph')]
return {
'name': _('Product Margins'),
'context': context,
'view_type': 'form',
"view_mode": 'tree,form,graph',
'res_model': 'product.product',
'type': 'ir.actions.act_window',
'views': views,
'view_id': False,
'search_view_id': search_view_id,
}
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 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)
class MrpProductionMessage(models.Model):
_name = "mrp.message"
_description = "Production Message"
@api.model
def _default_valid_until(self):
return datetime.today() + relativedelta(days=7)
name = fields.Text(compute='_get_note_first_line', store=True)
message = fields.Html(required=True)
product_tmpl_id = fields.Many2one('product.template', 'Product Template')
product_id = fields.Many2one('product.product', string="Product")
bom_id = fields.Many2one(
'mrp.bom',
'Bill of Material',
domain=
"['|', ('product_id', '=', product_id), ('product_tmpl_id.product_variant_ids','=', product_id)]"
)
workcenter_id = fields.Many2one('mrp.workcenter', string='Work Center')
valid_until = fields.Date('Validity Date',
default=_default_valid_until,
required=True)
routing_id = fields.Many2one('mrp.routing', string='Routing')
@api.depends('message')
def _get_note_first_line(self):
for message in self:
message.name = (message.message and html2plaintext(message.message)
or "").strip().replace('*', '').split("\n")[0]
@api.multi
def save(self):
""" Used in a wizard-like form view, manual save button when in edit mode """
return True
class ConverterTest(models.Model):
_name = 'web_editor.converter.test'
# disable translation export for those brilliant field labels and values
_translate = False
char = fields.Char()
integer = fields.Integer()
float = fields.Float()
numeric = fields.Float(digits=(16, 2))
many2one = fields.Many2one('web_editor.converter.test.sub')
binary = fields.Binary()
date = fields.Date()
datetime = fields.Datetime()
selection = fields.Selection([
(1, "réponse A"),
(2, "réponse B"),
(3, "réponse C"),
(4, "réponse <D>"),
])
selection_str = fields.Selection(
[
('A', "Qu'il n'est pas arrivé à Toronto"),
('B', "Qu'il était supposé arriver à Toronto"),
('C', "Qu'est-ce qu'il fout ce maudit pancake, tabernacle ?"),
('D', "La réponse D"),
],
string=u"Lorsqu'un pancake prend l'avion à destination de Toronto et "
u"qu'il fait une escale technique à St Claude, on dit:")
html = fields.Html()
text = fields.Text()
class CompanyDependent(models.Model):
_name = 'test_new_api.company'
foo = fields.Char(company_dependent=True)
date = fields.Date(company_dependent=True)
moment = fields.Datetime(company_dependent=True)
tag_id = fields.Many2one('test_new_api.multi.tag', company_dependent=True)
class MixedModel(models.Model):
_name = 'test_new_api.mixed'
number = fields.Float(digits=(10, 2), default=3.14)
date = fields.Date()
now = fields.Datetime(compute='_compute_now')
lang = fields.Selection(string='Language', selection='_get_lang')
reference = fields.Reference(string='Related Document',
selection='_reference_models')
comment1 = fields.Html(sanitize=False)
comment2 = fields.Html(sanitize_attributes=True, strip_classes=False)
comment3 = fields.Html(sanitize_attributes=True, strip_classes=True)
comment4 = fields.Html(sanitize_attributes=True, strip_style=True)
currency_id = fields.Many2one(
'res.currency', default=lambda self: self.env.ref('base.EUR'))
amount = fields.Monetary()
@api.one
def _compute_now(self):
# this is a non-stored computed field without dependencies
self.now = fields.Datetime.now()
@api.model
def _get_lang(self):
return self.env['res.lang'].get_installed()
@api.model
def _reference_models(self):
models = self.env['ir.model'].sudo().search([('state', '!=', 'manual')
])
return [(model.model, model.name) for model in models
if not model.model.startswith('ir.')]
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 LunchCashMove(models.Model):
""" Two types of cashmoves: payment (credit) or order (debit) """
_name = 'lunch.cashmove'
_description = 'lunch cashmove'
user_id = fields.Many2one('res.users',
'User',
default=lambda self: self.env.uid)
date = fields.Date('Date',
required=True,
default=fields.Date.context_today)
amount = fields.Float(
'Amount',
required=True,
help=
'Can be positive (payment) or negative (order or payment if user wants to get his money back)'
)
description = fields.Text('Description',
help='Can be an order or a payment')
order_id = fields.Many2one('lunch.order.line', 'Order', ondelete='cascade')
state = fields.Selection([('order', 'Order'), ('payment', 'Payment')],
'Is an order or a payment',
default='payment')
@api.multi
def name_get(self):
return [(cashmove.id,
'%s %s' % (_('Lunch Cashmove'), '#%d' % cashmove.id))
for cashmove in self]
class test_model(models.Model):
_name = 'test_converter.test_model'
char = fields.Char()
integer = fields.Integer()
float = fields.Float()
numeric = fields.Float(digits=(16, 2))
many2one = fields.Many2one('test_converter.test_model.sub', group_expand='_gbf_m2o')
binary = fields.Binary()
date = fields.Date()
datetime = fields.Datetime()
selection = fields.Selection([
(1, "réponse A"),
(2, "réponse B"),
(3, "réponse C"),
(4, "réponse <D>"),
])
selection_str = fields.Selection([
('A', u"Qu'il n'est pas arrivé à Toronto"),
('B', u"Qu'il était supposé arriver à Toronto"),
('C', u"Qu'est-ce qu'il fout ce maudit pancake, tabernacle ?"),
('D', u"La réponse D"),
], string=u"Lorsqu'un pancake prend l'avion à destination de Toronto et "
u"qu'il fait une escale technique à St Claude, on dit:")
html = fields.Html()
text = fields.Text()
# `base` module does not contains any model that implement the functionality
# `group_expand`; test this feature here...
@api.model
def _gbf_m2o(self, subs, domain, order):
sub_ids = subs._search([], order=order, access_rights_uid=SUPERUSER_ID)
return subs.browse(sub_ids)
class 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 AccountMoveReversal(models.TransientModel):
"""
Account move reversal wizard, it cancel an account move by reversing it.
"""
_name = 'account.move.reversal'
_description = 'Account move reversal'
date = fields.Date(string='Reversal date',
default=fields.Date.context_today,
required=True)
journal_id = fields.Many2one(
'account.journal',
string='Use Specific Journal',
help='If empty, uses the journal of the journal entry to be reversed.')
@api.multi
def reverse_moves(self):
ac_move_ids = self._context.get('active_ids', False)
res = self.env['account.move'].browse(ac_move_ids).reverse_moves(
self.date, self.journal_id or False)
if res:
return {
'name': _('Reverse Moves'),
'type': 'ir.actions.act_window',
'view_type': 'form',
'view_mode': 'tree,form',
'res_model': 'account.move',
'domain': [('id', 'in', res)],
}
return {'type': 'ir.actions.act_window_close'}
class FleetVehicleOdometer(models.Model):
_name = 'fleet.vehicle.odometer'
_description = 'Odometer log for a vehicle'
_order = 'date desc'
name = fields.Char(compute='_compute_vehicle_log_name', store=True)
date = fields.Date(default=fields.Date.context_today)
value = fields.Float('Odometer Value', group_operator="max")
vehicle_id = fields.Many2one('fleet.vehicle', 'Vehicle', required=True)
unit = fields.Selection(related='vehicle_id.odometer_unit', string="Unit", readonly=True)
driver_id = fields.Many2one(related="vehicle_id.driver_id", string="Driver")
@api.depends('vehicle_id', 'date')
def _compute_vehicle_log_name(self):
for record in self:
name = record.vehicle_id.name
if not name:
name = record.date
elif record.date:
name += ' / ' + record.date
record.name = name
@api.onchange('vehicle_id')
def _onchange_vehicle(self):
if self.vehicle_id:
self.unit = self.vehicle_id.odometer_unit
class ResPartner(models.Model):
_inherit = "res.partner"
partner_weight = fields.Integer(
'Level Weight',
default=lambda *args: 0,
help=
"Gives the probability to assign a lead to this partner. (0 means no assignation.)"
)
grade_id = fields.Many2one('res.partner.grade', 'Level')
grade_sequence = fields.Integer(related='grade_id.sequence',
readonly=True,
store=True)
activation = fields.Many2one('res.partner.activation',
'Activation',
index=True)
date_partnership = fields.Date('Partnership Date')
date_review = fields.Date('Latest Partner Review')
date_review_next = fields.Date('Next Partner Review')
# customer implementation
assigned_partner_id = fields.Many2one(
'res.partner',
'Implemented by',
)
implemented_partner_ids = fields.One2many(
'res.partner',
'assigned_partner_id',
string='Implementation References',
)
implemented_count = fields.Integer(
compute='_compute_implemented_partner_count', store=True)
@api.one
@api.depends('implemented_partner_ids',
'implemented_partner_ids.website_published',
'implemented_partner_ids.active')
def _compute_implemented_partner_count(self):
self.implemented_count = len(
self.implemented_partner_ids.filtered('website_published'))
@api.onchange('grade_id')
def _onchange_grade_id(self):
grade = self.grade_id
self.partner_weight = grade.partner_weight if grade else 0
class OpeningAccountMoveWizard(models.TransientModel):
_name = 'account.opening'
company_id = fields.Many2one(comodel_name='res.company', required=True)
opening_move_id = fields.Many2one(
string='Opening Journal Entry',
comodel_name='account.move',
related='company_id.account_opening_move_id')
currency_id = fields.Many2one(comodel_name='res.currency',
related='opening_move_id.currency_id')
opening_move_line_ids = fields.One2many(string='Opening Journal Items',
related="opening_move_id.line_ids")
journal_id = fields.Many2one(string='Journal',
comodel_name='account.journal',
required=True,
related='opening_move_id.journal_id')
date = fields.Date(string='Opening Date',
required=True,
related='opening_move_id.date')
def validate(self):
self.opening_move_id.post()
@api.onchange('opening_move_line_ids')
def opening_move_line_ids_changed(self):
debit_diff, credit_diff = self.company_id.get_opening_move_differences(
self.opening_move_line_ids)
unaffected_earnings_account = self.company_id.get_unaffected_earnings_account(
)
balancing_line = self.opening_move_line_ids.filtered(
lambda x: x.account_id == unaffected_earnings_account)
if balancing_line:
if not self.opening_move_line_ids == balancing_line and (
debit_diff or credit_diff):
balancing_line.debit = credit_diff
balancing_line.credit = debit_diff
else:
self.opening_move_line_ids -= balancing_line
elif debit_diff or credit_diff:
balancing_line = self.env['account.move.line'].new({
'name':
_('Automatic Balancing Line'),
'move_id':
self.company_id.account_opening_move_id.id,
'account_id':
unaffected_earnings_account.id,
'debit':
credit_diff,
'credit':
debit_diff,
'company_id':
self.company_id,
})
self.opening_move_line_ids += balancing_line
class PurchaseRequisitionLine(models.Model):
_name = "purchase.requisition.line"
_description = "Purchase Requisition Line"
_rec_name = 'product_id'
product_id = fields.Many2one('product.product', string='Product', domain=[('purchase_ok', '=', True)], required=True)
product_uom_id = fields.Many2one('product.uom', string='Product Unit of Measure')
product_qty = fields.Float(string='Quantity', digits=dp.get_precision('Product Unit of Measure'))
price_unit = fields.Float(string='Unit Price', digits=dp.get_precision('Product Price'))
qty_ordered = fields.Float(compute='_compute_ordered_qty', string='Ordered Quantities')
requisition_id = fields.Many2one('purchase.requisition', string='Purchase Agreement', ondelete='cascade')
company_id = fields.Many2one('res.company', related='requisition_id.company_id', string='Company', store=True, readonly=True, default= lambda self: self.env['res.company']._company_default_get('purchase.requisition.line'))
account_analytic_id = fields.Many2one('account.analytic.account', string='Analytic Account')
schedule_date = fields.Date(string='Scheduled Date')
move_dest_id = fields.Many2one('stock.move', 'Downstream Move')
@api.multi
@api.depends('requisition_id.purchase_ids.state')
def _compute_ordered_qty(self):
for line in self:
total = 0.0
for po in line.requisition_id.purchase_ids.filtered(lambda purchase_order: purchase_order.state in ['purchase', 'done']):
for po_line in po.order_line.filtered(lambda order_line: order_line.product_id == line.product_id):
if po_line.product_uom != line.product_uom_id:
total += po_line.product_uom._compute_quantity(po_line.product_qty, line.product_uom_id)
else:
total += po_line.product_qty
line.qty_ordered = total
@api.onchange('product_id')
def _onchange_product_id(self):
if self.product_id:
self.product_uom_id = self.product_id.uom_id
self.product_qty = 1.0
if not self.account_analytic_id:
self.account_analytic_id = self.requisition_id.account_analytic_id
if not self.schedule_date:
self.schedule_date = self.requisition_id.schedule_date
@api.multi
def _prepare_purchase_order_line(self, name, product_qty=0.0, price_unit=0.0, taxes_ids=False):
self.ensure_one()
requisition = self.requisition_id
return {
'name': name,
'product_id': self.product_id.id,
'product_uom': self.product_id.uom_po_id.id,
'product_qty': product_qty,
'price_unit': price_unit,
'taxes_id': [(6, 0, taxes_ids)],
'date_planned': requisition.schedule_date or fields.Date.today(),
'account_analytic_id': self.account_analytic_id.id,
'move_dest_ids': self.move_dest_id and [(4, self.move_dest_id.id)] or []
}
class Product(models.Model):
_inherit = 'product.template'
membership = fields.Boolean(help='Check if the product is eligible for membership.')
membership_date_from = fields.Date(string='Membership Start Date',
help='Date from which membership becomes active.')
membership_date_to = fields.Date(string='Membership End Date',
help='Date until which membership remains active.')
_sql_constraints = [
('membership_date_greater', 'check(membership_date_to >= membership_date_from)', 'Error ! Ending Date cannot be set before Beginning Date.')
]
@api.model
def fields_view_get(self, view_id=None, view_type='form', toolbar=False, submenu=False):
if self._context.get('product') == 'membership_product':
if view_type == 'form':
view_id = self.env.ref('membership.membership_products_form').id
else:
view_id = self.env.ref('membership.membership_products_tree').id
return super(Product, self).fields_view_get(view_id=view_id, view_type=view_type, toolbar=toolbar, submenu=submenu)
class YearlySalaryDetail(models.TransientModel):
_name = 'yearly.salary.detail'
_description = 'Hr Salary Employee By Category Report'
def _get_default_date_from(self):
year = fields.Date.from_string(fields.Date.today()).strftime('%Y')
return '{}-01-01'.format(year)
def _get_default_date_to(self):
date = fields.Date.from_string(fields.Date.today())
return date.strftime('%Y') + '-' + date.strftime(
'%m') + '-' + date.strftime('%d')
employee_ids = fields.Many2many('hr.employee',
'payroll_emp_rel',
'payroll_id',
'employee_id',
string='Employees',
required=True)
date_from = fields.Date(string='Start Date',
required=True,
default=_get_default_date_from)
date_to = fields.Date(string='End Date',
required=True,
default=_get_default_date_to)
@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_hryearlysalary').report_action(
self, data=data)
class ResourceCalendarAttendance(models.Model):
_name = "resource.calendar.attendance"
_description = "Work Detail"
_order = 'dayofweek, hour_from'
name = fields.Char(required=True)
dayofweek = fields.Selection([
('0', 'Monday'),
('1', 'Tuesday'),
('2', 'Wednesday'),
('3', 'Thursday'),
('4', 'Friday'),
('5', 'Saturday'),
('6', 'Sunday')
], 'Day of Week', required=True, index=True, default='0')
date_from = fields.Date(string='Starting Date')
date_to = fields.Date(string='End Date')
hour_from = fields.Float(string='Work from', required=True, index=True,
help="Start and End time of working.\n"
"A specific value of 24:00 is interpreted as 23:59:59.999999.")
hour_to = fields.Float(string='Work to', required=True)
calendar_id = fields.Many2one("resource.calendar", string="Resource's Calendar", required=True, ondelete='cascade')
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 CurrencyRate(models.Model):
_name = "res.currency.rate"
_description = "Currency Rate"
_order = "name desc"
name = fields.Date(string='Date',
required=True,
index=True,
default=lambda self: fields.Date.today())
rate = fields.Float(
digits=(12, 6),
help='The rate of the currency to the currency of rate 1')
currency_id = fields.Many2one('res.currency',
string='Currency',
readonly=True)
company_id = fields.Many2one('res.company',
string='Company',
default=lambda self: self.env.user.company_id)
_sql_constraints = [
('unique_name_per_day', 'unique (name,currency_id,company_id)',
'Only one currency rate per day allowed!'),
]
@api.model
def name_search(self, name, args=None, operator='ilike', limit=80):
if operator in ['=', '!=']:
try:
date_format = '%Y-%m-%d'
if self._context.get('lang'):
langs = self.env['res.lang'].search([
('code', '=', self._context['lang'])
])
if langs:
date_format = langs.date_format
name = time.strftime('%Y-%m-%d',
time.strptime(name, date_format))
except ValueError:
try:
args.append(('rate', operator, float(name)))
except ValueError:
return []
name = ''
operator = 'ilike'
return super(CurrencyRate, self).name_search(name,
args=args,
operator=operator,
limit=limit)
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 link_tracker_click(models.Model):
_name = "link.tracker.click"
_rec_name = "link_id"
click_date = fields.Date(string='Create Date')
link_id = fields.Many2one('link.tracker',
'Link',
required=True,
ondelete='cascade')
ip = fields.Char(string='Internet Protocol')
country_id = fields.Many2one('res.country', 'Country')
@api.model
def add_click(self, code, ip, country_code, stat_id=False):
self = self.sudo()
code_rec = self.env['link.tracker.code'].search([('code', '=', code)])
if not code_rec:
return None
again = self.search_count([('link_id', '=', code_rec.link_id.id),
('ip', '=', ip)])
if not again:
self.create(
self._get_click_values_from_route(
dict(
code=code,
ip=ip,
country_code=country_code,
stat_id=stat_id,
)))
def _get_click_values_from_route(self, route_values):
code = self.env['link.tracker.code'].search(
[('code', '=', route_values['code'])], limit=1)
country = self.env['res.country'].search(
[('code', '=', route_values['country_code'])], limit=1)
return {
'link_id': code.link_id.id,
'create_date': datetime.date.today(),
'ip': route_values['ip'],
'country_id': country.id,
}
class ResPartner(models.Model):
_inherit = "res.partner"
partner_latitude = fields.Float(string='Geo Latitude', digits=(16, 5))
partner_longitude = fields.Float(string='Geo Longitude', digits=(16, 5))
date_localization = fields.Date(string='Geolocation Date')
@classmethod
def _geo_localize(cls,
apikey,
street='',
zip='',
city='',
state='',
country=''):
search = geo_query_address(street=street,
zip=zip,
city=city,
state=state,
country=country)
result = geo_find(search, apikey)
if result is None:
search = geo_query_address(city=city, state=state, country=country)
result = geo_find(search, apikey)
return result
@api.multi
def geo_localize(self):
# We need country names in English below
apikey = self.env['ir.config_parameter'].sudo().get_param(
'google.api_key_geocode')
for partner in self.with_context(lang='en_US'):
result = partner._geo_localize(apikey, partner.street, partner.zip,
partner.city, partner.state_id.name,
partner.country_id.name)
if result:
partner.write({
'partner_latitude':
result[0],
'partner_longitude':
result[1],
'date_localization':
fields.Date.context_today(partner)
})
return True
class TimesheetAttendance(models.Model):
_name = 'hr.timesheet.attendance.report'
_auto = False
user_id = fields.Many2one('res.users')
date = fields.Date()
total_timesheet = fields.Float()
total_attendance = fields.Float()
total_difference = fields.Float()
@api.model_cr
def init(self):
self._cr.execute("""CREATE OR REPLACE VIEW %s AS (
SELECT
max(id) AS id,
t.user_id,
t.date,
coalesce(sum(t.attendance), 0) AS total_attendance,
coalesce(sum(t.timesheet), 0) AS total_timesheet,
coalesce(sum(t.attendance), 0) - coalesce(sum(t.timesheet), 0) as total_difference
FROM (
SELECT
-hr_attendance.id AS id,
resource_resource.user_id AS user_id,
hr_attendance.worked_hours AS attendance,
NULL AS timesheet,
date_trunc('day', hr_attendance.check_in) AS date
FROM hr_attendance
LEFT JOIN hr_employee ON hr_employee.id = hr_attendance.employee_id
LEFT JOIN resource_resource on resource_resource.id = hr_employee.resource_id
UNION ALL
SELECT
ts.id AS id,
ts.user_id AS user_id,
NULL AS attendance,
ts.unit_amount AS timesheet,
date_trunc('day', ts.date) AS date
FROM account_analytic_line AS ts
WHERE ts.project_id IS NOT NULL
) AS t
GROUP BY t.user_id, t.date
ORDER BY t.date
)
""" % self._table)
class Employee(models.Model):
_inherit = "hr.employee"
manager = fields.Boolean(string='Is a Manager')
medic_exam = fields.Date(string='Medical Examination Date',
groups="hr.group_hr_user")
place_of_birth = fields.Char('Place of Birth', groups="hr.group_hr_user")
children = fields.Integer(string='Number of Children',
groups="hr.group_hr_user")
vehicle = fields.Char(string='Company Vehicle', groups="hr.group_hr_user")
vehicle_distance = fields.Integer(string='Home-Work Dist.',
help="In kilometers",
groups="hr.group_hr_user")
contract_ids = fields.One2many('hr.contract',
'employee_id',
string='Contracts')
contract_id = fields.Many2one('hr.contract',
compute='_compute_contract_id',
string='Current Contract',
help='Latest contract of the employee')
contracts_count = fields.Integer(compute='_compute_contracts_count',
string='Contracts')
def _compute_contract_id(self):
""" get the lastest contract """
Contract = self.env['hr.contract']
for employee in self:
employee.contract_id = Contract.search(
[('employee_id', '=', employee.id)],
order='date_start desc',
limit=1)
def _compute_contracts_count(self):
# read_group as sudo, since contract count is displayed on form view
contract_data = self.env['hr.contract'].sudo().read_group(
[('employee_id', 'in', self.ids)], ['employee_id'],
['employee_id'])
result = dict((data['employee_id'][0], data['employee_id_count'])
for data in contract_data)
for employee in self:
employee.contracts_count = result.get(employee.id, 0)
class AccountAgedTrialBalance(models.TransientModel):
_name = 'account.aged.trial.balance'
_inherit = 'account.common.partner.report'
_description = 'Account Aged Trial balance Report'
period_length = fields.Integer(string='Period Length (days)',
required=True,
default=30)
journal_ids = fields.Many2many('account.journal',
string='Journals',
required=True)
date_from = fields.Date(default=lambda *a: time.strftime('%Y-%m-%d'))
def _print_report(self, data):
res = {}
data = self.pre_print_report(data)
data['form'].update(self.read(['period_length'])[0])
period_length = data['form']['period_length']
if period_length <= 0:
raise UserError(_('You must set a period length greater than 0.'))
if not data['form']['date_from']:
raise UserError(_('You must set a start date.'))
start = datetime.strptime(data['form']['date_from'], "%Y-%m-%d")
for i in range(5)[::-1]:
stop = start - relativedelta(days=period_length - 1)
res[str(i)] = {
'name': (i != 0 and (str(
(5 - (i + 1)) * period_length) + '-' + str(
(5 - i) * period_length))
or ('+' + str(4 * period_length))),
'stop':
start.strftime('%Y-%m-%d'),
'start': (i != 0 and stop.strftime('%Y-%m-%d') or False),
}
start = stop - relativedelta(days=1)
data['form'].update(res)
return self.env.ref(
'account.action_report_aged_partner_balance').with_context(
landscape=True).report_action(self, data=data)
