# 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
from datetime import date
import json

# 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, classOf, dob):
        self._name = name    # variables with self prefix become part of the object, 
        self._uid = uid
        self.set_password(password)
        self._classOf = classOf
        self._dob = dob 
        
    # a classOf getter method, extracts classOf from object
    @property
    def classOf(self):
        return self._classOf
    
    # a setter function, allows classOf to be updated after initial object creation
    @classOf.setter
    def classOf(self, classOf):
        self._name = classOf

    # a dob getter method, extracts dob from object
    @property
    def dob(self):
        dob_string = self._dob.strftime('%m-%d-%Y')
        return dob_string
    # a setter function, allows dob to be updated after initial object creation
    @dob.setter
    def dob(self, dob):
        self._dob = dob
        
    # 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
    @property
    def age(self):
        today = date.today()
        return today.year - self._dob.year - ((today.month, today.day) < (self._dob.month, self._dob.day))

    @property
    def dictionary(self):
        dict = {
            "name" : self.name,
            "uid" : self.uid,
            "dob" : self.dob,
            "age" : self.age
        }
        return dict
    # 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
    
    # output content using str(object) in human readable form, uses getter
    def __str__(self):
        return json.dumps(self.dictionary)

    # output command to recreate the object, uses attribute directly
    def __repr__(self):
        return f'Person(name={self._name}, uid={self._uid}, password={self._password})'
    
    def __dir__(self):
        return ["name", "uid"]


# tester method to print users
def tester(users, uid, psw):
    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
        

# place tester code inside of special if!  This allows include without tester running
if __name__ == "__main__":
    u1 = User(name='Chinmay Ramamurthy', uid='Gambit', password='sh2810sh', classOf = 2025, dob=date(2007, 4, 17))
    print("JSON ready string:\n", u1, "\n") 
    print("Raw Variables of object:\n", vars(u1), "\n") 
    print("Raw Attributes and Methods of object:\n", dir(u1), "\n")
    print("Representation to Re-Create the object:\n", repr(u1), "\n") 
    

JSON ready string:
 {"name": "Chinmay Ramamurthy", "uid": "Gambit", "dob": "04-17-2007", "age": 15} 

Raw Variables of object:
 {'_name': 'Chinmay Ramamurthy', '_uid': 'Gambit', '_password': 'sha256$cVjrOaDGVyyWMs8i$362f6825f8c4da42002a9bdb2a0aa8cdeb9fed17ddf3265324c690887712e7bb', '_classOf': 2025, '_dob': datetime.date(2007, 4, 17)} 

Raw Attributes and Methods of object:
 ['name', 'uid'] 

Representation to Re-Create the object:
 Person(name=Chinmay Ramamurthy, uid=Gambit, password=sha256$cVjrOaDGVyyWMs8i$362f6825f8c4da42002a9bdb2a0aa8cdeb9fed17ddf3265324c690887712e7bb)

My own class is below. I wrote it in java, just to see if a) I still remember it, b) to make sure the new stuff I learned could be applied anywhere, c) for an extra challenge

code:

image

output:

image