# A gateway in necessary as a web server cannot communicate directly with Python.
# In this case, imports are focused on generating hash code to protect passwords.
from werkzeug.security import generate_password_hash, check_password_hash
import json
from datetime import date
# Define a User Class/Template
# -- A User represents the data we want to manage
class User:
# constructor of a User object, initializes the instance variables within object (self)
def __init__(self, name, uid, password):
self._name = name # variables with self prefix become part of the object,
self._uid = uid
self.set_password(password)
self.birth = birth
self.age = age
self.classOf = classOf
# a name getter method, extracts name from object
@property
def name(self):
return self._name
# a setter function, allows name to be updated after initial object creation
@name.setter
def name(self, name):
self._name = name
# a getter method, extracts email from object
@property
def uid(self):
return self._uid
# a setter function, allows name to be updated after initial object creation
@uid.setter
def uid(self, uid):
self._uid = uid
# check if uid parameter matches user id in object, return boolean
def is_uid(self, uid):
return self._uid == uid
@property
def password(self):
return self._password[0:10] + "..." # because of security only show 1st characters
# update password, this is conventional setter
def set_password(self, password):
"""Create a hashed password."""
self._password = generate_password_hash(password, method='sha256')
# check password parameter versus stored/encrypted password
def is_password(self, password):
"""Check against hashed password."""
result = check_password_hash(self._password, password)
return result
# setting up the graduation class
@property
def classOf(self):
return self._classOf
@classOf.setter
def classOf(self, classOf):
self._classOf = classOf
# output content using str(object) in human readable form, uses getter
def __str__(self):
return f'name: "{self.name}", id: "{self.uid}", psw: "{self.password}", classOf: "{self.classOf}", birth: "{self.birth}", age: "{self.age}"'
# output command to recreate the object, uses attribute directly
def __repr__(self):
return f'Person(name={self._name}, uid={self._uid}, password={self._password}, classOf={self._classOf}, birth={self.birth}, age={self.age})'
@property
def birth(self):
return self._birth
@birth.setter
def birth(self, birth):
self._birth = birth
@property
def age(self):
return self._age
@age.setter
def age(self, age):
self._age = age
# tester method to print users
def tester(users, uid, psw, classOf, birth, age):
result = None
for user in users:
# test for match in database
if user.uid == uid and user.is_password(psw): # check for match
print("* ", end="")
result = user
# print using __str__ method
print(str(user))
return result
from datetime import date
def agecalculator(born):
today = date.today()
return today.year - born.year - ((today.month, today.day) < (born.month, born.day))
# place tester code inside of special if! This allows include without tester running
if __name__ == "__main__":
# define user objects
u1 = User(name='Rohan Agarwal', uid='RohanAgr', password='AirbusA320!', classOf=2024, born=[2005, 5, 19], age= calculate_age(date(2005, 5, 19)))
u2 = User(name='Vardaan Sangal', uid='vardaansangal', password='grocerystore', classOf=2024, born=[2006, 8, 7], age= calculate_age(date(2006, 8, 7)))
u3 = User(name='Sean Yeung', uid='syeung', password='APCSP!', classOf=2000, born=[1995, 2, 3], age= calculate_age(date(1995, 2, 3)))
u4 = User(name='Divyani Agarwal', uid='divyani006', password='kpop21', classOf=2026, born=[2008, 3, 21], age= calculate_age(date(2008, 3, 21)))
# put user objects in list for convenience
users = [u1, u2, u3, u4,]
# Find user
print("Test 1, find user 3")
u = tester(users, u3.uid, "APCSP!")
# Change user
print("Test 2, change user 3 from Sean Yeung to Rachna Agarwal")
u.name = "Rachna Agarwal"
u.uid = "rachna.sdca"
u.set_password("whatisthis23")
u.classOf = 1995
u.birth = [1977, 10, 24]
u.age = calculate_age(date(1977, 10, 28))
u = tester(users, u.uid, "whatisthis23", u.classOf, u.birth, u.age)
# Make dictionary
'''
The __dict__ in Python represents a dictionary or any mapping object that is used to store the attributes of the object.
Every object in Python has an attribute that is denoted by __dict__.
Use the json.dumps() method to convert the list of Users to a JSON string.
'''
print("Test 3, make a dictionary")
json_string = json.dumps([user.__dict__ for user in users])
print(json_string)
print("Test 4, make a dictionary")
json_string = json.dumps([vars(user) for user in users])
print(json_string)
