def comm_item_buyer(request, item, curr_user):
"""
The curr_user is the seller, show him the communication interface
"""
if request.method == 'POST':
form = CommForm(request.POST)
if form.is_valid():
msg = form.cleaned_data['message']
try:
comm = Comm.objects.get(buyer=curr_user.user_obj, item=item)
except Comm.DoesNotExist:
comm = Comm(buyer=curr_user.user_obj, item=item)
comm.save()
message = Messages(comm=comm, content=msg, user=curr_user.user_obj)
message.save()
form = CommForm()
else:
form = CommForm()
# View Part
try:
comm = Comm.objects.get(buyer=curr_user.user_obj, item=item)
try:
ret = Messages.objects.filter(comm=comm).order_by('-time')
except Messages.DoesNotExist:
ret = []
except Comm.DoesNotExist:
ret = []
comm = Comm(buyer=curr_user.user_obj, item=item)
return render(request, 'comm.html',{'msgs': ret, 'form': form, 'DealForm': DealForm(), 'comm': comm, 'role': 'buyer', 'item': item, 'CancelForm': CancelForm()})
def get_chat_stats(self, update, users_in_conversation):
msg = update.message
all_messages = Messages.objects(from_chat=msg.chat_id).only('from_user', 'number_of_words')
total_messages = all_messages.count()
user_stats = []
total_words = 0
for user in users_in_conversation:
messages = Messages.objects(
from_chat=msg.chat_id,
from_user=user
).only('from_user', 'number_of_words')
messages_per_user = messages.count()
words_per_user = self.count_words(messages)
total_words += words_per_user
conv_percentage = (messages_per_user / total_messages) * 100
user_stats.append({
'user': user,
'number_of_messages': messages_per_user,
'conversation_percentage': "{0:.2f}".format(conv_percentage),
'number_of_words': words_per_user
})
return {
'total_words': total_words,
'total_messages': total_messages,
'user_stats': user_stats
}
def setUp(self):
self.item = Messages()
self.item.title = "OK"
self.item.description = "OK"
self.item.save()
self.item1 = Event()
self.item1.title = "OK"
self.item1.description = "OK"
self.item1.save()
self.item2 = Documentation()
self.item2.title = "OK"
self.item2.description = "OK"
self.item2.save()
self.item3 = SignUp()
self.item3.title = "OK"
self.item3.description = "OK"
self.item3.save()
self.item4 = Feedback()
self.item4.title = "OK"
self.item4.description = "OK"
self.item4.save()
def send_message(cursor, from_id, recipient_name, text):
if len(text) > 255:
print("Message is too long!")
return
to = User.load_user_by_username(cursor, recipient_name)
if to:
message = Messages(from_id, to.id, text=text)
message.save_to_db(cursor)
print("Message send")
else:
print("Recipient does not exist.")
def count(self, update, args):
msg = update.message
if len(args) == 0:
messages = Messages.objects(from_chat=msg.chat.id)
username = msg.chat.title
else:
user = Users.objects(first_name__iexact=' '.join(args), chats__contains=msg.chat_id).first()
username = user.username if user.username else user.first_name
messages = Messages.objects(from_user=user.id).only('number_of_words')
return username, messages.count(), self.count_words(messages)
def start_mailing(bot: Bot, update: Update):
uid = update.message.from_user.id
message = update.message.text
chats = Chats.select()
for chat in chats:
Messages.create(owner=uid,
text=message,
chat_id=chat.id,
send_dt=dt.now())
bot.send_message(chat.id, message, parse_mode=ParseMode.HTML)
bot.send_message(uid, 'Рассылку закончил')
return ConversationHandler.END
def route_msg(request):
if current_user(request) == '【游客】':
return redirect('/login')
if request.method == 'POST':
form = request.form()
message = Messages(form)
message.save()
messages = '<br>'.join([str(m) for m in Messages.all()])
body = template('/index_basic.html')
body = body.replace('{{message}}', messages)
header = 'HTTP/1.1 200 OK\r\nContent-Type= text/html\r\n'
r = header + '\r\n' + body
return r.encode('utf-8')
def message():
if request.method == 'POST':
form = request.form
print(form)
name = form['name']
email = form['email']
message = form['message']
new_message = Messages(name=name, email=email, message=message)
new_message = new_message.save()
print(new_message)
return redirect(url_for('success'))
return render_template('index.html')
def comm_seller_buyer(request, item_id, user_nick, curr_user):
"""
Communication view for seller with a buyer
"""
try:
item = items.objects.get(id=item_id, is_expired=False, is_sold=False)
except items.DoesNotExist:
try:
item = items.objects.get(id=item_id, is_expired=False, is_sold=True)
if item.user != curr_user.user_obj and item.buyer != curr_user.user_obj:
return render(request, 'error.html', {'error': 'Item Not Found'})
except items.DoesNotExist:
return render(request, 'error.html', {'error': 'Item Not Found'})
try:
tar_user = user_profile.objects.get(nick=user_nick)
except user_profile.DoesNotExist:
return render(request, 'error.html', {'error': 'User Not Found'})
# if the curr_user is not the seller
if item.user != curr_user.user_obj:
return render(request, 'error.html', {'error': 'You are not allowed to be here!'})
try:
comm = Comm.objects.get(buyer=tar_user, item=item)
except Comm.DoesNotExist:
return render(request, 'error.html', {'error': 'No communications exist!'})
if request.method == 'POST':
form = CommForm(request.POST)
if form.is_valid():
msg = form.cleaned_data['message']
message = Messages(comm=comm, content=msg, user=curr_user.user_obj)
message.save()
form = CommForm()
else:
form = CommForm()
# View Part
try:
comm = Comm.objects.get(buyer=tar_user, item=item)
try:
ret = Messages.objects.filter(comm=comm).order_by('-time')
except Messages.DoesNotExist:
ret = []
except Comm.DoesNotExist:
return render(request, 'error.html', {'error': 'No communications exist!'})
return render(request, 'comm.html',{'msgs': ret, 'form': form, 'role': 'seller', 'DealForm': DealForm(), 'item': item, 'comm': comm})
def new_message():
if request.method == "POST":
message = Messages(names=request.form['name'],emails=request.form['email'],subjects=request.form['subject'],messages=request.form['message'])
db.session.add(message)
db.session.commit()
flash('Your message has been sent!', 'success')
return redirect(url_for('contact'))
def get(self, login):
"""
Retrouve toutes les messages destinées à un utilisateur qui a le login spécifié
et retourne une liste de toutes ces messages.
"""
try:
cle = ndb.Key("User", login)
destiUser = cle.get()
if destiUser is None:
self.error(400)
return
liste_msg = []
requete = Messages.query()
requete = requete.filter(Messages.to == login)
for msg in requete:
msg_dict = msg.to_dict()
msg_dict["id"] = msg.key.id()
liste_msg.append(msg_dict)
json_data = json.dumps(liste_msg, default=serialiser_pour_json)
self.response.headers["Content-Type"] = "application/json;" + " charset=utf-8"
self.response.out.write(json_data)
except (db.BadValueError, ValueError, KeyError):
logging.error("%s", traceback.format_exc())
self.error(400)
except Exception:
logging.error("%s", traceback.format_exc())
self.error(500)
def contact(request):
if request.POST:
try:
message = Messages(name=request.POST.get('name', None),
email=request.POST.get('email', None),
message=request.POST.get('message', None),
subject=request.POST.get('subject', None))
message.save()
return render(request, 'advertisements/contact.html',
{"success": True})
except Messages.DoesNotExist:
return render(request, 'advertisements/contact.html',
{"error": True})
else:
return render(request, 'advertisements/contact.html')
def setMessage():
text = request.json
current = Users.query.filter_by(user_id=session['user_id']).first()
msg = Messages(message=text['msg'], post_date=datetime.now(), send_id=session['user_id'], room_id=session['room_id'], post_msg=current.username)
db.session.add(msg)
db.session.commit()
return render_template('chatty_room.html')
def websocket_to_database():
try:
websocket = yield from websockets.connect("wss://ws-feed.exchange.coinbase.com")
except gaierror:
db_logger.error('socket.gaierror - had a problem connecting to Coinbase feed')
return
yield from websocket.send('{"type": "subscribe", "product_id": "BTC-USD"}')
while True:
message = yield from websocket.recv()
if message is None:
file_logger.error('Websocket message is None!')
break
try:
message = json.loads(message)
except TypeError:
db_logger.error('JSON did not load, see ' + str(message))
continue
if message['type'] != 'match':
continue
new_message = Messages()
for key in message:
if hasattr(new_message, key):
setattr(new_message, key, message[key])
else:
db_logger.error(str(key) + ' is missing, see ' + str(message))
continue
try:
session.add(new_message)
session.commit()
except IntegrityError:
session.rollback()
except DatabaseError:
file_logger.error('Database Error')
session.rollback()
def send_message():
""" Adds contact details to the backend while sending a dummy SMS.
"""
smstext = "Hi. Your OTP is: "
random_string = ''.join(
["%s" % random.randint(0, 9) for num in range(0, 6)])
smstext += random_string
print(smstext)
try:
result = Messages(name=session['current_user'],
message=smstext,
time=str(datetime.datetime.now()))
db.session.add(result)
print('Added result to session')
db.session.commit()
print('DB Addition Success')
except Exception as e:
db.session.rollback()
print("Unable to add item to database.")
print(e)
return render_template('error.html', error=e)
finally:
db.session.close()
return render_template('sendmessage.html', smstext=smstext)
def message(request):
if request.method == 'POST':
form = MessageForm(request.POST)
if form.is_valid():
name = form.cleaned_data['name']
content = form.cleaned_data['content']
ip = request.META['REMOTE_ADDR']
sess = request.session
if not sess.has_key( 'name' ) or sess['name'] != name:
sess['name'] = name
if name.lower() == 'orange':
name = 'Wrong way'
content = 'Try to pwn a shell instead of cracking md5.'
elif md5.new(name).hexdigest() == 'e5bc16fcbca0f279df17b66d8c37e109':
name = 'Orange'
Messages( name=name,
content=content,
ip=ip ).save()
return HttpResponseRedirect( '/' )
else:
sess = request.session.load()
if sess.has_key( 'name' ):
default = sess['name']
else:
default = 'Guest'
form = MessageForm( initial={'name': default} )
messages = Messages.objects.order_by('id').reverse()[:100]
response = render_to_response( 'message.html',
{'form': form, 'messages': messages} )
return response
def api_send_message(userid):
"""send message from one user to another"""
resp_data = {'result': False, 'message': None}
if request.headers['Content-Type'] == 'application/json':
message = request.json
recipient = message.get('recipient')
if recipient is None:
resp_data['message'] = 'missing the recipient'
return Response(json.dumps(resp_data), status=401, mimetype='application/json')
enc_message = message.get('message')
if enc_message is None:
resp_data['message'] = 'missing the encrypted message'
return Response(json.dumps(resp_data), status=401, mimetype='application/json')
message_id = message.get('messageID')
if message_id is None or not isInt(message_id):
resp_data['message'] = 'missing message ID'
return Response(json.dumps(resp_data), status=401, mimetype='application/json')
r = User.query.filter_by(username=recipient).first()
if r is None:
resp_data['message'] = 'no such recipient'
return Response(json.dumps(resp_data), status=401, mimetype='application/json')
m = Messages(userid, r, message_id, enc_message)
db.session.add(m)
db.session.commit()
resp_data['result'] = True
resp_data['message'] = 'message delivered'
return Response(json.dumps(resp_data), status=200, mimetype='application/json')
else:
return "415 Unsupported Media Type"
async def messages(addr, pm25, pm10):
data = time.strftime('%Y-%m-%d %H:%M')
messages = Messages(addr=addr, data=data, pm25=pm25, pm10=pm10)
await messages.save()
response = '<h1>OK!!!</h1>'
return web.Response(body=response.encode('utf-8'),
content_type='text/html')
def like(self, id):
message = Messages.load(id)
if message:
message.like.append(user_id=current_user.id, \
displayname=current_user.displayname, \
organisation_id=current_user.organisation_id, \
is_like = 1)
message.store()
def like(self, id):
message = Messages.load(id)
if message:
message.like.append(user_id=current_user.id, \
displayname=current_user.displayname, \
organisation_id=current_user.organisation_id, \
is_like = 1)
message.store()
def comment(self, id):
content=request.form['comment']
message = Messages.load(id)
message.comments.append(user_id=current_user.id, \
organisation_id=current_user.organisation_id, \
displayname=current_user.displayname, \
content=content)
message.store()
return jsonify({'response' : True})
def comment(self, id):
content = request.form['comment']
message = Messages.load(id)
message.comments.append(user_id=current_user.id, \
organisation_id=current_user.organisation_id, \
displayname=current_user.displayname, \
content=content)
message.store()
return jsonify({'response': True})
def top_messagers_in_chat(self, chat_id, top_num):
users_in_chat = Users.objects(chats__contains=chat_id).only('id')
user_ids = map(lambda n: n.id, users_in_chat)
count_dict = {}
for user_id in user_ids:
count_dict[self.get_user_name(user_id)] = Messages.objects(from_chat=chat_id, from_user=user_id).count()
return form_list(count_dict,top_num)
def print_user_messages(cursor, user):
messages = Messages.load_all_messages(cursor, user.id)
for message in messages:
from_ = User.load_user_by_id(cursor, message.from_id)
print(20 * "-")
print(f"from: {from_.username}")
print(f"data: {message.creation_date}")
print(message.text)
print(20 * "-")
def send_a_massage(username, password, to_id, text):
if User.load_user_by_username(connect1().cursor(), username) == None:
print('This username doesn\'t exists, submit a correct username')
else:
user1 = User.load_user_by_username(connect1().cursor(), username)
if check_password(str(password), user1.hashed_password):
a = User.load_user_by_id(connect1().cursor(), to_id)
if a != None:
if len(text) < 255:
from_id = user1.id
message1 = Messages(from_id, to_id, text)
message1.save_to_db(connect1().cursor())
return "Message sent"
else:
print('Your message is too long, should be maximum 255 characters')
else:
print("Receiver\'s id is incorrect")
else:
print('Wrong password')
def send_message(cursor, username, password, to_user, content):
user = User.load_user_by_name(cursor, username)
if not user:
print("User does not exist.")
elif check_password(password, user.hashed_password):
user2 = User.load_user_by_name(cursor, to_user)
if not user2:
print("That user does not exist.")
else:
if len(content) < 255:
message = Messages(from_id=user.id,
to_id=user2.id,
text=content)
message.save_to_db(cursor)
print("Message send.")
else:
print("Your message is too long, maximum 254 characters.")
else:
print("Incorrect password.")
def send_message(user_id, chat_id):
req = utils.check_params(request.get_json(), 'message')
# messages have a 100 char limit, make sure to break it up
db.session.add(
Messages(chat_id=chat_id, user_id=user_id, message=req['message']))
db.session.commit()
return jsonify(Chats.query.get(chat_id).serialize())
def select_messages(self, **kwargs):
self._selected_grbs = self._get_gids(**kwargs)
if len(self._selected_grbs) > 0:
self._gid_main_res = self._selected_grbs[0]
grid = GribGridDetails(self._selected_grbs[0])
# some cumulated messages come with the message at step=0 as instant, to permit aggregation
# cumulated rainfall rates could have the step zero instant message as kg/m^2, instead of kg/(m^2*s)
if len(self._selected_grbs) > 1:
unit = grib_get(self._selected_grbs[1], 'units')
type_of_step = grib_get(self._selected_grbs[1], 'stepType')
else:
type_of_step = grib_get(self._selected_grbs[0], 'stepType')
unit = grib_get(self._selected_grbs[0], 'units')
type_of_level = grib_get(self._selected_grbs[0], 'levelType')
missing_value = grib_get(self._selected_grbs[0], 'missingValue')
all_values = {}
all_values_second_res = {}
grid2 = None
input_step = self._step_grib
for g in self._selected_grbs:
start_step = grib_get(g, 'startStep')
end_step = grib_get(g, 'endStep')
points_meridian = grib_get(g, 'Nj')
if '{}-{}'.format(start_step,
end_step) == self._change_step_at:
# second time resolution
input_step = self._step_grib2
key = Step(start_step, end_step, points_meridian, input_step)
if points_meridian != grid.num_points_along_meridian and grid.get_2nd_resolution(
) is None:
# found second resolution messages
grid2 = GribGridDetails(g)
self._gid_ext_res = g
values = grib_get_double_array(g, 'values')
if not grid2:
all_values[key] = values
elif points_meridian != grid.num_points_along_meridian:
all_values_second_res[key] = values
if grid2:
key_2nd_spatial_res = min(all_values_second_res.keys())
grid.set_2nd_resolution(grid2, key_2nd_spatial_res)
return Messages(all_values, missing_value, unit, type_of_level,
type_of_step, grid, all_values_second_res)
# no messages found
else:
raise ValueError('No messages in grib file')
def close_qst():
rec = urllib.parse.parse_qs(request.body.read().decode())
log = rec.get('login')
puple = Puple.select().where(Puple.login == log)[0]
clas = puple[6]
letter = puple[7]
mes = Messages.select().where(Messages.puple_id == log)
mes.append()
return 'true'
def admin():
message = Messages.select(Messages.id, Messages.titre, Messages.content,
Messages.date_post, Messages.user).join(
Utilisateur, JOIN_LEFT_OUTER).order_by(
Messages.date_post.desc()).limit(5)
coms = Commentaires.select(
Commentaires.id, Commentaires.content, Commentaires.date,
Messages.user, Utilisateur.pseudo, Messages.titre,
Messages.id).join(Messages, JOIN_LEFT_OUTER).join(
Utilisateur,
JOIN_LEFT_OUTER).order_by(Commentaires.date.desc()).limit(5)
return render_template('management.html', com_loader=coms, loader=message)
def send_message(request, user_id):
if request.method == "POST":
message = Messages()
message.title = request.POST.get('title')
message.content = request.POST.get('content')
message.user_from = request.user
message.user_to = User.objects.get(id=user_id)
message.save()
return HttpResponseRedirect('/message/all/')
return HttpResponseRedirect('/message/write/'+user_id)
def insert_message(self, update):
self.create_chat(update)
self.create_user(update)
msg = update.message
new_message = Messages(
date=msg.date,
from_user=msg.from_user.id,
from_chat=msg.chat_id,
message_id=msg.message_id,
update_id=update.update_id,
number_of_words=len(msg.text.split()),
language=detect(msg.text)
)
new_text = Texts(
text=msg.text,
date=msg.date,
language=detect(msg.text)
)
new_text.save()
new_message.save()
def list_messages(cursor, username, password):
user = User.load_user_by_name(cursor, username)
if not user:
print("User does not exist.")
elif check_password(password, user.hashed_password):
messages = Messages.load_all_messages(cursor, user.id)
for message in messages:
sender = User.load_user_by_id(cursor, message.from_id)
print(
f"From: {sender.username}\n{message.text}\nDate: {message.creation_date}\n-----------------------------------------------------------------------------"
)
else:
print("Incorrect password.")
def messageAPI():
if request.method == 'GET':
messageID = request.args.get('messageID')
conversationID = request.args.get('conversationID')
filterBy = {}
if messageID:
filterBy['messageID'] = messageID
if conversationID:
filterBy['conversationID'] = conversationID
messages = Messages.query.filter_by(**filterBy).order_by(
Messages.sentTime)
messageList = []
for message in messages:
messageList.append({
"messageID": message.messageID,
"conversationID": message.conversationID,
"sender": message.sender,
"message": message.message,
"sentTime": message.sentTime,
"readTime": message.readTime,
"read": message.read
})
return jsonify(messageList)
elif request.method == 'POST':
#try:
updateJson = request.get_json()
print(updateJson)
returnPost = []
for jsonItem in list(updateJson):
conversationID = jsonItem['conversationID']
message = jsonItem['message']
sender = jsonItem['sender']
message = Messages(conversationID=conversationID,
message=message,
sender=sender)
saDB.session.add(message)
saDB.session.commit()
returnPost.append({
'ID': message.messageID,
'conversationID': message.conversationID,
'sender': message.sender,
'message': message.message,
'sentTime': message.sentTime
})
#except:
# return jsonify({'Message':'User Already Exists'})
return jsonify(returnPost)
def main():
error = None
form = MessageForm(request.form)
if request.method == 'POST':
if form.validate_on_submit():
new_message = Messages(datetime.datetime.utcnow(),
form.message.data)
db.session.add(new_message)
db.session.commit()
return redirect(url_for('main'))
return render_template('main.html',
messages=list_messages(),
form=form,
error=error)
def add_message():
first_user_id = request.json["first_user_id"]
second_user_name = request.json["second_user_name"]
message = request.json["message"]
second_user_id = Users.query.filter_by(
username=second_user_name).first().id
time_now = datetime.now(timezone('UTC')).strftime(
"%Y-%m-%d %H:%M:%S") #adds message in GMT(UTC)
new_message = Messages(first_user_id=first_user_id,
second_user_id=second_user_id,
message=message,
message_time_utc=time_now)
db.session.add(new_message)
db.session.commit()
return jsonify(message=new_message.message)
def sms_ahoy_reply():
number = request.args.get('From')
body = request.args.get('Body')
rating = request.args.get('poop_rating')
if verify_shant(number):
date_format='%m-%d-%Y'
date = datetime.datetime.now(tz=pytz.utc)
date = date.astimezone(timezone('US/Pacific'))
date_today = date.strftime(date_format)
new_poop = Messages(pooper_name='Shant',poop_date=date_today, poop_message=body, poop_rating=rating)
db.session.add(new_poop)
db.session.commit()
return 'Success'
return 'Falure'
"""
def print_msg(client, userdata, message):
payload = (message.payload).decode("utf-8").replace("'", '"')
payloaddict = json.loads(payload)
message = Messages(payloaddict['title'], payloaddict['body'])
print("The data with title: '" + message.title + "' and body: '" +
message.body + "' is received.")
db.session.add(message)
try:
db.session.commit()
print("message with title: '" + message.title + "' and body: '" +
message.body + "' is store to Database")
except exc.IntegrityError as e:
db.session().rollback()
print(e)
except exc.SQLAlchemyError:
pass
def chat():
json = request.get_json()
chat = Chats.query.get( json['chat_id'] )
if chat is None:
raise APIException('Chat was not found')
post = Messages(
chat_id = json["chat_id"],
writer_username = json["writer_username"],
message = json["message"]
)
db.session.add(post)
db.session.commit()
return 'added to chat'
def write_message(self, user, password, receiver, message, subject,
creation_date):
"""
this method takes the following arguments and creates a message object and inserts it into the database
:param user:
:param password:
:param receiver:
:param message:
:param subject:
:param creation_date:
:return:
"""
if self.check_user_password(user, password):
result = Messages(user, receiver, message, subject, creation_date)
self._insert_item(result)
return True
else:
return False
def post(self):
"""
Permet d'ajouter un message à la base de données avec le format de json suivant:
{
"sender":"alb",
"to":"a",
"message":"Albert a accepté votre demande de covoiturage",
"refParcour": 54531213213215
}
"""
try:
msg_dict_in = json.loads(self.request.body)
cle_sender = ndb.Key("User", msg_dict_in["sender"])
cle_receiver = ndb.Key("User", msg_dict_in["to"])
if cle_sender.get() is None or cle_receiver.get() is None:
self.error(400)
return
msg = Messages()
msg.sender = msg_dict_in["sender"]
msg.to = msg_dict_in["to"]
msg.message = msg_dict_in["message"]
msg.refParcour = msg_dict_in["refParcour"]
cle = msg.put()
self.response.set_status(200)
self.response.headers["Content-Type"] = "application/json;" + " charset=utf-8"
msg_dict_in["id"] = cle.id()
json_data = json.dumps(msg_dict_in, default=serialiser_pour_json)
self.response.out.write(json_data)
except (db.BadValueError, ValueError, KeyError):
logging.error("%s", traceback.format_exc())
self.error(400)
except Exception:
logging.error("%s", traceback.format_exc())
self.error(500)
def put(self, login, idParcours, idTrajet):
try:
cle_user_initiator = ndb.Key("User", login)
cle_parcours = ndb.Key("Parcours", long(idParcours))
cle_trajet = ndb.Key("Trajet", long(idTrajet))
user_initiator = cle_user_initiator.get()
parcours = cle_parcours.get()
trajet = cle_trajet.get()
if user_initiator is None or parcours is None or trajet is None:
self.error(400)
return
cle_user_target = ndb.Key("User", trajet.idAuthor)
user_target = cle_user_target.get()
msg_dict_out = {}
""" Ajouter une nouvelle demande"""
if (
idTrajet not in user_initiator.listeDemandesTrajet
and idParcours not in user_target.listDemandesParcours
and not trajet.booked
):
user_target.listDemandesParcours.append(idParcours)
msg = Messages()
msg.sender = login
msg.to = trajet.idAuthor
msg.message = user_initiator.firstName + u" vous a envoyé une demande de covoiturage"
msg.refParcour = long(idParcours)
msg.refTrajet = long(idTrajet)
cle = msg.put()
user_target.put()
msg_dict_out["id"] = cle.id()
msg_dict_out["succes"] = "La demande de covoiturage a été envoyé avec succès."
elif (
idTrajet in user_initiator.listeDemandesTrajet
and len(parcours.trajets) < parcours.nbPlaces
and idTrajet not in parcours.trajets
and not trajet.booked
):
""" Accepter une demande et ajouté un trajet à un parcours"""
parcours.trajets.append(long(idTrajet))
user_initiator.listeDemandesTrajet.remove(idTrajet)
msg = Messages()
msg.sender = login
msg.to = trajet.idAuthor
msg.message = user_initiator.firstName + u" a accepté votre demande de covoiturage"
msg.refParcour = long(idParcours)
msg.refTrajet = long(idTrajet)
cle = msg.put()
trajet.booked = True
parcours.put()
trajet.put()
user_initiator.put()
self.response.set_status(200)
msg_dict_out["succes"] = "Le trajet a été ajouté avec succès"
elif len(parcours.trajets) >= parcours.nbPlaces or trajet.booked:
if idTrajet in user_initiator.listeDemandesTrajet:
user_initiator.listeDemandesTrajet.remove(idTrajet)
user_initiator.put()
msg_dict_out["erreur"] = "Impossible d'ajouté un trajet. Le parcours est complet"
else:
msg_dict_out[
"erreur"
] = "Impossible de compléter votre requête. Votre demande est déjà envoyé ou la requête manque des données"
self.response.set_status(400)
self.response.headers["Content-Type"] = "application/json;" + " charset=utf-8"
response_json = json.dumps(msg_dict_out, default=serialiser_pour_json)
self.response.out.write(response_json)
except (db.BadValueError, ValueError, KeyError):
logging.error("%s", traceback.format_exc())
self.error(400)
except Exception:
logging.error("%s", traceback.format_exc())
self.error(500)
def delete(self, id):
message = Messages.load(id)
if message:
message.organisation_id = None
message.store()
def add(self, content):
message = Messages(user_id=current_user.id, \
organisation_id=current_user.organisation_id, \
displayname=current_user.displayname, \
content=content)
message.store()
