def testDeleteDictEntry(self):
today = datetime.date.today()
current_time = int(time.time())
u = self.createUser("da_zbur", "enabled", 10)
u.use_questions = "yes"
u.put()
d1 = self.createDictEntry("da_zbur", 2, "lucrative", \
u"profitable, moneymaking, remunerative", "[LOO-kruh-tiv]")
d2 = self.createDictEntry("da_zbur", 2, "ferociously(en)", \
u"жестоко, яростно, свирепо, дико, неистово. Ужасно, невыносимо.")
l1 = self.createLearnListItem("da_zbur", d1, today, current_time)
l2 = self.createLearnListItem("da_zbur", d2, today, current_time)
self.createQuestion(l1, today, "da_zbur", d1.word,
"profitable, moneymaking", 1, today, 100)
self.createQuestion(l2, today, "da_zbur", d2.word,
u"лажа", 2, today, 0)
deleteDictEntry(u, "lucrative[LOO-kruh-tiv]")
self.assertEqual(None, Dictionary.all().\
filter("word =", "lucrative").get())
self.assertEqual(1, LearnList.all().count())
self.assertEqual(1, Question.all().count())
self.assertEqual(1, Dictionary.all().count())
def getUsers():
userlist = []
for user in User.all().order("-total_points").run():
c = Dictionary.all().\
filter("twitter_user ="******"username": user.twitter, "points": user.total_points,
"wordscount": c})
return json.dumps(userlist)
def __init__(self):
i = words_iter()
if i:
self.words_iterator = i
else:
words = Dictionary.all().filter("twitter_user ="******"words":words,"pos":0}
set_words_iter(self.words_iterator)
def get(self):
user = current_user()
if not user:
self.redirect("/login")
else:
parameters = {}
parameters["total_points"] = User.all().\
filter("twitter =", user.twitter).get().total_points
parameters["total_words"] = Dictionary.all().\
filter("twitter_user =", user.twitter).count()
self.view(parameters)
def deleteDictEntry(user, word):
word, _ = parseOpt(word)
dict_entry = Dictionary.all().\
filter("twitter_user ="******"word =", word.strip()).get()
if dict_entry:
lli = LearnList.all().\
filter("dict_entry =", dict_entry.key()).get()
for q in Question.all().filter("lli_ref =", lli.key()).run():
q.delete()
lli.delete()
dict_entry.delete()
return json.dumps({})
def editDictEntry(user, original_word, new_string):
original_word, _ = parseOpt(original_word)
dict_entry = Dictionary.all().\
filter("twitter_user ="******"word =", original_word.strip()).get()
if dict_entry:
parsed_dict = parseMessage(new_string, '')
if parsed_dict != {}:
dict_entry.word = parsed_dict["word"]
dict_entry.meaning = parsed_dict["meaning"]
dict_entry.pronounce = parsed_dict["pronounce"]
dict_entry.put()
return json.dumps({})
def testProcessDuplicateWord(self):
json_file = open("files/direct_message1.json")
message_json = simplejson.load(json_file)
twitter_dm = DirectMessage.NewFromJsonDict(message_json)
processMessage(twitter_dm)
json_file = open("files/direct_message1.json")
message_json = simplejson.load(json_file)
twitter_dm = DirectMessage.NewFromJsonDict(message_json)
processMessage(twitter_dm)
query = Dictionary.all()
results = query.fetch(1)
self.assertEqual(1, len(results))
def testProcessMessageFromNonExistentUser(self):
# Message from user "spammer" who doesn't exist in database
# It must not be processed and must not be saved
json_file = open("files/direct_message_spammer.json")
message_json = simplejson.load(json_file)
twitter_dm = DirectMessage.NewFromJsonDict(message_json)
processMessage(twitter_dm)
query = Dictionary.all()
results = query.fetch(1)
self.assertEqual(0, len(results))
self.assertEqual("spammer", twitter_dm.sender_screen_name)
# Test integration with LearnList
query = LearnList.all()
ll_results = query.fetch(2)
self.assertEqual(0, len(ll_results))
def addNewDictEntry(twitter_user, message_id, entry, served):
new_dict_entry = None
# No duplicate words allowed for a single user
c = Dictionary.all().filter("word =", entry["word"]).\
filter("twitter_user ="******"Count for word %s is %s" % (entry["word"], c))
if c == 0:
new_dict_entry = Dictionary()
new_dict_entry.pronounce = entry["pronounce"]
new_dict_entry.twitter_user = twitter_user
new_dict_entry.message_id = message_id
new_dict_entry.word = entry["word"]
new_dict_entry.meaning = entry["meaning"]
new_dict_entry.served = served
new_dict_entry.source_lang = entry["source_lang"]
new_dict_entry.put()
return new_dict_entry
def testProcessMessageNormalAddForExistingUser(self):
json_file = open("files/direct_message1.json")
message_json = simplejson.load(json_file)
twitter_dm = DirectMessage.NewFromJsonDict(message_json)
processMessage(twitter_dm)
query = Dictionary.all()
results = query.fetch(1)
self.assertEqual(1, len(results))
self.assertEqual("", results[0].pronounce)
self.assertEqual("da_zbur", results[0].twitter_user)
self.assertEqual(289180663729512448L, results[0].message_id)
self.assertEqual("to advet", results[0].word)
self.assertEqual(u"обращаться к,ссылаться на",\
results[0].meaning)
self.assertEqual(0, results[0].served)
self.assertEqual(None, results[0].source_lang)
self.assertEqual(1, User.all().filter("twitter =",\
"da_zbur").get().total_points)
# Test integration with LearnList
query = LearnList.all()
ll_results = query.fetch(2)
self.assertEqual(1, len(ll_results))
# Check if LearnList references same object
self.assertEqual(ll_results[0].dict_entry.key(), results[0].key())
def postMessage(self, user):
#print "You are %s " % user.twitter
words = Dictionary.all()\
.filter("twitter_user ="******"served < ", user.repeat_times)
dict_entry_list = []
message = ""
for entry in words:
dict_entry_list.append(entry)
#If user has enough his own words to fill all slots for the day
# If not we need to fill slots with words from people he follows
if len(dict_entry_list) < user.messages_per_day:
follow_list = user.i_follow.split(",")
# for an empty string split() return list with one '' element
if follow_list == ['']:
follow_list = []
# Let's shuffle the list so we get some variety in users
random.shuffle(follow_list)
for follow_user in follow_list:
f_repeat = 0
for f_user in User.all().filter("twitter =", follow_user):
f_repeat = f_user.repeat_times
# Getting list of languages user follows
follow_lang_list = f_user.follow_lang_list
l = []
for lang in follow_lang_list.split(","):
l.append("'"+lang+"'")
lang_str = "(" + ",".join(l) + ")"
words = Dictionary.all()\
.filter("twitter_user ="******"served < ", f_repeat)\
.filter("source_lang IN ", lang_str)
for entry in words:
dict_entry_list.append(entry)
#print "Adding %s from %s" % (entry.word, follow_user)
if len(dict_entry_list) >= user.messages_per_day:
break
#print "You have %d words in your list" % len(dict_entry_list)
# If we have any messages to send at all
if len(dict_entry_list) > 0:
dict_entry = random.sample(dict_entry_list,1)[0]
served = dict_entry.served + 1
if dict_entry.pronounce:
pronounce = dict_entry.pronounce
else:
pronounce = ""
count = " [%s]" % served
# If we are posting message from one of the followed_by list
# need to add (via @username) if total message is less than 140
# characters
if dict_entry.twitter_user != user.twitter:
via = "(via " + dict_entry.twitter_user + ")"
else:
via = ""
if user.default_source_lang != dict_entry.source_lang:
lang = " ("+dict_entry.source_lang+")"
else:
lang = ""
message = dict_entry.word+lang+pronounce+": "+dict_entry.meaning+count
if len(message+via) < 140:
message = message + via
if user.message_type == "reply":
try:
self.twitter.api.PostUpdate("@" + user.twitter + " " + message,
in_reply_to_status_id=dict_entry.message_id)
#print "You will be sent word %s %s" % (dict_entry.word, via)
except TwitterError:
logging.error("Twitter error: %s when sending message %s" %
(TwitterError.message, "@" + dict_entry.twitter_user+
" " + message))
# Direct message are no longer user
#if user.message_type == "direct":
# self.twitter.api.PostDirectMessage(dict_entry.twitter_user, message)
# We do not change served field for word from other users
if via == "":
dict_entry.served = dict_entry.served + 1
dict_entry.put()
return message
