def mailing(self, mailing_id, email=None, res_id=None, token="", **post):
mailing = request.env['mailing.mailing'].sudo().browse(mailing_id)
if mailing.exists():
res_id = res_id and int(res_id)
if not self._valid_unsubscribe_token(mailing_id, res_id, email, str(token)):
raise exceptions.AccessDenied()
if mailing.mailing_model_real == 'mailing.contact':
# Unsubscribe directly + Let the user choose his subscriptions
mailing.update_opt_out(email, mailing.contact_list_ids.ids, True)
contacts = request.env['mailing.contact'].sudo().search([('email_normalized', '=', tools.email_normalize(email))])
subscription_list_ids = contacts.mapped('subscription_list_ids')
# In many user are found : if user is opt_out on the list with contact_id 1 but not with contact_id 2,
# assume that the user is not opt_out on both
# TODO DBE Fixme : Optimise the following to get real opt_out and opt_in
opt_out_list_ids = subscription_list_ids.filtered(lambda rel: rel.opt_out).mapped('list_id')
opt_in_list_ids = subscription_list_ids.filtered(lambda rel: not rel.opt_out).mapped('list_id')
opt_out_list_ids = set([list.id for list in opt_out_list_ids if list not in opt_in_list_ids])
unique_list_ids = set([list.list_id.id for list in subscription_list_ids])
list_ids = request.env['mailing.list'].sudo().browse(unique_list_ids)
unsubscribed_list = ', '.join(str(list.name) for list in mailing.contact_list_ids if list.is_public)
return request.render('mass_mailing.page_unsubscribe', {
'contacts': contacts,
'list_ids': list_ids,
'opt_out_list_ids': opt_out_list_ids,
'unsubscribed_list': unsubscribed_list,
'email': email,
'mailing_id': mailing_id,
'res_id': res_id,
'show_blacklist_button': request.env['ir.config_parameter'].sudo().get_param('mass_mailing.show_blacklist_buttons'),
})
else:
opt_in_lists = request.env['mailing.contact.subscription'].sudo().search([
('contact_id.email_normalized', '=', email),
('opt_out', '=', False)
]).mapped('list_id')
blacklist_rec = request.env['mail.blacklist'].sudo()._add(email)
self._log_blacklist_action(
blacklist_rec, mailing_id,
_("""Requested blacklisting via unsubscribe link."""))
return request.render('mass_mailing.page_unsubscribed', {
'email': email,
'mailing_id': mailing_id,
'res_id': res_id,
'list_ids': opt_in_lists,
'show_blacklist_button': request.env['ir.config_parameter'].sudo().get_param(
'mass_mailing.show_blacklist_buttons'),
})
return request.redirect('/web')
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()
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 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 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 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 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 portal_my_invoice_detail(self,
invoice_id,
access_token=None,
report_type=None,
download=False,
**kw):
try:
invoice_sudo = self._document_check_access('account.move',
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)
acquirers = values.get('acquirers')
if acquirers:
country_id = values.get('partner_id') and values.get(
'partner_id')[0].country_id.id
values['acq_extra_fees'] = acquirers.get_acquirer_extra_fees(
invoice_sudo.amount_residual, invoice_sudo.currency_id,
country_id)
return request.render("account.portal_invoice_page", values)
def blog_feed(self, blog, limit='15', **kwargs):
v = {}
v['blog'] = blog
v['base_url'] = blog.get_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 blacklist_page(self, mailing_id, trace_code, **post):
check_res = self._check_trace(mailing_id, trace_code)
if not check_res.get('trace'):
return werkzeug.utils.redirect('/web')
return request.render('mass_mailing_sms.blacklist_main', {
'mailing_id': mailing_id,
'trace_code': trace_code,
})
def portal_my_task(self, task_id, access_token=None, **kw):
try:
task_sudo = self._document_check_access('project.task', task_id,
access_token)
except (AccessError, MissingError):
return request.redirect('/my')
values = self._task_get_page_view_values(task_sudo, access_token, **kw)
return request.render("project.portal_my_task", values)
def blacklist_number(self, mailing_id, trace_code, **post):
check_res = self._check_trace(mailing_id, trace_code)
if not check_res.get('trace'):
return werkzeug.utils.redirect('/web')
country_code = request.session.get(
'geoip', False) and request.session.geoip.get(
'country_code',
False) if request.session.get('geoip') else None
trace = check_res['trace']
mailing_list_ids = trace.mass_mailing_id.contact_list_ids
# parse and validate number
sms_number = post.get('sms_number', '').strip(' ')
sanitize_res = phone_validation.phone_sanitize_numbers(
[sms_number], country_code, None)[sms_number]
tocheck_number = sanitize_res['sanitized'] or sms_number
# compute opt-out / blacklist information
lists_optout = request.env['mailing.list'].sudo()
lists_optin = request.env['mailing.list'].sudo()
unsubscribe_error = False
if tocheck_number and trace.sms_number == tocheck_number:
if mailing_list_ids:
subscriptions = request.env[
'mailing.contact.subscription'].sudo().search([
('list_id', 'in', mailing_list_ids.ids),
('contact_id.phone_sanitized', '=', tocheck_number),
])
subscriptions.write({'opt_out': True})
lists_optout = subscriptions.mapped('list_id')
else:
blacklist_rec = request.env['phone.blacklist'].sudo().add(
tocheck_number)
blacklist_rec._message_log(body=_(
'Blacklist through SMS Marketing unsubscribe (mailing ID: %s - model: %s)'
) % (trace.mass_mailing_id.id,
trace.mass_mailing_id.mailing_model_id.display_name))
lists_optin = request.env['mailing.contact.subscription'].sudo(
).search([
('contact_id.phone_sanitized', '=', tocheck_number),
('list_id', 'not in', mailing_list_ids.ids),
('opt_out', '=', False),
]).mapped('list_id')
elif tocheck_number and trace.sms_number != tocheck_number:
unsubscribe_error = _('Number %s not found' % tocheck_number)
else:
unsubscribe_error = sanitize_res['msg']
return request.render(
'mass_mailing_sms.blacklist_number', {
'mailing_id': mailing_id,
'trace_code': trace_code,
'sms_number': sms_number,
'lists_optin': lists_optin,
'lists_optout': lists_optout,
'unsubscribe_error': unsubscribe_error,
})
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 survey_start(self,
survey_token,
answer_token=None,
email=False,
**post):
""" Start a survey by providing
* a token linked to a survey;
* a token linked to an answer or generate a new token if access is allowed;
"""
access_data = self._get_access_data(survey_token,
answer_token,
ensure_token=False)
if access_data['validity_code'] is not True:
return self._redirect_with_error(access_data,
access_data['validity_code'])
survey_sudo, answer_sudo = access_data['survey_sudo'], access_data[
'answer_sudo']
if not answer_sudo:
try:
answer_sudo = survey_sudo._create_answer(user=request.env.user,
email=email)
except UserError:
answer_sudo = False
if not answer_sudo:
try:
survey_sudo.with_user(
request.env.user).check_access_rights('read')
survey_sudo.with_user(
request.env.user).check_access_rule('read')
except:
return werkzeug.utils.redirect("/")
else:
return request.render("survey.403", {'survey': survey_sudo})
# Select the right page
if answer_sudo.state == 'new': # Intro page
data = {'survey': survey_sudo, 'answer': answer_sudo, 'page': 0}
return request.render('survey.survey_init', data)
else:
return request.redirect(
'/survey/fill/%s/%s' %
(survey_sudo.access_token, answer_sudo.token))
def _redirect_with_error(self, access_data, error_key):
survey_sudo = access_data['survey_sudo']
answer_sudo = access_data['answer_sudo']
if error_key == 'survey_void' and access_data['can_answer']:
return request.render("survey.survey_void", {
'survey': survey_sudo,
'answer': answer_sudo
})
elif error_key == 'survey_closed' and access_data['can_answer']:
return request.render("survey.survey_expired",
{'survey': survey_sudo})
elif error_key == 'survey_auth' and answer_sudo.token:
if answer_sudo.partner_id and (answer_sudo.partner_id.user_ids
or survey_sudo.users_can_signup):
if answer_sudo.partner_id.user_ids:
answer_sudo.partner_id.signup_cancel()
else:
answer_sudo.partner_id.signup_prepare(
expiration=fields.Datetime.now() +
relativedelta(days=1))
redirect_url = answer_sudo.partner_id._get_signup_url_for_action(
url='/survey/start/%s?answer_token=%s' %
(survey_sudo.access_token,
answer_sudo.token))[answer_sudo.partner_id.id]
else:
redirect_url = '/web/login?redirect=%s' % (
'/survey/start/%s?answer_token=%s' %
(survey_sudo.access_token, answer_sudo.token))
return request.render("survey.auth_required", {
'survey': survey_sudo,
'redirect_url': redirect_url
})
elif error_key == 'answer_deadline' and answer_sudo.token:
return request.render("survey.survey_expired",
{'survey': survey_sudo})
elif error_key == 'answer_done' and answer_sudo.token:
return request.render(
"survey.sfinished",
self._prepare_survey_finished_values(survey_sudo,
answer_sudo,
token=answer_sudo.token))
return werkzeug.utils.redirect("/")
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 event_track_view(self, event, track, **post):
if not event.can_access_from_current_website():
raise NotFound()
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 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)
def event_register(self, event, **post):
if not event.can_access_from_current_website():
raise werkzeug.exceptions.NotFound()
urls = event._get_event_resource_urls()
values = {
'event': event,
'main_object': event,
'range': range,
'registrable': event.sudo()._is_event_registrable(),
'google_url': urls.get('google_url'),
'iCal_url': urls.get('iCal_url'),
}
return request.render("website_event.event_description_full", values)
def authorize_form_feedback(self, **post):
_logger.info('Authorize: entering form_feedback with post data %s',
pprint.pformat(post))
if post:
request.env['payment.transaction'].sudo().form_feedback(
post, 'authorize')
base_url = request.env['ir.config_parameter'].sudo().get_param(
'web.base.url')
# Authorize.Net is expecting a response to the POST sent by their server.
# This response is in the form of a URL that Authorize.Net will pass on to the
# client's browser to redirect them to the desired location need javascript.
return request.render(
'payment_authorize.payment_authorize_redirect',
{'return_url': urls.url_join(base_url, "/payment/process")})
def survey_print(self,
survey_token,
review=False,
answer_token=None,
**post):
'''Display an survey in printable view; if <answer_token> is set, it will
grab the answers of the user_input_id that has <answer_token>.'''
access_data = self._get_access_data(survey_token,
answer_token,
ensure_token=False)
if access_data['validity_code'] is not True and (
access_data['has_survey_access']
or access_data['validity_code'] not in
['token_required', 'survey_closed', 'survey_void', 'answer_done']):
return self._redirect_with_error(access_data,
access_data['validity_code'])
survey_sudo, answer_sudo = access_data['survey_sudo'], access_data[
'answer_sudo']
if survey_sudo.scoring_type == 'scoring_without_answers':
return request.render("survey.403", {'survey': survey_sudo})
return request.render(
'survey.survey_print', {
'review':
review,
'survey':
survey_sudo,
'answer':
answer_sudo,
'page_nr':
0,
'quizz_correction':
survey_sudo.scoring_type != 'scoring_without_answers'
and answer_sudo
})
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 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()
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 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_sudo = request.env['res.users'].sudo().search([
('login', '=', qcontext.get('login'))
])
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 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(
[('is_won', '!=', True)],
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 blog(self, blog=None, tag=None, page=1, **opt):
Blog = request.env['blog.blog']
if blog and not blog.can_access_from_current_website():
raise werkzeug.exceptions.NotFound()
blogs = Blog.search(request.website.website_domain(), order="create_date asc, id asc")
if not blog and len(blogs) == 1:
return werkzeug.utils.redirect('/blog/%s' % slug(blogs[0]), code=302)
date_begin, date_end, state = opt.get('date_begin'), opt.get('date_end'), opt.get('state')
values = self._prepare_blog_values(blogs=blogs, blog=blog, date_begin=date_begin, date_end=date_end, tags=tag, state=state, page=page)
if blog:
values['main_object'] = blog
values['edit_in_backend'] = True
values['blog_url'] = QueryURL('', ['blog', 'tag'], blog=blog, tag=tag, date_begin=date_begin, date_end=date_end)
else:
values['blog_url'] = QueryURL('/blog', ['tag'], date_begin=date_begin, date_end=date_end)
return request.render("website_blog.blog_post_short", values)
def event_tracks(self, event, tag=None, **post):
if not event.can_access_from_current_website() or (tag
and tag.color == 0):
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 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.with_user(
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 survey_change_page(self, survey_token, answer_token, page_id, **post):
""" Method called when the user switches from one page to another using the breadcrumbs links
in the survey layout.
TODO: Right now, the answers that are not submitted are LOST when changing from one page to another
using this method.
The survey "submit" mechanism needs to be refactored entirely to make this more user-friendly."""
# Controls if the survey can be displayed
access_data = self._get_access_data(survey_token,
answer_token,
ensure_token=False)
if access_data['validity_code'] is not True:
return self._redirect_with_error(access_data,
access_data['validity_code'])
survey_sudo, answer_sudo = access_data['survey_sudo'], access_data[
'answer_sudo']
return request.render(
'survey.survey', {
'survey': survey_sudo,
'page': request.env['survey.question'].sudo().browse(page_id),
'answer': answer_sudo
})
def event_page(self, event, page, **post):
if not event.can_access_from_current_website():
raise werkzeug.exceptions.NotFound()
values = {
'event': event,
}
if '.' not in page:
page = 'website_event.%s' % page
try:
# Every event page view should have its own SEO.
values['seo_object'] = request.website.get_template(page)
values['main_object'] = event
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 portal_my_invoices(self,
page=1,
date_begin=None,
date_end=None,
sortby=None,
**kw):
values = self._prepare_portal_layout_values()
AccountInvoice = request.env['account.move']
domain = [('type', 'in', ('out_invoice', 'out_refund', 'in_invoice',
'in_refund', 'out_receipt', 'in_receipt'))]
searchbar_sortings = {
'date': {
'label': _('Invoice Date'),
'order': 'invoice_date desc'
},
'duedate': {
'label': _('Due Date'),
'order': 'invoice_date_due desc'
},
'name': {
'label': _('Reference'),
'order': 'name desc'
},
'state': {
'label': _('Status'),
'order': 'state'
},
}
# default sort by order
if not sortby:
sortby = 'date'
order = searchbar_sortings[sortby]['order']
archive_groups = self._get_archive_groups('account.move', domain)
if date_begin and date_end:
domain += [('create_date', '>', date_begin),
('create_date', '<=', date_end)]
# count for pager
invoice_count = AccountInvoice.search_count(domain)
# pager
pager = portal_pager(url="/my/invoices",
url_args={
'date_begin': date_begin,
'date_end': date_end,
'sortby': sortby
},
total=invoice_count,
page=page,
step=self._items_per_page)
# content according to pager and archive selected
invoices = AccountInvoice.search(domain,
order=order,
limit=self._items_per_page,
offset=pager['offset'])
request.session['my_invoices_history'] = invoices.ids[:100]
values.update({
'date': date_begin,
'invoices': invoices,
'page_name': 'invoice',
'pager': pager,
'archive_groups': archive_groups,
'default_url': '/my/invoices',
'searchbar_sortings': searchbar_sortings,
'sortby': sortby,
})
return request.render("account.portal_my_invoices", values)
