class Beer(db.Model): """Beer object, takes care of everything you would want to know about a specific beer.""" # Attributes specific to this particular beer id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) abv = db.Column(db.Float) photo = db.Column(db.String(200)) special_ingredient = db.Column(db.String(250)) # Relationships to other models genre_id = db.Column(db.Integer, db.ForeignKey('genre.id')) genre = db.relationship('Genre', backref = db.backref('beers', lazy='dynamic')) brewery_id = db.Column(db.Integer, db.ForeignKey('brewery.id')) brewery = db.relationship('Brewery', backref = db.backref('beers', lazy='dynamic')) def __init__(self, name, abv, photo, special_ingredient, genre, brewery): self.name = name self.abv = abv self.photo = photo self.special_ingredient = special_ingredient self.genre = genre self.brewery = brewery def __repr__(self): return '<Beer %r>' % self.name
class Rating(db.Model): """Rating object for a beer, from a user.""" id = db.Column(db.Integer, primary_key=True) score = db.Column(db.Integer) scale = db.Column(db.Integer) notes = db.Column(db.Text) session_beer = db.Column(db.Integer) # Relationships to other models user_id = db.Column(db.Integer, db.ForeignKey('user.id')) user = db.relationship('User', backref = db.backref('user', lazy='dynamic')) beer_id = db.Column(db.Integer, db.ForeignKey('beer.id')) beer = db.relationship('Beer', backref = db.backref('beer', lazy='dynamic')) def __init__(self, score, scale, notes, session_beer, user, beer): self.score = score self.scale = scale self.notes = notes self.session_beer = session.beer self.user = user self.beer = beer def __repr__(self): return '<Rating %r>' % (self.score + '/' + self.scale)
class Vote(db.Model, TimestampMixin): __tablename__ = 'votes' id = db.Column(db.Integer, primary_key=True, autoincrement=True) video_id = db.Column(db.Integer, db.ForeignKey('videos.id')) video = db.relationship('Video', backref=db.backref('votes', uselist=True, cascade='delete,all')) user_id = db.Column(db.Integer, db.ForeignKey('users.id')) user = db.relationship('User', backref=db.backref('votes', uselist=True, cascade='delete,all')) status = db.Column(db.String(50)) def __init__(self, *args, **kwargs): super(Vote, self).__init__(*args, **kwargs)
class Usercontent(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.Integer, db.ForeignKey('user.username', ondelete='CASCADE')) user = db.relationship('User', backref=db.backref('usercontent_set')) content = db.Column(db.Text(), nullable=False) create_date = db.Column(db.DateTime(), nullable=False) modify_date = db.Column(db.DateTime(), nullable=True) filename = db.Column(db.String(200), nullable=False) voter = db.relationship('User', secondary=usercontent_like_voter, backref=db.backref('usercontent_voter_set'))
class Org(db.Model): __tablename__ = 'orgs' id = db.Column('id', db.Integer(), primary_key=True, autoincrement=True) name = db.Column('name', db.String(), nullable=False) en_name = db.Column('en_name', db.String()) head = db.Column('head', db.String()) parent_id = db.Column('parent_id', db.Integer, db.ForeignKey('orgs.id')) children = db.relationship('Org', backref=db.backref('parent', remote_side=[id])) strategies = db.relationship('Strategy', backref=db.backref('org')) def __repr__(self): return self.name
class Post(db.Model): id = db.Column(db.Integer, primary_key=True) subject = db.Column(db.String(200), nullable=False) content = db.Column(db.Text(), nullable=False) create_date = db.Column(db.DateTime(), nullable=False) modify_date = db.Column(db.DateTime(), nullable=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='CASCADE'), nullable=False) # user 속성은 Post모델에서 계정모델(User)을 참조하기 위해서 추가된 속성으로 post.user.username과 같이 사용된다. user = db.relationship('User', backref=db.backref('post_set')) voter = db.relationship('User', secondary=post_voter, backref=db.backref('post_voter_set'))
class SubjectModel(db.Model): __tablename__ = 'subjects' p_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), unique=True, nullable=False) code = db.Column(db.String(120), unique=True, nullable=False) class_id = db.Column(db.Integer, db.ForeignKey('classes.p_id'), nullable=False) department_id = db.Column(db.Integer, db.ForeignKey('departments.p_id'), nullable=False) classes = db.relationship("ClassModel", backref=db.backref("std_class", uselist=False)) departmentes = db.relationship("DepartmentModel", backref=db.backref("std_departments", uselist=False)) def save_to_db(self): db.session.add(self) db.session.commit() def db_to_delete(self): db.session.delete(self) db.session.commit() def db_to_commit(self): db.session.commit() #FOR CONVERT DATA INTO JSON FORMAT @staticmethod def to_json(data): return { 'name': data.name, 'code': data.code, 'class': data.class_id, 'department': data.department_id } @classmethod def find_by_id(cls, p_id): return cls.query.filter_by(p_id=p_id).first() @classmethod def return_all(cls): return { 'subjects': list(map(lambda x: self.to_json(x), SubjectModel.query.all())) }
class Reply(db.Model): id = db.Column(db.Integer, primary_key=True) post_id = db.Column(db.Integer, db.ForeignKey('post.id', ondelete='CASCADE')) post = db.relationship('Post', backref=db.backref('reply_set')) content = db.Column(db.Text(), nullable=False) create_date = db.Column(db.DateTime(), nullable=False) modify_date = db.Column(db.DateTime(), nullable=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='CASCADE'), nullable=False) user = db.relationship('User', backref=db.backref('reply_set')) voter = db.relationship('User', secondary=reply_voter, backref=db.backref('reply_voter_set'))
class Users_twitter(UserMixin ,db.Model): """this is the registering a new user""" id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80)) username = db.Column(db.String(30)) password = db.Column(db.String()) joined_on = db.Column(db.Date) profile_image= db.Column(db.String()) user=db.relationship("Posts", backref='this_user') # this is a query and it returns allm people that the curent user is following::: soo basically the cureent user is on the left of the table while\ # his/her follwers are on the right handside of the table following = db.relationship("Users_twitter", secondary="follower_followee_jk", primaryjoin=(followers.c.me_user_id_follower==id), secondaryjoin=(followers.c.followee_id_followee==id), backref=db.backref("followers", lazy="dynamic"), lazy="dynamic") # # this query returns all peape that follw the current user followed_by = db.relationship("Users_twitter", secondary=followers, primaryjoin=(followers.c.followee_id_followee==id), secondaryjoin=(followers.c.me_user_id_follower==id), backref=db.backref("poeple_following_me", lazy="dynamic"), lazy="dynamic" ) # function to commit tothe db def create(self): db.session.add(self) db.session.commit() # checking password and username @classmethod def pass_username_check (cls,username, password): username_check = cls.query.filter_by(username=username).first() if username_check and check_password_hash(username_check.password, password): return True else: return False
class CourseModel(db.Model): __tablename__ = 'course' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(255), nullable=False, unique=True) # Relationships students = db.relationship('StudentModel', backref='course', lazy='select', cascade='all, delete-orphan') classrooms = db.relationship('ClassroomModel', backref='course', lazy='select', cascade='all, delete-orphan') subjects = db.relationship('SubjectModel', secondary=course_subject, backref=db.backref('course', lazy='select')) def __init__(self, name: str): self.name = name def __repr__(self): return f'<CourseModel {self.name}>'
class Content(db.Model): __tablename__ = "content" content_id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(), nullable=False) genre = db.Column(db.String()) year = db.Column(db.Integer) groups = db.relationship("Group", secondary=group_content, backref=db.backref("contents")) profiles = db.relationship("Profile", secondary=unrecommend, backref=db.backref("contents")) def __repr__(self): return f"<Content {self.content_id}>"
class Beam(db.Model): id = db.Column(db.Integer, primary_key=True) tag = db.Column(db.String, unique=True) wall_tag = db.Column(db.String(10)) category_id = db.Column(db.Integer, db.ForeignKey('category.id')) category = db.relationship('Category', backref=db.backref('caregory', lazy=True)) width = db.Column(db.Float) depth = db.Column(db.Float) length = db.Column(db.Float) amount = db.Column(db.Integer) timestamp = db.Column(db.String, default=time.ctime()) def __init__(self, doc_id, tag, wall_tag, width, depth, length, amount, category, top_bar, mid_bar, bot_bar, stirup, stirup_spacing, amt_top, amt_mid, amt_bot): self.tag = tag self.wall_tag = wall_tag self.width = width self.length = length self.depth = depth self.amount = amount def __repr__(self): return '<Structural Member Beam {}'.format(self.tag)
class User(db.Model, UserMixin): id = db.Column(db.Integer(), primary_key=True) username = db.Column(db.String(255)) email = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean(), default=True) roles = db.relationship('Role', secondary=user_role_link, backref=db.backref('related_user', lazy='dynamic')) searchphrases = db.relationship('Theme', secondary=user_theme_link, backref=db.backref('related_user', lazy='dynamic')) def __repr__(self): return '<{}>'.format(self.username)
class ProjectModel(db.Model): __tablename__ = 'projects' projectID = db.Column(db.Integer, primary_key=True, autoincrement=True) project_name = db.Column(db.String(255), unique=True, nullable=False) project_manager = db.Column(db.String(255), unique=True, nullable=False) tasks = db.relationship('TaskModel', backref=db.backref('projects')) def __init__(self, project_name, project_manager): self.project_name = project_name self.project_manager = project_manager def get_id(self): return self.projectID def save_to_db(self): db.session.add(self) db.session.commit() def delete_from_db(self): db.session.delete(self) db.session.commit() @classmethod def find_by_projectID(cls, projectID): return cls.query.filter_by(projectID=projectID).first() @classmethod def find_by_project_name(cls, project_name): return cls.query.filter_by(project_name=project_name)
class QuizModel(db.Model): __tablename__ = 'quiz' id = db.Column(db.Integer, primary_key=True, autoincrement=True) start_date = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) final_date = db.Column(db.DateTime, nullable=False) num_of_questions = db.Column(db.Integer, nullable=False, default=1) grade = db.Column(db.Float, nullable=False, default=0) # Relationships subject_id = db.Column(db.Integer, db.ForeignKey('subject.id'), nullable=False) professor_id = db.Column(db.String(11), db.ForeignKey('professor.id'), nullable=False) questions = db.relationship('QuestionModel', secondary=quiz_question, lazy='select', backref=db.backref('quiz', lazy='select')) def __init__(self, start_date: datetime, final_date: datetime, num_of_questions: int, grade: float, subject_id: int, professor_id: str): self.start_date = start_date self.final_date = final_date self.num_of_questions = num_of_questions self.grade = grade self.subject_id = subject_id self.professor_id = professor_id
class PurchaseTransfer(db.Model): """ A record of a purchase being transferred from one user to another. """ __tablename__ = 'purchase_transfer' id = db.Column(db.Integer, primary_key=True) purchase_id = db.Column(db.Integer, db.ForeignKey('purchase.id'), nullable=False) to_user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) from_user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False) timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) purchase = db.relationship(Purchase, backref=db.backref("transfers", cascade="all")) def __init__(self, purchase, to_user, from_user): if to_user.id == from_user.id: raise PurchaseTransferException( '"From" and "To" users must be different.') super().__init__(purchase=purchase, to_user_id=to_user.id, from_user_id=from_user.id) def __repr__(self): return "<Purchase Transfer: %s from %s to %s on %s>" % ( self.ticket_id, self.from_user_id, self.to_user_id, self.timestamp)
class User(AuditableMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) login = db.Column(db.String(255), unique=True, nullable=False) password = db.Column(db.String(300)) email = db.Column(db.Unicode(300)) fullname = db.Column(db.Unicode(255), default=u'') last_sign_in = db.Column(db.DateTime) status = db.Column(db.String(1), default=ACTIVE_USER, nullable=False) roles = db.relationship(Role, secondary='users_roles', lazy='joined', backref=db.backref('users', lazy='dynamic')) def __init__(self, login, password=None, **kwargs): self.login = to_unicode(login) self.password = password kwargs.setdefault('fullname', u'') db.Model.__init__(self, **kwargs) @classmethod def by_login(cls, login): login = to_unicode(login) return db.query(cls).filter(cls.login == login).first() @property def is_active(self): """Returns `True` if the user is active.""" return self.status == ACTIVE_USER def add_role(self, name): """Adds a role (by name) to the user.""" role = Role.by_name(name) if not role: role = Role(name) db.add(role) if not role in self.roles: self.roles.append(role) def remove_role(self, name): """Remove a role (by name) from the user.""" role = Role.by_name(name) if not role: return if role in self.roles: self.roles.remove(role) def __repr__(self): return '<%s %s (%s)>' % (self.__class__.__name__, self.fullname.encode('utf8') or '?', self.login.encode('utf8'))
class Volunteer(db.Model): id = db.Column(db.Integer, primary_key=True) fname = db.Column(db.String(80)) lname = db.Column(db.String(100)) phone_numbers = db.relationship('PhoneNumber', lazy='subquery', backref=db.backref('volunteer', lazy=True)) areas = db.relationship('Area', secondary=areas_volunteers, lazy='subquery', backref=db.backref('volunteers', lazy=True)) species = db.relationship('FosterSpecies', secondary=volunteers_species, lazy='subquery', backref=db.backref('volunteers', lazy=True)) last_contacted = db.Column(db.DateTime, index=True, default=datetime.utcnow) active = db.Column(db.Boolean, default=True) black_listed = db.Column(db.Boolean, default=False) notes = db.Column(db.String(500), nullable=True) def __repr__(self): return '<Volunteer %r>' % self.fname+' '+self.lname
class User(UserMixin, db.Model): """ User model for reviewers. """ __tablename__ = 'user' id = Column(Integer, autoincrement=True, primary_key=True) active = Column(Boolean, default=True) username = Column(String(200), unique=True) email = Column(String(200), unique=True) password = Column(String(200), default='') admin = Column(Boolean, default=False) poweruser = Column(Boolean, default=False) about_me = db.Column(db.String(140)) register_in = db.Column(db.DateTime, default=datetime.now) last_seen = db.Column(db.DateTime, default=datetime.now) ratings = db.relationship('Rating', backref='user') reviews = db.relationship('Review', backref='user') lists = db.relationship('List', backref='user') followed = db.relationship('User', secondary=followers, primaryjoin=(followers.c.follower_id == id), secondaryjoin=(followers.c.followed_id == id), backref=db.backref('followers', lazy='dynamic'), lazy='dynamic') def is_active(self): """ Returns if user is active. """ return self.active def is_admin(self): """ Returns if user is admin. """ return self.admin def avatar(self, size): digest = md5(self.email.lower().encode('utf-8')).hexdigest() return 'https://www.gravatar.com/avatar/{}?d=identicon&s={}'.format( digest, size) def follow(self, user): if not self.is_following(user): self.followed.append(user) def unfollow(self, user): if self.is_following(user): self.followed.remove(user) def is_following(self, user): return self.followed.filter( followers.c.followed_id == user.id).count() > 0 def followed_review(self): followed = Review.query.join( followers, (followers.c.followed_id == Review.user_id)).filter( followers.c.follower_id == self.id) own = Review.query.filter_by(user_id=self.id) return followed.union(own).order_by(Review.timestamp.desc())
class Area(db.Model): area = db.Column(db.String(80), primary_key=True) # OneToMany connection with Clinic. Connection with Volunteer is ManyToMany and defined with helper table clinics = db.relationship('Clinic', backref=db.backref('areas', lazy='subquery'), lazy=True, ) def __repr__(self): return self.area
class Guides(db.Model): id = db.Column(db.Integer, primary_key=True, nullable=False) name = db.Column(db.String(100)) done = db.Column(db.Boolean, default=False, index=True) info = db.Column(db.PickleType()) time_lapse = db.Column(db.String(50)) doc_id = db.Column(db.Integer, db.ForeignKey('doctor.id')) patients = db.relationship('User', backref=db.backref('guides'), secondary=patients) @staticmethod def insert_guides(): guides = { "Pain Medication": ['Acetaminophen (Tylenol)', 'hours=4'], "Zinc Supplement": ['Cold-Eeze lozenges', 'hours=4'], "Vitamin C": ['Vitamin-C', 'days=1'] } for g in guides: guide = Guides.query.filter_by(name=g).first() if guide is None: guide = Guides(name=g, info=guides[g][0], time_lapse=guides[g][1]) db.session.add(guide) db.session.commit()
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), unique=False, nullable=False, default="default.jpg") password = db.Column(db.String(60), nullable=False) posts = db.relationship('Post', backref=db.backref('author', lazy=True)) def get_reset_token(self, expire_sec=1800): s = Serializer(app.config['SECRET_KEY'], expire_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'] return User.query.get(user_id) except: return None def __repr__(self): return f"User('{self.username}', '{self.email}', '{self.image_file}')"
class SurveyQuestion(db.Model): __tablename__ = 'survey_questions' id = db.Column(db.Integer, primary_key=True) cid = db.Column(db.Integer, db.ForeignKey('survey_categories.id')) category = db.relationship('SurveyCategory', backref=db.backref('questions', lazy='dynamic')) question = db.Column(db.String(128), nullable=False) year = db.Column(db.String(4), nullable=False)
class SurveyAnswer(db.Model): __tablename__ = 'survey_answers' id = db.Column(db.Integer, primary_key=True) question_id = db.Column(db.String(128), nullable=False) year = db.Column(db.String(4), nullable=False) qid = db.Column(db.Integer, db.ForeignKey('survey_questions.id')) question = db.relationship('SurveyQuestion', backref=db.backref('answers', lazy='dynamic'))
class StudentCheckInRecord(db.Model): __tablename__ = 'student_check_in_records' id = db.Column('id', db.Integer(), primary_key=True) stud_id = db.Column('stud_id', db.ForeignKey('students.id')) student = db.relationship('Student', backref=db.backref('check_in_records')) classchk_id = db.Column('classchk_id', db.Integer(), db.ForeignKey('class_check_in.id'), nullable=False) classchk = db.relationship('ClassCheckIn', backref=db.backref('student_records')) check_in_time = db.Column('checkin', db.DateTime(timezone=True), nullable=False) check_in_status = db.Column('status', db.String()) elapsed_mins = db.Column('elapsed_mins', db.Integer())
class District(db.Model): __tablename__ = 'districts' id = db.Column('id', db.Integer(), primary_key=True) name = db.Column('name', db.String(40), nullable=False) code = db.Column('code', db.String(), nullable=False) province_id = db.Column(db.Integer(), db.ForeignKey('provinces.id')) subdistricts = db.relationship('Subdistrict', backref=db.backref('district'))
class Products(db.Model): __tablename__ = 'products' products_id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(80), nullable=False) group = db.Column(db.String(30), nullable=False) stock_quantity = db.Column(db.Integer, default=0) price = db.Column(db.Integer, default=0) ordering = db.relationship('Invoices', secondary=orders, backref=db.backref('invoicing'), lazy='dynamic') product_qty = db.relationship('Quantities', backref='product', lazy=True)
class Comment(db.Model): id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id', ondelete='CASCADE'), nullable=False) user = db.relationship('User', backref=db.backref('comment_set')) content = db.Column(db.Text(), nullable=False) create_date = db.Column(db.DateTime(), nullable=False) modify_date = db.Column(db.DateTime(), nullable=True) usercontent_id = db.Column(db.Integer, db.ForeignKey('usercontent.id', ondelete='CASCADE'), nullable=True) usercontent = db.relationship('Usercontent', backref=db.backref('comment_set')) voter = db.relationship('User', secondary=comment_like_voter, backref=db.backref('comment_voter_set'))
class Refund(db.Model): __versioned__ = {} __tablename__ = "refund" id = db.Column(db.Integer, primary_key=True) payment_id = db.Column(db.Integer, db.ForeignKey("payment.id"), nullable=False) provider = db.Column(db.String, nullable=False) amount_int = db.Column(db.Integer, nullable=False) timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) purchases = db.relationship("Purchase", backref=db.backref("refund", cascade="all")) __mapper_args__ = {"polymorphic_on": provider} def __init__(self, payment, amount): self.payment_id = payment.id self.payment = payment self.amount = amount @classmethod def get_export_data(cls): if cls.__name__ == "Refund": # Export stats for each refund type separately return {} purchase_counts = (cls.query.outerjoin(cls.purchases).group_by( cls.id).with_entities(func.count("Ticket.id"))) data = { "public": { "refunds": { "counts": { "timestamp_week": export_intervals(cls.query, cls.timestamp, "week", "YYYY-MM-DD"), "purchases": bucketise(purchase_counts, [0, 1, 2, 3, 4]), "amounts": bucketise( cls.query.with_entities(cls.amount_int / 100), [0, 10, 20, 30, 40, 50, 100, 150, 200], ), } } }, "tables": ["refund"], } return data @property def amount(self): return Decimal(self.amount_int) / 100 @amount.setter def amount(self, val): self.amount_int = int(val * 100)
class Refund(db.Model): __versioned__ = {} __tablename__ = 'refund' id = db.Column(db.Integer, primary_key=True) payment_id = db.Column(db.Integer, db.ForeignKey('payment.id'), nullable=False) provider = db.Column(db.String, nullable=False) amount_int = db.Column(db.Integer, nullable=False) timestamp = db.Column(db.DateTime, nullable=False, default=datetime.utcnow) purchases = db.relationship('Purchase', backref=db.backref('refund', cascade='all')) __mapper_args__ = {'polymorphic_on': provider} def __init__(self, payment, amount): self.payment_id = payment.id self.payment = payment self.amount = amount @classmethod def get_export_data(cls): if cls.__name__ == 'Refund': # Export stats for each refund type separately return {} purchase_counts = cls.query.outerjoin(cls.purchases).group_by( cls.id).with_entities(func.count('Ticket.id')) data = { 'public': { 'refunds': { 'counts': { 'timestamp_week': export_intervals(cls.query, cls.timestamp, 'week', 'YYYY-MM-DD'), 'purchases': bucketise(purchase_counts, [0, 1, 2, 3, 4]), 'amounts': bucketise( cls.query.with_entities(cls.amount_int / 100), [0, 10, 20, 30, 40, 50, 100, 150, 200]), }, }, }, 'tables': ['refund'], } return data @property def amount(self): return Decimal(self.amount_int) / 100 @amount.setter def amount(self, val): self.amount_int = int(val * 100)