def post(self, category=None): """Feedback form post""" user = users.get_current_user() prefs = InternalUser.from_user(user) values = {'prefs': prefs} msg = decode(self.request.get('msg')) #logging.info("msg: %s" % msg) if msg: if prefs: sender = "%s (%s)" % (prefs.nickname, prefs.email) else: sender = decode(self.request.get('email')) logging.info("feedback '%s' from %s" % (msg, sender)) message = mail.EmailMessage() message.sender = "Android Snippets <*****@*****.**>" message.to = "*****@*****.**" message.subject = "Android snippets feedback" message.body = "Feedback from: %s:\n\n%s" % (sender, msg) message.send() values["info"] = "Thank you, we have received your feedback." self.response.out.write( \ template.render(tdir + "about.html", values))
def action(self): t = self.file.readline() if t == '': time.sleep(1) elif t[:5] == "From:": self.mfrom = decode(t[5:].strip()) elif t[:8] == "Subject:": self.msubject = decode(t[8:].strip()) elif t[:13] == "X-Spam-Score:": try: self.spam = float(t[14:].strip()) except: self.spam = -2 elif t[:14] == "X-Spam-Status:": try: self.spam = float(t[14:].split("=")[1].split()[0].strip()) except: self.spam = -2 if self.mfrom != "" and self.msubject != "": if self.spam < 0: try: self.bot.say(">> Mail de %s : %s (Spam Score : %f)" % (self.mfrom, self.msubject, self.spam)) except: self.bot.say(">> Mail de %s : <encodage foireux> (Spam Score : %f)" % (self.mfrom, self.spam)) self.mfrom = "" self.msubject = "" self.spam = -1
def get(self, category=None): user = users.get_current_user() prefs = InternalUser.from_user(user) values = {'prefs': prefs, "stats": []} mc_items = ["pv_login", "pv_main", "pv_profile", "pv_snippet", \ "pv_snippet_legacy", "ua_vote_snippet", "ua_edit_snippet", \ "pv_snippet_edit", "pv_tag", "ua_comment", "ua_comment_spam", \ "ua_comment_ham", "pv_otherprofile", "pv_search", "pv_userlist", \ "pv_snippet_404", "_last_reset"] mc_items.sort() if not category: self.response.out.write( \ template.render(tdir + "admin.html", values)) if category == "/stats": for item in mc_items: values["stats"].append((item, memcache.get(item))) self.response.out.write( \ template.render(tdir + "admin_stats.html", values)) if category == "/stats/reset": for item in mc_items: memcache.set(item, 0) memcache.set("_last_reset", datetime.datetime.now()) self.redirect("/admin/stats") if category == "/revision": key = decode(self.request.get('k')) action = decode(self.request.get('a')) if key: rev = SnippetRevision.get(db.Key(key)) if rev: if action == "1": # use as default rev.merge(prefs) elif action == "2": # delete revision for v in rev.snippetrevisionupvote_set: v.delete() for v in rev.snippetrevisiondownvote_set: v.delete() rev.snippet.proposal_count -= 1 rev.snippet.put() rev.delete() self.redirect("/admin/revision") return values["rev"] = rev self.response.out.write( \ template.render(tdir + "admin_rev.html", values)) else: revs = SnippetRevision.all() revs.filter("merged =", False) revs.order("-date_submitted") values["revs"] = revs.fetch(40) self.response.out.write( \ template.render(tdir + "admin_revlist.html", values))
def get(self): memcache.incr("pv_userlist", initial_value=0) user = users.get_current_user() prefs = InternalUser.from_user(user) q = decode(self.request.get('q')) p = decode(self.request.get('p')) _users = InternalUser.all() if q == "1" or not q: _users.order("-points") else: #_users.filter("date_lastactivity !=", None) _users.order("-date_lastactivity") page = int(p) if p else 1 items_per_page = 40 n = items_per_page / 2 offset = (page - 1) * items_per_page _users1 = _users.fetch(n, offset) _users2 = _users.fetch(n, (offset + (items_per_page / 2))) values = {'prefs': prefs, 'users1': _users1, 'users2': _users2, 'page': page, 'pages': range(1, page), 'prefix': q} self.response.out.write( \ template.render(tdir + "users.html", values))
def action(self): t = self.file.readline() if t == '': time.sleep(1) elif t[:5] == "From:": self.mfrom = decode(t[5:].strip()) elif t[:8] == "Subject:": self.msubject = decode(t[8:].strip()) elif t[:13] == "X-Spam-Score:": try: self.spam = float(t[14:].strip()) except: self.spam = -2 elif t[:14] == "X-Spam-Status:": try: self.spam = float(t[14:].split("=")[1].split()[0].strip()) except: self.spam = -2 if self.mfrom != "" and self.msubject != "": if self.spam < 0: try: self.bot.say(">> Mail de %s : %s (Spam Score : %f)" % (self.mfrom, self.msubject, self.spam)) except: self.bot.say( ">> Mail de %s : <encodage foireux> (Spam Score : %f)" % (self.mfrom, self.spam)) self.mfrom = "" self.msubject = "" self.spam = -1
def create_files(src, inputfile, algorithm, language): # creating input file with right extension with open("in.{}".format(src), "w+") as data_to_parse: data_to_parse.write(decode(inputfile).decode('utf-8')) # creating code files if language == "python": with open("code.py", "w+") as code_to_run: code_to_run.write(decode(algorithm).decode('utf-8'))
def post(self): n1 = decode(self.request.get('n1')) n2 = decode(self.request.get('n2')) if not n1 or not n2: self.response.out.write("""username not found""") return u1 = InternalUser.all().filter("nickname =", n1).get() u2 = InternalUser.all().filter("nickname =", n2).get() action = decode(self.request.get('action')) if action == "do": # move snippets cnt1 = 0 for snippet in u1.snippet_set: snippet.userprefs = u2 snippet.put() cnt1 += 1 cnt1_2 = 0 for rev in u1.snippetrevision_set: rev.userprefs = u2 rev.put() cnt1_2 += 1 # move comments cnt2 = 0 for comment in u1.snippetcomment_set: comment.userprefs = u2 comment.put() cnt2 += 1 if u1.points: u2.points += u1.points u2.put() self.response.out.write("""Moved %s snippets, %s revisions, %s comments and %s points from '%s' to '%s'""" % (cnt1, \ cnt1_2, cnt2, u1.points, u1.nickname, u2.nickname)) return self.response.out.write("""<form action="/admin/mapsnippets_post" method="post"> <input type="hidden" name="n1" value="%s" /> <input type="hidden" name="n2" value="%s" /> <input type="hidden" name="action" value="do" /> <table border="0"><tr><td>From User:</td><td>%s</td></tr> <tr><td>To User:</td><td>%s</td></tr></table> <br> <input type="submit" value="move comments, snippets to new user" /> </form> """ % (n1, n2, u1.nickname, u2.nickname))
def get(self): user = users.get_current_user() prefs = InternalUser.from_user(user) title = unquote(decode(self.request.get('title'))) code = unquote(decode(self.request.get('code'))) description = decode(self.request.get('desc')) desc_md = markdown.markdown(unquote(description)) tags = decode(self.request.get('tags')) values = {"prefs": prefs, "title": title, "code": code, 'desc_md': \ desc_md, 'tags': tags, 'preview': True} self.response.out.write(template.render(tdir + \ "snippets_edit_view.html", values))
def post(self, snippet_slug): memcache.incr("ua_edit_snippet", initial_value=0) user = users.get_current_user() prefs = InternalUser.from_user(user) title = decode(self.request.get('title')) code = decode(self.request.get('code')) description = decode(self.request.get('description')) tags = decode(self.request.get('tags')) comment = decode(self.request.get('comment')) if not title or not code or not description: self.response.out.write("-1") return q = Snippet.all() q.filter("slug1 =", snippet_slug) snippet = q.get() if not snippet: self.error(404) return # Create a new revision r = SnippetRevision(userprefs=prefs, snippet=snippet) r.title = title r.description = description r.description_md = markdown.markdown(description).replace( \ "<a ", "<a target='_blank' rel='nofollow' ") r.code = code r.comment = comment r.put() # and not snippet.has_editors: if prefs.key() == snippet.userprefs.key() or \ prefs.level > 70: # Auto-merge new revision if edits only by author r.merge(merged_by=prefs) else: # Add proposal info if from another editor snippet.proposal_count += 1 snippet.date_lastproposal = datetime.datetime.now() snippet.date_lastactivity = datetime.datetime.now() snippet.save() # Set last activity on submitting user prefs.date_lastactivity = datetime.datetime.now() prefs.put() self.redirect("/%s" % snippet_slug)
def get(self, category=None): if not category or category == "/": category = "/active" memcache.incr("pv_main", initial_value=0) user = users.get_current_user() prefs = InternalUser.from_user(user) p = decode(self.request.get('p')) page = int(p) if p else 1 # Get snippets list from cache #mc.cache.snippet_list(None, clear=True) snippets = mc.cache.snippet_list(category, page) # Set title if category == "/new": title = "New Snippets" elif category == "/active": title = "Active Snippets" elif category == "/popular": title = "Popular Snippets" elif category == "/comments": title = "Recently Commented Snippets" elif category == "/edits": title = "Snippets with Edits" # Build template values = {'prefs': prefs, 'snippets': snippets, 'title': title, \ 'page': page, 'pages': range(1, page)} self.response.out.write(template.render(tdir + \ "snippet_list.html", values))
def post(self, comment_key): comment = SnippetComment.get(db.Key(comment_key)) if not comment: self.error(404) return msg = decode(self.request.get('msg')) update = decode(self.request.get('update')) delete = decode(self.request.get('delete')) if update: comment.comment = msg comment.comment_md = markdown.markdown(msg.replace( \ "<a ", "<a target='_blank' rel='nofollow' ")) comment.put() logging.info("comment updated by admin") # Update cached comments mc.cache.snippet_comments(comment.snippet.key(), True) mc.cache.snippet(comment.snippet.slug1, force_update=True) self.redirect("/admin/comment/%s" % comment_key) elif delete: redirect_to = "/%s" % comment.snippet.slug1 snippet = comment.snippet comment.delete() # Update snippet's date_lastcomment comments = snippet.snippetcomment_set.order("-date_submitted") comment_last = comments.fetch(1) if not comment_last: snippet.date_lastcomment = None else: snippet.date_lastcomment = comment_last[0].date_submitted # Update snippet's comment count snippet.comment_count -= 1 snippet.put() mc.cache.snippet_comments(snippet.key(), force_update=True) mc.cache.snippet(snippet.slug1, force_update=True) logging.info("comment deleted by admin") self.redirect(redirect_to)
def try_get(self): try: data, addr = self.socket.recvfrom(2**13) if data: return tools.decode(data) else: return None except socket.timeout: return None
def __init__(self, login, password, relog): if os.path.exists('user.json') and relog is True: with open('user.json', 'r') as f: user_data = json.load(f) self.login = user_data['login'] self.password = tools.decode(user_data['password']) else: self.login = str(login) self.password = str(password)
def get(self): memcache.incr("pv_search", initial_value=0) user = users.get_current_user() prefs = InternalUser.from_user(user) q = decode(self.request.get('q')) values = {'prefs': prefs, 'q': q} self.response.out.write( \ template.render(tdir + "search_results.html", values))
def get(self, snippet_slug): memcache.incr("pv_snippet", initial_value=0) memcache.incr("pv_snippet_%s" % snippet_slug, initial_value=0) user = users.get_current_user() prefs = InternalUser.from_user(user) _snippet = mc.cache.snippet(snippet_slug) if not _snippet: memcache.incr("pv_snippet_404", initial_value=0) logging.info("404: %s" % snippet_slug) # Show snippet-not-found.html values = {'prefs': prefs, "q": snippet_slug.replace("-", " ")} self.response.out.write(template.render(tdir + \ "snippets_notfound.html", values)) return # get count for tags on this snippet tags = mc.cache.tags_dict() for tag in _snippet["_tags"]: if not tag in tags: tags[tag] = 1 _snippet["tags"].append((tag, tags[tag])) # if commented and was marked as spam: commentspam = decode(self.request.get('c')) == "m" compose_reply = decode(self.request.get('r')) #logging.info("compose: %s" % compose_reply) # get cached comments comments_html = mc.cache.snippet_comments(_snippet["key"]) # get if this user has already voted has_voted = mc.cache.has_upvoted(prefs, _snippet["key"]) # related snippets related = mc.cache.snippets_related(snippet_slug) values = {"prefs": prefs, "snippet": _snippet, 'voted': has_voted, "comments_html": comments_html, 'commentspam': commentspam, \ "compose_reply": compose_reply, 'related_snippets': related} self.response.out.write(template.render(tdir + \ "snippets_view.html", values))
def bank_sorter(bank): """Sorts bank of tested compounds by fitness and returns all tested compounds and the matches to results_bank.""" keys = np.argsort(bank[:,-1]) for j in range(len(bank)): # sort the paramterized vectors sorted_bank[j,:] = bank[keys[j],:] # call decoder and get symbol symbol_bank.append(decode(sorted_bank[j,0:3])) final_bank = [name for name in symbol_bank if (name in results_bank)] symbol_bank_select = symbol_bank[0:50] return "all tested = " + str(symbol_bank_select), "matches = " + str(final_bank)
def process_default(self, event): """ Called when a new mail is received and placed in Maildir’s new mail folder. """ try: with open(event.pathname, 'r') as handle: data = handle.read() except IOError: return message = self._parser.parsestr(data, headersonly=True) msg_subject = decode(message['Subject']) msg_from = decode(message['From']) msg_spam = message['X-Spam-Score'] or "" try: msg_spam = float(msg_spam) except ValueError: msg_spam = None if not msg_subject: msg_subject = u"[Pas de sujet]" if not msg_from: msg_from = u"<Pas d’expéditeur>" result = u">> Mail de %s : %s" % (msg_from, msg_subject) if msg_spam is not None: result += u" (Spam Score: %.1f)" % msg_spam if msg_spam is None or msg_spam < 0.0: self.bot.say(result) os.rename(event.pathname, join(self.destpath, event.name)) self.cleanup()
def train(self): for line in self: self.i += 1 self.minimum = int(round(math.log(self.i, 10))) i = 0 for line in self: tokens = tokenize(decode(line).lower()) targets = self.get_targets(tokens) for gram in targets: self.posterior[gram] += 1 self.grams_by_line[i].add(gram) for token in gram: self.prior[token] += 1 i += 1 # print self.prior.most_common(10) # print self.posterior.most_common(10) self.crunch()
def get(self, snippet_slug, rev_key): memcache.incr("pv_snippet_edit", initial_value=0) user = users.get_current_user() prefs = InternalUser.from_user(user) rev = SnippetRevision.get(rev_key) #q = db.GqlQuery("SELECT * FROM SnippetRevision WHERE __key__ = :1", \ # db.Key(rev_key)) #rev = q.get() # fetch(1)[0] if not rev: self.error(404) return # TODO: memcache? rev.views += 1 rev.put() has_voted = False if user: # see if user has already voted q1 = db.GqlQuery("SELECT * FROM SnippetRevisionUpvote WHERE \ userprefs = :1 and snippetrevision = :2", prefs, rev) q2 = db.GqlQuery("SELECT * FROM SnippetRevisionDownvote WHERE \ userprefs = :1 and snippetrevision = :2", prefs, rev) has_voted = q1.count() or -q2.count() # 0 if not, 1, -1 # Check if user wants to vote if not has_voted: has_voted = decode(self.request.get('v')) if has_voted == "1": # user wants to upvote v = SnippetRevisionUpvote(userprefs=prefs, \ snippetrevision=rev) v.save() rev.userprefs.points += 1 rev.userprefs.put() rev.date_lastactivity = datetime.datetime.now() rev.put() # Set last activity on voting use0r prefs.date_lastactivity = datetime.datetime.now() prefs.put() elif has_voted == "-1": # user downvotes v = SnippetRevisionDownvote(userprefs=prefs, \ snippetrevision=rev) v.save() rev.userprefs.points -= 1 rev.userprefs.put() rev.date_lastactivity = datetime.datetime.now() rev.save() # Set last activity on voting use0r prefs.date_lastactivity = datetime.datetime.now() prefs.put() values = {"prefs": prefs, "rev": rev, 'voted': str(has_voted), \ 'desc_md': rev.description_md} self.response.out.write(template.render(tdir + \ "snippets_edit_view.html", values))
def post(self): user = users.get_current_user() prefs = InternalUser.from_user(user) update = decode(self.request.get('update')) if update == "about": nickname = decode(self.request.get('nickname')) email = decode(self.request.get('email')) twitter = decode(self.request.get('twitter')) about = decode(self.request.get('about')) url_addon = "" if nickname and nickname != prefs.nickname and len(nickname) > 2: # check if nick is still available, if so then update q = InternalUser.all() q.filter("nickname =", nickname) if q.count(): # already taken url_addon += "&u=-1" else: # free. if email, only own is allowed if is_valid_email(nickname): if nickname == prefs.email: prefs.nickname = nickname url_addon += "&u=1" else: # othre email not permitted url_addon += "&u=2" else: prefs.nickname = nickname url_addon += "&u=1" if email and \ ((not prefs.email_new and email != prefs.email) or \ (prefs.email_new and email != prefs.email_new)): if not is_valid_email(email): self.redirect("/profile?e=-1") return # updating email address if prefs.email_new and email.strip() == prefs.email: # switching back to already verified mail is ok prefs.email = email.strip() prefs.email_new = None prefs.email_new_code = None url_addon += "&e=2" else: # send verification mail prefs.email_new = email.strip() prefs.email_new_code = hashlib.sha1(\ os.urandom(64)).hexdigest() body_text = template.render(tdir + \ "/email/verify_text.html", \ {'code': prefs.email_new_code, 'email': email}) #print "x" #print body_text #return message = mail.EmailMessage() message.sender = \ "MOAI Snippets <*****@*****.**>" message.to = email message.subject = "MOAI snippets email verification" message.body = body_text #message.html = email_body_html message.send() url_addon += "&e=1" if twitter and twitter != prefs.twitter: prefs.twitter = twitter url_addon += "&t=1" if about and about != prefs.about: prefs.about = about prefs.about_md = markdown.markdown(about).replace( \ "<a ", "<a target='_blank' ") url_addon += "&ab=1" if url_addon: prefs.put() prefs.clear_cache() url_addon = "%s%s" % ("?x=1", url_addon) self.redirect("/profile%s" % url_addon) return if update == "notifications": # Currently only 4 notification settings. increase as necessary notifications = 0 for i in xrange(4): s = decode(self.request.get('n%s' % i)) # n1 = lowest bit, n2 next higher, ... notifications |= 1 << i if s else 0 #logging.info("= n before: %s" % prefs.notifications) #logging.info("= n after: %s" % notifications) url_addon = "" if notifications != prefs.notifications: prefs.notifications = notifications url_addon = "%s%s" % ("&n=1", url_addon) if url_addon: prefs.put() url_addon = "%s%s" % ("?x=1", url_addon) self.redirect("/profile%s" % url_addon) return
def get(self): force_update = decode(self.request.get('n')) self.response.out.write(mc.cache.sitemap(force_update))
def get_fitness(compound): """Computes the fitness of a compound, and returns the negative of it (for function-minimizing).""" #get inputs to fitness function: cmpd_name = decode(compound) #finds the name of the compound corresponding to next_point_to_sample #then query for JSON file with same name return 0 - eval_fitness_complex_product(json_get(cmpd_name, 'gllbsc_dir-gap'), json_get(cmpd_name, 'gllbsc_ind-gap'), json_get(cmpd_name, 'heat_of_formation_all'), json_get(cmpd_name, 'VB_dir'), json_get(cmpd_name, 'CB_dir'), json_get(cmpd_name, 'VB_ind'), json_get(cmpd_name, 'CB_ind'))
def in_results(compound): """Returns a boolean based on whether a compound is in the results_bank.""" name = decode(compound) return (name in results_bank)
def turn(self) -> (str, int, int): # Fill these fields to return message: str = None message_value: int = 0 direction: int = Direction.CENTER.value ant = self.game.ant # print(ant.health) x = ant.currentX y = ant.currentY base_x = self.game.baseX base_y = self.game.baseY self.turn_number = self.turn_number + 1 self.init_dirs() if not self.vision: # print("Creating vision") for i in range(self.game.mapWidth): new_line = [] for j in range(self.game.mapHeight): new_line.append([(UNKNOWN, -1)]) self.vision.append(new_line) # self.vision[self.game.mapWidth-base_x-1][self.game.mapHeight-base_y-1].append((ENEMY_BASE, self.turn_number)) cur = self.game.ant.visibleMap.cells[ant.currentX][ant.currentY] for chat in self.game.chatBox.allChats: msg = chat.text for i in range(0, len(msg), 2): cx, cy, obj = encode(msg[i:i+2]) if not has_obj(obj, self.vision[cx][cy]): self.vision[cx][cy].append((obj, chat.turn)) new_objs = [] def upd(i, j, obj): if not has_obj(obj, self.vision[i][j]): new_objs.append((i, j, obj)) if cur.resource_type == ResourceType.BREAD.value or cur.resource_type == ResourceType.GRASS.value: tools.last_resource = (x,y) if cur.type == CellType.TRAP.value and tools.has_resource == 1: # self.vision[tools.last_resource[0]][tools.last_resource[1]].append((WALL,self.turn_number)) upd(x, y, BAD_TRAP) self.vision[x][y].append((BAD_TRAP,self.turn_number)) tools.allied_in_range = 0 tools.enemy_in_range = 0 tools.has_resource = 1 if ant.currentResource and ant.currentResource.value > 0 else 0 # print(self.turn_number , " " , tools.has_resource) if self.turn_number == 0: random_moves = [] for i in range(self.game.mapWidth): for j in range(self.game.mapHeight): cell = self.game.ant.visibleMap.cells[i][j] if not cell: continue if cell.type == CellType.WALL.value: upd(i, j, WALL) self.vision[i][j].append((WALL, self.turn_number)) elif cell.type == CellType.TRAP.value: upd(i, j, TRAP) if self.turn_number == 0: random_moves.append(cell) self.vision[i][j].append((TRAP, self.turn_number)) elif cell.type == CellType.SWAMP.value: upd(i, j, SWAMP) self.vision[i][j].append((SWAMP, self.turn_number)) elif cell.type != CellType.EMPTY and cell.type == CellType.BASE.value and (base_x != i or base_y != j): # what self.vision[i][j].append((ENEMY_BASE, self.turn_number)) else: if self.turn_number == 0: random_moves.append(cell) if cell.resource_type == ResourceType.BREAD.value: self.vision[i][j].append((BREAD, self.turn_number)) elif cell.resource_type == ResourceType.GRASS.value: self.vision[i][j].append((GRASS, self.turn_number)) else: self.vision[i][j].append((EMPTY, self.turn_number)) if cell.ants: maximum = TEAM_KARGAR for a in cell.ants: if a.antType == AntType.KARGAR.value and a.antTeam == AntTeam.ALLIED.value: this = TEAM_KARGAR tools.allied_in_range += 0.5 elif a.antType == AntType.SARBAAZ.value and a.antTeam == AntTeam.ALLIED.value: this = TEAM_SARBAZ tools.allied_in_range += 1 elif a.antType == AntType.KARGAR.value and a.antTeam == AntTeam.ENEMY.value: this = ENEMY_KARGAR tools.enemy_in_range += 0.5 else: this = ENEMY_SARBAZ tools.enemy_in_range += 1 if this > maximum: maximum = this self.vision[i][j].append((maximum, self.turn_number)) else: self.vision[i][j].append((NO_ANTS, self.turn_number)) self.vision[i][j] = prune(self.vision[i][j]) if self.turn_number == 0: print(random_moves) self.first_target = random.choice(random_moves) AI.first_target = self.first_target # print("turn: ", self.turn_number) set_turn_number(self.turn_number) if ant.antType == AntType.SARBAAZ.value: if self.turn_number == 0 and len(cur.ants) > 1: direction = random.choice([UP,DOWN,LEFT,RIGHT,CENTER]) else: direction = self.get_move('scorpion') elif ant.antType == AntType.KARGAR.value: # if self.turn_number == 0 or self.turn_number == 1: # direction = random.choice([UP,DOWN,LEFT,RIGHT,CENTER]) # else: direction = self.get_move('ant') AI.vision = self.vision AI.turn_number = self.turn_number message = "" message_value = 1 for i, j, obj in new_objs: message += decode(i, j, obj) if len(message) > MAX_CHARS: message = message[:MAX_CHARS] return message, message_value, direction
def post(self): """Check and add new snippet to db""" user = users.get_current_user() prefs = InternalUser.from_user(user) # Validate input title = self.request.get('title') code = self.request.get('code') description = self.request.get('description') version = self.request.get('version') tags = [] i = 0 while True: tag = self.request.get('tag%s' % i) logging.info("tag: %s" % tag) if not tag: break elif tag == "0": # 0 is placeholder for removed tag pass else: tags.append(decode(tag)) i += 1 errors = [] if not title: errors.append("title") elif len(title) < 16: errors.append("longer title") if not code: errors.append("snippet") if not description: errors.append("description") if len(tags) < 2: errors.append("a few tags") if len(errors) > 0: tags_mostused = mc.cache.tags_mostused() values = {'prefs': prefs, 'errors': errors, 'title': title, \ 'code': code, 'description': description, 'tags': tags, \ 'version': version, 'tag_cnt': len(tags), \ "tags_mostused": tags_mostused} self.response.out.write(template.render(tdir + \ "snippets_new.html", values)) return # Decode with utf-8 if necessary title = decode(title.strip()) code = decode(code) description = decode(description) # Find a free slug slug = slugify(title) _slug = slugify(title) cnt = 0 while True: q = Snippet.all() q.filter("slug1 =", _slug) if q.count() > 0: cnt += 1 _slug = u"%s%s" % (slug, cnt + 1) else: slug = _slug break # Create snippet (submitter is saved only in first revision) s = Snippet(userprefs=prefs) s.title = title s.slug1 = slug s.description = description s.description_md = markdown.markdown(description).replace( \ "<a ", "<a target='_blank' rel='nofollow' ") s.code = code s.android_minsdk = int(version) s.put() # Create the first revision r = SnippetRevision.create_first_revision(userprefs=prefs, snippet=s) r.put() # Create the first upvote upvote = SnippetUpvote(userprefs=prefs, snippet=s) upvote.put() # Create the tags for tag in tags: if not tag or len(tag.strip()) < 3: # skip empty and too short tags continue # See if tag base object already exists, if not then create it q = Tag.all() q.filter("name =", tag) t = q.get() if not t: t = Tag(name=tag) t.put() st = SnippetTag(snippet=s, tag=t) st.put() prefs.points += 1 prefs.date_lastactivity = datetime.datetime.now() prefs.put() # Clear snippet list cache and have next user rebuild it mc.cache.snippet_list(None, clear=True) mc.cache.tags_mostused(force_update=True) # Trigger background tasks taskqueue.add(url='/services/update_tags') taskqueue.add(url='/services/update_sitemap') taskqueue.add(url='/services/update_relations') # Prepare Tweet if not settings.IS_TESTENV: url = shorturl("http://www.androidsnippets.com/%s" % slug) max_status_len = 140 - len(url) - 11 # 10 = 2 spaces,:,#android status = s.title if len(status) > max_status_len: status = "%s..." % status[:max_status_len - 3] status = "%s: %s #android" % (status, url) logging.info("tweet: '%s' (%s)" % (status, len(status))) tweet(status) # Redirect to snippet view self.redirect("/%s" % s.slug1)
def post(self, snippet_slug): memcache.incr("ua_comment", initial_value=0) user = users.get_current_user() prefs = InternalUser.from_user(user) # Set last activity on commenting user prefs.date_lastactivity = datetime.datetime.now() prefs.put() q = Snippet.all() q.filter("slug1 =", snippet_slug) snippet = q.get() if not snippet: self.error(404) return comment = decode(self.request.get('comment')) parent_key = decode(self.request.get('parent_key')) if not comment or len(comment.strip()) == 0: self.redirect("/%s" % snippet_slug) return if parent_key: parent = SnippetComment.get(db.Key(parent_key)) logging.info("pk: %s" % parent) if not parent: self.error(404) return # Add the comment now c = SnippetComment(userprefs=prefs, snippet=snippet, comment=comment) c.comment_md = markdown.markdown(comment).replace( \ "<a ", "<a target='_blank' rel='nofollow' ") if parent_key and parent: c.parent_comment = parent # Check if comment is spam is_spam = False if not settings.IS_TESTENV: is_spam = akismet_spamcheck(comment, self.request.remote_addr, \ self.request.headers["User-Agent"]) if is_spam: memcache.incr("ua_comment_spam", initial_value=1) logging.warning("= comment: Yup, that's spam alright.") c.flagged_as_spam = True url_addon = "?c=m#comments" else: memcache.incr("ua_comment_ham", initial_value=1) url_addon = "" snippet.comment_count += 1 snippet.date_lastcomment = datetime.datetime.now() snippet.date_lastactivity = datetime.datetime.now() snippet.put() url_addon = "" # Clear snippet list cache and have next user rebuild it mc.cache.snippet_list(None, clear=True) mc.cache.snippet(snippet.slug1, clear=True) # Save comment now c.put() # if not spam, redirect user to see comment if not url_addon: url_addon = "#%s" % c.key() # Recalculate and cache comments mc.cache.snippet_comments(snippet.key(), True) self.redirect("/%s%s" % (snippet_slug, url_addon))