class AccountInvoiceLine(models.Model):
""" Override AccountInvoice_line to add the link to the purchase order line it is related to"""
_inherit = 'account.invoice.line'
purchase_line_id = fields.Many2one('purchase.order.line', 'Purchase Order Line', ondelete='set null', select=True, readonly=True)
purchase_id = fields.Many2one('purchase.order', related='purchase_line_id.order_id', string='Purchase Order', store=False, readonly=True,
help='Associated Purchase Order. Filled in automatically when a PO is chosen on the vendor bill.')
class Tags(models.Model):
_name = "forum.tag"
_description = "Forum Tag"
_inherit = ['website.seo.metadata']
name = fields.Char('Name', required=True)
create_uid = fields.Many2one('res.users',
string='Created by',
readonly=True)
forum_id = fields.Many2one('forum.forum', string='Forum', required=True)
post_ids = fields.Many2many('forum.post',
'forum_tag_rel',
'forum_tag_id',
'forum_id',
string='Posts')
posts_count = fields.Integer('Number of Posts',
compute='_get_posts_count',
store=True)
_sql_constraints = [
('name_uniq', 'unique (name, forum_id)', "Tag name already exists !"),
]
@api.multi
@api.depends("post_ids.tag_ids")
def _get_posts_count(self):
for tag in self:
tag.posts_count = len(tag.post_ids)
class ReportEventRegistrationQuestions(models.Model):
_name = "event.question.report"
_auto = False
attendee_id = fields.Many2one(comodel_name='event.registration', string='Registration')
question_id = fields.Many2one(comodel_name='event.question', string='Question')
answer_id = fields.Many2one(comodel_name='event.answer', string='Answer')
event_id = fields.Many2one(comodel_name='event.event', string='Event')
def init(self, cr):
""" Event Question main report """
tools.drop_view_if_exists(cr, 'event_question_report')
cr.execute(""" CREATE VIEW event_question_report AS (
SELECT
att_answer.id as id,
att_answer.event_registration_id as attendee_id,
answer.question_id as question_id,
answer.id as answer_id,
question.event_id as event_id
FROM
event_registration_answer as att_answer
LEFT JOIN
event_answer as answer ON answer.id = att_answer.event_answer_id
LEFT JOIN
event_question as question ON question.id = answer.question_id
GROUP BY
attendee_id,
event_id,
question_id,
answer_id,
att_answer.id
)""")
class RegistrationEditorLine(models.TransientModel):
"""Event Registration"""
_name = "registration.editor.line"
editor_id = fields.Many2one('registration.editor')
sale_order_line_id = fields.Many2one('sale.order.line',
string='Sale Order Line')
event_id = fields.Many2one('event.event', string='Event', required=True)
registration_id = fields.Many2one('event.registration',
'Original Registration')
event_ticket_id = fields.Many2one('event.event.ticket',
string='Event Ticket')
email = fields.Char(string='Email')
phone = fields.Char(string='Phone')
name = fields.Char(string='Name', select=True)
@api.one
def get_registration_data(self):
return {
'event_id': self.event_id.id,
'event_ticket_id': self.event_ticket_id.id,
'partner_id': self.editor_id.sale_order_id.partner_id.id,
'name': self.name or self.editor_id.sale_order_id.partner_id.name,
'phone': self.phone
or self.editor_id.sale_order_id.partner_id.phone,
'email': self.email
or self.editor_id.sale_order_id.partner_id.email,
'origin': self.editor_id.sale_order_id.name,
'sale_order_id': self.editor_id.sale_order_id.id,
'sale_order_line_id': self.sale_order_line_id.id,
}
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',
required=True,
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 DocumentPageHistory(models.Model):
"""This model is necessary to manage a document history."""
_name = "document.page.history"
_description = "Document Page History"
_order = 'id DESC'
_rec_name = "create_date"
page_id = fields.Many2one('document.page', 'Page')
summary = fields.Char('Summary', select=True)
content = fields.Text("Content")
create_date = fields.Datetime("Date")
create_uid = fields.Many2one('res.users', "Modified By")
def getDiff(self, v1, v2):
"""Return the difference between two version of document version."""
text1 = self.browse(v1).content
text2 = self.browse(v2).content
line1 = line2 = ''
if text1:
line1 = text1.splitlines(1)
if text2:
line2 = text2.splitlines(1)
if (not line1 and not line2) or (line1 == line2):
return _('There are no changes in revisions.')
else:
diff = difflib.HtmlDiff()
return diff.make_table(
line1, line2,
"Revision-{}".format(v1),
"Revision-{}".format(v2),
context=True
)
class EventMailRegistration(models.Model):
_name = 'event.mail.registration'
_description = 'Registration Mail Scheduler'
_rec_name = 'scheduler_id'
_order = 'scheduled_date DESC'
scheduler_id = fields.Many2one('event.mail', 'Mail Scheduler', required=True, ondelete='cascade')
registration_id = fields.Many2one('event.registration', 'Attendee', required=True, ondelete='cascade')
scheduled_date = fields.Datetime('Scheduled Time', compute='_compute_scheduled_date', store=True)
mail_sent = fields.Boolean('Mail Sent')
@api.one
def execute(self):
if self.registration_id.state in ['open', 'done'] and not self.mail_sent:
self.scheduler_id.template_id.send_mail(self.registration_id.id)
self.write({'mail_sent': True})
@api.one
@api.depends('registration_id', 'scheduler_id.interval_unit', 'scheduler_id.interval_type')
def _compute_scheduled_date(self):
if self.registration_id:
date_open = self.registration_id.date_open
date_open_datetime = date_open and datetime.strptime(date_open, tools.DEFAULT_SERVER_DATETIME_FORMAT) or fields.datetime.now()
self.scheduled_date = date_open_datetime + _INTERVALS[self.scheduler_id.interval_unit](self.scheduler_id.interval_nbr)
else:
self.scheduled_date = False
class link_tracker(models.Model):
_inherit = "link.tracker"
mass_mailing_id = fields.Many2one('mail.mass_mailing',
string='Mass Mailing')
mass_mailing_campaign_id = fields.Many2one('mail.mass_mailing.campaign',
string='Mass Mailing Campaign')
class link_tracker_click(models.Model):
_inherit = "link.tracker.click"
mail_stat_id = fields.Many2one('mail.mail.statistics',
string='Mail Statistics')
mass_mailing_id = fields.Many2one('mail.mass_mailing',
string='Mass Mailing')
mass_mailing_campaign_id = fields.Many2one('mail.mass_mailing.campaign',
string='Mass Mailing Campaign')
class ProductTemplate(models.Model):
_inherit = 'product.template'
asset_category_id = fields.Many2one('account.asset.category',
string='Asset Type',
ondelete="restrict")
deferred_revenue_category_id = fields.Many2one(
'account.asset.category',
string='Deferred Revenue Type',
ondelete="restrict")
class HtmlFormHistoryField(models.Model):
_name = "html.form.history.field"
_description = "HTML Form History Field"
html_id = fields.Many2one('html.form.history',
ondelete='cascade',
string="HTML History Form")
field_id = fields.Many2one('ir.model.fields', string="Field")
insert_value = fields.Char(string="Insert Value")
class res_company(models.Model):
_inherit = "res.company"
region_id = fields.Many2one('l10n_be_intrastat.region', 'Intrastat region')
transport_mode_id = fields.Many2one('l10n_be_intrastat.transport_mode',
'Default transport mode')
incoterm_id = fields.Many2one('stock.incoterms', 'Default incoterm for Intrastat',
help="International Commercial Terms are a series of "
"predefined commercial terms used in international "
"transactions.")
class account_invoice(models.Model):
_inherit = "account.invoice"
incoterm_id = fields.Many2one('stock.incoterms', 'Incoterm',
help="International Commercial Terms are a series of predefined commercial terms "
"used in international transactions.")
transport_mode_id = fields.Many2one('l10n_be_intrastat.transport_mode', 'Intrastat Transport Mode')
intrastat_country_id = fields.Many2one('res.country', 'Intrastat Country',
help='Intrastat country, delivery for sales, origin for purchases',
domain=[('intrastat', '=', True)])
class ImLivechatReportOperator(models.Model):
""" Livechat Support Report on the Operator """
_name = "im_livechat.report.operator"
_description = "Livechat Support Report"
_order = 'livechat_channel_id, partner_id'
_auto = False
partner_id = fields.Many2one('res.partner', 'Operator', readonly=True)
livechat_channel_id = fields.Many2one('im_livechat.channel',
'Channel',
readonly=True)
nbr_channel = fields.Integer('# of channel',
readonly=True,
group_operator="sum",
help="Number of conversation")
channel_id = fields.Many2one('mail.channel', 'Conversation', readonly=True)
start_date = fields.Datetime('Start Date of session',
readonly=True,
help="Start date of the conversation")
time_to_answer = fields.Float(
'Time to answer',
digits=(16, 2),
readonly=True,
group_operator="avg",
help="Average time to give the first answer to the visitor")
duration = fields.Float('Average duration',
digits=(16, 2),
readonly=True,
group_operator="avg",
help="Duration of the conversation (in seconds)")
def init(self, cr):
# Note : start_date_hour must be remove when the read_group will allow grouping on the hour of a datetime. Don't forget to change the view !
tools.drop_view_if_exists(cr, 'im_livechat_report_operator')
cr.execute("""
CREATE OR REPLACE VIEW im_livechat_report_operator AS (
SELECT
row_number() OVER () AS id,
P.id as partner_id,
L.id as livechat_channel_id,
count(C.id) as nbr_channel,
C.id as channel_id,
C.create_date as start_date,
EXTRACT('epoch' FROM (max((SELECT (max(M.create_date)) FROM mail_message M JOIN mail_message_mail_channel_rel R ON (R.mail_message_id = M.id) WHERE R.mail_channel_id = C.id))-C.create_date)) as duration,
EXTRACT('epoch' from ((SELECT min(M.create_date) FROM mail_message M, mail_message_mail_channel_rel R WHERE M.author_id=P.id AND R.mail_channel_id = C.id AND R.mail_message_id = M.id)-(SELECT min(M.create_date) FROM mail_message M, mail_message_mail_channel_rel R WHERE M.author_id IS NULL AND R.mail_channel_id = C.id AND R.mail_message_id = M.id))) as time_to_answer
FROM im_livechat_channel_im_user O
JOIN res_users U ON (O.user_id = U.id)
JOIN res_partner P ON (U.partner_id = P.id)
LEFT JOIN im_livechat_channel L ON (L.id = O.channel_id)
LEFT JOIN mail_channel C ON (C.livechat_channel_id = L.id)
GROUP BY P.id, L.id, C.id, C.create_date
)
""")
class HtmlFormAction(models.Model):
_name = "html.form.action"
_description = "HTML Form Action"
hf_id = fields.Many2one('html.form', string="HTML Form")
action_type_id = fields.Many2one('html.form.action.type',
string="Submit Action")
setting_name = fields.Char(string="Internal Name",
related="action_type_id.internal_name")
settings_description = fields.Char(string="Settings Description")
class DateRangeGenerator(models.TransientModel):
_name = 'date.range.generator'
@api.model
def _default_company(self):
return self.env['res.company']._company_default_get('date.range')
name_prefix = fields.Char('Range name prefix', required=True)
date_start = fields.Date(strint='Start date', required=True)
type_id = fields.Many2one(comodel_name='date.range.type',
string='Type',
required=True,
ondelete='cascade')
company_id = fields.Many2one(comodel_name='res.company',
string='Company',
default=_default_company)
unit_of_time = fields.Selection([(YEARLY, 'years'), (MONTHLY, 'months'),
(WEEKLY, 'weeks'), (DAILY, 'days')],
required=True)
duration_count = fields.Integer('Duration', required=True)
count = fields.Integer(string="Number of ranges to generate",
required=True)
@api.multi
def _compute_date_ranges(self):
self.ensure_one()
vals = rrule(freq=self.unit_of_time,
interval=self.duration_count,
dtstart=fields.Date.from_string(self.date_start),
count=self.count + 1)
vals = list(vals)
date_ranges = []
for idx, dt_start in enumerate(vals[:-1]):
date_start = fields.Date.to_string(dt_start.date())
dt_end = vals[idx + 1].date() - relativedelta(days=1)
date_end = fields.Date.to_string(dt_end)
date_ranges.append({
'name': '%s-%d' % (self.name_prefix, idx + 1),
'date_start': date_start,
'date_end': date_end,
'type_id': self.type_id.id,
'company_id': self.company_id.id
})
return date_ranges
@api.multi
def action_apply(self):
date_ranges = self._compute_date_ranges()
if date_ranges:
for dr in date_ranges:
self.env['date.range'].create(dr)
return self.env['ir.actions.act_window'].for_xml_id(
module='date_range', xml_id='date_range_action')
class ChannelPartner(models.Model):
_name = 'mail.channel.partner'
_description = 'Last Seen Many2many'
_table = 'mail_channel_partner'
_rec_name = 'partner_id'
partner_id = fields.Many2one('res.partner', string='Recipient', ondelete='cascade')
channel_id = fields.Many2one('mail.channel', string='Channel', ondelete='cascade')
seen_message_id = fields.Many2one('mail.message', string='Last Seen')
fold_state = fields.Selection([('open', 'Open'), ('folded', 'Folded'), ('closed', 'Closed')], string='Conversation Fold State', default='open')
is_minimized = fields.Boolean("Conversation is minimied")
is_pinned = fields.Boolean("Is pinned on the interface", default=True)
class LunchProduct(models.Model):
""" Products available to order. A product is linked to a specific vendor. """
_name = 'lunch.product'
_description = 'lunch product'
name = fields.Char('Product', required=True)
category_id = fields.Many2one('lunch.product.category',
'Category',
required=True)
description = fields.Text('Description')
price = fields.Float('Price', digits=dp.get_precision('Account'))
supplier = fields.Many2one('res.partner', 'Vendor')
class HrEquipmentCategory(models.Model):
_name = 'hr.equipment.category'
_inherits = {"mail.alias": "alias_id"}
_inherit = ['mail.thread']
_description = 'Asset Category'
@api.one
@api.depends('equipment_ids')
def _compute_fold(self):
self.fold = False if self.equipment_count else True
name = fields.Char('Category Name', required=True, translate=True)
user_id = fields.Many2one('res.users', 'Responsible', track_visibility='onchange', default=lambda self: self.env.uid)
color = fields.Integer('Color Index')
note = fields.Text('Comments', translate=True)
equipment_ids = fields.One2many('hr.equipment', 'category_id', string='Equipments', copy=False)
equipment_count = fields.Integer(string="Equipment", compute='_compute_equipment_count')
maintenance_ids = fields.One2many('hr.equipment.request', 'category_id', copy=False)
maintenance_count = fields.Integer(string="Maintenance", compute='_compute_maintenance_count')
alias_id = fields.Many2one(
'mail.alias', 'Alias', ondelete='cascade', required=True,
help="Email alias for this equipment category. New emails will automatically "
"create new maintenance request for this equipment category.")
fold = fields.Boolean(string='Folded in Maintenance Pipe', compute='_compute_fold', store=True)
@api.multi
def _compute_equipment_count(self):
equipment_data = self.env['hr.equipment'].read_group([('category_id', 'in', self.ids)], ['category_id'], ['category_id'])
mapped_data = dict([(m['category_id'][0], m['category_id_count']) for m in equipment_data])
for category in self:
category.equipment_count = mapped_data.get(category.id, 0)
@api.multi
def _compute_maintenance_count(self):
maintenance_data = self.env['hr.equipment.request'].read_group([('category_id', 'in', self.ids)], ['category_id'], ['category_id'])
mapped_data = dict([(m['category_id'][0], m['category_id_count']) for m in maintenance_data])
for category in self:
category.maintenance_count = mapped_data.get(category.id, 0)
@api.model
def create(self, vals):
self = self.with_context(alias_model_name='hr.equipment.request', alias_parent_model_name=self._name)
category_id = super(HrEquipmentCategory, self).create(vals)
category_id.alias_id.write({'alias_parent_thread_id': category_id.id, 'alias_defaults': {'category_id': category_id.id}})
return category_id
@api.multi
def unlink(self):
for category in self:
if category.equipment_ids or category.maintenance_ids:
raise UserError(_("You cannot delete an equipment category containing equipments or maintenance requests."))
res = super(HrEquipmentCategory, self).unlink()
return res
class SaasPortalCreateClient(models.TransientModel):
_name = 'saas_portal.create_client'
def _default_plan_id(self):
return self._context.get('active_id')
def _default_name(self):
plan_id = self._default_plan_id()
if plan_id:
plan = self.env['saas_portal.plan'].browse(plan_id)
return plan.generate_dbname(raise_error=False)[0]
return ''
name = fields.Char('Database name', required=True, default=_default_name)
plan_id = fields.Many2one('saas_portal.plan',
string='Plan',
readonly=True,
default=_default_plan_id)
partner_id = fields.Many2one('res.partner', string='Partner')
user_id = fields.Many2one('res.users', string='User')
notify_user = fields.Boolean(
help='Notify user by email when database will have been created',
default=False)
support_team_id = fields.Many2one(
'saas_portal.support_team',
'Support Team',
default=lambda self: self.env.user.support_team_id)
@api.onchange('user_id')
def update_parter(self):
if self.user_id:
self.partner_id = self.user_id.partner_id
@api.multi
def apply(self):
wizard = self[0]
res = wizard.plan_id.create_new_database(
dbname=wizard.name,
partner_id=wizard.partner_id.id,
user_id=self.user_id.id,
notify_user=self.notify_user,
support_team_id=self.support_team_id.id)
client = self.env['saas_portal.client'].browse(res.get('id'))
client.server_id.action_sync_server()
return {
'type': 'ir.actions.act_window',
'view_type': 'form',
'view_mode': 'form',
'res_model': 'saas_portal.client',
'res_id': client.id,
'target': 'current',
}
class Delegating(models.Model):
_name = 'delegation.parent'
_inherits = {
'delegation.child0': 'child0_id',
'delegation.child1': 'child1_id',
}
child0_id = fields.Many2one('delegation.child0',
required=True,
ondelete='cascade')
child1_id = fields.Many2one('delegation.child1',
required=True,
ondelete='cascade')
class CrmLeadLost(models.TransientModel):
_name = 'crm.lead.lost'
_description = 'Get Lost Reason'
lead_id = fields.Many2one('crm.lead', 'Lead', required=True)
lost_reason_id = fields.Many2one('crm.lost.reason', 'Lost Reason')
@api.multi
def action_lost_reason_apply(self):
res = False
for wizard in self:
self.lead_id.lost_reason = self.lost_reason_id
res = self.lead_id.action_set_lost()
return res
class HtmlFormDefaults(models.Model):
_name = "html.form.defaults"
_description = "HTML Form Defaults"
html_id = fields.Many2one('html.form',
ondelete='cascade',
string="HTML Form")
model_id = fields.Many2one('ir.model', string="Model", readonly=True)
model = fields.Char(related="model_id.model",
string="Model Name",
readonly=True)
field_id = fields.Many2one('ir.model.fields', string="Form Fields")
default_value = fields.Char(string="Default Value")
class ResUsers(models.Model):
_inherit = 'res.users'
@api.model
def _default_map_website(self):
return self.env['map.website'].search(
['|', ('address_url', '!=', False), ('lat_lon_url', '!=', False)],
limit=1)
@api.model
def _default_route_map_website(self):
return self.env['map.website'].search([
'|', ('route_address_url', '!=', False),
('route_lat_lon_url', '!=', False)
],
limit=1)
# begin with context_ to allow user to change it by himself
context_map_website_id = fields.Many2one('map.website',
string='Map Website',
default=_default_map_website,
domain=[
'|',
('address_url', '!=', False),
('lat_lon_url', '!=', False)
])
# We want to give the possibility to the user to have one map provider for
# regular maps and another one for routing
context_route_map_website_id = fields.Many2one(
'map.website',
string='Route Map Website',
domain=[
'|', ('route_address_url', '!=', False),
('route_lat_lon_url', '!=', False)
],
default=_default_route_map_website,
help="Map provided used when you click on the car icon on the partner "
"form to display an itinerary.")
context_route_start_partner_id = fields.Many2one(
'res.partner', string='Start Address for Route Map')
@api.model
def create(self, vals):
"""On creation, if no starting partner is provided, assign the current
created one.
"""
user = super(ResUsers, self).create(vals)
if not vals.get('context_route_start_partner_id'):
user.context_route_start_partner_id = user.partner_id.id
return user
class website_config_settings(models.TransientModel):
_inherit = 'website.config.settings'
salesperson_id = fields.Many2one('res.users',
related='website_id.salesperson_id',
string='Salesperson')
salesteam_id = fields.Many2one('crm.team',
related='website_id.salesteam_id',
string='Sales Team')
module_delivery_dhl = fields.Boolean("DHL integration")
module_delivery_fedex = fields.Boolean("Fedex integration")
module_delivery_ups = fields.Boolean("UPS integration")
module_delivery_usps = fields.Boolean("USPS integration")
module_sale_ebay = fields.Boolean("eBay connector")
class CrmActivity(models.Model):
''' CrmActivity is a model introduced in eCore v9 that models activities
performed in CRM, like phonecalls, sending emails, making demonstrations,
... Users are able to configure their custom activities.
Each activity has up to three next activities. This allows to model light
custom workflows. This way sales manager can configure their crm workflow
that salepersons will use in their daily job.
CrmActivity inherits from mail.message.subtype. This allows users to follow
some activities through subtypes. Each activity will generate messages with
the matching subtypes, allowing reporting and statistics computation based
on mail.message.subtype model. '''
_name = 'crm.activity'
_description = 'CRM Activity'
_inherits = {'mail.message.subtype': 'subtype_id'}
_rec_name = 'name'
_order = "sequence"
days = fields.Integer(
'Number of days',
default=0,
help=
'Number of days before executing the action, allowing you to plan the date of the action.'
)
sequence = fields.Integer('Sequence', default=0)
team_id = fields.Many2one('crm.team', string='Sales Team')
subtype_id = fields.Many2one('mail.message.subtype',
string='Message Subtype',
required=True,
ondelete='cascade')
activity_1_id = fields.Many2one('crm.activity', string="Next Activity 1")
activity_2_id = fields.Many2one('crm.activity', string="Next Activity 2")
activity_3_id = fields.Many2one('crm.activity', string="Next Activity 3")
@api.model
def create(self, values):
''' Override to set the res_model of inherited subtype to crm.lead.
This cannot be achieved using a default on res_model field because
of the inherits. Indeed a new field would be created. However the
field on the subtype would still exist. Being void, the subtype
will be present for every model in eCore. That's quite an issue. '''
if not values.get(
'res_model') and 'default_res_model' not in self._context:
values['res_model'] = 'crm.lead'
if 'internal' not in values and 'default_internal' not in self._context:
values['internal'] = True
return super(CrmActivity, self).create(values)
class EventRegistrationAnswer(models.Model):
''' This m2m table has to be explicitly instanciated as we need unique ids
in the reporting view event.question.report.
This model is purely technical. '''
_name = 'event.registration.answer'
_table = 'event_registration_answer'
event_answer_id = fields.Many2one('event.answer',
required=True,
ondelete='cascade')
event_registration_id = fields.Many2one('event.registration',
required=True,
ondelete='cascade')
class AccountFiscalPositionTax(models.Model):
_name = 'account.fiscal.position.tax'
_description = 'Taxes Fiscal Position'
_rec_name = 'position_id'
position_id = fields.Many2one('account.fiscal.position', string='Fiscal Position',
required=True, ondelete='cascade')
tax_src_id = fields.Many2one('account.tax', string='Tax on Product', required=True)
tax_dest_id = fields.Many2one('account.tax', string='Tax to Apply')
_sql_constraints = [
('tax_src_dest_uniq',
'unique (position_id,tax_src_id,tax_dest_id)',
'A tax fiscal position could be defined only once time on same taxes.')
]
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:
country_record = self.env['res.country'].search(
[('code', '=', country_code)], limit=1)
vals = {
'link_id': code_rec.link_id.id,
'create_date': datetime.date.today(),
'ip': ip,
'country_id': country_record.id,
'mail_stat_id': stat_id
}
if stat_id:
mail_stat = self.env['mail.mail.statistics'].search([
('id', '=', stat_id)
])
if mail_stat.mass_mailing_campaign_id:
vals[
'mass_mailing_campaign_id'] = mail_stat.mass_mailing_campaign_id.id
if mail_stat.mass_mailing_id:
vals['mass_mailing_id'] = mail_stat.mass_mailing_id.id
self.create(vals)
class RecruitmentStage(models.Model):
_name = "hr.recruitment.stage"
_description = "Stage of Recruitment"
_order = 'sequence'
name = fields.Char("Stage name", required=True, translate=True)
sequence = fields.Integer(
"Sequence",
default=1,
help="Gives the sequence order when displaying a list of stages.")
job_ids = fields.Many2many(
'hr.job',
'job_stage_rel',
'stage_id',
'job_id',
string='Job Stages',
default=lambda self: [(4, self._context['default_job_id'])]
if self._context.get('default_job_id') else None)
requirements = fields.Text("Requirements")
template_id = fields.Many2one(
'mail.template',
"Use template",
help=
"If set, a message is posted on the applicant using the template when the applicant is set to the stage."
)
fold = fields.Boolean(
"Folded in Recruitment Pipe",
help=
"This stage is folded in the kanban view when there are no records in that stage to display."
)
