class Tags(model):
query = db_session.query_property()
__tablename__ = 'tags'
id = Column('tag_id', UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, unique=True, nullable=False)
name = Column(String(200), unique=True, nullable=False)
description = Column(String(2000), nullable=True)
created_on = Column(DateTime, server_default=func.now())
updated_on = Column(DateTime, server_default=func.now(), server_onupdate=func.now())
def __init__(self, name: str, description: str):
self.name = name
self.description = description
def to_json(self):
return dict(name=self.name, description=self.description)
def __eq__(self, other):
return type(self) is type(other) and self.id == other.id
def __ne__(self, other):
return not self.__eq__(other)
class Agreements(model):
query = db_session.query_property()
__tablename__ = 'agreements'
id = Column('agreement_id',
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
title = Column(String(200), nullable=False)
description = Column(String(64000), nullable=True)
body = Column(String(), nullable=True)
valid_from = Column(DateTime)
valid_to = Column(DateTime)
is_active = Column(Boolean, default=False)
is_required = Column(Boolean, default=False)
created_on = Column(DateTime, server_default=func.now())
updated_on = Column(DateTime,
server_default=func.now(),
server_onupdate=func.now())
def __init__(self, title: str):
self.title = title
def to_json(self):
return dict(name=self.description)
def __eq__(self, other):
return type(self) is type(other) and self.id == other.id
def __ne__(self, other):
return not self.__eq__(other)
class Keywords(model):
query = db_session.query_property()
__tablename__ = 'keywords'
id = Column('keyword_id',
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = Column(String(200), nullable=False)
created_on = Column(DateTime, server_default=func.now())
updated_on = Column(DateTime,
server_default=func.now(),
server_onupdate=func.now())
course_id = Column(UUID(as_uuid=True),
ForeignKey('courses.course_id'),
nullable=False)
course = relationship('Courses', backref='keywords', lazy=True)
def __init__(self, name: str):
self.name = name
def to_json(self):
return dict(name=self.name)
def __eq__(self, other):
return type(self) is type(other) and self.id == other.id
def __ne__(self, other):
return not self.__eq__(other)
class Platforms(model):
query = db_session.query_property()
__tablename__ = 'platforms'
id = Column('platform_id',
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = Column(String(200), unique=True, nullable=False)
created_on = Column(DateTime, server_default=func.now())
updated_on = Column(DateTime,
server_default=func.now(),
server_onupdate=func.now())
def __init__(self, name):
self.name = name
def __eq__(self, other):
return type(self) is type(other) and self.id == other.id
def __ne__(self, other):
return not self.__eq__(other)
class Ratings(model):
query = db_session.query_property()
__tablename__ = 'ratings'
id = Column('rating_id', UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, unique=True, nullable=False)
points = Column(Integer, nullable=False)
created_on = Column(DateTime, server_default=func.now())
updated_on = Column(DateTime, server_default=func.now(), server_onupdate=func.now())
course_id = Column(UUID(as_uuid=True), ForeignKey('courses.course_id'), nullable=False)
course = relationship('Courses', backref='ratings', lazy=True)
user_id = Column(UUID(as_uuid=True), ForeignKey('users.user_id'), nullable=False)
user = relationship('Users', backref="ratings", lazy=True)
def __init__(self, user: Users, course: Courses, points: int):
self.user = user
self.course = course
self.points = points
def to_json(self):
return dict(name=self.points)
def __eq__(self, other):
return type(self) is type(other) and self.id == other.id
def __ne__(self, other):
return not self.__eq__(other)
class UserEvents(model):
query = db_session.query_property()
__tablename__ = 'user_events'
id = Column('user_event_id',
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
log = Column(String(512), unique=False, nullable=False)
meta = Column(JSON, nullable=True)
created_on = Column(DateTime, server_default=func.now())
user_id = Column(UUID(as_uuid=True),
ForeignKey('users.user_id'),
nullable=False)
user = relationship('Users', backref="user_events", lazy=True)
def __init__(self, user: Users, log: str, meta=None):
if meta is None:
meta = {}
self.user = user
self.log = log
self.meta = meta
def __eq__(self, other):
return type(self) is type(other) and self.id == other.id
def __ne__(self, other):
return not self.__eq__(other)
class CoursesHasTags(model):
query = db_session.query_property()
__tablename__ = 'courses_tags'
id = Column('courses_tags_id',
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
tag_id = Column(UUID(as_uuid=True),
ForeignKey('tags.tag_id'),
unique=False)
course_id = Column(UUID(as_uuid=True),
ForeignKey('courses.course_id'),
unique=False)
created_on = Column(DateTime, server_default=func.now())
updated_on = Column(DateTime,
server_default=func.now(),
server_onupdate=func.now())
course = relationship("Courses", backref="tags_courses_tags")
tag = relationship("Tags", backref="courses_courses_tags")
class Releases(model):
query = db_session.query_property()
__tablename__ = 'releases'
id = Column('release_id',
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = Column(String(200), nullable=False)
description = Column(String(2000), nullable=False)
created_on = Column(DateTime, server_default=func.now())
updated_on = Column(DateTime,
server_default=func.now(),
server_onupdate=func.now())
course_id = Column(UUID(as_uuid=True),
ForeignKey('courses.course_id'),
nullable=False)
course = relationship('Courses', backref='releases', lazy=True)
release_type_id = Column(UUID(as_uuid=True),
ForeignKey('release_types.release_type_id'),
nullable=False)
release_type = relationship("ReleaseTypes",
backref=backref("release", lazy="dynamic"))
def __init__(self, name: str, description: str,
release_type: ReleaseTypes):
self.name = name
self.description = description
self.release_type = release_type
def __eq__(self, other):
return type(self) is type(other) and self.id == other.id
def __ne__(self, other):
return not self.__eq__(other)
class Users(model):
query = db_session.query_property()
__tablename__ = 'users'
id = Column('user_id',
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
public_id = Column('public_id',
UUID(as_uuid=True),
default=uuid.uuid4,
unique=True,
nullable=False)
email = Column(String(200), unique=True, nullable=False)
name = Column(String(200), unique=True, nullable=False)
password = Column(String(100))
first_name = Column(String(200))
last_name = Column(String(200))
created_on = Column(DateTime, server_default=func.now())
confirmed = Column(Boolean, nullable=False, default=False)
confirmed_on = Column(DateTime, nullable=True)
agreements = relationship("Agreements", secondary="user_agreements")
def __init__(self, email, name, password):
self.email = email
self.name = name
self.password = sha256_crypt.encrypt(password)
def __eq__(self, other):
return type(self) is type(other) and self.id == other.id
def __ne__(self, other):
return not self.__eq__(other)
class Courses(model):
query = db_session.query_property()
__tablename__ = 'courses'
id = Column('course_id',
UUID(as_uuid=True),
primary_key=True,
default=uuid.uuid4,
unique=True,
nullable=False)
name = Column(String(200), nullable=False)
created_on = Column(DateTime, server_default=func.now())
updated_on = Column(DateTime,
server_default=func.now(),
server_onupdate=func.now())
platform_id = Column(UUID(as_uuid=True),
ForeignKey('platforms.platform_id'),
nullable=False)
platform = relationship("Platforms",
backref=backref("courses", lazy="dynamic"))
publisher_id = Column(UUID(as_uuid=True),
ForeignKey('publishers.publisher_id'),
nullable=False)
publisher = relationship("Publishers",
backref=backref("courses", lazy="dynamic"))
tags = relationship("Tags", secondary="courses_tags")
def __init__(self, name):
self.name = name
def __eq__(self, other):
return type(self) is type(other) and self.id == other.id
def __ne__(self, other):
return not self.__eq__(other)