def _order_get_page_view_values(self, order, access_token, **kwargs):
values = {
'sale_order': order,
'token': access_token,
'return_url': '/shop/payment/validate',
'bootstrap_formatting': True,
'partner_id': order.partner_id.id,
'report_type': 'html',
'action': order._get_portal_return_action(),
}
if order.company_id:
values['res_company'] = order.company_id
if order.has_to_be_paid():
domain = expression.AND([
['&', ('state', 'in', ['enabled', 'test']), ('company_id', '=', order.company_id.id)],
['|', ('country_ids', '=', False), ('country_ids', 'in', [order.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.partner_id.id)])
values['acq_extra_fees'] = acquirers.get_acquirer_extra_fees(order.amount_total, order.currency_id, order.partner_id.country_id.id)
if order.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))
return values
def subscription(self, account_id, uuid='', message='', message_class='', **kw):
account_res = request.env['sale.subscription']
if uuid:
account = account_res.sudo().browse(account_id)
if uuid != account.uuid:
raise NotFound()
if request.uid == account.partner_id.user_id.id:
account = account_res.browse(account_id)
else:
account = account_res.browse(account_id)
acquirers = request.env['payment.acquirer'].search([
('state', 'in', ['enabled', 'test']),
('registration_view_template_id', '!=', False),
('token_implemented', '=', True),
('company_id', '=', account.company_id.id)])
acc_pm = account.payment_token_id
part_pms = request.env['payment.token'].search([
('acquirer_id.company_id', '=', account.company_id.id),
('partner_id', 'child_of', account.partner_id.commercial_partner_id.id)])
display_close = account.template_id.sudo().user_closable and account.stage_category == 'progress'
is_follower = request.env.user.partner_id.id in [follower.partner_id.id for follower in account.message_follower_ids]
active_plan = account.template_id.sudo()
periods = {'daily': 'days', 'weekly': 'weeks', 'monthly': 'months', 'yearly': 'years'}
if account.recurring_rule_type != 'weekly':
rel_period = relativedelta(datetime.datetime.today(), account.recurring_next_date)
missing_periods = getattr(rel_period, periods[account.recurring_rule_type]) + 1
else:
delta = datetime.date.today() - account.recurring_next_date
missing_periods = delta.days / 7
dummy, action = request.env['ir.model.data'].get_object_reference('sale_subscription', 'sale_subscription_action')
values = {
'account': account,
'template': account.template_id.sudo(),
'display_close': display_close,
'is_follower': is_follower,
'close_reasons': request.env['sale.subscription.close.reason'].search([]),
'missing_periods': missing_periods,
'payment_mode': active_plan.payment_mode,
'user': request.env.user,
'acquirers': list(acquirers),
'acc_pm': acc_pm,
'part_pms': part_pms,
'is_salesman': request.env['res.users'].with_user(request.uid).has_group('sales_team.group_sale_salesman'),
'action': action,
'message': message,
'message_class': message_class,
'change_pm': kw.get('change_pm') != None,
'pricelist': account.pricelist_id.sudo(),
'submit_class':'btn btn-primary mb8 mt8 float-right',
'submit_txt':'Pay Subscription',
'bootstrap_formatting':True,
'return_url':'/my/subscription/' + str(account_id) + '/' + str(uuid),
}
history = request.session.get('my_subscriptions_history', [])
values.update(get_records_pager(history, account))
values['acq_extra_fees'] = acquirers.get_acquirer_extra_fees(account.recurring_total_incl, account.currency_id, account.partner_id.country_id)
return request.render("sale_subscription.subscription", values)
def _order_get_page_view_values(self, order, access_token, **kwargs):
order_invoice_lines = {
il.product_id.id: il.invoice_id
for il in order.invoice_ids.mapped('invoice_line_ids')
}
values = {
'order': order,
'order_invoice_lines': order_invoice_lines,
}
if access_token:
values['no_breadcrumbs'] = True
values['access_token'] = access_token
values['portal_confirmation'] = order.get_portal_confirmation_action()
if kwargs.get('error'):
values['error'] = kwargs['error']
if kwargs.get('warning'):
values['warning'] = kwargs['warning']
if kwargs.get('success'):
values['success'] = kwargs['success']
history = request.session.get('my_orders_history', [])
values.update(get_records_pager(history, order))
return values
def my_project(self, project=None, **kw):
vals = {
'project': project,
}
history = request.session.get('my_projects_history', [])
vals.update(get_records_pager(history, project))
return request.render("website_project.my_project", vals)
def portal_my_subcontractor(self, task_id=None, **kw):
task = request.env['project.task'].browse(task_id)
vals = {'task': task, 'user': request.env.user}
history = request.session.get('my_tasks_history', [])
vals.update(get_records_pager(history, task))
return request.render(
"job_order_subcontracting.portal_my_subcontractor", vals)
def orders_followup(self, order=None, access_token=None, **kw):
order = request.env['sale.order'].browse([order])
order_sudo = order.sudo()
values = {}
try:
order.check_access_rights('read')
order.check_access_rule('read')
except AccessError:
if not access_token or not consteq(order_sudo.access_token,
access_token):
return request.redirect('/my')
values.update({'no_breadcrumbs': True})
order_invoice_lines = {
il.product_id.id: il.invoice_id
for il in order_sudo.invoice_ids.mapped('invoice_line_ids')
}
history = request.session.get('my_orders_history', [])
values.update({
'order': order_sudo,
'order_invoice_lines': order_invoice_lines,
})
values.update(get_records_pager(history, order_sudo))
return request.render("sale.orders_followup", values)
def portal_my_purchase_order(self, order_id=None, **kw):
_logger.debug(
"*********** 9.- /web/purchase/<int:order_id> order_id: %r",
order_id)
_logger.debug("*********** 9.- /web/purchase/<int:order_id> kw: %r",
kw)
order = request.env['purchase.order'].browse(order_id)
poOrder = order.id
_logger.debug("*********** 9.- /web/purchase/<int:order_id> order: %r",
order)
_logger.debug(
"*********** 9.- end /web/purchase/<int:order_id> order ************"
)
try:
order.check_access_rights('read')
order.check_access_rule('read')
except AccessError:
return request.redirect('/my')
history = request.session.get('my_purchases_history', [])
#customer = request.env.user.partner_id.id
customer = order.user_id.partner_id.id
values = {}
_logger.debug("*********** 9.- /web/purchase/<int:order_id> kw: %r",
kw)
_logger.debug(
"*********** 9.- /web/purchase/<int:order_id> end kwargs ************"
)
_logger.debug(
"*********** 9.- /web/purchase/<int:order_id> customer: %r",
customer)
for field in [
'prq_1', 'prq_2', 'prq_3', 'prq_4', 'prq_5', 'prq_6', 'prq_7',
'prq_8', 'prq_9', 'prq_10', 'desc_1', 'desc_2', 'desc_3',
'desc_4', 'desc_5', 'desc_6', 'desc_7', 'desc_8', 'desc_9',
'desc_10', 'rejx_1', 'rejx_2', 'rejx_3', 'rejx_4', 'rejx_5',
'rejx_6', 'rejx_7', 'rejx_8', 'rejx_9', 'rejx_10'
]:
if kw.get(field):
values[field] = kw.pop(field)
values.update(kwargs=kw.items())
values.update(customer_id=customer, order=order.sudo())
customer_data = request.env['res.partner'].sudo().browse(customer)
values.update(partner_name=customer_data.name,
partner_mail=customer_data.email,
partner_id=customer)
values.update(get_records_pager(history, order))
_logger.debug(
"*********** 9.- /web/purchase/<int:order_id> values: %r", values)
_logger.debug(
"*********** 9.- /web/purchase/<int:order_id> end values ************"
)
return request.render("dropship_portal.portal_my_purchase_order",
values)
def view(self, order_id, pdf=None, token=None, message=False, **post):
# use sudo to allow accessing/viewing orders for public user
# only if he knows the private token
now = fields.Date.today()
if token:
Order = request.env['sale.order'].sudo().search([('id', '=', order_id), ('access_token', '=', token)])
else:
Order = request.env['sale.order'].search([('id', '=', order_id)])
# Log only once a day
if Order and request.session.get('view_quote_%s' % Order.id) != now and request.env.user.share:
request.session['view_quote_%s' % Order.id] = now
body = _('Quotation viewed by customer')
_message_post_helper(res_model='sale.order', res_id=Order.id, message=body, token=token, message_type='notification', subtype="mail.mt_note", partner_ids=Order.user_id.sudo().partner_id.ids)
if not Order:
return request.render('website.404')
# Token or not, sudo the order, since portal user has not access on
# taxes, required to compute the total_amout of SO.
order_sudo = Order.sudo()
days = 0
if order_sudo.validity_date:
days = (fields.Date.from_string(order_sudo.validity_date) - fields.Date.from_string(fields.Date.today())).days + 1
if pdf:
pdf = request.env.ref('website_quote.report_web_quote').sudo().with_context(set_viewport_size=True).render_qweb_pdf([order_sudo.id])[0]
pdfhttpheaders = [('Content-Type', 'application/pdf'), ('Content-Length', len(pdf))]
return request.make_response(pdf, headers=pdfhttpheaders)
transaction = order_sudo.get_portal_last_transaction()
values = {
'quotation': order_sudo,
'message': message and int(message) or False,
'option': any(not x.line_id for x in order_sudo.options),
'order_valid': (not order_sudo.validity_date) or (now <= order_sudo.validity_date),
'days_valid': days,
'action': request.env.ref('sale.action_quotations').id,
'no_breadcrumbs': request.env.user.partner_id.commercial_partner_id not in order_sudo.message_partner_ids,
'tx_id': transaction.id if transaction else False,
'tx_state': transaction.state if transaction else False,
'payment_tx': transaction,
'tx_post_msg': transaction.acquirer_id.post_msg if transaction else False,
'need_payment': order_sudo.invoice_status == 'to invoice' and transaction.state in ['draft', 'cancel'],
'token': token,
'return_url': '/shop/payment/validate',
'bootstrap_formatting': True,
'partner_id': order_sudo.partner_id.id,
}
if order_sudo.require_payment or values['need_payment']:
acquirers = request.env['payment.acquirer'].sudo().search([('website_published', '=', True), ('company_id', '=', order_sudo.company_id.id)])
values['form_acquirers'] = [acq for acq in acquirers if acq.payment_flow == 'form' and acq.view_template_id]
values['s2s_acquirers'] = [acq for acq in acquirers if acq.payment_flow == 's2s' and acq.registration_view_template_id]
values['pms'] = request.env['payment.token'].search(
[('partner_id', '=', order_sudo.partner_id.id),
('acquirer_id', 'in', [acq.id for acq in values['s2s_acquirers']])])
history = request.session.get('my_quotes_history', [])
values.update(get_records_pager(history, order_sudo))
return request.render('website_quote.so_quotation', values)
def portal_my_activity(self, activity_id=None, **kw):
if self.has_activity_access(activity_id):
activity = request.env['mail.activity'].sudo().browse(activity_id)
vals = {'activity': activity}
history = request.session.get('my_activities_history', [])
vals.update(get_records_pager(history, activity))
return request.render("crm_attooh.portal_my_activity", vals)
return request.redirect('/my')
def portal_my_meeting(self, meeting_id=None, **kw):
if self.has_meeting_access(meeting_id):
meeting = request.env['calendar.event'].sudo().browse(meeting_id)
vals = {'meeting': meeting}
history = request.session.get('my_meeting_history', [])
vals.update(get_records_pager(history, meeting))
return request.render("crm_attooh.portal_my_meeting", vals)
return request.redirect('/my')
def portal_my_signature(self, signature_id=None, **kw):
if self.has_signature_access(signature_id):
signature = request.env['signature.request'].sudo().browse(
signature_id)
vals = {'signature': signature}
history = request.session.get('my_signature_history', [])
vals.update(get_records_pager(history, signature))
return request.render("crm_attooh.portal_my_signature", vals)
return request.redirect('/my')
def portal_my_attachment(self, attachment_id=None, **kw):
if self.has_attachment_access(attachment_id):
attachment = request.env['ir.attachment'].sudo().browse(
attachment_id)
vals = {'attachment': attachment}
history = request.session.get('my_attachment_history', [])
vals.update(get_records_pager(history, attachment))
return request.render("crm_attooh.portal_my_attachment", vals)
return request.redirect('/my')
def portal_my_task(self, task_id=None, **kw):
task = request.env['project.task'].browse(task_id)
task.check_access_rights('read')
task.check_access_rule('read')
vals = {'task': task, 'user': request.env.user}
history = request.session.get('my_tasks_history', [])
vals.update(get_records_pager(history, task))
return request.render("project.portal_my_task", vals)
def portal_my_task(self, task_id=None, **kw):
task = request.env['project.task'].browse(task_id)
vals = {
'task': task,
'user': request.env.user
}
history = request.session.get('my_tasks_history', [])
vals.update(get_records_pager(history, task))
return request.render("project.portal_my_task", vals)
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
now = fields.Date.today()
# Log only once a day
if order_sudo and request.session.get(
'view_quote_%s' % order_sudo.id) != 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 portal_order_page(self, order_id, pdf=None, access_token=None, message=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 pdf:
pdf = request.env.ref('sale.report_web_quote').sudo().with_context(set_viewport_size=True).render_qweb_pdf([order_sudo.id])[0]
pdfhttpheaders = [('Content-Type', 'application/pdf'), ('Content-Length', len(pdf))]
return request.make_response(pdf, headers=pdfhttpheaders)
# use sudo to allow accessing/viewing orders for public user
# only if he knows the private token
now = fields.Date.today()
# Log only once a day
if order_sudo and request.session.get('view_quote_%s' % order_sudo.id) != 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)
transaction = order_sudo.get_portal_last_transaction()
# TODO SEB fix breadcrumbs -> should always be visible (or at least no home alone)
values = {
'sale_order': order_sudo,
'message': int(message) if message else False,
'action': request.env.ref('sale.action_quotations').id,
'no_breadcrumbs': request.env.user.partner_id.commercial_partner_id not in order_sudo.message_partner_ids,
'tx_state': transaction.state if transaction else False,
'need_payment': order_sudo.invoice_status == 'to invoice' and transaction.state in ['draft', 'cancel'],
'token': access_token,
'return_url': '/shop/payment/validate',
'bootstrap_formatting': True,
'partner_id': order_sudo.partner_id.id,
}
if order_sudo.has_to_be_paid() or values['need_payment']:
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['form_acquirers'] = [acq for acq in acquirers if acq.payment_flow == 'form' and acq.view_template_id]
values['s2s_acquirers'] = [acq for acq in acquirers if acq.payment_flow == 's2s' and acq.registration_view_template_id]
values['pms'] = request.env['payment.token'].search(
[('partner_id', '=', order_sudo.partner_id.id),
('acquirer_id', 'in', [acq.id for acq in values['s2s_acquirers']])])
history = request.session.get('my_quotes_history', [])
values.update(get_records_pager(history, order_sudo))
return request.render('sale.sale_order_portal_template', values)
def _order_get_page_view_values(self, order, access_token, **kwargs):
order_invoice_lines = {il.product_id.id: il.invoice_id for il in order.invoice_ids.mapped('invoice_line_ids')}
values = {
'order': order,
'order_invoice_lines': order_invoice_lines,
}
if access_token:
values['no_breadcrumbs'] = True
history = request.session.get('my_orders_history', [])
values.update(get_records_pager(history, order))
return values
def portal_user_job_order(self, task_id=None, **kw):
task = request.env['project.task'].sudo().browse(task_id)
vals = {
'task': task,
'user': request.env.user,
'page_name': 'job_order',
'is_job_order':True,
}
history = request.session.get('my_tasks_history', [])
vals.update(get_records_pager(history, task))
print ("vals:::::::::::::::::::::::::::::::::::::",vals)
return request.render("project.portal_my_task", vals)
def portal_review_page(self, order_id, report_type=None, access_token=None, message=False, download=False, **kw):
res = self.portal_order_page(order_id, report_type, access_token, message, download, **kw)
res.qcontext.update({
'pending_review': True,
'page_name': 'review',
})
history = request.session.get('my_pending_reviews', [])
res.qcontext.update(get_records_pager(history, res.qcontext['sale_order']))
return res
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.report_web_quote', download=download)
# use sudo to allow accessing/viewing orders for public user
# only if he knows the private token
now = fields.Date.today()
# Log only once a day
if order_sudo and request.session.get('view_quote_%s' % order_sudo.id) != 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)
transaction = order_sudo.get_portal_last_transaction()
values = {
'sale_order': order_sudo,
'message': int(message) if message else False,
'tx_state': transaction.state if transaction else False,
'need_payment': order_sudo.invoice_status == 'to invoice' and transaction.state in ['draft', 'cancel'],
'token': access_token,
'return_url': '/shop/payment/validate',
'bootstrap_formatting': True,
'partner_id': order_sudo.partner_id.id,
'report_type': 'html',
}
if order_sudo.has_to_be_paid() or values['need_payment']:
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['form_acquirers'] = [acq for acq in acquirers if acq.payment_flow == 'form' and acq.view_template_id]
values['s2s_acquirers'] = [acq for acq in acquirers if acq.payment_flow == 's2s' and acq.registration_view_template_id]
values['pms'] = request.env['payment.token'].search(
[('partner_id', '=', order_sudo.partner_id.id),
('acquirer_id', 'in', [acq.id for acq in values['s2s_acquirers']])])
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 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
now = fields.Date.today()
# Log only once a day
if order_sudo and request.session.get('view_quote_%s' % order_sudo.id) != now and request.env.user.share and access_token:
request.session['view_quote_%s' % order_sudo.id] = now
body = _('Quotation viewed by customer %s') % order_sudo.partner_id.name
_message_post_helper('sale.order', order_sudo.id, 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),
('acquirer_id', 'in', acquirers.filtered(lambda acq: acq.payment_flow == 's2s').ids)])
values['acq_extra_fees'] = acquirers.get_acquirer_extra_fees(order_sudo.amount_total, order_sudo.currency_id, order_sudo.partner_id.country_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 portal_my_purchase_order(self, order_id=None, **kw):
order = request.env['purchase.order'].browse(order_id)
try:
order.check_access_rights('read')
order.check_access_rule('read')
except AccessError:
return request.redirect('/my')
history = request.session.get('my_purchases_history', [])
values = {
'order': order.sudo(),
}
values.update(get_records_pager(history, order))
return request.render("purchase.portal_my_purchase_order", values)
def portal_my_subcontractor(self, task_id, access_token=None, **kw):
task = request.env['project.task'].browse(task_id)
try:
task_sudo = self._document_check_access('project.task', task_id,
access_token)
except (AccessError, MissingError):
return request.redirect('/my')
vals = {'task_contract': task, 'user': request.env.user}
history = request.session.get('my_tasks_history', [])
vals.update(get_records_pager(history, task))
return request.render(
"job_order_subcontracting.portal_my_subcontractor", vals)
def portal_subscriptions_page(self,
subscription_id,
access_token=None,
message=False,
download=False,
**kw):
try:
sbscr_sudo = self._document_check_access('subscription.service',
subscription_id,
access_token=access_token)
except (AccessError, MissingError):
return request.redirect('/my')
# use sudo to allow accessing/viewing orders for public user
# only if he knows the private token
now = datetime.date.today()
# Log only once a day
if sbscr_sudo and request.session.get(
'view_quote_%s' % sbscr_sudo.id
) != now and request.env.user.share and access_token:
request.session['view_quote_%s' % sbscr_sudo.id] = now
body = _('Subscription viewed by customer')
_message_post_helper(
res_model='subscription.service',
res_id=sbscr_sudo.id,
message=body,
token=sbscr_sudo.access_token,
message_type='notification',
subtype="mail.mt_note",
partner_ids=sbscr_sudo.user_id.sudo().partner_id.ids)
display_close = sbscr_sudo.state in ['open', 'pending']
values = {
'subscription_service': sbscr_sudo,
'display_close': display_close,
'message': message,
'token': access_token,
'return_url': '/shop/payment/validate',
'bootstrap_formatting': True,
'partner_id': sbscr_sudo.partner_id.id,
}
if sbscr_sudo.company_id:
values['res_company'] = sbscr_sudo.company_id
history = request.session.get('my_subscriptions_history', [])
values.update(get_records_pager(history, sbscr_sudo))
return request.render('mdlu_subscription_service.subscription', values)
def portal_user_job_order(self, task_id=None, access_token=None, **kw):
task = request.env['project.task'].sudo().browse(task_id)
try:
task_sudo = self._document_check_access('project.task', task_id,
access_token)
except (AccessError, MissingError):
return request.redirect('/my')
vals = {
'task': task,
'user': request.env.user,
'page_name': 'job_order',
'is_job_order': True,
}
history = request.session.get('my_tasks_history', [])
vals.update(get_records_pager(history, task))
return request.render("project.portal_my_task", vals)
def list_my_tickets(self, ticket_id=None, **kw):
values = self._prepare_portal_layout_values()
ticket = request.env['helpdesk.ticket'].sudo().search(
[('id', '=', ticket_id)])
rating = request.env['rating.rating'].sudo().search(
[('res_model', '=', 'helpdesk.ticket'),
('res_id', '=', ticket.id),
('write_uid', '=', request.session.uid)])
display_rating = False
if ticket.stage_id and ticket.stage_id.stage_type == 'done':
display_rating = True
values.update({'ticket': ticket, 'rating': rating,
'priority': int(ticket.priority),
'display_rating': display_rating})
history = request.session.get('my_tickets_history', [])
values.update(get_records_pager(history, ticket))
return request.render("website_helpdesk.portal_my_ticket", values)
def portal_my_purchase_request(self,
purchase_request_id=None,
access_token=None,
message=False,
download=False,
**kw):
try:
pr_sudo = self._document_check_access('purchase.request',
purchase_request_id,
access_token=access_token)
except (AccessError, MissingError):
return request.redirect('/my')
now = datetime.date.today()
if pr_sudo and request.session.get(
'view_pr_%s' %
pr_sudo.id) != now and request.env.user.share and access_token:
request.session['view_quote_%s' % pr_sudo.id] = now
body = _('Purchase request viewed by customer')
_message_post_helper(
res_model='purchase.request',
res_id=pr_sudo.id,
message=body,
token=pr_sudo.access_token,
message_type='notification',
subtype="mail.mt_note",
partner_ids=pr_sudo.user_id.sudo().partner_id.ids)
values = {
'purchase_request': pr_sudo,
'message': message,
'token': access_token,
'return_url': '/my/purchase_requests',
'bootstrap_formatting': True,
'partner_id': pr_sudo.user_id.partner_id.id,
}
if pr_sudo.company_id:
values['res_company'] = pr_sudo.company_id
history = request.session.get('my_purchases_request_history', [])
values.update(get_records_pager(history, pr_sudo))
return request.render(
"mdlu_purchase_request.portal_my_purchase_request", values)
def portal_my_brd(self, brd_id=None, **kw):
brd = request.env['business.requirement.deliverable'].browse(brd_id)
brd.check_access_rights('read')
brd.check_access_rule('read')
if not brd.portal_published:
raise AccessError(
"Can't access to this business requirement deliverable")
vals = {
'brd': brd,
'user': request.env.user,
'page_name': 'business_requirement_deliverable',
}
history = request.session.get('my_brd_history', [])
vals.update(get_records_pager(history, brd))
return request.render("business_requirement_deliverable.portal_my_brd",
vals)
def _order_get_page_view_values(self, order, access_token, **kwargs):
values = {
'order': order,
}
if access_token:
values['no_breadcrumbs'] = True
values['access_token'] = access_token
values['portal_confirmation'] = order.get_portal_confirmation_action()
if kwargs.get('error'):
values['error'] = kwargs['error']
if kwargs.get('warning'):
values['warning'] = kwargs['warning']
if kwargs.get('success'):
values['success'] = kwargs['success']
history = request.session.get('my_orders_history', [])
values.update(get_records_pager(history, order))
return values
def _appointments_get_page_view_values(self, appointment, access_token,
**kwargs):
values = {
'page_name': 'appoint_mgmt',
'appointment': appointment,
}
if access_token:
values['no_breadcrumbs'] = True
if kwargs.get('error'):
values['error'] = kwargs['error']
if kwargs.get('warning'):
values['warning'] = kwargs['warning']
if kwargs.get('success'):
values['success'] = kwargs['success']
history = request.session.get('my_appointments_history', [])
values.update(get_records_pager(history, appointment))
values.update(
request.env['payment.acquirer']._get_available_payment_input(
appointment.customer, appointment.customer.company_id))
#for payment ---- ref-> account_payment module
payment_inputs = request.env[
'payment.acquirer']._get_available_payment_input(
company=appointment.customer.company_id)
# if not connected (using public user), the method _get_available_payment_input will return public user tokens
is_public_user = request.env.user._is_public()
if is_public_user:
# we should not display payment tokens owned by the public user
payment_inputs.pop('pms', None)
token_count = request.env['payment.token'].sudo().search_count([
('acquirer_id.company_id', '=',
appointment.customer.company_id.id),
('partner_id', '=', appointment.customer.id),
])
values['existing_token'] = token_count > 0
values.update(payment_inputs)
values[
'partner_id'] = appointment.customer if is_public_user else request.env.user.partner_id,
return values
def orders_followup(self, order=None, access_token=None, **kw):
order = request.env['sale.order'].browse([order])
order_sudo = order.sudo()
values = {}
try:
order.check_access_rights('read')
order.check_access_rule('read')
except AccessError:
if not access_token or not consteq(order_sudo.access_token, access_token):
return request.redirect('/my')
values.update({'no_breadcrumbs': True})
order_invoice_lines = {il.product_id.id: il.invoice_id for il in order_sudo.invoice_ids.mapped('invoice_line_ids')}
history = request.session.get('my_orders_history', [])
values.update({
'order': order_sudo,
'order_invoice_lines': order_invoice_lines,
})
values.update(get_records_pager(history, order_sudo))
return request.render("sale.orders_followup", values)
def _br_get_page_view_values(self, br, access_token, **kwargs):
values = {
'business_requirement': br,
'page_name': 'business_requirement',
}
if access_token:
values['no_breadcrumbs'] = True
values['access_token'] = access_token
values['portal_confirmation'] = br.get_portal_confirmation_action()
if kwargs.get('error'):
values['error'] = kwargs['error']
if kwargs.get('warning'):
values['warning'] = kwargs['warning']
if kwargs.get('success'):
values['success'] = kwargs['success']
history = request.session.get('my_br_history', [])
values.update(get_records_pager(history, br))
return values
def _brd_get_page_view_values(self, brd, access_token, **kwargs):
values = {
'brd': brd,
'page_name': 'business_requirement_deliverable',
'user': request.env.user,
}
if access_token:
values['no_breadcrumbs'] = True
values['access_token'] = access_token
if kwargs.get('error'):
values['error'] = kwargs['error']
if kwargs.get('warning'):
values['warning'] = kwargs['warning']
if kwargs.get('success'):
values['success'] = kwargs['success']
history = request.session.get('my_br_history', [])
values.update(get_records_pager(history, brd))
return values
def _br_get_page_view_values(self, br, access_token, **kwargs):
values = {
"business_requirement": br,
"page_name": "business_requirement"
}
if access_token:
values["no_breadcrumbs"] = True
values["access_token"] = access_token
values["portal_confirmation"] = br.get_portal_confirmation_action()
if kwargs.get("error"):
values["error"] = kwargs["error"]
if kwargs.get("warning"):
values["warning"] = kwargs["warning"]
if kwargs.get("success"):
values["success"] = kwargs["success"]
history = request.session.get("my_br_history", [])
values.update(get_records_pager(history, br))
return values
def _invoice_get_page_view_values(self, invoice, access_token, **kwargs):
values = {
'page_name': 'invoice',
'invoice': invoice,
}
if access_token:
# force breadcrumbs even if access_token to `invite` users to register if they click on it
values['no_breadcrumbs'] = False
values['access_token'] = access_token
if kwargs.get('error'):
values['error'] = kwargs['error']
if kwargs.get('warning'):
values['warning'] = kwargs['warning']
if kwargs.get('success'):
values['success'] = kwargs['success']
history = request.session.get('my_invoices_history', [])
values.update(get_records_pager(history, invoice))
return values
def _order_get_page_view_values(self, order, access_token, **kwargs):
order_invoice_lines = {il.product_id.id: il.invoice_id for il in order.invoice_ids.mapped('invoice_line_ids')}
values = {
'order': order,
'order_invoice_lines': order_invoice_lines,
}
if access_token:
values['no_breadcrumbs'] = True
values['access_token'] = access_token
values['portal_confirmation'] = order.get_portal_confirmation_action()
if kwargs.get('error'):
values['error'] = kwargs['error']
if kwargs.get('warning'):
values['warning'] = kwargs['warning']
if kwargs.get('success'):
values['success'] = kwargs['success']
history = request.session.get('my_orders_history', [])
values.update(get_records_pager(history, order))
return values
def view(self, order_id, pdf=None, token=None, message=False, **post):
# use sudo to allow accessing/viewing orders for public user
# only if he knows the private token
now = fields.Date.today()
if token:
Order = request.env['sale.order'].sudo().search([('id', '=', order_id), ('access_token', '=', token)])
else:
Order = request.env['sale.order'].search([('id', '=', order_id)])
# Log only once a day
if Order and request.session.get('view_quote') != now and request.env.user.share:
request.session['view_quote'] = now
body = _('Quotation viewed by customer')
_message_post_helper(res_model='sale.order', res_id=Order.id, message=body, token=token, token_field="access_token", message_type='notification', subtype="mail.mt_note", partner_ids=Order.user_id.sudo().partner_id.ids)
if not Order:
return request.render('website.404')
# Token or not, sudo the order, since portal user has not access on
# taxes, required to compute the total_amout of SO.
order_sudo = Order.sudo()
days = 0
if order_sudo.validity_date:
days = (fields.Date.from_string(order_sudo.validity_date) - fields.Date.from_string(fields.Date.today())).days + 1
if pdf:
pdf = request.env.ref('website_quote.report_web_quote').sudo().with_context(set_viewport_size=True).render_qweb_pdf([order_sudo.id])[0]
pdfhttpheaders = [('Content-Type', 'application/pdf'), ('Content-Length', len(pdf))]
return request.make_response(pdf, headers=pdfhttpheaders)
transaction_id = request.session.get('quote_%s_transaction_id' % order_sudo.id)
if not transaction_id:
Transaction = request.env['payment.transaction'].sudo().search([('reference', '=', order_sudo.name)])
else:
Transaction = request.env['payment.transaction'].sudo().browse(transaction_id)
values = {
'quotation': order_sudo,
'message': message and int(message) or False,
'option': any(not x.line_id for x in order_sudo.options),
'order_valid': (not order_sudo.validity_date) or (now <= order_sudo.validity_date),
'days_valid': days,
'action': request.env.ref('sale.action_quotations').id,
'no_breadcrumbs': request.env.user.partner_id.commercial_partner_id not in order_sudo.message_partner_ids,
'tx_id': Transaction.id if Transaction else False,
'tx_state': Transaction.state if Transaction else False,
'tx_post_msg': Transaction.acquirer_id.post_msg if Transaction else False,
'need_payment': order_sudo.invoice_status == 'to invoice' and Transaction.state in ['draft', 'cancel', 'error'],
'token': token,
}
if order_sudo.require_payment or values['need_payment']:
values['acquirers'] = list(request.env['payment.acquirer'].sudo().search([('website_published', '=', True), ('company_id', '=', order_sudo.company_id.id)]))
extra_context = {
'submit_class': 'btn btn-primary',
'submit_txt': _('Pay & Confirm')
}
values['buttons'] = {}
for acquirer in values['acquirers']:
values['buttons'][acquirer.id] = acquirer.with_context(**extra_context).render(
'/',
order_sudo.amount_total,
order_sudo.pricelist_id.currency_id.id,
values={
'return_url': '/quote/%s/%s' % (order_id, token) if token else '/quote/%s' % order_id,
'type': 'form',
'alias_usage': _('If we store your payment information on our server, subscription payments will be made automatically.'),
'partner_id': order_sudo.partner_id.id,
})
history = request.session.get('my_quotes_history', [])
values.update(get_records_pager(history, order_sudo))
return request.render('website_quote.so_quotation', values)
def portal_my_project(self, project_id=None, **kw):
project = request.env['project.project'].browse(project_id)
vals = {'project': project}
history = request.session.get('my_projects_history', [])
vals.update(get_records_pager(history, project))
return request.render("project.portal_my_project", vals)
