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)