def pages_management(self, page=1, sortby='name', search='', **kw):
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, 'name')['order']
domain = ['|', ('website_ids', 'in', request.website.id), ('website_ids', '=', False)]
if search:
domain += ['|', ('name', 'ilike', search), ('url', 'ilike', search)]
pages_count = Page.search_count(domain)
pager = portal_pager(
url="/website/pages",
url_args={'sortby': sortby},
total=pages_count,
page=page,
step=50
)
pages = Page.search(domain, order=sort_order, limit=50, offset=pager['offset'])
values = {
'pager': pager,
'pages': pages,
'search': search,
'sortby': sortby,
'searchbar_sortings': searchbar_sortings,
}
return request.render("website.edit_website_pages", values)
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_quotes_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_my_invoices(self, page=1, date_begin=None, date_end=None, sortby=None, **kw):
values = self._prepare_portal_layout_values()
partner = request.env.user.partner_id
AccountInvoice = request.env['account.invoice']
domain = [
('type', 'in', ['out_invoice', 'out_refund']),
('message_partner_ids', 'child_of', [partner.commercial_partner_id.id]),
('state', 'in', ['open', 'paid', 'cancelled'])
]
searchbar_sortings = {
'date': {'label': _('Invoice Date'), 'order': 'date_invoice desc'},
'duedate': {'label': _('Due Date'), 'order': '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.invoice', 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'])
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)
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 portal_my_orders(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', ['sale', 'done'])
]
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
order_count = SaleOrder.search_count(domain)
# pager
pager = portal_pager(
url="/my/orders",
url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby},
total=order_count,
page=page,
step=self._items_per_page
)
# content according to pager and archive selected
orders = SaleOrder.search(domain, order=sort_order, limit=self._items_per_page, offset=pager['offset'])
request.session['my_orders_history'] = orders.ids[:100]
values.update({
'date': date_begin,
'orders': orders.sudo(),
'page_name': 'order',
'pager': pager,
'archive_groups': archive_groups,
'default_url': '/my/orders',
'searchbar_sortings': searchbar_sortings,
'sortby': sortby,
})
return request.render("sale.portal_my_orders", values)
def portal_my_invoices(self, page=1, date_begin=None, date_end=None, sortby=None, **kw):
values = self._prepare_portal_layout_values()
partner = request.env.user.partner_id
AccountInvoice = request.env['account.invoice']
domain = [
('type', 'in', ['out_invoice', 'out_refund']),
('message_partner_ids', 'child_of', [partner.commercial_partner_id.id]),
('state', 'in', ['open', 'paid', 'cancelled'])
]
searchbar_sortings = {
'date': {'label': _('Invoice Date'), 'order': 'date_invoice desc'},
'duedate': {'label': _('Due Date'), 'order': '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.invoice', 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'])
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)
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']
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,
'default_url': '/my/quotes',
'searchbar_sortings': searchbar_sortings,
'sortby': sortby,
})
return request.render("sale.portal_my_quotations", values)
def portal_my_projects(self, page=1, date_begin=None, date_end=None, sortby=None, **kw):
values = self._prepare_portal_layout_values()
Project = request.env['project.project']
uid = request.env.context.get('uid')
project_ids = request.env['project.task'].search([('user_id','=',uid)]).mapped('project_id')
domain = [('id', 'in', project_ids.ids)]
searchbar_sortings = {
'date': {'label': _('Newest'), 'order': 'create_date desc'},
'name': {'label': _('Name'), 'order': 'name'},
}
if not sortby:
sortby = 'date'
order = searchbar_sortings[sortby]['order']
# archive groups - Default Group By 'create_date'
archive_groups = self._get_archive_groups('project.project', domain)
if date_begin and date_end:
domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)]
# projects count
project_count = Project.search_count(domain)
# pager
pager = portal_pager(
url="/my/projects",
url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby},
total=project_count,
page=page,
step=self._items_per_page
)
# content according to pager and archive selected
projects = Project.sudo().search(domain, order=order, limit=self._items_per_page, offset=pager['offset'])
request.session['my_projects_history'] = projects.ids[:100]
values.update({
'date': date_begin,
'date_end': date_end,
'projects': projects,
'page_name': 'project',
'archive_groups': archive_groups,
'default_url': '/my/projects',
'pager': pager,
'searchbar_sortings': searchbar_sortings,
'sortby': sortby
})
return request.render("project.portal_my_projects", values)
def pages_management(self, page=1, sortby='name', 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, 'name')['order']
domain = [
'|', ('website_ids', 'in', request.website.id),
('website_ids', '=', False)
]
if search:
domain += [
'|', ('name', 'ilike', search), ('url', 'ilike', search)
]
pages_count = Page.search_count(domain)
pager = portal_pager(url="/website/pages",
url_args={'sortby': sortby},
total=pages_count,
page=page,
step=50)
pages = Page.search(domain,
order=sort_order,
limit=50,
offset=pager['offset'])
values = {
'pager': pager,
'pages': pages,
'search': search,
'sortby': sortby,
'searchbar_sortings': searchbar_sortings,
}
return request.render("website.edit_website_pages", values)
def portal_to_confirm_order(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', '=', 'sent')
]
searchbar_sortings = {
'date': {'label': _('Order Date'), 'order': 'date_order desc'},
'name': {'label': _('Reference'), 'order': 'name'},
'stage': {'label': _('Stage'), 'order': 'state'},
}
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)]
quotation_count = SaleOrder.search_count(domain)
pager = portal_pager(
url="/my/confirm",
url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby},
total=quotation_count,
page=page,
step=self._items_per_page
)
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,
'orders': quotations.sudo(),
'page_name': 'quote',
'pager': pager,
'archive_groups': archive_groups,
'default_url': '/my/confirm',
'searchbar_sortings': searchbar_sortings,
'sortby': sortby,
})
return request.render("extended_ecommerce.portal_to_confirm_orders", values)
def _project_get_page_view_values(self, project, access_token, page=1, date_begin=None, date_end=None, sortby=None, search=None, search_in='content', groupby=None, **kwargs):
# default filter by value
domain = [('project_id', '=', project.id)]
# pager
url = "/my/projects/%s" % project.id
values = self._prepare_tasks_values(page, date_begin, date_end, sortby, search, search_in, groupby, url, domain, su=bool(access_token))
pager = portal_pager(**values['pager'])
values.update(
grouped_tasks=values['grouped_tasks'](pager['offset']),
page_name='project',
pager=pager,
project=project,
task_url=f'projects/{project.id}/task',
)
return self._get_page_view_values(project, access_token, values, 'my_projects_history', False, **kwargs)
def portal_my_consigment_products(self, page=1, filterby=None, sortby=None, search=None, search_in='content', **kw):
# response = super(CustomerPortal, self)
values = self._prepare_portal_layout_values()
product_obj = http.request.env['product.product']
domain = [
('purchase_order_line_id', '!=', False)
]
searchbar_filters = {
'all': {'label': _('All'), 'domain': []},
}
if not filterby:
filterby = 'all'
domain += searchbar_filters[filterby]['domain']
searchbar_inputs = {
'content': {'input': 'content', 'label': _('Search <span class="nolabel"> (in Content)</span>')},
'name': {'input': 'name', 'label': _('Search in Name')},
'default_code': {'input': 'default_code', 'label': _('Search in Internal Reference')},
}
if search and search_in:
search_domain = []
if search_in in ('name', 'all'):
search_domain = OR([search_domain, [('name', 'ilike', search)]])
if search_in in ('default_code', 'all'):
search_domain = OR([search_domain, [('default_code','ilike',search)]])
domain += search_domain
# count for pager
consignment_product_count = product_obj.sudo().search_count(domain)
# pager
pager = portal_pager(
url="/my/consignment_product_list",
url_args={'sortby': sortby,'filterby': filterby},
total=consignment_product_count,
page=page,
step=self._items_per_page
)
# content according to pager and archive selected
consignment_products = product_obj.sudo().search(domain, limit=self._items_per_page, offset=pager['offset'])
values.update({
'consignment_products': consignment_products,
'page_name': 'consignment_product_page',
'searchbar_inputs': searchbar_inputs,
'search_in': search_in,
'filterby': filterby,
'pager': pager,
'default_url': '/my/consignment_product_list',
})
return request.render("odoo_consignment_process.display_consignment_product", values)
def portal_my_outsourcings(self, page=1, date_begin=None, date_end=None, sortby=None, **kw):
values = self._prepare_portal_layout_values()
outsourcing = request.env['outsourcing.outsourcing']
domain = []
searchbar_sortings = {
'date': {'label': _('Newest'), 'order': 'create_date desc'},
'name': {'label': _('Name'), 'order': 'name'},
}
if not sortby:
sortby = 'date'
order = searchbar_sortings[sortby]['order']
# archive groups - Default Group By 'create_date'
archive_groups = self._get_archive_groups('outsourcing.outsourcing', domain) if values.get('my_details') else []
if date_begin and date_end:
domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)]
# outsourcings count
outsourcing_count = outsourcing.search_count(domain)
# pager
pager = portal_pager(
url="/my/outsourcings",
url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby},
total=outsourcing_count,
page=page,
step=self._items_per_page
)
# content according to pager and archive selected
outsourcings = outsourcing.search(domain, order=order, limit=self._items_per_page, offset=pager['offset'])
request.session['my_outsourcings_history'] = outsourcings.ids[:100]
values.update({
'date': date_begin,
'date_end': date_end,
'outsourcings': outsourcings,
'page_name': 'outsourcing',
'archive_groups': archive_groups,
'default_url': '/my/outsourcings',
'pager': pager,
'searchbar_sortings': searchbar_sortings,
'sortby': sortby
})
return request.render("outsourcing.portal_my_outsourcings", values)
def group_view_messages(self,
group,
page=1,
mode='thread',
date_begin=None,
date_end=None,
**post):
GroupMessage = request.env['mail.group.message']
domain = [('mail_group_id', '=', group.id)]
if mode == 'thread':
domain += [('group_message_parent_id', '=', False)]
if date_begin and date_end:
domain += [('create_date', '>=', date_begin),
('create_date', '<=', date_end)]
messages = GroupMessage.search(domain,
limit=self._thread_per_page,
offset=(page - 1) *
self._thread_per_page,
order='create_date, id DESC')
pager = portal_pager(url=f'/groups/{slug(group)}',
total=GroupMessage.search_count(domain),
page=page,
step=self._thread_per_page,
scope=5,
url_args={
'date_begin': date_begin,
'date_end': date_end,
'mode': mode
})
return request.render(
'mail_group.group_messages', {
'group': group,
'messages': messages,
'archives': self._get_archives(group.id),
'date_begin': date_begin,
'date_end': date_end,
'pager': pager,
'replies_per_page': self._replies_per_page,
})
def portal_my_projects(self, page=1, date_begin=None, date_end=None, sortby=None, **kw):
values = self._prepare_portal_layout_values()
Project = request.env['project.project']
domain = [('privacy_visibility', '=', 'portal')]
searchbar_sortings = {
'date': {'label': _('Newest'), 'order': 'create_date desc'},
'name': {'label': _('Name'), 'order': 'name'},
}
if not sortby:
sortby = 'date'
order = searchbar_sortings[sortby]['order']
# archive groups - Default Group By 'create_date'
archive_groups = self._get_archive_groups('project.project', domain)
if date_begin and date_end:
domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)]
# projects count
project_count = Project.search_count(domain)
# pager
pager = portal_pager(
url="/my/projects",
url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby},
total=project_count,
page=page,
step=self._items_per_page
)
# content according to pager and archive selected
projects = Project.search(domain, order=order, limit=self._items_per_page, offset=pager['offset'])
request.session['my_projects_history'] = projects.ids[:100]
values.update({
'date': date_begin,
'date_end': date_end,
'projects': projects,
'page_name': 'project',
'archive_groups': archive_groups,
'default_url': '/my/projects',
'pager': pager,
'searchbar_sortings': searchbar_sortings,
'sortby': sortby
})
return request.render("project.portal_my_projects", values)
def portal_my_leave_request(self, page=1, sortby=None, **kw):
if not request.env.user.has_group(
'odoo_leave_request_portal_employee.group_employee_leave'):
# return request.render("odoo_timesheet_portal_user_employee.not_allowed_leave_request")
return request.render(
"odoo_leave_request_portal_employee.not_allowed_leave_request")
response = super(CustomerPortal, self)
values = self._prepare_portal_layout_values()
holidays_obj = http.request.env['hr.holidays']
domain = [('user_id', 'child_of', [request.env.user.id]),
('type', '=', 'remove')]
# count for pager
holidays_count = http.request.env['hr.holidays'].sudo().search_count(
domain)
# pager
# pager = request.website.pager(
pager = portal_pager(url="/my/leaves",
total=holidays_count,
page=page,
step=self._items_per_page)
sortings = {
'date': {
'label': _('Newest'),
'order': 'date_from desc'
},
}
order = sortings.get(sortby, sortings['date'])['order']
# content according to pager and archive selected
holidays = holidays_obj.sudo().search(domain,
order=order,
limit=self._items_per_page,
offset=pager['offset'])
values.update({
'holidays': holidays,
'page_name': 'holidays',
'sortings': sortings,
'sortby': sortby,
'pager': pager,
'default_url': '/my/holidays',
})
return request.render(
"odoo_leave_request_portal_employee.display_leave_request", values)
def portal_my_attendances(self, page=1, sortby=None, **kw):
if not request.env.user.has_group(
'odoo_portal_attendance.portal_user_employee_attendance'):
return request.render(
"odoo_portal_attendance.not_allowed_attendance")
import datetime
response = super(CustomerPortal, self)
values = self._prepare_portal_layout_values()
employee = request.env['hr.employee'].search([('user_id', '=',
request.env.user.id)])
attendance_obj = http.request.env['hr.attendance']
domain = [
('employee_id', '=', employee.id),
]
# count for pager
attendance_count = attendance_obj.sudo().search_count(domain)
# pager
# pager = request.website.pager(
pager = portal_pager(url="/my/attendances",
total=attendance_count,
page=page,
step=self._items_per_page)
no_check_out_attendances = request.env['hr.attendance'].sudo().search([
('employee_id', '=', employee.id),
('check_out', '=', False),
])
# content according to pager and archive selected
attendances = attendance_obj.sudo().search(domain,
limit=self._items_per_page,
offset=pager['offset'])
values.update({
'attendances': attendances,
'no_check_out_attendances': no_check_out_attendances,
'page_name': 'attendance',
'pager': pager,
'default_url': '/my/attendances',
})
return request.render("odoo_portal_attendance.display_attendances",
values)
def portal_my_applications(self, page=1, sortby=None, **kw):
""" Sortby values and pager functionality """
values = self._prepare_portal_layout_values()
JobApplication = request.env['job.application']
searchbar_sortings = {
'date': {
'label': _('Newest'),
'order': 'create_date desc'
},
'dob': {
'label': _('Date of birth'),
'order': 'dob'
},
}
if not sortby:
sortby = 'date'
order = searchbar_sortings[sortby]['order']
# Job Application count
application_count = JobApplication.search_count([])
# pager
pager = portal_pager(url="/my/applications",
url_args={'sortby': sortby},
total=application_count,
page=page,
step=4)
applications = JobApplication.search([],
order=order,
limit=4,
offset=pager['offset'])
# request.session['my_students_history'] = students.ids[:100]
values.update({
'applications': applications,
'page_name': 'Job Applications',
'pager': pager,
'searchbar_sortings': searchbar_sortings,
'sortby': sortby
})
return request.render("school.portal_my_application", values)
def portal_my_tasks(self,
page=1,
date_begin=None,
date_end=None,
sortby=None,
filterby=None,
search=None,
search_in='content',
groupby=None,
**kw):
searchbar_filters = self._get_my_tasks_searchbar_filters()
if not filterby:
filterby = 'all'
domain = searchbar_filters.get(filterby,
searchbar_filters.get('all'))['domain']
values = self._prepare_tasks_values(page,
date_begin,
date_end,
sortby,
search,
search_in,
groupby,
domain=domain)
# pager
pager_vals = values['pager']
pager_vals['url_args'].update(filterby=filterby)
pager = portal_pager(**pager_vals)
values.update({
'grouped_tasks':
values['grouped_tasks'](pager['offset']),
'pager':
pager,
'searchbar_filters':
OrderedDict(sorted(searchbar_filters.items())),
'filterby':
filterby,
})
return request.render("project.portal_my_tasks", values)
def portal_my_builds(self, page=1, sortby=None, **kw):
values = self._prepare_portal_layout_values()
Build = request.env["saas.db"]
domain = [("type", "=", "build")]
searchbar_sortings = {
"name": {
"label": _("Name"),
"order": "name"
},
}
if not sortby:
sortby = "name"
order = searchbar_sortings[sortby]["order"]
# archive groups - Default Group By 'create_date'
# archive_groups = self._get_archive_groups('project.project', domain)
# pager
pager = portal_pager(
url="/my/builds",
url_args={"sortby": sortby},
total=values["build_count"],
page=page,
step=self._items_per_page,
)
# content according to pager and archive selected
builds = Build.search(domain,
order=order,
limit=self._items_per_page,
offset=pager["offset"])
values.update({
"builds": builds,
"page_name": "build",
"default_url": "/my/builds",
"pager": pager,
"searchbar_sortings": searchbar_sortings,
"sortby": sortby,
})
return request.render("saas_portal.portal_my_builds", values)
def portal_my_appointment(self,
page=1,
date_begin=None,
date_end=None,
sortby=None,
**kw):
partner = request.env.user.partner_id
WebAppointment = request.env['doctor.appointment'].search([])
appointment_count = len(WebAppointment)
searchbar_sortings = {
'name': {
'label': ('Name'),
'appointment': 'name'
},
'age': {
'label': ('Age'),
'appointment': 'age'
},
}
if not sortby:
sortby = 'name'
sort_appointment = searchbar_sortings[sortby]['appointment']
pager = portal_pager(url="/my/appointment",
total=appointment_count,
page=page)
# search the count to display, according to the pager data
appointment = WebAppointment
print("----__________---------________\n\n\n\n", appointment)
request.session['my_appointment_history'] = appointment.ids[:100]
values = {
'appointments': appointment.sudo(),
'page_name': 'Appointment',
'pager': pager,
'default_url': '/my/appointment',
}
print("--------------------------\n\n\n\n\n\n\n", values)
return request.render("doctor_appointment.portal_my_appointments",
values)
def portal_my_ticket(self, page=1, ticket_id=None, **kw):
domain = [('user_id', '=', request.session.uid)]
ticket_count = request.env['helpdesk.ticket'].search_count(domain)
pager = portal_pager(
url="/my/tickets",
url_args={},
total=ticket_count,
page=page,
step=self._items_per_page
)
tickets = request.env['helpdesk.ticket'].search(
domain, limit=self._items_per_page, offset=pager['offset'])
request.session['my_tickets_history'] = tickets.ids[:100]
vals = {
'ticket': tickets,
'user': request.env.user,
'pager': pager,
}
return request.render("website_helpdesk.my_tickets", vals)
def hybrid_list(self, page=1, search='', search_type='all', **kw):
if not search:
return request.render("website.list_hybrid")
options = {
'displayDescription': True,
'displayDetail': True,
'displayExtraDetail': True,
'displayExtraLink': True,
'displayImage': True,
'allowFuzzy': not kw.get('noFuzzy'),
}
data = self.autocomplete(search_type=search_type,
term=search,
order='name asc',
limit=500,
max_nb_chars=200,
options=options)
results = data.get('results', [])
search_count = len(results)
parts = data.get('parts', {})
step = 50
pager = portal_pager(url="/website/search/%s" % search_type,
url_args={'search': search},
total=search_count,
page=page,
step=step)
results = results[(page - 1) * step:page * step]
values = {
'pager': pager,
'results': results,
'parts': parts,
'search': search,
'fuzzy_search': data.get('fuzzy_search'),
'search_count': search_count,
}
return request.render("website.list_hybrid", values)
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 portal_my_invoices(self,
page=1,
date_begin=None,
date_end=None,
sortby=None,
filterby=None,
**kw):
values = self._prepare_my_invoices_values(page, date_begin, date_end,
sortby, filterby)
# pager
pager = portal_pager(**values['pager'])
# content according to pager and archive selected
invoices = values['invoices'](pager['offset'])
request.session['my_invoices_history'] = invoices.ids[:100]
values.update({
'invoices': invoices,
'pager': pager,
})
return request.render("account.portal_my_invoices", values)
def portal_my_projects(self, page=1, date_begin=None, date_end=None, sortby=None, **kw):
values = self._prepare_portal_layout_values()
Project = request.env['project.project']
domain = self._prepare_project_domain()
searchbar_sortings = self._prepare_searchbar_sortings()
if not sortby:
sortby = 'date'
order = searchbar_sortings[sortby]['order']
if date_begin and date_end:
domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)]
# projects count
project_count = Project.search_count(domain)
# pager
pager = portal_pager(
url="/my/projects",
url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby},
total=project_count,
page=page,
step=self._items_per_page
)
# content according to pager and archive selected
projects = Project.search(domain, order=order, limit=self._items_per_page, offset=pager['offset'])
request.session['my_projects_history'] = projects.ids[:100]
values.update({
'date': date_begin,
'date_end': date_end,
'projects': projects,
'page_name': 'project',
'default_url': '/my/projects',
'pager': pager,
'searchbar_sortings': searchbar_sortings,
'sortby': sortby
})
return request.render("project.portal_my_projects", values)
def portal_my_records(self,
page=1,
date_begin=None,
date_end=None,
sortby=None,
**kw):
partner = request.env.user.partner_id
print(partner.id)
employee_records = request.env['employee.verification'].sudo().search(
['&', ('state', '=', 'assign'), ('agency', '=', partner.id)])
varification_count = request.env['employee.verification'].sudo(
).search_count(
['&', ('state', '=', 'assign'), ('agency', '=', partner.id)])
print(varification_count)
print(partner.name)
print(employee_records)
pager = portal_pager(url="/my/quotes",
url_args={
'date_begin': date_begin,
'date_end': date_end,
'sortby': sortby
},
total=varification_count,
page=page,
step=self._items_per_page)
values = {
'date': date_begin,
'records': employee_records.sudo(),
'page_name': 'employee',
'pager': pager,
# 'archive_groups': archive_groups,
'default_url': '/my/quotes',
# 'searchbar_sortings': searchbar_sortings,
'sortby': sortby,
}
return request.render("employee_background.portal_my_records", values)
def portal_my_orders(self,
page=1,
date_begin=None,
date_end=None,
sortby=None,
**kw):
res = super(CustomerPortal,
self).portal_my_orders(page, date_begin, date_end, sortby,
**kw)
SaleOrder = request.env['sale.order']
domain = self.get_domain_by_connected_user(date_begin, date_end,
'sale.order')
if not sortby:
sortby = 'date'
order = res.qcontext['searchbar_sortings'][sortby]['order']
filtered_orders = self.filter_data(domain, 'sale.order', **kw)
filtered_order_ids = []
for _order in filtered_orders:
filtered_order_ids.append(_order.id)
domain += [('id', 'in', filtered_order_ids)]
order_count = SaleOrder.sudo().search_count(domain)
pager = portal_pager(url="/my/orders",
url_args={
'date_begin': date_begin,
'date_end': date_end,
'sortby': sortby
},
total=order_count,
page=page,
step=self._items_per_page)
pager = self.recalculatePager(pager, **kw)
orders = SaleOrder.sudo().search(domain,
order=order,
limit=self._items_per_page,
offset=pager['offset'])
res.qcontext.update({'orders': orders, 'pager': pager})
return res
def group_view_messages(self, group, page=1, mode='thread', date_begin=None, date_end=None, **post):
GroupMessage = request.env['mail.group.message']
domain = expression.AND([self._get_website_domain(), [('mail_group_id', '=', group.id)]])
if mode == 'thread':
domain = expression.AND([domain, [('group_message_parent_id', '=', False)]])
if date_begin and date_end:
domain = expression.AND([domain, [('create_date', '>', date_begin), ('create_date', '<=', date_end)]])
# SUDO after the search to apply access rules but be able to read attachments
messages_sudo = GroupMessage.search(
domain, limit=self._thread_per_page,
offset=(page - 1) * self._thread_per_page).sudo()
pager = portal_pager(
url=f'/groups/{slug(group)}',
total=GroupMessage.search_count(domain),
page=page,
step=self._thread_per_page,
scope=5,
url_args={'date_begin': date_begin, 'date_end': date_end, 'mode': mode}
)
self._generate_attachments_access_token(messages_sudo)
return request.render('mail_group.group_messages', {
'page_name': 'groups',
'group': group,
'messages': messages_sudo,
'archives': self._get_archives(group.id),
'date_begin': date_begin,
'date_end': date_end,
'pager': pager,
'replies_per_page': self._replies_per_page,
'mode': mode,
})
def portal_my_crm_claim(self,
crm_claim_id=None,
page=1,
sortby=None,
**kw):
values = self._prepare_portal_layout_values()
Crm_claim = request.env['crm.claim']
# searchbar_sortings = self.get_query_order(sortby)
filtered_claim = self.filter_data([], 'crm.claim', **kw)
filtered_claim_ids = []
for claim in filtered_claim:
if claim in values['crm_claim_ids']:
filtered_claim_ids.append(claim.id)
domain = [('id', 'in', filtered_claim_ids)]
claim_count = Crm_claim.sudo().search_count(domain)
pager = portal_pager(url="/my/crm_claim",
total=claim_count,
page=page,
step=self._items_per_page)
pager = self.recalculatePager(pager, **kw)
claims = Crm_claim.sudo().search(domain,
limit=self._items_per_page,
offset=pager['offset'])
if crm_claim_id is None:
values.update({
'pager': pager,
'default_url': '/my/crm_claim',
'crm_claim_ids': claims,
# 'searchbar_sortings_2': searchbar_sortings
})
return request.render("website_crm_claim.portal_my_crm_claim",
values)
else:
crm_claim_id = Crm_claim.sudo().browse(crm_claim_id)
values.update({'crm_claim_id': crm_claim_id})
return request.render(
"website_crm_claim.portal_my_crm_claim_details", values)
def my_downloads(self, page=1, filter_id=0, **kw):
attachments = request.env['ir.attachment']
domain = [('is_portal_visible', '=', True)]
order_count = attachments.sudo().search_count(domain)
pager = portal_pager(url="/my/downloads",
url_args={},
total=order_count,
page=page,
step=25)
attachments = attachments.sudo().search(domain,
limit=25,
offset=pager['offset'])
request.session['my_downloads_history'] = attachments.ids[:100]
values = {
'attachments': attachments,
'pager': pager,
'default_url': '/my/downloads',
'page_display_name': 'Downloads',
'page_name': "download",
'filter_id': filter_id,
'download_count': order_count,
}
return request.render('website_download_attachments.download', values)
def my_prescriptions(self, page=1, sortby=None, **kw):
values = self._prepare_portal_layout_values()
user = request.env.user
if not sortby:
sortby = 'date'
sortings = {
'date': {'label': _('Newest'), 'order': 'create_date desc'},
'name': {'label': _('Name'), 'order': 'name'},
}
order = sortings.get(sortby, sortings['date'])['order']
pager = portal_pager(
url="/my/prescriptions",
url_args={},
total=values['prescription_count'],
page=page,
step=self._items_per_page
)
# content according to pager and archive selected
patient = request.env['hms.patient'].search([('partner_id', '=', request.env.user.partner_id.id)], limit=1)
prescriptions = request.env['prescription.order'].search([
('patient_id', '=', patient.id)],
order=order, limit=self._items_per_page, offset=pager['offset'])
values.update({
'sortings': sortings,
'sortby': sortby,
'prescriptions': prescriptions,
'page_name': 'prescription',
'default_url': '/my/prescriptions',
'searchbar_sortings': sortings,
'pager': pager
})
return request.render("acs_hms_portal.my_prescriptions", values)
def my_sms_logs(self, page=1, sortby=None, **kw):
sms = request.env['sms.message']
domain = [
('to_mobile', 'ilike', request.env.user.partner_id.mobile)
]
searchbar_sortings = {
'from_mobile': {'label': _('From Mobile'), 'order': 'from_mobile desc'},
'message_date': {'label': _('Message Date'), 'order': 'message_date desc'},
}
if not sortby:
sortby = 'message_date'
sort_order = searchbar_sortings[sortby]['order']
order_count = sms.sudo().search_count(domain)
pager = portal_pager(
url="/my/smslog",
url_args={'sortby': sortby},
total=order_count,
page=page,
step=25
)
sms = sms.sudo().search(domain, order=sort_order, limit=25, offset=pager['offset'])
request.session['my_sms_log_history'] = sms.ids[:100]
values = {
'page_name': "SMS Logs",
'sms_logs': sms,
'pager': pager,
'default_url': '/my/smslog',
'searchbar_sortings': searchbar_sortings,
'sortby': sortby,
'page_display_name': 'SMS Logs',
'page_name': "sms_log",
}
return request.render('inuka_customer_portal.sms_log', values)
def pages_management(self, page=1, sortby='name', 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, 'name')['order']
domain = ['|', ('website_ids', 'in', request.website.id), ('website_ids', '=', False)]
if search:
domain += ['|', ('name', 'ilike', search), ('url', 'ilike', search)]
pages_count = Page.search_count(domain)
pager = portal_pager(
url="/website/pages",
url_args={'sortby': sortby},
total=pages_count,
page=page,
step=50
)
pages = Page.search(domain, order=sort_order, limit=50, offset=pager['offset'])
values = {
'pager': pager,
'pages': pages,
'search': search,
'sortby': sortby,
'searchbar_sortings': searchbar_sortings,
}
return request.render("website.edit_website_pages", 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, 'sortby': sortby, 'filterby': filterby},
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_tickets(self,
page=1,
date_begin=None,
date_end=None,
sortby=None,
filterby=None,
**kw):
values = self._prepare_portal_layout_values()
HelpdesTicket = request.env['helpdesk.ticket']
partner = request.env.user.partner_id
domain = [('partner_id', 'child_of', partner.id)]
searchbar_sortings = {
'date': {
'label': _('Newest'),
'order': 'create_date desc'
},
'name': {
'label': _('Name'),
'order': 'name'
},
'stage': {
'label': _('Stage'),
'order': 'stage_id'
},
'update': {
'label': _('Last Stage Update'),
'order': 'last_stage_update desc'
},
}
searchbar_filters = {'all': {'label': _('All'), 'domain': []}}
for stage in request.env['helpdesk.ticket.stage'].search([]):
searchbar_filters.update({
str(stage.id): {
'label': stage.name,
'domain': [('stage_id', '=', stage.id)]
}
})
# default sort by order
if not sortby:
sortby = 'date'
order = searchbar_sortings[sortby]['order']
# default filter by value
if not filterby:
filterby = 'all'
domain += searchbar_filters[filterby]['domain']
# count for pager
ticket_count = HelpdesTicket.search_count(domain)
# pager
pager = portal_pager(url="/my/tickets",
url_args={},
total=ticket_count,
page=page,
step=self._items_per_page)
# content according to pager and archive selected
tickets = HelpdesTicket.search(domain,
order=order,
limit=self._items_per_page,
offset=pager['offset'])
values.update({
'date': date_begin,
'tickets': tickets,
'page_name': 'ticket',
'pager': pager,
'default_url': '/my/tickets',
'searchbar_sortings': searchbar_sortings,
'sortby': sortby,
'no_breadcrumbs': False,
'searchbar_filters': searchbar_filters,
'filterby': filterby,
})
return request.render("helpdesk.portal_my_tickets", values)
def portal_my_tasks(self, page=1, date_begin=None, date_end=None, sortby=None, filterby=None, search=None, search_in='content', groupby='project', **kw):
values = self._prepare_portal_layout_values()
searchbar_sortings = {
'date': {'label': _('Newest'), 'order': 'create_date desc'},
'name': {'label': _('Title'), 'order': 'name'},
'stage': {'label': _('Stage'), 'order': 'stage_id'},
'update': {'label': _('Last Stage Update'), 'order': 'date_last_stage_update desc'},
}
searchbar_filters = {
'all': {'label': _('All'), 'domain': []},
}
searchbar_inputs = {
'content': {'input': 'content', 'label': _('Search <span class="nolabel"> (in Content)</span>')},
'message': {'input': 'message', 'label': _('Search in Messages')},
'customer': {'input': 'customer', 'label': _('Search in Customer')},
'stage': {'input': 'stage', 'label': _('Search in Stages')},
'all': {'input': 'all', 'label': _('Search in All')},
}
searchbar_groupby = {
'none': {'input': 'none', 'label': _('None')},
'project': {'input': 'project', 'label': _('Project')},
}
# extends filterby criteria with project (criteria name is the project id)
# Note: portal users can't view projects they don't follow
projects = request.env['project.project'].sudo().search([('privacy_visibility', '=', 'portal')])
domain = [('project_id', 'in', projects.ids)]
for proj in projects:
searchbar_filters.update({
str(proj.id): {'label': proj.name, 'domain': [('project_id', '=', proj.id)]}
})
# default sort by value
if not sortby:
sortby = 'date'
order = searchbar_sortings[sortby]['order']
# default filter by value
if not filterby:
filterby = 'all'
domain += searchbar_filters[filterby]['domain']
# archive groups - Default Group By 'create_date'
archive_groups = self._get_archive_groups('project.task', domain)
if date_begin and date_end:
domain += [('create_date', '>', date_begin), ('create_date', '<=', date_end)]
# search
if search and search_in:
search_domain = []
if search_in in ('content', 'all'):
search_domain = OR([search_domain, ['|', ('name', 'ilike', search), ('description', 'ilike', search)]])
if search_in in ('customer', 'all'):
search_domain = OR([search_domain, [('partner_id', 'ilike', search)]])
if search_in in ('message', 'all'):
search_domain = OR([search_domain, [('message_ids.body', 'ilike', search)]])
if search_in in ('stage', 'all'):
search_domain = OR([search_domain, [('stage_id', 'ilike', search)]])
domain += search_domain
# task count
task_count = request.env['project.task'].search_count(domain)
# pager
pager = portal_pager(
url="/my/tasks",
url_args={'date_begin': date_begin, 'date_end': date_end, 'sortby': sortby, 'filterby': filterby},
total=task_count,
page=page,
step=self._items_per_page
)
# content according to pager and archive selected
if groupby == 'project':
order = "project_id, %s" % order # force sort on project first to group by project in view
tasks = request.env['project.task'].search(domain, order=order, limit=self._items_per_page, offset=pager['offset'])
request.session['my_tasks_history'] = tasks.ids[:100]
if groupby == 'project':
grouped_tasks = [request.env['project.task'].concat(*g) for k, g in groupbyelem(tasks, itemgetter('project_id'))]
else:
grouped_tasks = [tasks]
values.update({
'date': date_begin,
'date_end': date_end,
'projects': projects,
'grouped_tasks': grouped_tasks,
'page_name': 'task',
'archive_groups': archive_groups,
'default_url': '/my/tasks',
'pager': pager,
'searchbar_sortings': searchbar_sortings,
'searchbar_groupby': searchbar_groupby,
'searchbar_inputs': searchbar_inputs,
'search_in': search_in,
'sortby': sortby,
'groupby': groupby,
'searchbar_filters': OrderedDict(sorted(searchbar_filters.items())),
'filterby': filterby,
})
return request.render("project.portal_my_tasks", 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 = [
'|',
('message_partner_ids', 'child_of', [partner.commercial_partner_id.id]),
('partner_id', 'child_of', [partner.commercial_partner_id.id]),
]
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)
