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