def post_create(self, forum, post_parent=None, post_type=None, **post):
if post_type == "question" and not post.get("post_name", ""):
return request.render(
"website.http_error",
{"status_code": _("Bad Request"), "status_message": _("Title should not be empty.")},
)
if post.get("content", "") == "<p><br></p>":
return werkzeug.utils.redirect(
"/forum/%s/question/%s?nocontent=1" % (slug(forum), post_parent and slug(post_parent))
)
post_tag_ids = forum._tag_to_write_vals(post.get("post_tags", ""))
if request.env.user.forum_waiting_posts_count:
return werkzeug.utils.redirect("/forum/%s/ask" % slug(forum))
new_question = request.env["forum.post"].create(
{
"forum_id": forum.id,
"name": post.get("post_name") or (post_parent and "Re: %s" % (post_parent.name or "")) or "",
"content": post.get("content", False),
"content_link": post.get("content_link", False),
"parent_id": post_parent and post_parent.id or False,
"tag_ids": post_tag_ids,
"post_type": post_parent and post_parent.post_type or post_type, # tde check in selection field
}
)
return werkzeug.utils.redirect(
"/forum/%s/question/%s" % (slug(forum), post_parent and slug(post_parent) or new_question.id)
)
def convert_answer_to_comment(self, forum, post, **kwarg):
question = post.parent_id
new_msg = post.convert_answer_to_comment()
if not new_msg:
return werkzeug.utils.redirect("/forum/%s" % slug(forum))
return werkzeug.utils.redirect("/forum/%s/question/%s" %
(slug(forum), slug(question)))
def question_edit_answer(self, forum, question, **kwargs):
for record in question.child_ids:
if record.create_uid.id == request.uid:
answer = record
break
return werkzeug.utils.redirect("/forum/%s/post/%s/edit" %
(slug(forum), slug(answer)))
def post_delete(self, forum, post, **kwargs):
question = post.parent_id
post.unlink()
if question:
werkzeug.utils.redirect("/forum/%s/question/%s" %
(slug(forum), slug(question)))
return werkzeug.utils.redirect("/forum/%s" % slug(forum))
def convert_comment_to_answer(self, forum, post, comment, **kwarg):
post = request.env['forum.post'].convert_comment_to_answer(comment.id)
if not post:
return werkzeug.utils.redirect("/forum/%s" % slug(forum))
question = post.parent_id if post.parent_id else post
return werkzeug.utils.redirect("/forum/%s/question/%s" %
(slug(forum), slug(question)))
def question(self, forum, question, **post):
# Hide posts from abusers (negative karma), except for moderators
if not question.can_view:
raise werkzeug.exceptions.NotFound()
# Hide pending posts from non-moderators and non-creator
user = request.env.user
if question.state == 'pending' and user.karma < forum.karma_post and question.create_uid != user:
raise werkzeug.exceptions.NotFound()
# increment view counter
question.sudo().set_viewed()
if question.parent_id:
redirect_url = "/forum/%s/question/%s" % (slug(forum), slug(question.parent_id))
return werkzeug.utils.redirect(redirect_url, 301)
filters = 'question'
values = self._prepare_forum_values(forum=forum, searches=post)
values.update({
'main_object': question,
'question': question,
'can_bump': (question.forum_id.allow_bump and not question.child_ids and (datetime.today() - datetime.strptime(question.write_date, tools.DEFAULT_SERVER_DATETIME_FORMAT)).days > 9),
'header': {'question_data': True},
'filters': filters,
'reversed': reversed,
})
return request.render("website_forum.post_description_full", values)
def questions(self, forum, tag=None, page=1, filters='all', sorting=None, search='', post_type=None, **post):
Post = request.env['forum.post']
domain = [('forum_id', '=', forum.id), ('parent_id', '=', False), ('state', '=', 'active')]
if search:
domain += ['|', ('name', 'ilike', search), ('content', 'ilike', search)]
if tag:
domain += [('tag_ids', 'in', tag.id)]
if filters == 'unanswered':
domain += [('child_ids', '=', False)]
elif filters == 'followed':
domain += [('message_partner_ids', '=', request.env.user.partner_id.id)]
if post_type:
domain += [('post_type', '=', post_type)]
if sorting:
# check that sorting is valid
# retro-compatibily for V8 and google links
try:
Post._generate_order_by(sorting, None)
except ValueError:
sorting = False
if not sorting:
sorting = forum.default_order
question_count = Post.search_count(domain)
if tag:
url = "/forum/%s/tag/%s/questions" % (slug(forum), slug(tag))
else:
url = "/forum/%s" % slug(forum)
url_args = {
'sorting': sorting
}
if search:
url_args['search'] = search
if filters:
url_args['filters'] = filters
pager = request.website.pager(url=url, total=question_count, page=page,
step=self._post_per_page, scope=self._post_per_page,
url_args=url_args)
question_ids = Post.search(domain, limit=self._post_per_page, offset=pager['offset'], order=sorting)
values = self._prepare_forum_values(forum=forum, searches=post)
values.update({
'main_object': tag or forum,
'question_ids': question_ids,
'question_count': question_count,
'pager': pager,
'tag': tag,
'filters': filters,
'sorting': sorting,
'search': search,
'post_type': post_type,
})
return request.render("website_forum.forum_index", values)
def _compute_survey_url(self):
""" Computes a public URL for the survey """
base_url = '/' if self.env.context.get('relative_url') else self.env['ir.config_parameter'].get_param('web.base.url')
for survey in self:
survey.public_url = urljoin(base_url, "survey/start/%s" % (slug(survey)))
survey.print_url = urljoin(base_url, "survey/print/%s" % (slug(survey)))
survey.result_url = urljoin(base_url, "survey/results/%s" % (slug(survey)))
survey.public_url_html = '<a href="%s">%s</a>' % (survey.public_url, _("Click here to start survey"))
def post_accept(self, forum, post):
url = "/forum/%s/validation_queue" % (slug(forum))
if post.state == 'flagged':
url = "/forum/%s/flagged_queue" % (slug(forum))
elif post.state == 'offensive':
url = "/forum/%s/offensive_posts" % (slug(forum))
post.validate()
return werkzeug.utils.redirect(url)
def _compute_survey_url(self):
""" Computes a public URL for the survey """
base_url = '/' if self.env.context.get('relative_url') else self.env['ir.config_parameter'].get_param('web.base.url')
for survey in self:
survey.public_url = urljoin(base_url, "survey/start/%s" % (slug(survey)))
survey.print_url = urljoin(base_url, "survey/print/%s" % (slug(survey)))
survey.result_url = urljoin(base_url, "survey/results/%s" % (slug(survey)))
survey.public_url_html = '<a href="%s">%s</a>' % (survey.public_url, _("Click here to start survey"))
def post_mark_as_offensive(self, forum, post, **kwargs):
post.mark_as_offensive(reason_id=int(kwargs.get('reason_id', False)))
url = ''
if post.parent_id:
url = "/forum/%s/question/%s/#answer-%s" % (slug(forum), post.parent_id.id, post.id)
else:
url = "/forum/%s/question/%s" % (slug(forum), slug(post))
return werkzeug.utils.redirect(url)
def post_accept(self, forum, post):
url = "/forum/%s/validation_queue" % (slug(forum))
if post.state == 'flagged':
url = "/forum/%s/flagged_queue" % (slug(forum))
elif post.state == 'offensive':
url = "/forum/%s/offensive_posts" % (slug(forum))
post.validate()
return werkzeug.utils.redirect(url)
def _website_url(self, field_name, arg):
res = super(Track, self)._website_url(field_name, arg)
res.update({
(track.id,
'/event/%s/track/%s' % (slug(track.event_id), slug(track)))
for track in self
})
return res
def post_comment(self, forum, post, **kwargs):
question = post.parent_id if post.parent_id else post
if kwargs.get("comment") and post.forum_id.id == forum.id:
# TDE FIXME: check that post_id is the question or one of its answers
body = tools.mail.plaintext2html(kwargs["comment"])
post.with_context(mail_create_nosubscribe=True).message_post(
body=body, message_type="comment", subtype="mt_comment"
)
return werkzeug.utils.redirect("/forum/%s/question/%s" % (slug(forum), slug(question)))
def open_partner(self, forum, partner_id=0, **post):
if partner_id:
partner = request.env['res.partner'].sudo().search([('id', '=',
partner_id)])
if partner and partner.user_ids:
return werkzeug.utils.redirect(
"/forum/%s/user/%d" %
(slug(forum), partner.user_ids[0].id))
return werkzeug.utils.redirect("/forum/%s" % slug(forum))
def post_comment(self, forum, post, **kwargs):
question = post.parent_id if post.parent_id else post
if kwargs.get('comment') and post.forum_id.id == forum.id:
# TDE FIXME: check that post_id is the question or one of its answers
body = tools.mail.plaintext2html(kwargs['comment'])
post.with_context(mail_create_nosubscribe=True).message_post(
body=body, message_type='comment', subtype='mt_comment')
return werkzeug.utils.redirect("/forum/%s/question/%s" %
(slug(forum), slug(question)))
def _get_new_menu_pages(self):
self.ensure_one()
result = super(Event, self)._get_new_menu_pages()
if self.show_tracks:
result.append((_('Talks'), '/event/%s/track' % slug(self)))
result.append((_('Agenda'), '/event/%s/agenda' % slug(self)))
if self.show_track_proposal:
result.append((_('Talk Proposals'), '/event/%s/track_proposal' % slug(self)))
return result
def _get_new_menu_pages(self):
self.ensure_one()
result = super(Event, self)._get_new_menu_pages()
if self.show_tracks:
result.append((_("Talks"), "/event/%s/track" % slug(self)))
result.append((_("Agenda"), "/event/%s/agenda" % slug(self)))
if self.show_track_proposal:
result.append((_("Talk Proposals"), "/event/%s/track_proposal" % slug(self)))
return result
def forum_create(self, forum_name="New Forum", add_menu=False):
forum_id = request.env['forum.forum'].create({'name': forum_name})
if add_menu:
request.env['website.menu'].create({
'name': forum_name,
'url': "/forum/%s" % slug(forum_id),
'parent_id': request.website.menu_id.id,
'website_id': request.website.id,
})
return request.redirect("/forum/%s" % slug(forum_id))
def blog_post_create(self, blog_id, **post):
new_blog_post = request.env['blog.post'].create({
'blog_id':
blog_id,
'website_published':
False,
})
return werkzeug.utils.redirect(
"/blog/%s/post/%s?enable_editor=1" %
(slug(new_blog_post.blog_id), slug(new_blog_post)))
def _get_menu_entries(self):
self.ensure_one()
res = super(Event, self)._get_menu_entries()
if self.website_track:
res += [
(_('Talks'), '/event/%s/track' % slug(self), False),
(_('Agenda'), '/event/%s/agenda' % slug(self), False)]
if self.website_track_proposal:
res += [(_('Talk Proposals'), '/event/%s/track_proposal' % slug(self), False)]
return res
def forum_post(self, forum, post_type=None, **post):
user = request.env.user
if post_type not in ["question", "link", "discussion"]: # fixme: make dynamic
return werkzeug.utils.redirect("/forum/%s" % slug(forum))
if not user.email or not tools.single_email_re.match(user.email):
return werkzeug.utils.redirect(
"/forum/%s/user/%s/edit?email_required=1" % (slug(forum), request.session.uid)
)
values = self._prepare_forum_values(forum=forum, searches={}, header={"ask_hide": True})
return request.render("website_forum.new_%s" % post_type, values)
def blog_post_copy(self, blog_post_id, **post):
""" Duplicate a blog.
:param blog_post_id: id of the blog post currently browsed.
:return redirect to the new blog created
"""
new_blog_post = request.env["blog.post"].with_context(mail_create_nosubscribe=True).copy(int(blog_post_id), {})
return werkzeug.utils.redirect(
"/blog/%s/post/%s?enable_editor=1" % (slug(new_blog_post.blog_id), slug(new_blog_post))
)
def help_page_create(self, group_id, **post):
"""Add new help page via content menu"""
help_page = request.env['website.support.help.page'].create({
'group_id':
group_id,
'name':
"New Help Page"
})
return werkzeug.utils.redirect(
"/support/help/%s/%s?enable_editor=1" %
(slug(help_page.group_id), slug(help_page)))
def blog_post_copy(self, blog_post_id, **post):
""" Duplicate a blog.
:param blog_post_id: id of the blog post currently browsed.
:return redirect to the new blog created
"""
new_blog_post = request.env['blog.post'].with_context(
mail_create_nosubscribe=True).browse(int(blog_post_id)).copy()
return werkzeug.utils.redirect(
"/blog/%s/post/%s?enable_editor=1" %
(slug(new_blog_post.blog_id), slug(new_blog_post)))
def _get_new_menu_pages(self):
""" Retuns a list of tuple ('Page name', 'relative page url') for the event """
self.ensure_one()
todo = [(_("Introduction"), "website_event.template_intro"), (_("Location"), "website_event.template_location")]
result = []
for name, path in todo:
complete_name = name + " " + self.name
newpath = self.env["website"].new_page(complete_name, path, ispage=False)
url = "/event/" + slug(self) + "/page/" + newpath
result.append((name, url))
result.append((_("Register"), "/event/%s/register" % slug(self)))
return result
def forum_create(self, forum_name="New Forum", add_menu=False):
forum_id = request.env["forum.forum"].create({"name": forum_name})
if add_menu:
request.env["website.menu"].create(
{
"name": forum_name,
"url": "/forum/%s" % slug(forum_id),
"parent_id": request.website.menu_id.id,
"website_id": request.website.id,
}
)
return request.redirect("/forum/%s" % slug(forum_id))
def forum_post(self, forum, post_type=None, **post):
user = request.env.user
if post_type not in ['question', 'link',
'discussion']: # fixme: make dynamic
return werkzeug.utils.redirect('/forum/%s' % slug(forum))
if not user.email or not tools.single_email_re.match(user.email):
return werkzeug.utils.redirect(
"/forum/%s/user/%s/edit?email_required=1" %
(slug(forum), request.session.uid))
values = self._prepare_forum_values(forum=forum,
searches={},
header={'ask_hide': True})
return request.render("website_forum.new_%s" % post_type, values)
def post_save(self, forum, post, **kwargs):
if 'post_name' in kwargs and not kwargs.get('post_name').strip():
return request.render('website.http_error', {'status_code': _('Bad Request'), 'status_message': _('Title should not be empty.')})
post_tags = forum._tag_to_write_vals(kwargs.get('post_tags', ''))
vals = {
'tag_ids': post_tags,
'name': kwargs.get('post_name'),
'content': kwargs.get('content'),
'content_link': kwargs.get('content_link'),
}
post.write(vals)
question = post.parent_id if post.parent_id else post
return werkzeug.utils.redirect("/forum/%s/question/%s" % (slug(forum), slug(question)))
def get_blog_data(self):
limit = 7
blog_blog_1 = self.sudo().env.ref('website_blog.blog_blog_1')
post_domain = [('blog_id', '=', blog_blog_1.id)]
post_s = self.env['blog.post'].search(post_domain, limit=limit)
base_url = '/blog/our-blog-{}/post/'.format(slug(blog_blog_1), )
res = {}
for post in post_s:
name = post.name or 'Our post'
url = base_url + slug(post)
res[post.id] = (name, url)
return res
def _compute_website_url(self):
super(Slide, self)._compute_website_url()
base_url = self.env['ir.config_parameter'].sudo().get_param('web.base.url')
for slide in self:
if slide.id: # avoid to perform a slug on a not yet saved record in case of an onchange.
# 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
def _compute_website_url(self):
super(Slide, self)._compute_website_url()
base_url = self.env['ir.config_parameter'].get_param('web.base.url')
for slide in self:
if slide.id: # avoid to perform a slug on a not yet saved record in case of an onchange.
# 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))
}).short_url
else:
url = '%s/slides/slide/%s' % (base_url, slug(slide))
slide.website_url = url
def _get_new_menu_pages(self):
""" Retuns a list of tuple ('Page name', 'relative page url') for the event """
self.ensure_one()
todo = [(_('Introduction'), 'website_event.template_intro'),
(_('Location'), 'website_event.template_location')]
result = []
for name, path in todo:
complete_name = name + ' ' + self.name
newpath = self.env['website'].new_page(complete_name,
path,
ispage=False)
url = "/event/" + slug(self) + "/page/" + newpath
result.append((name, url))
result.append((_('Register'), '/event/%s/register' % slug(self)))
return result
def _compute_website_url(self):
super(Slide, self)._compute_website_url()
base_url = self.env["ir.config_parameter"].get_param("web.base.url")
for slide in self:
# 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))})
.short_url
)
else:
url = "%s/slides/slide/%s" % (base_url, slug(slide))
slide.website_url = url
def users(self, forum, page=1, **searches):
User = request.env['res.users']
step = 30
tag_count = User.sudo().search_count([('karma', '>', 1),
('website_published', '=', True)
])
pager = request.website.pager(url="/forum/%s/users" % slug(forum),
total=tag_count,
page=page,
step=step,
scope=30)
user_obj = User.sudo().search([('karma', '>', 1),
('website_published', '=', True)],
limit=step,
offset=pager['offset'],
order='karma DESC')
# put the users in block of 3 to display them as a table
users = [[] for i in range(len(user_obj) / 3 + 1)]
for index, user in enumerate(user_obj):
users[index / 3].append(user)
searches['users'] = 'True'
values = self._prepare_forum_values(forum=forum, searches=searches)
values.update({
'users': users,
'main_object': forum,
'notifications': self._get_notifications(),
'pager': pager,
})
return request.render("website_forum.users", values)
def _get_menu_entries(self):
self.ensure_one()
return [
(_('Introduction'), False, 'website_event.template_intro'),
(_('Location'), False, 'website_event.template_location'),
(_('Register'), '/event/%s/register' % slug(self), False),
]
def post_save(self, forum, post, **kwargs):
if "post_name" in kwargs and not kwargs.get("post_name").strip():
return request.render(
"website.http_error",
{"status_code": _("Bad Request"), "status_message": _("Title should not be empty.")},
)
post_tags = forum._tag_to_write_vals(kwargs.get("post_tags", ""))
vals = {
"tag_ids": post_tags,
"name": kwargs.get("post_name"),
"content": kwargs.get("content"),
"content_link": kwargs.get("content_link"),
}
post.write(vals)
question = post.parent_id if post.parent_id else post
return werkzeug.utils.redirect("/forum/%s/question/%s" % (slug(forum), slug(question)))
def _set_website_menu(self):
for event in self:
if event.menu_id and not event.website_menu:
event.menu_id.unlink()
elif event.website_menu:
if not event.menu_id:
root_menu = self.env['website.menu'].create({'name': event.name})
event.menu_id = root_menu
existing_page_names = event.menu_id.child_id.mapped('name')
required_page_names = [entry[0] for entry in self._get_menu_entries()]
standard_page_names = self._get_standard_menu_entries_names()
# remove entries that should not exist anymore
submenu_to_delete = event.menu_id.child_id.filtered(lambda menu: menu.name not in required_page_names and menu.name in standard_page_names)
submenu_to_delete.unlink()
# create missing entries
for sequence, (name, url, xml_id) in enumerate(self._get_menu_entries()):
if name not in existing_page_names:
if not url:
newpath = self.env['website'].new_page(name + ' ' + self.name, xml_id, ispage=False)
url = "/event/" + slug(self) + "/page/" + newpath
self.env['website.menu'].create({
'name': name,
'url': url,
'parent_id': event.menu_id.id,
'sequence': sequence,
})
def thread_headers(self, group, page=1, mode='thread', date_begin=None, date_end=None, **post):
Message = request.env['mail.message']
domain = [('model', '=', 'mail.channel'), ('res_id', '=', group.id), ('message_type', '!=', 'notification')]
if mode == 'thread':
domain += [('parent_id', '=', False)]
if date_begin and date_end:
domain += [('date', '>=', date_begin), ('date', '<=', date_end)]
pager = request.website.pager(
url='/groups/%s' % slug(group),
total=Message.search_count(domain),
page=page,
step=self._thread_per_page,
url_args={'mode': mode, 'date_begin': date_begin or '', 'date_end': date_end or ''},
)
messages = Message.search(domain, limit=self._thread_per_page, offset=pager['offset'])
values = {
'messages': messages,
'group': group,
'pager': pager,
'mode': mode,
'archives': self._get_archives(group.id),
'date_begin': date_begin,
'date_end': date_end,
'replies_per_page': self._replies_per_page,
}
return request.render('website_mail_channel.group_messages', values)
def add_product(self, name=None, category=0, **post):
product = request.env['product.product'].create({
'name': name or _("New Product"),
'public_categ_ids': category
})
return request.redirect("/shop/product/%s?enable_editor=1" % slug(product.product_tmpl_id))
def test_08_survey_urls(self):
def validate_url(url):
""" Reference: https://github.com/django/django/blob/master/django/core/validators.py """
url_regex = re.compile(
r'^https?://' # http:// or https://
r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+(?:[A-Z]{2,6}\.?|[A-Z0-9-]{2,}\.?)|' # domain...
r'localhost|' # localhost...
r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}|' # ...or ipv4
r'\[?[A-F0-9]*:[A-F0-9:]+\]?)' # ...or ipv6
r'(?::\d+)?' # optional port
r'(?:/?|[/?]\S+)$', re.IGNORECASE)
return True if url_regex.match(url) else False
base_url = self.env['ir.config_parameter'].get_param('web.base.url')
urltypes = {'public': 'start', 'print': 'print', 'result': 'results'}
for urltype, urltxt in pycompat.items(urltypes):
survey_url = getattr(self.survey1, urltype + '_url')
survey_url_relative = getattr(self.survey1.with_context({'relative_url': True}), urltype + '_url')
self.assertTrue(validate_url(survey_url))
url = "survey/%s/%s" % (urltxt, slug(self.survey1))
full_url = urls.url_join(base_url, url)
self.assertEqual(full_url, survey_url)
self.assertEqual('/' + url, survey_url_relative)
if urltype == 'public':
url_html = '<a href="%s">Click here to start survey</a>'
self.assertEqual(url_html % full_url, getattr(self.survey1, urltype + '_url_html'), msg="Public URL is incorrect")
self.assertEqual(url_html % ('/' + url), getattr(self.survey1.with_context({'relative_url': True}), urltype + '_url_html'), msg="Public URL is incorrect.")
def thread_headers(self, group, page=1, mode='thread', date_begin=None, date_end=None, **post):
if group.channel_type != 'channel':
raise werkzeug.exceptions.NotFound()
Message = request.env['mail.message']
domain = [('model', '=', 'mail.channel'), ('res_id', '=', group.id), ('message_type', '!=', 'notification')]
if mode == 'thread':
domain += [('parent_id', '=', False)]
if date_begin and date_end:
domain += [('date', '>=', date_begin), ('date', '<=', date_end)]
pager = request.website.pager(
url='/groups/%s' % slug(group),
total=Message.search_count(domain),
page=page,
step=self._thread_per_page,
url_args={'mode': mode, 'date_begin': date_begin or '', 'date_end': date_end or ''},
)
messages = Message.search(domain, limit=self._thread_per_page, offset=pager['offset'])
values = {
'messages': messages,
'group': group,
'pager': pager,
'mode': mode,
'archives': self._get_archives(group.id),
'date_begin': date_begin,
'date_end': date_end,
'replies_per_page': self._replies_per_page,
}
return request.render('website_mail_channel.group_messages', values)
def _set_website_menu(self):
for event in self:
if event.menu_id and not event.website_menu:
event.menu_id.unlink()
elif event.website_menu:
if not event.menu_id:
root_menu = self.env['website.menu'].create(
{'name': event.name})
event.menu_id = root_menu
for sequence, (name, url,
xml_id) in enumerate(self._get_menu_entries()):
existing_pages = event.menu_id.child_id.mapped('name')
if name not in existing_pages:
if not url:
newpath = self.env['website'].new_page(
name + ' ' + self.name, xml_id, ispage=False)
url = "/event/" + slug(self) + "/page/" + newpath
self.env['website.menu'].create({
'name':
name,
'url':
url,
'parent_id':
event.menu_id.id,
'sequence':
sequence,
})
def _compute_website_url(self):
super(Channel, self)._compute_website_url()
base_url = self.env['ir.config_parameter'].get_param('web.base.url')
for channel in self:
if channel.id: # avoid to perform a slug on a not yet saved record in case of an onchange.
channel.website_url = '%s/slides/%s' % (base_url,
slug(channel))
def blogs(self, page=1, **post):
Blog = request.env['blog.blog']
blogs = Blog.search([], limit=2)
if len(blogs) == 1:
return werkzeug.utils.redirect('/blog/%s' % slug(blogs[0]),
code=302)
BlogPost = request.env['blog.post']
total = BlogPost.search([], count=True)
pager = request.website.pager(
url='/blog',
total=total,
page=page,
step=self._blog_post_per_page,
)
posts = BlogPost.search([],
offset=(page - 1) * self._blog_post_per_page,
limit=self._blog_post_per_page)
blog_url = QueryURL('', ['blog', 'tag'])
return request.render("website_blog.latest_blogs", {
'posts': posts,
'pager': pager,
'blog_url': blog_url,
})
def send_get_mail_body(self, partner=None):
""" Short-circuit parent method for mail groups, replace the default
footer with one appropriate for mailing-lists."""
if self.model == 'mail.channel' and self.res_id:
# no super() call on purpose, no private links that could be quoted!
channel = self.env['mail.channel'].browse(self.res_id)
base_url = self.env['ir.config_parameter'].sudo().get_param(
'web.base.url')
vals = {
'maillist':
_('Mailing-List'),
'post_to':
_('Post to'),
'unsub':
_('Unsubscribe'),
'mailto':
'mailto:%s@%s' % (channel.alias_name, channel.alias_domain),
'group_url':
'%s/groups/%s' % (base_url, slug(channel)),
'unsub_url':
'%s/groups?unsubscribe' % (base_url, ),
}
footer = """_______________________________________________
%(maillist)s: %(group_url)s
%(post_to)s: %(mailto)s
%(unsub)s: %(unsub_url)s
""" % vals
body = tools.append_content_to_html(self.body,
footer,
container_tag='div')
return body
else:
return super(MailMail, self).send_get_mail_body(partner=partner)
def users(self, forum, page=1, **searches):
User = request.env["res.users"]
step = 30
tag_count = User.sudo().search_count([("karma", ">", 1), ("website_published", "=", True)])
pager = request.website.pager(
url="/forum/%s/users" % slug(forum), total=tag_count, page=page, step=step, scope=30
)
user_obj = User.sudo().search(
[("karma", ">", 1), ("website_published", "=", True)],
limit=step,
offset=pager["offset"],
order="karma DESC",
)
# put the users in block of 3 to display them as a table
users = [[] for i in range(len(user_obj) / 3 + 1)]
for index, user in enumerate(user_obj):
users[index / 3].append(user)
searches["users"] = "True"
values = self._prepare_forum_values(forum=forum, searches=searches)
values.update(
{"users": users, "main_object": forum, "notifications": self._get_notifications(), "pager": pager}
)
return request.render("website_forum.users", values)
def add_product(self, name=None, category=0, **post):
product = request.env['product.product'].create({
'name': name or _("New Product"),
'public_categ_ids': category
})
return request.redirect("/shop/product/%s?enable_editor=1" % slug(product.product_tmpl_id))
def _get_menu_entries(self):
""" Method returning menu entries to display on the website view of the
event, possibly depending on some options in inheriting modules. """
self.ensure_one()
return [
(_('Introduction'), False, 'website_event.template_intro'),
(_('Location'), False, 'website_event.template_location'),
(_('Register'), '/event/%s/register' % slug(self), False),
]
def event_register(self, event, **post):
if event.state == 'done':
return request.redirect("/event/%s" % slug(event))
values = {
'event': event,
'main_object': event,
'range': range,
}
return request.render("website_event.event_description_full", values)
def post_create(self, forum, post_parent=None, post_type=None, **post):
if post_type == 'question' and not post.get('post_name', ''):
return request.render('website.http_error', {'status_code': _('Bad Request'), 'status_message': _('Title should not be empty.')})
if post.get('content', '') == '<p><br></p>':
return werkzeug.utils.redirect("/forum/%s/question/%s?nocontent=1" % (slug(forum), post_parent and slug(post_parent)))
post_tag_ids = forum._tag_to_write_vals(post.get('post_tags', ''))
if request.env.user.forum_waiting_posts_count:
return werkzeug.utils.redirect("/forum/%s/ask" % slug(forum))
new_question = request.env['forum.post'].create({
'forum_id': forum.id,
'name': post.get('post_name') or (post_parent and 'Re: %s' % (post_parent.name or '')) or '',
'content': post.get('content', False),
'content_link': post.get('content_link', False),
'parent_id': post_parent and post_parent.id or False,
'tag_ids': post_tag_ids,
'post_type': post_parent and post_parent.post_type or post_type, # tde check in selection field
})
return werkzeug.utils.redirect("/forum/%s/question/%s" % (slug(forum), post_parent and slug(post_parent) or new_question.id))
def blogs(self, page=1, **post):
Blog = request.env["blog.blog"]
blogs = Blog.search([], limit=2)
if len(blogs) == 1:
return werkzeug.utils.redirect("/blog/%s" % slug(blogs[0]), code=302)
BlogPost = request.env["blog.post"]
total = BlogPost.search([], count=True)
pager = request.website.pager(url="/blog", total=total, page=page, step=self._blog_post_per_page)
posts = BlogPost.search([], offset=(page - 1) * self._blog_post_per_page, limit=self._blog_post_per_page)
blog_url = QueryURL("", ["blog", "tag"])
return request.render("website_blog.latest_blogs", {"posts": posts, "pager": pager, "blog_url": blog_url})
def save_edited_profile(self, forum, user, **kwargs):
values = {
'name': kwargs.get('name'),
'website': kwargs.get('website'),
'email': kwargs.get('email'),
'city': kwargs.get('city'),
'country_id': int(kwargs.get('country')) if kwargs.get('country') else False,
'website_description': kwargs.get('description'),
}
if request.uid == user.id: # the controller allows to edit only its own privacy settings; use partner management for other cases
values['website_published'] = kwargs.get('website_published') == 'True'
user.write(values)
return werkzeug.utils.redirect("/forum/%s/user/%d" % (slug(forum), user.id))
def message_get_email_values(self, notif_mail=None):
self.ensure_one()
res = super(MailGroup, self).message_get_email_values(notif_mail=notif_mail)
base_url = self.env['ir.config_parameter'].sudo().get_param('web.base.url')
headers = {}
if res.get('headers'):
try:
headers = safe_eval(res['headers'])
except Exception:
pass
headers.update({
'List-Archive': '<%s/groups/%s>' % (base_url, slug(self)),
'List-Subscribe': '<%s/groups>' % (base_url),
'List-Unsubscribe': '<%s/groups?unsubscribe>' % (base_url,),
})
res['headers'] = repr(headers)
return res
