def get(self):
self.login()
conversations = [self.datastore_fetcher.get(db.Key.from_path('User', self.user_key.id_or_name(), 'UserChat', c.id_or_name()))
for c in db.Query(models.UnreadChat, keys_only = True).ancestor(self.user_key).fetch(5)]
peer_keys = [common.get_ref_key(c.get_result(), 'peer_userchat').parent() for c in conversations]
peers_status = [self.memcache_fetcher.get(config.MEMCACHE_LAST_BEEN_ONLINE(pk.id_or_name())) for pk in peer_keys]
conversations_value = []
for i in range(len(conversations)):
conv = conversations[i].get_result()
status_class = "online" if peers_status[i].get_result() is not None else "offline"
username = models.User.get_username(peer_keys[i])
c = {'username' : username, 'title' : conv.title, 'name' : conv.name, 'status_class' : status_class}
conversations_value.append(c)
context = get_user_context(self.user_key)
if context:
self.template_values['context'] = context
self.template_values['top_searches'] = get_top_searches()
self.template_values['conversations'] = conversations_value
self.template_values['num_online_users'] = get_num_online_users()
self.render_page('HomePage.html')
def get(self, userchat_name):
userchat_name = unquote_plus(userchat_name)
userchat = db.Query(models.UserChat).ancestor(self.get_current_user_key()).filter('name =', userchat_name).get()
if not userchat:
self.response.set_status(404)
return
self.login(chat_id = userchat.key().id_or_name())
chat_key = db.Key.from_path('Chat', userchat.key().id_or_name())
messages_query = db.Query(models.Message).ancestor(chat_key).order('-date_time')
messages = messages_query.fetch(config.CHAT_HISTORY_MESSAGE_COUNT)
try:
chat_timestamp = messages[0].date_time
except IndexError:
chat_timestamp = self.now
messages.reverse()
peer_key = common.get_ref_key(userchat, 'peer_userchat').parent()
peer_status = self.memcache_fetcher.get(config.MEMCACHE_LAST_BEEN_ONLINE(peer_key.id_or_name()))
self.template_values["peer_username"] = models.User.get_username(peer_key)
self.template_values["peer_status_class"] = "offline" if peer_status.get_result() is None else "online"
self.template_values["title"] = userchat.title
self.template_values["userchat_key"] = userchat.key()
self.template_values["messages"] = [{'message_string': msg.message_string, 'username': models.User.get_username(common.get_ref_key(msg, 'sender').parent())} for msg in messages]
if len(messages) >= config.CHAT_HISTORY_MESSAGE_COUNT:
self.template_values['more_cursor'] = messages_query.cursor()
self.client_update['chat_timestamp'] = str(chat_timestamp)
self.render_page('ChatPage.html')
def hookup(user_key, queue_key):
now = datetime.datetime.now()
q = db.get(queue_key)
timediff = now - q.timestamp
if q is not None:
if q.timestamp < (now - datetime.timedelta(seconds = config.RANDOM_CHAT_WAIT)):
db.delete(q)
return False
if common.get_ref_key(q, 'peer') is None:
q.peer = user_key
q.put()
return True
return False
def hookup(user_key, queue_key):
now = datetime.datetime.now()
q = db.get(queue_key)
timediff = now - q.timestamp
if q is not None:
if q.timestamp < (
now - datetime.timedelta(seconds=config.RANDOM_CHAT_WAIT)):
db.delete(q)
return False
if common.get_ref_key(q, 'peer') is None:
q.peer = user_key
q.put()
return True
return False
def post(self):
username = self.request.get("username", None)
password_hash = common.get_hash(self.request.get("password", ""))
m = db.Query(models.Login).filter('username ='******'password_hash =', password_hash).get()
if m is None:
self.login()
self.template_values["login_username"] = username
self.template_values["message"] = "Invalid username or password."
self.render_page('LoginPage.html')
return
self.login_user(common.get_ref_key(m, 'user'), True if self.request.get('rememberme') else False)
self.redirect("/")
return
def post(self):
username = self.request.get("username", None)
password_hash = common.get_hash(self.request.get("password", ""))
m = db.Query(models.Login).filter('username ='******'password_hash =', password_hash).get()
if m is None:
self.login()
self.template_values["login_username"] = username
self.template_values["message"] = "Invalid username or password."
self.render_page('LoginPage.html')
return
self.login_user(common.get_ref_key(m, 'user'),
True if self.request.get('rememberme') else False)
self.redirect("/")
return
def random_chat(user_key):
def hookup(user_key, queue_key):
now = datetime.datetime.now()
q = db.get(queue_key)
timediff = now - q.timestamp
if q is not None:
if q.timestamp < (
now - datetime.timedelta(seconds=config.RANDOM_CHAT_WAIT)):
db.delete(q)
return False
if common.get_ref_key(q, 'peer') is None:
q.peer = user_key
q.put()
return True
return False
peer_key = None
q_key = db.Key.from_path('RandomChatQueue', user_key.id_or_name())
q = models.RandomChatQueue.get(q_key)
if q:
peer_key = common.get_ref_key(q, 'peer')
else:
peers = db.Query(models.RandomChatQueue,
keys_only=True).filter('peer =', None)
for p in peers:
if db.run_in_transaction(hookup, user_key, p):
peer_key = db.Key.from_path('User', p.id_or_name())
break
if not peer_key:
q = models.RandomChatQueue(key=q_key)
q.put()
if peer_key is None:
return None
if q:
db.delete(q)
time.sleep(0.05) # wait for peer to finish creating UserChat instances
my_userchat, peer_userchat = create_chat(user_key,
peer_key,
title_1="random",
title_2="random")
return my_userchat.name
def get(self):
self.login()
conversations = [
self.datastore_fetcher.get(
db.Key.from_path('User', self.user_key.id_or_name(),
'UserChat', c.id_or_name()))
for c in db.Query(models.UnreadChat, keys_only=True).ancestor(
self.user_key).fetch(5)
]
peer_keys = [
common.get_ref_key(c.get_result(), 'peer_userchat').parent()
for c in conversations
]
peers_status = [
self.memcache_fetcher.get(
config.MEMCACHE_LAST_BEEN_ONLINE(pk.id_or_name()))
for pk in peer_keys
]
conversations_value = []
for i in range(len(conversations)):
conv = conversations[i].get_result()
status_class = "online" if peers_status[i].get_result(
) is not None else "offline"
username = models.User.get_username(peer_keys[i])
c = {
'username': username,
'title': conv.title,
'name': conv.name,
'status_class': status_class
}
conversations_value.append(c)
context = get_user_context(self.user_key)
if context:
self.template_values['context'] = context
self.template_values['top_searches'] = get_top_searches()
self.template_values['conversations'] = conversations_value
self.template_values['num_online_users'] = get_num_online_users()
self.render_page('HomePage.html')
def get(self):
self.login()
convs_query = db.Query(models.UserChat).ancestor(self.user_key).order('-last_updated')
cur = self.request.get('cursor')
if cur:
convs_query.with_cursor(start_cursor = cur)
with_cursor = True
else:
with_cursor = False
conversations = []
users_status = []
unread_chats = []
counter = 0
cursor = None
for conv in convs_query:
if not conv.last_updated:
continue
counter += 1
c = {'title' : conv.title, 'name' : conv.name}
peer_key = common.get_ref_key(conv, 'peer_userchat').parent()
c['username'] = models.User.get_username(peer_key)
conversations.append(c)
unread_chats.append(self.datastore_fetcher.get(db.Key.from_path('User', self.user_key.id_or_name(), 'UnreadChat', conv.key().id_or_name())))
users_status.append(self.memcache_fetcher.get(config.MEMCACHE_LAST_BEEN_ONLINE(peer_key.id_or_name())))
if counter >= config.ITEMS_PER_PAGE:
cursor = convs_query.cursor()
break
for i in range(len(conversations)):
conv = conversations[i]
status_class = "online" if users_status[i].get_result() is not None else "offline"
conv['status_class'] = status_class
conv['unread'] = False if unread_chats[i].get_result() is None else True
self.template_values["conversations"] = conversations
self.template_values["cursor"] = cursor
self.template_values["with_cursor"] = with_cursor
self.render_page('InboxPage.html')
def random_chat(user_key):
def hookup(user_key, queue_key):
now = datetime.datetime.now()
q = db.get(queue_key)
timediff = now - q.timestamp
if q is not None:
if q.timestamp < (now - datetime.timedelta(seconds = config.RANDOM_CHAT_WAIT)):
db.delete(q)
return False
if common.get_ref_key(q, 'peer') is None:
q.peer = user_key
q.put()
return True
return False
peer_key = None
q_key = db.Key.from_path('RandomChatQueue', user_key.id_or_name())
q = models.RandomChatQueue.get(q_key)
if q:
peer_key = common.get_ref_key(q, 'peer')
else:
peers = db.Query(models.RandomChatQueue, keys_only = True).filter('peer =', None)
for p in peers:
if db.run_in_transaction(hookup, user_key, p):
peer_key = db.Key.from_path('User', p.id_or_name())
break
if not peer_key:
q = models.RandomChatQueue(key = q_key)
q.put()
if peer_key is None:
return None
if q:
db.delete(q)
time.sleep(0.05) # wait for peer to finish creating UserChat instances
my_userchat, peer_userchat = create_chat(user_key, peer_key, title_1 = "random", title_2 = "random")
return my_userchat.name
def get_update(self):
update_id = self.request.get("update_id", None)
if update_id is not None:
update_id = int(update_id)
chat_update_id = self.request.get("chat_update_id", None)
if chat_update_id is not None:
chat_update_id = int(chat_update_id)
userchat_key = db.Key(self.request.get("userchat_key", None))
chat_id = userchat_key.id_or_name()
if chat_id:
peer_id_holder = self.memcache_fetcher.get(
config.MEMCACHE_PEER_ID(userchat_key.parent().id_or_name(), chat_id)
)
self.login(prev_update_id=update_id, chat_id=chat_id, prev_chat_update_id=chat_update_id)
message = None
if chat_id:
if userchat_key.parent() != self.user_key:
self.response.set_status(404)
return
chat_key = db.Key.from_path("Chat", chat_id)
chat_timestamp = common.str2datetime(self.request.get("chat_timestamp"))
message = self.request.get("message", None)
peer_id = peer_id_holder.get_result()
if peer_id is None:
userchat = self.datastore_fetcher.get(userchat_key)
peer_userchat_key = common.get_ref_key(userchat.get_result(), "peer_userchat")
peer_id = peer_userchat_key.parent().id_or_name()
memcache.set(peer_id_holder.get_key(), peer_id, time=600)
peer_status = self.memcache_fetcher.get(config.MEMCACHE_LAST_BEEN_ONLINE(peer_id))
message_entity = None
if message:
message = common.htmlize_string(common.sanitize_string(message))
message_entity = models.Message(parent=chat_key, message_string=message, sender=userchat_key)
peer_chat_open = self.memcache_fetcher.get(config.MEMCACHE_USER_OPEN_CHAT(peer_id, chat_id))
if peer_chat_open.get_result() is None:
peer_unreadchat_key = db.Key.from_path("User", peer_id, "UnreadChat", chat_id)
peer_unreadchat = models.UnreadChat(key=peer_unreadchat_key)
userchat_holder = self.datastore_fetcher.get(userchat_key)
peer_userchat_holder = self.datastore_fetcher.get(
db.Key.from_path("User", peer_id, "UserChat", chat_id)
)
userchat = userchat_holder.get_result()
peer_userchat = peer_userchat_holder.get_result()
userchat.last_updated = self.now
peer_userchat.last_updated = self.now
db.put([message_entity, peer_unreadchat, peer_userchat, userchat])
peer_update_id = memcache.incr(config.MEMCACHE_USER_UPDATE_ID(peer_id), initial_value=0)
memcache.set(
config.MEMCACHE_USER_NOTIFICATION(peer_id, peer_update_id),
{
"username": models.User.get_username(self.user_key),
"chat_id": chat_id,
"message": message,
"link": "/chat/%s" % models.User.get_username(self.user_key),
"timestamp": message_entity.date_time,
},
time=config.NOTIFICATION_DURATION,
)
else:
db.put(message_entity)
if self.chat_update_id:
new_messages = (
db.Query(models.Message)
.ancestor(chat_key)
.filter("date_time >", chat_timestamp)
.order("-date_time")
.fetch(10)
)
try:
self.client_update["chat_timestamp"] = str(new_messages[0].date_time)
except:
pass
new_messages.reverse()
template_values = {
"username": models.User.get_username(self.user_key),
"messages": [
{
"message_string": msg.message_string,
"username": models.User.get_username(common.get_ref_key(msg, "sender").parent()),
}
for msg in new_messages
],
}
path = os.path.join(os.path.dirname(__file__), "_messages.html")
self.client_update["messages_html"] = template.render(path, template_values).decode("utf-8")
elif message_entity is not None:
self.client_update["chat_timestamp"] = str(message_entity.date_time)
template_values = {
"username": models.User.get_username(self.user_key),
"messages": [
{
"message_string": message_entity.message_string,
"username": models.User.get_username(common.get_ref_key(message_entity, "sender").parent()),
}
],
}
path = os.path.join(os.path.dirname(__file__), "_messages.html")
self.client_update["messages_html"] = template.render(path, template_values).decode("utf-8")
if chat_id and message_entity:
self.chat_update_id = memcache.incr(config.MEMCACHE_CHAT_UPDATE_ID(chat_id), delta=1, initial_value=0)
self.client_update["status_class"] = "offline" if peer_status.get_result() is None else "online"
self._get_client_update()
return self.client_update
def get_update(self):
update_id = self.request.get('update_id', None)
if update_id is not None:
update_id = int(update_id)
chat_update_id = self.request.get('chat_update_id', None)
if chat_update_id is not None:
chat_update_id = int(chat_update_id)
userchat_key = db.Key(self.request.get("userchat_key", None))
chat_id = userchat_key.id_or_name()
if chat_id:
peer_id_holder = self.memcache_fetcher.get(
config.MEMCACHE_PEER_ID(userchat_key.parent().id_or_name(),
chat_id))
self.login(prev_update_id=update_id,
chat_id=chat_id,
prev_chat_update_id=chat_update_id)
message = None
if chat_id:
if userchat_key.parent() != self.user_key:
self.response.set_status(404)
return
chat_key = db.Key.from_path('Chat', chat_id)
chat_timestamp = common.str2datetime(
self.request.get('chat_timestamp'))
message = self.request.get("message", None)
peer_id = peer_id_holder.get_result()
if peer_id is None:
userchat = self.datastore_fetcher.get(userchat_key)
peer_userchat_key = common.get_ref_key(userchat.get_result(),
'peer_userchat')
peer_id = peer_userchat_key.parent().id_or_name()
memcache.set(peer_id_holder.get_key(), peer_id, time=600)
peer_status = self.memcache_fetcher.get(
config.MEMCACHE_LAST_BEEN_ONLINE(peer_id))
message_entity = None
if message:
message = common.htmlize_string(
common.sanitize_string(message))
message_entity = models.Message(parent=chat_key,
message_string=message,
sender=userchat_key)
peer_chat_open = self.memcache_fetcher.get(
config.MEMCACHE_USER_OPEN_CHAT(peer_id, chat_id))
if peer_chat_open.get_result() is None:
peer_unreadchat_key = db.Key.from_path(
'User', peer_id, 'UnreadChat', chat_id)
peer_unreadchat = models.UnreadChat(
key=peer_unreadchat_key)
userchat_holder = self.datastore_fetcher.get(userchat_key)
peer_userchat_holder = self.datastore_fetcher.get(
db.Key.from_path('User', peer_id, 'UserChat', chat_id))
userchat = userchat_holder.get_result()
peer_userchat = peer_userchat_holder.get_result()
userchat.last_updated = self.now
peer_userchat.last_updated = self.now
db.put([
message_entity, peer_unreadchat, peer_userchat,
userchat
])
peer_update_id = memcache.incr(
config.MEMCACHE_USER_UPDATE_ID(peer_id),
initial_value=0)
memcache.set(
config.MEMCACHE_USER_NOTIFICATION(
peer_id, peer_update_id),
{
'username':
models.User.get_username(self.user_key),
'chat_id':
chat_id,
'message':
message,
'link':
'/chat/%s' %
models.User.get_username(self.user_key),
'timestamp':
message_entity.date_time,
},
time=config.NOTIFICATION_DURATION,
)
else:
db.put(message_entity)
if self.chat_update_id:
new_messages = db.Query(
models.Message).ancestor(chat_key).filter(
'date_time >',
chat_timestamp).order('-date_time').fetch(10)
try:
self.client_update['chat_timestamp'] = str(
new_messages[0].date_time)
except:
pass
new_messages.reverse()
template_values = {
"username":
models.User.get_username(self.user_key),
"messages": [{
'message_string':
msg.message_string,
'username':
models.User.get_username(
common.get_ref_key(msg, 'sender').parent())
} for msg in new_messages],
}
path = os.path.join(os.path.dirname(__file__),
'_messages.html')
self.client_update['messages_html'] = template.render(
path, template_values).decode('utf-8')
elif message_entity is not None:
self.client_update['chat_timestamp'] = str(
message_entity.date_time)
template_values = {
"username":
models.User.get_username(self.user_key),
"messages": [{
'message_string':
message_entity.message_string,
'username':
models.User.get_username(
common.get_ref_key(message_entity,
'sender').parent())
}],
}
path = os.path.join(os.path.dirname(__file__),
'_messages.html')
self.client_update['messages_html'] = template.render(
path, template_values).decode('utf-8')
if chat_id and message_entity:
self.chat_update_id = memcache.incr(
config.MEMCACHE_CHAT_UPDATE_ID(chat_id),
delta=1,
initial_value=0)
self.client_update[
'status_class'] = "offline" if peer_status.get_result(
) is None else "online"
self._get_client_update()
return self.client_update
def get(self):
userchat_key = db.Key(self.request.get('userchat_key', None))
if self.get_current_user_key() != userchat_key.parent():
self.response.set_status(403)
return
cursor = self.request.get('cursor')
chat_key = db.Key.from_path('Chat', userchat_key.id_or_name())
messages_query = db.Query(models.Message).ancestor(chat_key).order('-date_time')
messages_query.with_cursor(cursor)
messages = messages_query.fetch(config.CHAT_HISTORY_MESSAGE_COUNT)
messages.reverse()
template_values = {'username' : models.User.get_username(userchat_key.parent())}
if len(messages) >= config.CHAT_HISTORY_MESSAGE_COUNT:
template_values['more_cursor'] = messages_query.cursor()
template_values["messages"] = [{'message_string': msg.message_string, 'username': models.User.get_username(common.get_ref_key(msg, 'sender').parent())} for msg in messages]
import os
path = os.path.join(os.path.dirname(__file__), '_messages.html')
self.response.out.write(template.render(path, template_values))
