def pre_init_check(cr): from openerp.service import common from openerp.exceptions import Warning version_info = common.exp_version() server_serie =version_info.get('server_serie') if server_serie!='10.0':raise Warning('Module support Odoo series 10.0 found {}.'.format(server_serie)) return True
def odoo_version_check(cr): from openerp.exceptions import Warning from openerp.service import common exp_version = common.exp_version() if exp_version.get('server_serie') != '10.0': error_message = """ At Present this extension developed for Odoo version 10.0, Kindly not try to install in {version}""".format( version=exp_version.get('server_serie')) raise Warning(error_message) return True
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 odoo_version_check(cr): from openerp.exceptions import Warning from openerp.service import common exp_version = common.exp_version() return True
def caldav_icalendar(self, partner=False, **post): #~ environ["REQUEST_METHOD"] _logger.error('REQUEST_METHOD %s PATH_INFO %s ' % (request.httprequest.environ['REQUEST_METHOD'], request.httprequest.environ['PATH_INFO'])) _logger.error('httprequest.environ %s ' % (request.httprequest.environ)) path = request.httprequest.environ.get("PATH_INFO", '') # Get function corresponding to method function = getattr( self, "do_%s" % request.httprequest.environ["REQUEST_METHOD"].upper()) # Ask authentication backend to check rights try: login, password = request.httprequest.environ.get( 'HTTP_AUTHORIZATION', '').lstrip("Basic").strip().decode('base64').split(":") _logger.error('user %s password %s ' % (login, password)) except Exception as e: _logger.error('HTTP_AUTH error %s ' % (e)) return werkzeug.wrappers.Response( status=401, headers=[ ('WWW-Authenticate', 'Basic realm="Kalender"'), ('Server', 'Odoo %s ' % (common.exp_version().get('server_version'))), ]) user = request.env['res.users'].sudo().search([('login', '=', login)], limit=1) if user: try: user.check_credentials(password) except: _logger.error('Check Credentials %s ' % (login)) return werkzeug.wrappers.Response( status=403, headers=[ ('WWW-Authenticate', 'Basic realm="Kalender"'), ('Server', 'Odoo %s ' % (common.exp_version().get('server_version'))), ]) _logger.error('User OK %s ' % (user)) content = '' status, headers, content = getattr( self, "do_%s" % request.httprequest.environ["REQUEST_METHOD"].upper())(post, user) headers.append( ('Server', 'Odoo %s ' % (common.exp_version().get('server_version')))) #~ raise Warning(status,headers,content) return werkzeug.wrappers.Response( status=status, headers=headers, ) else: raise Warning('Pelle')