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_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 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_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)
