class AccountCommonReport(models.TransientModel):
_name = "account.common.report"
_description = "Account Common Report"
company_id = fields.Many2one('res.company',
string='Company',
required=True,
default=lambda self: self.env.company)
journal_ids = fields.Many2many(
'account.journal',
string='Journals',
required=True,
default=lambda self: self.env['account.journal'].search([(
'company_id', '=', self.company_id.id)]))
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')
@api.onchange('company_id')
def _onchange_company_id(self):
if self.company_id:
self.journal_ids = self.env['account.journal'].search([
('company_id', '=', self.company_id.id)
])
else:
self.journal_ids = self.env['account.journal'].search([])
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
result['company_id'] = data['form']['company_id'][0] or False
return result
def _print_report(self, data):
raise NotImplementedError()
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', 'company_id'
])[0]
used_context = self._build_contexts(data)
data['form']['used_context'] = dict(used_context,
lang=get_lang(self.env).code)
return self.with_context(discard_logo_check=True)._print_report(data)
class AccountFiscalYear(models.Model):
_name = 'account.fiscal.year'
_description = 'Fiscal Year'
name = fields.Char(string='Name', required=True)
date_from = fields.Date(string='Start Date',
required=True,
help='Start Date, included in the fiscal year.')
date_to = fields.Date(string='End Date',
required=True,
help='Ending Date, included in the fiscal year.')
company_id = fields.Many2one('res.company',
string='Company',
required=True,
default=lambda self: self.env.company)
@api.constrains('date_from', 'date_to', 'company_id')
def _check_dates(self):
'''
Check interleaving between fiscal years.
There are 3 cases to consider:
s1 s2 e1 e2
( [----)----]
s2 s1 e2 e1
[----(----] )
s1 s2 e2 e1
( [----] )
'''
for fy in self:
# Starting date must be prior to the ending date
date_from = fy.date_from
date_to = fy.date_to
if date_to < date_from:
raise ValidationError(
_('The ending date must not be prior to the starting date.'
))
domain = [
('id', '!=', fy.id),
('company_id', '=', fy.company_id.id),
'|',
'|',
'&',
('date_from', '<=', fy.date_from),
('date_to', '>=', fy.date_from),
'&',
('date_from', '<=', fy.date_to),
('date_to', '>=', fy.date_to),
'&',
('date_from', '<=', fy.date_from),
('date_to', '>=', fy.date_to),
]
if self.search_count(domain) > 0:
raise ValidationError(
_('You can not have an overlap between two fiscal years, please correct the start and/or end dates of your fiscal years.'
))
class CrmPartnerReportAssign(models.Model):
""" CRM Lead Report """
_name = "crm.partner.report.assign"
_auto = False
_description = "CRM Partnership Analysis"
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 Team', readonly=True)
nbr_opportunities = fields.Integer('# of Opportunity', readonly=True)
turnover = fields.Float('Turnover', readonly=True)
date = fields.Date('Invoice Account Date', readonly=True)
_depends = {
'account.invoice.report':
['invoice_date', 'partner_id', 'price_subtotal', 'state', 'type'],
'crm.lead': ['partner_assigned_id'],
'res.partner': [
'activation', 'country_id', 'date_partnership', 'date_review',
'grade_id', 'parent_id', 'team_id', 'user_id'
],
}
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_subtotal as turnover,
i.invoice_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','in_payment','paid'))
)""")
class AccountAnalyticDefault(models.Model):
_name = "account.analytic.default"
_description = "Analytic Distribution"
_rec_name = "analytic_id"
_order = "sequence"
sequence = fields.Integer(string='Sequence', help="Gives the sequence order when displaying a list of analytic distribution")
analytic_id = fields.Many2one('account.analytic.account', string='Analytic Account')
analytic_tag_ids = fields.Many2many('account.analytic.tag', string='Analytic Tags')
product_id = fields.Many2one('product.product', string='Product', ondelete='cascade', help="Select a product which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this product, it will automatically take this as an analytic account)")
partner_id = fields.Many2one('res.partner', string='Partner', ondelete='cascade', help="Select a partner which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this partner, it will automatically take this as an analytic account)")
account_id = fields.Many2one('account.account', string='Account', ondelete='cascade', help="Select an accounting account which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this account, it will automatically take this as an analytic account)")
user_id = fields.Many2one('res.users', string='User', ondelete='cascade', help="Select a user which will use analytic account specified in analytic default.")
company_id = fields.Many2one('res.company', string='Company', ondelete='cascade', help="Select a company which will use analytic account specified in analytic default (e.g. create new customer invoice or Sales order if we select this company, it will automatically take this as an analytic account)")
date_start = fields.Date(string='Start Date', help="Default start date for this Analytic Account.")
date_stop = fields.Date(string='End Date', help="Default end date for this Analytic Account.")
@api.constrains('analytic_id', 'analytic_tag_ids')
def _check_account_or_tags(self):
if any(not default.analytic_id and not default.analytic_tag_ids for default in self):
raise ValidationError(_('An analytic default requires at least an analytic account or an analytic tag.'))
@api.model
def account_get(self, product_id=None, partner_id=None, account_id=None, user_id=None, date=None, company_id=None):
domain = []
if product_id:
domain += ['|', ('product_id', '=', product_id)]
domain += [('product_id', '=', False)]
if partner_id:
domain += ['|', ('partner_id', '=', partner_id)]
domain += [('partner_id', '=', False)]
if account_id:
domain += ['|', ('account_id', '=', account_id)]
domain += [('account_id', '=', False)]
if company_id:
domain += ['|', ('company_id', '=', company_id)]
domain += [('company_id', '=', False)]
if user_id:
domain += ['|', ('user_id', '=', user_id)]
domain += [('user_id', '=', False)]
if date:
domain += ['|', ('date_start', '<=', date), ('date_start', '=', False)]
domain += ['|', ('date_stop', '>=', date), ('date_stop', '=', False)]
best_index = -1
res = self.env['account.analytic.default']
for rec in self.search(domain):
index = 0
if rec.product_id: index += 1
if rec.partner_id: index += 1
if rec.account_id: index += 1
if rec.company_id: index += 1
if rec.user_id: index += 1
if rec.date_start: index += 1
if rec.date_stop: index += 1
if index > best_index:
res = rec
best_index = index
return res
class ResourceCalendarAttendance(models.Model):
_name = "resource.calendar.attendance"
_description = "Work Detail"
_order = 'week_type, 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')
day_period = fields.Selection([('morning', 'Morning'),
('afternoon', 'Afternoon')],
required=True,
default='morning')
resource_id = fields.Many2one('resource.resource', 'Resource')
week_type = fields.Selection([('1', 'Odd week'), ('0', 'Even week')],
'Week Even/Odd',
default=False)
two_weeks_calendar = fields.Boolean(
"Calendar in 2 weeks mode", related='calendar_id.two_weeks_calendar')
display_type = fields.Selection([('line_section', "Section")],
default=False,
help="Technical field for UX purpose.")
sequence = fields.Integer(
default=10,
help=
"Gives the sequence of this line when displaying the resource calendar."
)
@api.onchange('hour_from', 'hour_to')
def _onchange_hours(self):
# avoid negative or after midnight
self.hour_from = min(self.hour_from, 23.99)
self.hour_from = max(self.hour_from, 0.0)
self.hour_to = min(self.hour_to, 23.99)
self.hour_to = max(self.hour_to, 0.0)
# avoid wrong order
self.hour_to = max(self.hour_to, self.hour_from)
class FleetVehicleAssignationLog(models.Model):
_name = "fleet.vehicle.assignation.log"
_description = "Drivers history on a vehicle"
_order = "create_date desc, date_start desc"
vehicle_id = fields.Many2one('fleet.vehicle',
string="Vehicle",
required=True)
driver_id = fields.Many2one('res.partner', string="Driver", required=True)
date_start = fields.Date(string="Start Date")
date_end = fields.Date(string="End Date")
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")
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_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 ResPartner(models.Model):
_inherit = "res.partner"
partner_weight = fields.Integer(
'Level Weight',
default=0,
tracking=True,
help=
"This should be a numerical value greater than 0 which will decide the contention for this partner to take this lead/opportunity."
)
grade_id = fields.Many2one('res.partner.grade',
'Partner Level',
tracking=True)
grade_sequence = fields.Integer(related='grade_id.sequence',
readonly=True,
store=True)
activation = fields.Many2one('res.partner.activation',
'Activation',
index=True,
tracking=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.depends('implemented_partner_ids',
'implemented_partner_ids.website_published',
'implemented_partner_ids.active')
def _compute_implemented_partner_count(self):
for partner in self:
partner.implemented_count = len(
partner.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 test_model(models.Model):
_name = 'test_converter.test_model'
_description = 'Test Converter 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(attachment=False)
date = fields.Date()
datetime = fields.Datetime()
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 AccountAnalyticLine(models.Model):
_name = 'account.analytic.line'
_description = 'Analytic Line'
_order = 'date desc, id desc'
@api.model
def _default_user(self):
return self.env.context.get('user_id', self.env.user.id)
name = fields.Char('Description', required=True)
date = fields.Date('Date', required=True, index=True, default=fields.Date.context_today)
amount = fields.Monetary('Amount', required=True, default=0.0)
unit_amount = fields.Float('Quantity', default=0.0)
product_uom_id = fields.Many2one('uom.uom', string='Unit of Measure', domain="[('category_id', '=', product_uom_category_id)]")
product_uom_category_id = fields.Many2one(related='product_uom_id.category_id', readonly=True)
account_id = fields.Many2one('account.analytic.account', 'Analytic Account', required=True, ondelete='restrict', index=True, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
partner_id = fields.Many2one('res.partner', string='Partner', domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
user_id = fields.Many2one('res.users', string='User', default=_default_user)
tag_ids = fields.Many2many('account.analytic.tag', 'account_analytic_line_tag_rel', 'line_id', 'tag_id', string='Tags', copy=True, domain="['|', ('company_id', '=', False), ('company_id', '=', company_id)]")
company_id = fields.Many2one('res.company', string='Company', required=True, readonly=True, default=lambda self: self.env.company)
currency_id = fields.Many2one(related="company_id.currency_id", string="Currency", readonly=True, store=True, compute_sudo=True)
group_id = fields.Many2one('account.analytic.group', related='account_id.group_id', store=True, readonly=True, compute_sudo=True)
@api.constrains('company_id', 'account_id')
def _check_company_id(self):
for line in self:
if line.account_id.company_id and line.company_id.id != line.account_id.company_id.id:
raise ValidationError(_('The selected account belongs to another company that the one you\'re trying to create an analytic item for'))
class LunchProduct(models.Model):
""" Products available to order. A product is linked to a specific vendor. """
_name = 'lunch.product'
_description = 'Lunch Product'
_inherit = 'image.mixin'
_order = 'name'
name = fields.Char('Product Name', required=True)
category_id = fields.Many2one('lunch.product.category',
'Product Category',
required=True)
description = fields.Text('Description')
price = fields.Float('Price', digits='Account', required=True)
supplier_id = fields.Many2one('lunch.supplier', 'Vendor', required=True)
active = fields.Boolean(default=True)
company_id = fields.Many2one('res.company',
related='supplier_id.company_id',
store=True)
currency_id = fields.Many2one('res.currency',
related='company_id.currency_id')
new_until = fields.Date('New Until')
favorite_user_ids = fields.Many2many('res.users',
'lunch_product_favorite_user_rel',
'product_id', 'user_id')
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",
readonly=False)
@api.depends('vehicle_id', 'date')
def _compute_vehicle_log_name(self):
for record in self:
name = record.vehicle_id.name
if not name:
name = str(record.date)
elif record.date:
name += ' / ' + str(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 FillTemporal(models.Model):
_name = 'test_read_group.fill_temporal'
_description = 'Group Test Fill Temporal'
date = fields.Date()
datetime = fields.Datetime()
value = fields.Integer()
class ConverterTest(models.Model):
_name = 'web_editor.converter.test'
_description = '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(attachment=False)
date = fields.Date()
datetime = fields.Datetime()
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'
_description = '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 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=0,
default=1.0,
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.company)
_sql_constraints = [
('unique_name_per_day', 'unique (name,currency_id,company_id)',
'Only one currency rate per day allowed!'),
('currency_rate_check', 'CHECK (rate>0)',
'The currency rate must be strictly positive.'),
]
@api.model
def _name_search(self,
name,
args=None,
operator='ilike',
limit=100,
name_get_uid=None):
if operator in ['=', '!=']:
try:
date_format = '%Y-%m-%d'
if self._context.get('lang'):
lang_id = self.env['res.lang']._search(
[('code', '=', self._context['lang'])],
access_rights_uid=name_get_uid)
if lang_id:
date_format = self.browse(lang_id).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,
name_get_uid=name_get_uid)
class User(models.Model):
_inherit = "res.users"
leave_manager_id = fields.Many2one(related='employee_id.leave_manager_id')
show_leaves = fields.Boolean(related='employee_id.show_leaves')
allocation_used_count = fields.Float(
related='employee_id.allocation_used_count')
allocation_count = fields.Float(related='employee_id.allocation_count')
leave_date_to = fields.Date(related='employee_id.leave_date_to')
is_absent = fields.Boolean(related='employee_id.is_absent')
allocation_used_display = fields.Char(
related='employee_id.allocation_used_display')
allocation_display = fields.Char(related='employee_id.allocation_display')
def __init__(self, pool, cr):
""" Override of __init__ to add access rights.
Access rights are disabled by default, but allowed
on some specific fields defined in self.SELF_{READ/WRITE}ABLE_FIELDS.
"""
readable_fields = [
'leave_manager_id',
'show_leaves',
'allocation_used_count',
'allocation_count',
'leave_date_to',
'is_absent',
'allocation_used_display',
'allocation_display',
]
init_res = super(User, self).__init__(pool, cr)
# duplicate list to avoid modifying the original reference
type(self).SELF_READABLE_FIELDS = type(
self).SELF_READABLE_FIELDS + readable_fields
return init_res
def _compute_im_status(self):
super(User, self)._compute_im_status()
on_leave_user_ids = self._get_on_leave_ids()
for user in self:
if user.id in on_leave_user_ids:
if user.im_status == 'online':
user.im_status = 'leave_online'
else:
user.im_status = 'leave_offline'
@api.model
def _get_on_leave_ids(self, partner=False):
now = fields.Datetime.now()
field = 'partner_id' if partner else 'id'
self.env.cr.execute(
'''SELECT res_users.%s FROM res_users
JOIN hr_leave ON hr_leave.user_id = res_users.id
AND state not in ('cancel', 'refuse')
AND res_users.active = 't'
AND date_from <= %%s AND date_to >= %%s''' % field,
(now, now))
return [r[0] for r in self.env.cr.fetchall()]
class ComplexModel(models.Model):
_name = model('complex')
_description = 'Tests: Base Import Model Complex'
f = fields.Float()
m = fields.Monetary()
c = fields.Char()
currency_id = fields.Many2one('res.currency')
d = fields.Date()
dt = fields.Datetime()
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 GroupOperator(models.Model):
_name = 'export.group_operator'
_description = 'Export Group Operator'
int_sum = fields.Integer(group_operator='sum')
int_max = fields.Integer(group_operator='max')
float_min = fields.Float(group_operator='min')
float_avg = fields.Float(group_operator='avg')
date_max = fields.Date(group_operator='max')
bool_and = fields.Boolean(group_operator='bool_and')
bool_or = fields.Boolean(group_operator='bool_or')
many2one = fields.Many2one('export.integer')
one2many = fields.One2many('export.group_operator.one2many', 'parent_id')
class ResumeLine(models.Model):
_name = 'hr.resume.line'
_description = "Resumé line of an employee"
_order = "line_type_id, date_end desc, date_start desc"
employee_id = fields.Many2one('hr.employee',
required=True,
ondelete='cascade')
name = fields.Char(required=True)
date_start = fields.Date(required=True)
date_end = fields.Date()
description = fields.Text(string="Description")
line_type_id = fields.Many2one('hr.resume.line.type', string="Type")
# Used to apply specific template on a line
display_type = fields.Selection([('classic', 'Classic')],
string="Display Type",
default='classic')
_sql_constraints = [
('date_check', "CHECK ((date_start <= date_end OR date_end = NULL))",
"The start date must be anterior to the end date."),
]
class PurchaseBillUnion(models.Model):
_name = 'purchase.bill.union'
_auto = False
_description = 'Purchases & Bills Union'
_order = "date desc, name desc"
name = fields.Char(string='Reference', readonly=True)
reference = fields.Char(string='Source', readonly=True)
partner_id = fields.Many2one('res.partner', string='Vendor', readonly=True)
date = fields.Date(string='Date', readonly=True)
amount = fields.Float(string='Amount', readonly=True)
currency_id = fields.Many2one('res.currency', string='Currency', readonly=True)
company_id = fields.Many2one('res.company', 'Company', readonly=True)
vendor_bill_id = fields.Many2one('account.move', string='Vendor Bill', readonly=True)
purchase_order_id = fields.Many2one('purchase.order', string='Purchase Order', readonly=True)
def init(self):
tools.drop_view_if_exists(self.env.cr, 'purchase_bill_union')
self.env.cr.execute("""
CREATE OR REPLACE VIEW purchase_bill_union AS (
SELECT
id, name, ref as reference, partner_id, date, amount_untaxed as amount, currency_id, company_id,
id as vendor_bill_id, NULL as purchase_order_id
FROM account_move
WHERE
type='in_invoice' and state = 'posted'
UNION
SELECT
-id, name, partner_ref as reference, partner_id, date_order::date as date, amount_untaxed as amount, currency_id, company_id,
NULL as vendor_bill_id, id as purchase_order_id
FROM purchase_order
WHERE
state in ('purchase', 'done') AND
invoice_status in ('to invoice', 'no')
)""")
def name_get(self):
result = []
for doc in self:
name = doc.name or ''
if doc.reference:
name += ' - ' + doc.reference
amount = doc.amount
if doc.purchase_order_id and doc.purchase_order_id.invoice_status == 'no':
amount = 0.0
name += ': ' + formatLang(self.env, amount, monetary=True, currency_obj=doc.currency_id)
result.append((doc.id, name))
return result
class L10nInAdvancesPaymentAdjustmentReport(models.Model):
_name = "l10n_in.advances.payment.adjustment.report"
_inherit = 'l10n_in.payment.report'
_description = "Advances Payment Adjustment Analysis"
_auto = False
date = fields.Date('Reconcile Date')
@api.depends('amount', 'currency_id', 'partner_id')
def _compute_tax_amount(self):
account_move_line = self.env['account.move.line']
for record in self:
taxes_data = self._compute_l10n_in_tax(taxes=record.l10n_in_tax_id,
price_unit=record.amount,
currency=record.currency_id
or None,
quantity=1,
partner=record.partner_id
or None)
record.igst_amount = taxes_data['igst_amount']
record.cgst_amount = taxes_data['cgst_amount']
record.sgst_amount = taxes_data['sgst_amount']
record.cess_amount = taxes_data['cess_amount']
record.gross_amount = taxes_data['total_excluded']
def _select(self):
select_str = super(L10nInAdvancesPaymentAdjustmentReport,
self)._select()
select_str += """,
apr.max_date AS date,
apr.amount AS amount
"""
return select_str
def _from(self):
from_str = super(L10nInAdvancesPaymentAdjustmentReport, self)._from()
from_str += """
JOIN account_partial_reconcile apr ON apr.credit_move_id = aml.id OR apr.debit_move_id = aml.id
"""
return from_str
def _where(self):
where_str = super(L10nInAdvancesPaymentAdjustmentReport, self)._where()
where_str += """
AND (apr.max_date > aml.date_maturity)
"""
return where_str
class CashmoveReport(models.Model):
_name = "lunch.cashmove.report"
_description = 'Cashmoves report'
_auto = False
_order = "date desc"
id = fields.Integer('ID')
amount = fields.Float('Amount')
date = fields.Date('Date')
currency_id = fields.Many2one('res.currency', string='Currency')
user_id = fields.Many2one('res.users', string='User')
description = fields.Text('Description')
def name_get(self):
return [(cashmove.id,
'%s %s' % (_('Lunch Cashmove'), '#%d' % cashmove.id))
for cashmove in self]
def init(self):
tools.drop_view_if_exists(self._cr, self._table)
self._cr.execute("""
CREATE or REPLACE view %s as (
SELECT
lc.id as id,
lc.amount as amount,
lc.date as date,
lc.currency_id as currency_id,
lc.user_id as user_id,
lc.description as description
FROM lunch_cashmove lc
UNION ALL
SELECT
-lol.id as id,
-lol.price as amount,
lol.date as date,
lol.currency_id as currency_id,
lol.user_id as user_id,
format('Order: %%s x %%s %%s', lol.quantity::text, lp.name, lol.display_toppings) as description
FROM lunch_order lol
JOIN lunch_product lp ON lp.id = lol.product_id
WHERE
lol.state in ('ordered', 'confirmed')
AND lol.active = True
);
""" % self._table)
class TimesheetAttendance(models.Model):
_name = 'hr.timesheet.attendance.report'
_auto = False
_description = 'Timesheet Attendance Report'
user_id = fields.Many2one('res.users')
date = fields.Date()
total_timesheet = fields.Float()
total_attendance = fields.Float()
total_difference = fields.Float()
def init(self):
tools.drop_view_if_exists(self.env.cr, self._table)
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,
hr_attendance.check_in::date 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,
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 AdvancesPaymentReport(models.Model):
_name = "l10n_in.advances.payment.report"
_inherit = 'l10n_in.payment.report'
_description = "Advances Payment Analysis"
_auto = False
date = fields.Date(string="Payment Date")
reconcile_amount = fields.Float(string="Reconcile amount in Payment month")
@api.depends('payment_amount', 'reconcile_amount', 'currency_id')
def _compute_tax_amount(self):
"""Calculate tax amount base on default tax set in company"""
account_move_line = self.env['account.move.line']
for record in self:
base_amount = record.payment_amount - record.reconcile_amount
taxes_data = self._compute_l10n_in_tax(taxes=record.l10n_in_tax_id,
price_unit=base_amount,
currency=record.currency_id
or None,
quantity=1,
partner=record.partner_id
or None)
record.igst_amount = taxes_data['igst_amount']
record.cgst_amount = taxes_data['cgst_amount']
record.sgst_amount = taxes_data['sgst_amount']
record.cess_amount = taxes_data['cess_amount']
record.gross_amount = taxes_data['total_excluded']
def _select(self):
select_str = super(AdvancesPaymentReport, self)._select()
select_str += """,
ap.payment_date as date,
(SELECT sum(amount) FROM account_partial_reconcile AS apr
WHERE (apr.credit_move_id = aml.id OR apr.debit_move_id = aml.id)
AND (to_char(apr.max_date, 'MM-YYYY') = to_char(aml.date_maturity, 'MM-YYYY'))
) AS reconcile_amount,
(am.amount_total - (SELECT (CASE WHEN SUM(amount) IS NULL THEN 0 ELSE SUM(amount) END) FROM account_partial_reconcile AS apr
WHERE (apr.credit_move_id = aml.id OR apr.debit_move_id = aml.id)
AND (to_char(apr.max_date, 'MM-YYYY') = to_char(aml.date_maturity, 'MM-YYYY'))
)) AS amount"""
return select_str
class L10nItDdt(models.Model):
_name = 'l10n_it.ddt'
_description = 'Transport Document'
invoice_id = fields.One2many('account.move',
'l10n_it_ddt_id',
string='Invoice Reference',
ondelete='cascade')
name = fields.Char(string="Numero DDT",
size=20,
help="Transport document number",
required=True)
date = fields.Date(string="Data DDT",
help="Transport document date",
required=True)
def name_get(self):
res = []
for ddt in self:
res.append((ddt.id, ("%s (%s)") % (ddt.name, ddt.date)))
return res
class User(models.Model):
_inherit = ['res.users']
medic_exam = fields.Date(related="employee_id.medic_exam")
vehicle = fields.Char(related="employee_id.vehicle")
bank_account_id = fields.Many2one(related="employee_id.bank_account_id")
def __init__(self, pool, cr):
""" Override of __init__ to add access rights.
Access rights are disabled by default, but allowed
on some specific fields defined in self.SELF_{READ/WRITE}ABLE_FIELDS.
"""
contract_readable_fields = [
'medic_exam',
'vehicle',
'bank_account_id',
]
init_res = super(User, self).__init__(pool, cr)
# duplicate list to avoid modifying the original reference
type(self).SELF_READABLE_FIELDS = type(
self).SELF_READABLE_FIELDS + contract_readable_fields
return init_res
class ResPartner(models.Model):
_inherit = "res.partner"
date_localization = fields.Date(string='Geolocation Date')
@api.model
def _geo_localize(self, street='', zip='', city='', state='', country=''):
geo_obj = self.env['base.geocoder']
search = geo_obj.geo_query_address(street=street,
zip=zip,
city=city,
state=state,
country=country)
result = geo_obj.geo_find(search, force_country=country)
if result is None:
search = geo_obj.geo_query_address(city=city,
state=state,
country=country)
result = geo_obj.geo_find(search, force_country=country)
return result
def geo_localize(self):
# We need country names in English below
for partner in self.with_context(lang='en_US'):
result = self._geo_localize(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 LunchCashMove(models.Model):
""" Two types of cashmoves: payment (credit) or order (debit) """
_name = 'lunch.cashmove'
_description = 'Lunch Cashmove'
_order = 'date desc'
currency_id = fields.Many2one('res.currency', default=lambda self: self.env.company.currency_id)
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)
description = fields.Text('Description')
def name_get(self):
return [(cashmove.id, '%s %s' % (_('Lunch Cashmove'), '#%d' % cashmove.id)) for cashmove in self]
@api.model
def get_wallet_balance(self, user, include_config=True):
result = float_round(sum(move['amount'] for move in self.env['lunch.cashmove.report'].search_read(
[('user_id', '=', user.id)], ['amount'])), precision_digits=2)
if include_config:
result += user.company_id.lunch_minimum_threshold
return result
