Example #1
0
 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()
Example #2
0
    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))
Example #3
0
    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
Example #4
0
    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})
Example #6
0
	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)
Example #7
0
 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)
Example #8
0
 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')
Example #9
0
	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)
Example #10
0
	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)
Example #11
0
 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()
Example #12
0
 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
Example #13
0
 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
     })
Example #14
0
	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)
Example #15
0
 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)
Example #16
0
    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}
        )
Example #17
0
 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)
Example #18
0
    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)
Example #19
0
    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)
Example #20
0
    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)
Example #21
0
 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})
Example #23
0
    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
            }
        )
Example #24
0
    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)
Example #25
0
    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)   
Example #27
0
 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)
Example #29
0
	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)
Example #30
0
 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)
Example #31
0
    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',
            {}
        )
Example #32
0
    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)
Example #33
0
File: main.py Project: nuxly/odoo
    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)
Example #34
0
File: main.py Project: nuxly/odoo
 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)
Example #35
0
 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)
Example #36
0
    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)
Example #37
0
    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)
Example #38
0
 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'
         })
Example #39
0
 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
         })
Example #40
0
    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)
Example #41
0
File: main.py Project: nuxly/odoo
 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)
Example #42
0
 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)
Example #43
0
    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()
Example #44
0
    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
Example #46
0
    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,
        })
Example #47
0
 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()
Example #48
0
    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)
Example #49
0
File: main.py Project: nuxly/odoo
    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))
Example #50
0
 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)
Example #51
0
    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()
Example #52
0
    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)
Example #53
0
    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
            })
Example #54
0
    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)
Example #55
0
    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)
Example #56
0
File: main.py Project: nuxly/odoo
 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)
Example #57
0
    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())
            })
Example #58
0
 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.')
Example #59
0
 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
                                      }
                            
                            )
Example #60
0
 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)