def get_hour_position_impression_click(self, ad_network_id, position_id,
day, hour):
"""
:type ad_network_id: str
:type position_id: str
:type day: datetime
:type hour: str
:rtype: (int, int)
"""
if config.server_local_fake:
return self.__get_random_data()
impression = None
click = None
try:
dt = day.strftime("%Y%m%d")
impression = self.redis.get('%s|%s|%s%s|2' %
(ad_network_id, position_id, dt, hour))
click = self.redis.get('%s|%s|%s%s|3' %
(ad_network_id, position_id, dt, hour))
except:
Logger.error(traceback.format_exc())
finally:
if not impression:
impression = 0
impression = int(impression)
if not click:
click = 0
click = int(click)
return impression, click
def edit_user(cls, user_id, user_right):
try:
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
session.query(Users).filter(Users.id == user_id).update(
{Users.user_right: user_right})
session.commit()
db_user_list = session.query(
Users.id, Users.user_email, Users.user_right,
Users.create_time).filter(Users.id == user_id)[:]
a_dict = dict()
a_dict['success'] = True
a_dict['msg'] = 'ok'
a_dict['content'] = content = list()
if len(db_user_list) > 0:
db_user = db_user_list[0]
a_user = {
'id':
db_user.id,
'user_email':
db_user.user_email,
'user_right':
db_user.user_right,
'create_time':
db_user.create_time.strftime('%Y-%m-%d %H:%M:%S')
}
content.append(a_user)
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['msg'] = 'update db failed'
return json.dumps(a_dict)
def __get_monitor_status(cls, job_id_set, service_list):
"""
:type job_id_set: set[int]
:param service_list: list[dict[str, Object]]
:return:
"""
try:
if len(job_id_set) <= 0:
return
service_id_string = ','.join([str(item) for item in job_id_set])
request_data = {'service_id': service_id_string}
url = config.monitor_server_url + '/api_monitor_status'
r = requests.post(url, data=request_data)
Logger.info(
"url=[%s], service_id_list=[%s], status_code=[%s], response=[%s]"
% (url, job_id_set, r.status_code, r.text))
if r.status_code != 200:
return
json_dict = json.loads(r.text)
if json_dict['code'] != 0:
return
status_dict = json_dict['content']
for a_service in service_list:
result = status_dict.get(str(a_service['id']), None)
if result is not None:
(healthy_code, last) = result
a_service[
'monitor_time'] = datetime.datetime.fromtimestamp(
last).strftime('%Y-%m-%d %H:%M:%S')
a_service['healthy_code'] = healthy_code
except:
Logger.error(traceback.format_exc())
def delete_one_machine(cls, machine_id):
try:
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
using_count = session.query(Services).filter(
Services.machine_id == machine_id).count()
if using_count > 0:
result = dict()
result['success'] = False
result['code'] = DbError.RELY_EXIST_ERROR
return json.dumps(result, ensure_ascii=False)
session.query(Machines).filter(
Machines.id == machine_id).delete(
synchronize_session=False)
session.commit()
# 返回成功
a_dict = dict()
a_dict['success'] = True
a_dict['code'] = DbError.OK
a_dict['msg'] = 'ok'
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['code'] = DbError.DB_OPERATE_ERROR
a_dict['msg'] = 'delete from db error'
return json.dumps(a_dict)
def get_user_info(cls, user_account):
"""
:type user_account: str
:rtype: UserList
"""
try:
# 创建session
session = sessionmaker(bind=cls.engine)()
# 查询用户
values = session.query(UserList).filter(
UserList.user_account == user_account)
# 关闭session
session.close()
# 获取用户信息
user = None
for value in values:
user = value
break
# 未查到用户
if not user:
Logger.error("user_account[%s] number[%s] != 0" %
(user_account, len(values)))
return None
return user
except:
Logger.error(traceback.format_exc())
return None
def delete_machines(cls, machine_id_list):
try:
# 过滤参数
split_id_list = machine_id_list.split(',')
join_id_list = list()
for user_id in split_id_list:
if user_id != '':
join_id_list.append(user_id)
if len(join_id_list) == 0:
a_dict = dict()
a_dict['success'] = False
a_dict['msg'] = list()
return json.dumps(a_dict)
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
session.query(Machines).filter(
Machines.id.in_(join_id_list)).delete(
synchronize_session=False)
session.commit()
# 返回成功
a_dict = dict()
a_dict['success'] = True
a_dict['msg'] = 'ok'
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['msg'] = 'delete from db error'
return json.dumps(a_dict)
def query_user_list(cls, user_account, off_set, limit):
try:
# 转换类型
off_set = int(off_set)
limit = int(limit)
if limit == -1:
limit_count = None
else:
limit_count = off_set + limit
# 创建session
session = sessionmaker(bind=cls.engine)()
# 查询数据
if user_account != '':
like_condition = '%' + user_account + '%'
count = session.query(
UserList.id, UserList.user_account, UserList.user_right,
UserList.update_time).filter(
UserList.user_account.like(like_condition)).count()
values = session.query(
UserList.id, UserList.user_account, UserList.user_right,
UserList.update_time).filter(
UserList.user_account.like(
like_condition))[off_set:limit_count]
else:
count = session.query(UserList.id, UserList.user_account,
UserList.user_right,
UserList.update_time).count()
values = session.query(
UserList.id, UserList.user_account, UserList.user_right,
UserList.update_time)[off_set:limit_count]
# 关闭session
session.close()
# 返回结果
a_user_list = list()
for value in values:
a_user = dict()
a_user_list.append(a_user)
a_user['user_id'] = value.id
a_user['user_account'] = value.user_account
a_user['user_right'] = value.user_right
a_user['update_time'] = datetime.datetime.fromtimestamp(
value.update_time).strftime('%Y-%m-%d %H:%M:%S')
# 返回成功
a_dict = dict()
a_dict['success'] = 'true'
a_dict['content'] = a_user_list
a_dict['item_count'] = count
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = 'false'
a_dict['content'] = list()
a_dict['item_count'] = 0
return json.dumps(a_dict)
def read_public_key(self, file_path):
try:
content = ''
with open(file_path, 'r') as key_file:
content = key_file.read()
return content
except Exception, e:
Logger.error(e.message)
return ''
def query_network_list(cls, network_name, off_set, limit):
try:
# 转换类型
off_set = int(off_set)
limit = int(limit)
if limit == -1:
limit_count = None
else:
limit_count = off_set + limit
# 创建session
session = sessionmaker(bind=cls.engine)()
# 查询数据
if network_name != '':
like_condition = '%' + network_name + '%'
count = session.query(
NetworkList.id, NetworkList.network,
NetworkList.update_time).filter(
NetworkList.network.like(like_condition)).count()
values = session.query(
NetworkList.id, NetworkList.network,
NetworkList.update_time).filter(
NetworkList.network.like(
like_condition))[off_set:limit_count]
else:
count = session.query(NetworkList.id, NetworkList.network,
NetworkList.update_time).count()
values = session.query(
NetworkList.id, NetworkList.network,
NetworkList.update_time)[off_set:limit_count]
# 关闭session
session.close()
# 返回结果
a_network_list = list()
for value in values:
a_network = dict()
a_network_list.append(a_network)
a_network['network_id'] = value.id
a_network['network_name'] = value.network
a_network['update_time'] = datetime.datetime.fromtimestamp(
value.update_time).strftime('%Y-%m-%d %H:%M:%S')
# 返回成功
a_dict = dict()
a_dict['success'] = 'true'
a_dict['content'] = a_network_list
a_dict['item_count'] = count
return a_dict
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = 'false'
a_dict['content'] = list()
a_dict['item_count'] = 0
return a_dict
def query_machine_list(cls, machine, off_set, limit):
try:
# 转换类型
off_set = int(off_set)
limit = int(limit)
if limit == -1:
limit_count = None
else:
limit_count = off_set + limit
# 创建session
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
# 查询数据
count_query = session.query(Machines.id)
value_query = session.query(Machines.id, Machines.ssh_user,
Machines.ssh_ip, Machines.ssh_port,
Machines.create_time)
if machine != '':
machine_condition = '%' + machine + '%'
count_query = count_query.filter(
or_(Machines.ssh_user.like(machine_condition),
Machines.ssh_ip.like(machine_condition)))
value_query = value_query.filter(
or_(Machines.ssh_user.like(machine_condition),
Machines.ssh_ip.like(machine_condition)))
count = count_query.count()
values = value_query[off_set:limit_count]
# 返回结果
a_machine_list = list()
for value in values:
a_machine = dict()
a_machine_list.append(a_machine)
a_machine['id'] = value.id
a_machine['ssh_user'] = value.ssh_user
a_machine['ssh_ip'] = value.ssh_ip
a_machine['ssh_port'] = value.ssh_port
a_machine['create_time'] = value.create_time.strftime(
'%Y-%m-%d %H:%M:%S')
# 返回成功
a_dict = dict()
a_dict['success'] = True
a_dict['content'] = a_machine_list
a_dict['item_count'] = count
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['content'] = list()
a_dict['item_count'] = 0
return json.dumps(a_dict)
def check_login_valid(self):
try:
str_last_time = self.get_secure_cookie('last_time')
if not str_last_time:
return False
when = float(str_last_time)
now = time.time()
if now - when > Config.LOGIN_EXPIRE_TIME:
return False
return True
except Exception, e:
Logger.error(e.message)
def query_all_monitor_base_v2(cls, service_id):
try:
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
# 查询数据
values = session.query(
Services.id,
Services.service_name).filter(Services.id != service_id)[:]
# 返回结果
return values
except:
Logger.error(traceback.format_exc())
return None
def query_user_list(cls, user_email, off_set, limit):
try:
# 转换类型
off_set = int(off_set)
limit = int(limit)
if limit == -1:
limit_count = None
else:
limit_count = off_set + limit
# 创建session
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
# 查询数据
count_query = session.query(Users.id)
value_query = session.query(Users.id, Users.user_email,
Users.user_right,
Users.create_time)
if user_email != '':
like_condition = '%' + user_email + '%'
count_query = count_query.filter(
Users.user_email.like(like_condition))
value_query = value_query.filter(
Users.user_email.like(like_condition))
count = count_query.count()
values = value_query[off_set:limit_count]
# 返回结果
a_user_list = list()
for value in values:
a_user = dict()
a_user_list.append(a_user)
a_user['id'] = value.id
a_user['user_email'] = value.user_email
a_user['user_right'] = value.user_right
a_user['create_time'] = value.create_time.strftime(
'%Y-%m-%d %H:%M:%S')
# 返回成功
a_dict = dict()
a_dict['success'] = True
a_dict['content'] = a_user_list
a_dict['item_count'] = count
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['content'] = list()
a_dict['item_count'] = 0
return json.dumps(a_dict)
def get_user_info(cls, token, open_id):
try:
a_dict = {
'access_token': token,
'appid': Config.OAUTH_APP_ID,
'openid': open_id
}
r = requests.post(Config.OAUTH_USER_URL, a_dict)
if r.status_code != 200:
Logger.error("get_user_info error, status_code[%s], content[%s]" % (r.status_code, r.content))
return r.status_code, r.content
except:
Logger.error(traceback.format_exc())
return None, None
def edit_machine(cls, machine_id, ssh_user, ssh_ip, ssh_port):
try:
a_dict = dict()
if not machine_id or not ssh_user or not ssh_ip or not ssh_port:
a_dict['success'] = False
a_dict['msg'] = 'data invalid'
return json.dumps(a_dict)
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
session.query(Machines).filter(
Machines.id == machine_id).update({
Machines.ssh_user:
ssh_user,
Machines.ssh_ip:
ssh_ip,
Machines.ssh_port:
ssh_port
})
session.commit()
db_machine_list = session.query(
Machines.id, Machines.ssh_user, Machines.ssh_ip,
Machines.ssh_port,
Machines.create_time).filter(Machines.id == machine_id)[:]
a_dict['success'] = True
a_dict['msg'] = 'ok'
a_dict['content'] = content = list()
if len(db_machine_list) > 0:
db_machine = db_machine_list[0]
a_machine = {
'id':
db_machine.id,
'ssh_user':
db_machine.ssh_user,
'ssh_ip':
db_machine.ssh_ip,
'ssh_port':
db_machine.ssh_port,
'create_time':
db_machine.create_time.strftime('%Y-%m-%d %H:%M:%S')
}
content.append(a_machine)
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['msg'] = 'update db failed'
return json.dumps(a_dict)
def set_monitor_active(cls, service_id, expect_active):
try:
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
session.query(Services).filter(
Services.id == service_id).update(
{Services.is_active: expect_active})
session.commit()
values = session.query(
Services.id, Services.user_email, Services.service_name,
Services.machine_id, Services.start_cmd, Services.stop_cmd,
Services.is_active, Services.auto_recover,
Services.mail_receiver,
Services.create_time).filter(Services.id == service_id)[:]
a_dict = dict()
a_dict['success'] = True
a_dict['msg'] = 'ok'
a_dict['content'] = content = list()
if len(values) == 0:
return json.dumps(a_dict, ensure_ascii=False)
else:
value = values[0]
a_service = dict()
content.append(a_service)
a_service['id'] = value.id
a_service['user_email'] = value.user_email
a_service['service_name'] = value.service_name
a_service['machine_id'] = value.machine_id
a_service['start_cmd'] = value.start_cmd
a_service['stop_cmd'] = value.stop_cmd
a_service['is_active'] = value.is_active
a_service['auto_recover'] = value.auto_recover
a_service['mail_receiver'] = value.mail_receiver
a_service['create_time'] = value.create_time.strftime(
'%Y-%m-%d %H:%M:%S')
a_service['healthy_code'] = 0
a_service['monitor_time'] = '1970-01-01 00:00:00'
# 获取最新监测状态
cls.__get_monitor_status(set(service_id), [a_service])
return json.dumps(a_dict, ensure_ascii=False)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['content'] = None
a_dict['msg'] = 'update db failed'
return json.dumps(a_dict, ensure_ascii=False)
def get_user_info(cls, token, open_id):
try:
a_dict = {
'access_token': token,
'appid': config.server_oauth_app_id,
'openid': open_id
}
r = requests.post(config.server_oauth_user_url, a_dict)
if r.status_code != 200:
Logger.error(
"get_user_info error, status_code[%s], content[%s]" %
(r.status_code, r.content))
return r.status_code, r.content
except:
Logger.error(traceback.format_exc())
return None, None
def get_access_token(cls, code):
try:
a_dict = {
'code': code,
'appid': Config.OAUTH_APP_ID,
'appsecret': Config.OAUTH_APP_SECRET,
'redirect_uri': Config.OAUTH_REDIRECT_URL,
'grant_type': 'auth_code',
}
r = requests.post(Config.OAUTH_TOKEN_URL, a_dict)
if r.status_code != 200:
Logger.error("get_access_token error, status_code[%s], content[%s]" % (r.status_code, r.content))
return r.status_code, r.content
except:
Logger.error(traceback.format_exc())
return None, None
def get_access_token(cls, code):
try:
a_dict = {
'code': code,
'appid': config.server_oauth_app_id,
'appsecret': config.server_oauth_app_secret,
'redirect_uri': config.server_oauth_redirect_url,
'grant_type': 'auth_code',
}
r = requests.post(config.server_oauth_token_url, a_dict)
if r.status_code != 200:
Logger.error(
"get_access_token error, status_code[%s], content[%s]" %
(r.status_code, r.content))
return r.status_code, r.content
except:
Logger.error(traceback.format_exc())
return None, None
def query_machine_list_v2(cls):
try:
# 创建session
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
# 查询数据
value_query = session.query(Machines.id, Machines.ssh_user,
Machines.ssh_ip, Machines.ssh_port)
values = value_query[:]
# 返回结果
a_machine_list = list()
for value in values:
a_machine_list.append(value)
return a_machine_list
except:
Logger.error(traceback.format_exc())
return None
def query_monitor_detail(cls, service_id):
try:
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
values = session.query(
Services.id, Services.user_email, Services.service_name,
Services.machine_id, Machines.ssh_user, Machines.ssh_ip,
Machines.ssh_port, Services.start_cmd, Services.stop_cmd,
Services.is_active, Services.auto_recover,
Services.mail_receiver, Services.create_time).join(
Machines, Machines.id == Services.machine_id).filter(
Services.id == service_id)[:]
if len(values) == 0:
return None
monitor_detail = MonitorDetail()
# Set monitor base information
monitor_detail.base_info = values[0]
# query check_cmd_list
values = session.query(
CheckCmd.id, CheckCmd.local_check, CheckCmd.check_shell,
CheckCmd.operator, CheckCmd.check_value,
CheckCmd.good_match).filter(
CheckCmd.service_id == service_id)[:]
for value in values:
if value.good_match == 1:
# healthy_check_list.append(check_cmd)
monitor_detail.healthy_check_list.append(value)
else:
# unhealthy_check_list.append(check_cmd)
monitor_detail.unhealthy_check_list.append(value)
# query rely services
values = session.query(
Services.id, Services.service_name).join(
ServiceRely,
Services.id == ServiceRely.rely_id).filter(
ServiceRely.service_id == service_id)[:]
for value in values:
monitor_detail.rely_service_list.append(value)
return monitor_detail
except:
Logger.error(traceback.format_exc())
return None
def add_one_user(cls, user_email, user_right):
try:
user = Users(user_email=user_email, user_right=user_right)
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
session.add(user)
session.flush()
session.commit()
a_dict = dict()
a_dict['success'] = True
a_dict['msg'] = 'ok'
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['msg'] = 'insert into db error'
return json.dumps(a_dict)
def query_all_operator(cls):
try:
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
values = session.query(Operator.operator)[:]
content = list()
for value in values:
item = dict()
content.append(item)
item['operator'] = value.operator
result = dict()
result['success'] = True
result['content'] = content
return json.dumps(result, ensure_ascii=False)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['content'] = list()
return json.dumps(a_dict, ensure_ascii=False)
def delete_network_list(cls, network_id_list):
try:
# 过滤参数
split_id_list = network_id_list.split(',')
join_id_list = list()
for user_id in split_id_list:
if user_id != '':
join_id_list.append(user_id)
if len(join_id_list) == 0:
a_dict = dict()
a_dict['success'] = 'false'
a_dict['content'] = list()
return json.dumps(a_dict)
# 创建session
session = sessionmaker(bind=cls.engine)()
# 添加用户
count = session.query(NetworkList).filter(
NetworkList.id.in_(join_id_list)).delete(
synchronize_session=False)
# 关闭session
session.commit()
session.close()
if count <= 0:
a_dict = dict()
a_dict['success'] = 'false'
a_dict['content'] = list()
return json.dumps(a_dict)
# 返回成功
a_dict = dict()
a_dict['success'] = 'true'
a_dict['content'] = join_id_list
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = 'false'
a_dict['content'] = list()
return json.dumps(a_dict)
def edit_user(cls, user_id, user_right):
try:
# 创建session
session = sessionmaker(bind=cls.engine)()
# 更新并获取用户信息
count = session.query(UserList).filter(
UserList.id == user_id).update(
{UserList.user_right: user_right})
if count != 1:
session.commit()
session.close()
a_dict = dict()
a_dict['success'] = 'false'
a_dict['content'] = dict()
return json.dumps(a_dict)
values = session.query(UserList).filter(UserList.id == user_id)
# 关闭session
session.commit()
session.close()
# 返回成功
a_user = dict()
for value in values:
a_user['user_id'] = value.id
a_user['user_account'] = value.user_account
a_user['user_right'] = value.user_right
a_user['update_time'] = datetime.datetime.fromtimestamp(
value.update_time).strftime('%Y-%m-%d %H:%M:%S')
a_dict = dict()
a_dict['success'] = 'true'
a_dict['content'] = a_user
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = 'false'
a_dict['content'] = dict()
return json.dumps(a_dict)
def add_user_account(cls, user_account, user_right):
try:
# 创建用户
now = int(time.time())
user = UserList(user_account=user_account,
user_right=user_right,
update_time=now)
# 创建session
session = sessionmaker(bind=cls.engine)()
# 添加用户
session.add(user)
# 获取新id
session.flush()
new_user_id = user.id
# 关闭session
session.commit()
session.close()
# 插入成功,返回结果
a_user_list = list()
a_user = dict()
a_user_list.append(a_user)
a_user['user_id'] = new_user_id
a_user['user_account'] = user_account
a_user['user_right'] = user_right
a_user['update_time'] = datetime.datetime.fromtimestamp(
now).strftime('%Y-%m-%d %H:%M:%S')
# 返回成功
a_dict = dict()
a_dict['success'] = 'true'
a_dict['content'] = a_user_list
a_dict['item_count'] = 1
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = 'false'
a_dict['content'] = list()
a_dict['item_count'] = 0
return json.dumps(a_dict)
def add_one_machine(cls, ssh_user, ssh_ip, ssh_port):
try:
machine = Machines(ssh_user=ssh_user,
ssh_ip=ssh_ip,
ssh_port=ssh_port)
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
session.add(machine)
session.flush()
session.commit()
a_dict = dict()
a_dict['success'] = True
a_dict['msg'] = 'ok'
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['msg'] = 'insert into db error'
return json.dumps(a_dict)
def get_hour_win(self, ad_network_id, day, hour):
"""
:type ad_network_id: str
:type day: datetime
:type hour: str
:rtype: int
"""
if config.server_local_fake:
return random.randint(100, 10000)
win = None
try:
dt = day.strftime("%Y%m%d")
win = self.win_redis.get('%s|%s|%s|win' %
(ad_network_id, dt, hour))
except:
Logger.error(traceback.format_exc())
finally:
if not win:
win = 0
win = int(win)
return win
def query_all_monitor_base(cls, service_name, off_set, limit):
try:
off_set = int(off_set)
limit = int(limit)
if limit == -1:
limit_count = None
else:
limit_count = off_set + limit
session = sessionmaker(bind=cls.engine)()
with Defer(session.close):
# 查询数据
value_query = session.query(Services.id, Services.service_name)
if service_name != '':
like_condition = '%' + service_name + '%'
value_query = value_query.filter(
Services.service_name.like(like_condition))
values = value_query[off_set:limit_count]
# 返回结果
service_list = list()
for value in values:
a_service = dict()
service_list.append(a_service)
a_service['id'] = value.id
a_service['service_name'] = value.service_name
# 返回成功
a_dict = dict()
a_dict['success'] = True
a_dict['content'] = service_list
return json.dumps(a_dict, ensure_ascii=False)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = False
a_dict['content'] = list()
return json.dumps(a_dict, ensure_ascii=False)
def add_network(cls, network_name):
try:
# 创建渠道
now = int(time.time())
network = NetworkList(network=network_name, update_time=now)
# 创建session
session = sessionmaker(bind=cls.engine)()
# 添加渠道
session.add(network)
# 获取新id
session.flush()
new_network_id = network.id
# 关闭session
session.commit()
session.close()
# 插入成功,返回结果
a_network_list = list()
a_network = dict()
a_network_list.append(a_network)
a_network['network_id'] = new_network_id
a_network['network_name'] = network_name
a_network['update_time'] = datetime.datetime.fromtimestamp(
now).strftime('%Y-%m-%d %H:%M:%S')
# 返回成功
a_dict = dict()
a_dict['success'] = 'true'
a_dict['content'] = a_network_list
a_dict['item_count'] = 1
return json.dumps(a_dict)
except:
Logger.error(traceback.format_exc())
a_dict = dict()
a_dict['success'] = 'false'
a_dict['content'] = list()
a_dict['item_count'] = 0
return json.dumps(a_dict)
