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)
