class User(db.Model, UserMixin): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(150), nullable=False) email = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) login_count = db.Column(db.Integer) current_login_ip = db.Column(db.String(255)) current_login_at = db.Column(db.DateTime, default=datetime.utcnow) created_at = db.Column(db.DateTime, default=datetime.utcnow) updated_at = db.Column(db.DateTime, default=datetime.utcnow) posts = db.relationship('Post', backref='author', lazy='dynamic') comments = db.relationship('Comment', backref='author', lazy='dynamic') roles = db.relationship('Role', secondary=role_users, backref=db.backref('users', lazy="dynamic"), cascade="save-update, merge, delete") def __init__(self, email, password=None, *args, **kwargs): super(User, self).__init__(email=email, password=password, *args, **kwargs) if not self.username: self.username = self.email.split("@")[0] if not self.roles: user_role = Role.query.filter(Role.name == 'user').first() self.roles.append(user_role) def __repr__(self): return f'<User #{self.id} {self.email}>'
class User(db.Model): __tablename__ = 'user' id = db.Column(db.Integer, primary_key=True) first_name = db.Column(db.String(32), nullable=False) last_name = db.Column(db.String(32)) password_hash = db.Column(db.String(120)) token = db.Column(db.String(130), nullable=False) email = db.Column(db.String(130), nullable=False, unique=True) contact_number = db.Column(db.String(12)) profile_url = db.Column(db.String(130)) about_me = db.Column(db.Text) city = db.Column(db.String(32)) country = db.Column(db.String(32)) no_goals_added = db.Column(db.Integer) no_goals_completed = db.Column(db.Integer) created_at = db.Column(db.DateTime, default=datetime.now()) updated_at = db.Column(db.DateTime, default=datetime.now()) user_goals = db.relationship('UserGoal', backref="user", cascade="all, delete-orphan", lazy='dynamic') goal = db.relationship('Goal', backref="user", cascade="all, delete-orphan", uselist=False) ug_likes = db.relationship('UserGoalLike', backref=db.backref('user', lazy='joined'), lazy='dynamic', cascade="all, delete, delete-orphan") g_likes = db.relationship('GoalLike', backref=db.backref('user', lazy='joined'), lazy='dynamic', cascade="all, delete, delete-orphan") 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)
class Goal(db.Model): __tablename__ = 'goal' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) name = db.Column(db.String(256), nullable=False) cat_id = db.Column(db.Integer, default=1) image_url = db.Column(db.String(130)) no_added = db.Column(db.Integer, default=1) no_completed = db.Column(db.Integer, default=0) created_at = db.Column(db.DateTime, default=datetime.now()) updated_at = db.Column(db.DateTime, default=datetime.now()) user_goals = db.relationship('UserGoal', backref="goal", cascade="all, delete-orphan", lazy='dynamic') g_likes = db.relationship('GoalLike', backref=db.backref('goal', lazy='joined'), lazy='dynamic', cascade="all, delete, delete-orphan") @property def serialize(self): return { 'id': self.id, 'user_id': self.user_id, 'first_name': self.user.first_name, 'last_name': self.user.last_name, 'name': self.name, 'cat_id': self.cat_id, 'image_url': self.image_url, 'no_added': self.no_added, 'no_completed': self.no_completed, 'created_at': self.created_at, 'updated_at': self.updated_at }
class User(db.Model): user_id = db.Column(db.Integer, primary_key=True, autoincrement=True) first_name = db.Column(db.String(80)) last_name = db.Column(db.String(80)) email = db.Column(db.String(80)) picture = db.Column(db.String(120)) age_range = db.Column(db.String(80)) fb_token = db.Column(db.String(120)) gender = db.Column(db.Integer) reg_date = db.Column(db.DateTime) posts = db.relationship('Post', backref='publisher', lazy='dynamic') subscribed_groups = db.relationship('Group', secondary=subscribe, backref=db.backref('subscribers', lazy='dynamic')) banned_from = db.relationship('Group', secondary=ban, backref=db.backref('banned_users', lazy='dynamic')) admin_of = db.relationship('Group') def __init__(self, first_name, last_name, email, picture, age_range, fb_token, gender): self.first_name = first_name self.last_name = last_name self.email = email self.picture = picture self.age_range = age_range self.fb_token = fb_token self.gender = gender self.reg_date = datetime.now() def __repr__(self): return '<User %r>' % self.user_id def get_subscribed_groups(self, user_id, page=0): # -> group_id [] user = User.query.filter(User.user_id == user_id).first() return [group.group_id for group in user.subscribed_groups] def subscribe_to(self, group_id, user_id, is_submitter): # -> bool subscribe.insert().values(group_id=group_id, user_id=user_id, is_submitter=is_submitter, time=datetime.now()) db.session.commit() return True def ban_user(self, group_id, admin_id, banned_by, is_shadow): # -> bool ban.insert().values(group_id=group_id, admin_id=admin_id, banned_by=banned_by, is_shadow=is_shadow, time=datetime.now()) db.session.commit() return True
class Post(db.Model): post_id = db.Column(db.Integer, primary_key=True, autoincrement=True) message = db.Column(db.String(5000)) url = db.Column(db.String(120)) settings = db.Column(db.SmallInteger) publish_date = db.Column(db.DateTime) publisher_id = db.Column(db.Integer, db.ForeignKey('user.user_id')) group_id = db.Column(db.Integer, db.ForeignKey('group.group_id')) seen_by = db.relationship('User', secondary=seen) comments = db.relationship('Comment', backref='post', lazy='dynamic') #backrefs #publisher -> submitted by #group -> submitted in def __init__(self, post): self.message = post.message self.url = post.url self.settings = post.settings self.publisher_id = post.publisher_id self.group_id = post.group_id self.publish_date = datetime.now() def __repr__(self): return '<Post %r>' % self.post_id def get_hot_feed(self, group_id, page=0): # -> post_id[] group = Group.query.filter(Group.group_id == group_id).first() return [post.post_id for post in group.posts] def get_trending_feed(self, group_id, page=0): # -> post_id[] group = Group.query.filter(Group.group_id == group_id).first() return [post.post_id for post in group.posts] def get_new_feed(self, group_id, page=0): # -> post_id[] group = Group.query.filter(Group.group_id == group_id).first() return [post.post_id for post in group.posts] def get_post(self, post_id): # -> post return Post.query.filter(Post.post_id == post_id).first() def create_post(self, post): # -> post_id temp = Post(post) db.session.add(temp) db.commit() return temp.post_id def get_front_page(self, user_id): # -> post_id [] user = User.query.filter(User.user_id == user_id).first() result = [] for group in user.subscribed_groups: result.append([post.post_id for post in group.posts]) return result
class Venue(db.Model): __tablename__ = 'venues' id = db.Column(db.Integer, primary_key=True, autoincrement=True) name = db.Column(db.String(), nullable=False) city = db.Column(db.String(120)) state = db.Column(db.String(10)) address = db.Column(db.String(120)) phone = db.Column(db.String(30)) image_link = db.Column(db.String(500)) facebook_link = db.Column(db.String(120)) website = db.Column(db.String(120)) seeking_talent = db.Column(db.Boolean, default=False) seeking_description = db.Column(db.String()) genres = db.relationship('Genre', secondary=venue_genre, backref='venues', lazy=True) shows = db.relationship('Show', backref='venue', cascade=['all'], lazy=True) def __repr__(self): return f"<Venue id={self.id} name={self.name}>" def venue_to_dictionary(self): data = { "id": self.id, "name": self.name, "address": self.address, "city": self.city, "state": self.state, "phone": self.phone, "website": self.website, "facebook_link": self.facebook_link, "seeking_talent": self.seeking_talent, "seeking_description": self.seeking_description, "image_link": self.image_link, "genres": [g.description for g in sorted(self.genres, key=lambda a: a.id)] } return data
class User(UserMixin, db.Model): __tablename__ = 'users' id = db.Column(db.Integer, primary_key=True) full_name = db.Column(db.String(30)) username = db.Column(db.String(20), unique=True, nullable=False) password = db.Column(db.Text, nullable=False) access_level = db.Column(db.Integer, db.ForeignKey('access_levels.id'), default=0) favorite_quotes = db.relationship('FavoriteQuote', backref='favorite_quotes') access_level_name = db.relationship('AccessLevel', backref='access_levels')
class User(db.Model): uid = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(32), unique=True) password_hash = db.Column(db.String(144)) timelines = db.relationship('Timeline', backref='owner', lazy='joined') def __init__(self, username, password): self.username = username self.password_hash = generate_password_hash(password, method='sha512') @classmethod def authenticate(cls, username, password): """Authenticates details of a user Parameters ---------- username : str The username of the user to authenticate password : str The password to authenticate with Returns ------- User The authenticated user """ if any(i is None for i in (username, password)): return dict(error='missing fields'), 400 user = cls.query.filter_by(username=username).first() if user is None or not check_password_hash(user.password_hash, password): return dict(error='incorrect credentials or user doesn\'t exist'), 401 else: token = create_access_token(identity=user) return dict(username=user.username, token=token), 200
class Subscription(db.Model): id = db.Column(INTEGER(unsigned=True), primary_key=True) device = db.Column(db.VARCHAR(40), nullable=False) service_id = db.Column(INTEGER(unsigned=True), db.ForeignKey('service.id'), nullable=False) service = db.relationship('Service', backref=db.backref('subscription', lazy='dynamic')) timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow) timestamp_checked = db.Column(db.TIMESTAMP) def __init__(self, device, service): self.device = device self.service = service self.timestamp_checked = datetime.utcnow() - timedelta(minutes=30) def __repr__(self): return '<Subscription %r>' % self.id def messages(self): return Message.query \ .filter_by(service_id=self.service_id) \ .filter(Message.timestamp_created > self.timestamp_checked) def as_dict(self): data = { "uuid": self.device, "service": self.service.as_dict(), "timestamp": int(self.timestamp_created.strftime('%s')), "timestamp_checked": int(self.timestamp_checked.strftime('%s')) } return data
class Users(db.Model, UserMixin): __tablename__ = 'users' # Primary key id = db.Column(db.Integer, primary_key=True) # Columns email = db.Column(db.String(255), unique=True) password = db.Column(db.String(255)) active = db.Column(db.Boolean()) confirmed_at = db.Column(db.DateTime()) roles = db.relationship('Roles', secondary=roles_users, backref=db.backref('users', lazy='dynamic')) # Representation def __repr__(self): return '<id %r>' % self.id # Check if a user email exists @classmethod def check_user(class_, email): Users = class_ # Query for the email user = Users.query.filter_by(email=email).first() # Return true if exists if user: return user else: return False
class Subscription(db.Model): id = db.Column(INTEGER(unsigned=True), primary_key=True) device = db.Column(db.VARCHAR(40), nullable=False) service_id = db.Column(INTEGER(unsigned=True), db.ForeignKey('service.id'), nullable=False) service = db.relationship('Service', backref=db.backref('subscription', lazy='dynamic')) last_read = db.Column(INTEGER(unsigned=True), db.ForeignKey('message.id'), default=0) timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow) timestamp_checked = db.Column(db.TIMESTAMP) def __init__(self, device, service): last_message = Message.query.order_by(Message.id.desc()).first() self.device = device self.service = service self.timestamp_checked = datetime.utcnow() self.last_read = last_message.id if last_message else 0 def __repr__(self): return '<Subscription {}>'.format(self.id) def messages(self): return Message.query \ .filter_by(service_id=self.service_id) \ .filter(Message.id > self.last_read) def as_dict(self): data = { "uuid": self.device, "service": self.service.as_dict(), "timestamp": int((self.timestamp_created - datetime.utcfromtimestamp(0)).total_seconds()), "timestamp_checked": int((self.timestamp_checked - datetime.utcfromtimestamp(0)).total_seconds()) } return data
class Booking(db.Model): __tablename__ = 'mimir_bookings' identifier = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(255), unique=False, nullable=False) start = db.Column(db.DateTime, nullable=False, default=datetime.now) end = db.Column(db.DateTime, nullable=False, default=datetime.now) cell_colour = db.Column(db.String(255), unique=False, nullable=False) timetable_id = db.Column(db.Integer, db.ForeignKey('mimir_timetables.identifier')) timetable = db.relationship('Timetable', back_populates="bookings") created_at = db.Column(db.DateTime, nullable=False, default=datetime.now) updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now) @property def duration(self): return abs(self.end - self.start).total_seconds() / 3600 @property def timetable_name(self): if timetable is not None: return timetable.name return "Not Set" @property def serialize(self): return { 'id': self.identifier, 'booking': self.name, 'timetable': self.timetable.name, 'timetable_id': self.timetable_id, 'start_time': self.start, 'end_time': self.end, 'duration': self.duration, 'cell_colour': self.cell_colour }
class Room(db.Model): __tablename__ = "rooms" id = db.Column("room_id", db.Integer, primary_key=True) info = db.Column("info", db.String(), nullable=True) name = db.Column("name", db.String(50), nullable=False) seats = db.relationship('Seat', back_populates="room", cascade="all, delete") def __init__(self, name, info): self.name = name self.info = info def get_seat_list(self): seat_list = list(map(lambda x: x.to_json(), self.seats)) sorted_seat_list = sorted(seat_list, key=lambda x: x['id']) return sorted_seat_list def to_json(self): return { "id": self.id, "name": self.name, "info": self.info, "seats": { "count": len(self.seats), "seats": self.get_seat_list(), }, } def __str__(self): return str(self.__class__) + ":" + str(self.__dict__)
class Message(db.Model): id = db.Column(INTEGER(unsigned=True), primary_key=True) service_id = db.Column(INTEGER(unsigned=True), db.ForeignKey('service.id'), nullable=False) service = db.relationship('Service', backref=db.backref('message', lazy='dynamic')) text = db.Column(db.TEXT, nullable=False) title = db.Column(db.VARCHAR) level = db.Column(TINYINT, nullable=False, default=0) link = db.Column(db.TEXT, nullable=False, default='') timestamp_created = db.Column(db.TIMESTAMP, default=datetime.utcnow) def __init__(self, service, text, title=None, level=0, link=''): self.service = service self.text = text self.title = title self.level = level self.link = link def __repr__(self): return '<Message %r>' % self.id def as_dict(self): return { "service": self.service.as_dict(), "message": self.text, "title": self.title, "link": self.link, "level": self.level, "timestamp": int(self.timestamp_created.strftime('%s')) }
class Post(db.Model): from models import User, Category __tablename__ = 'posts' id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(140), nullable=False) slug = db.Column(db.String(140), nullable=False, unique=True) text = db.Column(db.Text, nullable=False) photo = db.Column(db.String(255), unique=True) is_published = db.Column(db.Boolean, nullable=False, default=False, server_default='0') user_id = db.Column(db.Integer, db.ForeignKey(User.id, onupdate="CASCADE", ondelete="CASCADE"), nullable=False) category_id = db.Column(db.Integer, db.ForeignKey(Category.id, onupdate="CASCADE", ondelete="CASCADE"), nullable=False) created_at = db.Column(db.DateTime, default=datetime.now()) published_at = db.Column(db.DateTime, default=datetime.now()) tags = db.relationship('Tag', secondary=post_tags, backref=db.backref('posts', lazy="dynamic")) comments = db.relationship('Comment', secondary=post_comments, backref=db.backref('post', lazy="dynamic")) def __init__(self, *args, **kwargs): super(Post, self).__init__(*args, **kwargs) self.generate_slug() def generate_slug(self): if self.title: self.slug = slugify(self.title) def is_owner(self): return self.author == current_user def __repr__(self): return f'<Post #{self.id} {self.title}>'
class Room(db.Model): __tablename__ = 'heimdall_rooms' identifier = db.Column(db.Integer, primary_key=True) room_name = db.Column(db.String(255), unique=False, nullable=False) subnets = db.Column(db.String(255), unique=False, nullable=False) capacity = db.Column(db.Integer, unique=False, nullable=False, default=0) has_availability_map = db.Column(db.Boolean, unique=False, nullable=False, default=False) desks = db.relationship( 'Desk', back_populates='room') ## Link the Room to the desks created_at = db.Column(db.DateTime, nullable=False, default=datetime.now) updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now) def __init__(self, **kwargs): ## Default constructor handling by SQLAlchemy ORM super(Room, self).__init__(**kwargs) ## Custom constructor code self.validateSubnets() @property def serialize(self): return { 'id': self.identifier, 'name': self.room_name, 'subnets': self.subnets, 'capacity': self.capacity, 'number_of_desks': len(self.desks), 'number_of_computers': self.computer_count, 'has_availability_map': self.has_availability_map } @property def computer_count(self): ## Check the Room has desks if self.desks is None: return 0 ## Count the computers computerCount = 0 for desk in self.desks: if desk.computers is not None: computerCount += len(desk.computers) return computerCount def validateSubnets(self): ## Check the subnet is a valid format suppliedSubnets = self.subnets.split( ',') ## Split into each of the supplied subnets for subnet in suppliedSubnets: subnetSections = subnet.split('.') ## Check the subnet was composed of 3 sections, e.g. 192.168.0. Subnets with trailing '.' will also be marked as invalid if len(subnetSections) != 3: self.subnets = "Invalid" for section in subnetSections: ## check the subnet section is not longer than 3 characters if len(section) > 3: self.subnets = "Invalid"
class List(db.Model): __tablename__ = "list" id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.ForeignKey('user.id')) name = db.Column(db.String(128), nullable=False) created_at = db.Column(db.DateTime, default=datetime.now()) updated_at = db.Column(db.DateTime, default=datetime.now()) goals = db.relationship('UserGoal', backref="list", lazy='dynamic')
class Timeline(db.Model): uid = db.Column(db.Integer, primary_key=True) title = db.Column(db.String(32)) owner_id = db.Column(db.Integer, db.ForeignKey('user.uid')) nodes = db.relationship('TimelineNode', backref='timeline', lazy='joined', order_by='TimelineNode.position') @property def next_node(self): return len(self.nodes)
class Character(db.Model): __tablename__ = 'characters' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(30), unique=True, nullable=False) house_id = db.Column(db.Integer, db.ForeignKey('houses.id')) image_url_full = db.Column(db.Text) image_url_thumb = db.Column(db.Text) quotes = db.relationship('Quote', backref='quotes')
class Question(db.Model, JsondModel): __tablename__ = 'questions' external_attrs = ['title', 'prompt'] id = db.Column(db.Integer, primary_key=True) title = db.Column(db.String()) prompt = db.Column(db.Text) responses = db.relationship('Response', backref='question', lazy='dynamic') categories = db.relationship('Category', backref='question', lazy='dynamic') def __init__(self, title, prompt): self.title = title self.prompt = prompt def __repr__(self): return '<id {}>'.format(self.id)
class Desk(db.Model): __tablename__ = 'heimdall_desks' identifier = db.Column(db.Integer, primary_key=True) desk_id = db.Column(db.String(255), unique=False, nullable=False) room_id = db.Column( db.Integer, db.ForeignKey("heimdall_rooms.identifier")) ## Foreign Key to the room room = db.relationship( 'Room', back_populates="desks") ## Link to a Room (many-to-1) computers = db.relationship( 'Computer', back_populates='desk' ) ## Link to a desk to multiple computers (1-to-many) created_at = db.Column(db.DateTime, nullable=False, default=datetime.now) updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now) @property def serialize(self): return { 'id': self.identifier, 'name': self.desk_id, 'room': self.get_room, 'room_id': self.room_id, 'number_of_computers': len(self.computers), 'computers': self.get_computers } @property def get_room(self): if self.room is not None: return self.room.room_name return "Not Set" @property def get_computers(self): if self.computers is None: return [] else: computers = [] for computer in self.computers: computers.append(computer.trimmed_serialize) return computers
class User(db.Model): id = db.Column(db.Integer, primary_key=True) username = db.Column(db.String(80), unique=True, nullable=False) password = db.Column( PasswordType(schemes=['pbkdf2_sha512', ]) ) documents = db.relationship('Document', backref="user", lazy=True) surveydata = db.Column(db.String(5000), nullable=True) current_experiment_index = db.Column(db.Integer, default=0) def __repr__(self): return '<User %r>' % self.username
class Content(db.Model): ## The different fields of the model, these generate the table columns __tablename__ = 'yggdrasil_content' identifier = db.Column(db.Integer, primary_key=True) created_at = db.Column(db.DateTime, nullable=False, default=datetime.now) updated_at = db.Column(db.DateTime, nullable=False, default=datetime.now) name = db.Column(db.String(255), unique=False, nullable=False) carousel_id = db.Column(db.Integer, db.ForeignKey("yggdrasil_carousels.identifier")) carousel = db.relationship('Carousel', back_populates="content") content_type = db.Column(db.String(255), unique=False, nullable=False) content_location = db.Column(db.String(255), unique=False, nullable=False) slide_interval = db.Column(db.Integer, unique=False, nullable=False) # in milliseconds is_enabled = db.Column(db.Boolean, unique=False, nullable=False, default=True) def __init__(self, **kwargs): ## Default constructor handling by SQLAlchemy ORM super(Content, self).__init__(**kwargs) ## Custom constructor code self.validateContentType() ## Serialise the model instance ready for jsonification @property def serialize(self): return { 'id': self.identifier, 'name': self.name, 'carousel': self.carousel_name, 'carousel_id': self.carousel_id, 'type': self.content_type, 'location': self.content_location, 'interval': self.slide_interval, 'is_enabled': self.is_enabled } ## Function for grabbing the name of the carousel this content item is attached to @property def carousel_name(self): if self.carousel is not None: if self.carousel.name is not None: return self.carousel.name return "Not Set" def validateContentType(self): validTypes = ['picture', 'video', 'webpage', 'heimdall', 'mimir'] if self.content_type not in validTypes: self.content_type = 'invalid'
class Seat(db.Model): __tablename__ = "seats" id = db.Column("seat_id", db.Integer, primary_key=True) room_id = db.Column( db.ForeignKey("rooms.room_id"), nullable=False, ) seat_name = db.Column("seat_name", db.String(10), unique=False) room = db.relationship("Room", uselist=False, back_populates="seats") info = db.Column("info", db.String(), nullable=True) application = db.relationship("Application", uselist=False, back_populates="seat") def __init__(self, name, room, info): self.seat_name = name self.room = room self.info = info def to_json(self, refer_user=True): seatDict = { "id": self.id, "name": self.seat_name, "info": self.info, "roomId": self.room.id, } if refer_user: seatDict["user"] = self.application.user.to_json( ) if self.application else None return seatDict def __str__(self): return str(self.__class__) + ":" + str(self.__dict__)
class Author(db.Model): __tablename__ = 'authors' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.Text) books = db.relationship('Book', backref='author', lazy='dynamic') def __init__(self, name): self.name = name def __repr__(self): return 'id:{} name: {}'.format(self.id, self.name)
class Class(db.Model): __tablename__ = 'classes' id = db.Column(db.Integer, primary_key=True) size = db.Column(db.Integer, nullable=False) wod = db.Column(db.Text) type_id = db.Column(db.Integer, db.ForeignKey('class_types.id')) sessions = db.relationship('ClassSession', backref='classes', lazy='dynamic') type = db.relationship("ClassType", primaryjoin='ClassType.id==Class.type_id') def __init__(self, size, wod, type_id): self.size = size self.type_id = type_id self.wod = wod def __str__(self): return "Class"
class ClassSession(db.Model): __tablename__ = "class_sessions" id = db.Column(db.Integer, primary_key=True) class_id = db.Column(db.Integer, db.ForeignKey('classes.id')) dateTime = db.Column(db.Date, nullable=False) coach_id = db.Column(db.Integer, db.ForeignKey('athletes.id')) coach = db.relationship('Athlete', primaryjoin='Athlete.id==ClassSession.coach_id') def __init__(self, dateTime, coach_id): self.coach_id = coach_id self.dateTime = dateTime
class SuccessStory(db.Model): __tablename__ = "successstory" id = db.Column(db.Integer, primary_key=True) user_goal_id = db.Column(db.ForeignKey('usergoal.id')) story = db.Column(db.Text) lat = db.Column(db.Float) long = db.Column(db.Float) date_completed = db.Column(db.DateTime) likes = db.Column(db.Integer, default=0) image_url = db.Column(db.String(130)) video_url = db.Column(db.String(130)) created_at = db.Column(db.DateTime, default=datetime.now()) updated_at = db.Column(db.DateTime, default=datetime.now()) ss_likes = db.relationship('SuccessStoryLike', backref=db.backref('successstory', lazy='joined'), lazy='dynamic', cascade="all, delete, delete-orphan")
class UserGoal(db.Model): __tablename__ = 'usergoal' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer, db.ForeignKey('user.id')) goal_id = db.Column(db.Integer, db.ForeignKey('goal.id')) likes = db.Column(db.Integer, default=0) lat = db.Column(db.Float) long = db.Column(db.Float) date_target = db.Column(db.DateTime) privacy = db.Column(db.SmallInteger) list_id = db.Column(db.ForeignKey('list.id')) created_at = db.Column(db.DateTime, default=datetime.now()) updated_at = db.Column(db.DateTime, default=datetime.now()) ug_likes = db.relationship('UserGoalLike', backref=db.backref('usergoal', lazy='joined'), lazy='dynamic', cascade="all, delete, delete-orphan")
class Category(db.Model): __tablename__ = 'categories' id = db.Column(db.Integer, primary_key=True) name = db.Column(db.String(100), nullable=False) slug = db.Column(db.String(100), nullable=False, unique=True) posts = db.relationship('Post', backref='category', lazy='dynamic') def __init__(self, *args, **kwargs): super(Category, self).__init__(*args, **kwargs) self.slug = slugify(self.name) def __repr__(self): return f'<Category #{self.id} {self.name}>'