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 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 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 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 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 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 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 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 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 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))
