def test_validate_sender_and_receiver_exist(self):
user1 = app.User("Bob", "*****@*****.**")
db.session.add(user1)
user2 = app.User("Amanda Georgescu", "*****@*****.**")
db.session.add(user2)
db.session.commit()
validation = app.validate_sender_and_receiver(
"*****@*****.**", "*****@*****.**")
self.assertEqual(validation, None)
def setUp(self):
app.app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite://"
app.app.testing = True
self.app = app.app.test_client()
app.db.create_all()
app.db.session.add(app.User(username="******", latitude=10, longitude=20, active=True))
app.db.session.add(app.User(username="******", latitude=20, longitude=10, active=True))
app.db.session.add(app.User(username="******", latitude=100, longitude=100, active=True))
app.db.session.add(app.User(username="******", latitude=10.1, longitude=20.1, active=False))
app.db.session.commit()
def test_get_message_empty(self):
user1 = app.User("Bob", "*****@*****.**")
db.session.add(user1)
user2 = app.User("Amanda Georgescu", "*****@*****.**")
db.session.add(user2)
db.session.commit()
response = self.client.get(
'/messages',
data=
'{"sender":"*****@*****.**","receiver":"*****@*****.**"}',
content_type='application/json')
self.assertEqual(json.loads(response.data), [])
def test_post_message_successful(self):
user1 = app.User("Bob", "*****@*****.**")
db.session.add(user1)
user2 = app.User("Amanda Georgescu", "*****@*****.**")
db.session.add(user2)
db.session.commit()
response = self.client.post(
'/messages',
data=
'{"sender":"*****@*****.**","receiver":"*****@*****.**","text":"Hey Bob"}',
content_type='application/json')
self.assertEqual(json.loads(response.data)["status"], "Success")
self.assertEqual(
json.loads(response.data)["message"]["name"], "Amanda Georgescu")
self.assertEqual(
json.loads(response.data)["message"]["text"], "Hey Bob")
def setUp(self):
app.User.query.delete()
new_user = app.User(first_name='bob', last_name='onion')
app.db.session.add(new_user)
app.db.session.commit()
self.new_user = new_user
def test_post_message_too_long(self):
user1 = app.User("Bob", "*****@*****.**")
db.session.add(user1)
user2 = app.User("Amanda Georgescu", "*****@*****.**")
db.session.add(user2)
db.session.commit()
response = self.client.post(
'/messages',
data=
'{"sender":"*****@*****.**","receiver":"*****@*****.**","text":"Hey Bob848748738497389748937djhfjdkhfjkdshfjkdhfjkhdjkfhjkdhfjkdhfjkhdjkhfjkdhfjkhdsjkfhjkdshfjkdhfjkhdsjhfhghghfdye5ruhfjhdfijdhsfksdjkfhdsjkfhjkdshfjkhdsjfkhsdkjhfjksdhfjkhdskjfhjksdhfjkhdsjkfhdsjkhfjksdhfjkhsdkjfhsdjkhfjkdshjkfhkjdshfjdshfjkhdsjkfhjkdshfjkhdsjkfhkjdshfjkdshfjkhdsjkhfkdshfjkdshfjkhdkjdhsfjkhdsjkfhjksdhfjdhsfjkhdsjkfhdskjhjkdshfjkhdskjfhjkdshfjkhsdjkfh"}',
content_type='application/json')
self.assertEqual(
json.loads(response.data).items(), {
"status": "Error",
"message": "Message is too long to send!"
}.items())
def test_query_all_users_not_empty(self):
user1 = app.User("Bob", "*****@*****.**")
db.session.add(user1)
user2 = app.User("Amanda Georgescu", "*****@*****.**")
db.session.add(user2)
db.session.commit()
response = self.client.get('/users')
self.assertEqual(
json.loads(response.data).items(), {
"status":
"Success",
"Users": [{
"name": "Bob",
"email": "*****@*****.**"
}, {
"name": "Amanda Georgescu",
"email": "*****@*****.**"
}]
}.items())
def client():
db_fd, app.app.config['DATABASE_PATH'] = tempfile.mkstemp()
app.app.config['TESTING'] = True
client = app.app.test_client()
with app.app.app_context():
print(app.app.config['DATABASE_PATH'])
app.init_db(app.get_db(app.app.config['DATABASE_PATH']))
# Add some more users
f = open('users/views/test/test_data_create.sql', 'r')
sql = f.read()
f.close()
cur = app.g.db.cursor()
cur.executescript(sql)
# doris and John need passwords
rec = app.User(app.g.db).get('doris')
rec.password = getPasswordHash('password')
app.User(app.g.db).save(rec)
rec = app.User(app.g.db).get('John')
rec.password = getPasswordHash('password')
app.User(app.g.db).save(rec)
app.g.db.commit()
rec = app.User(app.g.db).get('doris')
print(rec)
rec = app.User(app.g.db).get('John')
print(rec)
yield client
os.close(db_fd)
os.unlink(app.app.config['DATABASE_PATH'])
def test_validate_receiver_not_exists(self):
user = app.User("Bob", "*****@*****.**")
db.session.add(user)
db.session.commit()
validation = app.validate_sender_and_receiver(
"*****@*****.**", "*****@*****.**")
self.assertEqual(
json.loads(validation).items(), {
"status":
"Error",
"message":
"*****@*****.**" + " is not registered to chat!"
}.items())
def test_add_user_already_exists(self):
user = app.User("Bob", "*****@*****.**")
db.session.add(user)
db.session.commit()
response = self.client.post(
'/users',
data='{"name":"Bob","email":"*****@*****.**"}',
content_type='application/json')
self.assertEqual(
json.loads(response.data).items(), {
"status": "Error",
"message": "User with this email address already exists!"
}.items())
def access(nome, password):
engine = db.create_engine('sqlite:///easyFindDB.db')
connection = engine.connect()
metadata = db.MetaData()
emp = db.Table('venditore', metadata, autoload=True, autoload_with=engine)
query = db.select([emp.columns.nome, emp.columns.password
]).where(db.and_(emp.columns.nome == nome.upper()))
ResultProxy = connection.execute(query)
ResultSet = ResultProxy.fetchall()
if (len(ResultSet) == 1):
if app.hashing.check_value(ResultSet[0][1], password, salt='geo'):
app.login_user(app.User(nome))
return redirect('/Home_page')
return render_template('index.html', error={'value': 'error_login'})
def setUpClass(self):
user = app.User(first_name="Jus", last_name="Onion")
app.db.session.add(user)
app.db.session.commit()
post = app.Post(title="new stuff",
content="new stuff",
user_id=user.id)
app.db.session.add(post)
app.db.session.commit()
self.user_id = user.id
self.post_id = post.id
self.post_title = post.title
def test_get_message_successful_then_empty(self):
user1 = app.User("Bob", "*****@*****.**")
db.session.add(user1)
user2 = app.User("Amanda Georgescu", "*****@*****.**")
db.session.add(user2)
message = app.Message("*****@*****.**", "*****@*****.**",
"Hey Bob")
db.session.add(message)
db.session.commit()
response = self.client.get(
'/messages',
data=
'{"sender":"*****@*****.**","receiver":"*****@*****.**"}',
content_type='application/json')
self.assertEqual(
json.loads(response.data)[0]["name"], "Amanda Georgescu")
self.assertEqual(json.loads(response.data)[0]["text"], "Hey Bob")
response = self.client.get(
'/messages',
data=
'{"sender":"*****@*****.**","receiver":"*****@*****.**"}',
content_type='application/json')
self.assertEqual(json.loads(response.data), [])
def test_get_message_correct_order(self):
user1 = app.User("Bob", "*****@*****.**")
db.session.add(user1)
user2 = app.User("Amanda Georgescu", "*****@*****.**")
db.session.add(user2)
db.session.commit()
self.client.post(
'/messages',
data=
'{"sender":"*****@*****.**","receiver":"*****@*****.**","text":"Hey Bob"}',
content_type='application/json')
self.client.post(
'/messages',
data=
'{"sender":"*****@*****.**","receiver":"*****@*****.**","text":"How are you?"}',
content_type='application/json')
response = self.client.get(
'/messages',
data=
'{"sender":"*****@*****.**","receiver":"*****@*****.**"}',
content_type='application/json')
self.assertEqual(json.loads(response.data)[0]["text"], "Hey Bob")
self.assertEqual(json.loads(response.data)[1]["text"], "How are you?")
async def on_message(message):
async def send(data):
"""Send text or files the correct way"""
try:
await client.send_file(message.channel, data)
except:
# split the data to multiple messages if it's too long
if data.startswith('```'):
data, md = data.replace('```', ''), '```'
else:
md = ''
m = data.splitlines()
for i in range(0, len(m), 30):
await client.send_message(message.channel,
md + '\n'.join(m[i:i + 30]) + md)
author, authorid = str(message.author).split('#')
# if the author of the message is the bot itself do nothing
if author == client.user.name:
return
# add the author to the database if they're not already there
users = app.User.query.all()
if int(authorid) not in [user.usernum for user in users]:
app.db.session.add(app.User(author, authorid))
app.db.session.commit()
print('Added {} to the database'.format(author))
# run a command if one is issued in the message
if message.content.startswith(config.COMMAND_SYMBOL):
print('{} issued command {}'.format(author, message.content))
command, _, args = message.content[1:].partition(' ')
# find the function and minimum permission level for the command
command_func, min_permissionlevel = COMMANDS.get(
command,
# if the command is not found in COMMANDS
(lambda _: '', 0))
# fetch the author's permission level from the database
author_permissionlevel = app.User.query.filter(app.User.usernum == authorid)\
.first().permissions
# check if the author has enough permissions to use the command
if author_permissionlevel >= min_permissionlevel:
await send(command_func(args))
else:
await send('You do not have enough permissions to use ' + command)
def call(cls):
name = request.form.get('name')
hashed_password = bcrypt.hashpw(
request.form.get('password').encode(), bcrypt.gensalt())
client_id = request.form.get('client_id')
client_secret = request.form.get('client_secret')
try:
app.db.session.add(
app.User(name=name,
hashed_password=hashed_password,
client_id=client_id,
client_secret=client_secret))
app.db.session.commit()
except (IntegrityError, InvalidRequestError) as e:
print(e)
app.db.session.rollback()
return render_template('signup.html', message='サインアップできませんでした')
user = app.User.query.filter_by(name=name).first()
login_user(user)
return redirect(url_for('fitbit_registration'))
def insert(nome, password, citta, indirizzo, lat, long):
engine = db.create_engine('sqlite:///easyFindDB.db')
connection = engine.connect()
metadata = db.MetaData()
emp = db.Table('venditore', metadata, autoload=True, autoload_with=engine)
query = db.select([emp.columns.nome
]).where(emp.columns.nome == nome.upper())
ResultProxy = connection.execute(query)
ResultSet = ResultProxy.fetchall()
if (len(ResultSet) > 0):
return render_template('index.html', error={'value': 'error_register'})
val_hash = app.hashing.hash_value(password, salt='geo')
query2 = db.insert(emp).values(nome=nome.upper(),
password=val_hash,
citta=citta.upper(),
indirizzo=indirizzo.upper(),
lat=lat,
long=long)
connection.execute(query2)
app.login_user(app.User(nome))
return redirect('/Home_page')
import pymysql
import app
# 1、创建连接
db = pymysql.connect(host="localhost",
port=3306,
db="nddb",
user="******",
password="******",
charset="utf8")
# 2.创建游标对象
cursor = db.cursor()
user = app.User()
# 3.创建sql语句
# sql ="insert into myuser value('xiaoming','123')"
# rows = cls.execute(sql)
sql = "insert into Users(USER_NAME, USER_PWD) value(null,%s,%s)"
try:
cursor.execute(sql, [user.name, user.pwd])
db.commit()
optSuccess = 1
except:
db.rollback()
optSuccess = 0
# 5.关闭
db.close()
#!/usr/bin/python3
import datetime
import app
if __name__ == "__main__":
print("Creating database.")
app.db.create_all()
# Create an admin user.
app.db.session.add(
app.User(
id=1,
name="root",
password_hash="???",
creation_time=datetime.datetime.now(),
))
app.db.session.commit()
print("Users:", app.User.query.all())
def test_validate_user_exists(self):
user = app.User("Amanda Georgescu", "*****@*****.**")
db.session.add(user)
db.session.commit()
exists = app.validate_user_exists("*****@*****.**")
self.assertEqual(exists, True)
import app
if __name__ == "__main__":
conn = sqlite3.connect('database.db')
print("BD otwarta")
conn.execute('CREATE TABLE uzytkownik (id INTEGER PRIMARY KEY, imie TEXT, nazwisko TEXT, login TEXT, haslo TEXT)')
conn.execute('CREATE TABLE post (operacja TEXT, sposob_wykonania TEXT, autor TEXT)')
cur = conn.cursor()
cur.execute("INSERT INTO uzytkownik (imie, nazwisko, login, haslo) VALUES (?,?,?,?)",('Adrian','Stolarz','adi','peugeot123') )
conn.commit()
cur.execute("SELECT id FROM uzytkownik WHERE login='******'")
row = cur.fetchall()
for r in row:
app.User(r[0])
cur.execute("INSERT INTO post (operacja, sposob_wykonania, autor) VALUES (?,?,?)",('Wymiana oleju','Mechanicy i specjaliści radzą, aby w autach, które są przede wszystkim eksploatowane w mieście, wymieniać olej częściej, co 10 – 12 tys. km przebiegu. Zaleca się, aby w samochodach z instalacją gazową wymieniać olej co 10 tys. km przebiegu.','Adrian Stolarz') )
conn.commit()
cur.execute('SELECT * FROM uzytkownik ORDER BY imie')
print(cur.fetchall())
cur.execute('SELECT * FROM post')
print(cur.fetchall())
conn.close()
print("BD zamknieta")
import app u = app.User(username='******', email='*****@*****.**') # app.db.session.add(u) # app.db.session.commit() # print(u) users = app.User.query.all() print(users)
import pymysql
def connect_db():
return pymysql.connect(host=os.environ['MYSQL_HOST_NAME'],
port=int(os.environ['MYSQL_PORT']),
user=os.environ['MYSQL_USER_NAME'],
password=os.environ['MYSQL_USER_PASSWORD'],
charset='utf8mb4')
con = connect_db()
cur = con.cursor()
sql = f"""CREATE DATABASE IF NOT EXISTS {os.environ['MYSQL_DB']} default charset = utf8mb4"""
cur.execute(sql)
cur.close()
con.close()
admin = os.environ['ADMIN']
password = os.environ['ADMIN_PASSWORD']
flask_app = app.app
app.db.create_all()
if app.User.query.filter_by(APP_ID=admin).first() is None:
user = app.User(APP_ID=admin)
user.hash_password(password)
app.db.session.add(user)
app.db.session.commit()
# flask_app.debug = True
# flask_app.run(port=6666, threaded=True)
def setUp(self):
self.user = app.User('username', '*****@*****.**', '5554443322',
'User Name', '1234')
import app
import os
app.db.create_all()
lh = app.User("system")
app.db.session.add(lh)
ip = app.Address("127.0.0.1", lh)
app.db.session.add(ip)
app.db.session.commit()
for f in os.listdir('webms/all'):
video = app.Video(f, f.replace(".webm", ""))
app.db.session.add(video)
app.db.session.commit()
for v in app.Video.query:
app.db.session.add(app.Action(ip, v, "upload"))
app.db.session.commit()
