def post(self):
login_user = self.get_login_user()
if not login_user:
return
if not login_user.user_right & UserRight.MANUAL_START:
self.redirect("/")
return
a_dict = dict()
a_dict['success'] = False
a_dict['content'] = list()
a_dict['item_count'] = 0
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
user_email = self.get_argument("user_email")
off_set = self.get_argument("off_set")
limit = self.get_argument("limit")
start_time = self.get_argument('start_time')
end_time = self.get_argument('end_time')
if not start_time or not end_time:
self.write(json.dumps(a_dict, ensure_ascii=False))
return
start_time = float(start_time)
end_time = float(end_time)
text = DbOperator.query_start_history(user_email, off_set, limit, start_time, end_time)
self.write(text)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
room_name = self.get_argument('room_name')
room_pwd = self.get_argument('room_pwd')
rooter_name = self.get_argument('rooter_name')
rooter_pwd = self.get_argument('rooter_pwd')
wifi_name = self.get_argument('wifi_name')
wifi_pwd = self.get_argument('wifi_pwd')
electric_date = self.get_argument('electric_date')
electric_fee = self.get_argument('electric_fee')
water_date = self.get_argument('water_date')
water_fee = self.get_argument('water_fee')
gas_date = self.get_argument('gas_date')
gas_fee = self.get_argument('gas_fee')
net_date = self.get_argument('net_date')
net_fee = self.get_argument('net_fee')
room_desc = self.get_argument('room_desc')
a_dict = dict()
if not room_name:
a_dict['code'] = 1
a_dict['msg'] = 'Room name is empty'
self.write(json.dumps(a_dict, ensure_ascii=False))
return
user_id = self.get_secure_cookie('user_id')
code, msg = DbOperator.insert_one_room(user_id, room_name, room_pwd, rooter_name, rooter_pwd, wifi_name, wifi_pwd,
electric_date, electric_fee, water_date, water_fee,
gas_date, gas_fee, net_date, net_fee, room_desc)
a_dict['code'] = code
a_dict['msg'] = msg
self.write(json.dumps(a_dict, ensure_ascii=False))
def get(self):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
json_text = DbOperator.query_plats()
self.write(json_text)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
room_id = self.get_argument('room_id')
states = self.get_argument('states')
json_text = DbOperator.save_room_states(room_id, states)
self.write(json_text)
def get(self):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
room_id = self.get_argument('room_id')
start_dt = self.get_argument('start_dt')
end_dt = self.get_argument('end_dt')
json_text = DbOperator.query_room_state(room_id, start_dt, end_dt)
self.write(json_text)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
service_name = self.get_argument("service_name")
off_set = self.get_argument("off_set")
limit = self.get_argument("limit")
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
text = DbOperator.query_all_monitor_base(service_name, off_set, limit)
self.write(text)
def get(self, *args, **kwargs):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
room_id = self.get_argument('room_id', None)
room_name = DbOperator.query_room_by_id(room_id)
if not room_name:
self.render('404.html')
return
self.render('order/add_order.html', login_user=login_user, room_id=room_id, room_name=room_name)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
if not login_user.user_right & UserRight.USER_MANAGER:
self.redirect("/")
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
user_id_list = self.get_argument("user_id_list")
text = DbOperator.delete_users(user_id_list)
self.write(text)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
if not login_user.user_right & UserRight.EDIT_MANAGER:
self.redirect("/")
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
service_id = self.get_argument('service_id')
text = DbOperator.delete_monitor_detail(service_id)
self.write(text)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
if not login_user.user_right & UserRight.EDIT_MANAGER:
self.redirect("/")
return
ssh_user = self.get_argument("ssh_user")
ssh_ip = self.get_argument("ssh_ip")
ssh_port = self.get_argument("ssh_port")
text = DbOperator.add_one_machine(ssh_user, ssh_ip, ssh_port)
self.write(text)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
room_name = self.get_argument('room_name')
sort_column = self.get_argument("sort_column")
desc_order = self.get_argument("desc_order")
off_set = self.get_argument("off_set")
limit = self.get_argument("limit")
user_id = self.get_secure_cookie('user_id')
text = DbOperator.query_room_list(user_id, room_name, sort_column, desc_order, off_set, limit)
self.write(text)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
if not login_user.user_right & UserRight.EDIT_MANAGER:
self.redirect("/")
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
machine = self.get_argument("machine")
off_set = self.get_argument("off_set")
limit = self.get_argument("limit")
text = DbOperator.query_machine_list(machine, off_set, limit)
self.write(text)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
if not login_user.user_right & UserRight.USER_MANAGER:
self.redirect("/")
return
user_name = self.get_argument("user_name")
user_email = self.get_argument("user_email")
user_pwd = self.get_argument("user_pwd")
user_right = self.get_argument("user_right")
text = DbOperator.add_one_user(user_name, user_email, user_pwd, user_right)
self.write(text)
def get(self):
login_user = self.get_login_user()
if not login_user:
return
if not login_user.user_right & UserRight.EDIT_MANAGER:
self.redirect("/")
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
service_id = self.get_argument('service_id')
monitor_detail = DbOperator.query_monitor_detail(service_id)
all_rely = DbOperator.query_all_monitor_base_v2(service_id)
all_machine = DbOperator.query_machine_list_v2()
if monitor_detail is None or all_rely is None or all_machine is None:
self.redirect('/')
return
self.render('monitor/edit_monitor.html',
login_user=login_user,
base=monitor_detail.base_info,
healthy=monitor_detail.healthy_check_list,
unhealthy=monitor_detail.unhealthy_check_list,
rely_id_set=set([item.id for item in monitor_detail.rely_service_list]),
all_rely=all_rely,
all_machine=all_machine)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
if not login_user.user_right & UserRight.EDIT_MANAGER:
self.redirect("/")
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
machine_id = self.get_argument("machine_id")
ssh_user = self.get_argument("ssh_user")
ssh_ip = self.get_argument("ssh_ip")
ssh_port = self.get_argument("ssh_port")
text = DbOperator.edit_machine(machine_id, ssh_user, ssh_ip, ssh_port)
self.write(text)
def get(self, *args, **kwargs):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
api = self.get_argument("api", None)
if not api:
self.render('order/order_list.html', login_user=login_user)
return
room_name = self.get_argument("room_name", None)
off_set = self.get_argument("off_set", None)
limit = self.get_argument("limit", None)
json_text = DbOperator.query_order_list(room_name, off_set, limit)
self.write(json_text)
def post(self):
a_dict = dict()
user_email = self.get_argument('user_email')
user_password = self.get_argument('user_password')
captcha_value = self.get_argument('captcha_value')
if not user_email or not user_password or not captcha_value:
a_dict['code'] = 1
a_dict['msg'] = 'empty input'
self.write(json.dumps(a_dict, ensure_ascii=False))
return
user_email = user_email.strip()
user_password = user_password.strip()
captcha_value = captcha_value.strip()
if captcha_value.lower() != self.get_secure_cookie('captcha_value').lower():
a_dict['code'] = 2
a_dict['msg'] = 'captcha error'
self.write(json.dumps(a_dict, ensure_ascii=False))
return
user = DbOperator.get_user_info(user_email)
if not user:
a_dict['code'] = 3
a_dict['msg'] = 'no this user'
self.write(json.dumps(a_dict, ensure_ascii=False))
return
m = hashlib.md5()
m.update(user_password)
input_password = m.hexdigest()
if input_password != user.user_pwd:
a_dict['code'] = 4
a_dict['msg'] = 'password error'
self.write(json.dumps(a_dict, ensure_ascii=False))
return
self.set_secure_cookie("user_id", str(user.id), expires_days=None)
self.set_secure_cookie("user_email", user.user_email, expires_days=None)
self.set_secure_cookie("user_name", user.user_name, expires_days=None)
self.set_secure_cookie("user_right", str(user.user_right), expires_days=None)
self.set_secure_cookie("last_time", str(time.time()), expires_days=None)
self.set_cookie("page_right", str(user.user_right), expires_days=None)
a_dict['code'] = 0
a_dict['msg'] = 'ok'
self.write(json.dumps(a_dict, ensure_ascii=False))
def post(self):
if Config.FAKE_LOGIN:
user_email = self.get_argument("user_email")
db_user = DbOperator.get_user_info(user_email)
if not db_user:
self.render("user/fake_login.html")
return
self.set_secure_cookie("user_email", db_user.user_email, expires_days=None)
if db_user.user_name:
self.set_secure_cookie("user_name", db_user.user_name, expires_days=None)
else:
self.set_secure_cookie("user_name", db_user.user_email, expires_days=None)
self.set_secure_cookie("user_right", str(db_user.user_right), expires_days=None)
self.set_secure_cookie("last_time", str(time.time()), expires_days=None)
self.set_cookie("page_right", str(db_user.user_right), expires_days=None)
self.redirect("/")
def post(self):
login_user = self.get_login_user()
if not login_user:
return
a_dict = dict()
old_pwd = self.get_argument('old_pwd')
new_pwd = self.get_argument('new_pwd')
if not new_pwd:
a_dict['code'] = 1
a_dict['msg'] = 'New password is empty'
self.write(json.dumps(a_dict, ensure_ascii=False))
return
code, msg = DbOperator.change_user_pwd(login_user.user_email, old_pwd, new_pwd)
a_dict['code'] = code
a_dict['msg'] = msg
self.write(json.dumps(a_dict, ensure_ascii=False))
def get(self):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
service_id = self.get_argument('service_id')
monitor_detail = DbOperator.query_monitor_detail(service_id)
if not monitor_detail:
self.redirect('/')
return
self.render('monitor/view_monitor.html',
login_user=login_user,
base=monitor_detail.base_info,
healthy=monitor_detail.healthy_check_list,
unhealthy=monitor_detail.unhealthy_check_list,
rely=monitor_detail.rely_service_list)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
user_name = self.get_argument('user_name')
user_count = DbOperator.get_user_count(user_name)
a_dict = dict()
if user_count is not None:
a_dict['code'] = 0
a_dict['msg'] = 'OK'
a_dict['count'] = user_count
else:
a_dict['code'] = 1
a_dict['msg'] = 'Internal error'
a_dict['count'] = -1
self.write(json.dumps(a_dict, ensure_ascii=False))
def post(self, *args, **kwargs):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
room_id = self.get_argument('room_id')
plat_id = self.get_argument('plat_id')
checkin_date = self.get_argument('check_in_date')
checkout_date = self.get_argument('check_out_date')
user_name = self.get_argument('user_name')
order_fee = self.get_argument('order_fee')
person_count = self.get_argument('person_count')
phone = self.get_argument('phone')
wechat = self.get_argument('wechat')
order_desc = self.get_argument('order_desc')
json_text = DbOperator.insert_one_order(room_id, plat_id, checkin_date, checkout_date, user_name, order_fee, person_count, phone, wechat,
order_desc)
self.write(json_text)
def post(self):
login_user = self.get_login_user()
if not login_user:
return
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
a_dict = dict()
user_name = self.get_argument('user_name')
if not user_name:
a_dict['code'] = 1
a_dict['msg'] = 'User name is empty'
self.write(json.dumps(a_dict, ensure_ascii=False))
return
code = DbOperator.change_user_name(login_user.user_email, user_name)
if code == 0:
self.set_secure_cookie("user_name", user_name, expires_days=None)
a_dict['code'] = 0
a_dict['msg'] = 'OK'
else:
a_dict['code'] = 2
a_dict['msg'] = 'Internal error'
self.write(json.dumps(a_dict, ensure_ascii=False))
def get(self):
if Config.FAKE_LOGIN:
# 本机fake登录
self.redirect('/fake_login')
return
# 线上真实登录
Logger.info(json.dumps(self.request.arguments, ensure_ascii=False), self.request.uri)
user_email = self.get_current_user()
if user_email:
if self.check_login_valid():
self.redirect("/")
return
code_from_auth = self.get_argument('code', None)
if not code_from_auth:
redirect_url = Config.OAUTH_AUTH_URL
redirect_url += '?appid=%s' % Config.OAUTH_APP_ID
redirect_url += '&response_type=code'
redirect_url += '&redirect_uri=%s' % quote(Config.OAUTH_REDIRECT_URL)
redirect_url += '&scope=user_info'
redirect_url += '&state=test'
self.redirect(redirect_url)
return
status, content = Login.get_access_token(code_from_auth)
if status != 200:
self.write(content)
return
Logger.info("get_access_token: [%s]" % content)
try:
a_dict = json.loads(content)
except:
Logger.error("parse token error: content[%s]" % content)
self.write(content)
return
access_token = a_dict.get("access_token", None)
openid = a_dict.get("openid", None)
status, content = Login.get_user_info(access_token, openid)
if status != 200:
self.write(content)
return
Logger.info("get_user_info: [%s]" % content)
try:
a_dict = json.loads(content)
except:
Logger.error("parse user_info error: contnet[%s]" % content)
self.write(content)
return
user_name = a_dict.get("name")
user_email = a_dict.get("email")
db_user = DbOperator.get_user_info(user_email)
if not db_user:
self.redirect('/refuse')
return
# 保存session
self.set_secure_cookie("user_email", user_email, expires_days=None)
self.set_secure_cookie("user_name", user_name, expires_days=None)
self.set_secure_cookie("user_right", str(db_user.user_right), expires_days=None)
self.set_secure_cookie("last_time", str(time.time()), expires_days=None)
self.set_cookie("page_right", str(db_user.user_right), expires_days=None)
# 重向定
self.redirect("/")
def __get_pie_column_data(self, start_date, end_date):
a_dict = DbOperator.query_network_list('', 0, -1)
a_network_list = list()
for item in a_dict['content']:
a_network_list.append(item['network_name'])
start_imp_list = list()
end_imp_list = list()
start_clk_list = list()
end_clk_list = list()
start_ctr_list = list()
end_ctr_list = list()
for network in a_network_list:
imp, clk = self.get_day_impression_click(network, start_date)
start_imp_list.append([network, imp])
start_clk_list.append([network, clk])
start_ctr_list.append(
[network, clk * 100.0 / imp if imp > 0 else 0])
for network in a_network_list:
imp, clk = self.get_day_impression_click(network, end_date)
end_imp_list.append([network, imp])
end_clk_list.append([network, clk])
end_ctr_list.append([network, clk * 100.0 / imp if imp > 0 else 0])
pie_data = dict()
# start date
pie_data['start_imp'] = {
'name': start_date.strftime('%Y年%m月%d日各渠道曝光量占比'),
'list': self.__handle_pie_list(start_imp_list)
}
pie_data['start_clk'] = {
'name': start_date.strftime('%Y年%m月%d日各渠道点击量占比'),
'list': self.__handle_pie_list(start_clk_list)
}
# end date
pie_data['end_imp'] = {
'name': end_date.strftime('%Y年%m月%d日各渠道曝光量占比'),
'list': self.__handle_pie_list(end_imp_list)
}
pie_data['end_clk'] = {
'name': end_date.strftime('%Y年%m月%d日各渠道点击量占比'),
'list': self.__handle_pie_list(end_clk_list)
}
# column data
column_data = dict()
column_data['start_ctr'] = {
'name': start_date.strftime('%Y年%m月%d日各渠道点击率'),
'list': self.__handle_column_list(start_ctr_list)
}
column_data['end_ctr'] = {
'name': end_date.strftime('%Y年%m月%d日各渠道点击率'),
'list': self.__handle_column_list(end_ctr_list)
}
return pie_data, column_data
def __main__():
# 设置编码
reload(sys)
sys.setdefaultencoding('utf-8')
# Do nothing
setting.description()
# 解析参数
options.parse_command_line()
if not Config.init(options.conf):
print 'parse %s error' % options.conf
return
if not Config.check():
return
# 设置程序名称
setproctitle.setproctitle('MTMonitorPlatServer')
# 不要输出日志到屏幕
logging.getLogger("tornado.access").propagate = False
logging.getLogger("tornado.application").propagate = False
logging.getLogger("tornado.general").propagate = False
logging.getLogger("process").propagate = False
logging.getLogger("report").propagate = False
logging.getLogger("third").propagate = False
# 初始化日志
Logger.init(Config.LOG_ENV, Config.LOG_TARGET, Config.LOG_NAME, Config.LOG_SIZE, Config.LOG_COUNT)
# 重定向tornado自带日志
logging.getLogger("tornado.access").addHandler(Logger.get_third_handler())
logging.getLogger("tornado.application").addHandler(Logger.get_third_handler())
logging.getLogger("tornado.general").addHandler(Logger.get_third_handler())
# 设置request日志
logging.getLogger("requests").setLevel(logging.WARNING)
# 打印启动日志
print "server is starting..."
Logger.info("server is starting...")
Logger.info("config.listen_port: %s" % Config.LISTEN_PORT)
Config.log_config()
# 初始化DB连接参数
if not DbOperator.init():
return
app = tornado.web.Application(
[
(r'/', RoomList),
(r'/refuse', RefuseHandler),
(r'/login', LoginHandler),
(r'/logout', LogoutHandler),
(r'/user_list', UserListHandler),
(r'/api_add_user', AddUserHandler),
(r'/api_del_user', DeleteUserHandler),
(r'/api_edit_user', EditUserHandler),
(r'/api_query_user', QueryUserListHandler),
(r'/personal', PersonalHandler),
(r'/get_user_count', GetUserCount),
(r'/api_change_user_name', ApiChangeUserName),
(r'/api_change_user_pwd', ApiChangeUserPwd),
(r'/room_plat', RoomPlat),
(r'/add_room', AddRoom),
(r'/room_list', RoomList),
(r'/edit_room', EditRoom),
(r'/room_state', RoomState),
(r'/captcha', Captcha),
(r'/order', Order),
(r'/order_list', OrderList),
(r'/dis', DisHandler),
],
cookie_secret=Config.LOGIN_COOKIE_SECRET,
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=False,
debug=Config.DEBUG_MODE
)
# http_server = tornado.httpserver.HTTPServer(app, ssl_options={
# 'certfile': '/Users/liyanguo/cluster/centos/work/room_manager/key/ssl.crt',
# 'keyfile': '/Users/liyanguo/cluster/centos/work/room_manager/key/ssl.key'
# })
# http_server.listen(433)
app.listen(Config.LISTEN_PORT, Config.LISTEN_HOST)
now = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
print '%s starting' % now
tornado.ioloop.IOLoop.current().start()
