class cloudserver_server(models.Model):
'''
实体：
'''
_name = 'oa.cloudserver.server'
provider = fields.Selection([('ali', '阿里'), ('tencent', '腾讯')],
string='提供商')
uses = fields.Selection([('app', '应用'), ('db', '数据库'),
('app+db', '应用＋数据库'), ('mail', '邮箱')],
string='用途')
server_id = fields.Char(string='服务器ID')
server_name = fields.Char(string='服务器名称')
local = fields.Char(string='地域')
area = fields.Char(string='所在可用区')
use_desp = fields.Char('用途简述')
description = fields.Text('描述')
cpu = fields.Char(string='CPU')
memory = fields.Char(string='内存(G)')
disk = fields.Char(string='硬盘(G)')
os = fields.Selection([('windows', 'Windows Server'),
('ubuntu', 'Ubuntu')],
string='操作系统')
ip_internet = fields.Char(string='公网IP')
ip_intranet = fields.Char(string='内网IP')
# bill_method = fields.Char(string='带宽计费方式')
bandwidth = fields.Char(string='带宽(M)')
# pay_method = fields.Selection([('pack_year_month', '包年包月'), ('flow_rate', '按流量')],string='付费方式')
createon = fields.Datetime(string='创建时间')
endon = fields.Datetime(string='到期时间')
domain_name = fields.Char(string='域名')
account4app = fields.Char(string='申请账号')
login_name = fields.Char(string='用户名')
login_pwd = fields.Char(string='密码')
data_disk = fields.Char(string='数据盘(G)')
_sql_constraints = [('server_id_uniq', 'unique(server_id)', '服务器ID必须唯一!')]
class OpAssignment(models.Model):
_name = 'op.assignment'
_inherit = 'mail.thread'
_description = 'Assignment'
name = fields.Char('Name', size=16, required=True)
course_id = fields.Many2one('op.course', 'Course', required=True)
batch_id = fields.Many2one('op.batch', 'Batch', required=True)
subject_id = fields.Many2one('op.subject', 'Subject', required=True)
faculty_id = fields.Many2one(
'op.faculty', 'Faculty', default=lambda self: self.env[
'op.faculty'].search([('user_id', '=', self.env.uid)]),
required=True)
assignment_type_id = fields.Many2one(
'op.assignment.type', 'Assignment Type', required=True)
marks = fields.Float('Marks', track_visibility='onchange')
description = fields.Text('Description', required=True)
state = fields.Selection(
[('draft', 'Draft'), ('publish', 'Published'),
('finish', 'Finished')], 'State', required=True, default='draft',
track_visibility='onchange')
issued_date = fields.Datetime(
'Issued Date', required=True,
default=lambda self: fields.Datetime.now())
submission_date = fields.Datetime(
'Submission Date', required=True,
track_visibility='onchange')
allocation_ids = fields.Many2many('op.student', string='Allocated To')
assignment_sub_line = fields.One2many(
'op.assignment.sub.line', 'assignment_id', 'Submissions')
reviewer = fields.Many2one('op.faculty', 'Reviewer')
@api.one
@api.constrains('issued_date', 'submission_date')
def check_dates(self):
issued_date = fields.Date.from_string(self.issued_date)
submission_date = fields.Date.from_string(self.submission_date)
if issued_date > submission_date:
raise ValidationError(
"Submission Date cannot be set before Issue Date.")
@api.onchange('course_id')
def onchange_course(self):
self.batch_id = False
@api.one
def act_publish(self):
self.state = 'publish'
@api.one
def act_finish(self):
self.state = 'finish'
class SaasPortalClient(models.Model):
_inherit = 'saas_portal.client'
subscription_start = fields.Datetime(string="Subscription start", track_visibility='onchange')
expiration_datetime = fields.Datetime(string="Expiration", compute='_handle_paid_invoices',
store=True,
help='Subscription start plus all paid days from related invoices')
invoice_lines = fields.One2many('account.invoice.line', 'saas_portal_client_id')
trial = fields.Boolean('Trial', help='indication of trial clients', default=False, store=True, readonly=True, compute='_handle_paid_invoices')
@api.multi
@api.depends('invoice_lines.invoice_id.state')
def _handle_paid_invoices(self):
for client_obj in self:
client_obj.expiration_datetime = datetime.strptime(client_obj.create_date, DEFAULT_SERVER_DATETIME_FORMAT) + timedelta(hours=client_obj.plan_id.expiration) # for trial
days = 0
for line in self.env['account.invoice.line'].search([('saas_portal_client_id', '=', client_obj.id), ('invoice_id.state', '=', 'paid')]):
days += line.period * line.quantity
if days != 0:
client_obj.expiration_datetime = datetime.strptime(client_obj.subscription_start or client_obj.create_date, DEFAULT_SERVER_DATETIME_FORMAT) + timedelta(days=days)
client_obj.trial = not bool(days)
@api.multi
def get_upgrade_database_payload(self):
res = super(SaasPortalClient, self).get_upgrade_database_payload()
res['params'].append({'key': 'saas_client.trial', 'value': 'False', 'hidden': True})
if self.invoice_lines:
params = []
recent_invoice_line = self.invoice_lines.sorted(reverse=True, key=lambda r: r.create_date)[0]
product_obj = recent_invoice_line.product_id
attribute_value_obj = product_obj.attribute_value_ids.filtered(lambda r: r.attribute_id.saas_code == 'MAX_USERS')
if attribute_value_obj and attribute_value_obj[0].saas_code_value:
params.append({'key': 'saas_client.max_users', 'value': attribute_value_obj[0].saas_code_value, 'hidden': True})
attribute_value_obj = product_obj.attribute_value_ids.filtered(lambda r: r.attribute_id.saas_code == 'INSTALL_MODULES')
addons = attribute_value_obj and attribute_value_obj[0].saas_code_value or ''
if addons:
res.update({'install_addons': addons.split(',') if addons else []})
attribute_value_obj = product_obj.attribute_value_ids.filtered(lambda r: r.attribute_id.saas_code == 'STORAGE_LIMIT')
if attribute_value_obj and attribute_value_obj[0].saas_code_value:
params.append({'key': 'saas_client.total_storage_limit', 'value': attribute_value_obj[0].saas_code_value, 'hidden': True})
res['params'].extend(params)
return res
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 cloudserver_domain(models.Model):
'''
实体：域名管理
'''
_name = 'oa.cloudserver.domain'
provider = fields.Selection([('ali', '阿里'), ('tencent', '腾讯')],
string='提供商')
name = fields.Char(string='域名')
owner = fields.Char(string='域名所有者')
endtime = fields.Datetime(string='到期时间')
state = fields.Selection([('normal', '正常'), ('disabled', '已停用')],
string='域名状态')
dns = fields.Char('DNS服务器')
contact_person = fields.Char('联系人')
country = fields.Many2one('res.country', string='国家')
province = fields.Many2one('res.country.state', string='省份')
city = fields.Char(string='城市')
address = fields.Char(string='通讯地址')
zip = fields.Char(string='邮编')
mail = fields.Char(string='联系人邮箱')
phone1 = fields.Char(string='联系电话1')
phone2 = fields.Char(string='联系电话2')
fax = fields.Char(string='传真')
description = fields.Text(string="描述")
account4domain = fields.Char(string='申请账号')
record_provider = fields.Selection([('ali', '阿里'), ('tencent', '腾讯')],
string='备案系统')
record_sys_account = fields.Char(string='备案系统账号')
record_sys_pwd = fields.Char(string='备案系统密码')
record_no = fields.Char(string='备案号')
record_pwd = fields.Char(string='备案密码')
record_description = fields.Text(string='备案描述')
_sql_constraints = [('name_uniq', 'unique(name)', '域名必须唯一!')]
class Vote(models.Model):
_name = 'forum.post.vote'
_description = 'Vote'
post_id = fields.Many2one('forum.post', string='Post', ondelete='cascade', required=True)
user_id = fields.Many2one('res.users', string='User', required=True, default=lambda self: self._uid)
vote = fields.Selection([('1', '1'), ('-1', '-1'), ('0', '0')], string='Vote', required=True, default='1')
create_date = fields.Datetime('Create Date', select=True, readonly=True)
forum_id = fields.Many2one('forum.forum', string='Forum', related="post_id.forum_id", store=True)
recipient_id = fields.Many2one('res.users', string='To', related="post_id.create_uid", store=True)
def _get_karma_value(self, old_vote, new_vote, up_karma, down_karma):
_karma_upd = {
'-1': {'-1': 0, '0': -1 * down_karma, '1': -1 * down_karma + up_karma},
'0': {'-1': 1 * down_karma, '0': 0, '1': up_karma},
'1': {'-1': -1 * up_karma + down_karma, '0': -1 * up_karma, '1': 0}
}
return _karma_upd[old_vote][new_vote]
@api.model
def create(self, vals):
vote = super(Vote, self).create(vals)
# own post check
if vote.user_id.id == vote.post_id.create_uid.id:
raise UserError(_('Not allowed to vote for its own post'))
# karma check
if vote.vote == '1' and not vote.post_id.can_upvote:
raise KarmaError('Not enough karma to upvote.')
elif vote.vote == '-1' and not vote.post_id.can_downvote:
raise KarmaError('Not enough karma to downvote.')
if vote.post_id.parent_id:
karma_value = self._get_karma_value('0', vote.vote, vote.forum_id.karma_gen_answer_upvote, vote.forum_id.karma_gen_answer_downvote)
else:
karma_value = self._get_karma_value('0', vote.vote, vote.forum_id.karma_gen_question_upvote, vote.forum_id.karma_gen_question_downvote)
vote.recipient_id.sudo().add_karma(karma_value)
return vote
@api.multi
def write(self, values):
if 'vote' in values:
for vote in self:
# own post check
if vote.user_id.id == vote.post_id.create_uid.id:
raise UserError(_('Not allowed to vote for its own post'))
# karma check
if (values['vote'] == '1' or vote.vote == '-1' and values['vote'] == '0') and not vote.post_id.can_upvote:
raise KarmaError('Not enough karma to upvote.')
elif (values['vote'] == '-1' or vote.vote == '1' and values['vote'] == '0') and not vote.post_id.can_downvote:
raise KarmaError('Not enough karma to downvote.')
# karma update
if vote.post_id.parent_id:
karma_value = self._get_karma_value(vote.vote, values['vote'], vote.forum_id.karma_gen_answer_upvote, vote.forum_id.karma_gen_answer_downvote)
else:
karma_value = self._get_karma_value(vote.vote, values['vote'], vote.forum_id.karma_gen_question_upvote, vote.forum_id.karma_gen_question_downvote)
vote.recipient_id.sudo().add_karma(karma_value)
res = super(Vote, self).write(values)
return res
class wx_message_record(models.AbstractModel):
_name = 'wx.message_record'
message_event = fields.Selection([('receive', '收'), ('send', '发')],
require=True,
string="消息事件类型")
association_user = fields.Many2one('res.partner', string="关联用户")
message_type = fields.Many2one('wx.messagetype', string='消息类型')
officialaccount = fields.Many2one('wx.officialaccount', '微信服务号/企业号应用')
createTime = fields.Datetime("消息创建时间")
session_id = fields.Char("会话ID")
message_status = fields.Selection([('draft', '草稿'), ('approving', '审核中'),
('approved', '审核通过'),
('sending', '发送中'),
('use_sucess', '已接受'),
('use_block', '已拒绝'),
('system_fail', '发送失败')],
require=True,
string="消息状态",
default='draft')
usergroup = fields.Many2many('res.users',
'usergroup_id',
'user_id',
string="群发企业用户")
official_username = fields.Many2one('wx.customer', string="接收方/发送方")
send_event = fields.Many2one('wx.message.send_event', string="消息发送事件")
class OpTimetable(models.Model):
_name = 'op.timetable'
_description = 'TimeTables'
_rec_name = 'faculty_id'
period_id = fields.Many2one('op.period', 'Period', required=True)
start_datetime = fields.Datetime(
'Start Time',
required=True,
default=lambda self: fields.Datetime.now())
end_datetime = fields.Datetime('End Time', required=True)
course_id = fields.Many2one('op.course', 'Course', required=True)
faculty_id = fields.Many2one('op.faculty', 'Faculty', required=True)
batch_id = fields.Many2one('op.batch', 'Batch', required=True)
subject_id = fields.Many2one('op.subject', 'Subject', required=True)
color = fields.Integer('Color Index')
type = fields.Selection([('Monday', 'Monday'), ('Tuesday', 'Tuesday'),
('Wednesday', 'Wednesday'),
('Thursday', 'Thursday'), ('Friday', 'Friday'),
('Saturday', 'Saturday')], 'Days')
@api.constrains('start_datetime', 'end_datetime')
def _check_date_time(self):
if self.start_datetime > self.end_datetime:
raise ValidationError('End Time cannot be set before Start Time.')
@api.onchange('course_id')
def onchange_course(self):
self.batch_id = False
@api.onchange('start_datetime')
def onchange_start_date(self):
start_datetime = datetime.datetime.strptime(self.start_datetime,
"%Y-%m-%d %H:%M:%S")
if start_datetime and start_datetime.weekday() == 0:
self.type = 'Monday'
elif start_datetime and start_datetime.weekday() == 1:
self.type = 'Tuesday'
elif start_datetime and start_datetime.weekday() == 2:
self.type = 'Wednesday'
elif start_datetime and start_datetime.weekday() == 3:
self.type = 'Thursday'
elif start_datetime and start_datetime.weekday() == 4:
self.type = 'Friday'
elif start_datetime and start_datetime.weekday() == 5:
self.type = 'Saturday'
class oa_journal(models.Model):
'''
模型：日常流水
'''
_name = 'oa.journal'
_description = 'OA Journal'
name = fields.Char('单号', required=True, select=True, copy=False, default=lambda obj: '/')
item = fields.Many2one('product.product', string='料品')
spec = fields.Char(string='规格')
description = fields.Text(string='描述')
total_debit = fields.Float(digits=(12, 2), string='金额', required=True)
invoice_type = fields.Many2one('oa_journal.invoice.type', string='发票类型')
mode_of_payment = fields.Selection(
[('Cash', '现金'), ('Tenpay', '财付通支付'), ('Alipay', '支付宝支付'), ('Transfer', '网银转账'),
('Credit', '信用卡支付'), ('Wechat', '微信支付')], string='支付方式', required=True)
payer_employee = fields.Many2one('hr.employee', string="付款人", required=True,
default=lambda self: _employee_get(self, self.env.cr, self.env.user.id))
paidon = fields.Datetime(string='付款时间', required=True, default=lambda self: datetime.datetime.now())
supplier = fields.Many2one('res.partner', string='供应商')
supplier_order = fields.Char(string='供应商单号')
receivedon = fields.Datetime(string='收货时间')
storage_location = fields.Char(string='存储地点')
collar_employee = fields.Many2one("hr.employee", string='领用人')
address = fields.Char(string='地址')
expense_claim = fields.Many2one('hr.expense.expense', string='报销单')
claim_amount = fields.Float(digits=(12, 2),string='销抵金额')
state = fields.Selection([('draft', '草稿'), ('paid', '已付款'), ('received', '已收货'), ('expensed', '已报销'),
('closed', '已关闭')], string='状态', readonly=True, default='draft')
ec_platform = fields.Many2one("oa_journal.ecplatform", string='电商平台')
extend_col1 = fields.Char(string='扩展字段1')
company_id = fields.Many2one("res.company", string='公司')
_sql_constraints = [
('name_uniq', 'unique(name, company_id)', '单号必须唯一!')
]
_order = "name desc"
@api.model
def create(self, vals):
if vals.get('name', '/') == '/':
vals['name'] = self.env['ir.sequence'].get('oa.journal') or '/'
_defaults = {
'name': '/',
}
return super(oa_journal, self).create(vals)
class report_plm_document_wall(models.Model):
_name = "report.plm_document.wall"
_description = "Users that did not inserted documents since one month"
_auto = False
name = fields.Date(_('Month'), readonly=True)
user_id = fields.Many2one('res.users', _('Owner'), readonly=True)
user = fields.Char(_('User'), size=64, readonly=True)
month = fields.Char(_('Month'), size=24, readonly=True)
last = fields.Datetime(_('Last Posted Time'), readonly=True)
class SaasClient(models.AbstractModel):
_name = 'saas_base.client'
users_len = fields.Integer('Count users', readonly=True)
max_users = fields.Char('Max users allowed', readonly=True)
file_storage = fields.Integer('File storage (MB)', readonly=True)
db_storage = fields.Integer('DB storage (MB)', readonly=True)
total_storage_limit = fields.Integer('Total storage limit (MB)', readonly=True, default=0)
expiration_datetime = fields.Datetime('Expiration', track_visibility='onchange')
trial = fields.Boolean('Trial', help='indication of trial clients', default=False, readonly=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 OpFaculty(models.Model):
_name = 'op.faculty'
_inherits = {'res.partner': 'partner_id'}
partner_id = fields.Many2one('res.partner',
'Partner',
required=True,
ondelete="cascade")
middle_name = fields.Char('Middle Name', size=128)
last_name = fields.Char('Last Name', size=128, required=True)
birth_date = fields.Date('Birth Date', required=True)
blood_group = fields.Selection([('A+', 'A+ve'), ('B+', 'B+ve'),
('O+', 'O+ve'), ('AB+', 'AB+ve'),
('A-', 'A-ve'), ('B-', 'B-ve'),
('O-', 'O-ve'), ('AB-', 'AB-ve')],
'Blood Group')
gender = fields.Selection([('male', 'Male'), ('female', 'Female')],
'Gender',
required=True)
nationality = fields.Many2one('res.country', 'Nationality')
emergency_contact = fields.Many2one('res.partner', 'Emergency Contact')
visa_info = fields.Char('Visa Info', size=64)
id_number = fields.Char('ID Card Number', size=64)
photo = fields.Binary('Photo')
login = fields.Char('Login',
related='partner_id.user_id.login',
readonly=1)
last_login = fields.Datetime('Latest Connection',
related='partner_id.user_id.login_date',
readonly=1)
faculty_subject_ids = fields.Many2many('op.subject', string='Subject(s)')
emp_id = fields.Many2one('hr.employee', 'Employee')
@api.one
@api.constrains('birth_date')
def _check_birthdate(self):
if self.birth_date > fields.Date.today():
raise ValidationError(
"Birth Date can't be greater than current date!")
@api.one
def create_employee(self):
vals = {
'name':
self.name + ' ' + (self.middle_name or '') + ' ' + self.last_name,
'country_id': self.nationality.id,
'gender': self.gender,
'address_home_id': self.partner_id.id
}
emp_id = self.env['hr.employee'].create(vals)
self.write({'emp_id': emp_id.id})
self.partner_id.write({'supplier': True, 'employee': True})
class pos_config(models.Model):
_inherit = 'pos.config'
@api.one
@api.depends('cache_ids')
def _get_oldest_cache_time(self):
pos_cache = self.env['pos.cache']
oldest_cache = pos_cache.search([('config_id', '=', self.id)],
order='write_date',
limit=1)
if oldest_cache:
self.oldest_cache_time = oldest_cache.write_date
# Use a related model to avoid the load of the cache when the pos load his config
cache_ids = fields.One2many('pos.cache', 'config_id')
oldest_cache_time = fields.Datetime(compute='_get_oldest_cache_time',
string='Oldest cache time',
readonly=True)
def _get_cache_for_user(self):
pos_cache = self.env['pos.cache']
cache_for_user = pos_cache.search([('id', 'in', self.cache_ids.ids),
('compute_user_id', '=',
self.env.uid)])
if cache_for_user:
return cache_for_user[0]
else:
return None
@api.multi
def get_products_from_cache(self, fields, domain):
cache_for_user = self._get_cache_for_user()
if cache_for_user:
return cache_for_user.get_cache(domain, fields)
else:
pos_cache = self.env['pos.cache']
pos_cache.create({
'config_id': self.id,
'product_domain': str(domain),
'product_fields': str(fields),
'compute_user_id': self.env.uid
})
new_cache = self._get_cache_for_user()
return new_cache.get_cache(domain, fields)
@api.one
def delete_cache(self):
# throw away the old caches
self.cache_ids.unlink()
class report_plm_document_user(models.Model):
_name = "report.plm_document.user"
_description = "Files details by Users"
_auto = False
name = fields.Char(_('Year'), size=64, readonly=True)
month = fields.Selection([('01', _('January')), ('02', _('February')),
('03', _('March')), ('04', _('April')),
('05', _('May')), ('06', _('June')),
('07', _('July')), ('08', _('August')),
('09', _('September')), ('10', _('October')),
('11', _('November')), ('12', _('December'))],
_('Month'),
readonly=True)
day = fields.Char(_('Day'), size=64, readonly=True)
user_id = fields.Integer(_('Owner'), readonly=True)
user = fields.Char(_('User'), size=64, readonly=True)
directory = fields.Char(_('Directory'), size=64, readonly=True)
datas_fname = fields.Char(_('File'), size=64, readonly=True)
create_date = fields.Datetime(_('Date Created'), readonly=True)
change_date = fields.Datetime(_('Modified Date'), readonly=True)
file_size = fields.Integer(_('File Size'), readonly=True)
nbr = fields.Integer(_('# of Files'), readonly=True)
type = fields.Char(_('Directory Type'), size=64, readonly=True)
class OpAssignmentSubLine(models.Model):
_name = 'op.assignment.sub.line'
_inherit = 'mail.thread'
_rec_name = 'assignment_id'
_description = 'Assignment Submission'
assignment_id = fields.Many2one('op.assignment',
'Assignment',
required=True)
student_id = fields.Many2one('op.student',
'Student',
default=lambda self: self.env['op.student'].
search([('user_id', '=', self.env.uid)]),
required=True)
description = fields.Text('Description', track_visibility='onchange')
state = fields.Selection([('draft', 'Draft'), ('submit', 'Submitted'),
('reject', 'Rejected'),
('change', 'Change Req.'),
('accept', 'Accepted')],
'State',
default='draft',
track_visibility='onchange')
submission_date = fields.Datetime(
'Submission Date',
readonly=True,
default=lambda self: fields.Datetime.now(),
required=True)
note = fields.Text('Note')
@api.one
def act_draft(self):
self.state = 'draft'
@api.one
def act_submit(self):
self.state = 'submit'
@api.one
def act_accept(self):
self.state = 'accept'
@api.one
def act_change_req(self):
self.state = 'change'
@api.one
def act_reject(self):
self.state = 'reject'
class wx_customer_subscribe(models.Model):
_name = 'wx.customer.subscribe'
subscribe_type = fields.Selection([('subscribe', '关注'),
('cancel_ subscribe', '取消关注')],
string='类型',
readonly=True)
subscribe_source = fields.Selection([('manual', '手工关注'), ('scan', '扫码关注')],
string='来源',
readonly=True)
subscribe_time = fields.Datetime(string='操作时间', readonly=True)
subscribe_key = fields.Char(string='Key', readonly=True)
wx_customer_id = fields.Many2one('wx.customer',
string='微信用户',
readonly=True)
#store_id =fields.Many2one('ycloud.o2o.store',string='门店',readonly=True)
_order = 'subscribe_time desc'
class OauthAccessToken(models.Model):
_name = 'oauth.access_token'
application_id = fields.Many2one('oauth.application', string='Application')
token = fields.Char('Access Token', required=True)
user_id = fields.Many2one('res.users', string='User', required=True)
expires = fields.Datetime('Expires', required=True)
scope = fields.Char('Scope')
def is_valid(self, cr, uid, ids, scopes=None, context=None):
"""
Checks if the access token is valid.
:param scopes: An iterable containing the scopes to check or None
"""
res = {}
for t in self.browse(cr, uid, ids, context=context):
res[t.id] = t.is_expired() and self._allow_scopes(
cr, uid, t, scopes)
return res
def is_expired(self, cr, uid, ids, context=None):
res = {}
for t in self.browse(cr, uid, ids, context=context):
res[t.id] = datetime.now() < datetime.strptime(
t.expires, DEFAULT_SERVER_DATETIME_FORMAT)
return res
def _allow_scopes(self, cr, uid, token, scopes, context=None):
if not scopes:
return True
provided_scopes = set(self.scope.split())
resource_scopes = set(scopes)
return resource_scopes.issubset(provided_scopes)
def allow_scopes(self, cr, uid, ids, scopes, context=None):
"""
Check if the token allows the provided scopes
:param scopes: An iterable containing the scopes to check
"""
res = {}
for t in self.browse(cr, uid, ids, context=context):
res[t.id] = self._allow_scopes(cr, uid, t, scopes, context=context)
return res
class ProductHistory(models.Model):
_name = 'website.sale.product.view'
_description = 'Ecommerce Product Views'
sessionid = fields.Char('Session ID', index=True)
product_id = fields.Many2one('product.template', 'Product')
last_view_datetime = fields.Datetime('Last view datetime',
default=fields.Datetime.now)
_sql_constraints = [
('unique_session_product', 'UNIQUE(sessionid, product_id)',
'There is already a record for this product and session')
]
_order = 'last_view_datetime DESC'
@api.multi
def human_readable_datetime_difference(self, now=None):
"""
Return an human readable form of the difference between the supplied
datetime (or the current datetime if not supplied) and the history
record ``last_view_datetime``.
"""
if now is None:
now = fields.Datetime.from_string(fields.Datetime.now())
timedifference = now - fields.Datetime.from_string(
self.last_view_datetime)
minutes = timedifference.seconds // 60
hours = timedifference.seconds // 3600
days = timedifference.days
# string concatenation and explicit singular/plural
# to make life easier for translators
if days > 1:
return str(days) + ' ' + _('days ago')
elif days == 1:
return str(days) + ' ' + _('Yesterday')
elif hours > 1:
return str(hours) + ' ' + _('hours ago')
elif hours == 1:
return str(hours) + ' ' + _('hour ago')
elif minutes > 1:
return str(minutes) + ' ' + _('minutes ago')
elif minutes == 1:
return str(minutes) + ' ' + _('minute ago')
return _('Less than a minute ago')
class plm_relation_line(models.Model):
_name = 'mrp.bom.line'
_inherit = 'mrp.bom.line'
create_date = fields.Datetime(_('Creation Date'), readonly=True)
source_id = fields.Many2one('plm.document', 'name', ondelete='no action', readonly=True, help=_("This is the document object that declares this BoM."))
type = fields.Selection([('normal', _('Normal BoM')), ('phantom', _('Sets / Phantom')), ('ebom', _('Engineering BoM')), ('spbom', _('Spare BoM'))], _('BoM Type'), required=True, help=
_("Use a phantom bill of material in raw materials lines that have to be " \
"automatically computed in on production order and not one per level." \
"If you put \"Phantom/Set\" at the root level of a bill of material " \
"it is considered as a set or pack: the products are replaced by the components " \
"between the sale order to the picking without going through the production order." \
"The normal BoM will generate one production order per BoM level."))
itemnum = fields.Integer(_('CAD Item Position'), help=_("This is the item reference position into the CAD document that declares this BoM."))
itemlbl = fields.Char(_('CAD Item Position Label'), size=64)
_defaults = {
'product_uom': 1,
}
_order = 'itemnum'
class hr_recruitment_report(models.Model):
_name = "hr.recruitment.report"
_description = "Recruitments Statistics"
_auto = False
_rec_name = 'date_create'
_order = 'date_create desc'
user_id = fields.Many2one('res.users', 'User', readonly=True)
company_id = fields.Many2one('res.company', 'Company', readonly=True)
date_create = fields.Datetime('Create Date', readonly=True)
date_last_stage_update = fields.Datetime('Last Stage Update', readonly=True)
date_closed = fields.Date('Closed', readonly=True)
job_id = fields.Many2one('hr.job', 'Applied Job', readonly=True)
stage_id = fields.Many2one('hr.recruitment.stage', 'Stage')
type_id = fields.Many2one('hr.recruitment.degree', 'Degree')
department_id = fields.Many2one('hr.department', 'Department', readonly=True)
priority = fields.Selection(hr_recruitment.AVAILABLE_PRIORITIES, 'Appreciation')
salary_prop = fields.Float("Salary Proposed", digits=0)
salary_prop_avg = fields.Float("Avg. Proposed Salary", group_operator="avg", digits=0)
salary_exp = fields.Float("Salary Expected", digits=0)
salary_exp_avg = fields.Float("Avg. Expected Salary", group_operator="avg", digits=0)
partner_id = fields.Many2one('res.partner', 'Partner', readonly=True)
delay_close = fields.Float('Avg. Delay to Close', digits=(16, 2), readonly=True, group_operator="avg", help="Number of Days to close the project issue")
last_stage_id = fields.Many2one('hr.recruitment.stage', 'Last Stage')
medium_id = fields.Many2one('utm.medium', 'Medium', readonly=True, help="This is the method of delivery. Ex: Postcard, Email, or Banner Ad")
source_id = fields.Many2one('utm.source', 'Source', readonly=True, help="This is the source of the link Ex: Search Engine, another domain, or name of email list")
def init(self, cr):
tools.drop_view_if_exists(cr, 'hr_recruitment_report')
cr.execute("""
create or replace view hr_recruitment_report as (
select
min(s.id) as id,
s.create_date as date_create,
date(s.date_closed) as date_closed,
s.date_last_stage_update as date_last_stage_update,
s.partner_id,
s.company_id,
s.user_id,
s.job_id,
s.type_id,
s.department_id,
s.priority,
s.stage_id,
s.last_stage_id,
s.medium_id,
s.source_id,
sum(salary_proposed) as salary_prop,
(sum(salary_proposed)/count(*)) as salary_prop_avg,
sum(salary_expected) as salary_exp,
(sum(salary_expected)/count(*)) as salary_exp_avg,
extract('epoch' from (s.write_date-s.create_date))/(3600*24) as delay_close,
count(*) as nbr
from hr_applicant s
group by
s.date_open,
s.create_date,
s.write_date,
s.date_closed,
s.date_last_stage_update,
s.partner_id,
s.company_id,
s.user_id,
s.stage_id,
s.last_stage_id,
s.type_id,
s.priority,
s.job_id,
s.department_id,
s.medium_id,
s.source_id
)
""")
class MailChannel(models.Model):
""" Chat Session
Reprensenting a conversation between users.
It extends the base method for anonymous usage.
"""
_name = 'mail.channel'
_inherit = ['mail.channel', 'rating.mixin']
anonymous_name = fields.Char('Anonymous Name')
create_date = fields.Datetime('Create Date', required=True)
channel_type = fields.Selection(selection_add=[('livechat',
'Livechat Conversation')])
livechat_channel_id = fields.Many2one('im_livechat.channel', 'Channel')
@api.multi
def _channel_message_notifications(self, message):
""" When a anonymous user create a mail.channel, the operator is not notify (to avoid massive polling when
clicking on livechat button). So when the anonymous person is sending its FIRST message, the channel header
should be added to the notification, since the user cannot be listining to the channel.
"""
notifications = super(MailChannel,
self)._channel_message_notifications(message)
if not message.author_id:
unpinned_channel_partner = self.mapped(
'channel_last_seen_partner_ids').filtered(
lambda cp: not cp.is_pinned)
if unpinned_channel_partner:
unpinned_channel_partner.write({'is_pinned': True})
notifications = self._channel_channel_notifications(
unpinned_channel_partner.mapped(
'partner_id').ids) + notifications
return notifications
@api.multi
def channel_info(self, extra_info=False):
""" Extends the channel header by adding the livechat operator and the 'anonymous' profile
:rtype : list(dict)
"""
channel_infos = super(MailChannel, self).channel_info(extra_info)
# add the operator id
if self.env.context.get('im_livechat_operator_partner_id'):
partner_name = self.env['res.partner'].browse(
self.env.context.get(
'im_livechat_operator_partner_id')).name_get()[0]
for channel_info in channel_infos:
channel_info['operator_pid'] = partner_name
# add the anonymous name
channel_infos_dict = dict((c['id'], c) for c in channel_infos)
for channel in self:
if channel.anonymous_name:
channel_infos_dict[
channel.id]['anonymous_name'] = channel.anonymous_name
return channel_infos_dict.values()
@api.model
def channel_fetch_slot(self):
values = super(MailChannel, self).channel_fetch_slot()
pinned_channels = self.env['mail.channel.partner'].search([
('partner_id', '=', self.env.user.partner_id.id),
('is_pinned', '=', True)
]).mapped('channel_id')
values['channel_livechat'] = self.search([
('channel_type', '=', 'livechat'), ('public', 'in', ['public']),
('id', 'in', pinned_channels.ids)
]).channel_info()
return values
@api.model
def cron_remove_empty_session(self):
hours = 1 # never remove empty session created within the last hour
self.env.cr.execute(
"""
SELECT id as id
FROM mail_channel C
WHERE NOT EXISTS (
SELECT *
FROM mail_message_mail_channel_rel R
WHERE R.mail_channel_id = C.id
) AND C.channel_type = 'livechat' AND livechat_channel_id IS NOT NULL AND
COALESCE(write_date, create_date, (now() at time zone 'UTC'))::timestamp
< ((now() at time zone 'UTC') - interval %s)""",
("%s hours" % hours, ))
empty_channel_ids = [item['id'] for item in self.env.cr.dictfetchall()]
self.browse(empty_channel_ids).unlink()
class SaasPortalClient(models.Model):
_name = 'saas_portal.client'
_description = 'Client'
_rec_name = 'name'
_inherit = ['mail.thread', 'saas_portal.database', 'saas_base.client']
name = fields.Char(required=True)
partner_id = fields.Many2one('res.partner', string='Partner', track_visibility='onchange')
plan_id = fields.Many2one('saas_portal.plan', string='Plan', track_visibility='onchange', ondelete='restrict')
expired = fields.Boolean('Expired', default=False, readonly=True)
user_id = fields.Many2one('res.users', default=lambda self: self.env.user, string='Salesperson')
notification_sent = fields.Boolean(default=False, readonly=True,
help='notification about oncoming expiration has sent')
support_team_id = fields.Many2one('saas_portal.support_team', 'Support Team')
expiration_datetime_sent = fields.Datetime(help='updates every time send_expiration_info is executed')
active = fields.Boolean(default=True, compute='_compute_active', store=True)
block_on_expiration = fields.Boolean('Block clients on expiration', default=False)
block_on_storage_exceed = fields.Boolean('Block clients on storage exceed', default=False)
storage_exceed = fields.Boolean('Storage limit has been exceed', default=False)
_track = {
'expired': {
'saas_portal.mt_expired':
lambda self, cr, uid, obj, ctx=None: obj.expired
}
}
@api.multi
@api.depends('state')
def _compute_active(self):
for record in self:
record.active = record.state != 'deleted'
@api.model
def _cron_suspend_expired_clients(self):
payload = {
'params': [{'key': 'saas_client.suspended', 'value': '1', 'hidden': True}],
}
now = fields.Datetime.now()
expired = self.search([
('expiration_datetime', '<', now),
('expired', '=', False)
])
expired.write({'expired': True})
for record in expired:
if record.trial or record.block_on_expiration:
template = self.env.ref('saas_portal.email_template_has_expired_notify')
record.message_post_with_template(template.id, composition_mode='comment')
self.env['saas.config'].do_upgrade_database(payload, record.id)
@api.model
def _cron_notify_expired_clients(self):
# send notification about expiration by email
notification_delta = int(
self.env['ir.config_parameter'].get_param('saas_portal.expiration_notify_in_advance', '0'))
if notification_delta > 0:
records = self.search([('expiration_datetime', '<=',
(datetime.now() + timedelta(days=notification_delta)).strftime(
DEFAULT_SERVER_DATETIME_FORMAT)),
('notification_sent', '=', False)])
records.write({'notification_sent': True})
for record in records:
template = self.env.ref('saas_portal.email_template_expiration_notify')
record.with_context(days=notification_delta).message_post_with_template(template.id,
composition_mode='comment')
def unlink(self, cr, uid, ids, context=None):
user_model = self.pool.get('res.users')
token_model = self.pool.get('oauth.access_token')
for obj in self.browse(cr, uid, ids):
to_search1 = [('application_id', '=', obj.id)]
tk_ids = token_model.search(cr, uid, to_search1, context=context)
if tk_ids:
token_model.unlink(cr, uid, tk_ids)
# TODO: it seems we don't need stuff below
# to_search2 = [('database', '=', obj.name)]
# user_ids = user_model.search(cr, uid, to_search2, context=context)
# if user_ids:
# user_model.unlink(cr, uid, user_ids)
# yuancloud.service.db.exp_drop(obj.name)
return super(SaasPortalClient, self).unlink(cr, uid, ids, context)
@api.multi
def rename_database(self, new_dbname):
self.ensure_one()
# TODO async
state = {
'd': self.name,
'client_id': self.client_id,
'new_dbname': new_dbname,
}
url = \
self.server_id._request_server(path='/saas_server/rename_database', state=state, client_id=self.client_id)[
0]
res = requests.get(url, verify=(self.server_id.request_scheme == 'https' and self.server_id.verify_ssl))
_logger.info('delete database: %s', res.text)
if res.status_code != 500:
self.name = new_dbname
@api.one
def duplicate_database(self, dbname=None, partner_id=None, expiration=None):
server = self.server_id
if not server:
server = self.env['saas_portal.server'].get_saas_server()
server.action_sync_server()
vals = {'name': dbname,
'server_id': server.id,
'plan_id': self.plan_id.id,
'partner_id': partner_id or self.partner_id.id,
}
if expiration:
now = datetime.now()
delta = timedelta(hours=expiration)
vals['expiration_datetime'] = (now + delta).strftime(DEFAULT_SERVER_DATETIME_FORMAT)
client = self.env['saas_portal.client'].create(vals)
client_id = client.client_id
scheme = server.request_scheme
port = server.request_port
state = {
'd': client.name,
'e': client.expiration_datetime,
'r': '%s://%s:%s/web' % (scheme, port, client.name),
}
state.update({'db_template': self.name,
'disable_mail_server': True})
scope = ['userinfo', 'force_login', 'trial', 'skiptheuse']
# TODO use _request_server
url = server._request(path='/saas_server/new_database',
scheme=scheme,
port=port,
state=state,
client_id=client_id,
scope=scope, )[0]
return url
@api.multi
def send_expiration_info(self):
for record in self:
if record.expiration_datetime_sent and record.expiration_datetime and record.expiration_datetime_sent != record.expiration_datetime:
record.expiration_datetime_sent = record.expiration_datetime
payload = record.get_upgrade_database_payload()
if payload:
self.env['saas.config'].do_upgrade_database(payload, record.id)
record.send_expiration_info_to_partner()
# expiration date has been changed, flush expiration notification flag
record.notification_sent = False
else:
record.expiration_datetime_sent = record.expiration_datetime
@api.multi
def get_upgrade_database_payload(self):
self.ensure_one()
return {
'params': [{'key': 'saas_client.expiration_datetime', 'value': self.expiration_datetime, 'hidden': True}]}
@api.multi
def send_params_to_client_db(self):
for record in self:
payload = {
'params': [{'key': 'saas_client.max_users', 'value': record.max_users, 'hidden': True},
{'key': 'saas_client.expiration_datetime', 'value': record.expiration_datetime,
'hidden': True},
{'key': 'saas_client.total_storage_limit', 'value': record.total_storage_limit,
'hidden': True}],
}
self.env['saas.config'].do_upgrade_database(payload, record.id)
@api.multi
def send_expiration_info_to_partner(self):
for record in self:
if record.expiration_datetime:
template = self.env.ref('saas_portal.email_template_expiration_datetime_updated')
record.message_post_with_template(template.id, composition_mode='comment')
@api.one
def write(self, vals):
if 'expiration_datetime' in vals and vals['expiration_datetime']:
self.env['saas.config'].do_upgrade_database(
{'params': [
{'key': 'saas_client.expiration_datetime', 'value': vals['expiration_datetime'], 'hidden': True}]},
self.id)
return super(SaasPortalClient, self).write(vals)
@api.multi
def storage_usage_monitoring(self):
payload = {
'params': [{'key': 'saas_client.suspended', 'value': '1', 'hidden': True}],
}
for r in self:
if r.total_storage_limit < r.file_storage + r.db_storage and r.storage_exceed is False:
r.write({'storage_exceed': True})
template = self.env.ref('saas_portal.email_template_storage_exceed')
r.message_post_with_template(template.id, composition_mode='comment')
if r.block_on_storage_exceed:
self.env['saas.config'].do_upgrade_database(payload, r.id)
if r.total_storage_limit >= r.file_storage + r.db_storage and r.storage_exceed is True:
r.write({'storage_exceed': False})
class SaasServerClient(models.Model):
_name = 'saas_server.client'
_inherit = ['mail.thread', 'saas_base.client']
name = fields.Char('Database name', readonly=True, required=True)
client_id = fields.Char('Database UUID', readonly=True, select=True)
expiration_datetime = fields.Datetime(readonly=True)
state = fields.Selection([('template', 'Template'), ('draft', 'New'),
('open', 'In Progress'),
('cancelled', 'Cancelled'),
('pending', 'Pending'), ('deleted', 'Deleted')],
'State',
default='draft',
track_visibility='onchange')
_sql_constraints = [
('client_id_uniq', 'unique (client_id)',
'client_id should be unique!'),
]
@api.one
def create_database(self, template_db=None, demo=False, lang='en_US'):
new_db = self.name
if template_db:
yuancloud.service.db._drop_conn(self.env.cr, template_db)
yuancloud.service.db.exp_duplicate_database(template_db, new_db)
else:
password = ''.join(
random.SystemRandom().choice(string.ascii_uppercase +
string.digits) for _ in range(32))
yuancloud.service.db.exp_create_database(new_db,
demo,
lang,
user_password='******')
self.state = 'open'
@api.one
def registry(self, new=False, **kwargs):
m = yuancloud.modules.registry.RegistryManager
if new:
return m.new(self.name, **kwargs)
else:
return m.get(self.name, **kwargs)
@api.one
def install_addons(self, addons, is_template_db):
addons = set(addons)
addons.add('mail_delete_sent_by_footer') # debug
if is_template_db:
addons.add('auth_oauth')
addons.add('saas_client')
else:
addons.add('saas_client')
if not addons:
return
with self.registry()[0].cursor() as cr:
env = api.Environment(cr, SUPERUSER_ID, self._context)
self._install_addons(env, addons)
@api.one
def disable_mail_servers(self):
'''
disables mailserver on db to stop it from sending and receiving mails
'''
# let's disable incoming mail servers
incoming_mail_servers = self.env['fetchmail.server'].search([])
if len(incoming_mail_servers):
incoming_mail_servers.write({'active': False})
# let's disable outgoing mailservers too
outgoing_mail_servers = self.env['ir.mail_server'].search([])
if len(outgoing_mail_servers):
outgoing_mail_servers.write({'active': False})
@api.one
def _install_addons(self, client_env, addons):
for addon in client_env['ir.module.module'].search([('name', 'in',
list(addons))]):
addon.button_install()
@api.one
def update_registry(self):
self.registry(new=True, update_module=True)
@api.one
def prepare_database(self, **kwargs):
with self.registry()[0].cursor() as cr:
env = api.Environment(cr, SUPERUSER_ID, self._context)
self._prepare_database(env, **kwargs)
@api.model
def _config_parameters_to_copy(self):
return ['saas_client.ab_location', 'saas_client.ab_register']
@api.one
def _prepare_database(self,
client_env,
owner_user=None,
is_template_db=False,
addons=[],
access_token=None,
tz=None):
client_id = self.client_id
# update saas_server.client state
if is_template_db:
self.state = 'template'
# set tz
if tz:
client_env['res.users'].search([]).write({'tz': tz})
client_env['ir.values'].set_default('res.partner', 'tz', tz)
# update database.uuid
client_env['ir.config_parameter'].set_param('database.uuid', client_id)
# copy configs
for key in self._config_parameters_to_copy():
value = self.env['ir.config_parameter'].get_param(key, default='')
client_env['ir.config_parameter'].set_param(key, value)
# copy auth provider from saas_server
saas_oauth_provider = self.env.ref('saas_server.saas_oauth_provider')
oauth_provider = None
if is_template_db and not client_env.ref(
'saas_server.saas_oauth_provider', raise_if_not_found=False):
oauth_provider_data = {'enabled': False, 'client_id': client_id}
for attr in [
'name', 'auth_endpoint', 'scope', 'validation_endpoint',
'data_endpoint', 'css_class', 'body', 'enabled'
]:
oauth_provider_data[attr] = getattr(saas_oauth_provider, attr)
oauth_provider = client_env['auth.oauth.provider'].create(
oauth_provider_data)
client_env['ir.model.data'].create({
'name': 'saas_oauth_provider',
'module': 'saas_server',
'noupdate': True,
'model': 'auth.oauth.provider',
'res_id': oauth_provider.id,
})
if not oauth_provider:
oauth_provider = client_env.ref('saas_server.saas_oauth_provider')
if not is_template_db:
oauth_provider.client_id = client_id
# prepare users
OWNER_TEMPLATE_LOGIN = '******'
user = None
if is_template_db:
client_env['res.users'].create({
'login': OWNER_TEMPLATE_LOGIN,
'name': 'NAME',
'email': '*****@*****.**',
})
client_env['res.users'].browse(SUPERUSER_ID).write({
'oauth_provider_id':
oauth_provider.id,
'oauth_uid':
SUPERUSER_ID,
'oauth_access_token':
access_token
})
else:
domain = [('login', '=', OWNER_TEMPLATE_LOGIN)]
res = client_env['res.users'].search(domain)
if res:
user = res[0]
client_env['ir.config_parameter'].set_param(
'res.users.owner',
user.id,
groups=['saas_client.group_saas_support'])
res = client_env['res.users'].search([('oauth_uid', '=',
owner_user['user_id'])])
if res:
# user already exists (e.g. administrator)
user = res[0]
if not user:
user = client_env['res.users'].browse(SUPERUSER_ID)
user.write({
'login': owner_user['login'],
'name': owner_user['name'],
'email': owner_user['email'],
'oauth_provider_id': oauth_provider.id,
'oauth_uid': owner_user['user_id'],
'oauth_access_token': access_token
})
@api.model
def update_all(self):
self.sudo().search([]).update()
@api.one
def update(self):
try:
registry = self.registry()[0]
with registry.cursor() as client_cr:
client_env = api.Environment(client_cr, SUPERUSER_ID,
self._context)
data = self._get_data(client_env, self.client_id)[0]
self.write(data)
except psycopg2.OperationalError:
if self.state != 'draft':
self.state = 'deleted'
return
@api.one
def _get_data(self, client_env, check_client_id):
client_id = client_env['ir.config_parameter'].get_param(
'database.uuid')
if check_client_id != client_id:
return {'state': 'deleted'}
users = client_env['res.users'].search([('share', '=', False)])
param_obj = client_env['ir.config_parameter']
max_users = param_obj.get_param('saas_client.max_users', '0').strip()
suspended = param_obj.get_param('saas_client.suspended', '0').strip()
total_storage_limit = param_obj.get_param(
'saas_client.total_storage_limit', '0').strip()
users_len = len(users)
data_dir = yuancloud.tools.config['data_dir']
file_storage = get_size('%s/filestore/%s' % (data_dir, self.name))
file_storage = int(file_storage / (1024 * 1024))
client_env.cr.execute("select pg_database_size('%s')" % self.name)
db_storage = client_env.cr.fetchone()[0]
db_storage = int(db_storage / (1024 * 1024))
data = {
'client_id': client_id,
'users_len': users_len,
'max_users': max_users,
'file_storage': file_storage,
'db_storage': db_storage,
'total_storage_limit': total_storage_limit,
}
if suspended == '0' and self.state == 'pending':
data.update({'state': 'open'})
if suspended == '1' and self.state == 'open':
data.update({'state': 'pending'})
return data
@api.one
def upgrade_database(self, **kwargs):
with self.registry()[0].cursor() as cr:
env = api.Environment(cr, SUPERUSER_ID, self._context)
return self._upgrade_database(env, **kwargs)[0]
@api.one
def _upgrade_database(self, client_env, data):
# "data" comes from saas_portal/models/wizard.py::upgrade_database
post = data
module = client_env['ir.module.module']
print '_upgrade_database', data
res = {}
# 0. Update module list
update_list = post.get('update_addons_list', False)
if update_list:
module.update_list()
# 1. Update addons
update_addons = post.get('update_addons', [])
if update_addons:
module.search([('name', 'in', update_addons)
]).button_immediate_upgrade()
# 2. Install addons
install_addons = post.get('install_addons', [])
if install_addons:
module.search([('name', 'in', install_addons)
]).button_immediate_install()
# 3. Uninstall addons
uninstall_addons = post.get('uninstall_addons', [])
if uninstall_addons:
module.search([('name', 'in', uninstall_addons)
]).button_immediate_uninstall()
# 4. Run fixes
fixes = post.get('fixes', [])
for model, method in fixes:
getattr(request.registry[model], method)()
# 5. update parameters
params = post.get('params', [])
for obj in params:
if obj['key'] == 'saas_client.expiration_datetime':
self.expiration_datetime = obj['value']
if obj['key'] == 'saas_client.trial' and obj['value'] == 'False':
self.trial = False
groups = []
if obj.get('hidden'):
groups = ['saas_client.group_saas_support']
client_env['ir.config_parameter'].set_param(obj['key'],
obj['value'] or ' ',
groups=groups)
# 6. Access rights
access_owner_add = post.get('access_owner_add', [])
owner_id = client_env['ir.config_parameter'].get_param(
'res.users.owner', 0)
owner_id = int(owner_id)
if not owner_id:
res['owner_id'] = "Owner's user is not found"
if access_owner_add and owner_id:
res['access_owner_add'] = []
for g_ref in access_owner_add:
g = client_env.ref(g_ref, raise_if_not_found=False)
if not g:
res['access_owner_add'].append('group not found: %s' %
g_ref)
continue
g.write({'users': [(4, owner_id, 0)]})
access_remove = post.get('access_remove', [])
if access_remove:
res['access_remove'] = []
for g_ref in access_remove:
g = client_env.ref(g_ref, raise_if_not_found=False)
if not g:
res['access_remove'].append('group not found: %s' % g_ref)
continue
users = []
for u in g.users:
if u.id != SUPERUSER_ID:
users.append((3, u.id, 0))
g.write({'users': users})
return res
@api.model
def delete_expired_databases(self):
now = time.strftime(DEFAULT_SERVER_DATETIME_FORMAT)
res = self.search([('state', 'not in', ['deleted', 'template']),
('expiration_datetime', '<=', now),
('trial', '=', True)])
_logger.info('delete_expired_databases %s', res)
res.delete_database()
@api.one
def delete_database(self):
yuancloud.service.db.exp_drop(self.name)
self.write({'state': 'deleted'})
@api.one
def rename_database(self, new_dbname):
yuancloud.service.db.exp_rename(self.name, new_dbname)
self.name = new_dbname
@api.model
def _transport_backup(self, dump_db, filename=None):
'''
backup transport agents should override this
'''
raise exceptions.Warning('Transport agent has not been configured')
@api.multi
def backup_database(self):
res = []
for database_obj in self:
data = {}
data['name'] = database_obj.name
filename = "%(db_name)s_%(timestamp)s.zip" % {
'db_name': database_obj.name,
'timestamp': datetime.utcnow().strftime("%Y-%m-%d_%H-%M-%SZ")
}
def dump_db(stream):
return db.dump_db(database_obj.name, stream)
try:
database_obj._transport_backup(dump_db, filename=filename)
data['status'] = 'success'
except Exception, e:
_logger.exception(
'An error happened during database %s backup' %
(database_obj.name))
data['status'] = 'fail'
data['message'] = str(e)
res.append(data)
return res
class Post(models.Model):
_name = 'forum.post'
_description = 'Forum Post'
_inherit = ['mail.thread', 'website.seo.metadata']
_order = "is_correct DESC, vote_count DESC, write_date DESC"
name = fields.Char('Title')
forum_id = fields.Many2one('forum.forum', string='Forum', required=True)
content = fields.Html('Content', strip_style=True)
plain_content = fields.Text('Plain Content', compute='_get_plain_content', store=True)
content_link = fields.Char('URL', help="URL of Link Articles")
tag_ids = fields.Many2many('forum.tag', 'forum_tag_rel', 'forum_id', 'forum_tag_id', string='Tags')
state = fields.Selection([('active', 'Active'), ('pending', 'Waiting Validation'), ('close', 'Close'), ('offensive', 'Offensive'), ('flagged', 'Flagged')], string='Status', default='active')
views = fields.Integer('Number of Views', default=0)
active = fields.Boolean('Active', default=True)
post_type = fields.Selection([
('question', 'Question'),
('link', 'Article'),
('discussion', 'Discussion')],
string='Type', default='question', required=True)
website_message_ids = fields.One2many(
'mail.message', 'res_id',
domain=lambda self: ['&', ('model', '=', self._name), ('message_type', 'in', ['email', 'comment'])],
string='Post Messages', help="Comments on forum post",
)
# history
create_date = fields.Datetime('Asked on', select=True, readonly=True)
create_uid = fields.Many2one('res.users', string='Created by', select=True, readonly=True)
write_date = fields.Datetime('Update on', select=True, readonly=True)
bump_date = fields.Datetime('Bumped on', readonly=True,
help="Technical field allowing to bump a question. Writing on this field will trigger "
"a write on write_date and therefore bump the post. Directly writing on write_date "
"is currently not supported and this field is a workaround.")
write_uid = fields.Many2one('res.users', string='Updated by', select=True, readonly=True)
relevancy = fields.Float('Relevance', compute="_compute_relevancy", store=True)
# vote
vote_ids = fields.One2many('forum.post.vote', 'post_id', string='Votes')
user_vote = fields.Integer('My Vote', compute='_get_user_vote')
vote_count = fields.Integer('Votes', compute='_get_vote_count', store=True)
# favorite
favourite_ids = fields.Many2many('res.users', string='Favourite')
user_favourite = fields.Boolean('Is Favourite', compute='_get_user_favourite')
favourite_count = fields.Integer('Favorite Count', compute='_get_favorite_count', store=True)
# hierarchy
is_correct = fields.Boolean('Correct', help='Correct answer or answer accepted')
parent_id = fields.Many2one('forum.post', string='Question', ondelete='cascade')
self_reply = fields.Boolean('Reply to own question', compute='_is_self_reply', store=True)
child_ids = fields.One2many('forum.post', 'parent_id', string='Answers')
child_count = fields.Integer('Number of answers', compute='_get_child_count', store=True)
uid_has_answered = fields.Boolean('Has Answered', compute='_get_uid_has_answered')
has_validated_answer = fields.Boolean('Is answered', compute='_get_has_validated_answer', store=True)
# offensive moderation tools
flag_user_id = fields.Many2one('res.users', string='Flagged by')
moderator_id = fields.Many2one('res.users', string='Reviewed by', readonly=True)
# closing
closed_reason_id = fields.Many2one('forum.post.reason', string='Reason')
closed_uid = fields.Many2one('res.users', string='Closed by', select=1)
closed_date = fields.Datetime('Closed on', readonly=True)
# karma calculation and access
karma_accept = fields.Integer('Convert comment to answer', compute='_get_post_karma_rights')
karma_edit = fields.Integer('Karma to edit', compute='_get_post_karma_rights')
karma_close = fields.Integer('Karma to close', compute='_get_post_karma_rights')
karma_unlink = fields.Integer('Karma to unlink', compute='_get_post_karma_rights')
karma_comment = fields.Integer('Karma to comment', compute='_get_post_karma_rights')
karma_comment_convert = fields.Integer('Karma to convert comment to answer', compute='_get_post_karma_rights')
karma_flag = fields.Integer('Flag a post as offensive', compute='_get_post_karma_rights')
can_ask = fields.Boolean('Can Ask', compute='_get_post_karma_rights')
can_answer = fields.Boolean('Can Answer', compute='_get_post_karma_rights')
can_accept = fields.Boolean('Can Accept', compute='_get_post_karma_rights')
can_edit = fields.Boolean('Can Edit', compute='_get_post_karma_rights')
can_close = fields.Boolean('Can Close', compute='_get_post_karma_rights')
can_unlink = fields.Boolean('Can Unlink', compute='_get_post_karma_rights')
can_upvote = fields.Boolean('Can Upvote', compute='_get_post_karma_rights')
can_downvote = fields.Boolean('Can Downvote', compute='_get_post_karma_rights')
can_comment = fields.Boolean('Can Comment', compute='_get_post_karma_rights')
can_comment_convert = fields.Boolean('Can Convert to Comment', compute='_get_post_karma_rights')
can_view = fields.Boolean('Can View', compute='_get_post_karma_rights')
can_display_biography = fields.Boolean("Is the author's biography visible from his post", compute='_get_post_karma_rights')
can_post = fields.Boolean('Can Automatically be Validated', compute='_get_post_karma_rights')
can_flag = fields.Boolean('Can Flag', compute='_get_post_karma_rights')
can_moderate = fields.Boolean('Can Moderate', compute='_get_post_karma_rights')
@api.one
@api.depends('content')
def _get_plain_content(self):
self.plain_content = tools.html2plaintext(self.content)[0:500] if self.content else False
@api.one
@api.depends('vote_count', 'forum_id.relevancy_post_vote', 'forum_id.relevancy_time_decay')
def _compute_relevancy(self):
if self.create_date:
days = (datetime.today() - datetime.strptime(self.create_date, tools.DEFAULT_SERVER_DATETIME_FORMAT)).days
self.relevancy = math.copysign(1, self.vote_count) * (abs(self.vote_count - 1) ** self.forum_id.relevancy_post_vote / (days + 2) ** self.forum_id.relevancy_time_decay)
else:
self.relevancy = 0
@api.multi
def _get_user_vote(self):
votes = self.env['forum.post.vote'].search_read([('post_id', 'in', self._ids), ('user_id', '=', self._uid)], ['vote', 'post_id'])
mapped_vote = dict([(v['post_id'][0], v['vote']) for v in votes])
for vote in self:
vote.user_vote = mapped_vote.get(vote.id, 0)
@api.multi
@api.depends('vote_ids.vote')
def _get_vote_count(self):
read_group_res = self.env['forum.post.vote'].read_group([('post_id', 'in', self._ids)], ['post_id', 'vote'], ['post_id', 'vote'], lazy=False)
result = dict.fromkeys(self._ids, 0)
for data in read_group_res:
result[data['post_id'][0]] += data['__count'] * int(data['vote'])
for post in self:
post.vote_count = result[post.id]
@api.one
def _get_user_favourite(self):
self.user_favourite = self._uid in self.favourite_ids.ids
@api.one
@api.depends('favourite_ids')
def _get_favorite_count(self):
self.favourite_count = len(self.favourite_ids)
@api.one
@api.depends('create_uid', 'parent_id')
def _is_self_reply(self):
self.self_reply = self.parent_id.create_uid.id == self._uid
@api.one
@api.depends('child_ids.create_uid', 'website_message_ids')
def _get_child_count(self):
def process(node):
total = len(node.website_message_ids) + len(node.child_ids)
for child in node.child_ids:
total += process(child)
return total
self.child_count = process(self)
@api.one
def _get_uid_has_answered(self):
self.uid_has_answered = any(answer.create_uid.id == self._uid for answer in self.child_ids)
@api.one
@api.depends('child_ids.is_correct')
def _get_has_validated_answer(self):
self.has_validated_answer = any(answer.is_correct for answer in self.child_ids)
@api.multi
def _get_post_karma_rights(self):
user = self.env.user
is_admin = user.id == SUPERUSER_ID
# sudoed recordset instead of individual posts so values can be
# prefetched in bulk
for post, post_sudo in itertools.izip(self, self.sudo()):
is_creator = post.create_uid == user
post.karma_accept = post.forum_id.karma_answer_accept_own if post.parent_id.create_uid == user else post.forum_id.karma_answer_accept_all
post.karma_edit = post.forum_id.karma_edit_own if is_creator else post.forum_id.karma_edit_all
post.karma_close = post.forum_id.karma_close_own if is_creator else post.forum_id.karma_close_all
post.karma_unlink = post.forum_id.karma_unlink_own if is_creator else post.forum_id.karma_unlink_all
post.karma_comment = post.forum_id.karma_comment_own if is_creator else post.forum_id.karma_comment_all
post.karma_comment_convert = post.forum_id.karma_comment_convert_own if is_creator else post.forum_id.karma_comment_convert_all
post.can_ask = is_admin or user.karma >= post.forum_id.karma_ask
post.can_answer = is_admin or user.karma >= post.forum_id.karma_answer
post.can_accept = is_admin or user.karma >= post.karma_accept
post.can_edit = is_admin or user.karma >= post.karma_edit
post.can_close = is_admin or user.karma >= post.karma_close
post.can_unlink = is_admin or user.karma >= post.karma_unlink
post.can_upvote = is_admin or user.karma >= post.forum_id.karma_upvote
post.can_downvote = is_admin or user.karma >= post.forum_id.karma_downvote
post.can_comment = is_admin or user.karma >= post.karma_comment
post.can_comment_convert = is_admin or user.karma >= post.karma_comment_convert
post.can_view = is_admin or user.karma >= post.karma_close or post_sudo.create_uid.karma > 0
post.can_display_biography = is_admin or post_sudo.create_uid.karma >= post.forum_id.karma_user_bio
post.can_post = is_admin or user.karma >= post.forum_id.karma_post
post.can_flag = is_admin or user.karma >= post.forum_id.karma_flag
post.can_moderate = is_admin or user.karma >= post.forum_id.karma_moderate
@api.one
@api.constrains('post_type', 'forum_id')
def _check_post_type(self):
if (self.post_type == 'question' and not self.forum_id.allow_question) \
or (self.post_type == 'discussion' and not self.forum_id.allow_discussion) \
or (self.post_type == 'link' and not self.forum_id.allow_link):
raise UserError(_('This forum does not allow %s' % self.post_type))
def _update_content(self, content, forum_id):
forum = self.env['forum.forum'].browse(forum_id)
if content and self.env.user.karma < forum.karma_dofollow:
for match in re.findall(r'<a\s.*href=".*?">', content):
content = re.sub(match, match[:3] + 'rel="nofollow" ' + match[3:], content)
if self.env.user.karma <= forum.karma_editor:
filter_regexp = r'(<img.*?>)|(<a[^>]*?href[^>]*?>)|(<[a-z|A-Z]+[^>]*style\s*=\s*[\'"][^\'"]*\s*background[^:]*:[^url;]*url)'
content_match = re.search(filter_regexp, content, re.I)
if content_match:
raise KarmaError('User karma not sufficient to post an image or link.')
return content
@api.model
def create(self, vals):
if 'content' in vals and vals.get('forum_id'):
vals['content'] = self._update_content(vals['content'], vals['forum_id'])
post = super(Post, self.with_context(mail_create_nolog=True)).create(vals)
# deleted or closed questions
if post.parent_id and (post.parent_id.state == 'close' or post.parent_id.active is False):
raise UserError(_('Posting answer on a [Deleted] or [Closed] question is not possible'))
# karma-based access
if not post.parent_id and not post.can_ask:
raise KarmaError('Not enough karma to create a new question')
elif post.parent_id and not post.can_answer:
raise KarmaError('Not enough karma to answer to a question')
if not post.parent_id and not post.can_post:
post.state = 'pending'
# add karma for posting new questions
if not post.parent_id and post.state == 'active':
self.env.user.sudo().add_karma(post.forum_id.karma_gen_question_new)
post.post_notification()
return post
@api.model
def check_mail_message_access(self, res_ids, operation, model_name=None):
if operation in ('write', 'unlink') and (not model_name or model_name == 'forum.post'):
# Make sure only author or moderator can edit/delete messages
if any(not post.can_edit for post in self.browse(res_ids)):
raise KarmaError('Not enough karma to edit a post.')
return super(Post, self).check_mail_message_access(res_ids, operation, model_name=model_name)
@api.multi
@api.depends('name', 'post_type')
def name_get(self):
result = []
for post in self:
if post.post_type == 'discussion' and post.parent_id and not post.name:
result.append((post.id, '%s (%s)' % (post.parent_id.name, post.id)))
else:
result.append((post.id, '%s' % (post.name)))
return result
@api.multi
def write(self, vals):
if 'content' in vals:
vals['content'] = self._update_content(vals['content'], self.forum_id.id)
if 'state' in vals:
if vals['state'] in ['active', 'close'] and any(not post.can_close for post in self):
raise KarmaError('Not enough karma to close or reopen a post.')
if 'active' in vals:
if any(not post.can_unlink for post in self):
raise KarmaError('Not enough karma to delete or reactivate a post')
if 'is_correct' in vals:
if any(not post.can_accept for post in self):
raise KarmaError('Not enough karma to accept or refuse an answer')
# update karma except for self-acceptance
mult = 1 if vals['is_correct'] else -1
for post in self:
if vals['is_correct'] != post.is_correct and post.create_uid.id != self._uid:
post.create_uid.sudo().add_karma(post.forum_id.karma_gen_answer_accepted * mult)
self.env.user.sudo().add_karma(post.forum_id.karma_gen_answer_accept * mult)
if any(key not in ['state', 'active', 'is_correct', 'closed_uid', 'closed_date', 'closed_reason_id'] for key in vals.keys()) and any(not post.can_edit for post in self):
raise KarmaError('Not enough karma to edit a post.')
res = super(Post, self).write(vals)
# if post content modify, notify followers
if 'content' in vals or 'name' in vals:
for post in self:
if post.parent_id:
body, subtype = _('Answer Edited'), 'website_forum.mt_answer_edit'
obj_id = post.parent_id
else:
body, subtype = _('Question Edited'), 'website_forum.mt_question_edit'
obj_id = post
obj_id.message_post(body=body, subtype=subtype)
return res
@api.multi
def post_notification(self):
base_url = self.env['ir.config_parameter'].get_param('web.base.url')
for post in self:
if post.state == 'active' and post.parent_id:
body = _(
'<p>A new answer for <i>%s</i> has been posted. <a href="%s/forum/%s/question/%s">Click here to access the post.</a></p>' %
(post.parent_id.name, base_url, slug(post.parent_id.forum_id), slug(post.parent_id))
)
post.parent_id.message_post(subject=_('Re: %s') % post.parent_id.name, body=body, subtype='website_forum.mt_answer_new')
elif post.state == 'active' and not post.parent_id:
body = _(
'<p>A new question <i>%s</i> has been asked on %s. <a href="%s/forum/%s/question/%s">Click here to access the question.</a></p>' %
(post.name, post.forum_id.name, base_url, slug(post.forum_id), slug(post))
)
post.message_post(subject=post.name, body=body, subtype='website_forum.mt_question_new')
elif post.state == 'pending' and not post.parent_id:
# TDE FIXME: in master, you should probably use a subtype;
# however here we remove subtype but set partner_ids
partners = post.sudo().message_partner_ids.filtered(lambda partner: partner.user_ids and partner.user_ids.karma >= post.forum_id.karma_moderate)
note_subtype = self.sudo().env.ref('mail.mt_note')
body = _(
'<p>A new question <i>%s</i> has been asked on %s and require your validation. <a href="%s/forum/%s/question/%s">Click here to access the question.</a></p>' %
(post.name, post.forum_id.name, base_url, slug(post.forum_id), slug(post))
)
post.message_post(subject=post.name, body=body, subtype_id=note_subtype.id, partner_ids=partners.ids)
return True
@api.multi
def reopen(self):
if any(post.parent_id or post.state != 'close' for post in self):
return False
reason_offensive = self.env.ref('website_forum.reason_7')
reason_spam = self.env.ref('website_forum.reason_8')
for post in self:
if post.closed_reason_id in (reason_offensive, reason_spam):
_logger.info('Upvoting user <%s>, reopening spam/offensive question',
post.create_uid)
post.create_uid.sudo().add_karma(post.forum_id.karma_gen_answer_flagged * -1)
self.sudo().write({'state': 'active'})
@api.multi
def close(self, reason_id):
if any(post.parent_id for post in self):
return False
reason_offensive = self.env.ref('website_forum.reason_7').id
reason_spam = self.env.ref('website_forum.reason_8').id
if reason_id in (reason_offensive, reason_spam):
for post in self:
_logger.info('Downvoting user <%s> for posting spam/offensive contents',
post.create_uid)
post.create_uid.sudo().add_karma(post.forum_id.karma_gen_answer_flagged)
self.write({
'state': 'close',
'closed_uid': self._uid,
'closed_date': datetime.today().strftime(tools.DEFAULT_SERVER_DATETIME_FORMAT),
'closed_reason_id': reason_id,
})
return True
@api.one
def validate(self):
if not self.can_moderate:
raise KarmaError('Not enough karma to validate a post')
# if state == pending, no karma previously added for the new question
if self.state == 'pending':
self.create_uid.sudo().add_karma(self.forum_id.karma_gen_question_new)
self.write({
'state': 'active',
'active': True,
'moderator_id': self.env.user.id,
})
self.post_notification()
return True
@api.one
def refuse(self):
if not self.can_moderate:
raise KarmaError('Not enough karma to refuse a post')
self.moderator_id = self.env.user
return True
@api.one
def flag(self):
if not self.can_flag:
raise KarmaError('Not enough karma to flag a post')
if(self.state == 'flagged'):
return {'error': 'post_already_flagged'}
elif(self.state == 'active'):
self.write({
'state': 'flagged',
'flag_user_id': self.env.user.id,
})
return self.can_moderate and {'success': 'post_flagged_moderator'} or {'success': 'post_flagged_non_moderator'}
else:
return {'error': 'post_non_flaggable'}
@api.one
def mark_as_offensive(self, reason_id):
if not self.can_moderate:
raise KarmaError('Not enough karma to mark a post as offensive')
# remove some karma
_logger.info('Downvoting user <%s> for posting spam/offensive contents', self.create_uid)
self.create_uid.sudo().add_karma(self.forum_id.karma_gen_answer_flagged)
self.write({
'state': 'offensive',
'moderator_id': self.env.user.id,
'closed_date': datetime.today().strftime(tools.DEFAULT_SERVER_DATETIME_FORMAT),
'closed_reason_id': reason_id,
'active': False,
})
return True
@api.multi
def unlink(self):
if any(not post.can_unlink for post in self):
raise KarmaError('Not enough karma to unlink a post')
# if unlinking an answer with accepted answer: remove provided karma
for post in self:
if post.is_correct:
post.create_uid.sudo().add_karma(post.forum_id.karma_gen_answer_accepted * -1)
self.env.user.sudo().add_karma(post.forum_id.karma_gen_answer_accepted * -1)
return super(Post, self).unlink()
@api.multi
def bump(self):
""" Bump a question: trigger a write_date by writing on a dummy bump_date
field. One cannot bump a question more than once every 10 days. """
self.ensure_one()
if self.forum_id.allow_bump and not self.child_ids and (datetime.today() - datetime.strptime(self.write_date, tools.DEFAULT_SERVER_DATETIME_FORMAT)).days > 9:
# write through super to bypass karma; sudo to allow public user to bump any post
return self.sudo().write({'bump_date': fields.Datetime.now()})
return False
@api.multi
def vote(self, upvote=True):
Vote = self.env['forum.post.vote']
vote_ids = Vote.search([('post_id', 'in', self._ids), ('user_id', '=', self._uid)])
new_vote = '1' if upvote else '-1'
voted_forum_ids = set()
if vote_ids:
for vote in vote_ids:
if upvote:
new_vote = '0' if vote.vote == '-1' else '1'
else:
new_vote = '0' if vote.vote == '1' else '-1'
vote.vote = new_vote
voted_forum_ids.add(vote.post_id.id)
for post_id in set(self._ids) - voted_forum_ids:
for post_id in self._ids:
Vote.create({'post_id': post_id, 'vote': new_vote})
return {'vote_count': self.vote_count, 'user_vote': new_vote}
@api.one
def convert_answer_to_comment(self):
""" Tools to convert an answer (forum.post) to a comment (mail.message).
The original post is unlinked and a new comment is posted on the question
using the post create_uid as the comment's author. """
if not self.parent_id:
return False
# karma-based action check: use the post field that computed own/all value
if not self.can_comment_convert:
raise KarmaError('Not enough karma to convert an answer to a comment')
# post the message
question = self.parent_id
values = {
'author_id': self.sudo().create_uid.partner_id.id, # use sudo here because of access to res.users model
'body': tools.html_sanitize(self.content, strict=True, strip_style=True, strip_classes=True),
'message_type': 'comment',
'subtype': 'mail.mt_comment',
'date': self.create_date,
}
new_message = self.browse(question.id).with_context(mail_create_nosubscribe=True).message_post(**values)
# unlink the original answer, using SUPERUSER_ID to avoid karma issues
self.sudo().unlink()
return new_message
@api.model
def convert_comment_to_answer(self, message_id, default=None):
""" Tool to convert a comment (mail.message) into an answer (forum.post).
The original comment is unlinked and a new answer from the comment's author
is created. Nothing is done if the comment's author already answered the
question. """
comment = self.env['mail.message'].sudo().browse(message_id)
post = self.browse(comment.res_id)
if not comment.author_id or not comment.author_id.user_ids: # only comment posted by users can be converted
return False
# karma-based action check: must check the message's author to know if own / all
karma_convert = comment.author_id.id == self.env.user.partner_id.id and post.forum_id.karma_comment_convert_own or post.forum_id.karma_comment_convert_all
can_convert = self.env.user.karma >= karma_convert
if not can_convert:
raise KarmaError('Not enough karma to convert a comment to an answer')
# check the message's author has not already an answer
question = post.parent_id if post.parent_id else post
post_create_uid = comment.author_id.user_ids[0]
if any(answer.create_uid.id == post_create_uid.id for answer in question.child_ids):
return False
# create the new post
post_values = {
'forum_id': question.forum_id.id,
'content': comment.body,
'parent_id': question.id,
}
# done with the author user to have create_uid correctly set
new_post = self.sudo(post_create_uid.id).create(post_values)
# delete comment
comment.unlink()
return new_post
@api.one
def unlink_comment(self, message_id):
user = self.env.user
comment = self.env['mail.message'].sudo().browse(message_id)
if not comment.model == 'forum.post' or not comment.res_id == self.id:
return False
# karma-based action check: must check the message's author to know if own or all
karma_unlink = comment.author_id.id == user.partner_id.id and self.forum_id.karma_comment_unlink_own or self.forum_id.karma_comment_unlink_all
can_unlink = user.karma >= karma_unlink
if not can_unlink:
raise KarmaError('Not enough karma to unlink a comment')
return comment.unlink()
@api.multi
def set_viewed(self):
self._cr.execute("""UPDATE forum_post SET views = views+1 WHERE id IN %s""", (self._ids,))
return True
@api.multi
def get_access_action(self):
""" Override method that generated the link to access the document. Instead
of the classic form view, redirect to the post on the website directly """
self.ensure_one()
return {
'type': 'ir.actions.act_url',
'url': '/forum/%s/question/%s' % (self.forum_id.id, self.id),
'target': 'self',
'res_id': self.id,
}
@api.multi
def _notification_get_recipient_groups(self, message, recipients):
""" Override to set the access button: everyone can see an access button
on their notification email. It will lead on the website view of the
post. """
res = super(Post, self)._notification_get_recipient_groups(message, recipients)
access_action = self._notification_link_helper('view', model=message.model, res_id=message.res_id)
for category, data in res.iteritems():
res[category]['button_access'] = {'url': access_action, 'title': '%s %s' % (_('View'), self.post_type)}
return res
@api.cr_uid_ids_context
def message_post(self, cr, uid, thread_id, message_type='notification', subtype=None, context=None, **kwargs):
if thread_id and message_type == 'comment': # user comments have a restriction on karma
if isinstance(thread_id, (list, tuple)):
post_id = thread_id[0]
else:
post_id = thread_id
post = self.browse(cr, uid, post_id, context=context)
# TDE FIXME: trigger browse because otherwise the function field is not compted - check with RCO
tmp1, tmp2 = post.karma_comment, post.can_comment
user = self.pool['res.users'].browse(cr, uid, uid)
tmp3 = user.karma
# TDE END FIXME
if not post.can_comment:
raise KarmaError('Not enough karma to comment')
return super(Post, self).message_post(cr, uid, thread_id, message_type=message_type, subtype=subtype, context=context, **kwargs)
class Slide(models.Model):
""" This model represents actual presentations. Those must be one of four
types:
- Presentation
- Document
- Infographic
- Video
Slide has various statistics like view count, embed count, like, dislikes """
_name = 'slide.slide'
_inherit = [
'mail.thread', 'website.seo.metadata', 'website.published.mixin'
]
_description = 'Slides'
_PROMOTIONAL_FIELDS = [
'__last_update', 'name', 'image_thumb', 'image_medium', 'slide_type',
'total_views', 'category_id', 'channel_id', 'description', 'tag_ids',
'write_date', 'create_date', 'website_published', 'website_url',
'website_meta_title', 'website_meta_description',
'website_meta_keywords'
]
_sql_constraints = [('name_uniq', 'UNIQUE(channel_id, name)',
'The slide name must be unique within a channel')]
# description
name = fields.Char('Title', required=True, translate=True)
description = fields.Text('Description', translate=True)
channel_id = fields.Many2one('slide.channel',
string="Channel",
required=True)
category_id = fields.Many2one('slide.category',
string="Category",
domain="[('channel_id', '=', channel_id)]")
tag_ids = fields.Many2many('slide.tag',
'rel_slide_tag',
'slide_id',
'tag_id',
string='Tags')
download_security = fields.Selection([('none', 'No One'),
('user', 'Authentified Users Only'),
('public', 'Everyone')],
string='Download Security',
required=True,
default='user')
image = fields.Binary('Image', attachment=True)
image_medium = fields.Binary('Medium',
compute="_get_image",
store=True,
attachment=True)
image_thumb = fields.Binary('Thumbnail',
compute="_get_image",
store=True,
attachment=True)
@api.depends('image')
def _get_image(self):
for record in self:
if record.image:
record.image_medium = image.crop_image(record.image,
type='top',
ratio=(4, 3),
thumbnail_ratio=4)
record.image_thumb = image.crop_image(record.image,
type='top',
ratio=(4, 3),
thumbnail_ratio=6)
else:
record.image_medium = False
record.iamge_thumb = False
# content
slide_type = fields.Selection(
[('infographic', 'Infographic'), ('presentation', 'Presentation'),
('document', 'Document'), ('video', 'Video')],
string='Type',
required=True,
default='document',
help=
"Document type will be set automatically depending on file type, height and width."
)
index_content = fields.Text('Transcript')
datas = fields.Binary('Content')
url = fields.Char('Document URL', help="Youtube or Google Document URL")
document_id = fields.Char('Document ID',
help="Youtube or Google Document ID")
mime_type = fields.Char('Mime-type')
@api.onchange('url')
def on_change_url(self):
self.ensure_one()
if self.url:
res = self._parse_document_url(self.url)
if res.get('error'):
raise Warning(
_('Could not fetch data from url. Document or access right not available:\n%s'
) % res['error'])
values = res['values']
if not values.get('document_id'):
raise Warning(
_('Please enter valid Youtube or Google Doc URL'))
for key, value in values.iteritems():
setattr(self, key, value)
# website
date_published = fields.Datetime('Publish Date')
website_message_ids = fields.One2many(
'mail.message',
'res_id',
domain=lambda self: [('model', '=', self._name),
('message_type', '=', 'comment')],
string='Website Messages',
help="Website communication history")
likes = fields.Integer('Likes')
dislikes = fields.Integer('Dislikes')
# views
embedcount_ids = fields.One2many('slide.embed',
'slide_id',
string="Embed Count")
slide_views = fields.Integer('# of Website Views')
embed_views = fields.Integer('# of Embedded Views')
total_views = fields.Integer("Total # Views",
default="0",
compute='_compute_total',
store=True)
@api.depends('slide_views', 'embed_views')
def _compute_total(self):
for record in self:
record.total_views = record.slide_views + record.embed_views
embed_code = fields.Text('Embed Code',
readonly=True,
compute='_get_embed_code')
def _get_embed_code(self):
base_url = self.env['ir.config_parameter'].get_param('web.base.url')
for record in self:
if record.datas and not record.document_id:
record.embed_code = '<iframe src="%s/slides/embed/%s?page=1" allowFullScreen="true" height="%s" width="%s" frameborder="0"></iframe>' % (
base_url, record.id, 315, 420)
elif record.slide_type == 'video' and record.document_id:
if not record.mime_type:
# embed youtube video
record.embed_code = '<iframe src="//www.youtube.com/embed/%s?theme=light" allowFullScreen="true" frameborder="0"></iframe>' % (
record.document_id)
else:
# embed google doc video
record.embed_code = '<embed src="https://video.google.com/get_player?ps=docs&partnerid=30&docid=%s" type="application/x-shockwave-flash"></embed>' % (
record.document_id)
else:
record.embed_code = False
@api.multi
@api.depends('name')
def _website_url(self, name, arg):
res = super(Slide, self)._website_url(name, arg)
base_url = self.env['ir.config_parameter'].get_param('web.base.url')
#link_tracker is not in dependencies, so use it to shorten url only if installed.
if self.env.registry.get('link.tracker'):
LinkTracker = self.env['link.tracker']
res.update({(slide.id, LinkTracker.sudo().create({
'url':
'%s/slides/slide/%s' % (base_url, slug(slide))
}).short_url)
for slide in self})
else:
res.update({(slide.id,
'%s/slides/slide/%s' % (base_url, slug(slide)))
for slide in self})
return res
@api.model
def create(self, values):
if not values.get('index_content'):
values['index_content'] = values.get('description')
if values.get(
'slide_type') == 'infographic' and not values.get('image'):
values['image'] = values['datas']
if values.get(
'website_published') and not values.get('date_published'):
values['date_published'] = datetime.datetime.now()
if values.get('url'):
doc_data = self._parse_document_url(values['url']).get(
'values', dict())
for key, value in doc_data.iteritems():
values.setdefault(key, value)
# Do not publish slide if user has not publisher rights
if not self.user_has_groups('base.group_website_publisher'):
values['website_published'] = False
slide = super(Slide, self).create(values)
slide.channel_id.message_subscribe_users()
slide._post_publication()
return slide
@api.multi
def write(self, values):
if values.get('url'):
doc_data = self._parse_document_url(values['url']).get(
'values', dict())
for key, value in doc_data.iteritems():
values.setdefault(key, value)
res = super(Slide, self).write(values)
if values.get('website_published'):
self.date_published = datetime.datetime.now()
self._post_publication()
return res
@api.model
def check_field_access_rights(self, operation, fields):
""" As per channel access configuration (visibility)
- public ==> no restriction on slides access
- private ==> restrict all slides of channel based on access group defined on channel group_ids field
- partial ==> show channel, but presentations based on groups means any user can see channel but not slide's content.
For private: implement using record rule
For partial: user can see channel, but channel gridview have slide detail so we have to implement
partial field access mechanism for public user so he can have access of promotional field (name, view_count) of slides,
but not all fields like data (actual pdf content)
all fields should be accessible only for user group defined on channel group_ids
"""
if self.env.uid == SUPERUSER_ID:
return fields or list(self._fields)
fields = super(Slide,
self).check_field_access_rights(operation, fields)
# still read not perform so we can not access self.channel_id
if self.ids:
self.env.cr.execute(
'SELECT DISTINCT channel_id FROM ' + self._table +
' WHERE id IN %s', (tuple(self.ids), ))
channel_ids = [x[0] for x in self.env.cr.fetchall()]
channels = self.env['slide.channel'].sudo().browse(channel_ids)
limited_access = all(
channel.visibility == 'partial'
and not len(channel.group_ids & self.env.user.groups_id)
for channel in channels)
if limited_access:
fields = [
field for field in fields
if field in self._PROMOTIONAL_FIELDS
]
return fields
def get_related_slides(self, limit=20):
domain = [('website_published', '=', True),
('channel_id.visibility', '!=', 'private'),
('id', '!=', self.id)]
if self.category_id:
domain += [('category_id', '=', self.category_id.id)]
for record in self.search(domain, limit=limit):
yield record
def get_most_viewed_slides(self, limit=20):
for record in self.search([('website_published', '=', True),
('channel_id.visibility', '!=', 'private'),
('id', '!=', self.id)],
limit=limit,
order='total_views desc'):
yield record
def _post_publication(self):
base_url = self.env['ir.config_parameter'].get_param('web.base.url')
for slide in self.filtered(lambda slide: slide.website_published):
publish_template = slide.channel_id.publish_template_id
html_body = publish_template.with_context({
'base_url': base_url
}).render_template(publish_template.body_html, 'slide.slide',
slide.id)
slide.channel_id.message_post(
body=html_body,
subtype='website_slides.mt_channel_slide_published')
return True
@api.one
def send_share_email(self, email):
base_url = self.env['ir.config_parameter'].get_param('web.base.url')
return self.channel_id.share_template_id.with_context({
'email':
email,
'base_url':
base_url
}).send_mail(self.id)
# --------------------------------------------------
# Parsing methods
# --------------------------------------------------
@api.model
def _fetch_data(self, base_url, data, content_type=False):
result = {'values': dict()}
try:
if data:
base_url = base_url + '?%s' % urlencode(data)
req = urllib2.Request(base_url)
content = urllib2.urlopen(req).read()
if content_type == 'json':
result['values'] = json.loads(content)
elif content_type in ('image', 'pdf'):
result['values'] = content.encode('base64')
else:
result['values'] = content
except urllib2.HTTPError as e:
result['error'] = e.read()
e.close()
except urllib2.URLError as e:
result['error'] = e.reason
return result
def _find_document_data_from_url(self, url):
expr = re.compile(
r'^.*((youtu.be/)|(v/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#\&\?]*).*'
)
arg = expr.match(url)
document_id = arg and arg.group(7) or False
if document_id:
return ('youtube', document_id)
expr = re.compile(
r'(^https:\/\/docs.google.com|^https:\/\/drive.google.com).*\/d\/([^\/]*)'
)
arg = expr.match(url)
document_id = arg and arg.group(2) or False
if document_id:
return ('google', document_id)
return (None, False)
def _parse_document_url(self, url, only_preview_fields=False):
document_source, document_id = self._find_document_data_from_url(url)
if document_source and hasattr(self,
'_parse_%s_document' % document_source):
return getattr(self, '_parse_%s_document' % document_source)(
document_id, only_preview_fields)
return {'error': _('Unknown document')}
def _parse_youtube_document(self, document_id, only_preview_fields):
key = self.env['ir.config_parameter'].sudo().get_param(
'website_slides.google_app_key')
fetch_res = self._fetch_data(
'https://www.googleapis.com/youtube/v3/videos', {
'id': document_id,
'key': key,
'part': 'snippet',
'fields': 'items(id,snippet)'
}, 'json')
if fetch_res.get('error'):
return fetch_res
values = {'slide_type': 'video', 'document_id': document_id}
youtube_values = fetch_res['values'].get('items', list(dict()))[0]
if youtube_values.get('snippet'):
snippet = youtube_values['snippet']
if only_preview_fields:
values.update({
'url_src': snippet['thumbnails']['high']['url'],
'title': snippet['title'],
'description': snippet['description']
})
return values
values.update({
'name':
snippet['title'],
'image':
self._fetch_data(snippet['thumbnails']['high']['url'], {},
'image')['values'],
'description':
snippet['description'],
})
return {'values': values}
@api.model
def _parse_google_document(self, document_id, only_preview_fields):
def get_slide_type(vals):
# TDE FIXME: WTF ??
image = Image.open(io.BytesIO(vals['image'].decode('base64')))
width, height = image.size
if height > width:
return 'document'
else:
return 'presentation'
key = self.env['ir.config_parameter'].sudo().get_param(
'website_slides.google_app_key')
fetch_res = self._fetch_data(
'https://www.googleapis.com/drive/v2/files/%s' % document_id, {
'projection': 'BASIC',
'key': key
}, "json")
if fetch_res.get('error'):
return fetch_res
google_values = fetch_res['values']
if only_preview_fields:
return {
'url_src': google_values['thumbnailLink'],
'title': google_values['title'],
}
values = {
'name':
google_values['title'],
'image':
self._fetch_data(
google_values['thumbnailLink'].replace('=s220', ''), {},
'image')['values'],
'mime_type':
google_values['mimeType'],
'document_id':
document_id,
}
if google_values['mimeType'].startswith('video/'):
values['slide_type'] = 'video'
elif google_values['mimeType'].startswith('image/'):
values['datas'] = values['image']
values['slide_type'] = 'infographic'
elif google_values['mimeType'].startswith(
'application/vnd.google-apps'):
values['datas'] = self._fetch_data(
google_values['exportLinks']['application/pdf'], {},
'pdf')['values']
values['slide_type'] = get_slide_type(values)
if google_values['exportLinks'].get('text/plain'):
values['index_content'] = self._fetch_data(
google_values['exportLinks']['text/plain'], {})['values']
if google_values['exportLinks'].get('text/csv'):
values['index_content'] = self._fetch_data(
google_values['exportLinks']['text/csv'], {})['values']
elif google_values['mimeType'] == 'application/pdf':
# TODO: Google Drive PDF document doesn't provide plain text transcript
values['datas'] = self._fetch_data(google_values['webContentLink'],
{}, 'pdf')['values']
values['slide_type'] = get_slide_type(values)
return {'values': values}
class report_event_registration(models.Model):
"""Events Analysis"""
_name = "report.event.registration"
_order = 'event_date desc'
_auto = False
create_date = fields.Datetime('Creation Date', readonly=True)
event_date = fields.Datetime('Event Date', readonly=True)
event_id = fields.Many2one('event.event', 'Event', required=True)
draft_state = fields.Integer(' # No of Draft Registrations')
cancel_state = fields.Integer(' # No of Cancelled Registrations')
confirm_state = fields.Integer(' # No of Confirmed Registrations')
seats_max = fields.Integer('Max Seats')
nbevent = fields.Integer('Number of Events')
nbregistration = fields.Integer('Number of Registrations')
event_type_id = fields.Many2one('event.type', 'Event Type')
registration_state = fields.Selection([('draft', 'Draft'), ('confirm', 'Confirmed'), ('done', 'Attended'), ('cancel', 'Cancelled')], 'Registration State', readonly=True, required=True)
event_state = fields.Selection([('draft', 'Draft'), ('confirm', 'Confirmed'), ('done', 'Done'), ('cancel', 'Cancelled')], 'Event State', readonly=True, required=True)
user_id = fields.Many2one('res.users', 'Event Responsible', readonly=True)
name_registration = fields.Char('Participant / Contact Name', readonly=True)
company_id = fields.Many2one('res.company', 'Company', readonly=True)
def init(self, cr):
"""Initialize the sql view for the event registration """
tools.drop_view_if_exists(cr, 'report_event_registration')
# TOFIX this request won't select events that have no registration
cr.execute(""" CREATE VIEW report_event_registration AS (
SELECT
e.id::varchar || '/' || coalesce(r.id::varchar,'') AS id,
e.id AS event_id,
e.user_id AS user_id,
r.name AS name_registration,
r.create_date AS create_date,
e.company_id AS company_id,
e.date_begin AS event_date,
count(r.id) AS nbevent,
count(r.event_id) AS nbregistration,
CASE WHEN r.state IN ('draft') THEN count(r.event_id) ELSE 0 END AS draft_state,
CASE WHEN r.state IN ('open','done') THEN count(r.event_id) ELSE 0 END AS confirm_state,
CASE WHEN r.state IN ('cancel') THEN count(r.event_id) ELSE 0 END AS cancel_state,
e.event_type_id AS event_type_id,
e.seats_max AS seats_max,
e.state AS event_state,
r.state AS registration_state
FROM
event_event e
LEFT JOIN event_registration r ON (e.id=r.event_id)
GROUP BY
event_id,
r.id,
registration_state,
event_type_id,
e.id,
e.date_begin,
e.user_id,
event_state,
e.company_id,
e.seats_max,
name_registration
)
""")
class Users(models.Model):
_inherit = 'res.users'
def __init__(self, pool, cr):
init_res = super(Users, self).__init__(pool, cr)
self.SELF_WRITEABLE_FIELDS = list(
set(self.SELF_WRITEABLE_FIELDS + [
'country_id', 'city', 'website', 'website_description',
'website_published'
]))
return init_res
create_date = fields.Datetime('Create Date',
readonly=True,
copy=False,
select=True)
karma = fields.Integer('Karma', default=0)
badge_ids = fields.One2many('gamification.badge.user',
'user_id',
string='Badges',
copy=False)
gold_badge = fields.Integer('Gold badges count',
compute="_get_user_badge_level")
silver_badge = fields.Integer('Silver badges count',
compute="_get_user_badge_level")
bronze_badge = fields.Integer('Bronze badges count',
compute="_get_user_badge_level")
@api.multi
@api.depends('badge_ids')
def _get_user_badge_level(self):
""" Return total badge per level of users
TDE CLEANME: shouldn't check type is forum ? """
for user in self:
user.gold_badge = 0
user.silver_badge = 0
user.bronze_badge = 0
self.env.cr.execute(
"""
SELECT bu.user_id, b.level, count(1)
FROM gamification_badge_user bu, gamification_badge b
WHERE bu.user_id IN %s
AND bu.badge_id = b.id
AND b.level IS NOT NULL
GROUP BY bu.user_id, b.level
ORDER BY bu.user_id;
""", [tuple(self.ids)])
for (user_id, level, count) in self.env.cr.fetchall():
# levels are gold, silver, bronze but fields have _badge postfix
self.browse(user_id)['{}_badge'.format(level)] = count
@api.model
def _generate_forum_token(self, user_id, email):
"""Return a token for email validation. This token is valid for the day
and is a hash based on a (secret) uuid generated by the forum module,
the user_id, the email and currently the day (to be updated if necessary). """
forum_uuid = self.env['ir.config_parameter'].sudo().get_param(
'website_forum.uuid')
return hashlib.sha256(
'%s-%s-%s-%s' %
(datetime.now().replace(hour=0, minute=0, second=0, microsecond=0),
forum_uuid, user_id, email)).hexdigest()
@api.one
def send_forum_validation_email(self, forum_id=None):
if not self.email:
return False
token = self._generate_forum_token(self.id, self.email)
activation_template = self.env.ref('website_forum.validation_email')
if activation_template:
params = {'token': token, 'id': self.id, 'email': self.email}
if forum_id:
params['forum_id'] = forum_id
base_url = self.env['ir.config_parameter'].get_param(
'web.base.url')
token_url = base_url + '/forum/validate_email?%s' % urlencode(
params)
activation_template.sudo().with_context(
token_url=token_url).send_mail(self.id, force_send=True)
return True
@api.one
def process_forum_validation_token(self,
token,
email,
forum_id=None,
context=None):
validation_token = self._generate_forum_token(self.id, email)
if token == validation_token and self.karma == 0:
karma = 3
forum = None
if forum_id:
forum = self.env['forum.forum'].browse(forum_id)
else:
forum_ids = self.env['forum.forum'].search([], limit=1)
if forum_ids:
forum = forum_ids[0]
if forum:
# karma gained: karma to ask a question and have 2 downvotes
karma = forum.karma_ask + (-2 *
forum.karma_gen_question_downvote)
return self.write({'karma': karma})
return False
@api.multi
def add_karma(self, karma):
for user in self:
user.karma += karma
return True
@api.model
def get_serialised_gamification_summary(self, excluded_categories=None):
if isinstance(excluded_categories, list):
if 'forum' not in excluded_categories:
excluded_categories.append('forum')
else:
excluded_categories = ['forum']
return super(Users, self).get_serialised_gamification_summary(
excluded_categories=excluded_categories)
# Wrapper for call_kw with inherits
@api.multi
def open_website_url(self):
return self.mapped('partner_id').open_website_url()
class plm_relation(models.Model):
_name = 'mrp.bom'
_inherit = 'mrp.bom'
create_date = fields.Datetime(_('Creation Date'), readonly=True)
source_id = fields.Many2one('plm.document','name',ondelete='no action',readonly=True,help=_('This is the document object that declares this BoM.'))
type = fields.Selection([('normal',_('Normal BoM')),('phantom',_('Sets / Phantom')),('ebom',_('Engineering BoM')),('spbom',_('Spare BoM'))], _('BoM Type'), required=True, help=
_("Use a phantom bill of material in raw materials lines that have to be " \
"automatically computed on a production order and not one per level." \
"If you put \"Phantom/Set\" at the root level of a bill of material " \
"it is considered as a set or pack: the products are replaced by the components " \
"between the sale order to the picking without going through the production order." \
"the normal bom will generate one production order per bom level."))
weight_net = fields.Float('Weight',digits_compute=dp.get_precision(_('Stock Weight')), help=_("The BoM net weight in Kg."))
_defaults = {
'product_uom' : 1,
'weight_net' : 0.0,
}
def init(self, cr):
self._packed=[]
def _getinbom(self, cr, uid, pid, sid=False):
bomLType=self.pool.get('mrp.bom.line')
ids=bomLType.search(cr,uid,[('product_id','=',pid),('source_id','=',sid),('type','=','ebom')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('source_id','=',sid),('type','=','normal')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('source_id','=',False),('type','=','ebom')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('source_id','=',False),('type','=','normal')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('type','=','ebom')])
if not ids:
ids=bomLType.search(cr,uid,[('product_id','=',pid),('type','=','normal')])
return bomLType.browse(cr,uid,list(set(ids)),context=None)
def _getbom(self, cr, uid, pid, sid=False):
if sid==None:
sid=False
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('source_id','=',sid),('type','=','ebom')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('source_id','=',sid),('type','=','normal')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('source_id','=',False),('type','=','ebom')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('source_id','=',False),('type','=','normal')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('type','=','ebom')])
if not ids:
ids=self.search(cr,uid,[('product_tmpl_id','=',pid),('type','=','normal')])
return self.browse(cr,uid,list(set(ids)),context=None)
def getListIdsFromStructure(self, structure):
'''
Convert from [id1,[[id2,[]]]] to [id1,id2]
'''
outList = []
if isinstance(structure, (list, tuple)) and len(structure) == 2:
outList.append(structure[0])
for item in structure[1]:
outList.extend(self.getListIdsFromStructure(item))
return list(set(outList))
def _getpackdatas(self, cr, uid, relDatas):
prtDatas = {}
tmpids = self.getListIdsFromStructure(relDatas)
if len(tmpids)<1:
return prtDatas
compType=self.pool.get('product.product')
tmpDatas=compType.read(cr, uid, tmpids)
for tmpData in tmpDatas:
for keyData in tmpData.keys():
if tmpData[keyData]==None:
del tmpData[keyData]
prtDatas[str(tmpData['id'])]=tmpData
return prtDatas
def _getpackreldatas(self, cr, uid, relDatas, prtDatas):
relids={}
relationDatas={}
tmpids = self.getListIdsFromStructure(relDatas)
if len(tmpids)<1:
return prtDatas
for keyData in prtDatas.keys():
tmpData=prtDatas[keyData]
if len(tmpData['bom_ids'])>0:
relids[keyData]=tmpData['bom_ids'][0]
if len(relids)<1:
return relationDatas
for keyData in relids.keys():
relationDatas[keyData]=self.read(cr, uid, relids[keyData])
return relationDatas
def GetWhereUsed(self, cr, uid, ids, context=None):
"""
Return a list of all fathers of a Part (all levels)
"""
self._packed = []
relDatas = []
if len(ids) < 1:
return None
sid = False
if len(ids) > 1:
sid = ids[1]
oid = ids[0]
relDatas.append(oid)
relDatas.append(self._implodebom(cr, uid, self._getinbom(cr, uid, oid, sid)))
prtDatas = self._getpackdatas(cr, uid, relDatas)
return (relDatas, prtDatas, self._getpackreldatas(cr, uid, relDatas, prtDatas))
def GetExplose(self, cr, uid, ids, context=None):
"""
Returns a list of all children in a Bom (all levels)
"""
self._packed = []
# get all ids of the children product in structured way like [[id,childids]]
relDatas = [ids[0], self._explodebom(cr, uid, self._getbom(cr, uid, ids[0]), False)]
prtDatas = self._getpackdatas(cr, uid, relDatas)
return (relDatas, prtDatas, self._getpackreldatas(cr, uid, relDatas, prtDatas))
def _explodebom(self, cr, uid, bids, check=True):
"""
Explodes a bom entity ( check=False : all levels, check=True : one level )
"""
output = []
self._packed = []
for bid in bids:
for bom_line in bid.bom_line_ids:
if check and (bom_line.product_id.id in self._packed):
continue
innerids = self._explodebom(cr, uid, self._getbom(cr, uid, bom_line.product_id.product_tmpl_id.id), check)
self._packed.append(bom_line.product_id.id)
output.append([bom_line.product_id.id, innerids])
return(output)
def GetTmpltIdFromProductId(self, cr, uid, product_id=False):
if not product_id:
return False
tmplDict = self.pool.get('product.product').read(cr, uid, product_id, ['product_tmpl_id']) # tmplDict = {'product_tmpl_id': (tmpl_id, u'name'), 'id': product_product_id}
tmplTuple = tmplDict.get('product_tmpl_id', {})
if len(tmplTuple) == 2:
return tmplTuple[0]
def GetExploseSum(self, cr, uid, ids, context=None):
"""
Return a list of all children in a Bom taken once (all levels)
"""
self._packed = []
prodTmplId = self.GetTmpltIdFromProductId(cr, uid, ids[0])
bomId = self._getbom(cr, uid, prodTmplId)
explosedBomIds = self._explodebom(cr, uid, bomId, True)
relDatas = [ids[0], explosedBomIds]
prtDatas = self._getpackdatas(cr, uid, relDatas)
return (relDatas, prtDatas, self._getpackreldatas(cr, uid, relDatas, prtDatas))
def _implodebom(self, cr, uid, bomObjs):
"""
Execute implosion for a a bom object
"""
pids = []
for bomObj in bomObjs:
if not bomObj.bom_id:
continue
if bomObj.bom_id.id in self._packed:
continue
self._packed.append(bomObj.bom_id.id)
bomFthObj = self.browse(cr, uid, [bomObj.bom_id.id], context=None)
innerids = self._implodebom(cr, uid, self._getinbom(cr, uid, bomFthObj.product_id.id))
pids.append((bomFthObj.product_id.id, innerids))
return (pids)
def GetWhereUsedSum(self, cr, uid, ids, context=None):
"""
Return a list of all fathers of a Part (all levels)
"""
self._packed = []
relDatas = []
if len(ids) < 1:
return None
sid = False
if len(ids) > 1:
sid = ids[1]
oid = ids[0]
relDatas.append(oid)
bomId = self._getinbom(cr, uid, oid, sid)
relDatas.append(self._implodebom(cr, uid, bomId))
prtDatas = self._getpackdatas(cr, uid, relDatas)
return (relDatas, prtDatas, self._getpackreldatas(cr, uid, relDatas, prtDatas))
def GetExplodedBom(self, cr, uid, ids, level=0, currlevel=0):
"""
Return a list of all children in a Bom ( level = 0 one level only, level = 1 all levels)
"""
self._packed=[]
result=[]
if level==0 and currlevel>1:
return result
bomids=self.browse(cr, uid, ids)
for bomid in bomids:
for bom in bomid.bom_line_ids:
children=self.GetExplodedBom(cr, uid, [bom.id], level, currlevel+1)
result.extend(children)
if len(str(bomid.bom_id))>0:
result.append(bomid.id)
return result
def SaveStructure(self, cr, uid, relations, level=0, currlevel=0):
"""
Save EBom relations
"""
def cleanStructure(parentID=None,sourceID=None):
"""
Clean relations having sourceID
"""
if parentID==None or sourceID==None:
return None
objPart=self.pool.get('product.product').browse(cr,uid,parentID,context=None)
ids=self.search(cr,uid,[('product_id','=',objPart.id),('source_id','=',sourceID)])
self.unlink(cr,uid,ids) # Cleans mrp.bom
ids=self.search(cr,uid,[('product_tmpl_id','=',objPart.product_tmpl_id.id),('source_id','=',sourceID)])
self.unlink(cr,uid,ids) # Cleans mrp.bom
bomLType=self.pool.get('mrp.bom.line')
ids=bomLType.search(cr,uid,[('bom_id','=',parentID),('source_id','=',sourceID)])
bomLType.unlink(cr,uid,ids) # Cleans mrp.bom.line
def toCleanRelations(relations):
"""
Processes relations
"""
listedSource=[]
for parentName, parentID, tmpChildName, tmpChildID, sourceID, tempRelArgs in relations:
if (not(sourceID==None)) and (not(sourceID in listedSource)):
cleanStructure(parentID,sourceID)
listedSource.append(sourceID)
return False
def toCompute(parentName, relations):
"""
Processes relations
"""
sourceIDParent=None
sourceID=None
bomID=False
subRelations=[(a, b, c, d, e, f) for a, b, c, d, e, f in relations if a == parentName]
if len(subRelations)<1: # no relation to save
return None
parentName, parentID, tmpChildName, tmpChildID, sourceID, tempRelArgs=subRelations[0]
ids=self.search(cr,uid,[('product_id','=',parentID),('source_id','=',sourceID)])
if not ids:
bomID=saveParent(parentName, parentID, sourceID, kindBom='ebom')
for rel in subRelations:
#print "Save Relation ", rel
parentName, parentID, childName, childID, sourceID, relArgs=rel
if parentName == childName:
logging.error('toCompute : Father (%s) refers to himself' %(str(parentName)))
raise Exception(_('saveChild.toCompute : Father "%s" refers to himself' %(str(parentName))))
tmpBomId=saveChild(childName, childID, sourceID, bomID, kindBom='ebom', args=relArgs)
tmpBomId=toCompute(childName, relations)
self.RebaseProductWeight(cr, uid, bomID, self.RebaseBomWeight(cr, uid, bomID))
return bomID
def saveParent(name, partID, sourceID, kindBom=None, args=None):
"""
Saves the relation ( parent side in mrp.bom )
"""
try:
res={}
if kindBom!=None:
res['type']=kindBom
else:
res['type']='ebom'
objPart=self.pool.get('product.product').browse(cr,uid,partID,context=None)
res['product_tmpl_id']=objPart.product_tmpl_id.id
res['product_id']=partID
res['source_id']=sourceID
res['name']=name
if args!=None:
for arg in args:
res[str(arg)]=args[str(arg)]
if ('product_qty' in res):
if(type(res['product_qty'])!=types.FloatType) or (res['product_qty']<1e-6):
res['product_qty']=1.0
return self.create(cr, uid, res)
except:
logging.error("saveParent : unable to create a relation for part (%s) with source (%d) : %s." %(name,sourceID,str(args)))
raise AttributeError(_("saveParent : unable to create a relation for part (%s) with source (%d) : %s." %(name,sourceID,str(sys.exc_info()))))
def saveChild(name, partID, sourceID, bomID=None, kindBom=None, args=None):
"""
Saves the relation ( child side in mrp.bom.line )
"""
try:
res={}
if bomID!=None:
res['bom_id']=bomID
if kindBom!=None:
res['type']=kindBom
else:
res['type']='ebom'
res['product_id']=partID
res['source_id']=sourceID
res['name']=name
if args!=None:
for arg in args:
res[str(arg)]=args[str(arg)]
if ('product_qty' in res):
if(type(res['product_qty'])!=types.FloatType) or (res['product_qty']<1e-6):
res['product_qty']=1.0
return self.pool.get('mrp.bom.line').create(cr, uid, res)
except:
logging.error("saveChild : unable to create a relation for part (%s) with source (%d) : %s." %(name,sourceID,str(args)))
raise AttributeError(_("saveChild : unable to create a relation for part (%s) with source (%d) : %s." %(name,sourceID,str(sys.exc_info()))))
if len(relations)<1: # no relation to save
return False
parentName, parentID, childName, childID, sourceID, relArgs=relations[0]
toCleanRelations(relations)
tmpBomId=toCompute(parentName, relations)
return False
def _sumBomWeight(self, bomObj):
"""
Evaluates net weight for assembly, based on BoM object
"""
weight=0.0
for bom_line in bomObj.bom_line_ids:
weight+=(bom_line.product_qty * bom_line.product_id.product_tmpl_id.weight)
return weight
def RebaseWeight(self, cr, uid, parentID, sourceID=False, context=None):
"""
Evaluates net weight for assembly, based on product ID
"""
weight=0.0
values={}
if not(parentID==None) or parentID:
objPart=self.pool.get('product.product').browse(cr,uid,parentID,context=None)
for bomID in self._getbom(cr, uid, objPart.product_tmpl_id.id, sourceID):
weight=self._sumBomWeight(bomID)
values['weight']=weight
partType=self.pool.get(bomID.product_tmpl_id._inherit)
partType.write(cr,uid,[bomID.product_tmpl_id.id],values)
return weight
def RebaseProductWeight(self, cr, uid, parentBomID, weight=0.0):
"""
Evaluates net weight for assembly, based on product ID
"""
if not(parentBomID==None) or parentBomID:
bomObj=self.browse(cr,uid,parentBomID,context=None)
self.pool.get('product.product').write(cr,uid,[bomObj.product_id.id],{'weight': weight})
def RebaseBomWeight(self, cr, uid, bomID, context=None):
"""
Evaluates net weight for assembly, based on BoM ID
"""
weight=0.0
if bomID:
for bomId in self.browse(cr, uid, bomID, context):
weight=self._sumBomWeight(bomId)
super(plm_relation,self).write(cr, uid, [bomId.id], {'weight_net': weight}, context=context)
return weight
# Overridden methods for this entity
def write(self, cr, uid, ids, vals, check=True, context=None):
ret=super(plm_relation,self).write(cr, uid, ids, vals, context=context)
for bomId in self.browse(cr,uid,ids,context=None):
self.RebaseBomWeight(cr, uid, bomId.id, context=context)
return ret
def copy(self,cr,uid,oid,defaults={},context=None):
"""
Return new object copied (removing SourceID)
"""
newId=super(plm_relation,self).copy(cr,uid,oid,defaults,context=context)
if newId:
compType=self.pool.get('product.product')
bomLType=self.pool.get('mrp.bom.line')
newOid=self.browse(cr,uid,newId,context=context)
for bom_line in newOid.bom_line_ids:
lateRevIdC=compType.GetLatestIds(cr,uid,[(bom_line.product_id.product_tmpl_id.engineering_code,False,False)],context=context) # Get Latest revision of each Part
bomLType.write(cr,uid,[bom_line.id],{'source_id':False,'name':bom_line.product_id.product_tmpl_id.name,'product_id':lateRevIdC[0]},context=context)
self.write(cr,uid,[newId],{'source_id':False,'name':newOid.product_tmpl_id.name,},check=False,context=context)
return newId
class Applicant(models.Model):
_name = "hr.applicant"
_description = "Applicant"
_order = "priority desc, id desc"
_inherit = ['mail.thread', 'ir.needaction_mixin', 'utm.mixin']
_mail_mass_mailing = _('Applicants')
def _default_stage_id(self):
if self._context.get('default_job_id'):
ids = self.env['hr.recruitment.stage'].search([
('job_ids', '=', self._context['default_job_id']),
('fold', '=', False)
], order='sequence asc', limit=1).ids
if ids:
return ids[0]
return False
def _default_company_id(self):
company_id = False
if self._context.get('default_department_id'):
department = self.env['hr.department'].browse(self._context['default_department_id'])
company_id = department.company_id.id
if not company_id:
company_id = self.env['res.company']._company_default_get('hr.applicant')
return company_id
name = fields.Char("Subject / Application Name", required=True)
active = fields.Boolean("Active", default=True, help="If the active field is set to false, it will allow you to hide the case without removing it.")
description = fields.Text("Description")
email_from = fields.Char("Email", size=128, help="These people will receive email.")
email_cc = fields.Text("Watchers Emails", size=252,
help="These email addresses will be added to the CC field of all inbound and outbound emails for this record before being sent. Separate multiple email addresses with a comma")
probability = fields.Float("Probability")
partner_id = fields.Many2one('res.partner', "Contact")
create_date = fields.Datetime("Creation Date", readonly=True, select=True)
write_date = fields.Datetime("Update Date", readonly=True)
stage_id = fields.Many2one('hr.recruitment.stage', 'Stage', track_visibility='onchange',
domain="[('job_ids', '=', job_id)]", copy=False, select=1,
default=_default_stage_id)
last_stage_id = fields.Many2one('hr.recruitment.stage', "Last Stage",
help="Stage of the applicant before being in the current stage. Used for lost cases analysis.")
categ_ids = fields.Many2many('hr.applicant.category', string="Tags")
company_id = fields.Many2one('res.company', "Company", default=_default_company_id)
user_id = fields.Many2one('res.users', "Responsible", track_visibility="onchange", default=lambda self: self.env.uid)
date_closed = fields.Datetime("Closed", readonly=True, select=True)
date_open = fields.Datetime("Assigned", readonly=True, select=True)
date_last_stage_update = fields.Datetime("Last Stage Update", select=True, default=fields.Datetime.now)
date_action = fields.Date("Next Action Date")
title_action = fields.Char("Next Action", size=64)
priority = fields.Selection(AVAILABLE_PRIORITIES, "Appreciation", default='0')
job_id = fields.Many2one('hr.job', "Applied Job")
salary_proposed_extra = fields.Char("Proposed Salary Extra", help="Salary Proposed by the Organisation, extra advantages")
salary_expected_extra = fields.Char("Expected Salary Extra", help="Salary Expected by Applicant, extra advantages")
salary_proposed = fields.Float("Proposed Salary", help="Salary Proposed by the Organisation")
salary_expected = fields.Float("Expected Salary", help="Salary Expected by Applicant")
availability = fields.Date("Availability", help="The date at which the applicant will be available to start working")
partner_name = fields.Char("Applicant's Name")
partner_phone = fields.Char("Phone", size=32)
partner_mobile = fields.Char("Mobile", size=32)
type_id = fields.Many2one('hr.recruitment.degree', "Degree")
department_id = fields.Many2one('hr.department', "Department")
survey = fields.Many2one('survey.survey', related='job_id.survey_id', string="Survey") # TDE FIXME: rename to survey_id
response_id = fields.Many2one('survey.user_input', "Response", ondelete="set null", oldname="response")
reference = fields.Char("Referred By")
day_open = fields.Float(compute='_compute_day', string="Days to Open")
day_close = fields.Float(compute='_compute_day', string="Days to Close")
color = fields.Integer("Color Index", default=0)
emp_id = fields.Many2one('hr.employee', string="Employee", track_visibility="onchange", help="Employee linked to the applicant.")
user_email = fields.Char(related='user_id.email', type="char", string="User Email", readonly=True)
attachment_number = fields.Integer(compute='_get_attachment_number', string="Number of Attachments")
employee_name = fields.Char(related='emp_id.name', string="Employee Name")
attachment_ids = fields.One2many('ir.attachment', 'res_id', domain=[('res_model', '=', 'hr.applicant')], string='Attachments')
@api.depends('date_open', 'date_closed')
@api.one
def _compute_day(self):
if self.date_open:
date_create = datetime.strptime(self.create_date, tools.DEFAULT_SERVER_DATETIME_FORMAT)
date_open = datetime.strptime(self.date_open, tools.DEFAULT_SERVER_DATETIME_FORMAT)
self.day_open = (date_open - date_create).total_seconds() / (24.0 * 3600)
if self.date_closed:
date_create = datetime.strptime(self.create_date, tools.DEFAULT_SERVER_DATETIME_FORMAT)
date_closed = datetime.strptime(self.date_closed, tools.DEFAULT_SERVER_DATETIME_FORMAT)
self.day_close = (date_closed - date_create).total_seconds() / (24.0 * 3600)
@api.multi
def _get_attachment_number(self):
read_group_res = self.env['ir.attachment'].read_group(
[('res_model', '=', 'hr.applicant'), ('res_id', 'in', self.ids)],
['res_id'], ['res_id'])
attach_data = dict((res['res_id'], res['res_id_count']) for res in read_group_res)
for record in self:
record.attachment_number = attach_data.get(record.id, 0)
@api.model
def _read_group_stage_ids(self, ids, domain, read_group_order=None, access_rights_uid=None):
access_rights_uid = access_rights_uid or self.env.uid
Stage = self.env['hr.recruitment.stage']
order = Stage._order
# lame hack to allow reverting search, should just work in the trivial case
if read_group_order == 'stage_id desc':
order = "%s desc" % order
# retrieve job_id from the context and write the domain: ids + contextual columns (job or default)
job_id = self._context.get('default_job_id')
department_id = self._context.get('default_department_id')
search_domain = []
if job_id:
search_domain = [('job_ids', '=', job_id)]
if department_id:
if search_domain:
search_domain = ['|', ('job_ids.department_id', '=', department_id)] + search_domain
else:
search_domain = [('job_ids.department_id', '=', department_id)]
if self.ids:
if search_domain:
search_domain = ['|', ('id', 'in', self.ids)] + search_domain
else:
search_domain = [('id', 'in', self.ids)]
stage_ids = Stage._search(search_domain, order=order, access_rights_uid=access_rights_uid)
stages = Stage.sudo(access_rights_uid).browse(stage_ids)
result = stages.name_get()
# restore order of the search
result.sort(lambda x, y: cmp(stage_ids.index(x[0]), stage_ids.index(y[0])))
fold = {}
for stage in stages:
fold[stage.id] = stage.fold or False
return result, fold
_group_by_full = {
'stage_id': _read_group_stage_ids
}
@api.onchange('job_id')
def onchange_job_id(self):
vals = self._onchange_job_id_internal(self.job_id.id)
self.department_id = vals['value']['department_id']
self.user_id = vals['value']['user_id']
self.stage_id = vals['value']['stage_id']
def _onchange_job_id_internal(self, job_id):
department_id = False
user_id = False
stage_id = self.stage_id.id
if job_id:
job = self.env['hr.job'].browse(job_id)
department_id = job.department_id.id
user_id = job.user_id.id
if not self.stage_id:
stage_ids = self.env['hr.recruitment.stage'].search([
('job_ids', '=', job.id),
('fold', '=', False)
], order='sequence asc', limit=1).ids
stage_id = stage_ids[0] if stage_ids else False
return {'value': {
'department_id': department_id,
'user_id': user_id,
'stage_id': stage_id
}}
@api.onchange('partner_id')
def onchange_partner_id(self):
self.partner_phone = self.partner_id.phone
self.partner_mobile = self.partner_id.mobile
self.email_from = self.partner_id.email
@api.onchange('stage_id')
def onchange_stage_id(self):
vals = self._onchange_stage_id_internal(self.stage_id.id)
if vals['value'].get('date_closed'):
self.date_closed = vals['value']['date_closed']
def _onchange_stage_id_internal(self, stage_id):
if not stage_id:
return {'value': {}}
stage = self.env['hr.recruitment.stage'].browse(stage_id)
if stage.fold:
return {'value': {'date_closed': fields.datetime.now()}}
return {'value': {'date_closed': False}}
@api.model
def create(self, vals):
if vals.get('department_id') and not self._context.get('default_department_id'):
self = self.with_context(default_department_id=vals.get('department_id'))
if vals.get('job_id') or self._context.get('default_job_id'):
job_id = vals.get('job_id') or self._context.get('default_job_id')
for key, value in self._onchange_job_id_internal(job_id)['value'].iteritems():
if key not in vals:
vals[key] = value
if vals.get('user_id'):
vals['date_open'] = fields.Datetime.now()
if 'stage_id' in vals:
vals.update(self._onchange_stage_id_internal(vals.get('stage_id'))['value'])
return super(Applicant, self.with_context(mail_create_nolog=True)).create(vals)
@api.multi
def write(self, vals):
# user_id change: update date_open
if vals.get('user_id'):
vals['date_open'] = fields.Datetime.now()
# stage_id: track last stage before update
if 'stage_id' in vals:
vals['date_last_stage_update'] = fields.Datetime.now()
vals.update(self._onchange_stage_id_internal(vals.get('stage_id'))['value'])
for applicant in self:
vals['last_stage_id'] = applicant.stage_id.id
res = super(Applicant, self).write(vals)
else:
res = super(Applicant, self).write(vals)
# post processing: if stage changed, post a message in the chatter
if vals.get('stage_id'):
if self.stage_id.template_id:
self.message_post_with_template(self.stage_id.template_id.id, notify=True, composition_mode='mass_mail')
return res
@api.model
def get_empty_list_help(self, help):
return super(Applicant, self.with_context(empty_list_help_model='hr.job',
empty_list_help_id=self.env.context.get('default_job_id'),
empty_list_help_document_name=_("job applicants"))).get_empty_list_help(help)
@api.multi
def action_get_created_employee(self):
self.ensure_one()
action = self.env['ir.actions.act_window'].for_xml_id('hr', 'open_view_employee_list')
action['res_id'] = self.mapped('emp_id').ids[0]
return action
@api.multi
def action_makeMeeting(self):
""" This opens Meeting's calendar view to schedule meeting on current applicant
@return: Dictionary value for created Meeting view
"""
self.ensure_one()
partners = self.partner_id | self.user_id.partner_id | self.department_id.manager_id.user_id.partner_id
category = self.env.ref('hr_recruitment.categ_meet_interview')
res = self.env['ir.actions.act_window'].for_xml_id('calendar', 'action_calendar_event')
res['context'] = {
'search_default_partner_ids': self.partner_id.name,
'default_partner_ids': partners.ids,
'default_user_id': self.env.uid,
'default_name': self.name,
'default_categ_ids': category and [category.id] or False,
}
return res
@api.multi
def action_start_survey(self):
self.ensure_one()
# create a response and link it to this applicant
if not self.response_id:
response = self.env['survey.user_input'].create({'survey_id': self.survey.id, 'partner_id': self.partner_id.id})
self.response_id = response.id
else:
response = self.response_id
# grab the token of the response and start surveying
return self.survey.with_context(survey_token=response.token).action_start_survey()
@api.multi
def action_print_survey(self):
""" If response is available then print this response otherwise print survey form (print template of the survey) """
self.ensure_one()
if not self.response_id:
return self.survey.action_print_survey()
else:
response = self.response_id
return self.survey.with_context(survey_token=response.token).action_print_survey()
@api.multi
def action_get_attachment_tree_view(self):
attachment_action = self.env.ref('base.action_attachment')
action = attachment_action.read()[0]
action['context'] = {'default_res_model': self._name, 'default_res_id': self.ids[0]}
action['domain'] = str(['&', ('res_model', '=', self._name), ('res_id', 'in', self.ids)])
return action
@api.multi
def _track_subtype(self, init_values):
record = self[0]
if 'emp_id' in init_values and record.emp_id:
return 'hr_recruitment.mt_applicant_hired'
elif 'stage_id' in init_values and record.stage_id and record.stage_id.sequence <= 1:
return 'hr_recruitment.mt_applicant_new'
elif 'stage_id' in init_values and record.stage_id and record.stage_id.sequence > 1:
return 'hr_recruitment.mt_applicant_stage_changed'
return super(Applicant, self)._track_subtype(init_values)
@api.model
def message_get_reply_to(self, ids, default=None):
""" Override to get the reply_to of the parent project. """
applicants = self.sudo().browse(ids)
aliases = self.env['hr.job'].message_get_reply_to(applicants.mapped('job_id').ids, default=default)
return dict((applicant.id, aliases.get(applicant.job_id and applicant.job_id.id or 0, False)) for applicant in applicants)
@api.multi
def message_get_suggested_recipients(self):
recipients = super(Applicant, self).message_get_suggested_recipients()
for applicant in self:
if applicant.partner_id:
applicant._message_add_suggested_recipient(recipients, partner=applicant.partner_id, reason=_('Contact'))
elif applicant.email_from:
applicant._message_add_suggested_recipient(recipients, email=applicant.email_from, reason=_('Contact Email'))
return recipients
@api.model
def message_new(self, msg, custom_values=None):
""" Overrides mail_thread message_new that is called by the mailgateway
through message_process.
This override updates the document according to the email.
"""
val = msg.get('from').split('<')[0]
defaults = {
'name': msg.get('subject') or _("No Subject"),
'partner_name': val,
'email_from': msg.get('from'),
'email_cc': msg.get('cc'),
'user_id': False,
'partner_id': msg.get('author_id', False),
}
if msg.get('priority'):
defaults['priority'] = msg.get('priority')
if custom_values:
defaults.update(custom_values)
return super(Applicant, self).message_new(msg, custom_values=defaults)
@api.multi
def create_employee_from_applicant(self):
""" Create an hr.employee from the hr.applicants """
employee = False
for applicant in self:
address_id = contact_name = False
if applicant.partner_id:
address_id = applicant.partner_id.address_get(['contact'])['contact']
contact_name = applicant.partner_id.name_get()[0][1]
if applicant.job_id and (applicant.partner_name or contact_name):
applicant.job_id.write({'no_of_hired_employee': applicant.job_id.no_of_hired_employee + 1})
employee = self.env['hr.employee'].create({'name': applicant.partner_name or contact_name,
'job_id': applicant.job_id.id,
'address_home_id': address_id,
'department_id': applicant.department_id.id or False,
'address_id': applicant.company_id and applicant.company_id.partner_id and applicant.company_id.partner_id.id or False,
'work_email': applicant.department_id and applicant.department_id.company_id and applicant.department_id.company_id.email or False,
'work_phone': applicant.department_id and applicant.department_id.company_id and applicant.department_id.company_id.phone or False})
applicant.write({'emp_id': employee.id})
applicant.job_id.message_post(
body=_('New Employee %s Hired') % applicant.partner_name if applicant.partner_name else applicant.name,
subtype="hr_recruitment.mt_job_applicant_hired")
employee._broadcast_welcome()
else:
raise UserError(_('You must define an Applied Job and a Contact Name for this applicant.'))
employee_action = self.env.ref('hr.open_view_employee_list')
dict_act_window = employee_action.read([])[0]
if employee:
dict_act_window['res_id'] = employee.id
dict_act_window['view_mode'] = 'form,tree'
return dict_act_window
@api.multi
def archive_applicant(self):
self.write({'active': False})
@api.multi
def reset_applicant(self):
""" Reinsert the applicant into the recruitment pipe in the first stage"""
for applicant in self:
first_stage_obj = self.env['hr.recruitment.stage'].search([('job_ids', 'in', applicant.job_id.id)], order="sequence asc", limit=1)
applicant.write({'active': True, 'stage_id': first_stage_obj.id})
