def blog_feed(self, blog, limit='15', **kwargs): v = {} v['blog'] = blog v['base_url'] = request.env['ir.config_parameter'].sudo().get_param( 'web.base.url') v['posts'] = request.env['blog.post'].search( [('blog_id', '=', blog.id)], limit=min(int(limit), 50), order="post_date DESC") v['html2plaintext'] = html2plaintext r = request.render("website_blog.blog_feed", v, headers=[('Content-Type', 'application/atom+xml')]) return r
def post_edit(self, forum, post, **kwargs): tags = [dict(id=tag.id, name=tag.name) for tag in post.tag_ids] tags = json.dumps(tags) values = self._prepare_forum_values(forum=forum) values.update({ 'tags': tags, 'post': post, 'is_answer': bool(post.parent_id), 'searches': kwargs, 'post_name': post.content_link, 'content': post.name, }) template = "website_forum.new_link" if post.post_type == 'link' and not post.parent_id else "website_forum.edit_post" return request.render(template, values)
def jobs_apply(self, job, **kwargs): if not job.can_access_from_current_website(): raise NotFound() 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 pages_management(self, page=1, sortby='url', search='', **kw): # only website_designer should access the page Management if not request.env.user.has_group('website.group_website_designer'): raise werkzeug.exceptions.NotFound() Page = request.env['website.page'] searchbar_sortings = { 'url': { 'label': _('Sort by Url'), 'order': 'url' }, 'name': { 'label': _('Sort by Name'), 'order': 'name' }, } # default sortby order sort_order = searchbar_sortings.get( sortby, 'url')['order'] + ', website_id desc, id' domain = request.website.website_domain() if search: domain += [ '|', ('name', 'ilike', search), ('url', 'ilike', search) ] pages = Page.search(domain, order=sort_order) if sortby != 'url' or not request.env.user.has_group( 'website.group_multi_website'): pages = pages.filtered(pages._is_most_specific_page) pages_count = len(pages) step = 50 pager = portal_pager(url="/website/pages", url_args={'sortby': sortby}, total=pages_count, page=page, step=step) pages = pages[(page - 1) * step:page * step] values = { 'pager': pager, 'pages': pages, 'search': search, 'sortby': sortby, 'searchbar_sortings': searchbar_sortings, } return request.render("website.list_website_pages", values)
def offensive_posts(self, forum, **kwargs): user = request.env.user if user.karma < forum.karma_moderate: raise werkzeug.exceptions.NotFound() Post = request.env['forum.post'] domain = [('forum_id', '=', forum.id), ('state', '=', 'offensive'), ('active', '=', False)] offensive_posts_ids = Post.search(domain, order='write_date DESC') values = self._prepare_forum_values(forum=forum) values.update({ 'posts_ids': offensive_posts_ids, 'queue_type': 'offensive', }) return request.render("website_forum.moderation_queue", values)
def website_info(self, **kwargs): try: request.website.get_template('website.website_info').name except Exception as e: return request.env['ir.http']._handle_exception(e) Module = request.env['ir.module.module'].sudo() apps = Module.search([('state', '=', 'installed'), ('application', '=', True)]) modules = Module.search([('state', '=', 'installed'), ('application', '=', False)]) values = { 'apps': apps, 'modules': modules, 'version': swerp.service.common.exp_version() } return request.render('website.website_info', values)
def validation_queue(self, forum, **kwargs): user = request.env.user if user.karma < forum.karma_moderate: raise werkzeug.exceptions.NotFound() Post = request.env['forum.post'] domain = [('forum_id', '=', forum.id), ('state', '=', 'pending')] posts_to_validate_ids = Post.search(domain) values = self._prepare_forum_values(forum=forum) values.update({ 'posts_ids': posts_to_validate_ids, 'queue_type': 'validation', }) return request.render("website_forum.moderation_queue", values)
def confirm(self, **kw): tx_id = int(kw.get('tx_id', 0)) if tx_id: 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 else: status = 'danger' message = tx.acquirer_id.error_msg PaymentProcessing.remove_payment_transaction(tx) return request.render('payment.confirm', {'tx': tx, 'status': status, 'message': message}) else: return request.redirect('/my/home')
def payment_method(self, **kwargs): acquirers = list(request.env['payment.acquirer'].search([ ('website_published', '=', True), ('registration_view_template_id', '!=', False), ('payment_flow', '=', 's2s'), ('company_id', '=', request.env.user.company_id.id) ])) partner = request.env.user.partner_id payment_tokens = partner.payment_token_ids payment_tokens |= partner.commercial_partner_id.sudo().payment_token_ids return_url = request.params.get('redirect', '/my/payment_method') values = { 'pms': payment_tokens, 'acquirers': acquirers, 'error_message': [kwargs['error']] if kwargs.get('error') else False, 'return_url': return_url, 'bootstrap_formatting': True, 'partner_id': partner.id } return request.render("payment.pay_methods", values)
def submit(self, survey, **post): _logger.debug('Incoming data: %s', post) page_id = int(post['page_id']) questions = request.env['survey.question'].search([('page_id', '=', page_id)]) # Answer validation errors = {} for question in questions: answer_tag = "%s_%s_%s" % (survey.id, page_id, question.id) errors.update(question.validate_question(post, answer_tag)) ret = {} if len(errors): # Return errors messages to webpage ret['errors'] = errors else: # Store answers into database try: user_input = request.env['survey.user_input'].sudo().search( [('token', '=', post['token'])], limit=1) except KeyError: # Invalid token return request.render("survey.403", {'survey': survey}) user_id = request.env.user.id if user_input.type != 'link' else SUPERUSER_ID for question in questions: answer_tag = "%s_%s_%s" % (survey.id, page_id, question.id) request.env['survey.user_input_line'].sudo( user=user_id).save_lines(user_input.id, question, post, answer_tag) go_back = post['button_submit'] == 'previous' next_page, _, last = request.env['survey.survey'].next_page( user_input, page_id, go_back=go_back) vals = {'last_displayed_page_id': page_id} if next_page is None and not go_back: vals.update({'state': 'done'}) else: vals.update({'state': 'skip'}) user_input.sudo(user=user_id).write(vals) ret['redirect'] = '/survey/fill/%s/%s' % (survey.id, post['token']) if go_back: ret['redirect'] += '/prev' return json.dumps(ret)
def view(self, **post): groups = request.env['mail.channel'].search([('alias_id.alias_name', '!=', False)]) # compute statistics month_date = datetime.today() - relativedelta.relativedelta(months=1) # use sudo to avoid side-effects due to custom ACLs messages = request.env['mail.message'].sudo().read_group([ ('model', '=', 'mail.channel'), ('date', '>=', fields.Datetime.to_string(month_date)), ('message_type', '!=', 'notification'), ('res_id', 'in', groups.ids), ], ['res_id'], ['res_id']) message_data = dict((message['res_id'], message['res_id_count']) for message in messages) group_data = dict( (group.id, {'monthly_message_nbr': message_data.get(group.id, 0), 'members_count': len(group.channel_partner_ids)}) for group in groups.sudo()) return request.render('website_mail_channel.mail_channels', {'groups': groups, 'group_data': group_data})
def web_auth_signup(self, *args, **kw): qcontext = self.get_auth_signup_qcontext() if not qcontext.get('token') and not qcontext.get('signup_enabled'): raise werkzeug.exceptions.NotFound() if 'error' not in qcontext and request.httprequest.method == 'POST': try: self.do_signup(qcontext) # Send an account creation confirmation email if qcontext.get('token'): User = request.env['res.users'] user_sudo = User.sudo().search( User._get_login_domain(qcontext.get('login')), order=User._get_login_order(), limit=1) template = request.env.ref( 'auth_signup.mail_template_user_signup_account_created', raise_if_not_found=False) if user_sudo and template: template.sudo().with_context( lang=user_sudo.lang, auth_login=werkzeug.url_encode( {'auth_login': user_sudo.email}), ).send_mail(user_sudo.id, force_send=True) return self.web_login(*args, **kw) except UserError as e: qcontext['error'] = e.name or e.value except (SignupError, AssertionError) as e: if request.env["res.users"].sudo().search([ ("login", "=", qcontext.get("login")) ]): qcontext["error"] = _( "Another user is already registered using this email address." ) else: _logger.error("%s", e) qcontext['error'] = _("Could not create a new account.") response = request.render('auth_signup.signup', qcontext) response.headers['X-Frame-Options'] = 'DENY' return response
def event_track_proposal_post(self, event, **post): if not event.can_access_from_current_website(): raise NotFound() tags = [] for tag in event.allowed_track_tag_ids: if post.get('tag_' + str(tag.id)): tags.append(tag.id) track = request.env['event.track'].sudo().create({ 'name': post['track_name'], 'partner_name': post['partner_name'], 'partner_email': post['email_from'], 'partner_phone': post['phone'], 'partner_biography': escape(post['biography']), 'event_id': event.id, 'tag_ids': [(6, 0, tags)], 'user_id': False, 'description': escape(post['description']) }) if request.env.user != request.website.user_id: track.sudo().message_subscribe( partner_ids=request.env.user.partner_id.ids) else: partner = request.env['res.partner'].sudo().search([ ('email', '=', post['email_from']) ]) if partner: track.sudo().message_subscribe(partner_ids=partner.ids) return request.render( "website_event_track.event_track_proposal_success", { 'track': track, 'event': event })
def event_page(self, event, page, **post): if not event.can_access_from_current_website(): raise werkzeug.exceptions.NotFound() values = {'event': event, 'main_object': event} if '.' not in page: page = 'website_event.%s' % page try: request.website.get_template(page) except ValueError: # page not found values['path'] = re.sub(r"^website_event\.", '', page) values[ 'from_template'] = 'website_event.default_page' # .strip('website_event.') page = 'website.%s' % (request.website.is_publisher() and 'page_404' or '404') return request.render(page, values)
def registration_confirm(self, event, **post): if not event.can_access_from_current_website(): raise werkzeug.exceptions.NotFound() Attendees = request.env['event.registration'] registrations = self._process_registration_details(post) for registration in registrations: registration['event_id'] = event Attendees += Attendees.sudo().create( Attendees._prepare_attendee_values(registration)) urls = event._get_event_resource_urls(Attendees.ids) return request.render( "website_event.registration_complete", { 'attendees': Attendees.sudo(), 'event': event, 'google_url': urls.get('google_url'), 'iCal_url': urls.get('iCal_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 event_tracks(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') searches = {} if tag: searches.update(tag=tag.id) tracks = event.track_ids.filtered( lambda track: tag in track.tag_ids) else: tracks = event.track_ids values = { 'event': event, 'main_object': event, 'tracks': tracks, 'tags': event.tracks_tag_ids, 'searches': searches, 'html2plaintext': html2plaintext } return request.render("website_event_track.tracks", values)
def portal_my_opportunity(self, opp, **kw): if opp.type != 'opportunity': raise NotFound() return request.render( "website_crm_partner_assign.portal_my_opportunity", { 'opportunity': opp, 'user_activity': opp.sudo().activity_ids.filtered( lambda activity: activity.user_id == request.env.user)[:1], 'stages': request.env['crm.stage'].search( [('probability', '!=', '100')], order='sequence desc, name desc, id desc'), 'activity_types': request.env['mail.activity.type'].sudo().search([]), 'states': request.env['res.country.state'].sudo().search([]), 'countries': request.env['res.country'].sudo().search([]), })
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)) return False
def google_map(self, *arg, **post): clean_ids = [] for partner_id in post.get('partner_ids', "").split(","): try: clean_ids.append(int(partner_id)) except ValueError: pass partners = request.env['res.partner'].sudo().search([ ("id", "in", clean_ids), ('website_published', '=', True), ('is_company', '=', True) ]) partner_data = {"counter": len(partners), "partners": []} for partner in partners.with_context(show_address=True): # TODO in master, do not use `escape` but `t-esc` in the qweb template. partner_data["partners"].append({ 'id': partner.id, 'name': escape(partner.name), 'address': escape('\n'.join(partner.name_get()[0][1].split('\n')[1:])), 'latitude': escape(str(partner.partner_latitude)), 'longitude': escape(str(partner.partner_longitude)), }) if 'customers' in post.get('partner_url', ''): partner_url = '/customers/' else: partner_url = '/partners/' google_maps_api_key = request.website.google_maps_api_key values = { 'partner_url': partner_url, 'partner_data': json.dumps(partner_data), 'google_maps_api_key': google_maps_api_key, } return request.render("website_google_map.google_map", values)
def thread_discussion(self, group, message, mode='thread', date_begin=None, date_end=None, **post): if group.channel_type != 'channel': raise werkzeug.exceptions.NotFound() Message = request.env['mail.message'] if mode == 'thread': base_domain = [('model', '=', 'mail.channel'), ('res_id', '=', group.id), ('parent_id', '=', message.parent_id and message.parent_id.id or False)] else: base_domain = [('model', '=', 'mail.channel'), ('res_id', '=', group.id)] next_message = Message.search(base_domain + [('date', '<', message.date)], order="date DESC", limit=1) or None prev_message = Message.search(base_domain + [('date', '>', message.date)], order="date", limit=1) or None values = { 'message': message, 'group': group, 'mode': mode, 'archives': self._get_archives(group.id), 'date_begin': date_begin, 'date_end': date_end, 'replies_per_page': self._replies_per_page, 'next_message': next_message, 'prev_message': prev_message, } return request.render('website_mail_channel.group_message', values)
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 = OrderedDict() attrs = products.mapped( 'product_tmpl_id.valid_product_template_attribute_line_ids.attribute_id' ).filtered(lambda x: x.create_variant != 'no_variant') for attr in attrs.sorted(lambda att: (att.category_id.sequence, att.sequence)): cat_name = attr.category_id.name or _('Uncategorized') res.setdefault(cat_name, OrderedDict()).setdefault(attr.name, [' - '] * len(products)) for num, product in enumerate(products): for var in product.product_tmpl_id.valid_product_template_attribute_line_ids.filtered( lambda x: x.attribute_id.create_variant != 'no_variant'): cat_name = var.attribute_id.category_id.name or _( 'Uncategorized') att_name = var.attribute_id.name 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 portal_my_invoice_detail(self, invoice_id, access_token=None, report_type=None, download=False, **kw): try: invoice_sudo = self._document_check_access('account.invoice', invoice_id, access_token) except (AccessError, MissingError): return request.redirect('/my') if report_type in ('html', 'pdf', 'text'): return self._show_report(model=invoice_sudo, report_type=report_type, report_ref='account.account_invoices', download=download) values = self._invoice_get_page_view_values(invoice_sudo, access_token, **kw) PaymentProcessing.remove_payment_transaction( invoice_sudo.transaction_ids) return request.render("account.portal_invoice_page", values)
def page(self, project_id=None, **kw): user = request.env.user project = request.env['project.project'].sudo().browse(project_id) # to avoid giving any access rights on projects to the public user, let's use sudo # and check if the user should be able to view the project (project managers only if it's unpublished or has no rating) if not ( (project.rating_status != 'no') and project.portal_show_rating ) and not user.sudo(user).has_group('project.group_project_manager'): raise NotFound() return request.render( 'project.rating_project_rating_page', { 'project': project, 'ratings': request.env['rating.rating'].sudo().search( [('consumed', '=', True), ('parent_res_model', '=', 'project.project'), ('parent_res_id', '=', project_id)], order='write_date DESC', limit=50), 'statistics': self._calculate_period_partner_stats(project_id), })
def portal_my_quotes(self, page=1, date_begin=None, date_end=None, sortby=None, **kw): values = self._prepare_portal_layout_values() partner = request.env.user.partner_id SaleOrder = request.env['sale.order'] domain = [('message_partner_ids', 'child_of', [partner.commercial_partner_id.id]), ('state', 'in', ['sent', 'cancel'])] searchbar_sortings = { 'date': { 'label': _('Order Date'), 'order': 'date_order desc' }, 'name': { 'label': _('Reference'), 'order': 'name' }, 'stage': { 'label': _('Stage'), 'order': 'state' }, } # default sortby order if not sortby: sortby = 'date' sort_order = searchbar_sortings[sortby]['order'] archive_groups = self._get_archive_groups('sale.order', domain) if date_begin and date_end: domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)] # count for pager quotation_count = SaleOrder.search_count(domain) # make pager pager = portal_pager(url="/my/quotes", url_args={ 'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby }, total=quotation_count, page=page, step=self._items_per_page) # search the count to display, according to the pager data quotations = SaleOrder.search(domain, order=sort_order, limit=self._items_per_page, offset=pager['offset']) request.session['my_quotations_history'] = quotations.ids[:100] values.update({ 'date': date_begin, 'quotations': quotations.sudo(), 'page_name': 'quote', 'pager': pager, 'archive_groups': archive_groups, 'default_url': '/my/quotes', 'searchbar_sortings': searchbar_sortings, 'sortby': sortby, }) return request.render("sale.portal_my_quotations", values)
def portal_order_page(self, order_id, report_type=None, access_token=None, message=False, download=False, **kw): try: order_sudo = self._document_check_access('sale.order', order_id, access_token=access_token) except (AccessError, MissingError): return request.redirect('/my') if report_type in ('html', 'pdf', 'text'): return self._show_report(model=order_sudo, report_type=report_type, report_ref='sale.action_report_saleorder', download=download) # use sudo to allow accessing/viewing orders for public user # only if he knows the private token # Log only once a day if order_sudo: now = fields.Date.today().isoformat() session_obj_date = request.session.get('view_quote_%s' % order_sudo.id) if isinstance(session_obj_date, date): session_obj_date = session_obj_date.isoformat() if session_obj_date != now and request.env.user.share and access_token: request.session['view_quote_%s' % order_sudo.id] = now body = _('Quotation viewed by customer') _message_post_helper( res_model='sale.order', res_id=order_sudo.id, message=body, token=order_sudo.access_token, message_type='notification', subtype="mail.mt_note", partner_ids=order_sudo.user_id.sudo().partner_id.ids) values = { 'sale_order': order_sudo, 'message': message, 'token': access_token, 'return_url': '/shop/payment/validate', 'bootstrap_formatting': True, 'partner_id': order_sudo.partner_id.id, 'report_type': 'html', } if order_sudo.company_id: values['res_company'] = order_sudo.company_id if order_sudo.has_to_be_paid(): domain = expression.AND( [[ '&', ('website_published', '=', True), ('company_id', '=', order_sudo.company_id.id) ], [ '|', ('specific_countries', '=', False), ('country_ids', 'in', [order_sudo.partner_id.country_id.id]) ]]) acquirers = request.env['payment.acquirer'].sudo().search(domain) values['acquirers'] = acquirers.filtered(lambda acq: ( acq.payment_flow == 'form' and acq.view_template_id) or ( acq.payment_flow == 's2s' and acq. registration_view_template_id)) values['pms'] = request.env['payment.token'].search([ ('partner_id', '=', order_sudo.partner_id.id) ]) if order_sudo.state in ('draft', 'sent', 'cancel'): history = request.session.get('my_quotations_history', []) else: history = request.session.get('my_orders_history', []) values.update(get_records_pager(history, order_sudo)) return request.render('sale.sale_order_portal_template', values)
def pay(self, reference='', order_id=None, amount=False, currency_id=None, acquirer_id=None, **kw): env = request.env user = env.user.sudo() # Default values values = { 'amount': 0.0, 'currency': user.company_id.currency_id, } # Check sale order if order_id: try: order_id = int(order_id) order = env['sale.order'].browse(order_id) values.update({ 'currency': order.currency_id, 'amount': order.amount_total, 'order_id': order_id }) except: order_id = None # Check currency if currency_id: try: currency_id = int(currency_id) values['currency'] = env['res.currency'].browse(currency_id) except: pass # Check amount if amount: try: amount = float(amount) values['amount'] = amount except: pass # Check reference reference_values = order_id and {'sale_order_ids': [(4, order_id)]} or {} values['reference'] = env['payment.transaction']._compute_reference(values=reference_values, prefix=reference) # Check acquirer acquirers = None if acquirer_id: acquirers = env['payment.acquirer'].browse(int(acquirer_id)) if not acquirers: acquirers = env['payment.acquirer'].search([('website_published', '=', True), ('company_id', '=', user.company_id.id)]) # Check partner partner_id = user.partner_id.id if not user._is_public() else False values.update({ 'partner_id': partner_id, 'bootstrap_formatting': True, 'error_msg': kw.get('error_msg') }) values['acquirers'] = [acq for acq in acquirers if acq.payment_flow in ['form', 's2s']] values['pms'] = request.env['payment.token'].search([('acquirer_id', 'in', acquirers.filtered(lambda x: x.payment_flow == 's2s').ids)]) return request.render('payment.pay', values)
def portal_my_purchase_orders(self, page=1, date_begin=None, date_end=None, sortby=None, filterby=None, **kw): values = self._prepare_portal_layout_values() partner = request.env.user.partner_id PurchaseOrder = request.env['purchase.order'] domain = [] archive_groups = self._get_archive_groups('purchase.order', domain) if date_begin and date_end: domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)] searchbar_sortings = { 'date': { 'label': _('Newest'), 'order': 'create_date desc, id desc' }, 'name': { 'label': _('Name'), 'order': 'name asc, id asc' }, 'amount_total': { 'label': _('Total'), 'order': 'amount_total desc, id desc' }, } # default sort by value if not sortby: sortby = 'date' order = searchbar_sortings[sortby]['order'] searchbar_filters = { 'all': { 'label': _('All'), 'domain': [('state', 'in', ['purchase', 'done', 'cancel'])] }, 'purchase': { 'label': _('Purchase Order'), 'domain': [('state', '=', 'purchase')] }, 'cancel': { 'label': _('Cancelled'), 'domain': [('state', '=', 'cancel')] }, 'done': { 'label': _('Locked'), 'domain': [('state', '=', 'done')] }, } # default filter by value if not filterby: filterby = 'all' domain += searchbar_filters[filterby]['domain'] # count for pager purchase_count = PurchaseOrder.search_count(domain) # make pager pager = portal_pager(url="/my/purchase", url_args={ 'date_begin': date_begin, 'date_end': date_end }, total=purchase_count, page=page, step=self._items_per_page) # search the purchase orders to display, according to the pager data orders = PurchaseOrder.search(domain, order=order, limit=self._items_per_page, offset=pager['offset']) request.session['my_purchases_history'] = orders.ids[:100] values.update({ 'date': date_begin, 'orders': orders, 'page_name': 'purchase', 'pager': pager, 'archive_groups': archive_groups, 'searchbar_sortings': searchbar_sortings, 'sortby': sortby, 'searchbar_filters': OrderedDict(sorted(searchbar_filters.items())), 'filterby': filterby, 'default_url': '/my/purchase', }) return request.render("purchase.portal_my_purchase_orders", values)
def portal_my_leads(self, page=1, date_begin=None, date_end=None, sortby=None, **kw): values = self._prepare_portal_layout_values() CrmLead = request.env['crm.lead'] domain = self.get_domain_my_lead(request.env.user) searchbar_sortings = { 'date': { 'label': _('Newest'), 'order': 'create_date desc' }, 'name': { 'label': _('Name'), 'order': 'name' }, 'contact_name': { 'label': _('Contact Name'), 'order': 'contact_name' }, } # default sort by value if not sortby: sortby = 'date' order = searchbar_sortings[sortby]['order'] # archive groups - Default Group By 'create_date' archive_groups = self._get_archive_groups('crm.lead', domain) if date_begin and date_end: domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)] # pager lead_count = CrmLead.search_count(domain) pager = request.website.pager(url="/my/leads", url_args={ 'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby }, total=lead_count, page=page, step=self._items_per_page) # content according to pager and archive selected leads = CrmLead.search(domain, order=order, limit=self._items_per_page, offset=pager['offset']) values.update({ 'date': date_begin, 'leads': leads, 'page_name': 'lead', 'archive_groups': archive_groups, 'default_url': '/my/leads', 'pager': pager, 'searchbar_sortings': searchbar_sortings, 'sortby': sortby, }) return request.render("website_crm_partner_assign.portal_my_leads", values)
def partners(self, country=None, grade=None, page=0, **post): country_all = post.pop('country_all', False) partner_obj = request.env['res.partner'] country_obj = request.env['res.country'] search = post.get('search', '') base_partner_domain = [('is_company', '=', True), ('grade_id', '!=', False), ('website_published', '=', True)] if not request.env['res.users'].has_group( 'website.group_website_publisher'): base_partner_domain += [('grade_id.website_published', '=', True)] if search: base_partner_domain += [ '|', ('name', 'ilike', search), ('website_description', 'ilike', search) ] # group by grade grade_domain = list(base_partner_domain) if not country and not country_all: country_code = request.session['geoip'].get('country_code') if country_code: country = country_obj.search([('code', '=', country_code)], limit=1) if country: grade_domain += [('country_id', '=', country.id)] grades = partner_obj.sudo().read_group(grade_domain, ["id", "grade_id"], groupby="grade_id") grades_partners = partner_obj.sudo().search_count(grade_domain) # flag active grade for grade_dict in grades: grade_dict[ 'active'] = grade and grade_dict['grade_id'][0] == grade.id grades.insert( 0, { 'grade_id_count': grades_partners, 'grade_id': (0, _("All Categories")), 'active': bool(grade is None), }) # group by country country_domain = list(base_partner_domain) if grade: country_domain += [('grade_id', '=', grade.id)] countries = partner_obj.sudo().read_group(country_domain, ["id", "country_id"], groupby="country_id", orderby="country_id") countries_partners = partner_obj.sudo().search_count(country_domain) # flag active country for country_dict in countries: country_dict['active'] = country and country_dict[ 'country_id'] and country_dict['country_id'][0] == country.id countries.insert( 0, { 'country_id_count': countries_partners, 'country_id': (0, _("All Countries")), 'active': bool(country is None), }) # current search if grade: base_partner_domain += [('grade_id', '=', grade.id)] if country: base_partner_domain += [('country_id', '=', country.id)] # format pager if grade and not country: url = '/partners/grade/' + slug(grade) elif country and not grade: url = '/partners/country/' + slug(country) elif country and grade: url = '/partners/grade/' + slug(grade) + '/country/' + slug( country) else: url = '/partners' url_args = {} if search: url_args['search'] = search if country_all: url_args['country_all'] = True partner_count = partner_obj.sudo().search_count(base_partner_domain) pager = request.website.pager(url=url, total=partner_count, page=page, step=self._references_per_page, scope=7, url_args=url_args) # search partners matching current search parameters partner_ids = partner_obj.sudo().search( base_partner_domain, order= "grade_sequence DESC, implemented_count DESC, display_name ASC, id ASC", offset=pager['offset'], limit=self._references_per_page) partners = partner_ids.sudo() google_map_partner_ids = ','.join(str(p.id) for p in partners) google_maps_api_key = request.website.google_maps_api_key values = { 'countries': countries, 'current_country': country, 'grades': grades, 'current_grade': grade, 'partners': partners, 'google_map_partner_ids': google_map_partner_ids, 'pager': pager, 'searches': post, 'search_path': "%s" % werkzeug.url_encode(post), 'google_maps_api_key': google_maps_api_key, } return request.render("website_crm_partner_assign.index", values, status=partners and 200 or 404)