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 slides_embed(self, slide_id, page="1", **kw): # Note : don't use the 'model' in the route (use 'slide_id'), otherwise if public cannot access the embedded # slide, the error will be the website.403 page instead of the one of the website_slides.embed_slide. # Do not forget the rendering here will be displayed in the embedded iframe # determine if it is embedded from external web page referrer_url = request.httprequest.headers.get('Referer', '') base_url = request.env['ir.config_parameter'].sudo().get_param( 'web.base.url') is_embedded = referrer_url and not bool( base_url in referrer_url) or False # try accessing slide, and display to corresponding template try: slide = request.env['slide.slide'].browse(slide_id) if is_embedded: request.env['slide.embed'].sudo()._add_embed_url( slide.id, referrer_url) values = self._get_slide_detail(slide) values['page'] = page values['is_embedded'] = is_embedded self._set_viewed_slide(slide) return request.render('website_slides.embed_slide', values) except AccessError: # TODO : please, make it clean one day, or find another secure way to detect # if the slide can be embedded, and properly display the error message. return request.render('website_slides.embed_slide_forbidden', {})
def view_user_profile(self, user_id, **post): user = self._check_user_profile_access(user_id) if not user: return request.render("website_profile.private_profile") values = self._prepare_user_values(**post) params = self._prepare_user_profile_parameters(**post) values.update(self._prepare_user_profile_values(user, **params)) return request.render("website_profile.user_profile_main", values)
def render_student_verification(self, **post): """ inherit render_student_verification method, student additional form should student admission form. ------------------------------------------------------ @param self : object pointer @param type : http @param auth : public @param website : booleab(True) @return : """ if 'DATE' in post and post['DATE']: data = post['DATE'] link_date = self.decode_base64(data) if link_date == '': return request.render("website_student_enquiry.student_link_expired_templet",{}) if 'ENQUIRY' in post and post['ENQUIRY']: eq_no = str(post['ENQUIRY']) env = request.env(context=dict(request.env.context, show_address=True, no_tag_br=True)) reg_obj = env['registration'] reg_rec = reg_obj.sudo().search([('enquiry_no','=',eq_no)],limit=1) if reg_rec.id: if reg_rec.add_form_filled != True: if link_date != '0000-00-00': s_date = datetime.strptime(link_date, '%Y-%m-%d').date() l_date = s_date + timedelta(days=10) c_date = date.today() if s_date <= c_date < l_date: if 'ENQUIRY' in post and post['ENQUIRY']: student_obj = env['res.partner'] student_rec = student_obj.sudo().search(['|',('active','=',True), ('strike_off','=',True), ('is_student','=',True), ('reg_no','=',eq_no)],limit=1) if student_rec.id: e_student_id = base64.b64encode(str(student_rec.id)) return request.redirect( "/student/verification/pagecode?student_id=%s" % (e_student_id)) else: return request.render("website_student_enquiry.student_link_expired_templet",{}) else: if 'ENQUIRY' in post and post['ENQUIRY']: eq_no = str(post['ENQUIRY']) env = request.env(context=dict(request.env.context, show_address=True, no_tag_br=True)) student_obj = env['res.partner'] student_rec = student_obj.sudo().search(['|',('active','=',True), ('strike_off','=',True), ('is_student','=',True), ('reg_no','=',eq_no)],limit=1) if student_rec.id: e_student_id = base64.b64encode(str(student_rec.id)) return request.redirect( "/student/verification/pagecode?student_id=%s" % (e_student_id)) else: return request.render("website_student_enquiry.student_link_expired_templet",{})
def slides_index(self, *args, **post): """ Returns a list of available channels: if only one is available, redirects directly to its slides """ domain = request.website.website_domain() channels = request.env['slide.channel'].search(domain, 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 confirm(self, **kw): tx_id = int(kw.get('tx_id', 0)) access_token = kw.get('access_token') if tx_id: if access_token: tx = request.env['payment.transaction'].sudo().browse(tx_id) secret = request.env['ir.config_parameter'].sudo().get_param( 'database.secret') valid_token_str = '%s%s%s' % (tx.id, tx.reference, tx.amount) valid_token = hmac.new(secret.encode('utf-8'), valid_token_str.encode('utf-8'), hashlib.sha256).hexdigest() if not consteq(ustr(valid_token), access_token): raise werkzeug.exceptions.NotFound else: tx = request.env['payment.transaction'].browse(tx_id) if tx.state in ['done', 'authorized']: status = 'success' message = tx.acquirer_id.done_msg elif tx.state == 'pending': status = 'warning' message = tx.acquirer_id.pending_msg PaymentProcessing.remove_payment_transaction(tx) return request.render('payment.confirm', { 'tx': tx, 'status': status, 'message': message }) else: return request.redirect('/my/home')
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.product_tmpl_id._get_valid_product_template_attribute_lines( ): cat_name = var.attribute_id.category_id.name or _( 'Uncategorized') att_name = var.attribute_id.name if not var.attribute_id.create_variant: continue res.setdefault(cat_name, OrderedDict()).setdefault( att_name, [' - '] * len(products)) val = product.attribute_value_ids.filtered( lambda x: x.attribute_id == var.attribute_id) if val: res[cat_name][att_name][num] = val[0].name values['specs'] = res values['compute_currency'] = self._get_compute_currency_and_context( products[:1].product_tmpl_id)[0] return request.render("website_sale_comparison.product_compare", values)
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 shop(self, page=0, category=None, search='', ppg=False, **post): if post.get('filter_clear'): return request.redirect('/shop') if post.get('filter_remove'): category = None values = self.ks_getShopValues(page, category, search, ppg, **post) return request.render("website_sale.products", 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 survey_report(self, survey, answer_token=None, **post): '''Display survey Results & Statistics for given survey.''' result_template = 'survey.result' current_filters = [] filter_display_data = [] filter_finish = False answers = survey.user_input_ids.filtered( lambda answer: answer.state != 'new' and not answer.test_entry) 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, 'answers': answers, '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 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 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 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 render_employement_form(self, **post): """ this method is used to Student email varification, if write email id then move to page that he is update his information and fill other details. ------------------------------------------ @param self : object pointer @param type : http @param auth : public @param website : True @return : call templet also pass dictonary for required data """ employee_id = post.get('employee') env = request.env(context=dict(request.env.context)) hr_emp_obj = env['hr.employee'] ir_model_fields_obj = env['ir.model.fields'] hr_emp_rec = hr_emp_obj.sudo().search([('id','=',employee_id)]) # if hr_emp_rec.employment_form_filled == True: # return request.render("edsys_hrm.employement_link_expired_templet",{}) orm_country = env['res.country'] orm_currency = env['res.currency'] state_orm = env['res.country.state'] orm_visa_type = env['visa.type'] orm_ir_attachment = env['ir.attachment'] countries = orm_country.sudo().search([]) currencies = orm_currency.sudo().search([]) states = state_orm.sudo().search([]) visa_type_ids = orm_visa_type.sudo().search([]) resume_ids = orm_ir_attachment.sudo().search([('name','=','Resume'),('res_model','=', 'hr.employee'), ('res_id','=',hr_emp_rec.id)]) if not resume_ids : resume_ids = False salary_certificate_ids = orm_ir_attachment.sudo().search([('name','=','Salary Certificate'),('res_model','=', 'hr.employee'), ('res_id','=',hr_emp_rec.id)]) if not salary_certificate_ids : salary_certificate_ids = False passport_copy_ids = orm_ir_attachment.sudo().search([('name','=','Passport'),('res_model','=', 'hr.employee'), ('res_id','=',hr_emp_rec.id)]) if not passport_copy_ids : passport_copy_ids = False relieving_letter_ids = orm_ir_attachment.sudo().search([('name','=','Relieving Letter'),('res_model','=', 'hr.employee'), ('res_id','=',hr_emp_rec.id)]) if not relieving_letter_ids : relieving_letter_ids = False if hr_emp_rec.id : if hr_emp_rec.image_medium : image_medium = True else : image_medium = False hr_web_data = { 'hr_emp_rec' : hr_emp_rec, 'countries' : countries, 'currencies' : currencies, 'states' : states, 'visa_type_ids' : visa_type_ids, 'resume_ids' : resume_ids, 'salary_certificate_ids' : salary_certificate_ids, 'relieving_letter_ids' : relieving_letter_ids, 'passport_copy_ids' : passport_copy_ids, 'image_medium' : image_medium, } return request.render("edsys_hrm.website_epmloyement_application_form",hr_web_data)
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() urls = event._get_event_resource_urls(list(attendee_ids)) return request.render( "website_event.registration_complete", { 'attendees': attendees, 'event': event, 'google_url': urls.get('google_url'), 'iCal_url': urls.get('iCal_url') }) return request.redirect("/shop/checkout")
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 productVariants(self, product, **post): pricelist = request.website.get_current_pricelist() return request.render( "update_variants_in_cart.variantUpdateForm", { 'product': product.with_context(pricelist=int(pricelist)), 'previous_line_id': post.get('previous_line_id', False) })
def pos_web(self, config_id=False, **k): """Open a pos session for the given config. The right pos session will be selected to open, if non is open yet a new session will be created. :param debug: The debug mode to load the session in. :type debug: str. :param config_id: id of the config that has to be loaded. :type config_id: str. :returns: object -- The rendered pos session. """ domain = [('state', '=', 'opened'), ('user_id', '=', request.session.uid), ('rescue', '=', False)] if config_id: domain = AND([domain, [('config_id', '=', int(config_id))]]) pos_session = request.env['pos.session'].sudo().search(domain, limit=1) if not pos_session: return werkzeug.utils.redirect( '/web#action=point_of_sale.action_client_pos_menu') # The POS only work in one company, so we enforce the one of the session in the context session_info = request.env['ir.http'].session_info() session_info['user_context'][ 'allowed_company_ids'] = pos_session.company_id.ids context = { 'session_info': session_info, 'login_number': pos_session.login(), } return request.render('point_of_sale.index', qcontext=context)
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 _serve_page(cls): req_page = request.httprequest.path page_domain = [('url', '=', req_page) ] + request.website.website_domain() published_domain = page_domain # need to bypass website_published, to apply is_most_specific # filter later if not publisher pages = request.env['website.page'].sudo().search(published_domain, order='website_id') pages = pages.filtered(pages._is_most_specific_page) if not request.website.is_publisher(): pages = pages.filtered('is_visible') mypage = pages[0] if pages else False _, ext = os.path.splitext(req_page) if mypage: return request.render( mypage.get_view_identifier(), { # 'path': req_page[1:], 'deletable': True, 'main_object': mypage, }, mimetype=_guess_mimetype(ext))
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 featured_product_get_dynamic_slider(self, **post): uid, context, pool = request.uid, dict(request.context), request.env if post.get('slider-id'): slider_header = request.env['feature.product.slider.config'].sudo( ).search([('id', '=', int(post.get('slider-id')))]) if not context.get('pricelist'): pricelist = request.website.get_current_pricelist() context = dict(request.context, pricelist=int(pricelist)) else: pricelist = pool.get('product.pricelist').browse( context['pricelist']) context.update({'pricelist': pricelist.id}) from_currency = pool['res.users'].browse( uid).company_id.currency_id to_currency = pricelist.currency_id def compute_currency(price): return pool['res.currency']._convert(price, from_currency, to_currency, fields.Date.today()) values = { 'compute_currency': compute_currency, 'slider_header': slider_header } return request.render( "eagle_theme.eagle_theme_featured_product_slider_view", values)
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 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 eagleshop_product_multi_get_dynamic_slider(self, **post): context, pool = dict(request.context), request.env if post.get('slider-type'): slider_header = request.env['multi.slider.config'].sudo().search([ ('id', '=', int(post.get('slider-type'))) ]) if not context.get('pricelist'): pricelist = request.website.get_current_pricelist() context = dict(request.context, pricelist=int(pricelist)) else: pricelist = pool.get('product.pricelist').browse( context['pricelist']) context.update({'pricelist': pricelist.id}) from_currency = pool['res.users'].sudo().browse( SUPERUSER_ID).company_id.currency_id to_currency = pricelist.currency_id def compute_currency(price): return pool['res.currency']._convert(price, from_currency, to_currency, fields.Date.today()) values = { 'slider_details': slider_header, 'slider_header': slider_header, 'compute_currency': compute_currency } return request.render( "eagle_theme.eagle_theme_multi_cat_slider_view", values)
def event_agenda(self, event, tag=None, **post): if not event.can_access_from_current_website(): raise NotFound() 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: (bool( track.date), track.date, 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 product(self, product, category='', search='', **kwargs): seconds = 0 values = super(WebsiteSale, self).product(product, category, search) values.qcontext.update({ "current_url_fb": "http://www.facebook.com/sharer/sharer.php?u=" + request.httprequest.base_url, "current_url_twit": "https://twitter.com/intent/tweet?text=" + request.httprequest.base_url, "current_url_lin": "http://www.linkedin.com/shareArticle?mini=true-url=" + request.httprequest.base_url, "current_url_gplus": "https://plus.google.com/share?url=" + request.httprequest.base_url, "seconds": seconds, 'unit_of_measure_name':request.env['product.template'].browse(product.id).sudo()._get_weight_uom_name_from_ir_config_parameter() }) query = "select product_template_id FROM product_template_res_users where res_user_id = %s ORDER BY recently_viewed_date DESC" request.env.cr.execute(query, (request.env.user.id,)) ids = request.env.cr.fetchall() product_template_ids = [i[0] for i in ids] if product.id not in product_template_ids: request.env.cr.execute("insert into product_template_res_users" " (res_user_id, product_template_id,recently_viewed_date)" " values" " (%s, %s, %s)", (request.env.user.id, product.id, fields.Datetime.now())) else: request.env.cr.execute( 'UPDATE product_template_res_users SET recently_viewed_date=%s WHERE product_template_id=%s and res_user_id=%s', (fields.Datetime.now(), product.id, request.env.user.id)) return request.render("website_sale.product", values.qcontext)
def portal_my_purchase_order(self, order_id=None, access_token=None, **kw): try: order_sudo = self._document_check_access('purchase.order', order_id, access_token=access_token) except (AccessError, MissingError): return request.redirect('/my') values = self._purchase_order_get_page_view_values(order_sudo, access_token, **kw) return request.render("purchase.portal_my_purchase_order", values)
def jobs_detail(self, job, **kwargs): if not job.can_access_from_current_website(): raise NotFound() return request.render("website_hr_recruitment.detail", { 'job': job, 'main_object': job, })
def portal_my_project(self, project_id=None, access_token=None, **kw): try: project_sudo = self._document_check_access('project.project', project_id, access_token) except (AccessError, MissingError): return request.redirect('/my') values = self._project_get_page_view_values(project_sudo, access_token, **kw) return request.render("project.portal_my_project", values)