Adrian Torres
679185f3e8
With this commit, all instances of errors being raised inside `BaseModel.unlink` overrides are moved into methods decorated with `api.ondelete` which is safer.
899 lines
42 KiB
Python
899 lines
42 KiB
Python
# -*- coding: utf-8 -*-
|
|
# Part of Odoo. See LICENSE file for full copyright and licensing details.
|
|
|
|
import base64
|
|
import datetime
|
|
import io
|
|
import re
|
|
import requests
|
|
import PyPDF2
|
|
import json
|
|
|
|
from dateutil.relativedelta import relativedelta
|
|
from PIL import Image
|
|
from werkzeug import urls
|
|
|
|
from odoo import api, fields, models, _
|
|
from odoo.addons.http_routing.models.ir_http import slug
|
|
from odoo.exceptions import Warning, UserError, AccessError
|
|
from odoo.http import request
|
|
from odoo.addons.http_routing.models.ir_http import url_for
|
|
from odoo.tools import sql
|
|
|
|
|
|
class SlidePartnerRelation(models.Model):
|
|
_name = 'slide.slide.partner'
|
|
_description = 'Slide / Partner decorated m2m'
|
|
_table = 'slide_slide_partner'
|
|
|
|
slide_id = fields.Many2one('slide.slide', ondelete="cascade", index=True, required=True)
|
|
channel_id = fields.Many2one(
|
|
'slide.channel', string="Channel",
|
|
related="slide_id.channel_id", store=True, index=True, ondelete='cascade')
|
|
partner_id = fields.Many2one('res.partner', index=True, required=True, ondelete='cascade')
|
|
vote = fields.Integer('Vote', default=0)
|
|
completed = fields.Boolean('Completed')
|
|
quiz_attempts_count = fields.Integer('Quiz attempts count', default=0)
|
|
|
|
@api.model_create_multi
|
|
def create(self, vals_list):
|
|
res = super().create(vals_list)
|
|
completed = res.filtered('completed')
|
|
if completed:
|
|
completed._set_completed_callback()
|
|
return res
|
|
|
|
def write(self, values):
|
|
res = super(SlidePartnerRelation, self).write(values)
|
|
if values.get('completed'):
|
|
self._set_completed_callback()
|
|
return res
|
|
|
|
def _set_completed_callback(self):
|
|
self.env['slide.channel.partner'].search([
|
|
('channel_id', 'in', self.channel_id.ids),
|
|
('partner_id', 'in', self.partner_id.ids),
|
|
])._recompute_completion()
|
|
|
|
|
|
class SlideLink(models.Model):
|
|
_name = 'slide.slide.link'
|
|
_description = "External URL for a particular slide"
|
|
|
|
slide_id = fields.Many2one('slide.slide', required=True, ondelete='cascade')
|
|
name = fields.Char('Title', required=True)
|
|
link = fields.Char('Link', required=True)
|
|
|
|
|
|
class SlideResource(models.Model):
|
|
_name = 'slide.slide.resource'
|
|
_description = "Additional resource for a particular slide"
|
|
|
|
slide_id = fields.Many2one('slide.slide', required=True, ondelete='cascade')
|
|
name = fields.Char('Name', required=True)
|
|
data = fields.Binary('Resource')
|
|
|
|
|
|
class EmbeddedSlide(models.Model):
|
|
""" Embedding in third party websites. Track view count, generate statistics. """
|
|
_name = 'slide.embed'
|
|
_description = 'Embedded Slides View Counter'
|
|
_rec_name = 'slide_id'
|
|
|
|
slide_id = fields.Many2one('slide.slide', string="Presentation", required=True, index=True)
|
|
url = fields.Char('Third Party Website URL', required=True)
|
|
count_views = fields.Integer('# Views', default=1)
|
|
|
|
def _add_embed_url(self, slide_id, url):
|
|
baseurl = urls.url_parse(url).netloc
|
|
if not baseurl:
|
|
return 0
|
|
embeds = self.search([('url', '=', baseurl), ('slide_id', '=', int(slide_id))], limit=1)
|
|
if embeds:
|
|
embeds.count_views += 1
|
|
else:
|
|
embeds = self.create({
|
|
'slide_id': slide_id,
|
|
'url': baseurl,
|
|
})
|
|
return embeds.count_views
|
|
|
|
|
|
class SlideTag(models.Model):
|
|
""" Tag to search slides accross channels. """
|
|
_name = 'slide.tag'
|
|
_description = 'Slide Tag'
|
|
|
|
name = fields.Char('Name', required=True, translate=True)
|
|
|
|
_sql_constraints = [
|
|
('slide_tag_unique', 'UNIQUE(name)', 'A tag must be unique!'),
|
|
]
|
|
|
|
|
|
class Slide(models.Model):
|
|
_name = 'slide.slide'
|
|
_inherit = [
|
|
'mail.thread',
|
|
'image.mixin',
|
|
'website.seo.metadata', 'website.published.mixin']
|
|
_description = 'Slides'
|
|
_mail_post_access = 'read'
|
|
_order_by_strategy = {
|
|
'sequence': 'sequence asc, id asc',
|
|
'most_viewed': 'total_views desc',
|
|
'most_voted': 'likes desc',
|
|
'latest': 'date_published desc',
|
|
}
|
|
_order = 'sequence asc, is_category asc, id asc'
|
|
|
|
# description
|
|
name = fields.Char('Title', required=True, translate=True)
|
|
active = fields.Boolean(default=True, tracking=100)
|
|
sequence = fields.Integer('Sequence', default=0)
|
|
user_id = fields.Many2one('res.users', string='Uploaded by', default=lambda self: self.env.uid)
|
|
description = fields.Text('Description', translate=True)
|
|
channel_id = fields.Many2one('slide.channel', string="Course", required=True)
|
|
tag_ids = fields.Many2many('slide.tag', 'rel_slide_tag', 'slide_id', 'tag_id', string='Tags')
|
|
is_preview = fields.Boolean('Allow Preview', default=False, help="The course is accessible by anyone : the users don't need to join the channel to access the content of the course.")
|
|
is_new_slide = fields.Boolean('Is New Slide', compute='_compute_is_new_slide')
|
|
completion_time = fields.Float('Duration', digits=(10, 4), help="The estimated completion time for this slide")
|
|
# Categories
|
|
is_category = fields.Boolean('Is a category', default=False)
|
|
category_id = fields.Many2one('slide.slide', string="Section", compute="_compute_category_id", store=True)
|
|
slide_ids = fields.One2many('slide.slide', "category_id", string="Slides")
|
|
# subscribers
|
|
partner_ids = fields.Many2many('res.partner', 'slide_slide_partner', 'slide_id', 'partner_id',
|
|
string='Subscribers', groups='website_slides.group_website_slides_officer', copy=False)
|
|
slide_partner_ids = fields.One2many('slide.slide.partner', 'slide_id', string='Subscribers information', groups='website_slides.group_website_slides_officer', copy=False)
|
|
user_membership_id = fields.Many2one(
|
|
'slide.slide.partner', string="Subscriber information", compute='_compute_user_membership_id', compute_sudo=False,
|
|
help="Subscriber information for the current logged in user")
|
|
# Quiz related fields
|
|
question_ids = fields.One2many("slide.question", "slide_id", string="Questions")
|
|
questions_count = fields.Integer(string="Numbers of Questions", compute='_compute_questions_count')
|
|
quiz_first_attempt_reward = fields.Integer("Reward: first attempt", default=10)
|
|
quiz_second_attempt_reward = fields.Integer("Reward: second attempt", default=7)
|
|
quiz_third_attempt_reward = fields.Integer("Reward: third attempt", default=5,)
|
|
quiz_fourth_attempt_reward = fields.Integer("Reward: every attempt after the third try", default=2)
|
|
# content
|
|
slide_type = fields.Selection([
|
|
('infographic', 'Infographic'),
|
|
('webpage', 'Web Page'),
|
|
('presentation', 'Presentation'),
|
|
('document', 'Document'),
|
|
('video', 'Video'),
|
|
('quiz', "Quiz")],
|
|
string='Type', required=True,
|
|
default='document',
|
|
help="The document type will be set automatically based on the document URL and properties (e.g. height and width for presentation and document).")
|
|
datas = fields.Binary('Content', attachment=True)
|
|
url = fields.Char('Document URL', help="Youtube or Google Document URL")
|
|
document_id = fields.Char('Document ID', help="Youtube or Google Document ID")
|
|
link_ids = fields.One2many('slide.slide.link', 'slide_id', string="External URL for this slide")
|
|
slide_resource_ids = fields.One2many('slide.slide.resource', 'slide_id', string="Additional Resource for this slide")
|
|
slide_resource_downloadable = fields.Boolean('Allow Download', default=True, help="Allow the user to download the content of the slide.")
|
|
mime_type = fields.Char('Mime-type')
|
|
html_content = fields.Html("HTML Content", help="Custom HTML content for slides of type 'Web Page'.", translate=True, sanitize_form=False)
|
|
# website
|
|
website_id = fields.Many2one(related='channel_id.website_id', readonly=True)
|
|
date_published = fields.Datetime('Publish Date', readonly=True, tracking=1)
|
|
likes = fields.Integer('Likes', compute='_compute_user_info', store=True, compute_sudo=False)
|
|
dislikes = fields.Integer('Dislikes', compute='_compute_user_info', store=True, compute_sudo=False)
|
|
user_vote = fields.Integer('User vote', compute='_compute_user_info', compute_sudo=False)
|
|
embed_code = fields.Text('Embed Code', readonly=True, compute='_compute_embed_code')
|
|
# views
|
|
embedcount_ids = fields.One2many('slide.embed', 'slide_id', string="Embed Count")
|
|
slide_views = fields.Integer('# of Website Views', store=True, compute="_compute_slide_views")
|
|
public_views = fields.Integer('# of Public Views', copy=False)
|
|
total_views = fields.Integer("Views", default="0", compute='_compute_total', store=True)
|
|
# comments
|
|
comments_count = fields.Integer('Number of comments', compute="_compute_comments_count")
|
|
# channel
|
|
channel_type = fields.Selection(related="channel_id.channel_type", string="Channel type")
|
|
channel_allow_comment = fields.Boolean(related="channel_id.allow_comment", string="Allows comment")
|
|
# Statistics in case the slide is a category
|
|
nbr_presentation = fields.Integer("Number of Presentations", compute='_compute_slides_statistics', store=True)
|
|
nbr_document = fields.Integer("Number of Documents", compute='_compute_slides_statistics', store=True)
|
|
nbr_video = fields.Integer("Number of Videos", compute='_compute_slides_statistics', store=True)
|
|
nbr_infographic = fields.Integer("Number of Infographics", compute='_compute_slides_statistics', store=True)
|
|
nbr_webpage = fields.Integer("Number of Webpages", compute='_compute_slides_statistics', store=True)
|
|
nbr_quiz = fields.Integer("Number of Quizs", compute="_compute_slides_statistics", store=True)
|
|
total_slides = fields.Integer(compute='_compute_slides_statistics', store=True)
|
|
|
|
_sql_constraints = [
|
|
('exclusion_html_content_and_url', "CHECK(html_content IS NULL OR url IS NULL)", "A slide is either filled with a document url or HTML content. Not both.")
|
|
]
|
|
|
|
@api.depends('date_published', 'is_published')
|
|
def _compute_is_new_slide(self):
|
|
for slide in self:
|
|
slide.is_new_slide = slide.date_published > fields.Datetime.now() - relativedelta(days=7) if slide.is_published else False
|
|
|
|
@api.depends('channel_id.slide_ids.is_category', 'channel_id.slide_ids.sequence')
|
|
def _compute_category_id(self):
|
|
""" Will take all the slides of the channel for which the index is higher
|
|
than the index of this category and lower than the index of the next category.
|
|
|
|
Lists are manually sorted because when adding a new browse record order
|
|
will not be correct as the added slide would actually end up at the
|
|
first place no matter its sequence."""
|
|
self.category_id = False # initialize whatever the state
|
|
|
|
channel_slides = {}
|
|
for slide in self:
|
|
if slide.channel_id.id not in channel_slides:
|
|
channel_slides[slide.channel_id.id] = slide.channel_id.slide_ids
|
|
|
|
for cid, slides in channel_slides.items():
|
|
current_category = self.env['slide.slide']
|
|
slide_list = list(slides)
|
|
slide_list.sort(key=lambda s: (s.sequence, not s.is_category))
|
|
for slide in slide_list:
|
|
if slide.is_category:
|
|
current_category = slide
|
|
elif slide.category_id != current_category:
|
|
slide.category_id = current_category.id
|
|
|
|
@api.depends('question_ids')
|
|
def _compute_questions_count(self):
|
|
for slide in self:
|
|
slide.questions_count = len(slide.question_ids)
|
|
|
|
@api.depends('website_message_ids.res_id', 'website_message_ids.model', 'website_message_ids.message_type')
|
|
def _compute_comments_count(self):
|
|
for slide in self:
|
|
slide.comments_count = len(slide.website_message_ids)
|
|
|
|
@api.depends('slide_views', 'public_views')
|
|
def _compute_total(self):
|
|
for record in self:
|
|
record.total_views = record.slide_views + record.public_views
|
|
|
|
@api.depends('slide_partner_ids.vote')
|
|
@api.depends_context('uid')
|
|
def _compute_user_info(self):
|
|
default_stats = {'likes': 0, 'dislikes': 0, 'user_vote': False}
|
|
|
|
if not self.ids:
|
|
self.update(default_stats)
|
|
return
|
|
|
|
slide_data = dict.fromkeys(self.ids, default_stats)
|
|
slide_partners = self.env['slide.slide.partner'].sudo().search([
|
|
('slide_id', 'in', self.ids)
|
|
])
|
|
for slide_partner in slide_partners:
|
|
if slide_partner.vote == 1:
|
|
slide_data[slide_partner.slide_id.id]['likes'] += 1
|
|
if slide_partner.partner_id == self.env.user.partner_id:
|
|
slide_data[slide_partner.slide_id.id]['user_vote'] = 1
|
|
elif slide_partner.vote == -1:
|
|
slide_data[slide_partner.slide_id.id]['dislikes'] += 1
|
|
if slide_partner.partner_id == self.env.user.partner_id:
|
|
slide_data[slide_partner.slide_id.id]['user_vote'] = -1
|
|
for slide in self:
|
|
slide.update(slide_data[slide.id])
|
|
|
|
@api.depends('slide_partner_ids.slide_id')
|
|
def _compute_slide_views(self):
|
|
# TODO awa: tried compute_sudo, for some reason it doesn't work in here...
|
|
read_group_res = self.env['slide.slide.partner'].sudo().read_group(
|
|
[('slide_id', 'in', self.ids)],
|
|
['slide_id'],
|
|
groupby=['slide_id']
|
|
)
|
|
mapped_data = dict((res['slide_id'][0], res['slide_id_count']) for res in read_group_res)
|
|
for slide in self:
|
|
slide.slide_views = mapped_data.get(slide.id, 0)
|
|
|
|
@api.depends('slide_ids.sequence', 'slide_ids.slide_type', 'slide_ids.is_published', 'slide_ids.is_category')
|
|
def _compute_slides_statistics(self):
|
|
# Do not use dict.fromkeys(self.ids, dict()) otherwise it will use the same dictionnary for all keys.
|
|
# Therefore, when updating the dict of one key, it updates the dict of all keys.
|
|
keys = ['nbr_%s' % slide_type for slide_type in self.env['slide.slide']._fields['slide_type'].get_values(self.env)]
|
|
default_vals = dict((key, 0) for key in keys + ['total_slides'])
|
|
|
|
res = self.env['slide.slide'].read_group(
|
|
[('is_published', '=', True), ('category_id', 'in', self.ids), ('is_category', '=', False)],
|
|
['category_id', 'slide_type'], ['category_id', 'slide_type'],
|
|
lazy=False)
|
|
|
|
type_stats = self._compute_slides_statistics_type(res)
|
|
|
|
for record in self:
|
|
record.update(type_stats.get(record._origin.id, default_vals))
|
|
|
|
def _compute_slides_statistics_type(self, read_group_res):
|
|
""" Compute statistics based on all existing slide types """
|
|
slide_types = self.env['slide.slide']._fields['slide_type'].get_values(self.env)
|
|
keys = ['nbr_%s' % slide_type for slide_type in slide_types]
|
|
result = dict((cid, dict((key, 0) for key in keys + ['total_slides'])) for cid in self.ids)
|
|
for res_group in read_group_res:
|
|
cid = res_group['category_id'][0]
|
|
slide_type = res_group.get('slide_type')
|
|
if slide_type:
|
|
slide_type_count = res_group.get('__count', 0)
|
|
result[cid]['nbr_%s' % slide_type] = slide_type_count
|
|
result[cid]['total_slides'] += slide_type_count
|
|
return result
|
|
|
|
@api.depends('slide_partner_ids.partner_id')
|
|
@api.depends('uid')
|
|
def _compute_user_membership_id(self):
|
|
slide_partners = self.env['slide.slide.partner'].sudo().search([
|
|
('slide_id', 'in', self.ids),
|
|
('partner_id', '=', self.env.user.partner_id.id),
|
|
])
|
|
|
|
for record in self:
|
|
record.user_membership_id = next(
|
|
(slide_partner for slide_partner in slide_partners if slide_partner.slide_id == record),
|
|
self.env['slide.slide.partner']
|
|
)
|
|
|
|
@api.depends('document_id', 'slide_type', 'mime_type')
|
|
def _compute_embed_code(self):
|
|
base_url = request and request.httprequest.url_root or self.env['ir.config_parameter'].sudo().get_param('web.base.url')
|
|
if base_url[-1] == '/':
|
|
base_url = base_url[:-1]
|
|
for record in self:
|
|
if record.datas and (not record.document_id or record.slide_type in ['document', 'presentation']):
|
|
slide_url = base_url + url_for('/slides/embed/%s?page=1' % record.id)
|
|
record.embed_code = '<iframe src="%s" class="o_wslides_iframe_viewer" allowFullScreen="true" height="%s" width="%s" frameborder="0"></iframe>' % (slide_url, 315, 420)
|
|
elif record.slide_type == 'video' and record.document_id:
|
|
if not record.mime_type:
|
|
# embed youtube video
|
|
query = urls.url_parse(record.url).query
|
|
query = query + '&theme=light' if query else 'theme=light'
|
|
record.embed_code = '<iframe src="//www.youtube-nocookie.com/embed/%s?%s" allowFullScreen="true" frameborder="0"></iframe>' % (record.document_id, query)
|
|
else:
|
|
# embed google doc video
|
|
record.embed_code = '<iframe src="//drive.google.com/file/d/%s/preview" allowFullScreen="true" frameborder="0"></iframe>' % (record.document_id)
|
|
else:
|
|
record.embed_code = False
|
|
|
|
@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(res.get('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.items():
|
|
self[key] = value
|
|
|
|
@api.onchange('datas')
|
|
def _on_change_datas(self):
|
|
""" For PDFs, we assume that it takes 5 minutes to read a page.
|
|
If the selected file is not a PDF, it is an image (You can
|
|
only upload PDF or Image file) then the slide_type is changed
|
|
into infographic and the uploaded dataS is transfered to the
|
|
image field. (It avoids the infinite loading in PDF viewer)"""
|
|
if self.datas:
|
|
data = base64.b64decode(self.datas)
|
|
if data.startswith(b'%PDF-'):
|
|
pdf = PyPDF2.PdfFileReader(io.BytesIO(data), overwriteWarnings=False)
|
|
self.completion_time = (5 * len(pdf.pages)) / 60
|
|
else:
|
|
self.slide_type = 'infographic'
|
|
self.image_1920 = self.datas
|
|
self.datas = None
|
|
|
|
@api.depends('name', 'channel_id.website_id.domain')
|
|
def _compute_website_url(self):
|
|
# TDE FIXME: clena this link.tracker strange stuff
|
|
super(Slide, self)._compute_website_url()
|
|
for slide in self:
|
|
if slide.id: # avoid to perform a slug on a not yet saved record in case of an onchange.
|
|
base_url = slide.channel_id.get_base_url()
|
|
# link_tracker is not in dependencies, so use it to shorten url only if installed.
|
|
if self.env.registry.get('link.tracker'):
|
|
url = self.env['link.tracker'].sudo().create({
|
|
'url': '%s/slides/slide/%s' % (base_url, slug(slide)),
|
|
'title': slide.name,
|
|
}).short_url
|
|
else:
|
|
url = '%s/slides/slide/%s' % (base_url, slug(slide))
|
|
slide.website_url = url
|
|
|
|
@api.depends('channel_id.can_publish')
|
|
def _compute_can_publish(self):
|
|
for record in self:
|
|
record.can_publish = record.channel_id.can_publish
|
|
|
|
@api.model
|
|
def _get_can_publish_error_message(self):
|
|
return _("Publishing is restricted to the responsible of training courses or members of the publisher group for documentation courses")
|
|
|
|
# ---------------------------------------------------------
|
|
# ORM Overrides
|
|
# ---------------------------------------------------------
|
|
|
|
@api.model
|
|
def create(self, values):
|
|
# Do not publish slide if user has not publisher rights
|
|
channel = self.env['slide.channel'].browse(values['channel_id'])
|
|
if not channel.can_publish:
|
|
# 'website_published' is handled by mixin
|
|
values['date_published'] = False
|
|
|
|
if values.get('slide_type') == 'infographic' and not values.get('image_1920'):
|
|
values['image_1920'] = values['datas']
|
|
if values.get('is_category'):
|
|
values['is_preview'] = True
|
|
values['is_published'] = True
|
|
if values.get('is_published') and not values.get('date_published'):
|
|
values['date_published'] = datetime.datetime.now()
|
|
if values.get('url') and not values.get('document_id'):
|
|
doc_data = self._parse_document_url(values['url']).get('values', dict())
|
|
for key, value in doc_data.items():
|
|
values.setdefault(key, value)
|
|
|
|
slide = super(Slide, self).create(values)
|
|
|
|
if slide.is_published and not slide.is_category:
|
|
slide._post_publication()
|
|
return slide
|
|
|
|
def write(self, values):
|
|
if values.get('url') and values['url'] != self.url:
|
|
doc_data = self._parse_document_url(values['url']).get('values', dict())
|
|
for key, value in doc_data.items():
|
|
values.setdefault(key, value)
|
|
if values.get('is_category'):
|
|
values['is_preview'] = True
|
|
values['is_published'] = True
|
|
|
|
res = super(Slide, self).write(values)
|
|
if values.get('is_published'):
|
|
self.date_published = datetime.datetime.now()
|
|
self._post_publication()
|
|
|
|
if 'is_published' in values or 'active' in values:
|
|
# if the slide is published/unpublished, recompute the completion for the partners
|
|
self.slide_partner_ids._set_completed_callback()
|
|
|
|
return res
|
|
|
|
@api.returns('self', lambda value: value.id)
|
|
def copy(self, default=None):
|
|
"""Sets the sequence to zero so that it always lands at the beginning
|
|
of the newly selected course as an uncategorized slide"""
|
|
rec = super(Slide, self).copy(default)
|
|
rec.sequence = 0
|
|
return rec
|
|
|
|
@api.ondelete(at_uninstall=False)
|
|
def _unlink_except_already_taken(self):
|
|
if self.question_ids and self.channel_id.channel_partner_ids:
|
|
raise UserError(_("People already took this quiz. To keep course progression it should not be deleted."))
|
|
|
|
def unlink(self):
|
|
for category in self.filtered(lambda slide: slide.is_category):
|
|
category.channel_id._move_category_slides(category, False)
|
|
super(Slide, self).unlink()
|
|
|
|
def toggle_active(self):
|
|
# archiving/unarchiving a channel does it on its slides, too
|
|
to_archive = self.filtered(lambda slide: slide.active)
|
|
res = super(Slide, self).toggle_active()
|
|
if to_archive:
|
|
to_archive.filtered(lambda slide: not slide.is_category).is_published = False
|
|
return res
|
|
|
|
# ---------------------------------------------------------
|
|
# Mail/Rating
|
|
# ---------------------------------------------------------
|
|
|
|
@api.returns('mail.message', lambda value: value.id)
|
|
def message_post(self, *, message_type='notification', **kwargs):
|
|
self.ensure_one()
|
|
if message_type == 'comment' and not self.channel_id.can_comment: # user comments have a restriction on karma
|
|
raise AccessError(_('Not enough karma to comment'))
|
|
return super(Slide, self).message_post(message_type=message_type, **kwargs)
|
|
|
|
def get_access_action(self, access_uid=None):
|
|
""" Instead of the classic form view, redirect to website if it is published. """
|
|
self.ensure_one()
|
|
if self.website_published:
|
|
return {
|
|
'type': 'ir.actions.act_url',
|
|
'url': '%s' % self.website_url,
|
|
'target': 'self',
|
|
'target_type': 'public',
|
|
'res_id': self.id,
|
|
}
|
|
return super(Slide, self).get_access_action(access_uid)
|
|
|
|
def _notify_get_groups(self):
|
|
""" Add access button to everyone if the document is active. """
|
|
groups = super(Slide, self)._notify_get_groups()
|
|
|
|
if self.website_published:
|
|
for group_name, group_method, group_data in groups:
|
|
group_data['has_button_access'] = True
|
|
|
|
return groups
|
|
|
|
# ---------------------------------------------------------
|
|
# Business Methods
|
|
# ---------------------------------------------------------
|
|
|
|
def _post_publication(self):
|
|
base_url = self.env['ir.config_parameter'].sudo().get_param('web.base.url')
|
|
for slide in self.filtered(lambda slide: slide.website_published and slide.channel_id.publish_template_id):
|
|
publish_template = slide.channel_id.publish_template_id
|
|
html_body = publish_template.with_context(base_url=base_url)._render_field('body_html', slide.ids)[slide.id]
|
|
subject = publish_template._render_field('subject', slide.ids)[slide.id]
|
|
# We want to use the 'reply_to' of the template if set. However, `mail.message` will check
|
|
# if the key 'reply_to' is in the kwargs before calling _get_reply_to. If the value is
|
|
# falsy, we don't include it in the 'message_post' call.
|
|
kwargs = {}
|
|
reply_to = publish_template._render_field('reply_to', slide.ids)[slide.id]
|
|
if reply_to:
|
|
kwargs['reply_to'] = reply_to
|
|
slide.channel_id.with_context(mail_create_nosubscribe=True).message_post(
|
|
subject=subject,
|
|
body=html_body,
|
|
subtype_xmlid='website_slides.mt_channel_slide_published',
|
|
email_layout_xmlid='mail.mail_notification_light',
|
|
**kwargs,
|
|
)
|
|
return True
|
|
|
|
def _generate_signed_token(self, partner_id):
|
|
""" Lazy generate the acces_token and return it signed by the given partner_id
|
|
:rtype tuple (string, int)
|
|
:return (signed_token, partner_id)
|
|
"""
|
|
if not self.access_token:
|
|
self.write({'access_token': self._default_access_token()})
|
|
return self._sign_token(partner_id)
|
|
|
|
def _send_share_email(self, email, fullscreen):
|
|
# TDE FIXME: template to check
|
|
mail_ids = []
|
|
base_url = self.env['ir.config_parameter'].sudo().get_param('web.base.url')
|
|
for record in self:
|
|
template = record.channel_id.share_template_id.with_context(
|
|
user=self.env.user,
|
|
email=email,
|
|
base_url=base_url,
|
|
fullscreen=fullscreen
|
|
)
|
|
email_values = {'email_to': email}
|
|
if self.env.user.has_group('base.group_portal'):
|
|
template = template.sudo()
|
|
email_values['email_from'] = self.env.company.catchall_formatted or self.env.company.email_formatted
|
|
|
|
mail_ids.append(template.send_mail(record.id, notif_layout='mail.mail_notification_light', email_values=email_values))
|
|
return mail_ids
|
|
|
|
def action_like(self):
|
|
self.check_access_rights('read')
|
|
self.check_access_rule('read')
|
|
return self._action_vote(upvote=True)
|
|
|
|
def action_dislike(self):
|
|
self.check_access_rights('read')
|
|
self.check_access_rule('read')
|
|
return self._action_vote(upvote=False)
|
|
|
|
def _action_vote(self, upvote=True):
|
|
""" Private implementation of voting. It does not check for any real access
|
|
rights; public methods should grant access before calling this method.
|
|
|
|
:param upvote: if True, is a like; if False, is a dislike
|
|
"""
|
|
self_sudo = self.sudo()
|
|
SlidePartnerSudo = self.env['slide.slide.partner'].sudo()
|
|
slide_partners = SlidePartnerSudo.search([
|
|
('slide_id', 'in', self.ids),
|
|
('partner_id', '=', self.env.user.partner_id.id)
|
|
])
|
|
slide_id = slide_partners.mapped('slide_id')
|
|
new_slides = self_sudo - slide_id
|
|
channel = slide_id.channel_id
|
|
karma_to_add = 0
|
|
|
|
for slide_partner in slide_partners:
|
|
if upvote:
|
|
new_vote = 0 if slide_partner.vote == -1 else 1
|
|
if slide_partner.vote != 1:
|
|
karma_to_add += channel.karma_gen_slide_vote
|
|
else:
|
|
new_vote = 0 if slide_partner.vote == 1 else -1
|
|
if slide_partner.vote != -1:
|
|
karma_to_add -= channel.karma_gen_slide_vote
|
|
slide_partner.vote = new_vote
|
|
|
|
for new_slide in new_slides:
|
|
new_vote = 1 if upvote else -1
|
|
new_slide.write({
|
|
'slide_partner_ids': [(0, 0, {'vote': new_vote, 'partner_id': self.env.user.partner_id.id})]
|
|
})
|
|
karma_to_add += new_slide.channel_id.karma_gen_slide_vote * (1 if upvote else -1)
|
|
|
|
if karma_to_add:
|
|
self.env.user.add_karma(karma_to_add)
|
|
|
|
def action_set_viewed(self, quiz_attempts_inc=False):
|
|
if any(not slide.channel_id.is_member for slide in self):
|
|
raise UserError(_('You cannot mark a slide as viewed if you are not among its members.'))
|
|
|
|
return bool(self._action_set_viewed(self.env.user.partner_id, quiz_attempts_inc=quiz_attempts_inc))
|
|
|
|
def _action_set_viewed(self, target_partner, quiz_attempts_inc=False):
|
|
self_sudo = self.sudo()
|
|
SlidePartnerSudo = self.env['slide.slide.partner'].sudo()
|
|
existing_sudo = SlidePartnerSudo.search([
|
|
('slide_id', 'in', self.ids),
|
|
('partner_id', '=', target_partner.id)
|
|
])
|
|
if quiz_attempts_inc and existing_sudo:
|
|
sql.increment_field_skiplock(existing_sudo, 'quiz_attempts_count')
|
|
SlidePartnerSudo.invalidate_cache(fnames=['quiz_attempts_count'], ids=existing_sudo.ids)
|
|
|
|
new_slides = self_sudo - existing_sudo.mapped('slide_id')
|
|
return SlidePartnerSudo.create([{
|
|
'slide_id': new_slide.id,
|
|
'channel_id': new_slide.channel_id.id,
|
|
'partner_id': target_partner.id,
|
|
'quiz_attempts_count': 1 if quiz_attempts_inc else 0,
|
|
'vote': 0} for new_slide in new_slides])
|
|
|
|
def action_set_completed(self):
|
|
if any(not slide.channel_id.is_member for slide in self):
|
|
raise UserError(_('You cannot mark a slide as completed if you are not among its members.'))
|
|
|
|
return self._action_set_completed(self.env.user.partner_id)
|
|
|
|
def _action_set_completed(self, target_partner):
|
|
self_sudo = self.sudo()
|
|
SlidePartnerSudo = self.env['slide.slide.partner'].sudo()
|
|
existing_sudo = SlidePartnerSudo.search([
|
|
('slide_id', 'in', self.ids),
|
|
('partner_id', '=', target_partner.id)
|
|
])
|
|
existing_sudo.write({'completed': True})
|
|
|
|
new_slides = self_sudo - existing_sudo.mapped('slide_id')
|
|
SlidePartnerSudo.create([{
|
|
'slide_id': new_slide.id,
|
|
'channel_id': new_slide.channel_id.id,
|
|
'partner_id': target_partner.id,
|
|
'vote': 0,
|
|
'completed': True} for new_slide in new_slides])
|
|
|
|
return True
|
|
|
|
def _action_set_quiz_done(self):
|
|
if any(not slide.channel_id.is_member for slide in self):
|
|
raise UserError(_('You cannot mark a slide quiz as completed if you are not among its members.'))
|
|
|
|
points = 0
|
|
for slide in self:
|
|
user_membership_sudo = slide.user_membership_id.sudo()
|
|
if not user_membership_sudo or user_membership_sudo.completed or not user_membership_sudo.quiz_attempts_count:
|
|
continue
|
|
|
|
gains = [slide.quiz_first_attempt_reward,
|
|
slide.quiz_second_attempt_reward,
|
|
slide.quiz_third_attempt_reward,
|
|
slide.quiz_fourth_attempt_reward]
|
|
points += gains[user_membership_sudo.quiz_attempts_count - 1] if user_membership_sudo.quiz_attempts_count <= len(gains) else gains[-1]
|
|
|
|
return self.env.user.sudo().add_karma(points)
|
|
|
|
def _compute_quiz_info(self, target_partner, quiz_done=False):
|
|
result = dict.fromkeys(self.ids, False)
|
|
slide_partners = self.env['slide.slide.partner'].sudo().search([
|
|
('slide_id', 'in', self.ids),
|
|
('partner_id', '=', target_partner.id)
|
|
])
|
|
slide_partners_map = dict((sp.slide_id.id, sp) for sp in slide_partners)
|
|
for slide in self:
|
|
if not slide.question_ids:
|
|
gains = [0]
|
|
else:
|
|
gains = [slide.quiz_first_attempt_reward,
|
|
slide.quiz_second_attempt_reward,
|
|
slide.quiz_third_attempt_reward,
|
|
slide.quiz_fourth_attempt_reward]
|
|
result[slide.id] = {
|
|
'quiz_karma_max': gains[0], # what could be gained if succeed at first try
|
|
'quiz_karma_gain': gains[0], # what would be gained at next test
|
|
'quiz_karma_won': 0, # what has been gained
|
|
'quiz_attempts_count': 0, # number of attempts
|
|
}
|
|
slide_partner = slide_partners_map.get(slide.id)
|
|
if slide.question_ids and slide_partner:
|
|
if slide_partner.quiz_attempts_count:
|
|
result[slide.id]['quiz_karma_gain'] = gains[slide_partner.quiz_attempts_count] if slide_partner.quiz_attempts_count < len(gains) else gains[-1]
|
|
result[slide.id]['quiz_attempts_count'] = slide_partner.quiz_attempts_count
|
|
if quiz_done or slide_partner.completed:
|
|
result[slide.id]['quiz_karma_won'] = gains[slide_partner.quiz_attempts_count-1] if slide_partner.quiz_attempts_count < len(gains) else gains[-1]
|
|
return result
|
|
|
|
# --------------------------------------------------
|
|
# Parsing methods
|
|
# --------------------------------------------------
|
|
|
|
@api.model
|
|
def _fetch_data(self, base_url, params, content_type=False):
|
|
result = {'values': dict()}
|
|
try:
|
|
response = requests.get(base_url, timeout=3, params=params)
|
|
response.raise_for_status()
|
|
if content_type == 'json':
|
|
result['values'] = response.json()
|
|
elif content_type in ('image', 'pdf'):
|
|
result['values'] = base64.b64encode(response.content)
|
|
else:
|
|
result['values'] = response.content
|
|
except requests.exceptions.HTTPError as e:
|
|
result['error'] = e.response.content
|
|
except requests.exceptions.ConnectionError as e:
|
|
result['error'] = str(e)
|
|
return result
|
|
|
|
def _find_document_data_from_url(self, url):
|
|
url_obj = urls.url_parse(url)
|
|
if url_obj.ascii_host == 'youtu.be':
|
|
return ('youtube', url_obj.path[1:] if url_obj.path else False)
|
|
elif url_obj.ascii_host in ('youtube.com', 'www.youtube.com', 'm.youtube.com', 'www.youtube-nocookie.com'):
|
|
v_query_value = url_obj.decode_query().get('v')
|
|
if v_query_value:
|
|
return ('youtube', v_query_value)
|
|
split_path = url_obj.path.split('/')
|
|
if len(split_path) >= 3 and split_path[1] in ('v', 'embed'):
|
|
return ('youtube', split_path[2])
|
|
|
|
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):
|
|
""" If we receive a duration (YT video), we use it to determine the slide duration.
|
|
The received duration is under a special format (e.g: PT1M21S15, meaning 1h 21m 15s). """
|
|
|
|
key = self.env['website'].get_current_website().website_slide_google_app_key
|
|
fetch_res = self._fetch_data('https://www.googleapis.com/youtube/v3/videos', {'id': document_id, 'key': key, 'part': 'snippet,contentDetails', 'fields': 'items(id,snippet,contentDetails)'}, 'json')
|
|
if fetch_res.get('error'):
|
|
return {'error': self._extract_google_error_message(fetch_res.get('error'))}
|
|
|
|
values = {'slide_type': 'video', 'document_id': document_id}
|
|
items = fetch_res['values'].get('items')
|
|
if not items:
|
|
return {'error': _('Please enter valid Youtube or Google Doc URL')}
|
|
youtube_values = items[0]
|
|
|
|
youtube_duration = youtube_values.get('contentDetails', {}).get('duration')
|
|
if youtube_duration:
|
|
parsed_duration = re.search(r'^PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?$', youtube_duration)
|
|
values['completion_time'] = (int(parsed_duration.group(1) or 0)) + \
|
|
(int(parsed_duration.group(2) or 0) / 60) + \
|
|
(int(parsed_duration.group(3) or 0) / 3600)
|
|
|
|
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_1920': self._fetch_data(snippet['thumbnails']['high']['url'], {}, 'image')['values'],
|
|
'description': snippet['description'],
|
|
'mime_type': False,
|
|
})
|
|
return {'values': values}
|
|
|
|
def _extract_google_error_message(self, error):
|
|
"""
|
|
See here for Google error format
|
|
https://developers.google.com/drive/api/v3/handle-errors
|
|
"""
|
|
try:
|
|
error = json.loads(error)
|
|
error = (error.get('error', {}).get('errors', []) or [{}])[0].get('reason')
|
|
except json.decoder.JSONDecodeError:
|
|
error = str(error)
|
|
|
|
if error == 'keyInvalid':
|
|
return _('Your Google API key is invalid, please update it in your settings.\nSettings > Website > Features > API Key')
|
|
|
|
return _('Could not fetch data from url. Document or access right not available:\n%s', error)
|
|
|
|
@api.model
|
|
def _parse_google_document(self, document_id, only_preview_fields):
|
|
def get_slide_type(vals):
|
|
# TDE FIXME: WTF ??
|
|
slide_type = 'presentation'
|
|
if vals.get('image_1920'):
|
|
image = Image.open(io.BytesIO(base64.b64decode(vals['image_1920'])))
|
|
width, height = image.size
|
|
if height > width:
|
|
return 'document'
|
|
return slide_type
|
|
|
|
# Google drive doesn't use a simple API key to access the data, but requires an access
|
|
# token. However, this token is generated in module google_drive, which is not in the
|
|
# dependencies of website_slides. We still keep the 'key' parameter just in case, but that
|
|
# is probably useless.
|
|
params = {}
|
|
params['projection'] = 'BASIC'
|
|
if 'google.drive.config' in self.env:
|
|
access_token = self.env['google.drive.config'].get_access_token()
|
|
if access_token:
|
|
params['access_token'] = access_token
|
|
if not params.get('access_token'):
|
|
params['key'] = self.env['website'].get_current_website().website_slide_google_app_key
|
|
|
|
fetch_res = self._fetch_data('https://www.googleapis.com/drive/v2/files/%s' % document_id, params, "json")
|
|
if fetch_res.get('error'):
|
|
return {'error': self._extract_google_error_message(fetch_res.get('error'))}
|
|
|
|
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_1920': 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_1920']
|
|
values['slide_type'] = 'infographic'
|
|
elif google_values['mimeType'].startswith('application/vnd.google-apps'):
|
|
values['slide_type'] = get_slide_type(values)
|
|
if 'exportLinks' in google_values:
|
|
values['datas'] = self._fetch_data(google_values['exportLinks']['application/pdf'], params, 'pdf')['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}
|
|
|
|
def _default_website_meta(self):
|
|
res = super(Slide, self)._default_website_meta()
|
|
res['default_opengraph']['og:title'] = res['default_twitter']['twitter:title'] = self.name
|
|
res['default_opengraph']['og:description'] = res['default_twitter']['twitter:description'] = self.description
|
|
res['default_opengraph']['og:image'] = res['default_twitter']['twitter:image'] = self.env['website'].image_url(self, 'image_1024')
|
|
res['default_meta_description'] = self.description
|
|
return res
|
|
|
|
# ---------------------------------------------------------
|
|
# Data / Misc
|
|
# ---------------------------------------------------------
|
|
|
|
def get_backend_menu_id(self):
|
|
return self.env.ref('website_slides.website_slides_menu_root').id
|