def message():
if request.method == 'POST':
msg = Message()
msg.email = request.form.get('email')
msg.message = get_word(request.form.get('message'))
db.session.add(msg)
db.session.commit()
return redirect(url_for('contact'))
else:
return render_template('leave_message.html')
def setUp(self):
db.create_all()
user1 = User("Elie", "Schoppik")
user2 = User("Tim", "Garcia")
user3 = User("Matt", "Lane")
db.session.add_all([user1, user2, user3])
message1 = Message("Hello Elie!!", 1)
message2 = Message("Goodbye Elie!!", 1)
message3 = Message("Hello Tim!!", 2)
message4 = Message("Goodbye Tim!!", 2)
db.session.add_all([message1, message2, message3,message4])
db.session.commit()
def handle_message(req):
try:
new_message = Message(content=req['message'],
created=datetime.now(),
user_id=session['user_id'])
db.session.add(new_message)
db.session.commit()
messages = Message.query.filter_by(
user_id=session['user_id']).order_by(Message.id.desc()).limit(1)
result = {
'data': {
'messages': [{
'id': msg.id,
'author': msg.user.username,
'content': msg.content,
'date': str(msg.created)
} for msg in messages]
}
}
emit('message-to-front', result, broadcast=True)
except:
result = {
'error': {
'type':
'message sending error',
'message':
'something went wrong with sending your message to the message board. try reloading the webpage and sending your message again later!'
}
}
emit('message-to-front', result)
def post(self, id):
parser = reqparse.RequestParser()
parser.add_argument('text', type=str, help='message text')
args = parser.parse_args()
new_message = Message(user_id=id, text=args['text'])
db.session.add(new_message)
db.session.commit()
print("Adding a message for logged in user")
return new_message
def test_unread_message(self):
u1 = User(username="******", email="*****@*****.**")
u2 = User(username="******", email="*****@*****.**")
db.session.add_all([u1, u2])
first_msg = Message(author=u1, recipient=u2, body="first message")
db.session.add(first_msg)
db.session.commit()
self.assertEqual(u2.new_messages(), 1)
second_msg = Message(author=u1, recipient=u2, body="second message")
db.session.add(second_msg)
db.session.commit()
self.assertEqual(u2.new_messages(), 2)
u2.last_message_read_time = datetime.utcnow()
self.assertEqual(u2.new_messages(), 0)
def show(id):
if request.method == 'POST':
db.session.add(Message(request.form['msg_text'], id))
db.session.commit()
messages = Message.query.filter_by(user_id=id)
user = User.query.filter_by(id=id).first()
return render_template('messages/message.html',
messages=messages,
id=id,
user=user)
def test_message_body(self):
u1 = User(username="******", email="*****@*****.**")
u2 = User(username="******", email="*****@*****.**")
db.session.add_all([u1, u2])
msg = Message(author=u1, recipient=u2, body="message to susan")
db.session.add(msg)
db.session.commit()
u2_msg = u2.messages_received.first()
self.assertEqual(u2_msg.body, "message to susan")
def new_message():
error = None
form = AddMessageForm(request.form)
if request.method == 'POST':
if form.validate_on_submit():
new_message = Message(form.message.data, form.message_type.data,
session['user_id'])
db.session.add(new_message)
db.session.commit()
flash('New entry was successful.')
return redirect(url_for('messages.allmessages'))
def index(user_id):
user = User.query.get(user_id)
if request.method == "POST":
form = MessageForm(request.form)
if form.validate():
new_message = Message(form.content.data, user.id)
db.session.add(new_message)
db.session.commit()
flash('Message Created!')
return redirect(url_for('messages.index', user_id=user.id))
return render_template('messages/new.html', form=form, user=user)
return render_template('messages/index.html', user=user)
def send_message(recipient):
user = User.query.filter_by(username=recipient).first_or_404()
form = MessagesForm()
if form.validate_on_submit():
msg = Message(author=current_user, recipient=user, body=form.message.data)
db.session.add(msg)
user.add_notification("unread_message_count", user.new_messages())
db.session.commit()
flash(_("Your message has been sent."))
return redirect(url_for("main.user", username=recipient))
return render_template(
"send_message.html", title=_("Send Message"), form=form, recipient=recipient
)
def message(username):
form = MessageForm()
user = User.query.filter_by(username=username).first()
if form.validate_on_submit():
title = form.title.data
body = form.body.data
receiver = user
sender = current_user
message = Message(title=title, body=body, receiver_id=receiver.id, sender_id=sender.id)
db.session.add(message)
db.session.commit()
flash(f'Sent message to {username}!', 'success')
return redirect(url_for('user', username=username))
return render_template('message.html', form=form, user=user)
def new_message(user_id):
form = MessageForm(request.form)
form.set_choices()
if form.validate():
user = User.query.get(user_id)
message = Message(request.form["message"])
tags = [Tag.query.get(t) for t in form.tags.data]
new_tag = get_new_tag(request.form["new_tag"])
if new_tag:
tags.append(new_tag)
message.tags.extend(tags)
user.messages.extend([message])
db.session.commit()
return redirect(url_for("messages.index"))
def index(user_id):
user = User.query.get(user_id)
if request.method == "POST":
form = MessageForm(request.form)
form.set_choices()
if form.validate():
new_message=Message(form.content.data, user.id)
for tag in form.tags.data:
new_message.tags.append(Tag.query.get(tag))
db.session.add(new_message)
db.session.commit()
flash('Message Created!')
return redirect(url_for('messages.index', user_id=user.id))
return render_template('new.html', user=user, form=form)
return render_template('index.html', user=user)
def send_message(recipient):
user = User.query.filter_by(username=recipient).first_or_404()
form = MessageForm()
if form.validate_on_submit():
msg = Message(athlet=current_user,
recipient=user,
body=form.message.data)
db.session.add(msg)
user.add_notification('unread_message_count', user.new_messages())
db.session.commit()
flash('Deine Nachricht wurde gesendet.')
return redirect(url_for('main.user', username=recipient))
return render_template('send_message.html',
title='Nachricht senden',
form=form,
recipient=recipient)
def search():
contacts = Contact.query.filter_by(owner_id=current_user.id).all()
if not g.search_form.validate():
return redirect(url_for('message.sent_messages'))
page = request.args.get('page', 1, type=int)
messages, total = Message.search(g.search_form.q.data, page,
current_app.config['MESSAGES_PER_PAGE'])
next_url = url_for(
'messages.search', q=g.search_form.q.data, page=page +
1) if total > page * current_app.config['MESSAGES_PER_PAGE'] else None
prev_url = url_for(
'messages.search', q=g.search_form.q.data, page=page -
1) if page > 1 else None
return render_template('sent.html',
title='Search',
sent_messages=messages,
contacts=contacts,
next_url=next_url,
prev_url=prev_url)
def message():
contacts = Contact.query.filter_by(owner_id=current_user.id).all()
form = MessageForm()
if form.validate_on_submit():
# response = send_message(form.recipient_no.data, form.message.data)
# print(response.text)
# print(type(response.text))
# print(response.status_code, type(response.status_code))
# print(response.json())
# if response.status_code == 200:
recipient = Contact.query.filter(
and_(Contact.contact_no == form.recipient_no.data,
Contact.owner == current_user)).first()
message = Message(message_body=form.message.data,
sender=current_user,
recipient=recipient)
db.session.add(message)
db.session.commit()
flash("message sent", "success")
return redirect(
url_for("messages.message", form=form, contacts=contacts))
return render_template("message.html", form=form, contacts=contacts)
def create_message(request, project_id, message_id):
project_id = int(project_id)
project = get_object_or_404(Project, id=project_id)
if message_id == None:
# create_message
message = Message(project=project,
owner=request.user)
message.save()
return redirect('create_message_page',
project_id=project_id,
message_id=message.id)
else:
message_id = int(message_id)
message = get_object_or_404(Message,
project=project,
owner=request.user,
id=message_id)
# process form
if request.method == 'POST':
file_upload_form = FileUploadForm(request.POST, request.FILES)
perm_choice_form = PermChoiceForm(request.POST)
message_info_form = MessageInfoForm(request.POST)
if message_info_form.is_valid():
message.title = message_info_form.cleaned_data['title']
message.description = message_info_form.cleaned_data['description']
message.post_flag = True
message.save()
# redirect to somewhere
if file_upload_form.is_valid() and perm_choice_form.is_valid():
uploaded_file = request.FILES['uploaded_file']
owner_perm = perm_choice_form.cleaned_data['owner_perm']
group_perm = perm_choice_form.cleaned_data['group_perm']
everyone_perm = perm_choice_form.cleaned_data['everyone_perm']
# check unique
md5 = gen_MD5_of_UploadedFile(uploaded_file)
unique_file = UniqueFile.objects.filter(md5=md5)
if not unique_file:
unique_file = UniqueFile(md5=md5)
unique_file.save()
unique_file.file.save(md5, uploaded_file)
else:
unique_file = unique_file[0]
# save file info
file_info = FileInfo(name=uploaded_file.name,
owner_perm=owner_perm,
group_perm=group_perm,
everyone_perm=everyone_perm,
unique_file=unique_file,
message=message)
file_info.save()
return redirect('create_message_page',
project_id=project_id,
message_id=message.id)
else:
file_upload_form = FileUploadForm()
perm_choice_form = PermChoiceForm(initial={
'owner_perm': FileInfo.READ_AND_WRITE,
'everyone_perm': FileInfo.READ,
'group_perm': FileInfo.READ
})
message_info_form = MessageInfoForm()
# rendering
# generate uploaded file list
# notice that file_name could be duplicate,
# so it can not be the key for dict.
display_file_info = {file_info.id: file_info.name\
for file_info in message.fileinfo_set.all()}
render_data_dict = {
'project_id': int(project_id),
'file_upload_form': file_upload_form,
'perm_choice_form': perm_choice_form,
'post_message_form': message_info_form,
'message_id': message.id,
'file_info_list': display_file_info,
}
return render(request,
'file_info/create_message_page.html',
render_data_dict)
def postFile(request):
if request.user is not None:
file = request.FILES['file']
groupName = request.data['groupName']
type = request.data['type']
qwirkGroup = QwirkGroup.objects.get(name=groupName)
#TODO security
#if request.user.qwirkuser in qwirkGroup.qwirkuser_set.all() or request.user.qwirkuser in qwirkGroup.contact_set.all():
message = Message(qwirkUser=request.user.qwirkuser,
qwirkGroup=qwirkGroup,
text=request.user.username + " upload a file",
dateTime=datetime.now(),
type=type)
message.file.save(file.name, file)
message.save()
messageSerialized = MessageSerializer(message)
text = json.dumps({
"action": "new-message",
"content": json.dumps(messageSerialized.data)
})
Group(groupName).send({
"text": text,
})
if qwirkGroup.isContactGroup:
for contact in qwirkGroup.contact_set.all():
print(contact.qwirkUser)
if contact.qwirkUser != request.user.qwirkuser:
notification = Notification.objects.create(
message=message, qwirkUser=contact.qwirkUser)
notification.save()
serializer = NotificationSerializerSimple(notification)
text = json.dumps({
"action": "notification",
"notification": serializer.data
})
Group("user" + contact.qwirkUser.user.username).send({
"text":
text,
})
else:
for qwirkUser in qwirkGroup.qwirkuser_set.all():
print(qwirkUser)
if qwirkUser != request.user.qwirkuser:
notification = Notification.objects.create(
message=message, qwirkUser=qwirkUser)
notification.save()
serializer = NotificationSerializerSimple(notification)
text = json.dumps({
"action": "notification",
"notification": serializer.data
})
Group("user" + qwirkUser.user.username).send({
"text": text,
})
return HttpResponse(status=200)
#else:
# return HttpResponse(status=403)
else:
return HttpResponse(status=401)
def new_message(user_id):
form = MessageForm(request.form)
if form.validate():
db.session.add(Message(request.form["message"], user_id))
db.session.commit()
return redirect(url_for("messages.index"))
