def create(self, data):
"""
Tao nguoi dung moi
:param data:
:return:
"""
if not isinstance(data, dict):
return
if not 'email' in data and not 'password' in data:
return
try:
print("first===========>")
exist_user = User.query.filter_by(email=data['email']).first()
print("second===========>")
if not exist_user:
user = self._parse_user(data=data, user=None)
db.session.add(user)
db.session.commit()
return result(
message='Create user successfully',
data=marshal(user, UserDto.model)
) # True, user # send_result(message='Create user successfully', data=marshal(user, UserDto.model_auth))
else:
return error(
message='User exists'
) # False, None # send_error(message='User already exists')
except Exception as e:
print(e.__str__())
return error(message='Could not create user. Check again.'
) # False, None # send_error(message=e)
def default_error_handler(e):
message = "An unhandled exception occured."
logger.exception(message)
print("=== Error: {}".format(e))
if app.config.get("DEBUG", False):
return error(e, status=status.ERROR_SERVER)
else:
return error(message, status=status.ERROR_SERVER)
def delete(self, data):
try:
comment = Comment.query.filter_by(commentID=data['commentID']).first()
if not comment:
return error(message='Comment not found')
else:
db.session.delete(comment)
db.session.commit()
return result(message='Delete comment successfully')
except Exception as e:
return error(message=e)
def logout_user(data):
if data:
auth_token = data.split(" ")[1]
else:
auth_token = ''
if auth_token:
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
return save_token(token=auth_token)
else:
return error(message=resp)
else:
return error(message='Provide a valid auth token')
def create(self, data):
if not isinstance(data, dict):
return error(message='Check data format!')
if not 'order_id' in data:
return error(message="Data does not consist information of buyer.")
try:
product = self._parse_product(data=data)
db.session.add(product)
db.session.commit()
return product
# return send_result(message="Create products successfully!")
except Exception as e:
# return send_error(message="Could not create product!")
print(e.__str__())
return None
def search(self, args):
if args is None or not isinstance(args, dict):
return error(
data=None,
message=
'Could not search over your criteria. Please check again.')
geo_long, geo_lat, country, city, street, max_distance, mode = None, None, None, None, None, None, None
if 'geo_long' in args:
geo_long = args['geo_long']
if 'geo_lat' in args:
geo_lat = args['geo_lat']
if 'country' in args:
country = args['country']
if 'city' in args:
city = args['city']
if 'street' in args:
street = args['street']
if 'max_distance' in args:
max_distance = args['max_distance']
if 'mode' in args:
mode = args['mode']
if geo_long is not None and geo_lat is not None and max_distance is not None:
users = self._get_by_geo(geo_long=geo_long,
geo_lat=geo_lat,
max_distance=max_distance,
mode=mode)
else:
users = self._get_by_address(country=country,
city=city,
street=street)
return result(data=marshal(users, UserDto.model)) # users
def delete(self, user_id):
try:
user = User.query.filter_by(user_id=user_id).first()
if not user:
return error(message='User not found'
) # False # send_error(message='User not found')
else:
db.session.delete(user)
db.session.commit()
return result(
message='User was deleted'
) # True # send_result(message='Delete user successfully')
except Exception as e:
print(e.__str__())
return error(message='Could not delete user'
) # False # send_error(message=e)
def get_list_blocked_user(self):
try:
list_blocked_user = User.query.filter_by(isblocked=True).all()
return result(data=marshal(list_blocked_user, UserDto.model))
except Exception as e:
print(e.__str__())
return error(message='Could not load list blocked users')
def update(self, object_id, data):
try:
user = User.query.filter_by(user_id=object_id).first()
if not user:
return error(message='User not found'
) # False # send_error(message='User not found')
else:
user = self._parse_user(data=data, user=user)
db.session.commit()
return result(
message='Update successfully',
data=marshal(user, UserDto.model)
) # True # send_result(message='Update user successfully', data=marshal(user, UserDto.model_auth))
except Exception as e:
print(e.__str__())
return error(message='Could not update user'
) # False # send_error(message=e)
def login_user(data, ip):
print('~~~ [login_user] ip', ip)
try:
login_attempt = LoginAttempts.query.filter_by(ip=ip).first()
if login_attempt is not None:
# print('\t ******* login_attempt', login_attempt, login_attempt.failed_login_attempts)
time_delt = delta_time(datetime.datetime.now(),
login_attempt.failed_login_time)
if login_attempt.failed_login_attempts == 3 and time_delt < 3:
print('\t ******* ERROR', login_attempt,
login_attempt.failed_login_attempts)
return error(
message=
'You\'ve reached limit tries. Please try again in {} minutes.'
.format(round(3 - time_delt, 2)))
# user = User.query.filter_by(email=cf.sanitize_data(data.get('email'))).first()
user = User.query.filter_by(email=data.get('email')).first()
print("data.get('password')", data.get('password'))
if user and user.check_password(data.get('password')):
auth_token = User.encode_auth_token(user.user_id)
if user.blocked:
return error(message='User has been blocked')
if auth_token:
return result(message='Successfully logged in',
data={'Authorization': auth_token.decode()})
else:
# ControllerUser.update()
if login_attempt is None:
# insert login_attempt of this ip
ip_login_attempt = LoginAttempts(ip=ip)
db.session.add(ip_login_attempt)
db.session.commit()
else:
if delta_time(datetime.datetime.now(),
login_attempt.failed_login_time) > 3:
login_attempt.failed_login_attempts = 1
else:
login_attempt.failed_login_attempts += 1
# print('\t ****** modify! login_attempt.failed_login_attempts', login_attempt.failed_login_attempts)
login_attempt.failed_login_time = datetime.datetime.now()
db.session.commit()
return error(message='Email or Password does not match')
except Exception as e:
return error(message=e)
def save_token(token):
blacklist_token = BlacklistToken(token=token)
try:
# insert token
db.session.add(blacklist_token)
db.session.commit()
return result(message='Successfully logged out.')
except Exception as e:
return error(message=e)
def get_logged_user(new_request):
auth_token = new_request.headers.get('Authorization')
if auth_token:
auth_token = auth_token.split(' ')[1]
resp = User.decode_auth_token(auth_token)
if not isinstance(resp, str):
user = User.query.filter_by(user_id=resp).first()
print(user)
res = {
'user_id': user.user_id,
'email': user.email,
'role': user.role,
'name': user.name
}
return result(data=res)
return error(message=resp)
else:
return error(message='Provide a valid auth token')
def decorated(*args, **kwargs):
print('[admin_token_required] request', request)
data, status = ControllerAuth.get_logged_user(request)
token = data.get('data')
if not token:
return data, status
role = token.get('role')
if role != 3:
return error('Admin token required')
return f(*args, **kwargs)
def get(self):
try:
list_comment = Comment.query.all()
list_comment = marshal(list_comment, DtoComment.comment)
# shipper = User.query.filter_by(userID=data['userID']).first()
for x in list_comment:
shipper = User.query.filter_by(userID=x['shipperID']).first().name
orderer = User.query.filter_by(userID=x['ordererID']).first().name
x['shipperName'] = shipper
x['ordererName'] = orderer
return result(data=list_comment)
except Exception as e:
return error(message=e)
def get(self):
"""
Return all users in database
:return:
"""
try:
users = User.query.all()
return result(data=marshal(users, UserDto.model))
# return users
except Exception as e:
print(e.__str__())
return error(message='Could not load users.'
) # None # send_error(message=e)
def post(self, item):
try:
parsed = parser.parse_args()
except:
return resp.error("model_name, start_date, end_date must be specified")
print parsed
if item not in PortfolioPerformance.__available_item_list:
return resp.error("Invalid item: {} ({})".format(item, PortfolioPerformance.__available_item_list))
with h5py.File(os.path.join(app.root_path, "tmp/sample.h5")) as h5:
date_list = h5["date_list"][:].tolist()
try:
start_index = date_list.index(parsed.start_date)
end_index = date_list.index(parsed.end_date)
except:
return resp.error("Invalid date: {}, {}".format(parsed.start_date, parsed.end_date))
date_list = date_list[start_index:end_index+1]
print start_index, end_index
if item == "return":
value_list = h5["performance/{}/pnl".format(parsed.model_name)][0][start_index:end_index+1] / 20e6
elif item == "tvr":
value_list = h5["performance/{}/tvr".format(parsed.model_name)][start_index:end_index+1]
elif item == "cum_return":
value_list = h5["performance/{}/pnl".format(parsed.model_name)][start_index:end_index+1] / 20e6
value_list[~np.isfinite(value_list)] = 0.0
value_list[0] = 0.0
value_list = np.cumsum(value_list)
else:
raise NotImplementedError
return resp.sucess({
"date_list": date_list,
"value_list": value_list
})
def create(self, data):
try:
comment = Comment(
content=data['content'],
rate=data['rate'],
ordererID=data['ordererID'],
shipperID=data['shipperID'],
time=datetime.datetime.utcnow()
)
db.session.add(comment)
db.session.commit()
return result(message='Create comment successfully', data=marshal(comment, DtoComment.comment))
except Exception as e:
return error(message=e)
def get_by_id(self, user_id):
user = User.query.filter_by(user_id=user_id).first()
if user is None:
return error(data="Could not find user by this id")
else:
role = user.role
if role.__eq__('user'):
pass
if role.__eq__('buyer'):
buyer_id = get_id(user_id=user.user_id, role=role)
user.buyer_id = buyer_id
if role.__eq__('supplier'):
supplier_id = get_id(user_id=user.user_id, role=role)
user.supplier_id = supplier_id
return result(data=marshal(user, UserDto.model)) # user
def login_user(data):
try:
user = User.query.filter_by(email=data.get('email')).first()
if user and user.check_password(data.get('password')):
auth_token = User.encode_auth_token(user.user_id)
if user.blocked:
return None # error(message='User has been blocked')
if auth_token:
role = user.role
if role.__eq__('user'):
pass
if role.__eq__('buyer'):
buyer_id = get_id(user_id=user.user_id, role=role)
print("I am here", buyer_id)
user.buyer_id = buyer_id
if role.__eq__('supplier'):
supplier_id = get_id(user_id=user.user_id, role=role)
user.supplier_id = supplier_id
return user # result(message='Successfully logged in', data={'Authorization': auth_token.decode()})
else:
return None # error(message='Email or Password does not match')
except Exception as e:
return error(message=e)
