def view(team_id):
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM `lesson-team` WHERE team_id = %s ",
team_id)
myLessonPlan = dict_cursor.fetchall()
if myLessonPlan:
print(type(myLessonPlan))
dict_cursor.close()
c.close()
db.close()
return jsonify({
"values": myLessonPlan,
"success": True,
"errorMessage": "",
"message": None
})
dict_cursor.close()
c.close()
db.close()
return jsonify({
"values": "",
"success": False,
"errorMessage": "Invalid team",
"message": None
})
def viewListLessonOfCoach(username):
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM user WHERE username = %s", username)
myCoach = dict_cursor.fetchone()
dict_cursor.execute("SELECT id,name FROM team WHERE coach_id = %s",
myCoach['id'])
myListTeam = dict_cursor.fetchall()
result = []
columns = ['lesson_id', 'team_name', 'lesson_name', 'date', 'check_record']
for myTeam in myListTeam:
dict_cursor.execute(
"SELECT L.id,L.name, DATE(LT.date) as date, LT.check_record FROM `lesson` L, `lesson-team` LT WHERE L.id = LT.lesson_id AND LT.team_id = %s ",
myTeam['id'])
myLesson = dict_cursor.fetchall()
for lesson in myLesson:
listRow = [
lesson['id'], myTeam['name'], lesson['name'],
lesson['date'].strftime("%Y-%m-%d"), lesson['check_record']
]
info = dict(zip(columns, listRow))
result.append(info)
dict_cursor.close()
c.close()
db.close()
return jsonify({
"values": result,
"success": True,
"errorMessage": "",
"message": None
})
def delete_swimmer(username, swimmer_username):
"""just delete a swimmer by his/her username"""
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
try:
c.execute('DELETE FROM user WHERE username = %s', swimmer_username)
db.commit()
except:
db.rollback()
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Something went wrong.",
"message": None,
"created_date": str(datetime.datetime.now())
})
return jsonify({
"values":
swimmer_username + " has been deleted by " + username + ".",
"success":
True,
"errorMessage":
None,
"message":
"Accepted.",
"created_date":
str(datetime.datetime.now())
})
def view(username):
"""return list json with keys(id, coach_id, name, age)"""
db, c = connector.connection()
c.execute("SELECT id FROM user WHERE username = %s", username)
myData = c.fetchall()
if myData:
c.execute("SELECT * FROM team WHERE coach_id = %s ", myData[0][0])
myData2 = c.fetchall()
columns = ['team_id', 'coach_id', 'name', 'age']
info = [dict(zip(columns, row)) for row in myData2]
return jsonify({
"values": {
"team": info
},
"success": True,
"errorMessage": "",
"message": None,
})
else:
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Invalid user",
"message": None,
})
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Empty",
"message": None,
})
def change_password(username, js_data):
""" username is GET method
js_data are password, new_password"""
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute('SELECT password FROM user WHERE username = %s',
username)
my_password = dict_cursor.fetchone()
hashed_pw = bcrypt.hashpw(js_data['password'].encode(),
my_password['password'].encode())
if my_password['password'].encode() == hashed_pw:
try:
c.execute('UPDATE user SET password = %s WHERE username = %s',
(bcrypt.hashpw(js_data['new_password'].encode(),
bcrypt.gensalt()), username))
db.commit()
return jsonify({
"values": "Password of " + username + " has been changed.",
"success": True,
"errorMessage": None,
"message": "Accepted.",
"created_date": str(datetime.datetime.now())
})
except:
db.rollback()
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Something went wrong.",
"message": None,
"created_date": str(datetime.datetime.now())
})
def forgot_password(js_data):
''' json must have username, new_password'''
db, c = connector.connection()
# hash new password
hashed_pw = bcrypt.hashpw(js_data['new_password'].encode(),
bcrypt.gensalt())
try:
c.execute('UPDATE user SET password = %s WHERE username = %s',
(hashed_pw, js_data['username']))
db.commit()
return jsonify({
"values":
"Update password for user " + js_data['username'],
"success":
True,
"errorMessage":
None,
"message":
"Accepted.",
"created_date":
str(datetime.datetime.now())
})
except:
db.rollback()
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Something went wrong.",
"message": None,
"created_date": str(datetime.datetime.now())
})
def swimmer_creation(number_of_swimmer):
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
list_swimmer_account = []
i = 0
while i < int(number_of_swimmer):
rand_num = str(random.randint(1, 9999)).zfill(4) # format 55 to 0055
this_year = str(datetime.datetime.now().year) # get this year
randuser = '******' + this_year + '_' + rand_num # format st<this year>_<random number>
my_dict = {"username": randuser, "password": "******"}
dict_cursor.execute('SELECT username FROM user WHERE username = %s',
randuser)
my_username = dict_cursor.fetchone()
if not my_username:
list_swimmer_account.append(my_dict)
i += 1
return jsonify({
"values": {
"swimmers": list_swimmer_account
},
"success": True,
"errorMessage": None,
"message": "Accepted.",
"created_date": str(datetime.datetime.now())
})
def delete(username, team_id):
try:
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
c.execute("SELECT id FROM user WHERE username = %s", username)
myData = c.fetchall()
if myData:
dict_cursor.execute("SELECT * FROM `team` WHERE id = %s", team_id)
myTeam = dict_cursor.fetchone()
c.execute("DELETE FROM team WHERE id = %s", team_id)
db.commit()
db.close()
return jsonify({
"values": "Team " + myTeam['name'] + " deleted. ",
"success": True,
"errorMessage": "",
"message": None,
})
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Invalid user",
"message": None,
})
except:
jsonify({
"values": "Error",
"success": False,
"errorMessage": "",
"message": None,
})
def get():
db, c = connector.connection()
"""get all databases from table age and convert to json"""
c.execute("SELECT * FROM age")
mydata = c.fetchall()
columns = ['id','range_age']
#columns = [column[0] for column in c.description] #get keys in db
info =[dict(zip(columns, row)) for row in mydata] #create zip with key & value => convert dict
db.close()
c.close()
return jsonify(info) #return json with keys(id,age_range)
def view(data):
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM lesson WHERE name = %s",
data['lesson_name'])
myLesson = dict_cursor.fetchone()
dict_cursor.execute(
"SELECT E.id as exercise_id,type_name,swim_name,swim_distance,repetition,description FROM exercise E,exercise_type ET, distance D,style S WHERE lesson_id = %s AND ET.id=E.type_id AND D.id = E.distance_id AND S.id = E.style_id",
myLesson['id'])
myExercise = dict_cursor.fetchall()
return jsonify({"lesson_id": myLesson['id'], "exercise": myExercise})
def getType():
db, c = connector.connection()
"""get all databases from table exercise_type and convert to json"""
c.execute("SELECT * FROM exercise_type")
myTyle = c.fetchall()
columns = ['id', 'type_name']
# columns = [column[0] for column in c.description] #get keys in db
info = [dict(zip(columns, row))
for row in myTyle] # create zip with key & value => convert dict
db.close()
c.close()
return jsonify(info)
def login(js_data):
db = connector.connection()
dict_cursor = connector.getDictCursor()
try:
dict_cursor.execute('SELECT * FROM user WHERE username = %s',
js_data['username'])
except:
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Invalid user.",
"message": None,
"created_date": str(datetime.datetime.now())
})
db_data = dict_cursor.fetchone()
if db_data:
# The next 3 lines check hashed password is valid for login
hashed_pw = bcrypt.hashpw(js_data['password'].encode(),
db_data['password'].encode())
if db_data['password'].encode() == hashed_pw:
# The next 4 lines is set up expires time
expires = datetime.timedelta(
seconds=constant.ACCESS_TOKEN_EXPIRES_TIME)
# the identity is username
access_token = create_access_token(identity=js_data['username'],
expires_delta=expires)
return jsonify({
"values": {
"token": access_token,
"expiresIn": constant.ACCESS_TOKEN_EXPIRES_TIME,
"username": js_data['username']
},
"success": True,
"errorMessage": None,
"message": "Accepted.",
"created_date": str(datetime.datetime.now())
})
else:
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Authentication failed. Wrong password.",
"message": None,
"created_date": str(datetime.datetime.now())
})
else:
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "User not found.",
"message": None,
"created_date": str(datetime.datetime.now())
})
def register(js_data):
"""recive a new coach account json and return a status"""
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute('SELECT username FROM user WHERE username = %s',
js_data['username'])
db_data = dict_cursor.fetchone()
if not db_data: # create mew account
hashed_pw = bcrypt.hashpw(js_data['password'].encode(),
bcrypt.gensalt()) # hash password by bcrypt
try:
c.execute(
'''INSERT INTO
user (username, password, first_name, last_name, dob, gender,
address, phone, email, role_id, is_verified, created_at)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)''',
(js_data['username'], hashed_pw, js_data['first_name'],
js_data['last_name'], js_data['dob'], js_data['gender'],
js_data['address'], js_data['phone'], js_data['email'], 1, 0,
str(datetime.datetime.now())))
db.commit()
except:
db.rollback()
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Username already exists",
"message": None,
"created_date": str(datetime.datetime.now())
})
dict_cursor.execute('SELECT id, password FROM user WHERE username = %s',
js_data['username'])
db_data2 = dict_cursor.fetchone() # db_data2 is id and password for user
return jsonify({
"values": {
"user": {
#"id": db_data2['id'],
"username": js_data['username'],
"email": js_data['email'],
"password": db_data2['password'],
"first_name": js_data['first_name'],
"last_name": js_data['last_name'],
"dob": js_data['dob'],
"role_id": 1
}
},
"success": True,
"errorMessage": None,
"message": "User Created",
"created_date": str(datetime.datetime.now())
})
def addSwimmerExit(user_id, data):
try:
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM `team` WHERE name =%s", "No Team")
myNoTeam = dict_cursor.fetchone()
dict_cursor.execute(
"SELECT * FROM `team-swimmer` WHERE user_id = %s AND team_id = %s",
(user_id, myNoTeam['id']))
if dict_cursor.fetchone():
dict_cursor.execute("SELECT * FROM `team` WHERE id = %s",
data['team_id'])
myTeam = dict_cursor.fetchone()
if myTeam:
c.execute(
"UPDATE `team-swimmer` SET team_id = %s WHERE user_id = %s",
(myTeam['id'], user_id))
db.commit()
db.close()
c.close()
dict_cursor.close()
dict_cursor2 = connector.getDictCursor()
dict_cursor2.execute(
"SELECT * FROM `team-swimmer` WHERE team_id = %s",
myTeam['id'])
myTeamAdded = dict_cursor2.fetchall()
return jsonify({
"values": myTeamAdded,
"success": True,
"errorMessage": "",
"message": None
})
return jsonify({
"values": "",
"success": False,
"errorMessage": "Invalid team",
"message": None
})
return jsonify({
"values": "",
"success": False,
"errorMessage": "Invalid user_id in No Team",
"message": None
})
except:
jsonify({
"values": "Error",
"success": False,
"errorMessage": "",
"message": None,
})
def edit(username, team_id, data):
'''recieve json with keys(name, age) return json with key(result)'''
try:
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT id FROM user WHERE username = %s",
username)
myCoach = dict_cursor.fetchone()
if myCoach:
object_data = JSONObject.json2obj(json.dumps(data))
dict_cursor.execute("SELECT * FROM `team` WHERE id = %s", team_id)
myTeam = dict_cursor.fetchone()
c.execute(
"SELECT name FROM team WHERE coach_id = %s AND name = %s",
(myCoach['id'], myTeam['name']))
if c.fetchall():
c.execute(
"UPDATE team SET name = %s, age =%s WHERE coach_id = %s AND name = %s",
(object_data.team.name, object_data.team.age,
myCoach['id'], myTeam['name']))
db.commit()
return jsonify({
"values":
"" + myTeam['name'] + " => " + object_data.team.name +
", " + myTeam['age'] + " => " + object_data.team.age,
"success":
True,
"errorMessage":
"",
"message":
None,
})
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Team doesn't exist.",
"message": None,
})
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Invalid user",
"message": None,
})
except:
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "",
"message": None
})
def delSwimmer(team_id, user_id):
try:
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM team WHERE id = %s", team_id)
myTeam = dict_cursor.fetchone()
if myTeam:
dict_cursor.execute(
"SELECT * FROM `user` WHERE id = %s AND role_id = %s",
(user_id, 2))
mySwimmer = dict_cursor.fetchone()
if mySwimmer:
dict_cursor.execute("SELECT id FROM team where name = %s",
"No team")
myNoTeam = dict_cursor.fetchone()
c.execute(
"UPDATE `team-swimmer` SET team_id = %s WHERE user_id= %s",
(myNoTeam['id'], user_id))
db.commit()
return jsonify({
"values":
mySwimmer['username'] + " in team " + myTeam['name'] +
" deleted.",
"success":
True,
"errorMessage":
"",
"message":
None,
})
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Invalid user_id",
"message": None,
})
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Invalid team",
"message": None,
})
except:
jsonify({
"values": "Error",
"success": False,
"errorMessage": "",
"message": None,
})
def add(username, data):
"""recieve json with key(name,age)
return json key (result)"""
try:
db, c = connector.connection()
dict_cursosr = connector.getDictCursor()
c.execute("SELECT id FROM user WHERE username = %s", username)
myData = c.fetchall()
if myData:
object_data = JSONObject.json2obj(json.dumps(data))
c.execute(
"SELECT name FROM team WHERE coach_id = %s AND name = %s",
(myData[0][0], object_data.team.name))
if not c.fetchall():
sql = "INSERT INTO team (coach_id,name,age) VALUES (%s, %s, %s)"
value = (myData[0][0], object_data.team.name,
object_data.team.age)
c.execute(sql, value)
db.commit()
dict_cursosr.execute("select id from team where name = %s",
object_data.team.name)
my_id = dict_cursosr.fetchone()
return jsonify({
"values":
"Team :" + object_data.team.name + " has created",
"success": True,
"team_id": my_id['id'],
"errorMessage": "",
"message": None
})
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Team name exist",
"message": None,
})
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Invalid user",
"message": None,
})
except:
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "",
"message": None,
})
def send_email_to_change_password(email):
''' data is email'''
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
try:
dict_cursor.execute(
'SELECT username, password, last_name FROM user WHERE email = %s',
email)
except:
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Something went wrong.",
"message": None,
"created_date": str(datetime.datetime.now())
})
data = dict_cursor.fetchone()
# reset password token generate
if data:
expires = datetime.timedelta(
seconds=constant.RESET_PASSWORD_TOKEN_EXPIRES_TIME)
# a random string with 6 digits
identity = ''.join(
random.choice(string.ascii_lowercase) for i in range(6))
reset_password_token = create_access_token(identity=identity,
expires_delta=expires)
# calling send email function
sendText(email, data['last_name'], reset_password_token)
return jsonify({
"values": {
"token": reset_password_token,
"expiresIn": constant.RESET_PASSWORD_TOKEN_EXPIRES_TIME,
"username": data['username'],
"identity": identity
},
"success": True,
"errorMessage": None,
"message": "Reset PIN was sent to " + email + ".",
"created_date": str(datetime.datetime.now())
})
else:
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "There is no email like this.",
"message": None,
"created_date": str(datetime.datetime.now())
})
def addSwimmer(team_name, data):
"""Add swimmer account generated into DB"""
try:
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
f = open("swimmer.txt", "r")
dict_cursor.execute("SELECT * FROM team WHERE name = %s", team_name)
myTeam = dict_cursor.fetchone()
if myTeam:
'''decode file swimmer.txt'''
temp = f.readline()
a = temp.encode("UTF-8")
decoded = base64.b64decode(a)
temp2 = str(decoded, encoding="UTF-8")
'''get id swimmer account and add to table `team-swimmer`'''
s = temp2.split("----------------------------------------\n")
i = 1
while (s[i] != ""):
result = s[i].split()
user = result[2]
dict_cursor.execute("SELECT * FROM user WHERE username = %s",
user)
mySwimmer = dict_cursor.fetchone()
if (mySwimmer):
c.execute(
"SELECT user_id FROM `team-swimmer` WHERE user_id = %s",
mySwimmer['id'])
if not c.fetchall():
c.execute(
"INSERT INTO `team-swimmer`(user_id,team_id) VALUES(%s,%s)",
(mySwimmer['id'], myTeam['id']))
db.commit()
i += 1
return send_email.sendAttachment(data, 'swimmer3.txt')
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Invalid team",
"message": None,
})
except:
jsonify({
"values": "Error",
"success": False,
"errorMessage": "",
"message": None,
})
def add(username, data):
'''input json key : lesson_id,repetition, username, exercise_id, milisec, sec, min, heart_beat_id '''
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM `user` WHERE username = %s", username)
myCoach = dict_cursor.fetchone()
for record in data['record']:
dict_cursor.execute(
"SELECT * FROM `user` WHERE `id`= %s AND role_id = 2",
record['user_id'])
mySwimmer = dict_cursor.fetchone()
dict_cursor.execute(
"SELECT COUNT(*) FROM `record` WHERE user_id = %s AND exercise_id =%s ",
(mySwimmer['id'], data['exercise_id']))
myRep = dict_cursor.fetchone()['COUNT(*)']
dict_cursor.execute("SELECT * FROM `exercise` WHERE id= %s ",
data['exercise_id'])
myExercise = dict_cursor.fetchone()
if myRep < myExercise['repetition']:
c.execute(
"INSERT INTO `record` (user_id, coach_id, lesson_id, exercise_id, swim_millisec , swim_sec , swim_min, heart_beat_id ) VALUES (%s, %s, %s, %s, %s, %s, %s ,%s)",
(record['user_id'], myCoach['id'], data['lesson_id'],
data['exercise_id'], record['millisec'], record['sec'],
record['min'], record['heart_beat_id']))
db.commit()
else:
dict_cursor.close()
c.close()
db.close()
return jsonify({
"values": "",
"success": False,
"errorMessage": "",
"message": None
})
dict_cursor.close()
c.close()
db.close()
return jsonify({
"values": "",
"success": True,
"errorMessage": "",
"message": None
})
def getSwimmerInfo(team_id):
try:
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM `team` WHERE id = %s", team_id)
myTeam = dict_cursor.fetchone()
if myTeam:
c.execute("SELECT user_id FROM `team-swimmer` WHERE team_id = %s",
myTeam['id'])
mySwimmerID = c.fetchall()
result = []
columns = ['user_id', 'username', 'dob', 'first_name', 'last_name']
for row in mySwimmerID:
dict_cursor.execute(
"SELECT username,dob,first_name,last_name FROM `user` WHERE id = %s",
row[0])
mySwimmerInfo = dict_cursor.fetchone()
listRow = [
row[0], mySwimmerInfo['username'],
mySwimmerInfo['dob'].strftime("%Y-%m-%d"),
mySwimmerInfo['first_name'], mySwimmerInfo['last_name']
]
info = dict(zip(columns, listRow))
result.append(info)
return jsonify({
"values": {
"team": result
},
"success": True,
"errorMessage": "",
"message": None,
})
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Invalid team",
"message": None,
})
except:
jsonify({
"values": "Error",
"success": False,
"errorMessage": "",
"message": None,
})
def edit(data, username):
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM `lesson` WHERE id = %s",
data['lesson_id'])
myLesson = dict_cursor.fetchone()
if myLesson:
c.execute(
"UPDATE `lesson` SET name = %s, updated_at = %s WHERE id = %s",
(data['lesson_name'], str(
datetime.datetime.now()), data['lesson_id']))
db.commit()
c.execute("UPDATE `lesson-team` SET date = %s WHERE lesson_id = %s",
(data['date'], data['lesson_id']))
db.commit()
for exercise in data['exercise']:
dict_cursor.execute(
"SELECT * FROM distance WHERE swim_distance = %s",
exercise['swim_distance'])
myDistanceID = dict_cursor.fetchone()
dict_cursor.execute("SELECT * FROM style WHERE swim_name = %s",
exercise['swim_name'])
myStyleID = dict_cursor.fetchone()
c.execute(
"UPDATE `exercise` SET style_id = %s,distance_id = %s, repetition=%s, description = %s WHERE lesson_id = %s AND type_id = %s",
(myStyleID['id'], myDistanceID['id'], exercise['repetition'],
exercise['description'], data['lesson_id'],
exercise['type_id']))
db.commit()
db.close()
return jsonify({
"values": "",
"success": True,
"errorMessage": "",
"message": None
})
return jsonify({
"values": "",
"success": False,
"errorMessage": "Invalid lesson",
"message": None
})
def swimmer_add(js_data): # GET methods
"""receive number of swimmer need to create"""
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
my_account_list = ""
for swimmer in js_data['swimmers']:
try:
c.execute(
'''INSERT INTO user (username, password,
role_id, is_verified, created_at, dob) VALUES (%s, %s, %s, %s, %s, %s)''',
(swimmer['username'], swimmer['password'], 2, 0,
str(datetime.datetime.now()), '2000-1-1'))
# add account to string
my_account_list += ('tai khoan: ' + swimmer['username'] + '\n' +
'mat khau: ' + swimmer['password'] + '\n' +
'-' * 40 + '\n')
db.commit()
except:
db.rollback()
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Something went wrong.",
"message": None,
"created_date": str(datetime.datetime.now())
})
# the next 4 lines store account to swimmer.txt
f = open('swimmer.txt', 'w')
temp = '-' * 40 + '\n' + my_account_list
encoded = base64.b64encode(temp.encode())
# encode before store in a text file
f.write(str(encoded.decode()))
return jsonify({
"values": "Swimmer created.",
"success": True,
"errorMessage": None,
"message": "Accepted.",
"created_date": str(datetime.datetime.now())
})
def get_info(username):
"""return all information of a username"""
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute('SELECT * FROM user WHERE username = %s', username)
value = dict_cursor.fetchone()
if not value:
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "No username like this.",
"message": None,
"created_date": str(datetime.datetime.now())
})
return jsonify({
"values": {
"user": value
},
"success": True,
"errorMessage": None,
"message": "Accepted.",
"created_date": str(datetime.datetime.now())
})
def edit_info(username, js_data):
''' username is GET method,
js_data are
first_name, last_name, gender, dob, weight,
height, address, phone, email, parent_name, parent_phone
protected'''
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
try:
c.execute(
'''UPDATE user
SET first_name = %s, last_name = %s, gender = %s, dob = %s, weight = %s,
height = %s, address = %s, phone = %s, email = %s, parent_name = %s,
parent_phone = %s
WHERE username = %s''',
(js_data['first_name'], js_data['last_name'], js_data['gender'],
js_data['dob'], js_data['weight'], js_data['height'],
js_data['address'], js_data['phone'], js_data['email'],
js_data['parent_name'], js_data['parent_phone'], username))
db.commit()
return jsonify({
"values": "Profile of " + username + " has been changed.",
"success": True,
"errorMessage": None,
"message": "Accepted.",
"created_date": str(datetime.datetime.now())
})
except:
db.rollback()
return jsonify({
"values": "Error",
"success": False,
"errorMessage": "Something went wrong.",
"message": None,
"created_date": str(datetime.datetime.now())
})
def add(username, data):
'''JSON include key : lesson_name,team_name,date'''
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM team where name = %s",
data['team_name'])
myTeam = dict_cursor.fetchone()
dict_cursor.execute("SELECT * FROM lesson WHERE name = %s",
data['lesson_name'])
myLesson = dict_cursor.fetchone()
dict_cursor.execute(
"SELECT * FROM `lesson-team` WHERE team_id = %s AND lesson_id = %s ",
(myTeam['id'], myLesson['id']))
if not dict_cursor.fetchone():
c.execute(
"INSERT INTO `lesson-team` (lesson_id,team_id,date) VALUES (%s, %s, %s)",
(myLesson['id'], myTeam['id'], data['date']))
db.commit()
dict_cursor.close()
c.close()
db.close()
return jsonify({
"values": "",
"success": True,
"errorMessage": "",
"message": None
})
dict_cursor.close()
c.close()
db.close()
return jsonify({
"values": "",
"success": False,
"errorMessage": "this team already has the same lesson",
"message": None
})
def delete(lesson_id):
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM `lesson` WHERE id = %s", lesson_id)
myLesson = dict_cursor.fetchone()
if myLesson:
c.execute("DELETE FROM `lesson` WHERE id = %s", lesson_id)
c.execute("DELETE FROM `exercise` WHERE lesson_id = %s", lesson_id)
db.commit()
db.close()
return jsonify({
"values": "Lesson " + myLesson['name'] + " has deleted",
"success": True,
"errorMessage": "",
"message": None
})
return jsonify({
"values": "",
"success": False,
"errorMessage": "Invalid lesson",
"message": None
})
def __init__(self):
self.exe = connection()
def __init__(self):
self.driver = connection()
self.config = configparser.ConfigParser()
self.config.read("config.ini")
def viewMember(username, data):
db, c = connector.connection()
dict_cursor = connector.getDictCursor()
dict_cursor.execute("SELECT * FROM `team-swimmer` WHERE team_id = %s",
data['team_id'])
