class User(db.Model): __tablename__ = "user" id = db.Column(db.Integer(), primary_key=True) email = db.Column(db.String(255), unique=True) username = db.Column(db.String(255), unique=True) password = db.Column(db.Binary(60), nullable=False) bodyweight = db.Column(db.Integer()) one_rep_max = db.relationship("OneRepMax") imperial = db.Column(db.Boolean()) sessions = db.relationship("UserSession", lazy="dynamic") def __init__(self, email, password, imperial=True, bodyweight=-1): self.email = email self.active = True self.password = User.hashed_password(password) self.imperial = imperial self.bodyweight = bodyweight @staticmethod def hashed_password(password): return bcrypt.generate_password_hash(password) @staticmethod def get_user_with_email_and_password(email, password): user = User.query.filter_by(email=email).first() if user and bcrypt.check_password_hash(user.password, password): return user else: return None
class TestCase(db.Model): __tablename__ = "test_case" test_case_id = db.Column(db.Integer, primary_key=True) test_suite_id = db.Column(db.ForeignKey(TestSuite.test_suite_id)) test_id = db.Column(db.String(80), nullable=True) test_status = db.Column(db.Integer, nullable=True) test_case_detail = db.Column(LONGTEXT, nullable=True) test_name = db.Column(db.String(80), nullable=True) src_db_id = db.Column(db.ForeignKey('dbdetail.db_id')) target_db_id = db.Column(db.ForeignKey('dbdetail.db_id')) created = db.Column(db.DateTime, default=datetime.datetime.now) test_suite = db.relationship(TestSuite, back_populates='test_case', lazy=True) test_case_log = db.relationship("TestCaseLog", back_populates='test_cases', lazy=True) src_db = db.relationship("DbDetail", foreign_keys=[src_db_id]) target_db = db.relationship("DbDetail", foreign_keys=[target_db_id]) def save_to_db(self): db.session.add(self) db.session.commit() def __init__(self, test_suite_id, test_id, test_status, test_case_detail, test_name, src_db_id, target_db_id): self.test_suite_id = test_suite_id self.test_id = test_id self.test_status = test_status self.test_name = test_name self.test_case_detail = test_case_detail self.src_db_id = src_db_id self.target_db_id = target_db_id
class TestCase(db.Model): __tablename__ = "test_case" test_case_id = db.Column(db.Integer, primary_key=True) test_suite_id = db.Column(db.ForeignKey('test_suite.test_suite_id'), nullable=False, index=True) owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False) test_case_class = db.Column(db.SMALLINT, nullable=False) latest_execution_status = db.Column( db.SMALLINT, nullable=False, default=ExecutionStatus().get_execution_status_id_by_name('new')) is_deleted = db.Column(db.Boolean, nullable=False, default=False) test_case_detail = db.Column(JSON, nullable=False) created_at = db.Column(db.DateTime, default=datetime.now) modified_at = db.Column(db.DateTime, default=datetime.now) test_suite = db.relationship(TestSuite, back_populates='test_case', lazy=True) test_case_log = db.relationship("TestCaseLog", back_populates='test_cases', lazy=True, order_by='TestCaseLog.created_at') def __init__(self, test_suite_id, owner_id, test_case_class, test_case_detail): self.test_suite_id = test_suite_id self.owner_id = owner_id self.test_case_class = test_case_class self.test_case_detail = test_case_detail def save_to_db(self): db.session.add(self) db.session.commit()
class City(db.Model): __bind_key__ = 'wehomeproperty' id = db.Column(db.Integer(), index=True, primary_key=True) geoid = db.Column(db.String(255), index=True, unique=True) area_geoid = db.Column(db.String(255), db.ForeignKey('area.geoid'), index=True) state_geoid = db.Column(db.String(255), db.ForeignKey('state.geoid'),index=True) zipcodes = db.relationship('Zipcode', backref='city') neighbors = db.relationship('Neighbor', backref='city_') name = db.Column(db.String(255), index=True) lat = db.Column(db.Float()) lng = db.Column(db.Float()) properties = db.Column(JSON) created_at = db.Column(db.DateTime(), default=datetime.datetime.now) updated_at = db.Column(db.DateTime(), default=datetime.datetime.now, onupdate=datetime.datetime.now)
class Object(db.Model): id = db.Column(db.Integer, primary_key=True) object_name = db.Column(db.String(120), nullable=False) object_parent_id = db.Column(db.Integer, nullable=True) object_server_id = db.Column(db.Integer, db.ForeignKey('server.id', ondelete='CASCADE'), nullable=False) object_variables = db.relationship("Variable", backref="object", cascade="all, delete-orphan", lazy='dynamic') def has_child(self): return True if Object.query.filter_by( object_parent_id=self.id) else False def is_parent(self): return True if self.object_parent_id is None else False def get_parent(self): return Object.query.get(self.object_parent_id) def get_child_objects(self): return self.query.filter_by( object_parent_id=self.id) if Object.query.filter_by( object_parent_id=self.id) else False def __repr__(self): return "Object: {}".format(self.object_name)
class TestCaseLog(db.Model): __tablename__ = "test_case_log" test_case_log_id = db.Column(db.Integer, primary_key=True) test_case_id = db.Column(db.ForeignKey('test_case.test_case_id'), index=True) job_id = db.Column(db.ForeignKey('job.job_id'), index=True) execution_status = db.Column(db.SMALLINT, nullable=False) dqi_percentage = db.Column(db.Float(precision=2), nullable=True) execution_log = db.Column(JSON, nullable=False) created_at = db.Column(db.DateTime, default=datetime.now) modified_at = db.Column(db.DateTime, default=datetime.now, index=True) test_cases = db.relationship(TestCase, back_populates='test_case_log', lazy=True) def __init__( self, test_case_id, job_id, execution_status=ExecutionStatus().get_execution_status_id_by_name( "new")): self.test_case_id = test_case_id self.job_id = job_id self.execution_status = execution_status def save_to_db(self): db.session.add(self) db.session.commit()
class ChallengeFollower(db.Model): id = db.Column(db.Integer(), primary_key=True) challenge_instance_id = db.Column(db.Integer(), db.ForeignKey("challenge_instance.id"), nullable=False) challenge_instance = db.relationship('ChallengeInstance') follower_id = db.Column(db.Integer(), db.ForeignKey("user.id"), nullable=False) follower = db.relationship('User') date_joined = db.Column(db.DateTime(), nullable=False) def __init__(self, challenge, follower): self.challenge_instance = challenge self.follower = follower self.date_joined = datetime.datetime.now()
class ToDoListModel(db.Model): __tablename__ = 'todolists' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) todos = db.relationship('ToDoModel', lazy='dynamic') def __init__(self, name): self.name = name def json(self): return { 'id': self.id, 'name': self.name, 'todos': [item.json() for item in self.todos.all()] } @classmethod def find_by_name(cls, name): return cls.query.filter_by(name=name).first() def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) ToDoModel.delete_by_list_id(self.id) db.session.commit()
class TestSuite(db.Model): __tablename__ = "test_suite" test_suite_id = db.Column(db.Integer, primary_key=True) project_id = db.Column(db.ForeignKey('project.project_id'), nullable=False, index=True) owner_id = db.Column(db.ForeignKey('user.user_id'), nullable=False) excel_name = db.Column(db.Text) test_suite_name = db.Column(db.Text, nullable=False) is_deleted = db.Column(db.Boolean, nullable=False, default=False) created_at = db.Column(db.DateTime, default=datetime.now) modified_at = db.Column(db.DateTime, default=datetime.now) test_case = db.relationship("TestCase", back_populates='test_suite', lazy=True, order_by='TestCase.created_at') def __init__(self, project_id, owner_id, excel_name, test_suite_name): self.project_id = project_id self.owner_id = owner_id self.excel_name = excel_name self.test_suite_name = test_suite_name def save_to_db(self): db.session.add(self) db.session.commit()
class User(db.Model, UserMixin): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(32), unique=True, nullable=False) email = db.Column(db.String(128), unique=True, nullable=False) image_file = db.Column(db.String(32), nullable=False, default='default.jpg') password = db.Column(db.String(64), nullable=False) posts = db.relationship('Post', backref='author', lazy=True) def get_reset_password_token(self, expires_in=900): return jwt.encode( { 'reset_password': self.id, 'exp_time': time() + expires_in }, key=ConfigManager.SECRET_KEY, algorithm='HS256').decode('utf-8') @staticmethod def verify_reset_password_token(token): try: id = jwt.decode(token, key=ConfigManager.SECRET_KEY, algorithms=['HS256'])['reset_password'] except: return else: return User.query.get(id) def __repr__(self): return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class User(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) # User authentication information (required for Flask-User) email = db.Column(db.Unicode(255), nullable=False, server_default=u'', unique=True) password = db.Column(db.String(255), nullable=False, server_default='') actiu = db.Column(db.Boolean(), nullable=False, server_default='0') # User information actiu = db.Column('is_active', db.Boolean(), nullable=False, server_default='0') nom = db.Column(db.Unicode(50), nullable=False, server_default=u'') # Relationships roles = db.relationship('Role', secondary='users_roles', backref=db.backref('users', lazy='dynamic')) def __str__(self): return u"Nom : {name}; Email: {email})".format(name=self.nom, email=self.email)
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(120), unique=True, nullable=False) image_file = db.Column(db.String(120), nullable=False, default='default.jpg') password = db.Column(db.String(120), nullable=False) posts = db.relationship('Post', backref='author', lazy=True) #creating user token to reset the user password 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 __repr__(self): return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class ChallengeInstance(db.Model): id = db.Column(db.Integer(), primary_key=True) challenge_id = db.Column(db.Integer, db.ForeignKey("challenge.id"), nullable=False) challenge = db.relationship('Challenge') date_created = db.Column(db.DateTime(), nullable=False) creator_id = db.Column(db.Integer, db.ForeignKey("user.id"), nullable=True) creator = db.relationship('User') def __init__(self, challenge, creator): self.challenge = challenge self.date_created = datetime.datetime.utcnow() self.creator = creator
class Tag(db.Model): __tablename__ = 'Tag' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String, unique=True, nullable=False) photos = db.relationship('Photo', secondary=photo_tags, backref=db.backref('Tag', lazy=True))
class Order(db.Model): __tablename__ = 'order' id = db.Column(db.Integer(), primary_key=True) uuid = db.Column(db.String(40), unique=True, index=True) entries = db.relationship("Entry", back_populates="order", primaryjoin=(id == Entry.order_id)) create_time = db.Column(db.DateTime, default=db.func.now()) description = db.Column(db.Text(), nullable=False) closes_at = db.Column(db.Text(), nullable=False) restaurant_id = db.Column(db.Integer, db.ForeignKey('restaurant.id'), nullable=False) restaurant = db.relationship("Restaurant", foreign_keys=restaurant_id) def __init__(self, description, closes_at, restaurant): self.description = description self.closes_at = closes_at self.restaurant = restaurant self.uuid = str(uuid.uuid4()) def json(self): return { 'id': self.uuid, 'description': self.description, 'closes_at': self.closes_at, 'restaurant_info': self.restaurant.info_json(), 'orders': map(lambda entry: entry.json(), self.entries) } def user_json(self, user_uuid): entry = None for e in self.entries: if e.user_uuid == user_uuid: entry = e return { 'id': self.uuid, 'description': self.description, 'closes_at': self.closes_at, 'restaurant_info': self.restaurant.info_json(), 'order': None if entry is None else entry.json(), 'menu': self.restaurant.menu_json() }
class Score(db.Model): id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(), nullable=True) bars = db.Column(db.Text, nullable=True) tracks = db.relationship('Track', backref='score', cascade="all, delete") def __repr__(self): return f"<Score {self.name}>"
class UserSet(db.Model): __tablename__ = "user_set" id = db.Column(db.Integer(), primary_key=True) workout_id = db.Column(db.Integer(), db.ForeignKey("user_session.id")) reps = db.relationship("UserRep") rest = db.Column(db.Integer()) ordinal = db.Column(db.Integer()) completed = db.Column(db.Boolean()) effort_level = db.Column(db.Integer())
class Vokabel(db.Model): id = db.Column('wort_id', db.Integer, primary_key=True) wort = db.Column(db.String(45)) bedeutung = db.Column(db.String(45)) beispiel = db.Column(db.String(250)) quelle_id = db.Column(db.Integer, db.ForeignKey('quelle.id')) quelle = db.relationship("Quelle", backref=db.backref("Vokabel", lazy=True))
class ChallengeInstanceVote(db.Model): id = db.Column(db.Integer(), primary_key=True) challenge_instance_id = db.Column(db.Integer(), db.ForeignKey("challenge_instance.id"), nullable=False) challenge_instance = db.relationship('ChallengeInstance') votee_id = db.Column(db.Integer, db.ForeignKey("challenge_instance_media.id"), nullable=False) votee = db.relationship( 'ChallengeInstanceMedia' ) #since this is a temporary model, I won't add too many constraits def __init__(self, challenge_instance, votee): self.challenge_instance = challenge_instance self.votee = votee
class UserSession(db.Model): __tablename__ = "user_session" id = db.Column(db.Integer(), primary_key=True) user_id = db.Column(db.Integer(), db.ForeignKey("user.id")) date = db.Column(db.Date()) sets = db.relationship("UserSet") note = db.Column(db.Text()) grip = db.Column(db.String(255)) program = db.Column(db.Integer(), db.ForeignKey("program_template.id"))
class User(db.Model): """docstring for User""" __tablename__ = "users" id = db.Column('user_id', db.Integer, primary_key=True) email = db.Column('email', db.String(80), unique=True) username = db.Column('username', db.String(80), unique=True) password = db.Column('password', db.String(80), nullable=False) auth = db.Column('auth', db.String(300), nullable=False) sync_token = db.Column('sync_token', db.String(150)) events = db.relationship('Event', backref='user', lazy='dynamic') def __init__(self, email, username, password, sync_token, auth): self.email = email self.username = username self.password = password self.sync_token = sync_token self.auth = auth def is_authenticated(self): return True def is_active(self): return True def is_anonymous(self): return False def get_id(self): return unicode(self.id) def __repr__(self): return '<User %r>' % (self.username) # def hash_password(self, password): # self.password_hash = pwd_context.encrypt(password) # def verify_password(self, password): # return pwd_context.verify(password, self.password_hash) def get_id(self): return unicode(self.id) def __repr__(self): return '<User %r>' % self.username @staticmethod def verify_email_password(email, password): # user = User.verify_auth_token(username_or_token) data = User.query.all() print("hey from model", email, password) user = User.query.filter_by(email=email).first() print(user) if user and user.password == password: g.user = user return user else: return None
class ChallengeParticipant(db.Model): id = db.Column(db.Integer(), primary_key=True) challenge_instance_id = db.Column(db.Integer(), db.ForeignKey("challenge_instance.id"), nullable=False) challenge_instance = db.relationship('ChallengeInstance') participant_id = db.Column(db.Integer(), db.ForeignKey("user.id"), nullable=False) participant = db.relationship('User') date_joined = db.Column(db.DateTime(), nullable=False) def __init__(self, challenge, participant): self.challenge_instance = challenge self.participant = participant self.date_joined = datetime.datetime.now()
class Document(db.Model, BlobMixin): __tablename__ = 'documents' id = db.Column(db.Integer, primary_key=True) creat = db.Column(db.DateTime, server_default=db.func.now()) nom = db.Column(db.Unicode(length=255), nullable=False, unique=True) compartit = db.Column(db.Boolean(), nullable=False, server_default='0') clients = db.relationship('User', secondary='users_documents', backref=db.backref('documents', lazy='dynamic')) tipus_id = db.Column(db.Integer(), db.ForeignKey('tipus_document.id')) tipus = db.relationship('TipusDocument', foreign_keys=tipus_id) def __str__(self): return u"nom: {name}; document: {filename})".format( name=self.nom, filename=self.filename) def __lt__(self, other): return self.creat > other.creat
class Item(db.Model): __tablename__ = 'item' category = db.relationship(Category) category_id = db.Column(db.Integer, db.ForeignKey('category.id')) description = db.Column(db.String(1000), nullable=False) id = db.Column(db.Integer, primary_key=True, nullable=False) name = db.Column(db.String(80), nullable=False) timestamp = db.Column(db.DateTime, default=datetime.datetime.utcnow) user = db.relationship(Usercat) user_id = db.Column(db.Integer, db.ForeignKey('usercat.id')) def __init__(self, category_id, description, name, user_id): self.category_id = category_id self.description = description self.name = name self.user_id = user_id def __repr__(self): return '<id {}>'.format(self.id)
class User(db.Model): id = db.Column(db.Integer(), primary_key=True) name = db.Column(db.String(255)) email = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) offers = db.relationship('Offer', backref='user.creator') requests = db.relationship('Request', backref='user.creator') offers_history = db.relationship('Offer', secondary=offers_history_table, backref=db.backref('passenger_list', lazy='dynamic')) def __init__(self, name, email, password): self.email = email self.name = name self.active = True self.password = User.hashed_password(password) @staticmethod def hashed_password(password): return bcrypt.generate_password_hash(password).decode("utf-8") @staticmethod def get_user_with_email_and_password(email, password): user = User.query.filter_by(email=email).first() if user and bcrypt.check_password_hash(user.password, password): return user else: return None @staticmethod def get_users(): users = User.query.all() #users = users.append([User.query.filter([User.requests] > None).all()]) print(users) return { x.id: { 'name': x.name, 'email': x.email + '@marlboro.edu' } for x in users }
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(120), 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 __repr__(self): return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class Photo(db.Model): __tablename__ = 'Photo' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('User.id')) filename = db.Column(db.String, default=None, nullable=True) url = db.Column(db.String, default=None, nullable=True) date_created = db.Column(db.DateTime, default=datetime.utcnow) date_updated = db.Column(db.DateTime, default=datetime.utcnow) caption = db.Column(db.String, default=None, nullable=True) tags = db.relationship('Tag', secondary=photo_tags, lazy='subquery', backref=db.backref('Photo', lazy=True)) likes = db.relationship('Like', backref='Photo', lazy=True) def __init__(self, user_id, filename=None, url=None, caption=None): self.user_id = user_id self.filename = filename self.url = url self.caption = caption
class DbDetail(db.Model): __tablename__ = "dbdetail" db_id = db.Column(INTEGER(unsigned=True), autoincrement=True, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.user_id'), nullable=False) connection_name = db.Column(db.String(80)) db_type = db.Column(db.String(80), nullable=False) db_name = db.Column(db.String(80), nullable=False) db_hostname = db.Column(db.String(128), nullable=False) db_username = db.Column(db.String(80), nullable=False) db_password = db.Column(db.String(256)) # users = db.relationship('User', back_populates='dbdetail', lazy=True) created = db.Column(db.DateTime, default=datetime.datetime.now) def __init__(self, connection_name, db_type, db_name, db_hostname, db_username, db_password, user_id): self.connection_name = connection_name self.db_type = db_type self.db_name = db_name self.db_hostname = db_hostname self.db_username = db_username self.db_password = db_password self.user_id = user_id def save_to_db(self): db.session.add(self) db.session.commit() def get_private_key(password1): salt = b"this is a salt" kdf = PBKDF2(password1, salt, 64, 1000) key = kdf[:32] return key def encrypt(raw): private_key = DbDetail.get_private_key( app.config.get('DB_ENCRYPTION_KEY')) raw = pad(raw) iv = Random.new().read(AES.block_size) cipher = AES.new(private_key, AES.MODE_CBC, iv) return base64.b64encode(iv + cipher.encrypt(raw)) def decrypt(enc): private_key = DbDetail.get_private_key( app.config.get('DB_ENCRYPTION_KEY')) enc = base64.b64decode(enc) iv = enc[:16] cipher = AES.new(private_key, AES.MODE_CBC, iv) return unpad(cipher.decrypt(enc[16:]))
class State(db.Model): __bind_key__ = 'wehomeproperty' id = db.Column(db.Integer(), index=True, primary_key=True) geoid = db.Column(db.String(255), index=True, unique=True) name = db.Column(db.String(255)) name_abbr = db.Column(db.String(255)) lat = db.Column(db.Float()) lng = db.Column(db.Float()) properties = db.Column(JSON) cities = db.relationship('City', backref='state') created_at = db.Column(db.DateTime(), default=datetime.datetime.now) updated_at = db.Column(db.DateTime(), default=datetime.datetime.now, onupdate=datetime.datetime.now)
class ChallengeInstanceMedia(db.Model): id = db.Column(db.Integer(), primary_key=True) data = db.Column(db.Text(), nullable=False) challenge_instance_id = db.Column(db.Integer(), db.ForeignKey("challenge_instance.id"), nullable=False) user_id = db.Column(db.Integer(), db.ForeignKey("user.id"), nullable=True) challenge_instance = db.relationship('ChallengeInstance') user = db.relationship('User') def __init__(self, challenge_instance, user, data): self.challenge_instance = challenge_instance self.user = user self.data = data @staticmethod def get_media(instance_id): challenge_instance_media = ChallengeInstanceMedia.query.filter_by( challenge_instance_id=instance_id) return ChallengeInstanceMediaSchema.dump(challenge_instance_media)