def confirm_unsubscribe(self, channel, partner_id, token, **kw):
subscriber = request.env['mail.channel.partner'].search([
('channel_id', '=', channel.id), ('partner_id', '=', partner_id)
])
if not subscriber:
partner = request.env['res.partner'].browse(
partner_id).sudo().exists()
# FIXME: remove try/except in master
try:
response = request.render(
'website_mail_channel.not_subscribed',
{'partner_id': partner})
# make sure the rendering (and thus error if template is
# missing) happens inside the try block
response.flatten()
return response
except ValueError:
return _(
"The address %s is already unsubscribed or was never subscribed to any mailing list"
) % (partner.email)
subscriber_token = channel._generate_action_token(partner_id,
action='unsubscribe')
if token != subscriber_token:
return request.render(
'website_mail_channel.invalid_token_subscription')
# remove partner
channel.sudo().write({'channel_partner_ids': [(3, partner_id)]})
return request.render("website_mail_channel.confirmation_subscription",
{'subscribing': False})
def slides_embed(self, slide_id, page="1", **kw):
# Note : don't use the 'model' in the route (use 'slide_id'), otherwise if public cannot access the embedded
# slide, the error will be the website.403 page instead of the one of the website_slides.embed_slide.
# Do not forget the rendering here will be displayed in the embedded iframe
# determine if it is embedded from external web page
referrer_url = request.httprequest.headers.get('Referer', '')
base_url = request.env['ir.config_parameter'].sudo().get_param(
'web.base.url')
is_embedded = referrer_url and not bool(
base_url in referrer_url) or False
# try accessing slide, and display to corresponding template
try:
slide = request.env['slide.slide'].browse(slide_id)
if is_embedded:
request.env['slide.embed'].sudo()._add_embed_url(
slide.id, referrer_url)
values = self._get_slide_detail(slide)
values['page'] = page
values['is_embedded'] = is_embedded
self._set_viewed_slide(slide)
return request.render('website_slides.embed_slide', values)
except AccessError: # TODO : please, make it clean one day, or find another secure way to detect
# if the slide can be embedded, and properly display the error message.
return request.render('website_slides.embed_slide_forbidden', {})
def view_user_profile(self, user_id, **post):
user = self._check_user_profile_access(user_id)
if not user:
return request.render("website_profile.private_profile")
values = self._prepare_user_values(**post)
params = self._prepare_user_profile_parameters(**post)
values.update(self._prepare_user_profile_values(user, **params))
return request.render("website_profile.user_profile_main", values)
def render_student_verification(self, **post):
"""
inherit render_student_verification method,
student additional form should student admission form.
------------------------------------------------------
@param self : object pointer
@param type : http
@param auth : public
@param website : booleab(True)
@return :
"""
if 'DATE' in post and post['DATE']:
data = post['DATE']
link_date = self.decode_base64(data)
if link_date == '':
return request.render("website_student_enquiry.student_link_expired_templet",{})
if 'ENQUIRY' in post and post['ENQUIRY']:
eq_no = str(post['ENQUIRY'])
env = request.env(context=dict(request.env.context, show_address=True, no_tag_br=True))
reg_obj = env['registration']
reg_rec = reg_obj.sudo().search([('enquiry_no','=',eq_no)],limit=1)
if reg_rec.id:
if reg_rec.add_form_filled != True:
if link_date != '0000-00-00':
s_date = datetime.strptime(link_date, '%Y-%m-%d').date()
l_date = s_date + timedelta(days=10)
c_date = date.today()
if s_date <= c_date < l_date:
if 'ENQUIRY' in post and post['ENQUIRY']:
student_obj = env['res.partner']
student_rec = student_obj.sudo().search(['|',('active','=',True),
('strike_off','=',True),
('is_student','=',True),
('reg_no','=',eq_no)],limit=1)
if student_rec.id:
e_student_id = base64.b64encode(str(student_rec.id))
return request.redirect(
"/student/verification/pagecode?student_id=%s" % (e_student_id))
else:
return request.render("website_student_enquiry.student_link_expired_templet",{})
else:
if 'ENQUIRY' in post and post['ENQUIRY']:
eq_no = str(post['ENQUIRY'])
env = request.env(context=dict(request.env.context, show_address=True, no_tag_br=True))
student_obj = env['res.partner']
student_rec = student_obj.sudo().search(['|',('active','=',True),
('strike_off','=',True),
('is_student','=',True),
('reg_no','=',eq_no)],limit=1)
if student_rec.id:
e_student_id = base64.b64encode(str(student_rec.id))
return request.redirect(
"/student/verification/pagecode?student_id=%s" % (e_student_id))
else:
return request.render("website_student_enquiry.student_link_expired_templet",{})
def slides_index(self, *args, **post):
""" Returns a list of available channels: if only one is available,
redirects directly to its slides
"""
domain = request.website.website_domain()
channels = request.env['slide.channel'].search(domain, order='sequence, id')
if not channels:
return request.render("website_slides.channel_not_found")
elif len(channels) == 1:
return request.redirect("/slides/%s" % channels.id)
return request.render('website_slides.channels', {
'channels': channels,
'user': request.env.user,
'is_public_user': request.env.user == request.website.user_id
})
def confirm(self, **kw):
tx_id = int(kw.get('tx_id', 0))
access_token = kw.get('access_token')
if tx_id:
if access_token:
tx = request.env['payment.transaction'].sudo().browse(tx_id)
secret = request.env['ir.config_parameter'].sudo().get_param(
'database.secret')
valid_token_str = '%s%s%s' % (tx.id, tx.reference, tx.amount)
valid_token = hmac.new(secret.encode('utf-8'),
valid_token_str.encode('utf-8'),
hashlib.sha256).hexdigest()
if not consteq(ustr(valid_token), access_token):
raise werkzeug.exceptions.NotFound
else:
tx = request.env['payment.transaction'].browse(tx_id)
if tx.state in ['done', 'authorized']:
status = 'success'
message = tx.acquirer_id.done_msg
elif tx.state == 'pending':
status = 'warning'
message = tx.acquirer_id.pending_msg
PaymentProcessing.remove_payment_transaction(tx)
return request.render('payment.confirm', {
'tx': tx,
'status': status,
'message': message
})
else:
return request.redirect('/my/home')
def product_compare(self, **post):
values = {}
product_ids = [
int(i) for i in post.get('products', '').split(',') if i.isdigit()
]
if not product_ids:
return request.redirect("/shop")
# use search to check read access on each record/ids
products = request.env['product.product'].search([('id', 'in',
product_ids)])
values['products'] = products.with_context(display_default_code=False)
res = {}
for num, product in enumerate(products):
for var in product.product_tmpl_id._get_valid_product_template_attribute_lines(
):
cat_name = var.attribute_id.category_id.name or _(
'Uncategorized')
att_name = var.attribute_id.name
if not var.attribute_id.create_variant:
continue
res.setdefault(cat_name, OrderedDict()).setdefault(
att_name, [' - '] * len(products))
val = product.attribute_value_ids.filtered(
lambda x: x.attribute_id == var.attribute_id)
if val:
res[cat_name][att_name][num] = val[0].name
values['specs'] = res
values['compute_currency'] = self._get_compute_currency_and_context(
products[:1].product_tmpl_id)[0]
return request.render("website_sale_comparison.product_compare",
values)
def blogs(self, page=1, **post):
domain = request.website.website_domain()
Blog = request.env['blog.blog']
blogs = Blog.search(domain, limit=2)
if len(blogs) == 1:
return werkzeug.utils.redirect('/blog/%s' % slug(blogs[0]),
code=302)
BlogPost = request.env['blog.post']
total = BlogPost.search_count(domain)
pager = request.website.pager(
url='/blog',
total=total,
page=page,
step=self._blog_post_per_page,
)
posts = BlogPost.search(domain,
offset=(page - 1) * self._blog_post_per_page,
limit=self._blog_post_per_page)
blog_url = QueryURL('', ['blog', 'tag'])
return request.render("website_blog.latest_blogs", {
'posts': posts,
'pager': pager,
'blog_url': blog_url,
})
def shop(self, page=0, category=None, search='', ppg=False, **post):
if post.get('filter_clear'):
return request.redirect('/shop')
if post.get('filter_remove'):
category = None
values = self.ks_getShopValues(page, category, search, ppg, **post)
return request.render("website_sale.products", values)
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 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 users(self, forum, page=1, **searches):
User = request.env['res.users']
step = 30
tag_count = User.sudo().search_count([('karma', '>', 1),
('website_published', '=', True)
])
pager = request.website.pager(url="/forum/%s/users" % slug(forum),
total=tag_count,
page=page,
step=step,
scope=30)
user_obj = User.sudo().search([('karma', '>', 1),
('website_published', '=', True)],
limit=step,
offset=pager['offset'],
order='karma DESC')
# put the users in block of 3 to display them as a table
users = [[] for i in range(len(user_obj) // 3 + 1)]
for index, user in enumerate(user_obj):
users[index // 3].append(user)
searches['users'] = 'True'
values = self._prepare_forum_values(forum=forum, searches=searches)
values.update({
'users': users,
'main_object': forum,
'notifications': self._get_notifications(),
'pager': pager,
})
return request.render("website_forum.users", values)
def tags(self, forum, tag_char=None, **post):
# build the list of tag first char, with their value as tag_char param Ex : [('All', 'all'), ('C', 'c'), ('G', 'g'), ('Z', z)]
first_char_tag = forum.get_tags_first_char()
first_char_list = [(t, t.lower()) for t in first_char_tag
if t.isalnum()]
first_char_list.insert(0, (_('All'), 'all'))
# get active first char tag
active_char_tag = first_char_list[1][1] if len(
first_char_list) > 1 else 'all'
if tag_char:
active_char_tag = tag_char.lower()
# generate domain for searched tags
domain = [('forum_id', '=', forum.id), ('posts_count', '>', 0)]
order_by = 'name'
if active_char_tag and active_char_tag != 'all':
domain.append(
('name', '=ilike', tools.escape_psql(active_char_tag) + '%'))
order_by = 'posts_count DESC'
tags = request.env['forum.tag'].search(domain,
limit=None,
order=order_by)
# prepare values and render template
values = self._prepare_forum_values(forum=forum,
searches={'tags': True},
**post)
values.update({
'tags': tags,
'pager_tag_chars': first_char_list,
'active_char_tag': active_char_tag,
})
return request.render("website_forum.tag", values)
def forum(self, **kwargs):
domain = request.website.website_domain()
forums = request.env['forum.forum'].search(domain)
if len(forums) == 1:
return werkzeug.utils.redirect('/forum/%s' % slug(forums[0]),
code=302)
return request.render("website_forum.forum_all", {'forums': forums})
def render_employement_form(self, **post):
"""
this method is used to Student email varification,
if write email id then move to page that he is
update his information and fill other details.
------------------------------------------
@param self : object pointer
@param type : http
@param auth : public
@param website : True
@return : call templet also pass dictonary for
required data
"""
employee_id = post.get('employee')
env = request.env(context=dict(request.env.context))
hr_emp_obj = env['hr.employee']
ir_model_fields_obj = env['ir.model.fields']
hr_emp_rec = hr_emp_obj.sudo().search([('id','=',employee_id)])
# if hr_emp_rec.employment_form_filled == True:
# return request.render("edsys_hrm.employement_link_expired_templet",{})
orm_country = env['res.country']
orm_currency = env['res.currency']
state_orm = env['res.country.state']
orm_visa_type = env['visa.type']
orm_ir_attachment = env['ir.attachment']
countries = orm_country.sudo().search([])
currencies = orm_currency.sudo().search([])
states = state_orm.sudo().search([])
visa_type_ids = orm_visa_type.sudo().search([])
resume_ids = orm_ir_attachment.sudo().search([('name','=','Resume'),('res_model','=', 'hr.employee'), ('res_id','=',hr_emp_rec.id)])
if not resume_ids :
resume_ids = False
salary_certificate_ids = orm_ir_attachment.sudo().search([('name','=','Salary Certificate'),('res_model','=', 'hr.employee'), ('res_id','=',hr_emp_rec.id)])
if not salary_certificate_ids :
salary_certificate_ids = False
passport_copy_ids = orm_ir_attachment.sudo().search([('name','=','Passport'),('res_model','=', 'hr.employee'), ('res_id','=',hr_emp_rec.id)])
if not passport_copy_ids :
passport_copy_ids = False
relieving_letter_ids = orm_ir_attachment.sudo().search([('name','=','Relieving Letter'),('res_model','=', 'hr.employee'), ('res_id','=',hr_emp_rec.id)])
if not relieving_letter_ids :
relieving_letter_ids = False
if hr_emp_rec.id :
if hr_emp_rec.image_medium :
image_medium = True
else :
image_medium = False
hr_web_data = {
'hr_emp_rec' : hr_emp_rec,
'countries' : countries,
'currencies' : currencies,
'states' : states,
'visa_type_ids' : visa_type_ids,
'resume_ids' : resume_ids,
'salary_certificate_ids' : salary_certificate_ids,
'relieving_letter_ids' : relieving_letter_ids,
'passport_copy_ids' : passport_copy_ids,
'image_medium' : image_medium,
}
return request.render("edsys_hrm.website_epmloyement_application_form",hr_web_data)
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(list(attendee_ids))
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 post_create(self, forum, post_parent=None, **post):
if post.get('content', '') == '<p><br></p>':
return request.render(
'http_routing.http_error', {
'status_code':
_('Bad Request'),
'status_message':
post_parent and _('Reply should not be empty.')
or _('Question should not be empty.')
})
post_tag_ids = forum._tag_to_write_vals(post.get('post_tags', ''))
if request.env.user.forum_waiting_posts_count:
return werkzeug.utils.redirect("/forum/%s/ask" % slug(forum))
new_question = request.env['forum.post'].create({
'forum_id':
forum.id,
'name':
post.get('post_name')
or (post_parent and 'Re: %s' % (post_parent.name or '')) or '',
'content':
post.get('content', False),
'parent_id':
post_parent and post_parent.id or False,
'tag_ids':
post_tag_ids
})
return werkzeug.utils.redirect(
"/forum/%s/question/%s" %
(slug(forum), post_parent and slug(post_parent)
or new_question.id))
def productVariants(self, product, **post):
pricelist = request.website.get_current_pricelist()
return request.render(
"update_variants_in_cart.variantUpdateForm", {
'product': product.with_context(pricelist=int(pricelist)),
'previous_line_id': post.get('previous_line_id', False)
})
def pos_web(self, config_id=False, **k):
"""Open a pos session for the given config.
The right pos session will be selected to open, if non is open yet a new session will be created.
:param debug: The debug mode to load the session in.
:type debug: str.
:param config_id: id of the config that has to be loaded.
:type config_id: str.
:returns: object -- The rendered pos session.
"""
domain = [('state', '=', 'opened'),
('user_id', '=', request.session.uid),
('rescue', '=', False)]
if config_id:
domain = AND([domain, [('config_id', '=', int(config_id))]])
pos_session = request.env['pos.session'].sudo().search(domain, limit=1)
if not pos_session:
return werkzeug.utils.redirect(
'/web#action=point_of_sale.action_client_pos_menu')
# The POS only work in one company, so we enforce the one of the session in the context
session_info = request.env['ir.http'].session_info()
session_info['user_context'][
'allowed_company_ids'] = pos_session.company_id.ids
context = {
'session_info': session_info,
'login_number': pos_session.login(),
}
return request.render('point_of_sale.index', qcontext=context)
def channel_rating(self, channel, **kw):
# get the last 100 ratings and the repartition per grade
domain = [
('res_model', '=', 'mail.channel'),
('res_id', 'in', channel.sudo().channel_ids.ids),
('consumed', '=', True),
('rating', '>=', 1),
]
ratings = request.env['rating.rating'].search(domain,
order='create_date desc',
limit=100)
repartition = channel.sudo().channel_ids.rating_get_grades(
domain=domain)
# compute percentage
percentage = dict.fromkeys(['great', 'okay', 'bad'], 0)
for grade in repartition:
percentage[grade] = round(
repartition[grade] * 100.0 / sum(repartition.values()),
1) if sum(repartition.values()) else 0
# the value dict to render the template
values = {
'channel': channel,
'ratings': ratings,
'team': channel.sudo().user_ids,
'percentage': percentage
}
return request.render("website_livechat.channel_page", values)
def _serve_page(cls):
req_page = request.httprequest.path
page_domain = [('url', '=', req_page)
] + request.website.website_domain()
published_domain = page_domain
# need to bypass website_published, to apply is_most_specific
# filter later if not publisher
pages = request.env['website.page'].sudo().search(published_domain,
order='website_id')
pages = pages.filtered(pages._is_most_specific_page)
if not request.website.is_publisher():
pages = pages.filtered('is_visible')
mypage = pages[0] if pages else False
_, ext = os.path.splitext(req_page)
if mypage:
return request.render(
mypage.get_view_identifier(),
{
# 'path': req_page[1:],
'deletable': True,
'main_object': mypage,
},
mimetype=_guess_mimetype(ext))
def channel_list(self, **kw):
# display the list of the channel
channels = request.env['im_livechat.channel'].search([
('website_published', '=', True)
])
values = {'channels': channels}
return request.render('website_livechat.channel_list_page', values)
def featured_product_get_dynamic_slider(self, **post):
uid, context, pool = request.uid, dict(request.context), request.env
if post.get('slider-id'):
slider_header = request.env['feature.product.slider.config'].sudo(
).search([('id', '=', int(post.get('slider-id')))])
if not context.get('pricelist'):
pricelist = request.website.get_current_pricelist()
context = dict(request.context, pricelist=int(pricelist))
else:
pricelist = pool.get('product.pricelist').browse(
context['pricelist'])
context.update({'pricelist': pricelist.id})
from_currency = pool['res.users'].browse(
uid).company_id.currency_id
to_currency = pricelist.currency_id
def compute_currency(price):
return pool['res.currency']._convert(price, from_currency,
to_currency,
fields.Date.today())
values = {
'compute_currency': compute_currency,
'slider_header': slider_header
}
return request.render(
"eagle_theme.eagle_theme_featured_product_slider_view", values)
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 eagleshop_product_multi_get_dynamic_slider(self, **post):
context, pool = dict(request.context), request.env
if post.get('slider-type'):
slider_header = request.env['multi.slider.config'].sudo().search([
('id', '=', int(post.get('slider-type')))
])
if not context.get('pricelist'):
pricelist = request.website.get_current_pricelist()
context = dict(request.context, pricelist=int(pricelist))
else:
pricelist = pool.get('product.pricelist').browse(
context['pricelist'])
context.update({'pricelist': pricelist.id})
from_currency = pool['res.users'].sudo().browse(
SUPERUSER_ID).company_id.currency_id
to_currency = pricelist.currency_id
def compute_currency(price):
return pool['res.currency']._convert(price, from_currency,
to_currency,
fields.Date.today())
values = {
'slider_details': slider_header,
'slider_header': slider_header,
'compute_currency': compute_currency
}
return request.render(
"eagle_theme.eagle_theme_multi_cat_slider_view", values)
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 product(self, product, category='', search='', **kwargs):
seconds = 0
values = super(WebsiteSale, self).product(product, category, search)
values.qcontext.update({
"current_url_fb": "http://www.facebook.com/sharer/sharer.php?u=" + request.httprequest.base_url,
"current_url_twit": "https://twitter.com/intent/tweet?text=" + request.httprequest.base_url,
"current_url_lin": "http://www.linkedin.com/shareArticle?mini=true-url=" + request.httprequest.base_url,
"current_url_gplus": "https://plus.google.com/share?url=" + request.httprequest.base_url,
"seconds": seconds,
'unit_of_measure_name':request.env['product.template'].browse(product.id).sudo()._get_weight_uom_name_from_ir_config_parameter()
})
query = "select product_template_id FROM product_template_res_users where res_user_id = %s ORDER BY recently_viewed_date DESC"
request.env.cr.execute(query, (request.env.user.id,))
ids = request.env.cr.fetchall()
product_template_ids = [i[0] for i in ids]
if product.id not in product_template_ids:
request.env.cr.execute("insert into product_template_res_users"
" (res_user_id, product_template_id,recently_viewed_date)"
" values"
" (%s, %s, %s)",
(request.env.user.id, product.id, fields.Datetime.now()))
else:
request.env.cr.execute(
'UPDATE product_template_res_users SET recently_viewed_date=%s WHERE product_template_id=%s and res_user_id=%s',
(fields.Datetime.now(), product.id, request.env.user.id))
return request.render("website_sale.product", values.qcontext)
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 jobs_detail(self, job, **kwargs):
if not job.can_access_from_current_website():
raise NotFound()
return request.render("website_hr_recruitment.detail", {
'job': job,
'main_object': job,
})
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)
