def post(self):
# TODO: add sms login
is_valid, data = self.get_params_from_request(
request, SCHEMA['store_sessions_post'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
mobile = data['mobile']
password = data['password']
flag, store = self.db.find_by_condition('stores', {'mobile': mobile})
if not flag:
return '', 500
if len(store) == 0:
return self.error_msg(self.ERR['user_not_found'])
store = store[0]
store_id = store['id']
password_from_db = store['password']
salt = create_md5_key(config['secret'])
if not validate_hash_key(password, password_from_db, salt):
return self.error_msg(self.ERR['password_verification_failed'])
token = self.create_jwt({'accountId': store_id}, salt)
result = self.get_data_with_keys(
store, ('mobile', 'id', 'address', 'storeName'),
{'token': token.decode()})
return jsonify(result), 201
def get(self, store_id):
flag, tag = self.authenticate(request, store_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
params = request.args.to_dict()
flag, tag = self.str_to_int(params)
if not flag:
return self.error_msg(self.ERR['invalid_query_params'], tag)
is_valid, tag = self.validate_dict_with_schema(
params, SCHEMA['store_orders_get'])
if not is_valid:
return self.error_msg(self.ERR['invalid_query_params'], tag)
params['storeId'] = store_id
api_resp = requests.get('{0}/transactions/orders'.format(
self.endpoint['transactions']),
params=params)
resp_status = api_resp.status_code
if resp_status != 200 and resp_status != 400:
self.logger.error('request transactions server failed')
return '', 500
return jsonify(api_resp.json()), resp_status
def post(self, store_id):
is_valid, data = self.get_params_from_request(
request, SCHEMA['point_password_post'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
password = data['pointPassword']
flag, store = self.db.find_by_condition('pointPassword',
{'storeId': store_id})
if not flag:
return '', 500
if store:
point_password = store[0].get('pointPassword')
if point_password:
return self.error_msg(self.ERR['password_been_set'])
salt = create_md5_key(store_id)
hashed_password = create_hash_key(password, salt)
data_to_insert = {
'storeId': store_id,
'pointPassword': hashed_password,
}
result = self.db.create('pointPassword', data_to_insert)
if not result:
return '', 500
return jsonify(result), 201
def post(self):
is_valid, data = self.get_params_from_request(request,
SCHEMA['stores_post'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
mobile = data['mobile']
password = data['password']
sms_code = data.pop('smsCode', None)
redis_key = self.redis.REDIS_STRING['ssu'] + mobile + ':'
code_from_redis = self.redis.get_value(redis_key)
if code_from_redis != sms_code:
return self.error_msg(self.ERR['sms_code_verification_failed'])
condition = self.get_data_with_keys(data, ('address', 'storeName'))
flag, store_by_address = self.db.find_by_condition('stores', condition)
if not flag:
return '', 500
if store_by_address:
return self.error_msg(self.ERR['conflict_user_exist'])
flag, store_by_mobile = self.db.find_by_condition(
'stores', {'mobile': mobile})
if not flag:
return '', 500
if store_by_mobile:
account_status = store_by_mobile[0]['status']
if account_status == 'processing':
store_id = store_by_mobile[0]['id']
else:
return self.error_msg(self.ERR['conflict_user_exist'])
else:
data['status'] = 'processing'
store_by_address = self.db.create('stores', data)
if not store_by_address:
return '', 500
store_id = store_by_address['id']
salt = create_md5_key(config['secret'])
hashed_password = create_hash_key(password, salt)
flag, result = self.db.update(
'stores', {'id': store_id},
{'$set': {
'password': hashed_password,
'status': 'done'
}})
if not flag:
return '', 500
if not result:
return self.error_msg(self.ERR['not_found'])
return jsonify({'id': store_id}), 201
def get(self, store_id):
flag, tag = self.authenticate(request, store_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
api_resp = requests.get('{0}/transactions/coupons'.format(
self.endpoint['transactions']),
params={'storeId': store_id})
resp_status = api_resp.status_code
if resp_status != 200 and resp_status != 400:
return '', 500
return jsonify(api_resp.json()), resp_status
def get(self, store_id):
flag, tag = self.authenticate(request, store_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
api_resp = requests.get('{0}/accounts/stores/{1}/profile'.format(
self.endpoint['accounts'], store_id))
resp_status = api_resp.status_code
if resp_status != 200 and resp_status != 400:
self.logger.error('request accounts server failed')
return '', 500
return jsonify(api_resp.json()), resp_status
def get(self, user_id):
flag, tag = self.authenticate(request, user_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
api_resp = requests.get('{0}/transactions/user-coupons'.format(
self.endpoint['transactions']),
params={'userId': user_id})
resp_status = api_resp.status_code
if resp_status != 200 and resp_status != 400:
self.logger.error('request transactions server failed')
return '', 500
return jsonify(api_resp.json()), resp_status
def put(self, store_id):
is_valid, data = self.get_params_from_request(
request, SCHEMA['point_password_put'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
password = data['pointPassword']
salt = create_md5_key(store_id)
hashed_password = create_hash_key(password, salt)
data_to_update = {
'pointPassword': hashed_password
}
flag, result = self.db.update('pointPassword', {'storeId': store_id},
{'$set': data_to_update})
if not flag:
return '', 500
return jsonify(result), 200
def post(self):
is_valid, data = self.get_params_from_request(
request, SCHEMA['user_sessions_post'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
open_id = data['openId']
flag, user = self.db.find_by_condition('users', {'openId': open_id})
if not flag:
return '', 500
if len(user) == 0:
return self.error_msg(self.ERR['user_not_found'])
user = user[0]
user_id = user['id']
salt = create_md5_key(config['secret'])
token = self.create_jwt({'accountId': user_id}, salt)
return jsonify({'id': user_id, 'token': token.decode()}), 201
def get(self, store_id):
flag, tag = self.authenticate(request, store_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
api_resp = requests.get('{0}/accounts/qr-code'.format(
self.endpoint['accounts']),
params={'storeId': store_id})
resp_status = api_resp.status_code
if resp_status != 200 and resp_status != 400:
self.logger.error('request accounts service failed')
return '', 500
qr_code = api_resp.json()['QRCodes']
if qr_code:
result = qr_code[0]
else:
result = dict()
return jsonify(result), resp_status
def post(self, store_id):
flag, tag = self.authenticate(request, store_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
is_valid, data = self.get_params_from_request(
request, SCHEMA['store_discounts_post'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
data['storeId'] = store_id
api_resp = requests.post('{0}/transactions/discounts'.format(
self.endpoint['transactions']),
json=data)
resp_status = api_resp.status_code
if resp_status != 201 and resp_status != 400:
return '', 500
return jsonify(api_resp.json()), resp_status
def put(self, store_id):
flag, tag = self.authenticate(request, store_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
is_valid, data = self.get_params_from_request(
request, SCHEMA['store_profile_put'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
api_resp = requests.put('{0}/accounts/stores/{1}/profile'.format(
self.endpoint['accounts'], store_id),
json=data)
resp_status = api_resp.status_code
if resp_status != 200 and resp_status != 400:
self.logger.error('request accounts server failed')
return '', 500
return jsonify(api_resp.json()), resp_status
def put(self, store_id, coupon_id):
flag, tag = self.authenticate(request, store_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
is_valid, data = self.get_params_from_request(
request, SCHEMA['store_coupon_put'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
api_resp = requests.put('{0}/transactions/coupons/{1}'.format(
self.endpoint['transactions'], coupon_id),
json=data,
params={'storeId': store_id})
resp_status = api_resp.status_code
if resp_status != 200 and resp_status != 400:
return '', 500
return jsonify(api_resp.json()), resp_status
def post(self, user_id):
flag, tag = self.authenticate(request, user_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
is_valid, data = self.get_params_from_request(
request, SCHEMA['user_points_decrease_post'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
data['userId'] = user_id
api_resp = requests.post('{0}/transactions/points/decrease'.format(
self.endpoint['transactions']),
json=data)
resp_status = api_resp.status_code
if resp_status != 201 and resp_status != 400:
self.logger.error('request transaction service failed')
return '', 500
return jsonify(api_resp.json()), resp_status
def post(self, user_id):
flag, tag = self.authenticate(request, user_id,
create_md5_key(config['secret']))
if not flag:
return self.error_msg(tag)
is_valid, data = self.get_params_from_request(
request, SCHEMA['point_password_checker_post'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
store_id = data.pop('storeId')
api_resp = requests.post(
'{0}/accounts/stores/{1}/point-password/checker'.format(
self.endpoint['accounts'], store_id),
json=data)
resp_status = api_resp.status_code
if resp_status != 201 and resp_status != 400:
self.logger.error('request accounts service failed')
return '', 500
return jsonify(api_resp.json()), resp_status
def post(self, store_id):
is_valid, data = self.get_params_from_request(
request, SCHEMA['point_password_checker'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
password = data['pointPassword']
salt = create_md5_key(store_id)
hashed_password = create_hash_key(password, salt)
flag, store = self.db.find_by_condition('pointPassword',
{'storeId': store_id})
if not flag:
return '', 500
if not store:
return self.error_msg(self.ERR['have_no_password'])
password_from_db = store[0]['pointPassword']
if hashed_password != password_from_db:
return self.error_msg(self.ERR['password_verification_failed'])
return jsonify({'id': store_id}), 201
def post(self):
is_valid, data = self.get_params_from_request(
request, SCHEMA['store_reset_password_post'])
if not is_valid:
return self.error_msg(self.ERR['invalid_body_content'], data)
new_password = data['newPassword']
sms_code = data['smsCode']
mobile = data['mobile']
flag, store = self.db.find_by_condition('stores', {'mobile': mobile})
if not flag:
self.logger.error('get store from db failed')
return '', 500
if not store:
return self.error_msg(self.ERR['not_found'])
store_id = store[0]['id']
redis_key = self.redis.REDIS_STRING['srp'] + mobile + ':'
code_from_redis = self.redis.get_value(redis_key)
if code_from_redis != sms_code:
return self.error_msg(self.ERR['sms_code_verification_failed'])
salt = create_md5_key(config['secret'])
hashed_password = create_hash_key(new_password, salt)
flag, result = self.db.update('stores', {'id': store_id},
{'$set': {
'password': hashed_password
}})
if not flag:
return '', 500
if not result:
return self.error_msg(self.ERR['not_found'])
return jsonify({'id': store_id}), 201
