def post(self): user = self.current_user origin_content = self.get_argument("content", '') content = md(origin_content) if origin_content != '': post = Post(user_id=user.id, content=content, origin_content=origin_content) db.add(post) db.commit() if self.is_ajax(): self.write( tornado.escape.json_encode({ 'username': user.name, 'avatar': user.get_avatar(), 'time': formatDate(int(time.time())), 'content': content, 'id': post.id })) ''' self.render('site/ajaxpage.html', posts = [post]) ''' else: self.redirect(self.next_url) if post.content.find('@') != -1: post_put_notifier(post) else: self.redirect(self.next_url) return
def update_edit(ip, e_type): edit = Edit(ip) edit.entity_id = entity.id edit.edit_type = e_type edit.edit_time = datetime.utcnow() db.add(edit) db.commit()
def add_reply(pid): # name = self.get_argument("reply[name]", default='') # email = self.get_argument("reply[email]", default='') # website = self.get_argument("reply[website]", default='') # origin_content = self.get_argument("reply[content]", default='') name = request.form["reply[name]"] email = request.form["reply[email]"] website = request.form["reply[website]"] origin_content = request.form["reply[content]"] content = markdown.markdown(formatText(origin_content)) if name == "": return redirect("/post/%d" % int(pid), error=u"请填入名字") if email == "": return redirect("/post/%d" % int(pid), error=u"请填入邮箱地址") if origin_content == "": return redirect("/post/%d" % int(pid), error=u"请输入评论内容") number = db.query(Reply).filter(Reply.pid == pid).count() + 1 db.add( Reply( pid=int(pid), name=name, email=email, website=website, content=content, origin_content=origin_content, number=number, ) ) db.commit() base.replyerSet(name, email, website) return redirect("/post/%d" % (int(pid)))
def get_comments_from_site(self, limit=None, store_in_db=True): subreddit = self.session.get_subreddit(self.subreddit) # get the newest comment we've previously seen as a stopping point last_comment = ( db.query(Comment) .filter_by(subreddit=self.subreddit) .order_by(Comment.date.desc()) .first() ) seen_ids = set() comments = [] for comment in subreddit.get_comments(limit=limit): comment = Comment(comment) if last_comment: if (comment.id == last_comment.id or comment.date <= last_comment.date): break # somehow there are occasionally duplicates - skip over them if comment.id in seen_ids: continue seen_ids.add(comment.id) comments.append(comment) if store_in_db: db.add(comment) if store_in_db: db.commit() return comments
def register_post(): username = request.form.get('username') email = request.form.get('email') name = request.form.get('name') password = request.form.get('password') user = User.query.filter_by(email=email).first( ) # if this returns a user, then the email already exists in database # if a user is found, we want to redirect back to signup page so user can try again if user: flash('Email address already exists') return redirect(url_for('register')) # create new user with the form data. Hash the password so plaintext version isn't saved. new_user = User(username=username, email=email, name=name, password=generate_password_hash(password, method='sha256')) # add the new user to the database db.add(new_user) db.commit() # when we add the user to the database, we will redirect to the login route return redirect(url_for('login'))
def create(key: str, value: Union[str, int, float, bool]) -> "Settings": if isinstance(value, bool): value = int(value) row = Settings(key=key, value=str(value)) db.add(row) return row
def post(self, post_id): user = self.current_user post_id = int(post_id) post = db.query(Post).get(post_id) if not post: raise tornado.web.HTTPError(404) else: origin_content = self.get_argument("comment-content", "") content = md(origin_content) if origin_content == "": self.redirect(self.next_url) return comment = Comment(post_id=post_id, user_id=user.id, content=content, origin_content=origin_content) db.add(comment) db.commit() the_comment = ( db.query(Comment).order_by(sa.desc(Comment.created_at)).filter(Comment.user_id == user.id).first() ) if self.is_ajax(): self.write( tornado.escape.json_encode( { "username": user.name, "avatar": user.get_avatar(size=24), "time": formatDate(int(time.time())), "content": content, } ) ) if post.user_id != user.id: db.add(Notifier(post_id=post_id, who_id=user.id, whom_id=post.user_id, comment_id=the_comment.id)) db.commit() if content.find("@") != -1: put_notifier(comment=comment, post=post)
def get_submissions_from_site(self, limit=None, store_in_db=True): subreddit = self.session.get_subreddit(self.subreddit) # get the newest submission we've previously seen as a stopping point last_submission = ( db.query(Submission) .filter_by(subreddit=self.subreddit) .order_by(Submission.date.desc()) .first() ) seen_ids = set() submissions = [] for submission in subreddit.get_new(limit=limit): submission = Submission(submission) if last_submission: if (submission.id == last_submission.id or submission.date <= last_submission.date): break # somehow there are occasionally duplicates - skip over them if submission.id in seen_ids: continue seen_ids.add(submission.id) submissions.append(submission) if store_in_db: db.add(submission) if store_in_db: db.commit() return submissions
def save_new_photo_form(db): occ_id = request.forms.occupancy_id if occ_id is None: raise HTTPError(400) try: occupancy = db.query(m.Occupancy).filter(m.Occupancy.id == occ_id).one() except NoResultFound: raise HTTPError(404, "No such occupancy to review") if occupancy.resident != request.user: raise HTTPError(403, "You must have been a resident of a room to review it") uploads = request.files.getall('photo') captions = request.forms.getall('caption') for image_upload, caption in reversed(zip(uploads, captions)): photo = m.Photo.from_file(image_upload.file) photo.caption = caption photo.occupancy = occupancy db.add(photo) return redirect('/rooms/{}#photos'.format(occupancy.listing.room.id))
def create(name: str, channel_id: int, public: bool) -> "DynamicVoiceGroup": row = DynamicVoiceGroup(name=name, channel_id=channel_id, public=public) db.add(row) return row
def save(): # app.logger.debug(request.data) jsonData = json.loads(request.data) if 'Event-Name' in request.headers: save_event_data(request) if 'optOut' in jsonData and jsonData['optOut']: return get_entities() entity = None data = jsonData['entity'] data["ip"] = request.remote_addr data["edit_type"] = None if data['id']: entity = Entity.query.get(data['id']) elif data['name']: data["edit_type"] = "create" entity = Entity(data['name']) db.add(entity) db.commit() if entity: if not data["edit_type"]: data["edit_type"] = "update" update(entity, data) return get_entities()
def add_reply(pid): #name = self.get_argument("reply[name]", default='') #email = self.get_argument("reply[email]", default='') #website = self.get_argument("reply[website]", default='') #origin_content = self.get_argument("reply[content]", default='') name = request.form["reply[name]"] email = request.form["reply[email]"] website = request.form["reply[website]"] origin_content = request.form["reply[content]"] content = markdown.markdown(formatText(origin_content)) if name == "": return redirect("/post/%d" % int(pid), error=u"请填入名字") if email == "": return redirect("/post/%d" % int(pid), error=u"请填入邮箱地址") if origin_content == "": return redirect("/post/%d" % int(pid), error=u"请输入评论内容") number = db.query(Reply).filter(Reply.pid == pid).count() + 1 db.add( Reply(pid=int(pid), name=name, email=email, website=website, content=content, origin_content=origin_content, number=number)) db.commit() base.replyerSet(name, email, website) return redirect("/post/%d" % (int(pid)))
def create(account_id=None, application_name=None, application_guid=None, application_key=None, application_secret=None, application_algorithm=None, created_user_id=None, app_metadata=None, training_status=None): try: application = Applications(account_id=account_id, application_name=application_name, application_guid=application_guid, application_key=application_key, application_secret=application_secret, application_algorithm=application_algorithm, created_user_id=created_user_id, app_metadata=app_metadata, training_status=training_status) db.add(application) db.commit() return application.application_id except Exception as e: db.rollback() raise Exception(e.message)
def replace_blocks(new_blocks): db.query(Block).delete() db.commit() for block_dict in new_blocks: block_dict['timestamp'] = datetime.strptime( block_dict['timestamp'], '%Y-%m-%d %H:%M:%S.%f') db.add(Block(**block_dict)) db.commit()
def create(channel_id: int, message_id: int, emoji: str, role_id: int) -> "ReactionRole": row = ReactionRole(channel_id=channel_id, message_id=message_id, emoji_hex=encode(emoji), role_id=role_id) db.add(row) return row
def save(self): db.add(self) try: db.commit() except Exception as ex: db.rollback() db.add(self) db.commit()
def create(member: int, member_name: str, mod: int, reason: str) -> "Kick": row = Kick(member=member, member_name=member_name, mod=mod, timestamp=datetime.utcnow(), reason=reason) db.add(row) return row
def create(member: int, member_name: str, timestamp: Optional[datetime] = None) -> "Join": row = Join(member=member, member_name=member_name, timestamp=timestamp or datetime.utcnow()) db.add(row) return row
def create(channel_id: int, group_id: int, text_chat_id: int, owner: int) -> "DynamicVoiceChannel": row = DynamicVoiceChannel(channel_id=channel_id, group_id=group_id, text_chat_id=text_chat_id, owner=owner) db.add(row) return row
def add_product(description, product_id=None, status='in_stock'): if not product_id: product_id = uuid4().hex db.add( Product(product_id=product_id, description=description, creator_id=get_config(key='node_identifier'), status=status)) db.commit()
def create(member: int, member_name: str, reporter: int, reason: str) -> "Report": row = Report(member=member, member_name=member_name, reporter=reporter, timestamp=datetime.utcnow(), reason=reason) db.add(row) return row
def create(member: int, member_name: str, new_name: str, nick: bool) -> "UsernameUpdate": row = UsernameUpdate(member=member, member_name=member_name, new_name=new_name, nick=nick, timestamp=datetime.utcnow()) db.add(row) return row
def do_update(db): for k, v in request.forms.items(): if k.endswith('-name'): user = db.query(m.Person).filter(m.Person.crsid == k[:-5]).one() user.name = v.decode('utf8') db.add(user) db.commit() return update_names(db)
def create(guild_id: int, code: str, guild_name: str, applicant: int, approver: int) -> "AllowedInvite": row = AllowedInvite( guild_id=guild_id, code=code, guild_name=guild_name, applicant=applicant, approver=approver, created_at=datetime.utcnow(), ) db.add(row) return row
def set_config(key, value, replace=False): config_value = get_config(key) if config_value is None: db.add(Config(key=key, value=value)) db.commit() return value if config_value != value and replace is True: db.add(Config(key=key, value=value)) db.commit() return value return config_value
def post(self): username = self.get_argument("username") email = self.get_argument("email") password = self.get_argument("password") confirm_password = self.get_argument("confirm_password") db.add(User(name=username,email=email,pw_hash= generate_password_hash(password))) db.commit() #self.set_cookie("email",email) #self.currentUserSet(username) self.redirect("/login")
def post(self): user = self.current_user description = self.get_argument("description", '') website = self.get_argument("website", '') city = self.get_argument("city", '') user.description = md(description) user.website = website user.city = city db.add(user) db.commit() self.redirect("/user/%s" % (user.name)) return
def create(guild_id: int, guild_name: str, applicant: int, mod: int, approved: bool) -> "InviteLog": row = InviteLog( guild_id=guild_id, guild_name=guild_name, applicant=applicant, mod=mod, timestamp=datetime.utcnow(), approved=approved, ) db.add(row) return row
def post(self): self.checkAdmin() title = self.get_argument("post[title]", '') origin_content = self.get_argument("post[content]", '') content = md(origin_content) if title != '' and origin_content != '': db.add(Post(title=title, content=content, origin_content=origin_content)) db.commit() self.redirect("/") else: self.render("postadd.html", error=u"标题或内容不能为空。", title=title, origin_content=origin_content)
def get(self, whom_name): who = self.current_user whom = db.query(User).filter(User.name == whom_name).first() if whom is None or whom is who: raise tornado.web.HTTPError(404) follower = db.query(Follower).filter( sa.and_(Follower.who_id == who.id, Follower.whom_id == whom.id)).first() if follower is not None: raise tornado.web.HTTPError(404) db.add(Follower(who_id=who.id, whom_id=whom.id)) db.commit() self.redirect(self.next_url) return
def insert_raw_news(raw_news_entity: RawNewsEntity): if raw_news_entity is None: logging.error(f'failed to create raw_news_entity') return logging.info(raw_news_entity) try: db.add(raw_news_entity) db.commit() except IntegrityError: db.rollback() logging.info(f'Duplicated {raw_news_entity.link}') except Exception as err: db.rollback() logging.error(f'failed to store raw_news_entity') logging.error(err)
def save(): entity = None data = json.loads(request.data)['entity'] if data['id']: entity = Entity.query.get(data['id']) elif data['name']: entity = Entity(data['name']) db.add(entity) db.commit() if entity: update(entity, data) cache.clear() else: print 'NO UPDATE' return get_entities()
def create(member: int, member_name: str, mod: int, days: int, reason: str) -> "Ban": row = Ban( member=member, member_name=member_name, mod=mod, timestamp=datetime.utcnow(), days=days, reason=reason, active=True, deactivation_timestamp=None, unban_reason=None, unban_mod=None, ) db.add(row) return row
def add_post(): if request.method == 'GET': base.checkAdmin() return render_template("postadd.html", getAvatar=getAvatar) base.checkAdmin() title = request.form["post[title]"] origin_content = request.form["post[content]"] content = markdown.markdown(origin_content) if title != '' and origin_content != '': db.add(Post(title=title, content=content, origin_content=origin_content)) db.commit() return redirect("/") else: return render_template("postadd.html", error=u"标题或内容不能为空。",getAvatar=getAvatar)
def get(self, post_id): post_id = int(post_id) user = self.current_user post = db.query(Post).get(post_id) if post and post.user_id != user.id: favorite = db.query(Favorite).filter(sa.and_(Favorite.user_id ==\ user.id, Favorite.post_id == post.id)).first() if favorite: db.delete(favorite) else: favorite = Favorite(user_id=user.id, post_id=post.id) db.add(favorite) db.commit() else: self.redirect(self.next_url) return
def post_comment_on(self, submission): comment = self.build_comment() # decide if we're going to post top-level or reply if (submission.num_comments == 0 or random.random() < 0.5): submission.add_comment(comment) else: comments = praw.helpers.flatten_tree(submission.comments) reply_to = random.choice(comments) reply_to.reply(comment) # update the database self.last_commented = datetime.now(pytz.utc) self.num_comments += 1 db.add(self) db.commit()
def create(configuration_guid=None, bot_name=None, account_guid=None, plan_family=None, plan_metadata=None): try: configuration = Configuration(configuration_guid=None, bot_name=None, account_guid=None, plan_family=None, plan_metadata=None) db.add(configuration) db.commit() return configuration.application_id except Exception as e: db.rollback() raise Exception(e.message)
def generate_graph(nodes, edges): g = Graph.Erdos_Renyi(n=nodes, m=edges) edge_list = g.get_edgelist() for _ in range(nodes): newuser = User() db.add(newuser) users = db.query(User).all() for (source, target) in edge_list: connection = Coachingconnection() db.add(connection) users[source].students.append(connection) users[target].coaches.append(connection) db.commit()
def add_bulk_comments(self, new_comments, store_in_db=True): cnt = 0 add = 0 for comment in new_comments: try: comment = Comment(comment) print(comment.date) if self.check_for_comment_dup(comment.id) == False: db.add(comment) add += 1 cnt += 1 except: pass print "Got " + str(cnt) + ". Added " + str(add) if store_in_db: db.commit()
def post(self, pid): name = self.get_argument("reply[name]", default='') email = self.get_argument("reply[email]", default='') website = self.get_argument("reply[website]", default='') origin_content = self.get_argument("reply[content]", default='') content = formatText(md(formatText(origin_content))) if name == "": self.redirect("/post/%d" % int(pid), error=u"请填入名字") if email == "": self.redirect("/post/%d" % int(pid), error=u"请填入邮箱地址") if origin_content == "": self.redirect("/post/%d" % int(pid), error=u"请输入评论内容") number = db.query(Reply).filter(Reply.pid == pid).count() + 1 db.add(Reply(pid=int(pid), name=name, email=email, website=website, content=content, origin_content=origin_content, number=number)) db.commit() self.replyerSet(name, email, website) self.redirect("/post/%d#%d" % (int(pid), int(number)))
def save(): app.logger.debug('SAVING') app.logger.debug(request.data) entity = None data = json.loads(request.data)['entity'] if data['id']: entity = Entity.query.get(data['id']) elif data['name']: app.logger.debug('ADDING NEW ENTITY ' + str(data['name'])) entity = Entity(str(data['name'])) db.add(entity) db.commit() if entity: app.logger.debug('UPDATING ENTITY ' + entity.name) update(entity, data) cache.clear() else: app.logger.debug('NO UPDATE') return get_entities()
def save_place_edit(place_id, db): try: place = db.query(m.Place).filter(m.Place.id == place_id).one() except NoResultFound: raise HTTPError(404, "No matching location") last_summary = place.summary summary = m.PlaceSummary( place=place, published_at=datetime.now(), markdown_content=request.forms.content, editor=request.user ) if last_summary and summary.markdown_content == last_summary.markdown_content: raise HTTPError(400, "Same as last edit") db.add(summary) redirect(utils.url_for(place))
def post_put_notifier(post): all_users = db.query(m.User).all() users = [] for user in all_users: if post.content.find('@' + user.name) != -1: users.append(user) if users != []: for user in users: if user.id != post.user_id: db.add(m.Notifier(who_id=post.user_id, whom_id=user.id, post_id=post.id, comment_id=0, type=3)) db.commit() for user in users: name = '@' + '(' + user.name + ')' for match in re.finditer(name, post.content): ame = match.group(0) mame = match.group(1) retext = '@<a class="mention" href="/user/%s">%s</a>' % (mame, mame) text = post.content.replace(ame, retext) post.content = text db.commit() return True
def add_images_to_db(self, popup): input_text = popup.children[0].children[0].children[0].children[0].children[1].text if input_text: self.new_file_name = input_text import_file = ImportFile(name=self.new_file_name, license=self.new_file_license, row_size=int(self.ids.x_tile_size.text)) db.add(import_file) for file in self.new_files: file_index = basename(file).split('.')[0] game_object = GameObject(id=file_index, name='(no name)', description='(no description)', committed=False, size=1) sprite_tile = SpriteTile(id=file_index, discard=False, tile_number=1, import_file=import_file, game_object=game_object) db.add(sprite_tile) db.commit() self.split_complete()
def create(account_name=None, account_guid=None, account_type=None, company=None, is_active=True, is_deleted=False, owner=None): try: account = Accounts(account_name=account_name, account_guid=account_guid, account_type=account_type, company=company, is_active=is_active, is_deleted=is_deleted) if owner: account.users.append(owner) db.add(account) db.commit() return account.account_id except Exception as e: db.rollback() raise Exception(e.message)
def create(user_guid=None, email=None, password=None, first_name=None, last_name=None, is_system=False, company=None ): try: user = Users(user_guid=user_guid, email=email, password=password, first_name=first_name, last_name=last_name, is_system=is_system, company=company) db.add(user) db.commit() return user except Exception as e: db.rollback() raise Exception(e.message)
def post_submission(self, subreddit, type=None): subreddit = self.session.get_subreddit(subreddit) title = self.title_model.make_short_sentence(300, tries=10000, max_overlap_total=MAX_OVERLAP_TOTAL, max_overlap_ratio=MAX_OVERLAP_RATIO) title = title.rstrip(".") if not type: type = self.pick_submission_type() if type == "link": url_source = random.choice(self.link_submissions) if url_source.over_18: title = "[NSFW] " + title subreddit.submit(title, url=url_source.url, send_replies=False, resubmit=True) else: selftext = "" while len(selftext) < self.avg_selftext_len: new_sentence = self.make_selftext_sentence() if not new_sentence: break selftext += " " + new_sentence selftext = selftext.strip() # need to do this to be able to submit an empty self-post if len(selftext) == 0: selftext = " " subreddit.submit(title, text=selftext, send_replies=False) # update the database self.last_submitted = datetime.now(pytz.utc) self.num_submissions += 1 db.add(self) db.commit()
def dispatch_request(self): logger = dlog.get_logger('imp0rt') if request.method == 'POST': importfile = request.files['airspace'] if importfile: logger.info('parsing file') airspaceFile = parse(importfile.filename,importfile) logger.info('file parsed') try: db.add(airspaceFile) logger.info('added airspaces to database') db.commit() logger.info('commited data') except Exception as e: logger.error(e.message) logger.info(e) raise model = self.get_objects() model['files'] = AirspaceFile.query.all() return self.render_template(model)
def create(account=None, nerd_guid=None, nerd_name=None, nerd_url=None, is_deleted=False, is_active=True, user=None): try: nerd = Nerds( nerd_url=nerd_url, nerd_guid=nerd_guid, nerd_name=nerd_name, is_deleted=is_deleted, is_active=is_active, ) nerd.users.append(user) account.nerds.append(nerd) db.add(account) db.commit() except Exception as e: db.rollback() raise Exception(e.message)
def save_new_review_form(db): occ_id = request.forms.occupancy_id if occ_id is None: raise HTTPError(400) occupancy = get_occupancy_to_review(db, occ_id) last_review = occupancy.review if 'delete' in request.forms: review = m.Review( occupancy=occupancy, published_at=datetime.now(), hidden=True ) else: sections = [] for key, value in request.forms.iteritems(): match = re.match(r'^section-(\d+)$', key) if match: heading_id = int(match.group(1)) try: heading = db.query(m.ReviewHeading).filter_by(id=heading_id).one() except NoResultFound: raise HTTPError(400) if value.strip(): sections += [ m.ReviewSection( heading=heading, content=value ) ] elif heading.is_summary: raise HTTPError(400, "{!r} section cannot be left blank".format(heading.name)) # validate the rating try: rating = int(request.forms.rating) except ValueError: raise HTTPError(404, "Rating must be an integer") if rating < 0 or rating > 10: raise HTTPError(404, "Rating must be between 0 and 10") review = m.Review( sections=sections, occupancy=occupancy, published_at=datetime.now(), rating=rating ) # if an edit occurred, record the editor if occupancy.resident != request.user: review.editor = request.user db.add(review) # check we haven't hit a double-post situation if last_review and review.contents_eq(last_review): raise HTTPError(400, "Same as last review") # TODO: fail gracefully db.rollback() flash_some_message() redirect_anyway() # look for references in the review import find_references for ref in find_references.scan_review(review): db.add(ref) redirect('/rooms/{}#review-{}'.format(occupancy.listing.room_id, review.id))
def put(self, data): self.data = data db.add(self) db.commit() return self.id
def assign_room(db): user = False room = False season = False if request.query.user: user = db.query(m.Person).get(request.query.user) if not user: d = utils.lookup_ldap([request.query.user]) print d d = d.get(request.query.user) if d: name = d.get('visibleName') user = m.Person(crsid=request.query.user, name=name) if request.query.room: room = db.query(m.Room).get(request.query.room) if request.query.year: season = db.query(m.BallotSeason).get(request.query.year) # incomplete form - get if request.method == 'GET': return template('tools-assign', user=user, room=room, season=season, seasons=db.query(m.BallotSeason).all()) # form must be complete for post elif not all([season, room, user]): raise HTTPError(400) else: # check if a swap was requested do_swap = (request.forms.cancel_src == 'swap') + (request.forms.cancel_src == 'swap') if do_swap == 1: raise HTTPError(400, "Either neither or both users must be swapping") do_swap = do_swap == 2 cancel_src = do_swap or request.forms.cancel_src == "1" cancel_dest = do_swap or request.forms.cancel_dest == "1" from sqlalchemy.orm.session import make_transient from datetime import datetime import roombooking # better lock the table now, just to be sure roombooking.lock_occupancies(db) # the listing for the target room listing = room.listing_for.get(season) if not listing: listing = m.RoomListing( room=room, ballot_season=season ) occs = listing.occupancies if any(occ.resident == user for occ in occs): raise HTTPError(400, "User is already in this room!") src_occs = [ occ for occ in user.occupancies if occ.listing.ballot_season == season if not occ.cancelled ] dest_occs = [ occ for occ in listing.occupancies if not occ.cancelled ] now = datetime.now() if cancel_src: for occ in src_occs: occ.cancelled = True if cancel_dest: for occ in dest_occs: occ.cancelled = True if do_swap: if len(src_occs) > 1: raise HTTPError(400, "Cannot swap a user residing in multiple simultaneous rooms") if len(dest_occs) > 1: raise HTTPError(400, "Cannot swap a user into a room with multiple residents") src_occ = src_occs[0] dest_occ = dest_occs[0] reverse_occ = m.Occupancy(resident=dest_occ.resident, listing=src_occ.listing, chosen_at=now) db.add(reverse_occ) new_occ = m.Occupancy(resident=user, listing=listing, chosen_at=now) db.add(new_occ) redirect('/rooms/{}'.format(room.id))