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 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 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 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"
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)
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 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 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 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 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 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 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 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 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 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 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 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 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 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 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_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 chatting(user_id):
global present_user
print(present_user)
user = User.query.get_or_404(user_id)
form = MessageForm()
if form.validate_on_submit():
print('hi')
msg = Messages(form.message.data, present_user.name, user.name)
db.session.add(msg)
db.session.commit()
db.session.refresh(msg)
# form.submit.data = False
return render_template('chatting.html',
user=user,
users=User.query.all(),
messages=Messages.query.all(),
form=form)
print('data : ' + str(form.submit.data))
return render_template('chatting.html',
user=user,
users=User.query.all(),
messages=Messages.query.all(),
form=form)
def index():
if request.method == 'GET':
return render_template('contact/index.html')
elif request.method == 'POST' and recaptcha.verify():
name = request.form['name']
email = request.form['email']
title = request.form['title']
text = request.form['message']
else:
return render_template('contact/index.html', captcha_error='Recaptcha error!')
if name and email and title and text:
try:
message = Messages(name=name, title=title, email=email, text=text)
db.session.add(message)
db.session.commit()
except:
print('Something wrong! Please, try again.')
return render_template('contact/index.html')
feedback_message = Message('Thank you for your attention!', sender=Configuration.ADMINS[0],
recipients=[email])
feedback_message.body = render_template("contact/feedback_message.txt",
name=name)
customer_message = Message(title, sender=Configuration.ADMINS[0],
recipients=[Configuration.ADMINS[0]])
customer_message.body = render_template("contact/customer_message.txt",
name=name, title=title, email=email, text=text)
with app.app_context():
mail.send(feedback_message)
mail.send(customer_message)
return redirect(url_for('index'))
def messages(partner):
# getting logged in user or redirect
user = get_logged_in_user()
if not user:
flash("You are not logged in.", "info")
return redirect(url_for("index"))
# getting entry for partner form db
try:
partner_id = int(partner)
partner = db.query(User).filter(User.id == partner_id).first()
except ValueError:
flash("Invalid Chatpartner", "info")
return redirect(url_for("all_users"))
# if method post, then take message and create new entry in db
if request.method == "POST":
message = request.form.get("message")
time = datetime.datetime.now()
msg = Messages(message=message,
time=time,
sender=user.id,
receiver=partner.id)
db.add(msg)
db.commit()
# get all messages for logged in user and partner
msgs = db.query(Messages).filter(
and_(Messages.sender.in_([user.id, partner.id]),
Messages.receiver.in_([partner.id, user.id])))
return render_template("messages.html",
messages=msgs,
user=user,
partner=partner)
def update_status():
message = request.json['message']
rating = request.json['rating']
session_id = request.json['session_id']
if rating == 0 or rating == 1 or rating == 2 or rating == 3 or rating == 4 or rating == 5:
rating = rating
else:
rating = 5
if session_id != '':
user_name = Users_v2.query.filter_by(id=session_id).first().username
user_id = Users_v2.query.filter_by(id=session_id).first().id
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=user_name,
poop_date=date_today,
poop_message=message,
poop_rating=rating)
db.session.add(new_poop)
db.session.commit()
send_notifications(message, user_id)
return 'Success'
return 'Falure'
def run():
#Arrange the deletes in the opposite order of the models
Invites.query.delete()
Messages.query.delete()
Chats.query.delete()
# MYSQL database for gitpod
db.session.execute("ALTER TABLE invites AUTO_INCREMENT = 1")
db.session.execute("ALTER TABLE messages AUTO_INCREMENT = 1")
db.session.execute("ALTER TABLE chats AUTO_INCREMENT = 1")
# POSTGRES database for heroku
# db.session.execute("ALTER SEQUENCE messages_id_seq RESTART")
# db.session.execute("ALTER SEQUENCE chats_id_seq RESTART")
db.session.add(Chats())
db.session.add(Chats())
db.session.add(Chats())
db.session.add(Chats())
db.session.add(Chats())
db.session.add(Chats())
now = datetime.utcnow()
##################
# INVITES
##################
db.session.add(Invites(chat_id=1, username="******"))
db.session.add(Invites(chat_id=1, username="******"))
##################
# MESSAGES
##################
db.session.add(
Messages(chat_id=1,
writer_username="******",
message="'Sup",
created_at=now))
db.session.add(
Messages(chat_id=2,
writer_username="******",
message="Konichiwa",
created_at=now))
db.session.add(
Messages(chat_id=3,
writer_username="******",
message="Hey",
created_at=now))
db.session.add(
Messages(chat_id=4,
writer_username="******",
message="Dude",
created_at=now))
db.session.add(
Messages(chat_id=5,
writer_username="******",
message="Yo",
created_at=now))
db.session.add(
Messages(chat_id=6,
writer_username="******",
message="Hi",
created_at=now))
############################################
db.session.add(
Messages(chat_id=1,
writer_username="******",
message="Konichiwa, kolis10",
created_at=now + timedelta(minutes=2)))
db.session.add(
Messages(chat_id=2,
writer_username="******",
message="'Sup, Naz",
created_at=now + timedelta(minutes=2)))
db.session.add(
Messages(chat_id=3,
writer_username="******",
message="Hi, Curly-Fry",
created_at=now + timedelta(minutes=2)))
db.session.add(
Messages(chat_id=4,
writer_username="******",
message="Yo, Coder",
created_at=now + timedelta(minutes=2)))
db.session.add(
Messages(chat_id=5,
writer_username="******",
message="Dude, Rager",
created_at=now + timedelta(minutes=2)))
db.session.add(
Messages(chat_id=6,
writer_username="******",
message="Hey, Tony",
created_at=now + timedelta(minutes=2)))
db.session.commit()
return 'seeds ran successfully'
db.session.add(user1)
db.session.commit()
is_unq = Users.query.filter_by(username='******').all()
if len(is_unq) == 0:
user2 = Users(username='******', password='******')
db.session.add(user2)
db.session.commit()
is_unq = Messages.query.filter_by(sender=1).all()
if len(is_unq) == 0:
# Range limits for the coordinates, it will generate it based on these limits.
lat_limits = (64.5, 66.0)
lon_limits = (24.5, 26.0)
for i in range(5):
msg = Messages(sender=1,
sendername='example0',
message="sender1 test msg " + str(i),
timestamp=datetime.datetime.now(),
latitude=random.uniform(lat_limits[0], lat_limits[1]),
longitude=random.uniform(lon_limits[0], lon_limits[1]))
db.session.add(msg)
db.session.commit()
is_unq = Messages.query.filter_by(sender=2).all()
if len(is_unq) == 0:
# Range limits for the coordinates, it will generate it based on these limits.
lat_limits = (64.5, 66.0)
lon_limits = (24.5, 26.0)
for i in range(5):
msg = Messages(sender=2,
sendername='example1',
message="sender2 test msg " + str(i),
timestamp=datetime.datetime.now(),
latitude=random.uniform(lat_limits[0], lat_limits[1]),
def send(user):
message = request.form["message"]
mes = Messages(session["user"], int(user), message)
db.session.add(mes)
db.session.commit()
return redirect("/message/" + user)
