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