def post(self):
"""
Add new messages to the specified group
:Parameters:
- `session_data`: See `pms.server.server.is_valid_key`
- `group`: The group the message is been sent to
- `message`: The message to be added
"""
user, user_data = server.is_valid_key(self)
if user:
group_name = escape(self.request.get("group"))
message = escape(self.request.get("message"))
if message == "" or group_name == "":
return server.response(self, {"status" : "MISSINGVALUES"})
group = memcache.get("group-" + group_name)
if group is None:
group = models.Group.get_by_key_name(group_name)
if group is None:
return server.response(self, {"status" : "NOTGROUP"})
member = memcache.get("member-" + user.name + group.name)
if member is None:
member = models.GroupMember.all().filter("group =", group).filter("user ="******"status" : "NONMEMBER"})
#cache member and group
memcache.set("member-" + user.name + group.name, member)
memcache.set("group-" + group.name, group)
mess = models.Message(user=user, group=group, comment=message, date=int(time.time()))
mess.put()
#cache this date for other users
memcache.set("last_message-" + group.name, mess.date)
server.response(self)
else:
server.response(self, {"status" : "BADAUTH"})
def post(self):
user, user_data = server.is_valid_key(self)
if not user:
return server.response(self, {"values" : "BADAUTH"})
password_required = True if self.request.get("password") != "" else False
group = escape(self.request.get("group"))
if group == "":
return server.response(self, {"status" : "MISSINGVALUES"})
if password_required:
salt = server.generate_salt()
password = hashlib.sha1(self.request.get("password") + salt).hexdigest()
else:
password = None
salt = None
description = escape(self.request.get("description"))
check = models.Group.get_by_key_name(group)
if check is not None:
return server.response(self, {"status" : "GROUPEXISTS"})
new_group = models.Group(key_name=group, name=group, owner=user,
description=description,
password_required=password_required,
password=password, salt=salt)
new_group.put()
memcache.delete("user-groups" + user.name)
member = models.GroupMember(group=new_group, user=user)
member.put()
server.response(self)
def post(self):
user, user_data = server.is_valid_key(self)
if not user:
return server.response(self, values={"status" : "BADAUTH"})
logged_in = memcache.get("logged_in")
del(logged_in[user.name])
memcache.set("logged_in", logged_in)
server.response(self)
def post(self):
user, user_details = server.is_valid_key(self)
if not user:
return server.response(self, values={"status" : "BADAUTH"})
facebook_session_key = models.FacebookSession.get_by_key_name(user.name)
if not facebook_session_key:
return server.response(self, values={"status" : "NOFBKEY"})
return server.response(self, values={"status": "OK", "session" : facebook_session_key},
template="session")
def post(self):
user, userdata = server.is_valid_key(self)
group = models.Group.get_by_key_name(self.request.get("group"))
if group is None:
return server.response(self, {"status" : "NOGROUP"})
if models.GroupMember.all().filter("group =", group).count(2) > 1:
return server.response(self, {"status" : "HASMEMBERS"})
member = models.GroupMember.all().filter("group =", group).get()
member.delete()
group.delete()
memcache.delete("user-groups" + user.name)
server.response(self)
def post(self):
"""Logs the user in so other can see they are online. This should be called
at least every 10 minutes otherwise the users status will be set to offline
Returns the current ONLINE list"""
user, user_data = server.is_valid_key(self)
if not user:
return server.response(self, values={"status" : "BADAUTH"})
logged_in = memcache.get("logged_in")
if logged_in is None:
logged_in = {}
logged_in[user.name] = time.time()
memcache.set("logged_in", logged_in)
server.response(self, values={'status' : 'OK', "users" : logged_in}, template="loginlist")
def post(self):
user, userdata = server.is_valid_key(self)
group = models.Group.get_by_key_name(self.request.get("group"))
if group is None:
return server.response(self, {"status" : "NOGROUP"})
member = models.GroupMember.all().filter("group =", group).filter("user ="******"status" : "NONMEMBER"})
#owners cant leave their group
if user.name == group.owner.name:
return server.response(self, {"status" : "ISOWNER"})
member.delete()
memcache.delete("user-groups" + user.name)
server.response(self)
def post(self):
user, userdata = server.is_valid_key(self)
group = models.Group.get_by_key_name(self.request.get("group"))
if group is None:
return server.response(self, {"status" : "NOGROUP"})
if user.name != group.owner.name:
return server.response(self, {"status" : "NOTOWNER"})
owner = models.GroupMember.all().filter("group =", group).filter("user ="******"newowner"))
is_member = models.GroupMember.all().filter("group =", group).filter("user = "******"status" : "NONMEMBER"})
owner.owner = new_owner
owner.put()
server.response(self)
def post(self):
user, user_details = server.is_valid_key(self)
if not user:
return server.response(self, values={"status": "BADAUTH"})
facebook_session_key = models.FacebookSession.get_by_key_name(user.name)
if not facebook_session_key:
facebook_session_key = models.FacebookSession(key_name=user.name,
user=user, uid=self.request.get("uid"),
session_key=self.request.get("facebook_session_key"),
expires=int(self.request.get("expires")))
else:
facebook_session_key.uid = self.request.get("uid")
facebook_session_key.session_key = self.request.get("facebook_session_key")
facebook_session_key.expires = int(self.request.get("expires"))
facebook_session_key.put()
return server.response(self)
def post(self):
user, userdata = server.is_valid_key(self)
if not user:
return server.response(self, {"status": userdata})
if self.request.get("group") == "":
return server.response(self, {"status" : "MISSINGVALUES"})
group = models.Group.get_by_key_name(self.request.get("group"))
if group is None:
return server.response(self, {"status" : "NOTGROUP"})
if group.password_required:
password = hashlib.sha1(self.request.get("password") + group.salt).hexdigest()
if password != group.password:
return server.response(self, {"status" : "BADPASS"})
member = models.GroupMember(group=group, user=user)
member.put()
memcache.delete("user-groups" + user.name)
return server.response(self)
def post(self):
"""
Update the users avatar
:Parameters:
- `session_data`: See `pms.server.server.is_valid_key`
- avatar: An image containing the new avatar
"""
user, user_data = server.is_valid_key(self)
if not user:
return server.response(self, {"status" : "BADAUTH"})
users_avatar = models.UserAvatar.get_by_key_name(user.name)
if users_avatar is None:
users_avatar = models.UserAvatar(key_name=user.name)
users_avatar.avatar = str(self.request.get("avatar"))
users_avatar.user = user
users_avatar.upload_time = time.time()
users_avatar.put()
memcache.set("useravatar-" + user.name, users_avatar)
return server.response(self)
def post(self):
"""
Checks the server for new messages
:Parameters:
- session_data: See `pms.server.server.is_valid_key`
- time: The timestamp of the last message recieved
"""
user, user_data = server.is_valid_key(self)
if not user:
return server.response(self, {"status" : "BADAUTH"})
last_checked = int(self.request.get("time"))
membership = memcache.get("user-groups" + user.name)
if membership is None:
membership = models.GroupMember.all().filter("user ="******"user-groups" + user.name, membership)
all_messages = []
for member in membership:
logging.info("Checking %s" % member.group.name)
if member.group.name == "Facebook":
continue
last_message = memcache.get("last_message-" + member.group.name)
logging.info("Last stored message in memcache: %s" % last_message)
if last_message is not None:
logging.info("%s : %s" % (last_message, last_checked))
if last_message == "No new" or int(last_message) == last_checked:
continue
logging.info("Using datastore for %s" % member.group.name)
logging.info("Last check: %s" % last_checked)
messages = models.Message.all().filter("group =", member.group).filter(
"date >", last_checked).order("-date").fetch(100)
for message in messages:
logging.info("date: %s" % message.date)
if len(messages) > 0:
logging.info("We have %s messages, setting memcache" % len(messages))
memcache.set("last_message-" + member.group.name, float(messages[0].date))
else:
logging.info("No new messages")
memcache.set("last_message-" + member.group.name, "No new")
all_messages.extend(messages)
server.response(self, values={"status" : "OK", "messages" : all_messages}, template="messages")
def post(self):
"""
Outputs a list of avatars for users this user requires the avatar for,
uploaded after a certain time. This is desirable if there are many users.
:Paramters:
- `session_data`: See `pms.server.server.is_valid_key`
- time: A unix timestamp of the last downloaded avatar
- userlist: A list of users we want to check
"""
user, user_details = server.is_valid_key(self)
last_time = self.request.get("time")
if not user:
return server.response(self, values={"status" : "BADAUTH"})
userlist = self.request.get("userlist").split(",")
logging.info(str(userlist))
new_avatars = []
logging.info("name list %s" % str(userlist))
for name in userlist:
avatar = memcache.get("useravatar-" + name)
if avatar is None:
avatar = models.UserAvatar.get_by_key_name(name)
memcache.set("useravatar-" + name, avatar)
if avatar is None:
logging.info("There is no avatar for '%s' continue" % name)
continue
if last_time != "all":
logging.info(avatar.upload_time - float(last_time))
if last_time == "all":
new_avatars.append(avatar)
logging.info("Appended avatar")
elif avatar.upload_time > float(last_time):
new_avatars.append(avatar)
logging.info("Appended avatar")
else:
logging.info("avatar not appened: %s" % name)
logging.info("upload time: %s last time: %s" % (avatar.upload_time, last_time))
return server.response(self, values={"status" : "OK", "avatars" : new_avatars},
template="avatars")
