def ab_css(self, dbuuid=None): content = '' message = self._get_message(dbuuid) if message: content = ''' .openerp .announcement_bar{ display:block; } .announcement_bar>span.message:before{ content: %s } .announcement_bar>.url>a:before{ content: 'Contact Us' } .announcement_bar .close { height: 15px; width: 15px; background : url(/web/static/src/img/icons/gtk-close.png) no-repeat; background-size : 15px 15px; opacity: 1; } .announcement_bar { color: #ffffff; height: 30px; vertical-align: middle !important; text-align: center !important; width: 100%; border: 0 !important; margin: 0 !important; padding: 8px !important; background-color: #8785C0; background-image: -webkit-linear-gradient(135deg, rgba(255, 255, 255, 0.05) 25%, rgba(255, 255, 255, 0) 25%, rgba(255, 255, 255, 0) 50%, rgba(255, 255, 255, 0.05) 50%, rgba(255, 255, 255, 0.05) 75%, rgba(255, 255, 255, 0) 75%, rgba(255, 255, 255, 0) 100% ); background-size: 40px 40px; -webkit-transition: all 350ms ease; text-shadow: 0px 0px 2px rgba(0,0,0,0.2); box-shadow: 0px 2px 10px rgba(0,0,0,0.38) inset; display: none; } .announcement_bar a { font-weight: bold; color: #d3ffb0 !important; text-decoration: none !important; border-radius: 3px; padding: 5px 8px; cursor: pointer; -webkit-transition: all 350ms ease; } ''' content = content.replace('%s', message) return http.Response(content, mimetype='text/css')
def memcached_stats(self, **post): self.memcached_check_group() slab_limit = {k.split(':')[1]:v for k,v in memcached.MEMCACHED_CLIENT().stats('items').items() if k.split(':')[2] == 'number' } key_lists = [memcached.MEMCACHED_CLIENT().stats('cachedump',slab,str(limit)) for slab,limit in slab_limit.items()] return http.Response( '<h1>Memcached Stat</h1><table>%s</table>' % ''.join(['<tr><td>%s</td><td>%s</td></tr>' % (k,v) for k,v in memcached.MEMCACHED_CLIENT().stats().items()]) + '<h2>Items</h2><table>%s</table>' % ''.join(['<tr><td>%s</td><td>%s</td></tr>' % (k,v) for k,v in memcached.MEMCACHED_CLIENT().stats('items').items()]) + '<h2>Slab Limit</h2>%s' % slab_limit + '<h2>Key Lists</h2>%s' % key_lists + '<h2>Keys</h2>%s' % [key for sublist in key_lists for key in sublist.keys()])
def ab_css(self, dbuuid=None): content = ''' .openerp .announcement_bar{ display:block; } .announcement_bar>.url>a:before{ content: 'Contact Us' } .announcement_bar { color: #ffffff; height: 30px; vertical-align: middle !important; text-align: center !important; width: 100%; border: 0 !important; margin: 0 !important; padding: 0 !important; background-color: #8785C0; background-image: -webkit-linear-gradient(135deg, rgba(255, 255, 255, 0.05) 25%, rgba(255, 255, 255, 0) 25%, rgba(255, 255, 255, 0) 50%, rgba(255, 255, 255, 0.05) 50%, rgba(255, 255, 255, 0.05) 75%, rgba(255, 255, 255, 0) 75%, rgba(255, 255, 255, 0) 100% ); background-size: 40px 40px; -webkit-transition: all 350ms ease; text-shadow: 0px 0px 2px rgba(0,0,0,0.2); box-shadow: 0px 2px 10px rgba(0,0,0,0.38) inset; display: none; } .announcement_bar a { font-weight: bold; color: #d3ffb0 !important; text-decoration: none !important; border-radius: 3px; padding: 5px 8px; cursor: pointer; -webkit-transition: all 350ms ease; } ''' return http.Response(content, mimetype='text/css')
def response_wrap(*args, **kw): #~ _logger.warn('\n\npath: %s\n' % request.httprequest.path) if routing.get('key'): # Function that returns a raw string for key making # Format {path}{session}{etc} key_raw = routing['key'](kw).format(path=request.httprequest.path, session='%s' % {k:v for k,v in request.session.items() if len(k)<40}, device_type='%s' % request.session.get('device_type','md'), # xs sm md lg context='%s' % {k:v for k,v in request.env.context.items() if not k == 'uid'}, context_uid='%s' % {k:v for k,v in request.env.context.items()}, uid=request.env.context.get('uid'), logged_in='1' if request.env.context.get('uid') > 0 else '0', db=request.env.cr.dbname, lang=request.env.context.get('lang'), post='%s' % kw, xmlid='%s' % kw.get('xmlid'), version='%s' % kw.get('version'), publisher='1' if request.env.ref('base.group_website_publisher') in request.env.user.groups_id else '0', designer='1' if request.env.ref('base.group_website_designer') in request.env.user.groups_id else '0', ).encode('latin-1') #~ raise Warning(request.env['res.users'].browse(request.uid).group_ids) key = str(MEMCACHED_HASH(key_raw)) else: key_raw = ('%s,%s,%s' % (request.env.cr.dbname,request.httprequest.path,request.env.context)).encode('latin-1') # Default key key = str(MEMCACHED_HASH(key_raw)) ############### Key is ready if 'cache_invalidate' in kw.keys(): kw.pop('cache_invalidate',None) mc_delete(key) page_dict = None error = None try: page_dict = mc_load(key) except MemcacheClientError as e: error = "MemcacheClientError %s " % e _logger.warn(error) except MemcacheUnknownCommandError as e: error = "MemcacheUnknownCommandError %s " % e _logger.warn(error) except MemcacheIllegalInputError as e: error = "MemcacheIllegalInputError %s " % e _logger.warn(error) except MemcacheServerError as e: error = "MemcacheServerError %s " % e _logger.warn(error) except MemcacheUnknownError as e: error = clean_text(str(e)) _logger.warn("MemcacheUnknownError %s key: %s path: %s" % (eror, key, request.httprequest.path)) return werkzeug.wrappers.Response(status=500,headers=[ ('X-CacheKey',key), ('X-CacheError','MemcacheUnknownError %s' %error), ('X-CacheKeyRaw',key_raw), ('Server','Odoo %s Memcached %s' % (common.exp_version().get('server_version'), MEMCACHED_VERSION)), ]) except MemcacheUnexpectedCloseError as e: error = "MemcacheUnexpectedCloseError %s " % e _logger.warn(error) except Exception as e: err = sys.exc_info() # ~ error = "Memcached Error %s key: %s path: %s %s" % (e,key,request.httprequest.path, ''.join(traceback.format_exception(err[0], err[1], err[2]))) error = clean_text(''.join(traceback.format_exception(err[0], err[1], err[2]))) _logger.warn("Memcached Error %s key: %s path: %s" % (error, key, request.httprequest.path)) error = clean_text(str(e)) return werkzeug.wrappers.Response(status=500,headers=[ ('X-CacheKey',key), ('X-CacheError','Memcached Error %s' % error), ('X-CacheKeyRaw',key_raw), ('Server','Odoo %s Memcached %s' % (common.exp_version().get('server_version'), MEMCACHED_VERSION)), ]) if page_dict and not page_dict.get('db') == request.env.cr.dbname: _logger.warn('Database violation key=%s stored for=%s env db=%s ' % (key,page_dict.get('db'),request.env.cr.dbname)) page_dict = None # Blacklist if page_dict and any([p if p in request.httprequest.path else '' for p in kw.get('blacklist','').split(',')]): page_dict = None if 'cache_viewkey' in kw.keys(): if page_dict: res = mc_meta(key) view_meta = '<h2>Metadata</h2><table>%s</table>' % ''.join(['<tr><td>%s</td><td>%s</td></tr>' % (k,v) for k,v in res['page_dict'].items() if not k == 'page']) view_meta += 'Page Len : %.2f Kb<br>' % res['size'] #~ view_meta += 'Chunks : %s<br>' % ', '.join([len(c) for c in res['chunks']]) #~ view_meta += 'Chunks : %s<br>' % res['chunks'] return http.Response('<h1>Key <a href="/mcpage/%s">%s</a></h1>%s' % (key,key,view_meta)) else: if error: error = '<h1>Error</h1><h2>%s</h2>' % error return http.Response('%s<h1>Key is missing %s</h1>' % (error if error else '',key)) if routing.get('add_key') and not 'cache_key' in kw.keys(): #~ raise Warning(args,kw,request.httprequest.args.copy()) args = request.httprequest.args.copy() args['cache_key'] = key return werkzeug.utils.redirect('{}?{}'.format(request.httprequest.path, url_encode(args)), 302) max_age = routing.get('max_age',600) # 10 minutes cache_age = routing.get('cache_age',24 * 60 * 60) # One day s_maxage = routing.get('s_maxage',max_age) page = None if not page_dict: page_dict = {} controller_start = timer() response = f(*args, **kw) # calls original controller render_start = timer() if routing.get('content_type'): response.headers['Content-Type'] = routing.get('content_type') #~ if isinstance(response.headers,list) and isinstance(response.headers[0],tuple): #~ _logger.error('response is list and tuple') #~ header_dict = {h[0]: h[1] for h in response.headers} #~ header_dict['Content-Type'] = routing.get('content_type') #~ response.headers = [(h[0],h[1]) for h in header_dict.items()] if response.template: #~ _logger.error('template %s values %s response %s' % (response.template,response.qcontext,response.response)) page = response.render() else: page = ''.join(response.response) page_dict = { 'max-age': max_age, 'cache-age':cache_age, 'private': routing.get('private',False), 'key_raw': key_raw, 'render_time': '%.3f sec' % (timer()-render_start), 'controller_time': '%.3f sec' % (render_start-controller_start), 'path': request.httprequest.path, 'db': request.env.cr.dbname, 'page': base64.b64encode(page), 'date': http_date(), 'module': f.__module__, 'status_code': response.status_code, 'flush_type': routing['flush_type'](kw).lower().encode('ascii', 'replace').replace(' ', '-') if routing.get('flush_type', None) else "", 'headers': response.headers, } if routing.get('no_cache'): page_dict['ETag'] = '%s' % MEMCACHED_HASH(page) # ~ _logger.warn('\n\npath: %s\nstatus_code: %s\nETag: %s\n' % (page_dict.get('path'), page_dict.get('status_code'), page_dict.get('ETag'))) mc_save(key, page_dict,cache_age) if routing.get('flush_type'): add_flush_type(request.cr.dbname, routing['flush_type'](kw)) #~ raise Warning(f.__module__,f.__name__,route()) else: request_dict = {h[0]: h[1] for h in request.httprequest.headers} #~ _logger.warn('Page Exists If-None-Match %s Etag %s' %(request_dict.get('If-None-Match'), page_dict.get('ETag'))) if request_dict.get('If-None-Match') and (request_dict.get('If-None-Match') == page_dict.get('ETag')): header = [ ('X-CacheETag', page_dict.get('ETag')), ('X-CacheKey',key), ('X-Cache','newly rendered' if page else 'from cache'), ('X-CacheKeyRaw',key_raw), ('X-CacheController',page_dict.get('controller_time')), ('X-CacheRender',page_dict.get('render_time')), ('X-CacheCacheAge',cache_age), ('Server','Odoo %s Memcached %s' % (common.exp_version().get('server_version'), MEMCACHED_VERSION)), ] header += [(k,v) for k,v in page_dict.get('headers',[(None,None)])] _logger.warn('returns 304 headers %s' % header) if page_dict.get('status_code') in [301, 302, 307, 308]: return werkzeug.wrappers.Response(status=page_dict['status_code'],headers=header) return werkzeug.wrappers.Response(status=304,headers=header) response = http.Response(base64.b64decode(page_dict.get('page'))) # always create a new response (drop response from controller) # https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Cache-Control # https://developers.google.com/web/fundamentals/performance/optimizing-content-efficiency/http-caching # https://jakearchibald.com/2016/caching-best-practices/ #~ if page_dict.get('headers') and isinstance(page_dict['headers'],dict): #~ _logger.error('respnse headers dict') #~ for k,v in page_dict['headers'].items(): #~ response.headers.add(k,v) #response.headers[k] = v #~ if page_dict.get('headers') and isinstance(page_dict['headers'],list): #~ _logger.error('respnse headers list') #~ response.headers = {h[0]: h[1] for h in response.headers} if page_dict.get('headers'): for k,v in page_dict['headers'].items(): #~ response.headers.add(k,v) response.headers[k] = v response.headers['Cache-Control'] ='max-age=%s,s-maxage=%s, %s' % (max_age, s_maxage, ','.join([keyword for keyword in ['no-store', 'immutable', 'no-transform', 'no-cache', 'must-revalidate', 'proxy-revalidate'] if routing.get(keyword.replace('-', '_'))] + [routing.get('private', 'public')])) # private: must not be stored by a shared cache. if page_dict.get('ETag'): response.headers['ETag'] = page_dict.get('ETag') response.headers['X-CacheKey'] = key response.headers['X-Cache'] = 'newly rendered' if page else 'from cache' response.headers['X-CacheKeyRaw'] = key_raw response.headers['X-CacheController'] = page_dict.get('controller_time') response.headers['X-CacheRender'] = page_dict.get('render_time') response.headers['X-CacheCacheAge'] = cache_age response.headers['X-CacheBlacklist'] = kw.get('blacklist','') response.headers['Date'] = page_dict.get('date',http_date()) response.headers['Server'] = 'Odoo %s Memcached %s' % (common.exp_version().get('server_version'), MEMCACHED_VERSION) response.status_code = page_dict.get('status_code', 200) return response
def memcached_page_delete(self, key='',**post): self.memcached_check_group() memcached.mc_delete(key) if post.get('url'): return werkzeug.utils.redirect(post.get('url'), 302) return http.Response('<h1>Key is deleted %s</h1>' % (key))
def __ok(self, ): return http.Response( 'OK', 200, )
def __throw_error(self, exception): return http.Response( str(exception), exception.status, exception.headers, )
def wrap(*args, **kw): try: return f(*args, **kw) except Exception, e: _logger.exception(str(e)) return http.Response(response=str(e), status=500)
def convert_base64_attachment(self, **kwargs): try: # response_obj = self.do_get_response_callback() # return http.Response(json.dumps(response_obj)) #ids = '19392,24348,24389,24364,25206,14293,24344,19590,24892,24372' params = http.request.jsonrequest cr = http.request.cr env = api.Environment(cr, 1, {}) obj_partner_rank_history = env['partner.rank.history'] obj_ir_attachment = env['ir.attachment'] obj_hr_applicant = env['hr.applicant'] # partner_rank_histories = obj_partner_rank_history.search(['|', ('form_img_attachment_id', '=', False), # ('signature_img_attachment_id', '=', False)], limit=100) # query = """ SELECT id FROM partner_rank_history WHERE form_img_attachment_id is null or signature_img_attachment_id is null LIMIT 1000 """ # cr.execute(query, ()) # res = cr.dictfetchall() # if res: # for r in res: # partner_rank_his = obj_partner_rank_history.search([('id', '=', r['id'])]) # if partner_rank_his.form_img and not partner_rank_his.form_img_attachment_id: # attachment_id = obj_ir_attachment.create({'name': 'demo', 'datas': partner_rank_his.form_img}) # print("ngadv: " +str(attachment_id)) # partner_rank_his.write({ # 'form_img_attachment_id': attachment_id.id, # }) # cr.commit() # if partner_rank_his.signature_img and not partner_rank_his.signature_img_attachment_id: # signature_attachment_id = obj_ir_attachment.create({'name': 'demo', 'datas': partner_rank_his.signature_img}) # print("ngadv1: " +str(signature_attachment_id)) # partner_rank_his.write({ # 'signature_img_attachment_id': signature_attachment_id.id, # }) # cr.commit() # applicants = obj_hr_applicant.search(['id', '=', 0]) query_applicant = """ SELECT id FROM hr_applicant WHERE avatar_attachment_id is null LIMIT 1000 """ cr.execute(query_applicant, ()) res_applicant = cr.dictfetchall() for r in res_applicant: applicant = obj_hr_applicant.search([('id', '=', r['id'])]) if applicant.avatar and not applicant.avatar_attachment_id: attachment_id = obj_ir_attachment.create({ 'name': 'demo', 'datas': applicant.avatar }) print("ngadv: " + str(attachment_id)) applicant.write({ 'avatar_attachment_id': attachment_id.id, }) cr.commit() print('context:' + str(http.request.context)) return {'name': 'ngadv'} except xmlrpclib.Fault as e: response_object = { 'code': CODE_SYSTEM_ERROR, 'message': e.faultString } return http.Response(json.dumps(response_object))
os.unlink(path) except OSError: pass def get_response(self, httprequest, result, explicit_session): if isinstance(result, http.Response) and result.is_qweb: try: result.flatten() except(Exception), e: if http.request.db: result = http.request.registry['ir.http']._handle_exception(e) else: raise if isinstance(result, basestring): response = http.Response(result, mimetype='text/html') else: response = result if httprequest.session.should_save: self.session_store.save(httprequest.session) # We must not set the cookie if the session id was specified using a http header or a GET parameter. # There are two reasons to this: # - When using one of those two means we consider that we are overriding the cookie, which means creating a new # session on top of an already existing session and we don't want to create a mess with the 'normal' session # (the one using the cookie). That is a special feature of the Session Javascript class. # - It could allow session fixation attacks. if not explicit_session and hasattr(response, 'set_cookie'): max_age = 2 * 60 * 60 if config.get('session_timeout_idle'): max_age = int(config.get('session_timeout_idle'))
def get_document(self, id, token): return http.Response(template='website_sign._doc_sign', qcontext=self.get_document_qweb_context( id, token)).render()