262 lines
8.4 KiB
Python
262 lines
8.4 KiB
Python
#!/bin/python
|
|
import sqlite3
|
|
import secrets
|
|
import time
|
|
import flask_socketio
|
|
from flask import Flask, request
|
|
# base socket
|
|
|
|
app = Flask(__name__)
|
|
socketio = flask_socketio.SocketIO(app)
|
|
|
|
###############################################################################
|
|
|
|
|
|
def first_run():
|
|
"""
|
|
create databases
|
|
"""
|
|
con = sqlite3.connect("database.db")
|
|
cur = con.cursor()
|
|
cur.execute("CREATE TABLE USERS(\
|
|
username,\
|
|
password,\
|
|
token)")
|
|
|
|
cur.execute("CREATE TABLE NOTIFICATION(\
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,\
|
|
date,\
|
|
machine,\
|
|
token,\
|
|
title,\
|
|
content)")
|
|
|
|
cur.execute("CREATE TABLE CLIPBOARD(\
|
|
id INTEGER PRIMARY KEY AUTOINCREMENT,\
|
|
date,\
|
|
machine,\
|
|
token,\
|
|
content)")
|
|
|
|
con.commit()
|
|
con.close()
|
|
|
|
###############################################################################
|
|
|
|
|
|
@app.route("/user", methods=['POST'])
|
|
def auth():
|
|
"""
|
|
Authentifie un user, simple, basique
|
|
"username"
|
|
"password"
|
|
"""
|
|
user = (request.values.get("username"), request.values.get("password"))
|
|
con = sqlite3.connect("database.db")
|
|
cur = con.cursor()
|
|
db_user = cur.execute("SELECT token FROM USERS WHERE USERNAME=? AND \
|
|
PASSWORD=?", user).fetchone()
|
|
con.close()
|
|
if db_user is None:
|
|
return {"status": "This user does not exist or the password is \
|
|
incorrect"}, 404
|
|
else:
|
|
return {"status": "ok", "token": db_user[0]}
|
|
|
|
|
|
@app.route("/user", methods=['PUT'])
|
|
def register():
|
|
"""
|
|
Authentifie un user, simple, basique
|
|
"username"
|
|
"password"
|
|
"""
|
|
con = sqlite3.connect("database.db")
|
|
cur = con.cursor()
|
|
username = request.values.get("username")
|
|
user = (username,)
|
|
if cur.execute("SELECT username FROM USERS WHERE username=?", user)\
|
|
.fetchone() is not None:
|
|
con.close()
|
|
return {"status": "Error, username already taken"}, 500
|
|
user = (request.values.get("username"), request.values.get("password"),
|
|
secrets.token_urlsafe(64))
|
|
try:
|
|
cur.execute("INSERT INTO USERS VALUES (?,?,?)", user)
|
|
con.commit()
|
|
con.close()
|
|
return {"status": "ok"}
|
|
except:
|
|
con.close()
|
|
return {"status": "Error, most likely username already taken"}, 500
|
|
|
|
###############################################################################
|
|
|
|
|
|
@app.route("/notification", methods=['PUT'])
|
|
def add_notification():
|
|
"""
|
|
Le but de cet app se resume a cette fonction, elle recoit une requete
|
|
http et renvoie via le websocket le contenu de la requette a tout les
|
|
client.
|
|
"""
|
|
token = request.values.get("token")
|
|
title = request.values.get('title')
|
|
content = request.values.get('content')
|
|
device_name = request.values.get('deviceName')
|
|
date = time.time()
|
|
con = sqlite3.connect("database.db")
|
|
cur = con.cursor()
|
|
if cur.execute("SELECT username FROM USERS WHERE token=?", (token,))\
|
|
.fetchone() is None:
|
|
return {"status": "Error, no user"}, 500
|
|
try:
|
|
notification = (date, device_name, token, title, content)
|
|
cur.execute("INSERT INTO notification VALUES (null,?,?,?,?,?)",
|
|
notification)
|
|
con.commit()
|
|
con.close()
|
|
socketio.emit("NotificationUpdate",
|
|
data={"device_name": device_name},
|
|
broadcast=True)
|
|
|
|
return {"status": "ok"}, 200
|
|
except:
|
|
return {"status": "error"}, 500
|
|
|
|
|
|
@app.route("/notification", methods=['GET'])
|
|
def get_notifications():
|
|
"""
|
|
Le but de cet app se resume a cette fonction, elle recoit une requete
|
|
http et renvoie via le websocket le contenu de la requette a tout les
|
|
client.
|
|
"""
|
|
token = request.values.get("token")
|
|
con = sqlite3.connect("database.db")
|
|
cur = con.cursor()
|
|
notifications = cur.execute("SELECT title,content \
|
|
FROM NOTIFICATION \
|
|
WHERE token=?",
|
|
(token, )).fetchall()
|
|
data = {"status": "ok"}
|
|
data["notifications"] = []
|
|
for notification in notifications:
|
|
data["notifications"].append({"title": notification[0],"content": notification[1]})
|
|
return data, 200
|
|
|
|
|
|
@app.route("/notification/<notifid>", methods=['GET'])
|
|
def get_notification_by_id(notifid):
|
|
"""
|
|
Le but de cet app se resume a cette fonction, elle recoit une requete
|
|
http et renvoie via le websocket le contenu de la requette a tout les
|
|
client.
|
|
"""
|
|
notifid = int(notifid)
|
|
token = request.values.get("token")
|
|
con = sqlite3.connect("database.db")
|
|
cur = con.cursor()
|
|
if notifid == -1:
|
|
notifications = cur.execute("SELECT title,content \
|
|
FROM NOTIFICATION \
|
|
WHERE token=?\
|
|
ORDER BY id DESC \
|
|
LIMIT 1",
|
|
(token,)).fetchone()
|
|
else:
|
|
notifications = cur.execute("SELECT title,content \
|
|
FROM NOTIFICATION \
|
|
WHERE token=? AND id=?",
|
|
(token, notifid)).fetchone()
|
|
|
|
return {"status": "ok",
|
|
"notifications": {"title": notifications[0],
|
|
"content": notifications[1]
|
|
}
|
|
}, 200
|
|
|
|
###############################################################################
|
|
|
|
|
|
@app.route("/clipboard", methods=['PUT'])
|
|
def add_clipboard():
|
|
"""
|
|
Le but de cet app se resume a cette fonction, elle recoit une requete http
|
|
et renvoie via le websocket le contenu de la requette a tout les clients.
|
|
"""
|
|
token = request.values.get("token")
|
|
content = request.values.get('content')
|
|
device_name = request.values.get('deviceName')
|
|
date = time.time()
|
|
con = sqlite3.connect("database.db")
|
|
cur = con.cursor()
|
|
if cur.execute("SELECT username FROM USERS WHERE token=?", (token,))\
|
|
.fetchone() is None:
|
|
return {"status": "Error, no user"}, 500
|
|
try:
|
|
clipboard = (date, device_name, token, content)
|
|
cur.execute("INSERT INTO CLIPBOARD VALUES (null,?,?,?,?)", clipboard)
|
|
con.commit()
|
|
con.close()
|
|
socketio.emit("ClipboardUpdate",
|
|
data={"device_name": device_name},
|
|
broadcast=True)
|
|
return {"status": "ok"}, 200
|
|
except:
|
|
return {"status": "error"}, 500
|
|
|
|
|
|
@app.route("/clipboard", methods=['GET'])
|
|
def get_clipboard():
|
|
"""
|
|
Le but de cet app se resume a cette fonction, elle recoit une requete
|
|
http et renvoie via le websocket le contenu de la requette a tout les
|
|
client.
|
|
"""
|
|
token = request.values.get("token")
|
|
con = sqlite3.connect("database.db")
|
|
cur = con.cursor()
|
|
clipboard = cur.execute("SELECT content \
|
|
FROM CLIPBOARD \
|
|
WHERE token=?",
|
|
(token, )).fetchall()
|
|
|
|
return {"status": "ok", "clipboard": clipboard}, 200
|
|
|
|
|
|
@app.route("/clipboard/<clipid>", methods=['GET'])
|
|
def get_clipboard_by_id(clipid):
|
|
"""
|
|
Le but de cet app se resume a cette fonction, elle recoit une requete
|
|
http et renvoie via le websocket le contenu de la requette a tout les
|
|
client.
|
|
"""
|
|
clipid = int(clipid)
|
|
token = request.values.get("token")
|
|
con = sqlite3.connect("database.db")
|
|
cur = con.cursor()
|
|
if clipid == -1:
|
|
clipboard = cur.execute("SELECT content \
|
|
FROM CLIPBOARD \
|
|
WHERE token=? \
|
|
ORDER BY id DESC \
|
|
LIMIT 1",
|
|
(token,)).fetchone()
|
|
else:
|
|
clipboard = cur.execute("SELECT content \
|
|
FROM CLIPBOARD \
|
|
token=? AND id=?",
|
|
(token, clipid)).fetchone()
|
|
|
|
return {"status": "ok", "clipboard": clipboard[0]}, 200
|
|
|
|
|
|
if __name__ == '__main__':
|
|
try:
|
|
f=open("database.db","r")
|
|
f.close()
|
|
except :
|
|
first_run()
|
|
socketio.run(app, host="0.0.0.0", port=9564)
|