def reply_salmon_run(requester,
request_time: float,
request_input: str,
txt: bool = True,
img: bool = True):
if "下" in request_input:
run = req_nex_salmon_run(request_time)
else:
run = req_salmon_run(request_time)
if run is None:
requester.send_msg("木有找到当前打工信息")
return
if txt:
if run.start_time <= request_time <= run.end_time:
remain_message = "剩余{}小时结束".format(
diff_hours(request_time, run.end_time))
else:
remain_message = "还有{}小时开始".format(
diff_hours(request_time, run.start_time))
requester.send_msg("打工: {rem}, 地图: {stage}, 武器: {weapon}".format(
rem=remain_message,
stage=dict_get(STAGES, run.stage.name),
weapon=" ".join(str(s) for s in list(map(
lambda w: dict_get(WEAPONS, w.name), run.weapons)))))
if img:
send_web_img(run.stage.img_url, requester)
remove_if_exist(TMP_IMG)
if combine_imgs(list(map(lambda w: download_img(w.img_url),
run.weapons)), TMP_IMG, vertical=False):
requester.send_image(TMP_IMG)
def post(self):
"""
Creates new user
:return: success or error dictionary
"""
try:
json_data = request.get_json(force=True)
email = dict_get(json_data, 'email')
if AppUser.get_by_email(email) is not None:
return _error('User with email %s already exists' % email)
password = dict_get(json_data, 'password')
passwordHash = _generate_hash(password)
firstName = dict_get(json_data, 'firstName')
lastName = dict_get(json_data, 'lastName')
role = dict_get(json_data, 'role')
result = AppUser.create(email, passwordHash, firstName, lastName,
role)
if result is not None:
del result['passwordHash']
return result
except Exception as e:
return _error('Error during creating a new user: %s' % e), 500
def post(self):
"""
Registers new user
:return: dictionary with error or sucess/access tokens
"""
try:
json_data = request.get_json(force=True)
email = dict_get(json_data, 'email')
if AppUser.get_by_email(email) is not None:
return _error('User with email %s already exists' % email)
password = dict_get(json_data, 'password')
passwordHash = _generate_hash(password)
firstName = dict_get(json_data, 'firstName')
lastName = dict_get(json_data, 'lastName')
# The very first registered user is an admin
userCount = AppUser.get_count()
role = 'ADMIN' if userCount == 0 else 'USER'
user = AppUser.create(email, passwordHash, firstName, lastName,
role)
return _ok_with_tokens_and_user(user)
except Exception as e:
print(e)
return _error('Error adding user: %s' % e), 500
def post(self):
"""
POST method.
Uploads the file anc creates the Takeoff.
:return: {'takeoff_id': takeoff_id} dictionary
"""
json_data = request.get_json(force=True)
filename = dict_get(json_data, 'filename', '')
content = dict_get(json_data, 'content', '')
takeoff = Takeoff.create_from_file(filename, content)
return {'takeoff_id': takeoff.takeoff_id}
def post(self):
"""
POST method.
Uses action field in the payload JSON object to understand what to do.
Right now only the drop_database action is supported.
:return: {'success': success, 'error': error} dictionary
"""
json_data = request.get_json(force=True)
action = dict_get(json_data, 'action', '')
success = True
error = ''
action_name = ''
try:
if action == 'drop_database':
action_name = 'dropping MongoDB database'
MongoUtil.drop_db()
else:
success = False
error = '[%s] action is not supported' % action
except Exception as e:
success = False
error = 'Error when %s : %s' % (action_name, e)
return {'success': success, 'error': error}
def reply_battle(requester,
mode: str,
msg_time: float,
request_input: str,
txt: bool = True,
img: bool = True):
query_time = msg_time
if "下" in request_input:
query_time = msg_time + (2 * HOURS_EPOCH) * request_input.count("下")
elif "小时后" in request_input:
index = request_input.index("小时后") - 1
num_char = request_input[index]
try:
parsed = int(num_char)
except ValueError:
parsed = TIME.get(request_input[index], 0)
query_time = msg_time + parsed * HOURS_EPOCH
schedule = req_schedule(mode, query_time)
if schedule is None:
requester.send_msg("木有找到当前模式信息")
return
if txt:
if schedule.start_time <= msg_time <= schedule.end_time:
remain_message = "剩余{}分钟结束".format(
diff_minutes(msg_time, schedule.end_time))
else:
remain_message = "还有{}分钟开始".format(
diff_minutes(msg_time, schedule.start_time))
requester.send_msg("{mode}: {type}模式, {rem}, 地图: {stage}".format(
mode=dict_get(MODES, mode),
type=dict_get(BATTLE_TYPES, schedule.mode),
rem=remain_message,
stage=" ".join(str(s) for s in
list(map(lambda s: dict_get(STAGES, s.name),
schedule.stages)))))
if img:
remove_if_exist(TMP_IMG)
if combine_imgs(list(map(lambda s: download_img(s.img_url),
schedule.stages)), TMP_IMG):
if os.path.isfile(TMP_IMG):
requester.send_image(TMP_IMG)
def post(self):
"""
Checks if user exists and password matches.
:return: dictionary with error or sucess/access tokens and user details
"""
try:
json_data = request.get_json(force=True)
email = dict_get(json_data, 'email')
password = dict_get(json_data, 'password')
user = AppUser.get_by_email(email)
if user is not None and _verify_hash(password,
user['passwordHash']):
return _ok_with_tokens_and_user(user)
else:
return _error('Invalid email/password')
except Exception as e:
return _error('Error during login: %s' % e), 500
def put(self, email):
"""
Updates user
:return: updated user or error dictionary
"""
try:
json_data = request.get_json(force=True)
password = dict_get(json_data, 'password')
passwordHash = _generate_hash(password)
firstName = dict_get(json_data, 'firstName')
lastName = dict_get(json_data, 'lastName')
role = dict_get(json_data, 'role')
result = AppUser.update(email, passwordHash, firstName, lastName,
role)
if result is not None:
del result['passwordHash']
return self._check(result, email)
except Exception as e:
return _error('Error during updating user: %s' % e), 500
def _upload_file(self, infile):
"""
Uploads the file with the given name.
:param string infile: path to file
:return: ID of the created Takeoff
"""
with open(infile, 'rb') as f:
byte_content = f.read()
base64_content = util.base64_encode(byte_content)
payload = dict(filename=infile, content=base64_content)
response = self.app.post('/upload_file', data=json.dumps(payload))
result = self._toJson(response)
takeoff_id = util.dict_get(result, 'takeoff_id', None)
return takeoff_id
def put(self, takeoff_id, floor_plan_number):
"""
PUT method.
Sets tiled mask for the takeoff floor plan with the given number.
:param string takeoff_id: ID of the takeoff to use
:param int floor_plan_number: number of the floor plan to update
:return: {'success': True} or None if takeoff or floor plan not found
"""
json_data = request.get_json(force=True)
tiled_mask = dict_get(json_data, 'tiled_mask', None)
if tiled_mask is None:
abort(400, 'No tiled_mask field supplied')
result = Takeoff.set_takeoff_floor_plan_tiled_mask(
takeoff_id, floor_plan_number, tiled_mask)
return self.check_takeoff(
result, takeoff_id,
'No Takeoff with ID=%s or floor plan #%s exists' %
(takeoff_id, floor_plan_number))
def put(self, takeoff_id, page_number):
"""
PUT method.
Sets bboxes for the takeoff page with the given number.
:param string takeoff_id: ID of the takeoff to use
:param int page_number: number of the page to update
:return: {'success': True} or None if takeoff or page not found
"""
json_data = request.get_json(force=True)
bboxes = dict_get(json_data, 'bboxes', None)
if bboxes is None:
abort(400, 'No bbox field supplied')
result = Takeoff.set_takeoff_page_bboxes(takeoff_id, page_number,
bboxes)
return self.check_takeoff(
result, takeoff_id,
'No Takeoff with ID=%s or page number %s exists' %
(takeoff_id, page_number))
def get_server_meta():
server_meta = dict_get(get_threadlocal(), ["server_meta"], {})
set_server_meta(server_meta)
return server_meta
def get_request_meta():
request_meta = dict_get(get_threadlocal(), ["request_meta"], {})
# write back dictionary in case it was newly created
set_request_meta(request_meta)
return request_meta
def get_request_id():
return dict_get(get_threadlocal(), ["request_meta", "request_id"], None)
def get_request_id():
return dict_get(get_threadlocal(), ["request_meta", "request_id"], None)
def get_server_meta():
server_meta = dict_get(get_threadlocal(), ["server_meta"], {})
set_server_meta(server_meta)
return server_meta
def get_request_meta():
request_meta = dict_get(get_threadlocal(), ["request_meta"], {})
# write back dictionary in case it was newly created
set_request_meta(request_meta)
return request_meta
