def post_create(self, forum, post_parent=None, **post):
if post.get('content', '') == '<p><br></p>':
return request.render(
'http_routing.http_error', {
'status_code':
_('Bad Request'),
'status_message':
post_parent and _('Reply should not be empty.')
or _('Question should not be empty.')
})
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),
'parent_id':
post_parent and post_parent.id or False,
'tag_ids':
post_tag_ids
})
return werkzeug.utils.redirect(
"/forum/%s/question/%s" %
(slug(forum), post_parent and slug(post_parent)
or new_question.id))
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 sitemap_partners(env, rule, qs):
if not qs or qs.lower() in '/partners':
yield {'loc': '/partners'}
Grade = env['res.partner.grade']
dom = [('website_published', '=', True)]
dom += sitemap_qs2dom(qs=qs,
route='/partners/grade/',
field=Grade._rec_name)
for grade in env['res.partner.grade'].search(dom):
loc = '/partners/grade/%s' % slug(grade)
if not qs or qs.lower() in loc:
yield {'loc': loc}
partners_dom = [('is_company', '=', True), ('grade_id', '!=', False),
('website_published', '=', True),
('grade_id.website_published', '=', True),
('country_id', '!=', False)]
dom += sitemap_qs2dom(qs=qs, route='/partners/country/')
countries = env['res.partner'].sudo().read_group(
partners_dom, fields=['id', 'country_id'], groupby='country_id')
for country in countries:
loc = '/partners/country/%s' % slug(country['country_id'])
if not qs or qs.lower() in loc:
yield {'loc': loc}
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 TrendyStyleHomePage(self):
all_blogs = request.env['blog.post'].sudo().search([("is_published", "=", True)], limit=4,
order='create_date desc')
blogs_all = []
for prods in all_blogs:
display_date = prods['create_date'].strftime("%d %B")
for prod_blog in request.env['blog.blog'].sudo().search([]):
ks_blog_redirect_url = ("/blog/%s" % slug(prod_blog))
ks_blog_redirect_url_1 = ("/post/%s" % slug(prods))
ks_link_redirect = ks_blog_redirect_url + ks_blog_redirect_url_1
ks_blog_url_sanitized = ''
if prods.cover_properties:
ks_blog_url = json.loads(prods.cover_properties)['background-image']
if ks_blog_url != "none":
# bad hack to get url
ks_blog_url_inner = ks_blog_url.split("(")[1]
ks_blog_url_sanitized = ks_blog_url_inner.split(")")[0]
values = {
'ks_blog_url': ks_blog_url_sanitized,
'ks_create_date': display_date,
'ks_name': prods.name,
'ks_Subtitle': prods.subtitle,
'id': prods.id,
'ks_blog_content': prods.teaser,
'ks_link_redirect': ks_link_redirect,
}
blogs_all.append(values)
return blogs_all
def ks_deal_of_the_day(self):
value = []
qty = []
item_ids = request.env['ks_theme_kinetik.ks_deal_of_the_day'].sudo().search([]).ks_selected_product.item_ids
for x in range(0, len(item_ids)):
qty.append(item_ids[x].min_quantity)
if (len(qty) > 0):
if not (len(qty) > 0 and all(elem == qty[0] for elem in qty)):
# index = qty.index(max(qty))
item_ids = request.env['ks_theme_kinetik.ks_deal_of_the_day'].sudo().search(
[]).ks_selected_product.item_ids.search([], order='min_quantity DESC')[0]
else:
item_ids = request.env['ks_theme_kinetik.ks_deal_of_the_day'].sudo().search(
[]).ks_selected_product.item_ids.search([], order='create_date DESC')[0]
date_start = item_ids.date_start
date_end = item_ids.date_end
if not (date_end and date_start):
seconds = 0
else:
seconds = self.second_calculation(date_start, date_end)
value.append(seconds)
apld_on = item_ids.applied_on
if apld_on == '0_product_variant':
prd_vrnt = item_ids.product_id.product_tmpl_id
url = "/shop/product/%s" % slug(prd_vrnt)
elif apld_on == '1_product':
prd = item_ids.product_tmpl_id
url = "/shop/product/%s" % slug(prd)
elif apld_on == '2_product_category':
url = "/shop"
elif apld_on == '3_global':
url = "/shop"
value.append(url)
return value
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 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 post_accept(self, forum, post, **kwargs):
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 slide_set_completed_and_redirect(self, slide, next_slide_id=None):
self._set_completed_slide(slide)
next_slide = None
if next_slide_id:
next_slide = self._fetch_slide(next_slide_id).get('slide', None)
return werkzeug.utils.redirect(
"/slides/slide/%s" %
(slug(next_slide) if next_slide else slug(slide)))
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_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_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 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 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 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 "/forum/%s" % slug(forum_id)
def __call__(self, path=None, path_args=None, **kw):
path = path or self.path
for key, value in self.args.items():
kw.setdefault(key, value)
path_args = OrderedSet(path_args or []) | self.path_args
paths, fragments = {}, []
for key, value in kw.items():
if value and key in path_args:
if isinstance(value, models.BaseModel):
paths[key] = slug(value)
else:
paths[key] = u"%s" % value
elif value:
if isinstance(value, list) or isinstance(value, set):
fragments.append(
werkzeug.url_encode([(key, item) for item in value]))
else:
fragments.append(werkzeug.url_encode([(key, value)]))
for key in path_args:
value = paths.get(key)
if value is not None:
path += '/' + key + '/' + value
if fragments:
path += '?' + '&'.join(fragments)
return path
def forum(self, **kwargs):
domain = request.website.website_domain()
forums = request.env['forum.forum'].search(domain)
if len(forums) == 1:
return werkzeug.utils.redirect('/forum/%s' % slug(forums[0]),
code=302)
return request.render("website_forum.forum_all", {'forums': forums})
def _compute_website_url(self):
super(Channel, self)._compute_website_url()
for channel in self:
if channel.id: # avoid to perform a slug on a not yet saved record in case of an onchange.
base_url = channel.get_base_url()
channel.website_url = '%s/slides/%s' % (base_url,
slug(channel))
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 urltypes.items():
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 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 _send_prepare_body(self):
""" 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_prepare_body()
def _compute_website_url(self):
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
def jobs_add(self, **kwargs):
# avoid branding of website_description by setting rendering_bundle in context
job = request.env['hr.job'].with_context(rendering_bundle=True).create(
{
'name': _('Job Title'),
})
return request.redirect("/jobs/detail/%s?enable_editor=1" % slug(job))
def blogs(self, page=1, **post):
domain = request.website.website_domain()
Blog = request.env['blog.blog']
blogs = Blog.search(domain, 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(domain)
pager = request.website.pager(
url='/blog',
total=total,
page=page,
step=self._blog_post_per_page,
)
posts = BlogPost.search(domain,
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 sitemap_forum(env, rule, qs):
Forum = env['forum.forum']
dom = sitemap_qs2dom(qs, '/forum', Forum._rec_name)
dom += env['website'].get_current_website().website_domain()
for f in Forum.search(dom):
loc = '/forum/%s' % slug(f)
if not qs or qs.lower() in loc:
yield {'loc': loc}
def _notify_email_header_dict(self):
headers = super(MailGroup, self)._notify_email_header_dict()
base_url = self.env['ir.config_parameter'].sudo().get_param(
'web.base.url')
headers['List-Archive'] = '<%s/groups/%s>' % (base_url, slug(self)),
headers['List-Subscribe'] = '<%s/groups>' % (base_url),
headers['List-Unsubscribe'] = '<%s/groups?unsubscribe>' % (base_url, ),
return headers
def sitemap_slide(env, rule, qs):
Channel = env['slide.channel']
dom = sitemap_qs2dom(qs=qs, route='/slides/', field=Channel._rec_name)
dom += env['website'].get_current_website().website_domain()
for channel in Channel.search(dom):
loc = '/slides/%s' % slug(channel)
if not qs or qs.lower() in loc:
yield {'loc': loc}
def tags_list(tag_ids, current_tag):
tag_ids = list(tag_ids) # required to avoid using the same list
if current_tag in tag_ids:
tag_ids.remove(current_tag)
else:
tag_ids.append(current_tag)
tag_ids = request.env['blog.tag'].browse(tag_ids).exists()
return ','.join(slug(tag) for tag in tag_ids)
def blog_post_create(self, blog_id, **post):
# Use sudo so this line prevents both editor and admin to access blog from another website
# as browse() will return the record even if forbidden by security rules but editor won't
# be able to access it
if not request.env['blog.blog'].browse(
blog_id).sudo().can_access_from_current_website():
raise werkzeug.exceptions.NotFound()
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)))
