class User(UserMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), unique=True) email = db.Column(db.String(64), unique=True, index=True) password_hash = db.Column(db.String(128)) def get_reset_token(self, expires_sec=1800): s = Serializer(app.config['SECRET_KEY'], expires_sec) return s.dumps({'user_id': self.id}).decode('utf-8') @staticmethod def verify_reset_token(token): s = Serializer(app.config['SECRET_KEY']) try: user_id = s.loads(token)['user_id'] except: return None return User.query.get(user_id) def __init__(self, email, username, password): self.username = username self.email = email self.password_hash = generate_password_hash(password) def check_password(self, password): return check_password_hash(self.password_hash, password)
class User(db.Model, UserMixin): # this is the table name inside the database __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) # id, remains unique name = db.Column(db.String(20)) email = db.Column(db.String(64), unique=True, index=True) # email should be unique password_hash = db.Column(db.String(128)) # password hash diseases = db.relationship('Disease', backref='users', lazy='dynamic') def __init__(self, name, email, password): self.name = name self.email = email # saving a sha sum hash instead of actual pass self.password_hash = generate_password_hash(password) def check_password(self, password): # checking if hashes match return check_password_hash(self.password_hash, password) def diseases_dict(self): disease_list = [] symptoms_list = [] for disease in self.diseases: disease_list.append(disease.disease_name) symptoms_list.append(disease.symptoms) disease_dict = dict(zip(symptoms_list, disease_list)) return disease_dict
class Role(db.Model): __tablename__ = 'roles' id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(50), unique=True) def __init__(self, name): self.name = name
class Condidate(db.Model): __tablename__ = 'condidates' id = db.Column(db.Integer,primary_key= True) group_id = db.Column(db.Integer,db.ForeignKey('groups.id')) emailc = db.Column(db.String(64), unique=True, index=True) pronounc = db.Column(db.Text) phonenumc = db.Column(db.String(10)) stimes = db.Column(db.Text) text = db.Column(db.Text) status = db.Column(db.Text) firstname = db.Column(db.Text) lastname = db.Column(db.Text) def __init__(self,group_id,emailc,pronounc,phonenumc,stimes,text,status,firstname,lastname): self.group_id = group_id self.emailc = emailc self.pronounc = pronounc self.phonenumc = phonenumc self.stimes = stimes self.text = text self.status = status self.firstname =firstname self.lastname = lastname
class RequestUIDS(db.Model): __tablename__ = 'ruids' id = db.Column(db.Integer, primary_key=True) ruid = db.Column(db.Integer) def __init__(self, ruid): self.ruid = ruid
class TestReport(db.Model): __tablename__ = 'test_report' id = db.Column(db.Integer, primary_key=True) filename = db.Column(db.String(64), nullable=False) test_id = db.Column(db.Integer, db.ForeignKey('patient_test.id'), nullable=False, unique=True) test = db.relationship('PatientTest', backref=db.backref('report', uselist=False, cascade="delete")) def __init__(self, filename, test_id): self.filename = filename self.test_id = test_id def __repr__(self): return f'test_report({self.id},{self.filename},{self.test_id})' def save(self): db.session.add(self) db.session.commit()
class BlogPost(db.Model): """This class represents a table movies in the database """ __tablename__ = 'blogPosts' id = db.Column(db.Integer, primary_key=True) posted_on = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) title = db.Column(db.String(140), nullable=False) text = db.Column(db.Text, nullable=False) # Connecting the BlogPost to a particular user (poster) user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False) # Setup the relationship to the User table users = db.relationship(User) @property def serialize(self): """This method will help to represent the class User as a json object """ return { 'id': self.id, 'posted_on': self.posted_on, 'title': self.title, 'text': self.text, 'user_id': self.user_id } def __repr__(self): """This method helps to easily print an instance of the class""" return f"<Post ID: {self.id} -- Date: {self.date} --- {self.title}>"
class PUIDS(db.Model): __tablename__ = 'puids' id = db.Column(db.Integer, primary_key=True) puid = db.Column(db.Integer) def __init__(self, puid): self.puid = puid
class User(UserMixin,db.Model): # Create a table in the db __tablename__ = 'users' id = db.Column(db.Integer, primary_key = True) email = db.Column(db.String(64), unique=True, nullable=False) username = db.Column(db.String(64), unique=True, nullable=False) password_hash = db.Column(db.String(128)) location=db.Column(db.String(64)) def __init__(self, email, username, password,location): self.email = email self.username = username self.password_hash = generate_password_hash(password) # self.password_hash = password self.location = location def check_password(self,password): # https://stackoverflow.com/questions/23432478/flask-generate-password-hash-not-constant-output # if password==self.password_hash: # return True # else: # return False return check_password_hash(self.password_hash,password)
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key= True) username = db.Column(db.String(20), unique=True, nullable=False) email = db.Column(db.String(20), unique=True, nullable=False) image_file = db.Column(db.String(20), nullable=False, default='default.jpg') password = db.Column(db.String(60), nullable=False) posts = db.relationship('Post', backref='author', lazy=True) def get_reset_token(self, expires_sec=1800): s = Serializer(app.config['SECRET_KEY'], expires_sec) return s.dumps({'user_id': self.id}).decode('utf-8') @staticmethod def verify_reset_token(token): s = Serializer(app.config['SECRET_KEY']) try: user_id = s.loads(token)['user_id'] except: return None return User.query.get(user_id) def __init__(self,username,email,password): self.username = username self.email = email self.password = self.set_password(password) def __repr__(self): return f"User('{self.username}','{self.email}','{self.image_file}')" def set_password(self, pw): pwhash = bcrypt.hashpw(pw.encode('utf8'), bcrypt.gensalt()) self.password_hash = pwhash.decode('utf8') # decode the hash to prevent is encoded twice return self.password_hash
class Schedule(db.Model): __tablename__ = 'schedule' id = db.Column(db.Integer, primary_key=True, index=True) day = db.Column(db.String(10), nullable=False) start_time = db.Column(db.Time) end_time = db.Column(db.Time) doctor_id = db.Column(db.Integer, db.ForeignKey('doctor.id'), nullable=False) doctor = db.relationship('Doctor', backref=db.backref('schedule', lazy='dynamic', cascade="all, delete")) def __init__(self, day, start_time, end_time, doctor_id): self.day = day self.start_time = start_time self.end_time = end_time self.doctor_id = doctor_id def __repr__(self): return f'schedule({self.id},{self.day},{self.start_time},{self.end_time})' def save(self): db.session.add(self) db.session.commit()
class User(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(64), unique=True, index=True) password_hash = db.Column(db.String(128)) email = db.Column(db.String(64), unique=True, index=True) profile_image = db.Column(db.String, nullable=False, default='default_profile.png') posts = db.relationship('BlogPosts', backref='author', lazy=True) def __init__(self, username, password, email): self.username = username self.password_hash = generate_password_hash(password) self.email = email def check_password(self, password): return check_password_hash(self.password_hash, password) def __repr__(self): return f"User: {self.username}"
class PatientTest(db.Model): __tablename__ = 'patient_test' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), nullable=False) details = db.Column(db.String(150)) patient_id = db.Column(db.Integer, db.ForeignKey('patient.id'), nullable=False) appointment_id = db.Column(db.Integer, db.ForeignKey('appointment.id'), nullable=False) patient = db.relationship('Patient', backref=db.backref('test', lazy='dynamic', cascade="all, delete")) appointment = db.relationship('Appointment', backref=db.backref('patient_test', lazy='dynamic', cascade="all, delete")) def __init__(self, name, details, patient_id, appointment_id): self.name = name self.details = details self.patient_id = patient_id self.appointment_id = appointment_id def __repr__(self): return f'patient_test({self.id},{self.name},{self.patient_id},{self.details},{self.appointment_id})' def save(self): db.session.add(self) db.session.commit()
class Quotes(db.Model): id = db.Column(db.Integer, primary_key=True) quoteauthor = db.Column(db.String(100), index=True) quotestring = db.Column(db.String(200), index=True) def __repr__(self): return "<Quote : {}>".format(self.quotestring)
class User(db.Model, UserMixin): __tablename__ = 'users' # Columns or attributes in database table named __tablename__ id = db.Column(db.Integer, primary_key=True) # Primary key and will auto increment email = db.Column(db.String(128), unique=True, index=True, nullable=False) name = db.Column(db.String(128), nullable=False) contact_no = db.Column(db.String(20), default='0') password_hash = db.Column(db.String(512), nullable=False) # First argument is the name of class model to which it will reference # backref is the name of the relation # backref is a simple way to also declare a new property on the 'BlogPost' class # It is a one to many relationship by default events = db.relationship('Event', backref='user_of_this_event', lazy=True) #If you would want to have a one-to-one relationship you can pass uselist=False to relationship() def __init__(self, email, name, password, contact_no=None): self.email = email self.name = name self.contact_no = contact_no self.password_hash = generate_password_hash(password) def validate_password(self, password): return check_password_hash(self.password_hash, password) # Returns the string representaion of the class object def __repr__(self): return f'User mail: {self.email}'
class Solved_Classroom_Assignment(db.Model): __tablename__ = 'solved_classroom_assignments' classroom_id = db.Column(db.Integer, db.ForeignKey('classroom.id')) student_id = db.Column(db.Integer, db.ForeignKey('students.id')) assignment_id = db.Column(db.Integer, db.ForeignKey('assignments.id')) points = db.Column(db.Integer) classroom = db.relationship( 'Classroom', backref=backref("Solved_Classroom_Assignment_JOIN_Classroom", cascade="all,delete")) student = db.relationship( 'Student', backref="Solved_Classroom_Assignment_JOIN_Student") assignment = db.relationship( 'Assignments', backref=backref("Solved_Classroom_Assignment_JOIN_Assignments", cascade="all,delete")) __table_args__ = (db.PrimaryKeyConstraint( classroom_id, student_id, assignment_id, ), ) def __init__(self, classroom_id, assignment_id, student_id, points): self.classroom_id = classroom_id self.student_id = student_id self.assignment_id = assignment_id self.points = points
class Teacher(db.Model): __tablename__ = 'teachers' id = db.Column(db.Integer, primary_key=True) teacher_fname = db.Column(db.Text) teacher_lname = db.Column(db.Text) teacher_uname = db.Column(db.Text, unique=True) teacher_email = db.Column(db.Text) teacher_password_hash = db.Column(db.Text) teacher_rating = db.Column(db.Float) teacher_no_Of_reviews = db.Column(db.Integer) teacher_account_status = db.Column(db.Boolean) teacher_bio = db.Column(db.Text) def __init__(self, teacher_fname, teacher_lname, teacher_uname, teacher_email, teacher_password, teacher_rating, teacher_no_Of_reviews, teacher_account_status, teacher_bio): self.teacher_fname = teacher_fname self.teacher_lname = teacher_lname self.teacher_uname = teacher_uname self.teacher_email = teacher_email self.teacher_password_hash = generate_password_hash(teacher_password) self.teacher_rating = teacher_rating self.teacher_no_Of_reviews = teacher_no_Of_reviews self.teacher_account_status = teacher_account_status self.teacher_bio = teacher_bio def check_password(self, mypassword): return check_password_hash(self.teacher_password_hash, mypassword) def hash_password(self, mypassword): self.teacher_password_hash = generate_password_hash(mypassword) def __repr__(self): return f"Teacher Id: {self.id} First Name: {self.teacher_fname} Last Name: {self.teacher_lname}"
class Settings(db.Model): __tablename__ = 'settings' student_id = db.Column( db.Integer, db.ForeignKey('students.id'), primary_key=True) # Can be a PK because its a 1-1 Relationship display_rank = db.Column(db.Boolean) display_stats = db.Column(db.Boolean) student = db.relationship('Student', backref="Student_JOIN_Settings", uselist=False) # Backref def __init__(self, student_id, display_rank, display_stats): self.student_id = student_id self.display_rank = display_rank self.display_stats = display_stats # Function that returns settings code def return_setting_preset(self): if self.display_rank and self.display_stats: return 1 # Display both == 1 elif self.display_rank and not self.display_stats: return 2 # Display rank only == 2 elif self.display_stats and not self.display_rank: return 3 # Display stats only == 3 else: return 4 # Hide both == 4
class Comment(db.Model): id = db.Column(db.Integer, primary_key=True) body = db.Column(db.String(100), nullable=False) timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False) def __repr__(self): return f"Comment('{self.body}', '{self.timestamp}')"
class Places(db.Model): id = db.Column(db.Integer, primary_key=True) address = db.Column(db.String()) city = db.Column(db.String()) country = db.Column(db.String()) def __repr__(self): return '<city %r>' % (self.city)
class Category(db.Model): __tablename__ = "categories" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, unique=True) product_id = db.Column(db.Integer, db.ForeignKey("products.id")) def __init__(self, name): self.name = name
class Recipe_Calories(db.Model): __tablename__ = 'recipe_calories' recipe_id = db.Column('recipe_id', db.Integer, primary_key=True, nullable=False) recipe_name = db.Column('recipe_name', db.String(100), nullable=False) calories = db.Column('calories', db.Integer, nullable=False)
class Answers(db.Model): id = db.Column(db.Integer, primary_key=True) question_id = db.Column(db.Integer, db.ForeignKey(Questions.id)) body = db.Column(db.Text) def __init__(self, body, question_id): self.body = body self.question_id = question_id
class Category(db.Model): __tablename__ = "categories" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String) products = db.relationship("Product", backref="category", lazy="dynamic") def __init__(self, name): self.name = name
class Post(db.Model): id = db.Column(db.Integer, primary_key= True) title = db.Column(db.String(100), nullable=False) date_posted = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) content = db.Column(db.Text, nullable=False) user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) def __repr__(self): return f"Post('{self.title}','{self.date_posted}')"
class Symptoms(db.Model): __tablename__ = 'symptoms' disease_id = db.Column(db.Integer,primary_key=True) symptom_name=db.Column(db.String,primary_key=True) def __init__(self, disease_id,symptom_name): self.disease_id = disease_id self.symptom_name = symptom_name
class UIDS(db.Model): __tablename__ = 'uids' id = db.Column(db.Integer, primary_key=True) uid = db.Column(db.Integer, unique=True, nullable=False) # links=db.Column(db.String(114),nullable=False) def __init__(self, uid): self.uid = uid
class Admin(db.Model): __tablename__ = "admins" id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey("users.id")) user = db.relationship("User", backref="admins") def __init__(self, user_id): self.user_id = user_id
class Owner(db.Model): __tablename__ = 'owner' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Text) puppy_id = db.Column(db.Integer, db.ForeignKey('puppies.id')) def __init__(self, name, puppy_id): self.name = name self.puppy_id = puppy_id
class Scans(db.Model): __tablename__ = "scans" id = db.Column(db.Integer, primary_key=True) p_id = db.Column(db.Integer, db.ForeignKey('p_accounts.id')) scan = db.Column(db.String) def __init__(self, p_id, scan): self.p_id = p_id self.scan = scan