def update_user(id):
user = User.query.get_or_404(id)
data = request.get_json() or {}
if 'username' in data and data['username'] != user.username and \
User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if 'email' in data and data['email'] != user.email and \
User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email address')
user.from_dict(data, new_user=False)
db.session.commit()
return jsonify(user.to_dict())
def create_user():
data = request.get_json() or {}
if 'username' not in data or 'email' not in data or 'password' not in data:
return bad_request('must include username, email and password fields')
if User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email address')
user = User()
user.from_dict(data, new_user=True)
db.session.add(user)
db.session.commit()
response = jsonify(user.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_user', id=user.id)
return response
def create_post():
data = request.get_json() or {}
if 'body' not in data:
return bad_request(_("must include body"))
post = Post(body=data['body'], author=g.current_user)
db.session.add(post)
db.session.commit()
return jsonify(post.to_dict())
def create_user():
data = request.get_json() or {}
if 'username' not in data or 'email' not in data or 'password' not in data:
return bad_request(
_('must include username, email and password fields'))
if User.query.filter_by(username=data['username']).first():
return bad_request(_('please use a different username'))
if User.query.filter_by(email=data['email']).first():
return bad_request(_('please use a different email address'))
user = User()
user.from_dict(data, new_user=True)
db.session.add(user)
db.session.commit()
response = jsonify(user.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_user', id=user.id)
return response
def reset_password(token):
'''用户点击邮件中的链接，通过验证 JWT 来重置对应的账户的密码'''
data = request.get_json()
if not data:
return bad_request('You must post JSON data.')
if 'password' not in data or not data.get('password', None).strip():
return bad_request('Please provide a valid password.')
user = User.verify_reset_password_jwt(token)
if not user:
return bad_request(
'The reset password link is invalid or has expired.')
user.set_password(data.get('password'))
db.session.commit()
return jsonify({
'status': 'success',
'message': 'Your password has been reset.'
})
def skin_cancer_create_diagnosis():
"""Extracts cancer image from JSON data in the request.
Decodes a base64 encoded image into binary form before sending
to the project model. The image is also saved locally to be
used for prediction. Each time the method is called the
image is saved with the same name, overwritting the previous image.
Verification of binary image data is done by PIL library.
"""
if request.headers['Content-Type'] == 'application/json':
data = request.get_json() or {}
else:
data = request.form.to_dict() or {}
if not data.get('photo_base64'):
return bad_request(
'must include content type and photo data in request')
photo_base64 = data.get('photo_base64')
try:
diagnosis_photo = base64.b64decode(photo_base64, validate=True)
except binascii.Error:
return bad_request('failed to decode base64 string')
del data['photo_base64']
try:
imageBytes = BytesIO(diagnosis_photo)
image = Image.open(imageBytes)
image.save(r"app/projects/skin_cancer_analysis/image/data/image.jpg",
"JPEG")
content_type = image.format
image.close()
except IOError:
return bad_request('image file is not valid')
diagnosis = skinCancerModel(user_id=g.current_user.id,
content_type=content_type,
**data,
diagnosis_photo=diagnosis_photo)
diagnosis.save()
return jsonify(diagnosis), 201
def search_microcons():
'''
:return: 按时间降序返回分页微猜想集合
'''
q = request.args.get('q', '').strip()
if q == '':
return bad_request(
message='Enter keyword about micropub, or microcon.')
if len(q) < 3:
return bad_request(message='Keyword must be 3 characters or more.')
topic = request.args.get('tag', '').strip().split(' ')
status = request.args.get('status', type=str)
if not status:
return bad_request('Please provide the status of microcons.')
status = status.split(',')
for item in status:
if item.strip() not in ['0', '1', '-1']:
return bad_request(
'Please provide valid status of microcons, 0, 1 or -1.')
q_list = []
for item in status:
q_list.append(Microcon.query.filter(Microcon.status == int(item)))
final_query = q_list[0]
for i in range(1, len(q_list)):
final_query = final_query.union(q_list[i])
page = request.args.get('page', 1, type=int)
per_page = min(
request.args.get('per_page',
current_app.config['POSTS_PER_PAGE'],
type=int), 100)
data = Microcon.to_collection_dict(
final_query.query.whooshee_search(q).filter(
Microcon.tag.in_(topic)).order_by(Microcon.timestamp.desc()), page,
per_page, 'api.get_microcons')
# 是否被当前用户关注或点赞
for item in data["items"]:
item["is_liked"] = g.current_user.id in item["likers_id"]
item["is_collected"] = g.current_user.id in item["collecters_id"]
return jsonify(data)
def search_recommend_micropubs_for_user(id):
'''
推荐的微证据
'''
q = request.args.get('q', '').strip()
if q == '':
return bad_request(
message='Enter keyword about micropub, or microcon.')
if len(q) < 3:
return bad_request(message='Keyword must be 3 characters or more.')
topic = request.args.get('tag', '').strip().split(' ')
user = User.query.get_or_404(id)
if g.current_user != user:
return error_response(403)
k = request.args.get('k', 5, type=int) # 邻居个数
n = request.args.get('n', 10, type=int) # 推荐个数
model = CF(type=0, k=k, n=n)
recommend_list = model.recommend_by_user(user)
# 用热点补齐 n 个
if len(recommend_list) < n:
micropubs = Micropub.query.order_by(Micropub.views.desc()).all()
for micropub in micropubs:
if micropub not in recommend_list:
recommend_list.append(micropub)
if len(recommend_list) == n:
break
micropubs_ids = [micropub.id for micropub in recommend_list]
page = request.args.get('page', 1, type=int)
per_page = min(
request.args.get('per_page',
current_app.config['POSTS_PER_PAGE'],
type=int), 100)
data = Micropub.to_collection_dict(
Micropub.query.whooshee_search(q).filter(
Micropub.tag.in_(topic)).filter(Micropub.id.in_(micropubs_ids)),
page,
per_page,
'api.get_recommend_micropubs_for_user',
id=id)
return jsonify(data)
def add_car():
from cars.car import CarBase
if not g.current_user.is_admin():
return bad_request('You don\'t have permission to perform this action')
from cars.parts import (Model, Gearbox, EngineCapacity, Colour)
data = request.get_json() or {}
required_fields = ['model', 'colour', 'engine_capacity', 'gearbox']
if not all(required_field in data for required_field in required_fields):
return bad_request(
'Must include `model`, `colour`, `engine_capacity` and `gearbox` fields'
)
if not Model.query.filter_by(id=data['model']).first():
return bad_request('Model not found. Please, use existing model')
if not Colour.query.filter_by(id=data['colour']).first():
return bad_request('Colour not found. Please, use existing colour')
if not EngineCapacity.query.filter_by(id=data['engine_capacity']).first():
return bad_request(
'Engine capacity not found. Please, use existing Engine capacity')
if not Gearbox.query.filter_by(id=data['gearbox']).first():
return bad_request('Gearbox not found. Please, use existing gearbox')
car = CarBase.from_dict(data)
if car.is_already_exists():
return bad_request('Car already exists.')
try:
car.save_car()
except ProgrammingError:
return error_response(400, "Unexpected error occurred")
response = jsonify(data)
response.status_code = 201
return response
def update_user(id):
user = User.query.get_or_404(id)
data = request.get_json() or {}
if 'username' in data and data['username'] != user.username and \
User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if 'email' in data and data['email'] != user.email and \
User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email address')
user.from_dict(data, new_user=False)
db.session.commit()
###Michael: note we only seem to commit here, we don't add
return jsonify(user.to_dict())
###Michael: Concept is you login to get the tokens, and once you get the tokens you don't have to keep relogging in,
### token basically verifies you.
def update_category(category_id):
category = Categories.query.get_or_404(category_id)
data = request.get_json() or {}
if 'category_name' in data and Categories.query.filter_by(
category_name=data['category_name']).first():
return bad_request('please use a different category_name')
category.from_dict(data, new_category=False)
db.session.commit()
return jsonify(category.to_dict())
def add_room():
data = request.get_json() or {}
if 'name' not in data or 'gpsposition' not in data:
return bad_request('must include roomname and gpsposition')
if db.session.query(Room).filter_by(name=data['name'].upper()).first():
return bad_request('room aready existing')
else:
# add room with points
room = Room()
room.name = data['name'].upper()
room.gpsposition = data['gpsposition']
room.points = data['points']
db.session.add(room)
db.session.commit()
response = jsonify(room.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.add_room', id=room.id)
return response
def unfollow(id):
'''取消关注一个用户'''
user = User.query.get_or_404(id)
if g.current_user == user:
return bad_request('You cannot unfollow yourself.')
if not g.current_user.is_following(user):
return bad_request('You are not following this user.')
g.current_user.unfollow(user)
# 给该用户发送新粉丝通知(需要自动减1)
user.add_notification('unread_follows_count', user.new_follows())
db.session.commit()
username = user.name if user.name else user.username
return jsonify({
'status':
'success',
'message':
_('You are not following %(username)s anymore.', username=username)
})
def create_user():
data = request.get_json() or {}
if 'username' not in data or 'email' not in data or 'password' not in data:
return bad_request('must include username, email and password fields')
if User.query.filter_by(username=data['username']).first():
return bad_request('that username is already taken')
if User.query.filter_by(email=data['email']).first():
return bad_request('that email address is already registered')
user = User()
user.from_dict(data, new_user=True)
db.session.add(user)
db.session.commit()
response = jsonify(user.to_dict())
response.status_code = 201
# the HTTP protocol requires that a 201 response includes a Location
# header that is set to the URL of the new resource.
response.headers['Location'] = url_for('api.get_user', id=user.id)
return response
def new_backup_event():
data = request.get_json() or {}
if ('cluster_id' not in data or 'database_id' not in data
or 'scheduled' not in data):
return bad_request(
'must include cluster_id, database_id and scheduled fields')
if 'timecreated' not in data:
data['timecreated'] = datetime.datetime.utcnow
if not Cluster.query.filter_by(id=data['cluster_id']).first():
return bad_request('please use a valid cluster identifier')
if not Database.query.filter_by(id=data['database_id']).first():
return bad_request('please use a valid database identifier')
bh = BackupHistory()
bh.from_dict(data)
db.session.add(bh)
db.session.commit()
return jsonify(bh.to_dict())
def create_account():
'''
Create new Account
'''
data = request.get_json() or {}
if 'account_id' not in data:
return bad_request('must include account_id')
if Account.query.filter_by(account_id=data['account_id']).first():
return bad_request('account_id already exists')
account = Account()
account.from_dict(data)
db.session.add(account)
db.session.commit()
response = jsonify(account.to_dict())
response.status_code = 201
response.headers['Location'] = url_for(
'api.get_account', account_id=account.account_id)
return response
def create_music_item():
data = request.get_json() or {}
user = token_auth.current_user()
if 'resource_type' not in data or 'resource_id' not in data:
return bad_request('must include resource type and resource id fields')
music_item = MusicItem.query.filter_by(resource_type=data['resource_type'],
resource_id=data['resource_id']).first()
if music_item:
if music_item.private == False:
return bad_request('Music video already publicly avaliable')
if user.is_in_private_list(music_item):
return bad_request('Music video is already in private list')
if music_item is None:
music_item = MusicItem()
music_item.from_dict(data, private=True)
user.create_private_music_item(music_item)
db.session.commit()
return '', 201
def create_message():
'''
Create new Message
'''
data = request.get_json or {}
if 'message_id' not in data:
return bad_request('must include message_id')
if Message.query.filter_by(message_id=data['message_id']).first():
return bad_request('message_id already exists')
message = Message()
message.from_dict(data)
db.session.add(message)
db.session.commit()
response = jsonify(message.to_dict())
response.status_code = 201
response.headers['Location'] = url_for(
'api.get_message', message_id=message.message_id)
return response
def train_mode():
"""开启训练，返回开启训练信号"""
data = request.get_json()
if not data:
return bad_request('You must post JSON data.')
model_type = data.get('model_type')
name = data.get('name')
if model_type=='dl':
return jsonify('开启训练!')
def update_answer(id):
data = request.get_json() or {}
answer = Answer.query.get_or_404(id)
if 'response' in data and data['response'] != answer.response and Question.query.filter_by(
name=data['response']).first():
return bad_request('please use a different response')
answer.from_dict(data)
db.session.commit()
return jsonify(answer.to_dict())
def create_user():
"""
This route should create a new user and return its informations
"""
data = request.get_json() or {}
if 'userid' not in data or 'password' not in data or 'gender' not in data or 'name' not in data or 'access' not in data:
return bad_request('must include id, password, gender, name and access fields')
if User.query.filter_by(userid=data['userid']).first():
return bad_request('please use a different userid')
user = User()
user.from_dict(data, new_user=True)
db.session.add(user)
db.session.commit()
response = jsonify(user.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_user', id=user.id)
return response
def show_followers(username):
u = User.query.filter_by(username=username).first()
if u is None:
return bad_request('User does not exist.')
data = []
all_followers = u.followers.all()
for f in all_followers:
data.append(f.username)
return jsonify({"followers": data})
def get_user_history_messages(id):
'''取得我和from用户之间的私信记录'''
user = User.query.get_or_404(id)
if g.current_user != user:
return bad_request(403)
page = request.args.get('page',1,type=int)
per_page = request.args.get('per_page',10000,type=int)
from_id = request.args.get('from',type=int)
if not from_id:
return bad_request('from_id is None')
recived = user.messages_received.filter_by(sender_id=from_id)
sent = user.messages_sent.filter_by(recipient_id=from_id)
history_messages = recived.union(sent).order_by(Message.timestamp)
data = user.to_collection_dict(
history_messages,
page,per_page,'/api.get_user_history_messages',id=id
)
return jsonify(data)
def follow(id):
'''开始关注一个用户'''
user = User.query.get_or_404(id)
if g.current_user == user:
return bad_request(_('You cannot follow yourself.'))
if g.current_user.is_following(user):
return bad_request(_('You have already followed that user.'))
g.current_user.follow(user)
# 给该用户发送新粉丝通知
user.add_notification('unread_follows_count', user.new_follows())
db.session.commit()
username = user.name if user.name else user.username
return jsonify({
'status':
'success',
'message':
_('You are now following %(username)s.', username=username)
})
def update_post(id):
post = Post.query.get_or_404(id)
data = request.get_json()
if not data:
return bad_request('You must post JSON data.')
message = {}
if 'title' not in data or not data.get('title', None):
message['title'] = 'Title is required.'
elif len(data.get('title')) > 255:
message['title'] = 'Title must less than 255 characters.'
if 'body' not in data or not data.get('body'):
message['body'] = 'Body is required.'
if message:
return bad_request(message)
post.from_dict(data)
db.session.commit()
return jsonify(post.to_dict())
def modify_user(id):
user = User.query.get_or_404(id)
data = request.get_json()
if not data:
return bad_request('You must post JSON data')
message = {}
if 'username' in data and not data.get('username', None):
message['username'] = '******'
if 'password' in data and not data.get('password', None):
message['password'] = '******'
if User.query.filter_by(username=data.get('username', None)).first():
message['username'] = '******'
if message:
return bad_request(message)
user.json_to_dict(data, new_user=False)
db.session.commit()
return jsonify(user.dict_to_json())
def update_post(id):
data = request.get_json() or None
if (data == None):
return bad_request('Error: Empty data')
if 'body' not in data:
logging.error('%s raised an error', data)
return bad_request(
'Error: must include post body fields: {}'.format(data))
post = Post.query.get_or_404(id)
post.from_dict(data)
db.session.add(post)
db.session.commit()
response = jsonify(post.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_post', id=post.id)
return response
def create_user():
# only admins can add users
if current_user.is_authenticated and not current_user.is_admin:
return bad_request("user doesn't have admin rights")
data = request.get_json() or {}
if 'username' not in data or 'password' not in data or 'badge_id' not in data:
return bad_request(
'must include username, badge_id and password fields')
if User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
user = User()
user.from_dict(data, new_user=True)
db.session.add(user)
db.session.commit()
response = jsonify(user.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_user', id=user.id)
return response
def edit_category(id):
category = Category.query.get_or_404(id)
data = request.get_json() or {}
if 'name' in data and data['name'] != category.name and \
Category.query.filter_by(name=data['name']).first():
return bad_request('please use a different name')
category.from_dict(data)
db.session.commit()
return jsonify(category.to_dict())
def create_domain():
'''
Create new Domain
'''
data = request.get_json() or {}
if 'domain_id' not in data and 'account_id' not in data:
return bad_request('must include domain_id and account_id')
if Domain.query.filter_by(domain_id=data['domain_id']).first():
return bad_request('domain_id already exists')
domain = Domain()
domain.from_dict(data)
db.session.add(domain)
db.session.commit()
response = jsonify(domain.to_dict())
response.status_code = 201
response.headers['Location'] = url_for(
'api.get_domain', domain_id=domain.domain_id)
return response
def update_user(id):
user = User.query.get_or_404(id)
data = request.get_json() or {}
if 'email' in data and data['email'] != user.email and \
User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email address')
user.from_dict(data, new_user=False)
db.session.commit()
return jsonify(user.to_dict())
def create_user():
"""注册新用户"""
# Flask提供request.get_json()方法从请求中提取JSON并将其作为Python结构返回。 如果在请求中没有找到JSON数据，该方法返回None
data = request.get_json() or {}
if 'username' not in data or 'email' not in data or 'password' not in data:
return bad_request('must include username, email and password fields')
if User.query.filter_by(username=data['username']).first():
return bad_request('please use a different username')
if User.query.filter_by(email=data['email']).first():
return bad_request('please use a different email address')
user = User()
user.from_dict(data, new_user=True)
db.session.add(user)
db.session.commit()
response = jsonify(user.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_user', id=user.id)
return response
def a():
query = request.args.get('domain')
if query:
domain = query
else:
http_request = request.json
result = {}
if not request.json:
abort(500)
domain = http_request.get('domain')
if not domain:
return bad_request()
result_domain = redis_store.get(domain)
province = get_ip_locality(request.remote_addr)
if result_domain:
if result_domain == '0':
a_record = redis_store.get('%s_%s' % (domain, province))
matched = True
if not a_record:
invalid_province_domain = Domain.query.filter_by(domain=domain).first()
a_record = IP.query.filter_by(domain_id=invalid_province_domain.id).first().ip
matched = False
result = {domain: a_record,
province: matched}
elif result_domain:
ip_list = pickle.loads(redis_store.get(domain))
priority_list = pickle.loads(redis_store.get('%s_priority' % domain))
index = random.choice(priority_list)
result = {domain: ip_list[index],
'index': index}
else:
return bad_request()
return jsonify(result)
else:
return bad_request()
def update_workspace(workspace, storage=None):
fields = request.get_json(silent=True) or {}
for k in request.form.keys():
fields[k] = request.form.get(k, type=str)
if not 'code' in fields:
file = request.files.get('code', None)
if file:
fields['code'] = file.read().decode("utf-8")
if len(request.args) > 0:
return bad_request('invalid update parameters')
with workspaces.find_or_404(workspace) as w:
if storage is None:
w.update(**fields)
else:
s = w.storage[storage]
with s as s:
s.update(**fields)
return {'status': 200, 'message': 'updated' }
