def load(cls, **keys):
'''load the object'''
cls._init_meta()
for _ in keys.values():
pass #检验参数
query_str = ','.join(['%s=%s' % (k, v) for k, v in keys.items()])
info('start load object with %s[table:%s]' % (query_str, cls._table))
#load from cache
obj = cls.load_from_cache(keys)
if obj:
return obj
condition = ' and '.join(["%s=%%s" % k for k in keys.keys()])
param = [keys[k] for k in keys.keys()]
sql = 'select * from %s where %s' % (cls._table, condition)
cursor = connection.cursor()
try:
data = cursor.fetchone(sql, param)
if data:
obj = cls._build_object(data)
cache_key = cls.build_cache_key(obj)
if cache_key:
cls._cache.set(cache_key, obj, 1800)
info('success load object[%s, %s]' % (cls._table, query_str))
return obj
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('load failure[table:%s]' % cls._table)
return None
def load(cls, **keys):
'''load the object'''
cls._init_meta()
for _ in keys.values():
pass #检验参数
query_str = ','.join(['%s=%s' % (k, v) for k, v in keys.items()])
info('start load object with %s[table:%s]' % (query_str, cls._table))
#load from cache
obj = cls.load_from_cache(keys)
if obj:
return obj
condition = ' and '.join(["%s=%%s" % k for k in keys.keys()])
param = [keys[k] for k in keys.keys()]
sql = 'select * from %s where %s' % (cls._table, condition)
cursor = connection.cursor()
try:
data = cursor.fetchone(sql, param)
if data:
obj = cls._build_object(data)
cache_key = cls.build_cache_key(obj)
if cache_key:
cls._cache.set(cache_key, obj, 1800)
info('success load object[%s, %s]' % (cls._table, query_str))
return obj
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('load failure[table:%s]' % cls._table)
return None
def persist(self):
'''persist object self'''
self._init_meta()
info('start to save object....[table:%s]' % self._table)
cache_key = self.build_cache_key(self)
if cache_key:
self._cache.delete(cache_key)
data = {}
update_skip_columns = ['id', 'created_time', 'updated_time']
meta = Persistable._meta_cache[self._table]
columns = meta.columns
for column in columns:
field_name = column.field
if hasattr(self, field_name):
data[field_name] = getattr(self, field_name)
elif field_name == 'created_time':
data['created_time'] = ReserveLiteral('now()')
cursor = connection.cursor()
try:
cursor.insert(data, self._table, True, update_skip_columns)
if not hasattr(self, 'id'):
data = cursor.fetchone('select last_insert_id() as id')
if data:
self.id = int(data['id'])
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('finish save object....[table:%s]' % self._table)
def inserts(cls, objects):
'''insert objects'''
cls._init_meta()
info('start to save objects....[table:%s]' % cls._table)
update_skip_columns = ['id', 'created_time', 'updated_time']
meta = Persistable._meta_cache[cls._table]
columns = meta.columns
datas = []
for obj in objects:
data = {}
cache_key = obj.build_cache_key(obj)
if cache_key:
cls._cache.delete(cache_key)
for column in columns:
field_name = column.field
if field_name == 'updated_time':
continue
elif hasattr(obj, field_name):
data[field_name] = getattr(object, field_name)
elif field_name == 'created_time':
data['created_time'] = ReserveLiteral('now()')
datas.append(data)
cursor = connection.cursor()
try:
cursor.insert(datas, cls._table, True, update_skip_columns)
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('finish save objects....[table:%s]' % cls._table)
def persist(self):
'''persist object self'''
self._init_meta()
info('start to save object....[table:%s]' % self._table)
cache_key = self.build_cache_key(self)
if cache_key:
self._cache.delete(cache_key)
data = {}
update_skip_columns = ['id', 'created_time', 'updated_time']
meta = Persistable._meta_cache[self._table]
columns = meta.columns
for column in columns:
field_name = column.field
if hasattr(self, field_name):
data[field_name] = getattr(self, field_name)
elif field_name == 'created_time':
data['created_time'] = ReserveLiteral('now()')
cursor = connection.cursor()
try:
cursor.insert(data, self._table, True, update_skip_columns)
if not hasattr(self, 'id'):
data = cursor.fetchone('select last_insert_id() as id')
if data:
self.id = int(data['id'])
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('finish save object....[table:%s]' % self._table)
def inserts(cls, objects):
'''insert objects'''
cls._init_meta()
info('start to save objects....[table:%s]' % cls._table)
update_skip_columns = ['id', 'created_time', 'updated_time']
meta = Persistable._meta_cache[cls._table]
columns = meta.columns
datas = []
for obj in objects:
data = {}
cache_key = obj.build_cache_key(obj)
if cache_key:
cls._cache.delete(cache_key)
for column in columns:
field_name = column.field
if field_name == 'updated_time':
continue
elif hasattr(obj, field_name):
data[field_name] = getattr(object, field_name)
elif field_name == 'created_time':
data['created_time'] = ReserveLiteral('now()')
datas.append(data)
cursor = connection.cursor()
try:
cursor.insert(datas, cls._table, True, update_skip_columns)
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('finish save objects....[table:%s]' % cls._table)
def delete(self, key=None):
'''delete the object'''
self._init_meta()
if not key:
key = 'id'
if hasattr(self, key):
key_value = getattr(self, key)
else:
raise 'key value not exist'
info('start to delete[table:%s, %s=%s]' %
(self._table, key, key_value))
sql = 'delete from %s where %s = %s' % (self._table, key, key_value)
cache_key = self.build_cache_key(self)
if cache_key:
info('start to delete from cache:[%s]' % cache_key)
self._cache.delete(cache_key)
cursor = connection.cursor()
try:
cursor.execute(sql)
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('finish delete')
def delete(self, key=None):
'''delete the object'''
self._init_meta()
if not key:
key = 'id'
if hasattr(self, key):
key_value = getattr(self, key)
else:
raise 'key value not exist'
info('start to delete[table:%s, %s=%s]' % (self._table, key, key_value))
sql = 'delete from %s where %s = %s' % (self._table, key, key_value)
cache_key = self.build_cache_key(self)
if cache_key:
info('start to delete from cache:[%s]' % cache_key)
self._cache.delete(cache_key)
cursor = connection.cursor()
try:
cursor.execute(sql)
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('finish delete')
def replace_function(*args, **kwargs):
while True:
try:
return input_function(*args, **kwargs)
except KeyboardInterrupt:
raise
except:
log_execption()
exception_mgr.on_except()
time.sleep(10)
def partner_service_delete(request,sid,pid):
try:
sid = int(sid)
pid = int(pid)
partnerServices = PartnerService()
partnerServices.delete_mul(sid=sid,pid=pid)
return redirect('/partner/'+str(pid)+'/')
except:
exception_mgr.on_except()
raise Http404()
def partner_service_delete(request, sid, pid):
try:
sid = int(sid)
pid = int(pid)
partnerServices = PartnerService()
partnerServices.delete_mul(sid=sid, pid=pid)
return redirect('/partner/' + str(pid) + '/')
except:
exception_mgr.on_except()
raise Http404()
def replace_function(*args, **kwargs):
while True:
try:
return input_function(*args, **kwargs)
except KeyboardInterrupt:
raise
except:
log_execption()
exception_mgr.on_except()
time.sleep(10)
def count(cls, condition='1=1'):
'''count the records'''
cls._init_meta()
cursor = connection.cursor()
sql = 'select count(*) as count from %s where %s' % (cls._table, condition)
try:
data = cursor.fetchone(sql)
return data['count']
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
def count(cls, condition='1=1'):
'''count the records'''
cls._init_meta()
cursor = connection.cursor()
sql = 'select count(*) as count from %s where %s' % (cls._table,
condition)
try:
data = cursor.fetchone(sql)
return data['count']
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
def replace_function(*args, **kwargs):
request = args[0]
user = user_roles.get_userinfo(request)
if user:
request.user = user
try:
return input_function(*args, **kwargs)
except:
full_path = request.get_full_path()
exception_mgr.on_except('request url: %r' % full_path, 1)
log_execption('request url: %r' % full_path, 1)
raise
else:
response = HttpResponseRedirect("/login/")
return response
def replace_function(*args, **kwargs):
request = args[0]
user = user_roles.get_userinfo(request)
if user or True:
request.user = user
try:
return input_function(*args, **kwargs)
except:
full_path = request.get_full_path()
exception_mgr.on_except('request url: %r' % full_path, 1)
log_execption('request url: %r' % full_path, 1)
raise
else:
response = HttpResponseRedirect('/login/')
return response
def _dispatch_rpc_call(self, request, module_name, raw_post_data, args, kwargs):
response_dict = {}
try:
if module_name in _dispatchers_dict:
dispatcher = _dispatchers_dict[module_name]
else:
raise Exception("Module '%s' doesn't have JSON-RPC functions" % module_name)
call_data = self.serializer.deserialize(raw_post_data)
call_id = call_data.get("id", None)
if call_id:
response_dict["id"] = call_id
else:
#following JSON-RPC spec, it's a notification, not a request
return ""
func_name = str(call_data["method"])
func_params = list(call_data["params"])
args_list = list(args)
args_list.insert(0, request)
args_list.extend(func_params)
result = dispatcher.dispatch(func_name, *args_list, **kwargs)
response_dict['result'] = result
response_dict['error'] = None
except Exception, e:
except_msg = exception_mgr.on_except(None, 2)
error_dict = {
"name": str(sys.exc_info()[0]),
"message": str(e),
"stack": except_msg
}
response_dict['error'] = error_dict
response_dict['result'] = None
def _dispatch_rpc_call(self, request, module_name, raw_post_data, args,
kwargs):
response_dict = {}
try:
if module_name in _dispatchers_dict:
dispatcher = _dispatchers_dict[module_name]
else:
raise Exception("Module '%s' doesn't have JSON-RPC functions" %
module_name)
call_data = self.serializer.deserialize(raw_post_data)
call_id = call_data.get("id", None)
if call_id:
response_dict["id"] = call_id
else:
#following JSON-RPC spec, it's a notification, not a request
return ""
func_name = str(call_data["method"])
func_params = list(call_data["params"])
args_list = list(args)
args_list.insert(0, request)
args_list.extend(func_params)
result = dispatcher.dispatch(func_name, *args_list, **kwargs)
response_dict['result'] = result
response_dict['error'] = None
except Exception, e:
except_msg = exception_mgr.on_except(None, 2)
error_dict = {
"name": str(sys.exc_info()[0]),
"message": str(e),
"stack": except_msg
}
response_dict['error'] = error_dict
response_dict['result'] = None
def process_exception(self, request, e):
"""处理异常，将异常记录到日志文件"""
global ERROR_500
full_path = request.get_full_path()
s = exception_mgr.on_except('request url: %r' % full_path, 2)
logging = get_logging()
logging.error(s)
if not DEBUG:
#return HttpResponseServerError(ERROR_500 % full_path)
return HttpResponseRedirect("/error")
return None
def process_exception(self, request, e):
"""处理异常，将异常记录到日志文件"""
global ERROR_500
full_path = request.get_full_path()
s = exception_mgr.on_except('request url: %r' % full_path, 2)
logging = get_logging()
logging.error(s)
if not DEBUG:
#return HttpResponseServerError(ERROR_500 % full_path)
return HttpResponseRedirect("/error")
return None
def delete_mul(cls, **keys):
'''load the object'''
cls._init_meta()
for _ in keys.values():
pass #检验参数
query_str = ','.join(['%s=%s' % (k, v) for k, v in keys.items()])
info('start load object with %s[table:%s]' % (query_str, cls._table))
condition = ' and '.join(["%s=%%s" % k for k in keys.keys()])
param = [keys[k] for k in keys.keys()]
sql = 'delete from %s where %s' % (cls._table, condition)
cursor = connection.cursor()
try:
cursor.execute(sql, param)
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('finish delete')
def delete_mul(cls,**keys):
'''load the object'''
cls._init_meta()
for _ in keys.values():
pass #检验参数
query_str = ','.join(['%s=%s' % (k, v) for k, v in keys.items()])
info('start load object with %s[table:%s]' % (query_str, cls._table))
condition = ' and '.join(["%s=%%s" % k for k in keys.keys()])
param = [keys[k] for k in keys.keys()]
sql = 'delete from %s where %s' % (cls._table, condition)
cursor = connection.cursor()
try:
cursor.execute(sql,param)
except:
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
info('finish delete')
def query(cls, **args):
'''query objects'''
cls._init_meta()
limit = ''
order = ''
where = '1=1'
if 'limit' in args:
limit = 'limit %s' % args['limit']
if 'order' in args:
order = 'order by %s' % args['order']
if 'condition' in args:
where = args['condition']
columns = args.get('columns', '*')
sql = 'select %s from %s where %s %s %s ' % (columns, cls._table,
where, order, limit)
if len(sql) < 2000:
info('start to load objects[%s] with sql:%s' % (cls._table, sql))
info('start to load objects')
cursor = connection.cursor()
try:
data = cursor.fetchall(sql)
if data:
objs = []
for row in data:
obj = cls._build_object(row)
objs.append(obj)
info('query success, return %s records...' % len(objs))
return objs
except:
logging.error(traceback.format_exc())
exception_mgr.on_except(sql)
raise PersistableException()
finally:
cursor.close()
info('not record found')
return []
def query(cls, **args):
'''query objects'''
cls._init_meta()
limit = ''
order = ''
where = '1=1'
if 'limit' in args:
limit = 'limit %s' % args['limit']
if 'order' in args:
order = 'order by %s' % args['order']
if 'condition' in args:
where = args['condition']
columns = args.get('columns', '*')
sql = 'select %s from %s where %s %s %s ' % (columns, cls._table, where, order, limit)
if len(sql) < 2000:
info('start to load objects[%s] with sql:%s' % (cls._table, sql))
info('start to load objects')
cursor = connection.cursor()
try:
data = cursor.fetchall(sql)
if data:
objs = []
for row in data:
obj = cls._build_object(row)
objs.append(obj)
info('query success, return %s records...' % len(objs))
return objs
except:
logging.error(traceback.format_exc())
exception_mgr.on_except(sql)
raise PersistableException()
finally:
cursor.close()
info('not record found')
return []
def partner(request,num='0'):
try:
partners = Partner.query()
partnerServices = PartnerService.query(condition='pid='+num)
services = []
filterservices = Service.query()
for p in partnerServices:
service = Service.load(sid=p.sid)
services.append(service)
if services:
filterservices.extend(services)
filterservices = list(set(filterservices))
data = {
'post_path': request.get_full_path(),
'services': services,
'partners':partners,
'pid':num,
'filterservices':filterservices
}
response = render_to_response(request, "admin/partner.html",data)
return response
except :
exception_mgr.on_except()
raise Http404()
def partner(request, num='0'):
try:
partners = Partner.query()
partnerServices = PartnerService.query(condition='pid=' + num)
services = []
filterservices = Service.query()
for p in partnerServices:
service = Service.load(sid=p.sid)
services.append(service)
if services:
filterservices.extend(services)
filterservices = list(set(filterservices))
data = {
'post_path': request.get_full_path(),
'services': services,
'partners': partners,
'pid': num,
'filterservices': filterservices
}
response = render_to_response(request, "admin/partner.html", data)
return response
except:
exception_mgr.on_except()
raise Http404()
def _init_meta(cls):
if hasattr(cls, 'inited') and getattr(cls, 'inited'):
return
info('-' * 100)
info('start to init meta[%s]...' % cls.__name__)
info('-' * 100)
if not hasattr(cls, '_table') or getattr(cls, '_table') is None:
cls._table = cls._parse_table()
meta = cls._cache.get(cls._table)
if meta:
#try get from cache
info('meta hit in cache, use it!!!')
Persistable._meta_cache[cls._table] = meta
cls.inited = True
return
if cls._table in Persistable._meta_cache:
return
sql = 'show columns from %s'
cursor = connection.cursor()
try:
try:
data = cursor.fetchall(sql % cls._table)
except ProgrammingError:
raise TableNotExistException(cls._table)
meta = Meta(cls._table)
column_infos = data.to_list()
for column_info in column_infos:
field = column_info['Field']
default = column_info['Default']
column_type = column_info['Type']
extra = column_info['Extra']
if column_type.startswith(Column.TYPE_INT):
temp_type = column_type[:len(Column.TYPE_INT)]
length = column_type[len(Column.TYPE_INT) + 1:-1]
column_type = temp_type
elif column_type.startswith(Column.TYPE_VARCHAR):
temp_type = column_type[:len(Column.TYPE_VARCHAR)]
length = column_type[len(Column.TYPE_VARCHAR) + 1:-1]
column_type = temp_type
else:
length = None
key = column_info['Key']
if key == 'UNI' or key == 'PRI':
is_unique = True
else:
is_unique = False
column = Column(field=field, column_type=column_type, length=length, \
is_unique=is_unique, default=default, extra=extra)
meta.add_column(column)
cls._cache.set(cls._table, meta)
Persistable._meta_cache[cls._table] = meta
except:
info(traceback.format_exc())
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
cls.inited = True
def _init_meta(cls):
if hasattr(cls, 'inited') and getattr(cls, 'inited'):
return
info('-' * 100)
info('start to init meta[%s]...' % cls.__name__)
info('-' * 100)
if not hasattr(cls, '_table') or getattr(cls, '_table') is None:
cls._table = cls._parse_table()
meta = cls._cache.get(cls._table)
if meta:
#try get from cache
info('meta hit in cache, use it!!!')
Persistable._meta_cache[cls._table] = meta
cls.inited = True
return
if cls._table in Persistable._meta_cache:
return
sql = 'show columns from %s'
cursor = connection.cursor()
try:
try:
data = cursor.fetchall(sql % cls._table)
except ProgrammingError:
raise TableNotExistException(cls._table)
meta = Meta(cls._table)
column_infos = data.to_list()
for column_info in column_infos:
field = column_info['Field']
default = column_info['Default']
column_type = column_info['Type']
extra = column_info['Extra']
if column_type.startswith(Column.TYPE_INT):
temp_type = column_type[:len(Column.TYPE_INT)]
length = column_type[len(Column.TYPE_INT) + 1:-1]
column_type = temp_type
elif column_type.startswith(Column.TYPE_VARCHAR):
temp_type = column_type[:len(Column.TYPE_VARCHAR)]
length = column_type[len(Column.TYPE_VARCHAR) + 1:-1]
column_type = temp_type
else:
length = None
key = column_info['Key']
if key == 'UNI' or key == 'PRI':
is_unique = True
else:
is_unique = False
column = Column(field=field, column_type=column_type, length=length, \
is_unique=is_unique, default=default, extra=extra)
meta.add_column(column)
cls._cache.set(cls._table, meta)
Persistable._meta_cache[cls._table] = meta
except:
info(traceback.format_exc())
exception_mgr.on_except()
raise PersistableException()
finally:
cursor.close()
cls.inited = True
