def test_user_find_by_name(self): user = User.create(self.params['username'], self.params['password']) user_found = User.find_by_username(self.params['username']) self.assertEqual(user.id, user_found.id) self.assertEqual(self.params['username'], user_found.username) user_not_found = User.find_by_username('not_found') self.assertEqual(None, user_not_found)
def test_dispatch_post_to_followers(self): user_to_follow = User.create('anonymous', 'password') me = User.create(self.params['username'], self.params['password']) me.follow(user_to_follow) Post.create(user_to_follow, self.params['post']) self.assertEqual(1, len(me.timeline())) self.assertEqual(1, len(me.timeline()))
def test_user_find_by_name(self): user = User.create(self.params['username'],self.params['password']) user_found = User.find_by_username(self.params['username']) self.assertEqual(user.id,user_found.id) self.assertEqual(self.params['username'],user_found.username) user_not_found = User.find_by_username('not_found') self.assertEqual(None,user_not_found)
def test_dispatch_post_to_followers(self): user_to_follow = User.create('anonymous','password') me = User.create(self.params['username'],self.params['password']) me.follow(user_to_follow) Post.create(user_to_follow,self.params['post']) self.assertEqual(1,len(me.timeline())) self.assertEqual(1,len(me.timeline()))
def test_create_user(self): user = User.create(self.params['username'],self.params['password']) self.assertEqual(self.params['username'], user.username) self.assertEqual(settings.SALT + self.params['password'], user.password) self.assertEqual(1,user.id) self.assertEqual(0,len(user.followees)) self.assertEqual(0,len(user.followers)) self.assertEqual(0,len(user.posts())) self.assertEqual(0,len(user.mentions())) self.assertEqual(0,len(user.timeline())) user = User.create(self.params['username'],self.params['password']) self.assertEqual(None,user)
def test_follow(self): user_to_follow = User.create('anonymous','password') me = User.create(self.params['username'],self.params['password']) me.follow(user_to_follow) self.assertEqual(1,len(me.followees)) self.assertEqual(1,len(user_to_follow.followers)) self.assertEqual(0,len(me.followers)) self.assertEqual(0,len(user_to_follow.followees)) self.assertEqual(True,me.following(user_to_follow)) me.stop_following(user_to_follow) self.assertEqual(0,len(me.followees)) self.assertEqual(0,len(user_to_follow.followers)) self.assertEqual(False,me.following(user_to_follow))
def test_follow(self): user_to_follow = User.create('anonymous', 'password') me = User.create(self.params['username'], self.params['password']) me.follow(user_to_follow) self.assertEqual(1, len(me.followees)) self.assertEqual(1, len(user_to_follow.followers)) self.assertEqual(0, len(me.followers)) self.assertEqual(0, len(user_to_follow.followees)) self.assertEqual(True, me.following(user_to_follow)) me.stop_following(user_to_follow) self.assertEqual(0, len(me.followees)) self.assertEqual(0, len(user_to_follow.followers)) self.assertEqual(False, me.following(user_to_follow))
def _check_auth(*args,**kwargs): sess = Session(bottle.request,bottle.response) if not sess.is_new(): user = User.find_by_id(sess['id']) if user: return handler(user,*args,**kwargs) return handler(None,*args,**kwargs)
def _check_auth(*args, **kwargs): sess = Session(bottle.request, bottle.response) if not sess.is_new(): user = User.find_by_id(sess['id']) if user: return handler(user, *args, **kwargs) bottle.redirect('/login')
def register(session: Session, email: str, password: str, given_name: str, last_name: str, phone: str) -> RegisterResult: """ Register a new user in the application. :param given_name: The users given name to register with. :param last_name: The users last name to register with. :param phone: The users mobile phone number. :param session: A SQLAlchemy Session for the query. :param email: The email to register with, this is also the username. :param password: The password to register with. :return: The result of the registration process. """ # Validate the data integrity of the parameters if email is None: return RegisterResult.BAD_USERNAME if password is None or not passwordService.validate(password): return RegisterResult.BAD_PASSWORD # Check to see if the user already exists existing_user = session.query(User) \ .filter(User.email == email) \ .first() if existing_user is not None: return RegisterResult.USERNAME_ALREADY_REGISTERED # Everything seems fine, so we go ahead and create the user & the linked account. password_hash = passwordService.hash(password) new_user = User(role=UserType.VOLUNTEER, password=password_hash, first_name=given_name, last_name=last_name, mobile_number=phone, email=email, preferred_hours={}, experience_years=0, possibleRoles=["Basic"], qualifications=[], availabilities={"Friday": [], "Monday": [], "Sunday": [], "Tuesday": [], "Saturday": [], "Thursday": [], "Wednesday": []}) session.add(new_user) session.flush() return RegisterResult.SUCCESS
def sign_up(): if 'name' in bottle.request.POST and 'password' in bottle.request.POST: name = bottle.request.POST['name'] if name not in reserved_usernames.split(): password = bottle.request.POST['password'] attributes = {} if 'firstName' in bottle.request.POST: attributes['firstName'] = bottle.request.POST['firstName'] if 'lastName' in bottle.request.POST: attributes['lastName'] = bottle.request.POST['lastName'] if 'greeting' in bottle.request.POST: attributes['greeting'] = bottle.request.POST['greeting'] user = User.create(name, password, attributes) if user: sess = Session(bottle.request, bottle.response) sess['id'] = user.id sess.save() bottle.redirect('/home') return bottle.template('login', page='login', error_login=False, error_signup=True, logged=False)
def user_page(auth, name): user = User.find_by_username(name) if user: counts = user.followees_count, user.followers_count, user.tweet_count if auth != None: is_following, is_logged = False, user_is_logged() logged_user = logged_in_user() himself = logged_user.username == name if logged_user: is_following = logged_user.following(user) return bottle.template('user', user=user, posts=user.posts(), counts=counts, page='timeline', username=user.username, logged=is_logged, is_following=is_following, himself=himself, viewer=auth.username) else: return bottle.template('guest/user', user=user, posts=user.posts(), counts=counts, page='timeline', username=user.username, logged=False) return bottle.HTTPError(code=404, message='tweet not found')
def test_post_find_by_id(self): user = User.create(self.params['username'],self.params['password']) Post.create(user,self.params['post']) post_found = Post.find_by_id(1) self.assertEqual(1,post_found.id) self.assertEqual(user.id,int(post_found.user_id)) #shouldn't need int() self.assertEqual(self.params['username'],post_found.user.username)
def api_user_authenticate(*, email, password): if not email or not email.strip(): raise APIValueError('email', 'email is Null') if not _RE_EMAIL.match(email): raise APIValueError('email', 'email is not format') if not password or not password.strip(): raise APIValueError('password', 'password is Null') users = (yield from User(email=email).find())['data'] if len(users) == 0: raise APIValueError('email', 'email is not in use') user = users[0] sha1_password = '******' % (user.id, password) if hashlib.sha1( sha1_password.encode('utf-8')).hexdigest() != user.password: raise APIValueError('password', 'password is error') rep = web.Response() rep.content_type = 'application/json' rep.set_cookie(_COOKIE_NAME, user2cookie(user, 86400), max_age=86400, httponly=True) user.password = '******' rep.body = json.dumps(user, ensure_ascii=False).encode('utf-8') return rep
def api_get_users(*, page='0', pagesize='0'): users = (yield from User().find(limit=int(pagesize), offset=int(pagesize) * int(page)))['data'] for user in users: logging.info('user: %s' % user) return dict(users=users)
def api_blog_detail(*, id=0): blogs = (yield from Blog(id=id).find())['data'] for blog in blogs: # blog.createtime = datetime.strptime(blog.createtime, '%Y-%m-%d %H:%M:%S,%f').timestamp() user = (yield from User(id=blog.userid).find())['data'][0] blog.author = user return {'blog': blogs[0]}
def get_inbox(): ''' user = context.get_cur_user() messages = user.inbox() return respond_success({'messages': messages}) ''' user = User.find_by_id(1) messages = user.inbox(1) return respond_success({'messages': messages})
def api_get_blogs(request): blogs = (yield from Blog().find())['data'] for blog in blogs: blog.createtime = datetime.strptime( blog.createtime, '%Y-%m-%d %H:%M:%S,%f').timestamp() user = (yield from User(id=blog.userid).find())['data'][0] blog.author = user return {'__template__': 'blogs.html', 'blogs': blogs}
def sign_up(): if 'name' in bottle.request.POST and 'password' in bottle.request.POST: name = bottle.request.POST['name'] if name not in reserved_usernames.split(): password = bottle.request.POST['password'] user = User.create(name,password) if user: sess=Session(bottle.request,bottle.response) sess['id'] = user.id sess.save() bottle.redirect('/home') return bottle.template('login',page='login',error_login=False,error_signup=True,logged=False)
def execute(self, request): response = Response() try: for post in [p['data'] for p in request.endpoint_data['data']['children']]: user_id = self.user_repo.add_user(User(name = post['author'], ups = post['ups'], comments = post['num_comments'])) created_time = datetime.fromtimestamp(post['created_utc'], tz = pytz.timezone(request.timezone)) self.post_repo.add_post(Post(title = post['title'], ups = post['ups'], comments = post['num_comments'], created = created_time, author = user_id)) return response except Exception as e: response.add_exception_error(e) return response
def test_get_ladders_when_in_a_ladder_should_put_your_ladder_at_the_top_and_have_true_flag(self): with patch.object(self.manager.dao, "get_ladders", return_value=[ fixtures.ladder(1, "Ladder 1", date.today(), date.today(), False), fixtures.ladder(2, "Ladder 2", date.today(), date.today(), False), ]): with patch.object(self.manager.dao, "get_users_ladder_ids", return_value=[2]): self.manager.user = User("TEST1", "User", "*****@*****.**", "555-555-5555", "user.jpg", "availability", False) ladders = self.manager.get_ladders() self.assertEqual(2, len(ladders)) self.assertEqual(2, ladders[0].ladder_id) self.assertTrue(ladders[0].logged_in_user_has_joined) self.assertEqual(1, ladders[1].ladder_id) self.assertFalse(ladders[1].logged_in_user_has_joined)
def login(): if 'name' in bottle.request.POST and 'password' in bottle.request.POST: name = bottle.request.POST['name'] password = bottle.request.POST['password'] user = User.find_by_username(name) if user and user.password == settings.SALT + password: sess=Session(bottle.request,bottle.response) sess['id'] = user.id sess.save() bottle.redirect('/home') return bottle.template('login',page='login',error_login=True,error_signup=False,logged=False)
def status(name, id): user = User.find_by_username(name) if user: post = Post.find_by_id(user.id + ':' + id) else: post = None if post: if post.user.username == name: return bottle.template('single', username=post.user.username, tweet=post, page='single', logged=user_is_logged()) return bottle.HTTPError(code=404, message='tweet not found')
def user_page(name): is_following,is_logged = False,user_is_logged() user = User.find_by_username(name) if user: counts = user.followees_count,user.followers_count,user.tweet_count logged_user = logged_in_user() himself = logged_user.username == name if logged_user: is_following = logged_user.following(user) return bottle.template('user',posts=user.posts(),counts=counts,page='user', username=user.username,logged=is_logged,is_following=is_following,himself=himself) else: return bottle.HTTPError(code=404)
def api_user_register(*, name, password, email): if not name or not name.strip(): raise APIValueError('name', 'name is Null') if not password or not password.strip(): raise APIValueError('password', 'password is Null') if not email or not email.strip(): raise APIValueError('email', 'email is Null') if not _RE_EMAIL.match(email): raise APIValueError('email: %s' % email, 'email is no format') users = (yield from User(email=email).find())['data'] if len(users) > 0: raise APIValueError('email', 'email: %s is already in use' % email) uid = next_id() sha1_password = '******' % (uid, password) user = User(id=uid, name=name, password=hashlib.sha1( sha1_password.encode('utf-8')).hexdigest(), email=email, image='./res/tumble.png') res = yield from user.save() rep = web.Response() rep.content_type = 'application/json' if res == 1: logging.info('save user sucessed') rep.set_cookie(_COOKIE_NAME, user2cookie(user, 86400), max_age=86400, httponly=True) user.password = '******' rep.body = json.dumps(user, ensure_ascii=False).encode('utf-8') else: logging.error('user save error') raise APIError('register', 'save', 'register failed') return rep
def user_page(auth, name): user = User.find_by_username(name) if user: counts = user.followees_count,user.followers_count,user.post_count if auth != None: is_following,is_logged = False,user_is_logged() logged_user = logged_in_user() himself = logged_user.username == name if logged_user: is_following = logged_user.following(user) return bottle.template('user',user=user,posts=user.posts(),counts=counts,page='timeline', username=user.username,logged=is_logged,is_following=is_following,himself=himself,viewer=auth.username) else: return bottle.template('guest/user',user=user,posts=user.posts(),counts=counts,page='timeline', username=user.username, logged=False) return bottle.HTTPError(code=404,message='tweet not found')
async def update( self, db: SQLAlchemyUserDatabase, *, user_db: models.UserDB, user: domain.User ) -> (DbModelType, DomainModelType): if isinstance(user, dict): update_data = user else: update_data = user.dict(exclude_unset=True) columns = [col.key for col in inspect(user_db).mapper.column_attrs] for field in update_data: if field in columns: setattr(user_db, field, update_data[field]) await db.update(user_db) return user_db, domain.User.from_orm(user_db)
def login(): if 'name' in bottle.request.POST and 'password' in bottle.request.POST: name = bottle.request.POST['name'] password = bottle.request.POST['password'] user = User.find_by_username(name) if user and user.password == settings.SALT + password: sess = Session(bottle.request, bottle.response) sess['id'] = user.id sess.save() bottle.redirect('/home') return bottle.template('login', page='login', error_login=True, error_signup=False, logged=False)
def api_blog_list(*, page='0'): try: if int(page) < 0: page = 0 except Exception as e: logging.exception(e) page = 0 page = int(page) pagesize = 5 data = (yield from Blog().find(index=page, limit=pagesize)) blogs = data['data'] info = data['info'] for blog in blogs: # blog.createtime = datetime.strptime(blog.createtime, '%Y-%m-%d %H:%M:%S,%f').timestamp() user = (yield from User(id=blog.userid).find())['data'][0] blog.author = user return {"blogs": blogs, "page": info}
def user_page(name): is_following, is_logged = False, user_is_logged() user = User.find_by_username(name) if user: counts = user.followees_count, user.followers_count, user.tweet_count logged_user = logged_in_user() himself = logged_user.username == name if logged_user: is_following = logged_user.following(user) return bottle.template('user', posts=user.posts(), counts=counts, page='user', username=user.username, logged=is_logged, is_following=is_following, himself=himself) else: return bottle.HTTPError(code=404)
def list_users(self, order): """ Lists users ordering the results according to the constraints defined by the parameters of the function Args: order (datetime): How the users must be ordered. Options are 'ups' (number of upvotes) or 'comments' number of comments Returns: [List(User)]: List of Users ordered accordingly """ try: order_clause = DbUser.comments.desc( ) if order == 'comments' else DbUser.ups.desc() db_users = DbUser.select().order_by(order_clause) return [ User(name=u.name, ups=u.ups, comments=u.comments) for u in db_users ] except Exception as e: raise Exception('error listing user')
def validate_token(self, token): if token is None: return try: firebase_user = self.firebase_client.get_firebase_user(token) self.user = self.dao.get_user(firebase_user["user_id"]) if self.user is None: print("Creating new user: "******"user_id"], name=firebase_user.get("name", "Unknown"), email=firebase_user["email"], phone_number=None, photo_url=firebase_user.get("picture") if firebase_user.get("picture") != "" else None, availability_text=None, admin=False ) self.dao.create_user(self.user) except Exception as error: print("Token auth error: ", error) self.user = None
def cookie2user(zip_cookie): if not zip_cookie: return None try: unzip_cookie = zip_cookie.split('-') if len(unzip_cookie) != 3: return None uid, duration, sha1 = unzip_cookie if int(duration) < time.time(): return None users = (yield from User(id = uid).find())['data'] user = users[0] if user is None: return None cookies = '%s-%s-%s-%s' % (user.id, user.password, duration, COOKIE_KEY) if sha1 != hashlib.sha1(cookies.encode('utf-8')).hexdigest(): logging.info('invalid sha1') return None user.password = '******' return user except Exception as e: logging.exception(e) return None
def send_message(): #user = context.get_cur_user() user = User.find_by_id(1) ''' content = CompoundMessage(bottle.request.POST['content']) recepients = bottle.request.POST['recepients'] method = bottle.request.POST['method'] subject = bottle.request.POST['subject'] ''' inmessage_json = request.json content = inmessage_json['content'] #compoundMessage中的image和location从哪里来????? recepients = inmessage_json['recepients'] method = inmessage_json['method'] subject = inmessage_json['subject'] outmessage_id= OutMessage.create(user, method, subject, content) #rc = dispatcher.dispatch(method, recepients, out_message) rc = dispatcher.dispatch(recepients, outmessage_id) out_message = OutMessage.find_by_id(outmessage_id) if rc == STATUS_SENT_SUCCESS: out_message.set_sent_ok() return respond_success() else: out_message.set_sent_error(rc) return respond_failure(rc)
def logged_in_user(): sess = Session(bottle.request,bottle.response) if not sess.is_new(): return User.find_by_id(sess['id']) return None
def logged_in_user(): sess = Session(bottle.request, bottle.response) if not sess.is_new(): return User.find_by_id(sess['id']) return None
def test_create_post(self): user = User.create(self.params['username'], self.params['password']) Post.create(user, self.params['post']) self.assertEqual(1, len(user.posts())) self.assertEqual(1, user.posts()[0].id) self.assertEqual(self.params['post'], user.posts()[0].content)
def post(user,name): user_to_unfollow = User.find_by_username(name) if user_to_unfollow: user.stop_following(user_to_unfollow) bottle.redirect('/%s' % name)
def test_create_post_with_mention(self): user = User.create(self.params['username'], self.params['password']) content_with_mention = self.params['post'] + '@' + self.params[ 'username'] Post.create(user, content_with_mention) self.assertEqual(1, len(user.mentions()))
def test_create_post_with_mention(self): user = User.create(self.params['username'],self.params['password']) content_with_mention = self.params['post'] + '@' + self.params['username'] Post.create(user,content_with_mention) self.assertEqual(1,len(user.mentions()))
def test_create_post(self): user = User.create(self.params['username'],self.params['password']) Post.create(user,self.params['post']) self.assertEqual(1,len(user.posts())) self.assertEqual(1,user.posts()[0].id) self.assertEqual(self.params['post'],user.posts()[0].content)
def user(user_id="", name="", email="", phone_number=None, photo_url=None, availability_text=None, admin=False) -> User: return User(user_id, name, email, phone_number, photo_url, availability_text, admin)