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')
