def discussions_create():
form = DiscussionForm(request.form)
if not form.validate():
return render_template(
"discussions/new.html",
form=DiscussionForm(),
error=
"Title length must be between 5 and 100 characters. Content must be between 5 and 2000 characters."
)
discussion = Discussion(form.title.data)
discussion.set_account_id(current_user.id)
#Tags are separated by whitespace, split them into array and append them to discussion separately.
discussion_tags = form.tags.data.split(' ')
for tagname in discussion_tags:
# Check for empty strings
if tagname and tagname.strip():
tag = Tag(tagname)
discussion.tags.append(tag)
db.session().add(discussion)
db.session().commit()
message = Message(form.content.data)
message.set_account_id(current_user.id)
message.set_discussion_id(discussion.id)
db.session().add(message)
db.session().commit()
return redirect(url_for("discussions_show", discussion_id=discussion.id))
def messages_create(thread_id):
form = MessageForm(request.form)
if not form.validate():
thread = Thread.query.filter_by(id=thread_id).first()
title = thread.title
return render_template(
"messages/list.html",
messages=Message.query.filter_by(thread_id=thread_id).order_by(
Message.date_created),
thread_id=thread_id,
title=title,
form=form)
m = Message(form.content.data)
m.thread_id = thread_id
m.account_id = current_user.id
db.session().add(m)
db.session().commit()
t = Thread.query.filter_by(id=thread_id).first()
t.date_modified = datetime.utcnow()
db.session().commit()
return redirect(url_for("get_messages_from_thread_id",
thread_id=thread_id))
def threads_create():
categories = [(c.id, c.name) for c in Category.query.all()]
if request.method == "GET":
form = ThreadForm()
form.categories.choices = categories
return render_template("threads/new.html", form=form)
form = ThreadForm(request.form)
form.categories.choices = categories
if not form.validate():
return render_template("threads/new.html", form=form)
t = Thread(form.title.data)
t.account_id = current_user.id
categories = form.categories.data
for c_id in categories:
c = Category.query.get(c_id)
t.categories.append(c)
db.session().add(t)
db.session().flush()
m = Message(form.content.data)
m.thread_id = t.id
m.account_id = current_user.id
db.session().add(m)
db.session().commit()
return redirect(url_for("threads_index"))
def messages_create(channel_id):
messageform = MessageForm(request.form)
channel = Channel.query.get(channel_id)
if not messageform.validate() or messageform.body.data.isspace():
return render_template(
"channels/channel.html",
messageform=MessageForm(),
channel=channel,
que=Message.count_how_many_comments_get_first(channel_id),
my_channels=Channel.get_my_channels(current_user.id),
all_channels=Channel.get_channels_where_not_in(current_user.id),
allready_join=Channel.is_joined(channel_id, current_user.id),
error="message must be 2 character length",
public_channels=Channel.get_all_publics())
message = Message(messageform.body.data, current_user.username)
message.account_id = current_user.id
message.channel_id = channel_id
db.session().add(message)
db.session().commit()
return redirect(
url_for("one_channel_index", channel_id=channel_id, sort='first'))
def topics_create():
form = TopicForm(request.form)
if form.title.validate(form) and form.message.validate(form):
place = db.session.query(Place).get(form.place.data)
if form.place.data == 0:
place_id = 0
else:
place_id = place.id
topic = Topic(form.title.data, place_id)
db.session().add(topic)
db.session().commit()
topic_timefix = Topic.query.get(topic.id)
topic_timefix.date_created = datetime.now().replace(microsecond=0, second = 0)
db.session().commit
message = Message(form.message.data, topic.id, current_user.id)
db.session().add(message)
db.session().commit()
message_timefix = Message.query.get(message.id)
message_timefix.date_created = datetime.now().replace(microsecond=0, second = 0)
db.session().commit()
newTopicAccount = topicAccount.insert().values(topic_id=topic.id, account_id=current_user.id)
db.session().execute(newTopicAccount)
db.session.commit()
return redirect(url_for("topics_index"))
places = db.session.query(Place)
form=TopicForm()
form.place.choices = [("0", "---")] + [(i.id, i.name) for i in places]
return render_template("topics/new.html", form = form, error="topic name must be between 1-100 characters and message between 1-1000 characters")
def thread(thread_id,
thread_edit=None,
message_create=Message("", None, None),
show_errors=False,
message_edit=None,
message_edit_id=None):
if message_edit_id:
message_edit_id = int(message_edit_id)
message_edit = Message.query.get(message_edit_id)
thread = Thread.query.get(thread_id)
thread.user = User.query.get(thread.account_id)
if current_user.is_authenticated:
Read.mark_as_read(current_user.id, thread_id)
return render_template("thread.html",
thread=thread,
thread_edit=thread_edit,
tags=Tag.find_thread_id(thread_id),
other_tags=Tag.find_not_thread_id(thread_id),
messages=Message.find_thread_id(thread_id),
message_create=message_create,
show_errors=show_errors,
message_edit=message_edit)
def thread_respond(thread_id):
form = MessageForm(request.form)
if not form.validate():
return render_template("message_response_form.html", form = form)
new_message = Message(title=form.title.data, content=form.content.data, time_of_sending=datetime.now(), author_id=current_user.id, thread_id=thread_id)
db.session.add(new_message)
db.session.commit()
return render_template("thread_details.html", thread=Thread.query.get(thread_id))
def post_reply(thread_id, message_text, user_id):
m = Message(message_text, thread_id=thread_id,
user_id=user_id)
t = Thread.query.get(thread_id)
t.date_modified = db.func.current_timestamp()
db.session.add(m)
db.session.commit()
def create_thread(title, message_text, user_id, category_id):
t = Thread(title=title, category_id=category_id)
db.session.add(t)
db.session.flush()
m = Message(message_text=message_text, thread_id=t.id,
user_id=user_id, original_post=True)
db.session.add(m)
db.session.commit()
def messages_create(target):
check_ban(target)
form = MessageForm(request.form)
if not form.validate():
return redirect(url_for("discussion_home", target=target, page=1))
m = Message(request.form.get("message"), target, current_user.get_id())
db.session().add(m)
db.session().commit()
return redirect(url_for("discussion_home", target=target, page=1))
def message_create(thread_id):
text = request.form.get("text")
message = Message(text, current_user.id, thread_id)
if not message.validate(new=True):
return thread(thread_id=thread_id,
message_create=message,
show_errors=True)
db.session().add(message)
db.session().commit()
return redirect(url_for('thread', thread_id=thread_id))
def discussions_comment(discussion_id):
form = CommentForm(request.form)
if not form.validate():
return redirect(
url_for("discussions_show", discussion_id=discussion_id))
message = Message(form.comment.data)
message.set_account_id(current_user.id)
message.set_discussion_id(discussion_id)
db.session().add(message)
db.session().commit()
return redirect(url_for("discussions_show", discussion_id=discussion_id))
def message_new(group_id):
form = MessageForm(request.form)
if not form.validate():
return render_template("messages/newMessage.html", form=form)
m = Message(form.name.data)
m.text = m.text
m.account_id = current_user.id
m.group_id = group_id
db.session().add(m)
db.session().commit()
return redirect(url_for("group_messages", group_id=group_id))
def messages_create(topic_id):
form = MessageForm(request.form)
if not form.validate():
return render_template("messages/new.html", form = form, topic_id=topic_id)
m = Message(form.message.data)
m.account_id = current_user.id
m.topic_id = topic_id
db.session().add(m)
db.session().commit()
return redirect(url_for("messages_index", topic_id=topic_id))
def messages_create():
form = MessageForm(request.form)
if not form.validate():
return render_template("index.html",
messages=Message.query.all(),
form=form)
m = Message(form.message.data)
db.session().add(m)
db.session().commit()
return redirect(url_for("index"))
def messages_create():
form = MessageForm(request.form)
if not form.validate():
return render_template("messages/new.html", form = form)
t = Message(form.name.data, form.messagetext.data)
t.account_id = current_user.id
t.category_id = request.form['category_id']
db.session().add(t)
db.session().commit()
return redirect(url_for("messages_index"))
def message_add(club_id):
club = Club.query.get(club_id)
if not club or current_user.id != club.leader_id:
return redirect(url_for("clubs_index"))
form = MessageForm(request.form)
if not form.validate():
return render_template("clubs/club.html", club=club)
message = Message(form.message.data)
message.club_id = club.id
db.session().add(message)
db.session().commit()
return redirect(url_for("club_page", club_id=club.id))
def messages_create():
f = MessageForm()
if not f.validate():
return render_template("messages/new.html", form=f)
m = Message(f.subject.data, f.body.data)
m.account_id = current_user.id
for c in f.categories.data:
cat = Category.query.get(c)
m.categories.append(cat)
db.session.add(m)
db.session.commit()
return redirect(url_for("messages_index"))
def thread_create():
user_choices = request.form.getlist("choices")
topics = []
for user_choice in user_choices:
topics.append(Topic.query.get(int(user_choice)))
new_thread = Thread(title="väliaikainen otsikko", time_of_opening=datetime.now(), author_id=current_user.id, topics=topics)
db.session.add(new_thread)
db.session.commit()
form = MessageForm(request.form)
if not form.validate():
return render_template("message_opening_form.html", form = form)
new_message = Message(title=form.title.data, content=form.content.data, time_of_sending=datetime.now(), author_id=current_user.id, thread_id=new_thread.id)
new_thread.title = new_message.title
db.session.add(new_message)
db.session.commit()
return render_template("thread_details.html", thread = new_thread)
def messages_create(topic_id):
form = MessageForm(request.form)
if not form.validate():
return render_template("topics/one_topic.html",
form=form,
topic=Topic.query.get(topic_id),
messages=Message.query.filter_by(
topic_id=topic_id,
reply_id=None).paginate(page=1,
per_page=5,
error_out=False))
m = Message(form.name.data)
m.author = current_user.name
m.account_id = current_user.id
m.topic_id = topic_id
db.session.add(m)
db.session.commit()
return redirect("/topics/" + topic_id + "/")
def messages_create(topic_id):
form = ReplyForm(request.form)
if form.validate_on_submit():
message = Message(form.reply.data, topic_id, current_user.id)
db.session().add(message)
db.session().commit()
message_timefix = Message.query.get(message.id)
message_timefix.date_created = datetime.now().replace(microsecond=0, second = 0)
db.session().commit()
currentTopicUsers = Topic.query.get(topic_id).accounts.all()
for user in currentTopicUsers:
if user.id == current_user.id:
return redirect(url_for("topic_index", topic_id = topic_id))
newTopicAccount = topicAccount.insert().values(topic_id=topic_id, account_id=current_user.id)
db.session().execute(newTopicAccount)
db.session.commit()
return redirect(url_for("topic_index", topic_id = topic_id))
return render_template("topics/topic.html", messages = db.session.query(Message).filter(Message.topic_id == topic_id), topic = Topic.query.get(topic_id), form = form, error="message must be between 1-1000 characters")
def messages_reply(topic_id, message_id):
form = MessageForm(request.form)
if not form.validate():
return render_template(
"messages/one.html",
topic=Topic.query.get(topic_id),
form=form,
message=Message.query.get(message_id),
replies=Message.query.filter_by(reply_id=message_id).all(),
further_replies=Message.query.filter_by(topic_id=topic_id))
reply = Message(form.name.data)
reply.author = current_user.name
reply.account_id = current_user.id
reply.topic_id = topic_id
reply.reply_id = message_id
db.session.add(reply)
db.session.commit()
return redirect("/topics/" + topic_id + "/" + "messages" + "/" +
message_id + "/")
def messages_create(auction_id):
html_file = "auctions/view.html"
a = Auction.query.get(auction_id)
form = BiddingForm(request.form)
invalid = False
if not form.message.validate(form):
invalid = True
seller = User.query.get(a.account_id)
bids = Bid.find_bids(auction_id)
highest_bid = Bid.highest_bid(auction_id)
messages = Message.get_messages(auction_id)
ended = 0
if a.date_ends < datetime.datetime.now():
ended = 1
time_to_go = a.date_ends - datetime.datetime.now()
if invalid:
return render_template(html_file,
form=form,
edit_mode=0,
seller=seller,
bids=bids,
highest_bid=highest_bid,
ended=ended,
days_to_go=time_to_go.days,
messages=messages,
auction=a)
m = Message(auction_id, current_user.id, form.message.data)
db.session().add(m)
db.session().commit()
return redirect(url_for("auctions_view", auction_id=auction_id))