class Students(db.Model): __tablename__ = "students" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(250)) last_name = db.Column(db.String(250)) age = db.Column(db.Integer) email = db.Column(db.String(250)) def __init__(self, *args, **kwargs): self.name = kwargs['name'] self.last_name = kwargs['last_name'] self.age = kwargs['age'] self.email = kwargs['email'] @property def serializer(self): return { 'name': self.name, 'last_name': self.last_name, 'age': self.age, 'email': self.email } def __str__(self): return f'{self.name} {self.last_name}'
class Donation(db.Model): __tablename__ = "donations" id = db.Column(db.Integer, primary_key=True, autoincrement=True) subscriber_id = db.Column(db.Integer, db.ForeignKey('subscribers.id'), nullable=False) amount = db.Column(db.Integer) date_of_expiration = db.Column(db.DateTime()) volume_of_blood = db.Column(db.Integer) onset_time = db.Column(db.DateTime()) termination_time = db.Column(db.DateTime()) torfru = db.Column(db.DateTime()) created_at = db.Column(db.DateTime, default=db.func.now()) updated_at = db.Column(db.DateTime, default=db.func.now()) def _asdict(self): return { c.key: getattr(self, c.key) for c in db.inspect(self).mapper.column_attrs } @hybrid_method def update_donor_dolbd(self): if self.donor: self.donor.update_dolbd(self.created_at)
class BlacklistToken(db.Model): """ Token Model for storing JWT tokens """ __tablename__ = 'blacklist_tokens' id = db.Column(db.Integer, primary_key=True, autoincrement=True) token = db.Column(db.String(500), unique=True, nullable=False) blacklisted_on = db.Column(db.DateTime, nullable=False) def __init__(self, token): self.token = token self.blacklisted_on = datetime.datetime.now() def __repr__(self): return '<id: token: {}'.format(self.token) @staticmethod def check_blacklist(auth_token): # check whether auth token has been blacklisted res = BlacklistToken.query.filter_by(token=str(auth_token)).first() if res: return True else: return False
class User(db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) projects = db.relationship('Project', backref='users', lazy=True) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') self.admin = admin def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.id def __repr__(self): return '<User {0}>'.format(self.email)
class User(db.Model): """ User Model for storing user related details """ __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS') ).decode() self.registered_on = datetime.datetime.now() self.admin = admin def encode_auth_token(self, user_id): """ Generates the Auth Token :return: string """ try: payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=0, seconds=5), 'iat': datetime.datetime.utcnow(), 'sub': user_id } return jwt.encode( payload, app.config.get('SECRET_KEY'), algorithm='HS256' ) except Exception as e: return e @staticmethod def decode_auth_token(auth_token): """ Decodes the auth token :param auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) return payload['sub'] except jwt.ExpiredSignatureError: return 'Signature expired. Please log in again.' except jwt.InvalidTokenError: return 'Invalid token. Please log in again.' @app.route("/users/index") def users_index(): users = db.session.query(User).all() user_list = [] for i in users: user_list.append(i.email) return str(user_list)
class Loan(db.Model): """Represents the loans that have been accepted.""" __tablename__ = 'loans' STATES = [ (u'active', u'Active'), (u'closed', u'Closed'), ] id = db.Column(db.Integer, primary_key=True, autoincrement=True) loan_application_id = db.Column(db.Integer, db.ForeignKey('loan_applications.id')) loan_application = relationship("LoanApplication", back_populates="loan") loan_status = db.Column(ChoiceType(STATES), nullable=False) accepted_on = db.Column(db.DateTime, nullable=False) requested_amount = db.Column(db.Numeric(12, 4), nullable=False) def __init__(self, loan_application_id, loan_status, requested_amount): self.loan_application_id = loan_application_id self.loan_status = loan_status self.accepted_on = datetime.datetime.now() self.requested_amount = requested_amount def __repr__(self): return f"{self.loan_application}, accepted_on={self.accepted_on}"
class Attachments(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) fileName = db.Column(db.String(255)) documentLink = db.Column(db.String(500)) answer_id = db.Column(db.Integer, db.ForeignKey('answer.id'), nullable=False)
class Section(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) owner_id = db.Column(db.Integer) assignedTo = db.Column(db.String(255)) assessment_id = db.Column(db.Integer, db.ForeignKey('assessment.id'), nullable=False)
class Expert(db.Model): __tablename__ = 'expert' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) nickname = db.Column(db.String(255), unique=True, nullable=False) active = db.Column(db.Boolean, default=True) # def __init__(self, name, created_by): # self.name = name # self.created_by = created_by # # def save(self): # db.session.add(self) # db.session.commit() # # @staticmethod # def get_all(user_id): # return Expert.query.filter_by(created_by=user_id) # # def delete(self): # db.session.delete(self) # db.session.commit() # # def __repr__(self): # return "<ExpertList: {}>".format(self.name) def toDict(self): return { c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs }
class Question(db.Model): """ Question Model for storing questions """ __tablename__ = 'questions' Prompt = db.Column(db.String(255), nullable=True) Choices = db.Column(db.String(255), nullable=True) Solution = db.Column(db.String(255), nullable=True) zone = db.Column(db.String(30), nullable=True) branch = db.Column(db.String(30), nullable=True) qType = db.Column(db.String(255), nullable=True) iLink = db.Column(db.String(255), nullable=True) sLink = db.Column(db.String(255), nullable=True) blanks = db.Column(db.String(255), nullable=True) id = db.Column(db.Integer, primary_key=True, autoincrement=True) __table_args__ = (db.ForeignKeyConstraint([branch, zone], [Zone.branch, Zone.zone]), {}) def __init__(self, Prompt, Choices, Solution, zone, branch, qType, iLink, sLink, blanks): self.Prompt = Prompt self.Choices = Choices self.Solution = Solution self.zone = zone self.branch = branch self.qType = qType self.iLink = iLink self.sLink = sLink self.blanks = blanks
class UserModule(db.Model): __tablename__ = 'user_modules' id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey('users.id', ondelete='CASCADE')) module_id = db.Column(db.Integer(), db.ForeignKey('modules.id', ondelete='CASCADE'))
class Module(db.Model): __tablename__ = 'modules' id = db.Column(db.Integer(), primary_key=True, autoincrement=True) name = db.Column(db.String(50), unique=False) def __init__(self, name): self.name = name
class User(db.Model): __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') self.registered_on = datetime.datetime.now() self.admin = admin def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return self.id def __repr__(self): return '<User {0}>'.format(self.email)
class Appointment(BaseModel, Base): """""" user_id = db.Column(db.Integer, db.ForeignKey('users.id')) date = db.Column(db.DateTime, nullable=False) notes = db.Column(db.Text, nullable=False) treatments = db.relationship('Treatment', secondary='user_symptom_treatment')
class RSAPair(db.Model): """ RSAPair model for database mapping to create RSAPair table which store RSA Key Pairs generated for each of login session """ __tablename__ = 'rsa_key' id = db.Column(db.Integer, primary_key=True, autoincrement=True) public_modulus = db.Column(db.String(), nullable=False) public_exponent = db.Column(db.Integer, nullable=False) private_exponent = db.Column(db.String(), nullable=False) def __init__(self, public_modulus, public_exponent, private_exponent): """ RSAPair Model Constructor :params: :modulus: public modulus :exponent: public exponent :key_mod: private modulus :returns: void """ self.public_modulus = public_modulus self.public_exponent = public_exponent self.private_exponent = private_exponent @staticmethod def is_existed(key): """ Check if provided key is existed :params: :key: list or RSA instance of the key :returns: True or False """ if isinstance(key, str): rsa_key = RSAPair.query.filter_by(public_modulus=key).first() elif isinstance(key, list): rsa_key = RSAPair.query.filter_by(public_modulus=key[0]).first() else: rsa_key = RSAPair.query.filter_by( public_modulus=str(key.n)).first() return True if rsa_key else False @staticmethod def get_RSA_by_public(public_key): """ Get stored RSAPair from the public key :params: :public_key: the corresponding public key :returns: :RSAPair: """ if isinstance(public_key, list): return RSAPair.query.filter_by( public_modulus=public_key[0]).first() elif isinstance(public_key, str): return RSAPair.query.filter_by(public_modulus=public_key).first() elif isinstance(public_key, int): return RSAPair.query.filter_by( public_modulus=str(public_key)).first() else: return RSAPair.query.filter_by( public_modulus=str(public_key.n)).first()
class User(db.Model): """ User Model for storing user related details """ __tablename__ = "users" id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, email, password, admin=False): self.email = email self.password = bcrypt.generate_password_hash( password, app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') self.registered_on = datetime.datetime.now() self.admin = admin def __str__(self): return "Email: " + self.email + ", Password: "******""" Generates the Auth Token :return: string """ try: payload = { 'exp': datetime.datetime.utcnow() + datetime.timedelta(days=0, seconds=5), 'iat': datetime.datetime.utcnow(), 'sub': user_id } return jwt.encode(payload, app.config.get('SECRET_KEY'), algorithm='HS256') except Exception as e: return e @staticmethod def decode_auth_token(auth_token): """ Validates the auth token :param auth_token: :return: integer|string """ try: payload = jwt.decode(auth_token, app.config.get('SECRET_KEY')) is_blacklisted_token = BlacklistToken.check_blacklist(auth_token) if is_blacklisted_token: return 'Token blacklisted. Please log in again.' else: return payload['sub'] except jwt.ExpiredSignatureError: return 'Signature expired. Please log in again.' except jwt.InvalidTokenError: return 'Invalid token. Please log in again.'
class Product(db.Model): __tablename__ = 'products' id = db.Column(db.Integer, primary_key=True, autoincrement=True) title = db.Column(db.String(255), nullable=False) price = db.Column(db.Numeric(asdecimal=True, precision=10, scale=2), nullable=False) bogof = db.Column(db.Boolean, default=False)
class User_Symptom_Treatment(BaseModel, Base): """""" __tablename__ = 'user_symptom_treatment' user_symptom_id = db.Column(db.Integer, db.ForeignKey('user_symptom.id')) treatment_id = db.Column(db.Integer, db.ForeignKey('treatment.id')) appointment_id = db.Column(db.Integer, db.ForeignKey('appointment.id')) date = db.Column(db.DateTime, nullable=False) notes = db.Column(db.Text, nullable=True)
class Example(db.Model): __tablename__ = "example" id = db.Column(db.Integer, primary_key=True, autoincrement=True) field = db.Column(db.String(255), unique=True, nullable=False) def __init__(self, field): self.field = field
class User(db.Model): """ Defines a user database with associated login information. This is an SQL table. """ # Define the table name, this is the SQLite table name. __tablename__ = "users" # Define the column names and their types in this SQL table. user_id = db.Column(db.Integer, primary_key=True, autoincrement=True) email = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(255), nullable=False) registered_on = db.Column(db.DateTime, nullable=False) admin = db.Column(db.Boolean, nullable=False, default=False) def __init__(self, email, password, admin=False): """ Calling a new instance of this class runs this __init__ function. This is how a new user is created. """ # Assign the values to the class instance, this populates # the SQL row entries. self.email = email # TODO: Comment this, explain what is happening here and # what is actually saved in the row. self.password = bcrypt.generate_password_hash( password, current_app.config.get('BCRYPT_LOG_ROUNDS')).decode('utf-8') # Save what time the user was created. self.registered_on = datetime.datetime.now() # Set the administrator boolean value. self.admin = admin def is_authenticated(self): """ TODO: Populated this function. """ return True def is_active(self): return False def is_anonymous(self): return False def get_id(self): return self.user_id def __repr__(self): """Return a string representation of the user, wrapped in an HTML User tag.""" return '<User {0}>'.format(self.email)
class Entry(db.Model): __tablename__ = 'entries' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.Text) text = db.Column(db.Text) def __repr__(self): return '<Entry id={id} title={title!r}>'.format(id=self.id, title=self.title)
class WalletMemberRoles(db.Model): __bind_key__ = 'agwallet' __tablename__ = 'wallet_member_roles' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False) def __init__(self, name): self.name = name
class Genre(db.Model): __tablename__ = 'genre' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False, unique=True) artists = db.relationship('Artist', backref="genre") def __init__(self, name): self.name = name
class Skills(db.Model): """ Skill fo jobs """ __tablename__ = "skills" id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), unique=True, nullable=False) level = db.Column(db.Integer, nullable=True)
class Picture(db.Model): __tablename__ = 'pictures' id = db.Column(db.Integer, primary_key=True, autoincrement=True) upload_date = db.Column(db.DateTime, nullable=False) owner_id = db.Column(db.Integer, nullable=True) filename = db.Column(db.String(255), unique=True, nullable=False) filesize = db.Column(db.String(255), nullable=True) original_filename = db.Column(db.String(255), nullable=True) original_filesize = db.Column(db.String(255), nullable=True) geolocation = db.Column(db.String(255), nullable=True) park_id = db.Column(db.Integer, nullable=True) tags = db.Column(db.String(255), nullable=True) def __init__(self, filename, owner_id=None, filesize=None, original_filename=None, \ original_filesize=None, geolocation=None, park_id=None, tags='[]'): self.upload_date = datetime.datetime.now() self.owner_id = owner_id self.filename = filename self.filesize = filesize self.original_filename = original_filename self.original_filesize = original_filesize self.geolocation = geolocation self.park_id = park_id self.tags = tags def has_tag(self, tag): return tag in self.tags # string match is enough def get_tags_list(self): return json.loads(self.tags) def get_tags_html(self): tags_list = self.get_tags_list() i = 0 html = '' for tag in tags_list: if i > 0: html += ', ' html += '<a href="' html += app.config.get('BASE_URL') + '/tag/' + tag html += '">' html += tag html += '</a>' i += 1 return html def get_details_url(self): return app.config.get('BASE_URL') + '/image-details/' + str(self.id) def get_file_url(self): return app.config.get('BASE_URL') + '/img/' + self.filename def __repr__(self): return '<Picture {0}>'.format(self.filename)
class CompanyUsers(db.Model): __tablename__ = "company_general_users" id = db.Column(db.Integer(), primary_key=True, autoincrement=True) company_id = db.Column(db.Integer(), nullable=False) user_id = db.Column(db.Integer(), nullable=False) def __init__(self, company_id, user_id): self.company_id = company_id self.user_id = user_id
class LatexFile(db.Model): __tablename__ = "latex_files" uuid = db.Column(db.String(100), primary_key=True) text = db.Column(db.Text, nullable=False) def __init__(self, uuid, text): self.uuid = uuid self.text = text
class Score(db.Model): """ A user's score on a candidate.feature """ __tablename__ = 'scores' user_id = db.Column(pg.UUID, db.ForeignKey('users.id', **fk_cascade), primary_key=True) candidate_id = db.Column(pg.UUID, db.ForeignKey('candidates.id', **fk_cascade), primary_key=True) feature_id = db.Column(pg.UUID, db.ForeignKey('features.id', **fk_cascade), primary_key=True) score = db.Column(db.Integer, nullable=False) # TODO min: 0, max: 5
class User_Symptom(BaseModel, Base): """""" __tablename__ = 'user_symptom' user_id = db.Column(db.Integer, db.ForeignKey('users.id')) symptom_id = db.Column(db.Integer, db.ForeignKey('symptom.id')) start_date = db.Column(db.DateTime, nullable=False) end_date = db.Column(db.DateTime, nullable=False) notes = db.Column(db.Text, nullable=True) treatments = db.relationship('Treatment', secondary='user_symptom_treatment')
class Action(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) section_id = db.Column(db.Integer) owner_id = db.Column(db.Integer) question_id = db.Column(db.Integer, db.ForeignKey('question.id'), nullable=False) additional_info = db.relationship('AdditionalInformation', backref='action', lazy=True)