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