def open_rating(self, token, rate, **kwargs): rating = request.env['rating.rating'].sudo().search([('access_token', '=', token)]) if not rating.consumed: return request.render('rating.rating_external_page_submit', {'rating': rate, 'token': token}) else: return request.render('rating.rating_external_page_view', {'is_rated': True}) return request.not_found()
def add(self, option_id, order_id, token, **post): vals = {} order = request.registry.get('sale.order').browse(request.cr, SUPERUSER_ID, order_id) if token != order.access_token: return request.render('website.404') if order.state not in ['draft', 'sent']: return request.render('website.http_error', {'status_code': 'Forbidden', 'status_message': _('You cannot add options to a confirmed order.')}) option_obj = request.registry.get('sale.order.option') option = option_obj.browse(request.cr, SUPERUSER_ID, option_id) vals = { 'price_unit': option.price_unit, 'website_description': option.website_description, 'name': option.name, 'order_id': order.id, 'product_id': option.product_id.id, 'layout_category_id': option.layout_category_id.id, 'product_uom_qty': option.quantity, 'product_uom': option.uom_id.id, 'discount': option.discount, } line = request.registry.get('sale.order.line').create(request.cr, SUPERUSER_ID, vals, context=request.context) request.registry.get('sale.order.line')._compute_tax_id(request.cr, SUPERUSER_ID, [line], context=request.context) option_obj.write(request.cr, SUPERUSER_ID, [option.id], {'line_id': line}, context=request.context) return werkzeug.utils.redirect("/quote/%s/%s#pricing" % (order.id, token))
def index(self, **kwargs): method = request.httprequest.method if method == "GET": return request.render("hr_sf.attendance_index") elif method == "POST": Attendance = request.env["hr.attendance"].sudo() Employee = request.env["hr.employee"].sudo() UploadLog = request.env["hr_sf.attendance_upload_log"].sudo() try: upload_file = kwargs.get("upload_file", None) source = kwargs.get("source", None) if upload_file is None: raise Exception("can not get upload file from http post data") upload_file_content = upload_file.stream.read() sniffer = csv.Sniffer() dialect = sniffer.sniff(upload_file_content, delimiters=',\t') rows = csv.reader(upload_file_content.splitlines(), dialect=dialect) upload_log = None if rows: base64_file = base64.standard_b64encode(upload_file_content) upload_log = UploadLog.create({"upload_file": base64_file, "file_name": upload_file.filename, "date": Datetime.now(), "source": source}) upload_log_id = upload_log.id employees = Employee.search([]) employee_ids = dict(employees.mapped(lambda r: (r.internal_code, r.id))) line_number = 0 values = [] for row in rows: code, name, year, month, day, hour, minute = row[0:7] location = str(int(row[7])) dt_str = "%s-%s-%s %s:%s:00" % (year, month, day, hour, minute) dt = Datetime.from_string(dt_str) dt = dt - datetime.timedelta(hours=8) odoo_dt_str = Datetime.to_string(dt) exist_count = Attendance.search_count([("code", "=", code), ("name", "=", odoo_dt_str)]) if exist_count <= 0: emp_id = employee_ids.get(code, None) if emp_id is not None: # Attendance.create({"employee_id": emp_id, "name": odoo_dt_str, "location": location, # "action": "action", "upload_log_id": upload_log_id}) values.append({"employee_id": emp_id, "name": odoo_dt_str, "location": location, "action": "action", "upload_log_id": upload_log_id, "forget_card": False}) else: raise Exception("error in line:%d,employee with code:%s not found" % (line_number, code)) line_number += 1 for value in values: Attendance.create(value) return request.render("hr_sf.attendance_upload_finish", {"import_count": len(values)}) except Exception, e: request.env.cr.rollback() return e.message or e.value
def form_lead(self, form=False, lead=False, **post): cr, uid, context, pool = request.cr, request.uid, request.context, request.registry form = request.env['form.form'].search([('name', '=', form)]) if not form: _logger.info("Not Form 404") return request.render('website.page_404', {}) if not lead: _logger.info("Not Lead 404") return request.render('website.page_404', {}) # self.pool['mail.mail.statistics'].set_replied(cr, uid, mail_message_ids=message_ids, context=context) # Sätt öppnade formulär i "replied" # message_ids == self.pool['mail.mail.statistics'].search([('model','=','crm.lead'),('res_id','=',lead.id)] if request.httprequest.method == 'POST': form_data = request.env['form.form'].form_eval(form.model_id.model,post) _logger.debug("Form Data %s %s" % (form_data, post)) partner = request.env['res.partner'].sudo().create({'is_company': True, 'name': form_data['partner_name'], 'email': form_data.get('email_from',''), 'phone': form_data.get('phone',''), 'mobile':form_data.get('mobile',''), 'ref': form_data.get('contact_name','') }) form_data['partner_id'] = partner.id form_data['type'] = 'opportunity' form_data['stage_id'] = request.env.ref('crm.stage_lead1').id lead.sudo().write(form_data) return werkzeug.utils.redirect(form.thanks_url) return request.render(form.template, {'form': form, 'lead': lead})
def get_products(self, category=False, **post): cr, uid, context, pool = request.cr, request.uid, request.context, request.registry if category and not category.website_published: return request.render('website.page_404', {}) elif category.website_description_template: return request.render(category.website_description_template.id, {'products': request.env['product.template'].sudo().search(['&', ('categ_id', '=', category.id), ('state', '=', 'sellable')], order='website_sequence'), 'category': category}) else: return request.render('website_product_category.page_behandling', {'products': request.env['product.template'].sudo().search(['&', ('categ_id', '=', category.id), ('state', '=', 'sellable')], order='website_sequence'), 'category': category})
def view_project(self, project_id=None, token=None, **post): if self.check_token(token, request): context = { "project" : request.env["project.project"].sudo().browse(project_id), "token" : token } return request.render("lia2_site.project_template", context) else: return request.render("lia2_site.unauthorized_template", None)
def applications(self, app_name, **kwargs): jdapps_obj = request.registry['jdapps.apps'] apps_ids = jdapps_obj.search(request.cr, request.uid, [('uri', '=', app_name)], context=request.context) if not apps_ids: return request.render('jdapps.404') values = { 'app': jdapps_obj.browse(request.cr, request.uid, apps_ids[0], request.context), } return request.render('jdapps.applications', values)
def redsys_result(self, page, **vals): try: order_id = vals.get('order_id', 0) sale_obj = request.env['sale.order'] order = sale_obj.browse(int(order_id)) res = { 'order': order, } return request.render('payment_redsys.%s' % str(page), res) except: return request.render('website.404')
def view_sprint(self, sprint_id=None, token=None, **post): if self.check_token(token, request): sprint = request.env["project.scrum.sprint"].sudo().browse(sprint_id) context = { "sprint" : sprint, "token" : token } return request.render("lia2_site.sprint_template", context) else: return request.render("lia2_site.unauthorized_template", None)
def portal(self, token=False, **post): if self.check_token(token, request): context = { "employees" : request.env["hr.employee"].sudo().search([("publish_in_portal", "=", True)]), "projects" : request.env["project.project"].sudo().search([("publish_in_portal", "=", True)]), "token" : token } return request.render("lia2_site.main_template", context) else: return request.render("lia2_site.unauthorized_template", None)
def submit_rating(self, token, rate, **kwargs): rating = request.env['rating.rating'].sudo().search([('access_token', '=', token)]) if not rating.consumed: record_sudo = request.env[rating.res_model].sudo().browse(rating.res_id) record_sudo.rating_apply(rate, token=token, feedback=kwargs.get('feedback')) # redirect to the form view if logged person if request.session.uid: return werkzeug.utils.redirect('/web#model=%s&id=%s&view_type=form' % (record_sudo._name, record_sudo.id)) return request.render('rating.rating_external_page_view', {'is_public': True}) else: return request.render('rating.rating_external_page_view', {'is_rated': True}) return request.not_found()
def accept(self, order_id, token=None, signer=None, sign=None, **post): order_obj = request.registry.get('sale.order') order = order_obj.browse(request.cr, SUPERUSER_ID, order_id) if token != order.access_token: return request.render('website.404') if order.require_payment: return request.render('website.404') if order.state != 'sent': return False attachments=sign and [('signature.png', sign.decode('base64'))] or [] order_obj.action_confirm(request.cr, SUPERUSER_ID, [order_id], context=request.context) message = _('Order signed by %s') % (signer,) _message_post_helper(message=message, res_id=order_id, res_model='sale.order', attachments=attachments, **({'token': token, 'token_field': 'access_token'} if token else {})) return True
def slides_index(self, *args, **post): """ Returns a list of available channels: if only one is available, redirects directly to its slides """ channels = request.env['slide.channel'].search([], 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 view_employee(self, employee_id=None, token=None, **post): if self.check_token(token, request): employee = request.env["hr.employee"].sudo().browse(employee_id) context = { "meetings" : request.env["project.scrum.meeting"].sudo().search([("user_id_meeting", "=", employee.user_id.id)], order="date_meeting desc"), "projects" : request.env["project.project"].sudo().search([("members.id", "=", employee.user_id.id)]), "employee" : employee, "token" : token } return request.render("lia2_site.employee_template", context) else: return request.render("lia2_site.unauthorized_template", None)
def support_page(self, dbname, channel_id, **kwargs): registry, cr, uid, context = openerp.modules.registry.RegistryManager.get(dbname), request.cr, openerp.SUPERUSER_ID, request.context info = registry.get('im_livechat.channel').get_info_for_chat_src(cr, uid, channel_id) info["dbname"] = dbname info["channel"] = channel_id info["channel_name"] = registry.get('im_livechat.channel').read(cr, uid, channel_id, ['name'], context=context)["name"] return request.render('im_livechat.support_page', info)
def get_patients(self, *args, **kw): """ Returns the patient task list for patients. :returns: patient task list response object :rtype: :class:`http.Response<openerp.http.Response>` """ cr, uid, context = request.cr, request.session.uid, request.context patient_api = request.registry['nh.eobs.api'] patient_api.unassign_my_activities(cr, uid) follow_activities = patient_api.get_assigned_activities( cr, uid, activity_type='nh.clinical.patient.follow', context=context ) patients = self.process_patient_list( cr, uid, patient_api.get_patients( cr, uid, [], context=context), context=context) patient_api.get_patient_followers(cr, uid, patients, context=context) following_patients = self.process_patient_list( cr, uid, patient_api.get_followed_patients( cr, uid, []), context=context) return request.render( 'nh_eobs_mobile.patient_task_list', qcontext={ 'notifications': follow_activities, 'items': patients, 'notification_count': len(follow_activities), 'followed_items': following_patients, 'section': 'patient', 'username': request.session['login'], 'urls': URLS} )
def loader(self, dbname, channel_id, **kwargs): registry, cr, uid, context = openerp.modules.registry.RegistryManager.get(dbname), request.cr, openerp.SUPERUSER_ID, request.context info = registry.get('im_livechat.channel').get_info_for_chat_src(cr, uid, channel_id) info["dbname"] = dbname info["channel"] = channel_id info["username"] = kwargs.get("username", "Visitor") return request.render('im_livechat.loader', info)
def smart_login(self, redirect=None, **kw): #return "Method %s Session UID %s uid %s" % (request.httprequest.method,request.session.uid,request.uid) ensure_db() if request.httprequest.method == 'GET' and redirect and request.session.uid: return http.redirect_with_hash(redirect) if request.httprequest.method == 'GET' and request.session.uid: # if request.httprequest.method == 'GET': return http.redirect_with_hash('/dashboard') if not request.uid: request.uid = openerp.SUPERUSER_ID values = request.params.copy() if not redirect: redirect = '/dashboard?' + request.httprequest.query_string values['redirect'] = redirect try: values['databases'] = http.db_list() except openerp.exceptions.AccessDenied: values['databases'] = None if request.httprequest.method == 'POST': old_uid = request.uid uid = request.session.authenticate(request.session.db, request.params['login'], request.params['password']) if uid is not False: return http.redirect_with_hash(redirect) request.uid = old_uid values['error'] = "Wrong login/password" return request.render('smart_common.login', values)
def FieldTextHtml(self, model=None, res_id=None, field=None, callback=None, **kwargs): cr, uid, context = request.cr, request.uid, request.context kwargs.update( model=model, res_id=res_id, field=field, datarecord=json.loads(kwargs['datarecord']), debug='debug' in kwargs) for k in kwargs: if isinstance(kwargs[k], basestring) and kwargs[k].isdigit(): kwargs[k] = int(kwargs[k]) trans = dict( lang=kwargs.get('lang', context.get('lang')), translatable=kwargs.get('translatable'), edit_translations=kwargs.get('edit_translations'), editable=kwargs.get('enable_editor')) context.update(trans) kwargs.update(trans) record = None if model and kwargs.get('res_id'): record = request.registry[model].browse(cr, uid, kwargs.get('res_id'), context) kwargs.update(content=record and getattr(record, field) or "") return request.render(kwargs.get("template") or "web_editor.FieldTextHtml", kwargs, uid=request.uid)
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 support_page(self, dbname, channel_id, **kwargs): Channel = request.env['im_livechat.channel'] info = Channel.get_channel_infos(channel_id) info["dbname"] = dbname info["channel"] = channel_id info["channel_name"] = Channel.browse(channel_id).name return request.render('im_livechat.support_page', info)
def form_view(self, form=False,**post): cr, uid, context, pool = request.cr, request.uid, request.context, request.registry form = request.env['form.form'].search([('name','=', form)]) if request.httprequest.method == 'POST': form_data = {} for key in post.keys(): # fields project.issue.description_1 .. nn if re.match(".*_(\d+)",key): (field_name,nr) = re.split('_',key,1) if form_data.get(field_name): form_data[field_name].append(post.get(key)) else: form_data[field_name] = [post.get(key)] for key in form_data.keys(): if type(form_data[key]) is list: form_data[key] = ', '.join(form_data[key]) form_data = dict((field_name, post.pop(form.model_id.model + '.' + field_name)) # fields project.issue.name for field_name in request.env[form.model_id.model].fields_get().keys() if post.get(form.model_id.model + '.' + field_name)) form_so = {'sale.order': form_data} _logger.warning("Form Data %s %s" % (form_data, post)) object = request.env[form.model_id.model].create(form_data) _logger.warning("Form created object %s" % (object)) return werkzeug.utils.redirect(form.thanks_url) _logger.warning("This is form post %s %s" % (form, post)) return request.render('website_form.form', {'form': form})
def get_share_patients(self, *args, **kw): """ Renders the shared patient list. :returns: shared patient list response object :rtype: :class:`http.Response<openerp.http.Response>` """ cr, uid, context = request.cr, request.session.uid, request.context api = request.registry['nh.eobs.api'] api.unassign_my_activities(cr, uid) patients = api.get_patients(cr, uid, [], context=context) api.get_patient_followers(cr, uid, patients, context=context) api.get_invited_users(cr, uid, patients, context=context) follow_activities = api.get_assigned_activities( cr, uid, activity_type='nh.clinical.patient.follow', context=context ) self.process_patient_list(cr, uid, patients, context=context) sorted_pts = sorted( patients, key=lambda k: cmp(k['followers'], k['invited_users']) ) return request.render( 'nh_eobs_mobile.share_patients_list', qcontext={ 'items': sorted_pts, 'section': 'patient', 'username': request.session['login'], 'share_list': True, 'notification_count': len(follow_activities), 'urls': URLS, 'user_id': uid } )
def question(self, forum, question, **post): # Hide posts from abusers (negative karma), except for moderators if not question.can_view: raise werkzeug.exceptions.NotFound() # Hide pending posts from non-moderators and non-creator user = request.env.user if question.state == 'pending' and user.karma < forum.karma_post and question.create_uid != user: raise werkzeug.exceptions.NotFound() # increment view counter question.sudo().set_viewed() if question.parent_id: redirect_url = "/forum/%s/question/%s" % (slug(forum), slug(question.parent_id)) return werkzeug.utils.redirect(redirect_url, 301) filters = 'question' values = self._prepare_forum_values(forum=forum, searches=post) values.update({ 'main_object': question, 'question': question, 'can_bump': (question.forum_id.allow_bump and not question.child_ids and (datetime.today() - datetime.strptime(question.write_date, tools.DEFAULT_SERVER_DATETIME_FORMAT)).days > 9), 'header': {'question_data': True}, 'filters': filters, 'reversed': reversed, }) return request.render("website_forum.post_description_full", values)
def get_tasks(self, *args, **kw): """ Renders the patient task list for tasks. :returns: task list response object :rtype: :class:`http.Response<openerp.http.Response>` """ cr, uid, context = request.cr, request.uid, request.context task_api = request.registry['nh.eobs.api'] task_api.unassign_my_activities(cr, uid) follow_activities = task_api.get_assigned_activities( cr, uid, activity_type='nh.clinical.patient.follow', context=context ) # grab the patient object and get id? tasks = task_api.get_activities(cr, uid, [], context=context) for task in tasks: task['url'] = '{0}{1}'.format(URLS['single_task'], task['id']) task['color'] = self.calculate_ews_class(task['clinical_risk']) return request.render( 'nh_eobs_mobile.patient_task_list', qcontext={ 'items': tasks, 'section': 'task', 'username': request.session['login'], 'notification_count': len(follow_activities), 'urls': URLS } )
def facebook_header(self, user=False, **post): cr, uid, context, pool = request.cr, request.uid, request.context, request.registry ctx = { 'user' : user, } return request.render('website_facebook.fb_page', ctx)
def loader(self, dbname, channel_id, **kwargs): info = request.env['im_livechat.channel'].sudo().get_channel_infos(channel_id) info["dbname"] = dbname info["channel"] = channel_id info["username"] = kwargs.get("username", _("Visitor")) # find the country from the request country_id = False country_code = request.session.geoip and request.session.geoip.get('country_code') or False if country_code: countries = request.env['res.country'].search([('code', '=', country_code)]) if countries: country_id = countries[0] # extract url url = request.httprequest.headers.get('Referer') or request.httprequest.base_url # find the match rule for the given country and url rule = request.env['im_livechat.channel.rule'].match_rule(channel_id, url, country_id) if rule: if rule.action == 'hide_button': # don't return the initialization script, since its blocked (in the country) return rule_data = { 'action' : rule.action, 'auto_popup_timer' : rule.auto_popup_timer, 'regex_url' : rule.regex_url, } info['rule'] = json.dumps(rule and rule_data or False) return request.render('im_livechat.loader', info)
def timereport_form(self, user=False, task=False, start=False, **post): cr, uid, context, pool = request.cr, request.uid, request.context, request.registry if not user: return werkzeug.utils.redirect("/treport/%s/form" %uid,302) works=pool.get('project.task.work').search(cr,uid,['&',('task_id','=',task.id),('hours', '=', 0)]) if request.httprequest.method == 'POST': _logger.warning(_("This is timereport post %s ") % (post)) if start == 1: task.start_stop_work(context, post.get('name')) return werkzeug.utils.redirect("/treport/%s" %user.id) if len (works)!=0: pool.get('project.task.work').browse(cr,uid,works[0]).name=post.get('name') if start == 2: stage=request.env.ref('project.project_tt_deployment') #if the statement above is correct return the first element in the list stage. if len(stage) > 0: task.stage_id=stage[0] return werkzeug.utils.redirect("/treport/%s" %user.id) ctx = { 'user': user, 'task': task, 'work': False if len (works)==0 else pool.get('project.task.work').browse(cr,uid,works[0]), } return request.render('mobile_timesheet_timer.project_timereport_form', ctx)
def web_login(self, redirect=None, **kw): openerp.addons.web.controllers.main.ensure_db() if request.httprequest.method == 'GET' and redirect and request.session.uid: return http.redirect_with_hash(redirect) if not request.uid: request.uid = openerp.SUPERUSER_ID values = request.params.copy() if not redirect: redirect = '/web?' + request.httprequest.query_string values['redirect'] = redirect try: values['databases'] = http.db_list() except openerp.exceptions.AccessDenied: values['databases'] = None if request.httprequest.method == 'POST': old_uid = request.uid uid = request.session.authenticate(request.session.db, request.params['login'], request.params['password']) if uid is not False: return http.redirect_with_hash(redirect) request.uid = old_uid values['error'] = "Login failed due to one of the following reasons" values['error2'] = "- Wrong login/password" values['error3'] = "- User already logged in from another system" return request.render('web.login', values)
def loader(self, dbname, channel_id, **kwargs): registry, cr, uid, context = openerp.modules.registry.RegistryManager.get(dbname), request.cr, openerp.SUPERUSER_ID, request.context info = registry.get('im_livechat.channel').get_info_for_chat_src(cr, uid, channel_id) info["dbname"] = dbname info["channel"] = channel_id info["username"] = kwargs.get("username", "Visitor") # find the country from the request country_id = False country_code = request.session.geoip and request.session.geoip.get('country_name', False) or False if country_code: country_ids = registry.get('res.country').search(cr, uid, [('code', '=', country_code)], context=context) if country_ids: country_id = country_ids[0] # extract url url = request.httprequest.headers.get('Referer', False) or request.httprequest.base_url # find the match rule for the given country and url rule = registry.get('im_livechat.channel.rule').match_rule(cr, uid, channel_id, url, country_id, context=context) if rule: if rule.action == 'hide_button': # don't return the initialization script, since its blocked (in the country) return rule_data = { 'action' : rule.action, 'auto_popup_timer' : rule.auto_popup_timer, 'regex_url' : rule.regex_url, } info['rule'] = json.dumps(rule and rule_data or False) return request.render('im_livechat.loader', info)
def my_shift(self, **kw): """ Personal page for managing your shifts """ if self.is_user_irregular(): return request.render( 'beesdoo_website_shift.my_shift_irregular_worker', self.my_shift_irregular_worker(nexturl='/my/shift') ) if self.is_user_regular_without_shift(): return request.render( 'beesdoo_website_shift.my_shift_regular_worker_without_shift', self.my_shift_regular_worker_without_shift() ) if self.is_user_regular(): return request.render( 'beesdoo_website_shift.my_shift_regular_worker', self.my_shift_regular_worker() ) if self.is_user_exempted(): return request.render( 'beesdoo_website_shift.my_shift_exempted_worker', self.my_shift_exempted_worker() ) if self.is_user_worker(): return request.render( 'beesdoo_website_shift.my_shift_new_worker', {} ) return request.render( 'beesdoo_website_shift.my_shift_non_worker', {} )
def portal_my_orders(self, page=1, date_begin=None, date_end=None, keyword=None, **kw): values = self._prepare_portal_layout_values() partner = request.env.user.partner_id SaleOrder = request.env['sale.order'] txs = request.env['payment.transaction'].sudo().search([ ('state', 'in', ['refund', 'done']), ('tx_no', '!=', '') ]) domain = [ '&', ('message_partner_ids', 'child_of', [partner.commercial_partner_id.id]), '|', ('state', 'in', ['sale']), ('id', 'in', [t.sale_order_id.id for t in txs]) ] if keyword: domain.append(('name', 'ilike', keyword)) 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 = request.website.pager(url="/my/orders", url_args={ 'date_begin': date_begin, 'date_end': date_end }, total=order_count, page=page, step=self._items_per_page) # content according to pager and archive selected orders = SaleOrder.search(domain, limit=self._items_per_page, offset=pager['offset']) values.update({ 'date': date_begin, 'orders': orders, 'page_name': 'order', 'pager': pager, 'archive_groups': archive_groups, 'default_url': '/my/orders', }) return request.render("website_portal_sale.portal_my_orders", values)
def post_ask_for_mark_as_offensive(self, forum, post): offensive_reasons = request.env['forum.post.reason'].search([ ('reason_type', '=', 'offensive') ]) values = self._prepare_forum_values(forum=forum) values.update({ 'question': post, 'forum': forum, 'reasons': offensive_reasons, 'offensive': True, }) return request.render("website_forum.close_post", values)
def badges(self, forum, **searches): Badge = request.env['gamification.badge'] badges = Badge.sudo().search([('challenge_ids.category', '=', 'forum') ]) badges = sorted(badges, key=lambda b: b.stat_count_distinct, reverse=True) values = self._prepare_forum_values(forum=forum, searches={'badges': True}) values.update({ 'badges': badges, }) return request.render("website_forum.badge", values)
def gondola_result(self, **post): datas = {} stock_inventory_trans_obj = http.request.env['stock.inventory.trans'] gondola_obj = http.request.env['gondola'] gondola_code = post['gondolacode'] args = [('code', '=', gondola_code.upper())] gondola_ids = gondola_obj.sudo().search(args) if len(gondola_ids) > 0: gondola = gondola_ids[0] request.session['gondolaid'] = gondola.id request.session['gondolacode'] = gondola.code request.session['gondolaname'] = gondola.name gondola.write({'state': 'active'}) args = [('stock_inventory_periode_id', '=', request.session['periodeid']), ('gondola_id', '=', gondola.id)] stock_inventory_trans = stock_inventory_trans_obj.sudo().search( args) if stock_inventory_trans: request.session['transid'] = stock_inventory_trans.id request.session['step'] = stock_inventory_trans.step else: vals = {} vals.update({ 'stock_inventory_periode_id': request.session['periodeid'] }) vals.update({'gondola_id': gondola.id}) vals.update({'user_id': request.session.userid}) vals.update({'state': 'open'}) res = stock_inventory_trans_obj.sudo().create(vals) request.session['transid'] = res.id request.session['step'] = res.step return request.render( 'ranch_project.warehouse_opname_gondola_result', datas) else: datas.update({'msg': 'Gondola not found'}) return request.render( 'ranch_project.warehouse_opname_gondola_find', datas)
def timereport_list(self, user=False, clicked=False, **post): cr, uid, context, pool = request.cr, request.uid, request.context, request.registry if not user: return werkzeug.utils.redirect("/treport/%s/list" %uid,302) ctx = { 'user' : user, 'tasks': request.registry.get('project.task').browse(cr,uid,request.registry.get('project.task').search(cr,uid,['&',("user_id","=",user.id),("stage_id.name","!=","Done")], order='sequence') ,context=context), } return request.render('mobile_timesheet_timer.project_timereport', ctx)
def timereport_list(self, user=False, clicked=False, **post): cr, uid, context, pool = request.cr, request.uid, request.context, request.registry if not user: return werkzeug.utils.redirect("/timereport/%s/list" %uid,302) ctx = { 'user' : user, 'tasks': request.registry.get('project.task').browse(cr,uid,request.registry.get('project.task').search(cr,uid,[("user_id","=",user.id)]) ,context=context), } return request.render('project_timereport.project_timereport', ctx)
def not_accept_delivery_reasons(self, **post): if not post: return utils.redirect('/') delivery_obj = request.env['stock.picking.delivery'] delivery = delivery_obj.sudo().search([('token', '=', post['access_token'])]) if not delivery: return request.render('website.404') if delivery.delivery_contact_id.user_ids: delivery.env.uid = delivery.delivery_contact_id.user_ids[0].id msg = delivery.with_context(mail_post_autofollow=False).message_post( body=post['reason'], subject='Delivery refused') if post.get('attachment'): files = request.httprequest.files.getlist('attachment') attachemnts = [] for file in files: data = file.read() attach = request.env['ir.attachment'].sudo().create({ 'res_model': 'mail.message', 'res_id': msg, 'datas_fname': file.filename, 'datas': data.encode('base64'), 'name': file.filename }) attachemnts.append(attach.id) message = request.env['mail.message'].sudo().browse(msg) message.attachment_ids = attachemnts delivery.sudo().to_not_accepted() return request.render( 'stock_picking_delivery.' 'stock_picking_delivery_sended_layout', { 'delivery': delivery, 'action': 'ko' })
def get_add_gld_second_page(self, template_type, template, title, text, emergency, userid): user = request.env['res.users'].sudo().search([('id', '=', int(userid)) ]) return request.render( 'ToproERP_WeChat_GLD.get_add_gld_second_page', { "template_type": template_type, "template": template, "title": title, "text": text, "emergency": emergency, "user": user })
def get_profile(self, **kw): env, uid = request.env, request.uid if uid != env.ref('base.public_user').id: user = env['res.users'].sudo().browse(uid) values = { 'user': user, 'DATE_FORMAT': DATE_FORMAT, 'TIME_FORMAT': TIME_FORMAT, 'DEFAULT_SERVER_DATETIME_FORMAT': DEFAULT_SERVER_DATETIME_FORMAT, } return request.render('baseball.profile', values)
def forum_post(self, forum, post_type=None, **post): user = request.env.user if post_type not in ['question', 'link', 'discussion']: # fixme: make dynamic return werkzeug.utils.redirect('/forum/%s' % slug(forum)) if not user.email or not tools.single_email_re.match(user.email): return werkzeug.utils.redirect( "/forum/%s/user/%s/edit?email_required=1" % (slug(forum), request.session.uid)) values = self._prepare_forum_values(forum=forum, searches={}, header={'ask_hide': True}) return request.render("website_forum.new_%s" % post_type, values)
def sitemap_xml_index(self): pages = list(request.website.enumerate_pages()) if len(pages)<=LOC_PER_SITEMAP: return self.__sitemap_xml(pages, 0) # Sitemaps must be split in several smaller files with a sitemap index values = { 'pages': range(len(pages)/LOC_PER_SITEMAP+1), 'url_root': request.httprequest.url_root } headers = { 'Content-Type': 'application/xml;charset=utf-8', } return request.render('website.sitemap_index_xml', values, headers=headers)
def web_client(self, s_action=None, **kw): ensure_db() if request.session.uid: if kw.get('redirect'): return werkzeug.utils.redirect(kw.get('redirect'), 303) if not request.uid: request.uid = request.session.uid menu_data = request.registry['ir.ui.menu'].load_menus(request.cr, request.uid, context=request.context) return request.render('odoosoft_mobile.client', qcontext={'menu_data': menu_data}) # return request.render('web.webclient_bootstrap', qcontext={'menu_data': menu_data}) else: return login_redirect()
def view_employee(self, employee_id=None, token=None, **post): if self.check_token(token, request): employee = request.env["hr.employee"].sudo().browse(employee_id) context = { "meetings": request.env["project.scrum.meeting"].sudo().search( [("user_id_meeting", "=", employee.user_id.id)], order="date_meeting desc"), "projects": request.env["project.project"].sudo().search([ ("members.id", "=", employee.user_id.id) ]), "employee": employee, "token": token } return request.render("lia2_site.employee_template", context) else: return request.render("lia2_site.unauthorized_template", None)
def posted_tests(self, **kw): """ Allow students to access tests through the Odoo web """ academy_tests_domain = [('id', '>=', 1)] academy_tests_obj = request.env['academy.tests.test'] academy_tests_set = academy_tests_obj.search(academy_tests_domain) result = request.render('academy_tests_web.academy_post_tests', { 'tests': academy_tests_set, }) return result
def stages_apply(self, stage): print '..........................', stage error = {} default = {} if 'iway_test_web_error' in request.session: error = request.session.pop('iway_test_web_error') default = request.session.pop('iway_test_web_default') return request.render("iway_test_web.apply", { 'stage': stage, 'error': error, 'default': default, })
def add_rating(self, token, rate, **kwargs): Rating = request.env['rating.rating'] rating = Rating.search([('access_token', '=', token)]) if rating: is_rated = bool(rating.rating != -1) if not is_rated: request.env['rating.rating'].sudo().apply_rating(rate, token=token) # redirect to the form view if logged person if request.session.uid and not is_rated: record = request.env[rating.res_model].browse(rating.res_id) return werkzeug.utils.redirect('/web#model=%s&id=%s&view_type=form' % (record._name, record.id)) return request.render('rating.rating_external_page_view', {'rating': rate, 'is_rated': is_rated}) return request.not_found()
def web_login(self, redirect=None, **kw): """redefind function to make username in login case-insensitive """ ensure_db() if request.httprequest.method == 'GET' and redirect and request.session.uid: return http.redirect_with_hash(redirect) if not request.uid: request.uid = openerp.SUPERUSER_ID values = request.params.copy() if not redirect: redirect = '/web?' + request.httprequest.query_string values['redirect'] = redirect try: values['databases'] = http.db_list() except openerp.exceptions.AccessDenied: values['databases'] = None if request.httprequest.method == 'POST': old_uid = request.uid username_lcase = (request.params['login']).lower() login_list = {} params_login = '' users = request.registry['res.users'].search( request.cr, openerp.SUPERUSER_ID, [('id', '>', 0)]) for user in request.registry['res.users'].browse( request.cr, openerp.SUPERUSER_ID, users): login_list[user.login.lower()] = user.login for user2 in login_list: if request.params['login'].lower() == user2: params_login = login_list[user2] uid = request.session.authenticate(request.session.db, params_login, request.params['password']) if uid is not False: return http.redirect_with_hash(redirect) request.uid = old_uid values['error'] = _("Wrong login/password") if request.env.ref('web.login', False): return request.render('web.login', values) else: # probably not an odoo compatible database error = 'Unable to login on database %s' % request.session.db return werkzeug.utils.redirect( '/web/database/selector?error=%s' % error, 303)
def add(self, option_id, order_id, token, **post): vals = {} order = request.registry.get('sale.order').browse( request.cr, SUPERUSER_ID, order_id) if token != order.access_token: return request.render('website.404') if order.state not in ['draft', 'sent']: return request.render( 'website.http_error', { 'status_code': 'Forbidden', 'status_message': _('You cannot add options to a confirmed order.') }) option_obj = request.registry.get('sale.order.option') option = option_obj.browse(request.cr, SUPERUSER_ID, option_id) vals = { 'price_unit': option.price_unit, 'website_description': option.website_description, 'name': option.name, 'order_id': order.id, 'product_id': option.product_id.id, 'layout_category_id': option.layout_category_id.id, 'product_uom_qty': option.quantity, 'product_uom': option.uom_id.id, 'discount': option.discount, } line = request.registry.get('sale.order.line').create( request.cr, SUPERUSER_ID, vals, context=request.context) request.registry.get('sale.order.line')._compute_tax_id( request.cr, SUPERUSER_ID, [line], context=request.context) option_obj.write(request.cr, SUPERUSER_ID, [option.id], {'line_id': line}, context=request.context) return werkzeug.utils.redirect("/quote/%s/%s#pricing" % (order.id, token))
def program(self, redirect=None, **post): programs = request.env['school.program'].sudo().search( [('state', '=', 'published')], order="domain_id, cycle_id, name ASC") program_list = [] for program in programs: program_list.append({ 'program': program, 'slug_id': slug(program), }) values = { 'program_list': program_list, } return request.render("website_school_management.program", values)
def web_client(self, s_action=None, **kw): openerp.addons.web.controllers.main.ensure_db() if request.session.uid: if kw.get('redirect'): return werkzeug.utils.redirect(kw.get('redirect'), 303) if not request.uid: request.uid = request.session.uid menu_data = request.registry['ir.ui.menu'].load_menus(request.cr, request.uid, context=request.context) abc = get_my_conf() return request.render('web.webclient_bootstrap', qcontext={'menu_data': menu_data, 'title_conf': abc.get('title')}) else: return openerp.addons.web.controllers.main.login_redirect()
def page_ask_for_trial(self, **kwargs): values = {} products = request.registry['product.product'].search_read(request.cr, SUPERUSER_ID,[],['name']) values.update(products=products) for field in ['description', 'partner_name', 'phone', 'contact_name', 'email_from', 'name']: if kwargs.get(field): values[field] = kwargs.pop(field) values.update(kwargs=kwargs.items()) return request.render('theme_myfactory.ask_for_trial', values)
def support_ticket_view_list(self, **kw): """Displays a list of support tickets owned by the logged in user""" values = {} for field_name, field_value in kw.items(): values[field_name] = field_value #Determine which tickets the logged in user can see ticket_access = [] #Can see own tickets ticket_access.append(http.request.env.user.partner_id.id) #Can see tickets of any contacts under the logged in users additional access field (TODO remove this as departments is the evolved version of this feature) for extra_permission in http.request.env.user.partner_id.stp_ids: ticket_access.append(extra_permission.id) #If the logged in user is a department manager then add all the contacts in the department to the access list for dep in request.env['website.support.department.contact'].sudo( ).search([('user_id', '=', http.request.env.user.id)]): for contact in dep.wsd_id.partner_ids: ticket_access.append(contact.id) search_t = [('partner_id', 'in', ticket_access), ('partner_id', '!=', False)] if 'state' in values: search_t.append(('state', '=', int(values['state']))) support_tickets = request.env['website.support.ticket'].sudo().search( search_t) no_approval_required = request.env['ir.model.data'].get_object( 'website_support', 'no_approval_required') change_requests = request.env['website.support.ticket'].sudo().search( [('partner_id', 'in', ticket_access), ('partner_id', '!=', False), ('approval_id', '!=', no_approval_required.id)], order="planned_time desc") ticket_states = request.env['website.support.ticket.states'].sudo( ).search([]) return request.render( 'website_support.support_ticket_view_list', { 'support_tickets': support_tickets, 'ticket_count': len(support_tickets), 'change_requests': change_requests, 'request_count': len(change_requests), 'ticket_states': ticket_states })
def team(self, team_id, **post): env, uid = request.env, request.uid team = env['baseball.teams'].sudo().browse(team_id) user = env['res.users'].sudo().browse( uid) if uid != env.ref('base.public_user').id else False values = { 'team': team, 'user': user, 'DATE_FORMAT': DATE_FORMAT, 'TIME_FORMAT': TIME_FORMAT, 'DEFAULT_SERVER_DATETIME_FORMAT': DEFAULT_SERVER_DATETIME_FORMAT, } return request.render('baseball.team_page', values)
def upcoming_games(self, **kw): env, uid = request.env, request.uid games = env['baseball.game'].sudo()._get_upcoming_games() user = env['res.users'].sudo().browse( uid) if uid != env.ref('base.public_user').id else False values = { 'games': games, 'user': user, 'DATE_FORMAT': DATE_FORMAT, 'TIME_FORMAT': TIME_FORMAT, 'DEFAULT_SERVER_DATETIME_FORMAT': DEFAULT_SERVER_DATETIME_FORMAT, } return request.render('baseball.upcoming_schedule', values)
def post_edit(self, forum, post, **kwargs): tags = [dict(id=tag.id, name=tag.name) for tag in post.tag_ids] tags = json.dumps(tags) values = self._prepare_forum_values(forum=forum) values.update({ 'tags': tags, 'post': post, 'is_answer': bool(post.parent_id), 'searches': kwargs, 'post_name': post.content_link, 'content': post.name, }) template = "website_forum.new_link" if post.post_type == 'link' and not post.parent_id else "website_forum.edit_post" return request.render(template, values)
def web_client(self, s_action=None, **kw): openerp.addons.web.controllers.main.ensure_db() if not request.session.uid: return werkzeug.utils.redirect('/web/login', 303) if kw.get('redirect'): return werkzeug.utils.redirect(kw.get('redirect'), 303) request.uid = request.session.uid return request.render( 'web.webclient_bootstrap', qcontext={ 'db_info': json.dumps(openerp.addons.web.controllers.main.db_info()) })
def program_details(self, program_id, redirect=None, **post): _, program_id = unslug(program_id) program = request.env['school.program'].sudo().search([('id', '=', program_id)]) if program: values = { 'program': program, 'slug_id': program_id, } return request.render("website_school_management.program_details", values) else: raise werkzeug.exceptions.HTTPException( description='Unkown program.')
def index(self, **kw): request.uid = request.session.uid user = request.registry.get('res.users').browse(request.cr, request.uid,request.uid) #hr_root menu_xml_id = request.env.ref('smart_hr.hr_root') return request.render('web.login', qcontext={'db_info': json.dumps(openerp.addons.web.controllers.main.db_info()), 'user': user, 'hr_root': menu_xml_id.id } )
def realestatetops(self, top, **post): uid = request.uid user = request.env['res.users'].with_context(active_test=False).search([('id', '=', uid)]) company = user.company_id values = { 'tops' : top, 'companies' : company } return request.render("website_real_estate.tops_template", values)