def confirm_unsubscribe(self, channel, partner_id, token, **kw):
subscriber = request.env['mail.channel.partner'].search([
('channel_id', '=', channel.id), ('partner_id', '=', partner_id)
])
if not subscriber:
partner = request.env['res.partner'].browse(
partner_id).sudo().exists()
# FIXME: remove try/except in master
try:
response = request.render(
'website_mail_channel.not_subscribed',
{'partner_id': partner})
# make sure the rendering (and thus error if template is
# missing) happens inside the try block
response.flatten()
return response
except ValueError:
return _(
"The address %s is already unsubscribed or was never subscribed to any mailing list"
) % (partner.email)
subscriber_token = channel._generate_action_token(partner_id,
action='unsubscribe')
if token != subscriber_token:
return request.render(
'website_mail_channel.invalid_token_subscription')
# remove partner
channel.sudo().write({'channel_partner_ids': [(3, partner_id)]})
return request.render("website_mail_channel.confirmation_subscription",
{'subscribing': False})
def mailing(self, mailing_id, email=None, res_id=None, **post):
mailing = request.env['mail.mass_mailing'].sudo().browse(mailing_id)
if mailing.exists():
if mailing.mailing_model_real == 'mail.mass_mailing.contact':
contacts = request.env['mail.mass_mailing.contact'].sudo().search([('email', '=', email)])
return request.render('website_mass_mailing.page_unsubscribe', {
'contacts': contacts,
'email': email,
'mailing_id': mailing_id})
else:
super(MassMailController, self).mailing(mailing_id, email=email, res_id=res_id, **post)
return request.render('website_mass_mailing.page_unsubscribed')
def slides_index(self, *args, **post):
""" Returns a list of available channels: if only one is available,
redirects directly to its slides
"""
channels = request.env['slide.channel'].search([], order='sequence, id')
if not channels:
return request.render("website_slides.channel_not_found")
elif len(channels) == 1:
return request.redirect("/slides/%s" % channels.id)
return request.render('website_slides.channels', {
'channels': channels,
'user': request.env.user,
'is_public_user': request.env.user == request.website.user_id
})
def web_auth_reset_password(self, *args, **kw):
qcontext = self.get_auth_signup_qcontext()
if not qcontext.get('token') and not qcontext.get(
'reset_password_enabled'):
raise werkzeug.exceptions.NotFound()
if 'error' not in qcontext and request.httprequest.method == 'POST':
try:
if qcontext.get('token'):
self.do_signup(qcontext)
return super(AuthSignupHome, self).web_login(*args, **kw)
else:
login = qcontext.get('login')
assert login, _("No login provided.")
_logger.info(
"Password reset attempt for <%s> by user <%s> from %s",
login, request.env.user.login,
request.httprequest.remote_addr)
request.env['res.users'].sudo().reset_password(login)
qcontext['message'] = _(
"An email has been sent with credentials to reset your password"
)
except UserError as e:
qcontext['error'] = e.name or e.value
except SignupError:
qcontext['error'] = _("Could not reset your password")
_logger.exception('error when resetting password')
except Exception as e:
qcontext['error'] = str(e)
response = request.render('auth_signup.reset_password', qcontext)
response.headers['X-Frame-Options'] = 'DENY'
return response
def FieldTextHtml(self,
model=None,
res_id=None,
field=None,
callback=None,
**kwargs):
kwargs.update(model=model,
res_id=res_id,
field=field,
datarecord=json.loads(kwargs['datarecord']),
debug=request.debug)
for k in kwargs:
if isinstance(kwargs[k],
pycompat.string_types) and kwargs[k].isdigit():
kwargs[k] = int(kwargs[k])
trans = dict(lang=kwargs.get('lang', request.env.context.get('lang')),
translatable=kwargs.get('translatable'),
edit_translations=kwargs.get('edit_translations'),
editable=kwargs.get('enable_editor'))
kwargs.update(trans)
record = None
if model and kwargs.get('res_id'):
record = request.env[model].with_context(trans).browse(
kwargs.get('res_id'))
kwargs.update(content=record and getattr(record, field) or "")
return request.render(kwargs.get("template")
or "web_editor.FieldTextHtml",
kwargs,
uid=request.uid)
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 product_compare(self, **post):
values = {}
product_ids = [
int(i) for i in post.get('products', '').split(',') if i.isdigit()
]
if not product_ids:
return request.redirect("/shop")
# use search to check read access on each record/ids
products = request.env['product.product'].search([('id', 'in',
product_ids)])
values['products'] = products.with_context(display_default_code=False)
res = {}
for num, product in enumerate(products):
for var in product.attribute_line_ids:
cat_name = var.attribute_id.category_id.name or _(
'Uncategorized')
att_name = var.attribute_id.name
if not product.attribute_value_ids: # create_variant = False
continue
res.setdefault(cat_name,
{}).setdefault(att_name,
[' - '] * len(products))
val = product.attribute_value_ids.filtered(
lambda x: x.attribute_id == var.attribute_id)
res[cat_name][att_name][num] = val[0].name
values['specs'] = res
values['compute_currency'] = self._get_compute_currency_and_context(
)[0]
return request.render("website_sale_comparison.product_compare",
values)
def statistics_shorten_url(self, code, **post):
code = request.env['link.tracker.code'].search([('code', '=', code)], limit=1)
if code:
return request.render("website_links.graphs", code.link_id.read()[0])
else:
return werkzeug.utils.redirect('', 301)
def survey_reporting(self, survey, token=None, **post):
'''Display survey Results & Statistics for given survey.'''
result_template = 'survey.result'
current_filters = []
filter_display_data = []
filter_finish = False
if not survey.user_input_ids or not [
input_id.id for input_id in survey.user_input_ids
if input_id.state != 'new'
]:
result_template = 'survey.no_result'
if 'finished' in post:
post.pop('finished')
filter_finish = True
if post or filter_finish:
filter_data = self.get_filter_data(post)
current_filters = survey.filter_input_ids(filter_data,
filter_finish)
filter_display_data = survey.get_filter_display_data(filter_data)
return request.render(
result_template, {
'survey': survey,
'survey_dict': self.prepare_result_dict(
survey, current_filters),
'page_range': self.page_range,
'current_filters': current_filters,
'filter_display_data': filter_display_data,
'filter_finish': filter_finish
})
def event_agenda(self, event, tag=None, **post):
event = event.with_context(tz=event.date_tz or 'UTC')
local_tz = pytz.timezone(event.date_tz or 'UTC')
days_tracks = collections.defaultdict(lambda: [])
for track in event.track_ids.sorted(
lambda track: (track.date or '', bool(track.location_id))):
if not track.date:
continue
date = fields.Datetime.from_string(
track.date).replace(tzinfo=pytz.utc).astimezone(local_tz)
days_tracks[str(date)[:10]].append(track)
days = {}
tracks_by_days = {}
for day, tracks in days_tracks.items():
tracks_by_days[day] = tracks
days[day] = self._prepare_calendar(event, tracks)
return request.render(
"website_event_track.agenda", {
'event': event,
'days': days,
'tracks_by_days': tracks_by_days,
'tag': tag
})
def tags(self, forum, tag_char=None, **post):
# build the list of tag first char, with their value as tag_char param Ex : [('All', 'all'), ('C', 'c'), ('G', 'g'), ('Z', z)]
first_char_tag = forum.get_tags_first_char()
first_char_list = [(t, t.lower()) for t in first_char_tag
if t.isalnum()]
first_char_list.insert(0, (_('All'), 'all'))
# get active first char tag
active_char_tag = first_char_list[1][1] if len(
first_char_list) > 1 else 'all'
if tag_char:
active_char_tag = tag_char.lower()
# generate domain for searched tags
domain = [('forum_id', '=', forum.id), ('posts_count', '>', 0)]
order_by = 'name'
if active_char_tag and active_char_tag != 'all':
domain.append(
('name', '=ilike', tools.escape_psql(active_char_tag) + '%'))
order_by = 'posts_count DESC'
tags = request.env['forum.tag'].search(domain,
limit=None,
order=order_by)
# prepare values and render template
values = self._prepare_forum_values(forum=forum,
searches={'tags': True},
**post)
values.update({
'tags': tags,
'pager_tag_chars': first_char_list,
'active_char_tag': active_char_tag,
})
return request.render("website_forum.tag", values)
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
current_grade, current_country = None, None
grade_id = post.get('grade_id')
country_id = post.get('country_id')
if grade_id:
current_grade = request.env['res.partner.grade'].browse(
int(grade_id)).exists()
if country_id:
current_country = request.env['res.country'].browse(
int(country_id)).exists()
if partner_id:
partner = request.env['res.partner'].sudo().browse(partner_id)
is_website_publisher = request.env['res.users'].has_group(
'website.group_website_publisher')
if partner.exists() and (partner.website_published
or is_website_publisher):
values = {
'main_object': partner,
'partner': partner,
'current_grade': current_grade,
'current_country': current_country
}
return request.render("website_crm_partner_assign.partner",
values)
return self.partners(**post)
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 registration_confirm(self, event, **post):
order = request.website.sale_get_order(force_create=1)
attendee_ids = set()
registrations = self._process_registration_details(post)
for registration in registrations:
ticket = request.env['event.event.ticket'].sudo().browse(
int(registration['ticket_id']))
cart_values = order.with_context(
event_ticket_id=ticket.id, fixed_price=True)._cart_update(
product_id=ticket.product_id.id,
add_qty=1,
registration_data=[registration])
attendee_ids |= set(cart_values.get('attendee_ids', []))
# free tickets -> order with amount = 0: auto-confirm, no checkout
if not order.amount_total:
order.action_confirm() # tde notsure: email sending ?
attendees = request.env['event.registration'].browse(
list(attendee_ids)).sudo()
# clean context and session, then redirect to the confirmation page
request.website.sale_reset()
return request.render("website_event.registration_complete", {
'attendees': attendees,
'event': event,
})
return request.redirect("/shop/checkout")
def channel_list(self, **kw):
# display the list of the channel
channels = request.env['im_livechat.channel'].search([
('website_published', '=', True)
])
values = {'channels': channels}
return request.render('website_livechat.channel_list_page', values)
def channel_rating(self, channel, **kw):
# get the last 100 ratings and the repartition per grade
domain = [
('res_model', '=', 'mail.channel'),
('res_id', 'in', channel.sudo().channel_ids.ids),
('consumed', '=', True),
('rating', '>=', 1),
]
ratings = request.env['rating.rating'].search(domain,
order='create_date desc',
limit=100)
repartition = channel.sudo().channel_ids.rating_get_grades(
domain=domain)
# compute percentage
percentage = dict.fromkeys(['great', 'okay', 'bad'], 0)
for grade in repartition:
percentage[grade] = round(
repartition[grade] * 100.0 / sum(repartition.values()),
1) if sum(repartition.values()) else 0
# the value dict to render the template
values = {
'channel': channel,
'ratings': ratings,
'team': channel.sudo().user_ids,
'percentage': percentage
}
return request.render("website_livechat.channel_page", values)
def event_register(self, event, **post):
values = {
'event': event,
'main_object': event,
'range': range,
'registrable': event.sudo()._is_event_registrable()
}
return request.render("website_event.event_description_full", values)
def post_toc(self, forum, post, **kwargs):
assert request.env.user.karma >= 200, 'You need 200 karma to promote a post to the documentation'
value = {
'post': post,
'forum': post.forum_id,
'chapters': request.env['forum.documentation.toc'].search([('child_ids', '=', False)])
}
return request.render("website_forum_doc.promote_question", value)
def event_track_view(self, event, track, **post):
track = track.sudo().with_context(tz=event.date_tz or 'UTC')
values = {
'track': track,
'event': track.event_id,
'main_object': track
}
return request.render("website_event_track.track_view", values)
def edit_profile(self, forum, user, **kwargs):
countries = request.env['res.country'].search([])
values = self._prepare_forum_values(forum=forum, searches=kwargs)
values.update({
'email_required': kwargs.get('email_required'),
'countries': countries,
'notifications': self._get_notifications(),
})
return request.render("website_forum.edit_profile", values)
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
if partner_id:
partner = request.env['res.partner'].sudo().browse(partner_id)
if partner.exists() and partner.website_published:
values = {}
values['main_object'] = values['partner'] = partner
return request.render("website_customer.details", values)
return self.customers(**post)
def partners_detail(self, partner_id, **post):
_, partner_id = unslug(partner_id)
if partner_id:
partner = request.env['res.partner'].sudo().browse(partner_id)
if partner.exists() and partner.website_published: # TODO should be done with access rules
values = {}
values['main_object'] = values['partner'] = partner
return request.render("website_membership.partner", values)
return self.members(**post)
def portal_my_task(self, task_id=None, **kw):
task = request.env['project.task'].browse(task_id)
task.check_access_rights('read')
task.check_access_rule('read')
vals = {'task': task, 'user': request.env.user}
history = request.session.get('my_tasks_history', [])
vals.update(get_records_pager(history, task))
return request.render("project.portal_my_task", vals)
def portal_my_invoice_detail(self, invoice_id, access_token=None, **kw):
try:
invoice_sudo = self._invoice_check_access(invoice_id, access_token)
except AccessError:
return request.redirect('/my')
values = self._invoice_get_page_view_values(invoice_sudo, access_token,
**kw)
return request.render("account.portal_invoice_page", values)
def portal_order_page(self, order=None, access_token=None, **kw):
try:
order_sudo = self._order_check_access(order,
access_token=access_token)
except AccessError:
return request.redirect('/my')
values = self._order_get_page_view_values(order_sudo, access_token,
**kw)
return request.render("sale.portal_order_page", values)
def post(self, toc, post, **kwargs):
# TODO: implement a redirect instead of crash
assert post.documentation_toc_id == toc, "Wrong post!"
value = {
'toc': toc,
'post': post,
'main_object': post,
'forum': post.forum_id
}
return request.render("website_forum_doc.documentation_post", value)
def start_survey(self, survey, token=None, **post):
UserInput = request.env['survey.user_input']
# Test mode
if token and token == "phantom":
_logger.info("[survey] Phantom mode")
user_input = UserInput.create({
'survey_id': survey.id,
'test_entry': True
})
data = {'survey': survey, 'page': None, 'token': user_input.token}
return request.render('survey.survey_init', data)
# END Test mode
# Controls if the survey can be displayed
errpage = self._check_bad_cases(survey, token=token)
if errpage:
return errpage
# Manual surveying
if not token:
vals = {'survey_id': survey.id}
if request.website.user_id != request.env.user:
vals['partner_id'] = request.env.user.partner_id.id
user_input = UserInput.create(vals)
else:
user_input = UserInput.sudo().search([('token', '=', token)],
limit=1)
if not user_input:
return request.render("website.403")
# Do not open expired survey
errpage = self._check_deadline(user_input)
if errpage:
return errpage
# Select the right page
if user_input.state == 'new': # Intro page
data = {'survey': survey, 'page': None, 'token': user_input.token}
return request.render('survey.survey_init', data)
else:
return request.redirect('/survey/fill/%s/%s' %
(survey.id, user_input.token))
def confirm_subscribe(self, channel, partner_id, token, **kw):
subscriber = request.env['mail.channel.partner'].search([
('channel_id', '=', channel.id), ('partner_id', '=', partner_id)
])
if subscriber:
# already registered, maybe clicked twice
return request.render(
'website_mail_channel.invalid_token_subscription')
subscriber_token = channel._generate_action_token(partner_id,
action='subscribe')
if token != subscriber_token:
return request.render(
'website_mail_channel.invalid_token_subscription')
# add partner
channel.sudo().write({'channel_partner_ids': [(4, partner_id)]})
return request.render("website_mail_channel.confirmation_subscription",
{'subscribing': True})
def jobs_apply(self, job, **kwargs):
error = {}
default = {}
if 'website_hr_recruitment_error' in request.session:
error = request.session.pop('website_hr_recruitment_error')
default = request.session.pop('website_hr_recruitment_default')
return request.render("website_hr_recruitment.apply", {
'job': job,
'error': error,
'default': default,
})
def question_ask_for_close(self, forum, question, **post):
reasons = request.env['forum.post.reason'].search([('reason_type', '=',
'basic')])
values = self._prepare_forum_values(**post)
values.update({
'question': question,
'forum': forum,
'reasons': reasons,
})
return request.render("website_forum.close_post", values)
