def accept(self, user, **kw):
request_handler = kw.get('request_handler')
username = kw.get('username')
session = meta.get_session()
friend = session.query(User).filter(User.username == username).first()
if not friend:
return self.render_to_json({"status": "error", "msg": "Inexistent user!"}, request_handler)
invite = session.query(Invite).filter(and_(Invite.user_id == friend.id, Invite.friend_id == user.id)).first()
if not invite:
return self.render_to_json({"status": "error", "msg": "Invite not found."}, request_handler)
if invite.friend_id == user.id:
friendship = Friendship()
friendship.user_id = user.id
friendship.friend_id = friend.id
friendship.created_dt = datetime.now()
try:
friendship.save()
except IntegrityError:
return self.render_to_json({"status": "error", "msg": "You and %s are already friend!" % friend.first_name}, request_handler)
invite.delete()
return self.render_to_json({"status": "ok", "msg": "User %s is now your friend!" % friend.first_name}, request_handler)
def send(self, user, **kw):
request_handler = kw.get('request_handler')
username = kw.get('username')
session = meta.get_session()
friend = session.query(User).filter(User.username == username).first()
friendship = session.query(Friendship).filter(Friendship.user_id == user.id).filter(Friendship.friend_id==friend.id).first()
if friendship:
return self.render_to_json({"status": "error", "msg": "User is already your friend."}, request_handler)
if not friend:
return self.render_to_json({"status": "error", "msg": "User not found."}, request_handler)
if friend.id == user.id:
return self.render_to_json({"status": "error", "msg": "You cannot be a friend of yourself!"}, request_handler)
invite = Invite()
invite.user_id = user.id
invite.friend_id = friend.id
invite.date = datetime.now()
try:
invite.save()
except IntegrityError:
return self.render_to_json({"status": "error", "msg": "You have already invited this user. Just relax!"}, request_handler)
return self.render_to_json({"status": "ok", "msg": "Your invite has been sent."}, request_handler)
def login(self, **kw):
request_handler = kw.get('request_handler')
username = kw.get('username')
password = kw.get('password')
session = meta.get_session()
user = session.query(User).filter(User.username==username).first()
m = hashlib.sha1()
m.update(password)
password = '******' + m.hexdigest()
if user and (user.password == password):
auth = hashlib.md5()
auth.update('%s' % getrandbits(32))
cache = get_cache()
cache.set(auth.hexdigest(), '%s' % user.username)
invites = session.query(Invite).filter(Invite.friend_id==user.id).all()
invites_lst = [invite.user.as_dict() for invite in invites]
else:
return self.render_to_json({'status': 'error', 'msg': 'Wrong username or password.'}, request_handler)
return self.render_to_json({'status': 'ok', 'msg': auth.hexdigest(),'invites': invites_lst}, request_handler)
def test_user_can_be_saved():
session = get_session()
user = User()
user.last_name = 'should-be-last-name'
user.first_name = 'should-be-first-name'
user.username = '******'
user.created = datetime.now()
user.last_login = datetime.now()
user.password = '******'
user.gender = 'M'
user.email = 'should-be-email'
user.is_staff = False
user.is_superuser = False
user.is_active = True
user.save()
user_db = session.query(User).filter(
User.username == 'should-be-username').first()
assert user_db.username == user.username
user_db.delete()
def search_ids(self, parameters):
session = meta.get_session()
query = 'select id from auth_user where first_name like "%%%s%%"' % parameters[0]
if len(parameters) > 1:
query += ' or last_name like "%%%s%%"' % parameters[1]
result = session.execute(query)
return [row['id'] for row in result.fetchall()]
def friends(self, user, **kw):
request_handler = kw.get('request_handler')
session = meta.get_session()
friends = session.query(Friendship).filter(Friendship.user_id == user.id).all()
friends_lst = [friend.friend.as_dict() for friend in friends]
return self.render_to_json({'friend': friends_lst}, request_handler)
def list(self, user, **kw):
request_handler = kw.get('request_handler')
session = meta.get_session()
invites = session.query(Invite).filter(Invite.user_id == user.id).all()
invites_lst = [invite.friend.as_dict() for invite in invites]
return self.render_to_json({'invite': invites_lst}, request_handler)
def list(self, user, **kw):
request_handler = kw.get('request_handler')
session = meta.get_session()
invites = session.query(Invite).filter(Invite.user_id == user.id).all()
invites_lst = [invite.friend.as_dict() for invite in invites]
return self.render_to_json({'invite': invites_lst}, request_handler)
def friends(self, user, **kw):
request_handler = kw.get('request_handler')
session = meta.get_session()
friends = session.query(Friendship).filter(
Friendship.user_id == user.id).all()
friends_lst = [friend.friend.as_dict() for friend in friends]
return self.render_to_json({'friend': friends_lst}, request_handler)
def send(self, user, **kw):
request_handler = kw.get('request_handler')
username = kw.get('username')
session = meta.get_session()
friend = session.query(User).filter(User.username == username).first()
friendship = session.query(Friendship).filter(
Friendship.user_id == user.id).filter(
Friendship.friend_id == friend.id).first()
if friendship:
return self.render_to_json(
{
"status": "error",
"msg": "User is already your friend."
}, request_handler)
if not friend:
return self.render_to_json(
{
"status": "error",
"msg": "User not found."
}, request_handler)
if friend.id == user.id:
return self.render_to_json(
{
"status": "error",
"msg": "You cannot be a friend of yourself!"
}, request_handler)
invite = Invite()
invite.user_id = user.id
invite.friend_id = friend.id
invite.date = datetime.now()
try:
invite.save()
except IntegrityError:
return self.render_to_json(
{
"status": "error",
"msg": "You have already invited this user. Just relax!"
}, request_handler)
return self.render_to_json(
{
"status": "ok",
"msg": "Your invite has been sent."
}, request_handler)
def accept(self, user, **kw):
request_handler = kw.get('request_handler')
username = kw.get('username')
session = meta.get_session()
friend = session.query(User).filter(User.username == username).first()
if not friend:
return self.render_to_json(
{
"status": "error",
"msg": "Inexistent user!"
}, request_handler)
invite = session.query(Invite).filter(
and_(Invite.user_id == friend.id,
Invite.friend_id == user.id)).first()
if not invite:
return self.render_to_json(
{
"status": "error",
"msg": "Invite not found."
}, request_handler)
if invite.friend_id == user.id:
friendship = Friendship()
friendship.user_id = user.id
friendship.friend_id = friend.id
friendship.created_dt = datetime.now()
try:
friendship.save()
except IntegrityError:
return self.render_to_json(
{
"status": "error",
"msg":
"You and %s are already friend!" % friend.first_name
}, request_handler)
invite.delete()
return self.render_to_json(
{
"status": "ok",
"msg": "User %s is now your friend!" % friend.first_name
}, request_handler)
def search(self, user, **kw):
request_handler = kw.get('request_handler')
username = kw.get('username')
#TODO - Escape
session = meta.get_session()
users = session.query(User).filter(User.username.like("%" + username + "%")).order_by(User.first_name).all()
users_lst = [user.as_dict() for user in users]
users_json = {'users': users_lst}
return self.render_to_json(users_json, request_handler)
def user(self, user, **kw):
request_handler = kw.get('request_handler')
if kw.get('username'):
username = kw.get('username')
session = meta.get_session()
user_db = session.query(User).filter(User.username==username).first()
if not user_db:
return self.render_to_json({"status": "error", "msg": "User not found."}, request_handler)
return self.render_to_json({'user': user_db.as_dict()}, request_handler)
else:
return self.render_to_json({'user': user.as_dict()}, request_handler)
def remove(self, user, **kw):
request_handler = kw.get('request_handler')
username = kw.get('username')
session = meta.get_session()
friend = session.query(User).filter(User.username == username).first()
if not friend:
return self.render_to_json(
{
"status": "error",
"msg": "Inexistent user!"
}, request_handler)
friend_id = friend.id
if friend_id == user.id:
return self.render_to_json(
{
"status": "error",
"msg": "Do you hate yourself?!"
}, request_handler)
friendship = session.query(Friendship).filter(
Friendship.friend_id == friend_id).filter(
User.id == user.id).first()
if not friendship:
return self.render_to_json(
{
"status": "error",
"msg": "This user are not your friend!"
}, request_handler)
friendship.delete()
return self.render_to_json(
{
"status": "ok",
"msg": "Your friendship has been removed!"
}, request_handler)
def post(self, **kw):
username = self.request.GET[u'username']
session = meta.get_session()
user = session.query(User).filter(User.username==username).first()
if user:
password = self.create_random_passord()
m = hashlib.sha1()
m.update(password)
user.password = '******'+m.hexdigest()
user.save()
else:
self.response.headers['Content-Type'] = 'application/json'
self.response.out.write(simplejson.dumps({'status':'ok', 'msg':'Password re-created! Verify you email account'}))
body="""
Dear %s: <br />
<br />
Your new password is %s. We strongly recommend you change as soon as possible. <br />
<br />
Please let us know if you have any questions. <br />
<br />
The MSS Team
""" % (user.first_name, password)
try:
mensagem=EmailHelper.mensagem(destinatario=user.username,corpo=body,strFrom='Mobile Social Share Team <*****@*****.**>',subject="Your account has been created")
EmailHelper.enviar(mensagem=mensagem,destinatario=user.username)
except SMTPException, e:
logging.exception(str(e))
def remove(self, user, **kw):
request_handler = kw.get('request_handler')
username = kw.get('username')
session = meta.get_session()
friend = session.query(User).filter(User.username == username).first()
if not friend:
return self.render_to_json({"status": "error", "msg": "Inexistent user!"}, request_handler)
friend_id = friend.id
if friend_id == user.id:
return self.render_to_json({"status": "error", "msg": "Do you hate yourself?!"}, request_handler)
friendship = session.query(Friendship).filter(Friendship.friend_id == friend_id).filter(User.id==user.id).first()
if not friendship:
return self.render_to_json({"status": "error", "msg": "This user are not your friend!"}, request_handler)
friendship.delete()
return self.render_to_json({"status": "ok", "msg": "Your friendship has been removed!"}, request_handler)
def ids(self):
session = meta.get_session()
result = session.execute('select id from application_context')
return [row['id'] for row in result.fetchall()]
def ids(self):
session = meta.get_session()
result = session.execute('select id from auth_user')
return [row['id'] for row in result.fetchall()]
def ids(self):
session = meta.get_session()
result = session.execute('select context_type_id from context_type')
return [row['context_type_id'] for row in result.fetchall()]
def ids(self):
session = meta.get_session()
result = session.execute('select application_id from application')
return [row['application_id'] for row in result.fetchall()]
try:
user.save()
except Exception, e:
logging.exception(e)
return self.render_to_json({'status': 'error', 'msg': 'Username already exists.'}, request_handler)
try:
mensagem = EmailHelper.mensagem(destinatario=user.email, corpo=body, strFrom='Mobile Social Share Team <*****@*****.**>', subject="Your account has been created")
EmailHelper.enviar(mensagem=mensagem, destinatario=user.email)
except SMTPException, e:
logging.exception(str(e))
code = kw.get("code", "")
if code != "":
session = meta.get_session()
invite_email = session.query(InviteEmail).filter(InviteEmail.code==code).first()
if invite_email:
friendship = Friendship()
friendship.user_id = invite_email.user_id
friendship.friend_id = user.id
friendship.created_dt = datetime.now()
friendship.save()
invite_email.delete()
return self.render_to_json({'status': 'ok', 'msg': 'Account Created! Verify you email account'}, request_handler)
def login(self, **kw):
class InviteHandlerTestCase(AsyncHTTPTestCase):
session = get_session()
def get_app(self):
routes = [(r"/invite/send", SendInviteHandler),
(r"/invite/accept", AcceptInviteHandler),
(r"/invite/get.json", GetInviteHandler),
(r"/invite/email/send", SendEmailInviteHandler),
(r"/invite/email/accept", AcceptEmailInviteHandler)]
return tornado.web.Application(routes)
def test_send_invite(self):
user = create_logged_user()
user2 = create_user(last_name='test_send_invite',
first_name='test_send_invite',
username='******')
self.http_client.fetch(
self.get_url('/invite/send?username=%s&auth=should-be-user-auth' %
user2.username), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
'{"status": "ok", "msg": "Your invite has been sent."}')
invite = self.session.query(Invite).filter(
Invite.user_id == user.id).first()
assert invite.user_id == user.id
assert invite.friend_id == user2.id
invite.delete()
user.delete()
user2.delete()
def test_accept_invite(self):
user = create_logged_user(username="******")
friend = create_user(last_name='test_accept_invite',
first_name='test_accept_invite',
username='******')
create_invite(friend, user)
self.http_client.fetch(
self.get_url(
'/invite/accept?username=%s&auth=should-be-user-auth' %
friend.username), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
'{"status": "ok", "msg": "User test_accept_invite is now your friend!"}'
)
invite = self.session.query(Invite).filter(
Invite.user_id == user.id).first()
self.assertEqual(invite, None)
friendship = self.session.query(Friendship).filter(
Friendship.user_id == user.id).first()
assert friendship.user_id == user.id
assert friendship.friend_id == friend.id
friendship.delete()
friend.delete()
user.delete()
def test_accept_inexistent_invite(self):
user = create_logged_user(username="******")
friend = create_user(last_name='test_accept_invite',
first_name='test_accept_invite',
username='******')
self.http_client.fetch(
self.get_url(
'/invite/accept?username=%s&auth=should-be-user-auth' %
friend.username), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(response.body,
'{"status": "error", "msg": "Invite not found."}')
user.delete()
friend.delete()
def test_accept_duplicated_invite(self):
user = create_logged_user(username='******')
friend = create_user(last_name='test_accept_invite',
first_name='test_accept_invite',
username='******')
friendship = create_friendship(user, friend)
invite = create_invite(friend, user)
self.http_client.fetch(
self.get_url(
'/invite/accept?username=%s&auth=should-be-user-auth' %
friend.username), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
simplejson.dumps({
"status":
"error",
"msg":
"You and %s are already friend!" % friend.first_name
}))
invite.delete()
friendship.delete()
user.delete()
friend.delete()
def test_get_invites(self):
user = create_logged_user()
friend1 = create_user(last_name='test_get_invites-1',
first_name='test_get_invites-1',
username='******')
friend2 = create_user(last_name='test_get_invites-2',
first_name='test_get_invites-2',
username='******')
invite1 = create_invite(user, friend1)
invite2 = create_invite(user, friend2)
self.http_client.fetch(
self.get_url('/invite/get.json?auth=should-be-user-auth'),
self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
'{"invite": [{"username": "******", "first_name": "test_get_invites-1", "last_name": "test_get_invites-1", "gender": "M", "is_active": true, "is_superuser": false, "is_staff": false, "email": "should-be-email"}, {"username": "******", "first_name": "test_get_invites-2", "last_name": "test_get_invites-2", "gender": "M", "is_active": true, "is_superuser": false, "is_staff": false, "email": "should-be-email"}]}'
)
invite1.delete()
invite2.delete()
user.delete()
friend1.delete()
friend2.delete()
def test_send_email_invite(self):
user = create_logged_user()
email = "*****@*****.**"
m = hashlib.md5()
m.update("%s%s" % (email, user.id))
code = m.hexdigest()
self.http_client.fetch(
self.get_url(
'/invite/email/send?email=%s&auth=should-be-user-auth' %
email), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
'{"status": "ok", "msg": "Your invite has been sent."}')
invite_email = self.session.query(InviteEmail).filter(
InviteEmail.code == code).first()
invite_email.delete()
user.delete()
def test_send_duplicate_email_invite(self):
user = create_logged_user()
email = "*****@*****.**"
invite_email = create_invite_email(user=user, email=email)
self.http_client.fetch(
self.get_url(
'/invite/email/send?email=%s&auth=should-be-user-auth' %
email), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
'{"status": "error", "msg": "You have already invited this user. Just relax!"}'
)
invite_email.delete()
user.delete()
def test_accept_email_invite(self):
pass
class FriendshipHandlerTestCase(AsyncHTTPTestCase):
session = get_session()
def get_app(self):
routes = [
(r"/friendship/get.json", GetFriendshipsHandler),
(r"/friendship/remove", RemoveFriendshipsHandler)
]
return tornado.web.Application(routes)
def test_get_friendship(self):
user = create_logged_user()
user2 = create_user(last_name='test_get_friendship-2', first_name='test_get_friendship-2', username='******')
user3 = create_user(last_name='test_get_friendship-3', first_name='test_get_friendship-3', username='******')
friendship = create_friendship(user, user2)
friendship2 = create_friendship(user, user3)
self.http_client.fetch(self.get_url('/friendship/get.json?auth=should-be-user-auth'), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(response.body, '{"friend": [{"username": "******", "first_name": "test_get_friendship-2", "last_name": "test_get_friendship-2", "gender": "M", "is_active": true, "is_superuser": false, "is_staff": false, "email": "should-be-email"}, {"username": "******", "first_name": "test_get_friendship-3", "last_name": "test_get_friendship-3", "gender": "M", "is_active": true, "is_superuser": false, "is_staff": false, "email": "should-be-email"}]}')
friendship.delete()
friendship2.delete()
user3.delete()
user2.delete()
user.delete()
def test_remove_friendship(self):
user = create_logged_user()
user2 = create_user(last_name='test_remove_friendship-2', first_name='test_remove_friendship-2', username='******')
create_friendship(user, user2)
self.http_client.fetch(self.get_url('/friendship/remove?username=%s&auth=should-be-user-auth' % user2.username), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(response.body, '{"status": "ok", "msg": "Your friendship has been removed!"}')
friendship_db = self.session.query(Friendship).filter(Friendship.user_id == user.id).first()
self.assertEqual(friendship_db, None)
user.delete()
user2.delete()
def test_remove_myself_friendship(self):
user = create_logged_user()
self.http_client.fetch(self.get_url('/friendship/remove?username=%s&auth=should-be-user-auth' % user.username), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(response.body, '{"status": "error", "msg": "Do you hate yourself?!"}')
user.delete()
def test_remove_inexistent_friendship(self):
user = create_logged_user(username='******')
user2 = create_user(last_name='remove_inexistent_friendship-2', first_name='remove_inexistent_friendship-2', username='******')
self.http_client.fetch(self.get_url('/friendship/remove?username=%s&auth=should-be-user-auth' % user2.username), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(response.body, '{"status": "error", "msg": "This user are not your friend!"}')
user.delete()
user2.delete()
def test_remove_inexistent_friendship_with_inexistent_user(self):
user = create_logged_user()
self.http_client.fetch(self.get_url('/friendship/remove?username=0&auth=should-be-user-auth'), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(response.body, '{"status": "error", "msg": "Inexistent user!"}')
user.delete()
def ids(self):
session = meta.get_session()
result = session.execute('select context_id from context')
return [row['context_id'] for row in result.fetchall()]
def save(self):
session = meta.get_session()
if not self.id:
session.add(self)
session.flush()
def delete(self):
session = meta.get_session()
session.delete(self)
session.flush()
def all(cls, limit=None):
session = meta.get_session()
if limit:
return session.query(cls).all()[limit[0]:limit[1]]
return session.query(cls).all()
def fetch_by(cls, **kw):
session = meta.get_session()
return session.query(cls).filter_by(**kw)
def get(cls, id):
session = meta.get_session()
return session.query(cls).get(id)
def get_profile_ids(self):
session = meta.get_session()
result = session.execute('select id from user_profile')
return [row['id'] for row in result.fetchall()]
class UserHandlerTestCase(AsyncHTTPTestCase):
session = get_session()
def get_app(self):
routes = [(r"/login", LoginHandler),
(r"/login/create", CreateLoginHandler),
(r"/user.json", UserHandler),
(r"/search/users.json", UserSearchHandler)]
return tornado.web.Application(routes)
def test_can_login(self):
user = create_user(username='******')
self.http_client.fetch(
self.get_url('/login') +
'?username=%s&password=should-be-password' % user.username,
self.stop)
response = self.wait()
cache = get_cache()
username = cache.get(simplejson.loads(response.body)['msg'])
assert username == user.username
user.delete()
def test_create_user(self):
self.http_client.fetch(
self.get_url('/login/create') +
'?username=should-be-username&[email protected]&firstName=test_create_user&lastName=should-be-last-name&gender=M',
self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
'{"status": "ok", "msg": "Account Created! Verify you email account"}'
)
user_db = self.session.query(User).filter(
User.email == '*****@*****.**').first()
user_db.delete()
def test_create_existent_user(self):
user = create_user(username="******",
email="*****@*****.**")
self.http_client.fetch(
self.get_url('/login/create') +
'?username=%s&email=%s&firstName=%s&lastName=%s&gender=M' %
(user.username, user.email, user.first_name, user.last_name),
self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
'{"status": "error", "msg": "Username already exists."}')
user.delete()
def test_get_user_myself(self):
user = create_logged_user()
self.http_client.fetch(
self.get_url('/user.json?auth=should-be-user-auth'), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(response.body,
simplejson.dumps({'user': user.as_dict()}))
user.delete()
def test_get_other_user(self):
user = create_logged_user(username="******")
user2 = create_user(username="******")
self.http_client.fetch(
self.get_url('/user.json?username=%s&auth=should-be-user-auth' %
user2.username), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(response.body,
simplejson.dumps({'user': user2.as_dict()}))
user.delete()
user2.delete()
def test_get_other_inexistent_user(self):
user = create_logged_user(username='******')
self.http_client.fetch(
self.get_url(
'/user.json?username=anybody&auth=should-be-user-auth'),
self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
simplejson.dumps({
"status": "error",
"msg": "User not found."
}))
user.delete()
def test_search_user(self):
user = create_logged_user(username="******")
user2 = create_user(username="******")
user3 = create_user(username="******")
self.http_client.fetch(
self.get_url(
'/search/users.json?username=%s&auth=should-be-user-auth' %
"test_"), self.stop)
response = self.wait()
self.failIf(response.error)
self.assertEqual(
response.body,
simplejson.dumps({'users': [user2.as_dict(),
user3.as_dict()]}))
user.delete()
user2.delete()
user3.delete()
