def post(self):
"""
Создать пользователя/продавца
:return:
"""
request_json = request.json
account = {
'email': request_json.get('email'),
'password': request_json.get('password'),
'first_name': request_json.get('first_name'),
'last_name': request_json.get('last_name')
}
is_seller = request_json.get('is_seller')
if is_seller:
seller = {
'phone': request_json.get('phone'),
'zip_code': request_json.get('zip_code'),
'city_id': request_json.get('city_id'),
'street': request_json.get('street'),
'home': request_json.get('home')
}
password_hash = generate_password_hash(account["password"])
user_service = UserService(db.connection)
new_user = user_service.add_account(account, password_hash)
print(new_user)
if is_seller:
city_service = CityService(db.connection)
if city_service.get_zipcode(seller['zip_code']) is None:
city_service.add_zipcode(seller['zip_code'], seller['city_id'])
new_seller = user_service.add_seller(seller, new_user['id'])
return {**new_user, **{'is_seller': is_seller}, **new_seller}, 201
return {**new_user, **{'is_seller': is_seller}}, 201
def get_user():
page, per_page, offset = get_page_items()
paginate = request.args.get('paginate', 'true').lower()
paginate = False if paginate == 'false' else True
user_ids = request.args.get('userIds', None)
if user_ids:
user_ids = [
user_id for user_id in user_ids.split(',')
if ObjectId.is_valid(user_id)
]
users = UserService.get_users(user_ids=user_ids, paginate=False)
else:
q = request.args.get('q', '')
emails = [
email for email in request.args.get('emails', '').split(',')
if AuthService.validate_email(email)
]
users = UserService.get_users(query=q,
page=page,
limit=per_page,
emails=emails,
paginate=paginate)
if users.get('data'):
return ResponseDto(status=0, result=users).to_json()
return ResponseDto(status=-1, msg='No User Found.').to_json()
def nodeJoin(self, node: Node):
logger.info(f"Join node {node}")
print(node)
if (node.groupID != '0') and (GroupService.getGroup(node.groupID) is None):
GroupService.addGroup(node.groupID, node.groupName, node.maxPerson)
UserService.addUser(node.username, node.firstname,
node.lastname, node.faculty, node.year, node.groupID)
def acceptRequest(popup, req: Request):
popup.destroy()
ackReq = Request(req.fromUsername, req.groupID,
{'message': 'Accept join group request'})
print('Sending Group Acknowledge Request')
setup.net.sendGroupAcknowledgeRequest(ackReq)
UserService.updateGroup(req.fromUsername, req.groupID)
def login(self, credentials):
login_error = []
if len(credentials['email']) == 0:
login_error.append('Email cannot be empty')
if len(credentials['password']) == 0:
login_error.append('Password cannot be empty')
if login_error:
return {'success': False, 'errors': login_error}
user_service = UserService()
user = user_service.load_user_by_email(credentials['email'])
auth = False
if user:
try:
auth = pwd_context.verify(credentials['password'], user.password)
except:
pass
if auth:
update_last_login_sql = text('UPDATE flask_user SET last_login = :last_login WHERE id = :id')
db.engine.execute(update_last_login_sql, last_login=str(datetime.now()), id=user.id)
return {'success': True, 'user': user}
login_error.append('Invalid Username or password')
return {'success': False, 'errors': login_error}
def receiveGroupBroadcast(self, b: GroupBroadcast):
logger.info(f"Receive group broadcast {b}")
print('Group broadcast body: ', b.body)
if (b.body.get('groupID') != '0') and (GroupService.getGroup(b.body.get('groupID')) is None):
GroupService.addGroup(b.body.get('groupID'), b.body.get(
'group_name'), b.body.get('max_person'))
UserService.addUser(b.username, b.body.get('firstname', 'test'), b.body.get(
'lastname', 'Test L'), b.body.get('faculty', 'test faculty'), b.body.get('year', 4), b.groupID)
def logout():
user_service = UserService()
if user_service.logout_user():
flash('Successfully logged out', 'success')
else:
# try flask flash
flash('Error in logging you out. Please try again later', 'danger')
return redirect(url_for('.index'))
class TestUserService(unittest.TestCase):
def setUp(self):
self.session_mock = Mock()
self.test_instance = UserService(logger, self.session_mock)
def test_add_user(self):
self.test_instance.add_user('username', 'password', 'role', False)
self.session_mock.return_value.add.assert_called_once
async def get_user_information(request, user_id: int):
user_service = UserService()
offer_service = OfferService()
try:
user = user_service.get_user_by_id(user_id)
except UserNotFound as e:
return json({"answer": "user with this id does not exist"}, 404)
offers = offer_service.get_offers_by_user_id(user_id)
return json({**(user.as_dict()), "offers": offers}, 200)
def index():
user_service = UserService()
current_user = user_service.get_current_user()
try:
if current_user:
return redirect(url_for('.get_user', user_id=current_user.id))
except:
pass
return render_template("login.html")
def get(self, user_id):
"""
returns user data
:param user_id: id user in session
:return: data user in josn format
"""
service = UserService(db.connection)
user = service.get_user(user_id=user_id)
return jsonify(scheme.user.get_user_schema.dump(user)), 200
def get(self, user_id):
"""
Получить пользователя/продавца
:param user_id: id пользователя
:return:
"""
if session.get('user_id') is None:
return '', 401
user_service = UserService(db.connection)
return jsonify(user_service.get_user(user_id)), 200
def update(self):
first_name = self.e1.get()
last_name = self.e2.get()
year = self.e4.get()
faculty = self.e5.get()
setup.current_user.update(first_name, last_name, year, faculty)
UserService.updateProfile(first_name, last_name, faculty, year)
print(first_name, last_name, year, faculty)
print(UserService.getProfile())
def get(self):
"""
Получить все цвета
:return:
"""
if session.get('user_id') is None:
return '', 401
user_service = UserService(db.connection)
if not user_service.is_user_a_seller(session.get('user_id')):
return 'получать цвета могут только продавцы', 405
color_service = ColorService(db.connection)
return jsonify(color_service.get_colors()), 200
async def register_user(request):
try:
user = RegisterUserSchema.parse_obj(request.json)
except ValidationError as e:
return json(e.errors(), 422)
service = UserService()
try:
new_user = service.create_user(user)
print(new_user.as_dict())
return json({"user_id": new_user.id}, 201)
except UserExistExcept:
return json({"answer": "User with this mail or username exists"}, 409)
def post(self):
request_json = request.json
try:
user = scheme.user.user_schema.load(request_json)
except ValidationError as ValidEr:
return jsonify(ValidEr.messages), 400
service = UserService(db.connection)
try:
user = service.create_user(user=user)
except ThisEmailAlreadyUse as email_er:
return email_er.message, 400
return jsonify(scheme.user.get_user_schema.dump(user)), 201
def __init__(self):
self.net = NetworkInterface()
UserService.initMe(self.net.getInterfaceMac(), '', '', '', 1)
self.macAddress = self.net.getInterfaceMac()
self.nodeList = set()
# self.selfInfo = mocSelf()
self.selfInfo = UserService.infoBroadcast()
self.nodeMap = dict()
self.packetSet = set()
self.reverseMap = dict()
self.isRunning = False
self.sender = Sender(self.reverseMap, self.selfInfo)
self.eventListener = None
def post(self):
"""
Загрузить изображение на сервер
"""
if session.get('user_id') is None:
return '', 401
user_service = UserService(db.connection)
if not user_service.is_user_a_seller(session.get('user_id')):
return 'загружать фотографии могут только продавцы', 403
file = request.files['image']
image_service = ImageService(db.connection)
url = image_service.save_file(file)
return jsonify(url), 201
def login():
if request.method == 'POST':
email = request.form['email']
password = request.form['password']
auth_service = AuthService()
login_result = auth_service.login({'email': email, 'password': password})
if login_result['success']:
user = login_result['user']
#login_user(user, remember=True) #https://flask-login.readthedocs.io/en/latest/#remember-me
user_service = UserService()
user_service.login_user(user)
return redirect(url_for('.get_user', user_id=user.id))
return render_template("login.html", invalid_credentials=True)
return render_template("login.html")
def get_slot():
page, per_page, offset = get_page_items()
paginate = request.args.get('paginate', 'true').lower()
paginate = False if paginate == 'false' else True
slot_ids = request.args.get('slotIds', None)
order_by = request.args.get('orderBy', '-created_at')
if slot_ids:
slot_ids = [
slot_id for slot_id in slot_ids.split(',')
if ObjectId.is_valid(slot_id)
]
slots = CalendarService.get_slots(slot_ids=slot_ids,
paginate=False,
order_by=order_by)
else:
start_ts = request.args.get('startTimestamp', None)
end_ts = request.args.get('endTimestamp', None)
user = request.args.get('userEmail', None)
if user:
user = UserService.get_users(emails=[user],
data_objects=True,
paginate=False).first()
if user is None:
return ResponseDto(
status=-1,
msg="User is not present with this email.").to_json()
booked_by = request.args.get('bookedBy', None)
if booked_by:
booked_by = UserService.get_users(emails=[booked_by],
data_objects=True,
paginate=False).first()
if booked_by is None:
return ResponseDto(
status=-1,
msg="Booking user is not present with this email."
).to_json()
slots = CalendarService.get_slots(page=page,
limit=per_page,
user=user,
booked_by=booked_by,
end_ts=end_ts,
order_by=order_by,
start_ts=start_ts,
paginate=paginate)
if slots.get('data'):
return ResponseDto(status=0, result=slots).to_json()
return ResponseDto(status=-1, msg='No Slot Found.').to_json()
async def create_offer(request):
"""
Create new offer
из-за требования user_id в теле запроса, код вышел запутанный
приходется проверять user_id в токене с user_id в теле запроса
:param request:
:return: json offer
"""
try:
offer_data = CreateOfferSchema.parse_obj(request.json)
except ValidationError as e:
return json(e.errors(), 422)
try:
is_current_user = AuthService().indentify(request, "user_id")
except:
return json({"answer": "not a valid token"}, 401)
if not is_current_user:
return json({"answer": "not a valid token"}, 401)
try:
user = UserService().get_user_by_id(offer_data.user_id)
except UserNotFound as e:
return json({"answer": "user with this id does not exist"}, 400)
offer_serivce = OfferService()
new_offer = offer_serivce.create_offer(offer_data)
return json(new_offer.as_dict(), 201)
async def get_project_result(self, project):
result = {
'id': str(project.id),
'name': project.name,
'key': project.key,
'owner': None,
'links': []
}
user_service = UserService()
owner = await user_service.user_by_id(project.owner)
if owner:
result['owner'] = user_service.get_user_result(owner)
if project.links:
for link in project.links:
result['links'].append({'name': link['name'], 'url': link['url'], 'id': str(link['id'])})
return result
def run(self):
while True:
if time.time() - self.clearTime > 1800:
self.packetSet.clear()
self.clearTime = time.time()
nodes = self.getAllNode()
addedNode, deletedNode = self.diffNode(nodes)
self.nodeList = nodes
logger.debug(f"Add node: {addedNode}, deleted node: {deletedNode}")
logger.debug(f"Len node {len(nodes)}, add node {len(addedNode)}, deleted node {len(deletedNode)}")
nodeInfo = self.probeNode(addedNode)
for (ip, info) in nodeInfo:
# createdNode = Node(ip, info["username"], info["firstname"], info["lastname"],
# info["faculty"], info["year"], info["groupID"], info)
createdNode = Node(ip, info)
self.eventListener.nodeJoin(createdNode)
self.nodeMap[ip] = info
self.reverseMap[info["username"]] = ip
for ip in deletedNode:
if ip in self.nodeMap:
info = self.nodeMap.get(ip)
# createdNode = Node(ip,info["username"],info["firstname"],info["lastname"],info["faculty"],info["year"],info["group_id"],info)
createdNode = Node(ip, info)
self.eventListener.nodeLeave(createdNode)
self.nodeMap.pop(ip)
self.reverseMap.pop(info["username"])
self.info = UserService.infoBroadcast()
self.sender.info = self.info
self.sender.sendGroupBroadcast()
class SignupHandler(BaseHandler):
s_user = UserService()
@tornado.web.asynchronous
@tornado.gen.coroutine
def post(self):
name = self.get_argument("name")
email = self.get_argument("email")
password = self.get_argument("password")
fields = {
"name": True,
"email": True,
"gitlab": True,
"last_time": True,
"login_time": True,
"create_time": True,
"password": True
}
hasName = yield self.s_user.find_one({"name": name}, fields=fields)
hasEmail = yield self.s_user.find_one({"email": email}, fields=fields)
if ((hasName is not None) or (hasEmail is not None)):
self.render_error(error_code=404, msg='user exist')
else:
user = yield self.s_user.signup(name, email, password, fields)
if not user:
self.render_error(error_code=404, msg='signup failed')
else:
self.write_result(data=user)
def receive(username, groupID, time, msg):
user = UserService.getProfile()
user_groupID = user[-1]
if user_groupID == groupID:
DB.execute(
'INSERT INTO message_group(from_username, group_id, time, message) VALUES (?,?,?,?)',
(username, groupID, time, msg))
def post(self):
"""
receives user data and registers him
:return: data user in josn format
"""
request_json = request.json
try:
user = scheme.user.user_schema.load(request_json)
except ValidationError as ValidEr:
return jsonify(ValidEr.messages), 400
service = UserService(db.connection)
try:
user = service.create_user(user=user)
except ThisEmailAlreadyUse as email_er:
return email_er.message, 400
return jsonify(scheme.user.get_user_schema.dump(user)), 201
def get_session_user_by_email(email):
"""Returns the session user instance for given user email"""
user = UserService.get_users(emails=[email],
paginate=False,
data_objects=True).first()
if user:
return SessionUser(email=user.email, name=user.name)
return None
def getFriends(self):
self.list_box.delete(0, END)
self.username = []
availableFriends = UserService.getAvailableUser()
for (username, firstname, lastname, faculty, year) in availableFriends:
self.username.append(username)
self.list_box.insert(END, faculty + '#' +
str(year) + ' ' + firstname + ' ' + lastname)
async def decorator_function(request, *args, **kwargs):
service = UserService()
state, user = await service.verify_token(request.token)
if state:
kwargs[user_keyword] = user
return await func(request, *args, **kwargs)
else:
return json({"msg": "认证失败", "code": 401, "result": "未登录或认证过期"})
async def get_project_user_result(self, project):
result = []
user_service = UserService()
owner = await user_service.user_by_id(project.owner)
owner_result = {
'id': str(uuid.uuid4()),
'role_key': ProjectRoleEnums.OWNER.name,
'role_name': ProjectRoleEnums.OWNER.value,
'user': project.owner,
'user_detail': user_service.get_user_result(owner)
}
result.append(owner_result)
if project.users:
for user in project.users:
user_obj = await user_service.user_by_id(user['user'])
user['user_detail'] = user_service.get_user_result(user_obj)
result.append(user)
return result
