def follower():
auth = request.headers.get('Authorization')
auth_user_id = Auth.identify(auth)
# Authorization header不正确
if auth_user_id is None:
result = return_status(-2)
return jsonify(result)
# 获取用户
user = User()
user.set_user_id(auth_user_id)
user_dao = UserDAO()
try:
retrieve_user = user_dao.retrieve(user)
except:
result = return_status(-2)
return jsonify(result)
# 用户不存在
if retrieve_user is None:
result = return_status(-1)
return jsonify(result)
follower_dao = FollowerDAO()
try:
followers = follower_dao.retrieve(retrieve_user.get_user_id())
results = return_follower(followers)
return jsonify(results)
except:
result = return_status(-2)
return jsonify(result)
def deleteUser(self, uid):
dao = UserDAO ()
if not dao.getUserById (uid):
return jsonify (Error="User not found."), 404
else:
dao.delete (uid)
return jsonify (DeleteStatus="OK"), 200
def getNumberMessagesByUserId(self, id):
dao = UserDAO()
result = dao.getNumberMessagesByUserId(id)
if not result:
return jsonify(Error="NOT FOUND"), 404
else:
return jsonify(NumberMessages=result)
def updateUser(self, userDic, userAddressDic):
dao = UserDAO ()
if not dao.getUserById (userDic['uid']):
return jsonify (Error="Resource not found."), 404
else:
if len (userDic) != 4 & len (userAddressDic) != 7:
return jsonify (Error="Malformed update request"), 400
else:
uid = userDic['uid']
uname = userDic['uname']
ulast = userDic['ulast']
utype = userDic['utype']
uaddress = userAddressDic['uaddress']
ucity = userAddressDic['ucity']
uregion = userAddressDic['uregion']
uzip = userAddressDic['uzip']
ustate = userAddressDic['ustate']
loclat = userAddressDic['loclat']
loclon = userAddressDic['loclon']
if uid and uname and ulast and utype and uaddress and ucity and uregion and uzip and ustate and loclat and loclon:
uidout = dao.update (uid, uname, ulast, utype, uaddress, ucity, uregion, uzip, ustate, loclat, loclon)
result = self.build_alluserinfo_dict2 (uidout, uname, ulast, utype, uaddress, ucity, uregion, uzip,
ustate, loclat, loclon)
return jsonify (User=result), 201
else:
return jsonify (Error="Unexpected attributes in put request"), 400
def getUserByState(self, ustate):
dao = UserDAO ()
user_list = dao.getUserByState (ustate)
result_list = []
for row in user_list:
result = self.build_alluserinfo_dict (row)
result_list.append (result)
return jsonify (result_list)
def getUserByRegion(self, uregion):
dao = UserDAO ()
user_list = dao.getUserByRegion (uregion)
result_list = []
for row in user_list:
result = self.build_alluserinfo_dict (row)
result_list.append (result)
return jsonify (result_list)
def getAllSuppliers(self):
dao = UserDAO()
suppliers_list = dao.getAllSuppliers()
result_list = []
for row in suppliers_list:
result = self.build_alluserinfo_dict(row)
result_list.append(result)
return jsonify(Suppliers=result_list)
def getAllCustomers(self):
dao = UserDAO()
customers_list = dao.getAllCustomers()
result_list = []
for row in customers_list:
result = self.build_alluserinfo_dict(row)
result_list.append(result)
return jsonify(Customers=result_list)
def getUserById(self, uid):
dao = UserDAO()
row = dao.getUserById(uid)
if not row:
return jsonify(Error="User Not Found"), 404
else:
result = self.build_alluserinfo_dict(row)
return jsonify(result)
def getUserByLastname(self, ulast):
dao = UserDAO ()
user_list = dao.getUserByLastname (ulast)
result_list = []
if not user_list:
return jsonify (Error="Customers Not Found"), 404
else:
result = self.build_alluserinfo_dict (user_list)
return jsonify (result)
def getAllUsers(self):
dao = UserDAO()
result = dao.getAllUsers()
if not result:
return jsonify(Error="NOT FOUND"), 404
mapped_result = []
for r in result:
mapped_result.append(self.mapToDict(r))
return jsonify(Users=mapped_result)
def getAllChatsByUserId(self, id):
dao = UserDAO()
result = dao.getAllChatsByUserId(id)
if not result:
return jsonify(Error="NOT FOUND"), 404
mapped_result = []
for r in result:
mapped_result.append(self.maptoChatDict(r))
return jsonify(Chats=mapped_result)
def getInformationOfUserByUsername(self, uname):
dao = UserDAO()
result = dao.getInformationOfUserByUsername(uname)
if not result:
return jsonify(Error="NOT FOUND"), 404
mapped_result = []
for r in result:
mapped_result.append(self.mapToDict2(r))
return jsonify(UserInfo=mapped_result)
def upload_homepage():
auth = request.headers.get('Authorization')
auth_user_id = Auth.identify(auth)
# Authorization header不正确
if auth_user_id is None:
result = return_status(-2)
return jsonify(result)
# 获取用户
user = User()
user.set_user_id(auth_user_id)
user_dao = UserDAO()
try:
retrieve_user = user_dao.retrieve(user)
except:
result = return_status(-2)
return jsonify(result)
# 用户不存在
if retrieve_user is None:
result = return_status(-1)
return jsonify(result)
# 设置路径
folder_path = 'background/' + str(auth_user_id)
mkdir(folder_path)
information = Information()
path = folder_path + '/background.jpg'
information.set_user_id(auth_user_id)
information.set_background_photo(path)
# 读取背景图片
try:
homepage = request.get_data()
if homepage is None:
return "上传的图片为空"
with open(path, 'wb') as f:
f.write(homepage)
except:
result = return_status(-2)
return jsonify(result)
# 数据库修改
information_dao = InformationDAO()
try:
result = information_dao.update_background_photo(information)
if result is not None:
result = return_homepage(result, path)
return jsonify(result)
else:
result = return_status(-2)
return jsonify(result)
except:
result = return_status(-2)
return jsonify(result)
def get_mylike():
auth = request.headers.get('Authorization')
auth_user_id = Auth.identify(auth)
# Authorization header不正确
if auth_user_id is None:
result = return_status(-2)
return jsonify(result)
user_id = request.args.get('userid')
if user_id is None:
return "信息不完整"
user_id = int(user_id)
# 获取用户
user = User()
user.set_user_id(user_id)
user_dao = UserDAO()
try:
retrieve_user = user_dao.retrieve(user)
except:
result = return_status(-2)
return jsonify(result)
# 用户不存在
if retrieve_user is None:
result = return_status(-1)
return jsonify(result)
my_like_work_ids = user_dao.get_my_like(retrieve_user)
my_like_works = WorkDAO().list(my_like_work_ids)
start = request.args.get('start')
if start is None:
return "信息不完整"
start = int(start)
count = request.args.get('count')
if count is None:
return "信息不完整"
count = int(count)
type = request.args.get('type')
if type is None:
return "信息不完整"
type = str(type)
if type == 'home':
result = return_home_my_like(my_like_works, start, count)
return jsonify(result)
if type == 'detail':
result = return_detail_my_like(my_like_works, start, count)
return jsonify(result)
else:
return "信息不正确"
def modifyInformation():
auth = request.headers.get('Authorization')
auth_user_id = Auth.identify(auth)
# Authorization header不正确
if auth_user_id is None:
result = return_status(-2)
return jsonify(result)
# 获取用户
user = User()
user.set_user_id(auth_user_id)
user_dao = UserDAO()
try:
retrieve_user = user_dao.retrieve(user)
except:
result = return_status(-2)
return jsonify(result)
# 用户不存在
if retrieve_user is None:
result = return_status(-1)
return jsonify(result)
information = Information()
information.set_user_id(auth_user_id)
data = request.get_json()
if 'NickName' not in data:
return "上传的信息不完整"
nick_name = data['NickName']
nick_name = str(nick_name)
information.set_nick_name(nick_name)
if 'Avatar' not in data:
return "上传的信息不完整"
avatar = data['Avatar']
avatar = str(avatar)
information.set_avatar(avatar)
if 'Signature' not in data:
return "上传的信息不完整"
signature = data['Signature']
signature = str(signature)
information.set_signature(signature)
if 'BackgroundPhoto' not in data:
return "上传的信息不完整"
background_photo = data['BackgroundPhoto']
background_photo = str(background_photo)
information.set_background_photo(background_photo)
information_dao = InformationDAO()
result = information_dao.update(information)
result = return_status(result)
return jsonify(result)
def getCredentials(self, form):
if len(form) != 2:
return jsonify(Error="Malformed post request"), 400
username = form['username']
password = form['password']
if not username or not password:
return jsonify(Error="Unexpected attributes in post request"), 400
dao = UserDAO()
result = dao.getCredentials(username, password)
return jsonify(User=self.mapToDict3(result))
def getResourcesBySupplierId(self, uid):
dao = UserDAO()
if not dao.getResourcesBySupplierId(uid):
return jsonify(Error="ResourcesBySupplier Not Found"), 404
resources_list = dao.getResourcesBySupplierId(uid)
result_list = []
for row in resources_list:
result = self.getResourceBySupllierIDdic(row)
result_list.append(result)
return jsonify(ResourcesBySupplier=result_list)
def getMessagesByUserId(self, id):
dao = UserDAO()
result = dao.getMessagesByUserId(id)
r = []
if not result:
return jsonify(Error="NOT FOUND"), 404
else:
for m in result:
r.append(self.maptoDicMessage(m))
return jsonify(Messages=r)
def get_myworks():
auth = request.headers.get('Authorization')
auth_user_id = Auth.identify(auth)
# Authorization header不正确
if auth_user_id is None:
result = return_status(-2)
return jsonify(result)
user_id = request.args.get('userid')
if user_id is None:
return "信息不完整"
# 获取用户
user = User()
user.set_user_id(user_id)
user_dao = UserDAO()
try:
retrieve_user = user_dao.retrieve(user)
except:
result = return_status(-2)
return jsonify(result)
# 用户不存在
if retrieve_user is None:
result = return_status(-1)
return jsonify(result)
type = request.args.get('type')
if type is None:
return "信息不完整"
type = str(type)
top = request.args.get('top')
if top is None:
return "信息不完整"
top = str(top)
work_dao = WorkDAO()
works = work_dao.retrieve(user_id)
if type == 'home':
if top is 'true' or top is 'True':
pass
else:
result = return_home(works)
return jsonify(result)
if type == 'detail':
if top is 'true' or top is 'True':
pass
else:
result = return_detail(works)
return jsonify(result)
else:
return "信息不正确"
def login():
data = request.get_json()
if 'phone' not in data or 'password' not in data:
return "信息缺失"
phone = data['phone']
password = data['password']
# 判断电话号码是否为空
if phone is None:
return "The phone number is empty!"
# 判断密码是否为空
if password is None:
return "The password is empty!"
user = User()
user.set_phone(phone)
user.set_password(password)
try:
user = UserDAO().retrieve(user)
except:
return "Server Failure!"
# 用户不存在
if user is None:
result = return_status(-1)
return jsonify(result)
# 授权
result = Auth.authorize(user)
return jsonify(result)
def follow():
auth = request.headers.get('Authorization')
auth_user_id = Auth.identify(auth)
# Authorization header不正确
if auth_user_id is None:
result = return_status(-2)
return jsonify(result)
# 获取用户
user = User()
user.set_user_id(auth_user_id)
user_dao = UserDAO()
try:
retrieve_user = user_dao.retrieve(user)
except:
result = return_status(-2)
return jsonify(result)
# 用户不存在
if retrieve_user is None:
result = return_status(-1)
return jsonify(result)
data = request.get_json()
if 'UserID' not in data or 'Cancel' not in data:
return "信息缺失"
user_id = data['UserID']
cancel_follow = data['Cancel']
follow_dao = FollowDAO()
if cancel_follow == 'True' or cancel_follow == 'true' or cancel_follow is True:
follow_dao.delete(user_id, auth_user_id)
result = return_status(1)
return jsonify(result)
if cancel_follow == 'False' or cancel_follow == 'false' or cancel_follow is False:
follow_dao.add(user_id, auth_user_id)
result = return_status(0)
return jsonify(result)
else:
result = return_status(-1)
return jsonify(result)
def like():
auth = request.headers.get('Authorization')
auth_user_id = Auth.identify(auth)
# Authorization header不正确
if auth_user_id is None:
result = return_status(-2)
return jsonify(result)
# 获取用户
user = User()
user.set_user_id(auth_user_id)
user_dao = UserDAO()
try:
retrieve_user = user_dao.retrieve(user)
except:
result = return_status(-2)
return jsonify(result)
# 用户不存在
if retrieve_user is None:
result = return_status(-1)
return jsonify(result)
data = request.get_json()
if 'id' not in data or 'Cancel' not in data:
return "信息缺失"
id = data['id']
cancel_like = data['Cancel']
work_dao = WorkDAO()
if cancel_like == 'True' or cancel_like == 'true' or cancel_like is True:
work_dao.delete_my_like(auth_user_id, id)
result = return_status(1)
return jsonify(result)
if cancel_like == 'False' or cancel_like == 'false' or cancel_like is False:
work_dao.add_my_like(auth_user_id, id)
result = return_status(0)
return jsonify(result)
else:
result = return_status(-1)
return jsonify(result)
def insertUser(self, form):
if len(form) != 6:
return jsonify(Error="Malformed post request"), 400
else:
firstname = form['firstname']
lastname = form['lastname']
phone = form['phone']
email = form['email']
password = form['password']
username = form['username']
if firstname and lastname and email and phone and password and username:
dao = UserDAO()
uid = dao.insertUser(firstname, lastname, phone, email,
password, username)
result = self.mapToDict2([
uid, firstname, lastname, phone, email, password, username
])
return jsonify(User=result), 201
else:
return jsonify(
Error="Unexpected attributes in post request"), 400
def register():
data = request.get_json()
if 'phone' not in data or 'password' not in data:
return "信息缺失"
phone = data['phone']
password = data['password']
# 判断电话号码是否为空
if phone is None:
return "The phone number is empty!"
# 判断密码是否为空
if password is None:
return "The password is empty!"
# 检测手机是否已经使用
phone_is_used = verify_phone(phone)
if phone_is_used:
result = return_status(-1) # 手机号码被使用
return jsonify(result)
# 检测手机格式是否正确
phone_format_false = verify_phone_format(phone)
if phone_format_false:
result = return_status(-2) # 手机格式不正确
return jsonify(result)
user = User()
user.set_phone(phone)
user.set_password(password)
try:
user_dao = UserDAO()
user_dao.add(user)
result = return_status(0)
return jsonify(result) # 注册成功
except:
return "Server failure!"
def insertUser(self, userDic, userAddressDic):
dao = UserDAO ()
if len (userDic) != 3 & len (userAddressDic) != 7:
return jsonify (Error="Malformed post request"), 400
else:
uname = userDic['uname']
ulast = userDic['ulast']
utype = userDic['utype']
uaddress = userAddressDic['uaddress']
ucity = userAddressDic['ucity']
uregion = userAddressDic['uregion']
uzip = userAddressDic['uzip']
ustate = userAddressDic['ustate']
loclat = userAddressDic['loclat']
loclon = userAddressDic['loclon']
if uname and ulast and utype and uaddress and ucity and uregion and uzip and ustate and loclat and loclon:
uid = dao.insert (uname , ulast , utype , uaddress , ucity , uregion , uzip , ustate , loclat , loclon)
result = self.build_alluserinfo_dict2 (uid, uname , ulast , utype , uaddress , ucity , uregion , uzip , ustate , loclat , loclon)
return jsonify (User=result), 201
else:
return jsonify (Error="Unexpected attributes in post request"), 400
def build_controller():
user_dao = UserDAO()
user_service = UserService(user_dao)
input_shape = (28, 28, 3)
modelBuilder = Model(input_shape, construct_model=True)
lr = 1e-3
epochs = 250
loss_function = 'binary_crossentropy'
optimizer = Adam(lr=lr, decay=lr / epochs)
metrics = ['accuracy']
loaded_model = modelBuilder.load_model_from_file()
loaded_model.compile(loss=loss_function,
optimizer=optimizer,
metrics=metrics)
face_detector = FaceDetector(loaded_model, 1.5, (128, 128), 32, 0.4)
eye_detector = EyeDetector()
eye_fixer = EyeFixer(face_detector, eye_detector)
appController = ApplicationController(user_service, eye_fixer)
return appController
def api_add_user():
id = UserDAO.add(request.json)
return jsonify({"id": str(id)})
from flask import jsonify, flash, session
from dao.UserDAO import UserDAO
from handler import DictBuilder as Dict
dao = UserDAO()
###################### Main HANDLER ############################
def register(form):
# Assumes form contains username, password, first_name, last_name, email, phone
if form and len(form) >= 6:
username = form['username']
password = form['password']
first_name = form['first_name']
last_name = form['last_name']
email = form['email']
phone = form['phone']
if username and password and first_name and last_name and email and phone:
user_id = dao.registerUser(first_name, last_name, email, phone)
dao.registerUserCredentials(username, password, user_id)
result = {}
result['user_id'] = user_id
result['username'] = username
result['first_name'] = first_name
result['last_name'] = last_name
result['email'] = email
result['phone'] = [phone]
def __init__(self):
self.userDAO = UserDAO.getInstance()
self.authDAO = AuthDAO.getInstance()
super().__init__()
