class Video(db.Model):
id = db.Column(db.Integer, primary_key=True)
site = db.Column(db.Text())
key = db.Column(db.Text())
type = db.Column(db.Text())
movie_id = db.Column(db.Integer, db.ForeignKey('movie.id'))
name = db.Column(db.Text())
iso_639_1 = db.Column(db.String(2))
class Character(db.Model):
id = db.Column(db.Integer, primary_key=True)
character_name = db.Column(db.Text())
actor_name = db.Column(db.Text())
# M : 1
actor_id = db.Column(db.Integer(), db.ForeignKey('actor.id'))
actor = db.relationship('Actor', backref='roles')
profile_path = db.Column(db.Text())
order = db.Column(db.Integer())
movie_id = db.Column(db.Integer(), db.ForeignKey('movie.id'))
cast_id = db.Column(db.Integer())
credit_id = db.Column(db.Text())
class SettingModel(db.Model):
__tablename__: str = "setting"
key: db.Column = db.Column(db.String(255), primary_key=True, unique=True)
value: db.Column = db.Column(db.Text(500000), nullable=False)
@property
def serialize(self):
dict = self.__dict__
key = '_sa_instance_state'
if key in dict:
del dict[key]
return dict
@staticmethod
def create(key: str, value: str) -> 'SettingModel':
setting = SettingModel(key=key, value=value)
db.session.add(setting)
db.session.commit()
return setting
class Actor(db.Model):
id = db.Column(db.Integer(), primary_key=True) # 1-1 w/ api
query_class = ActorQuery
search_vector = db.Column(TSVectorType('name'))
biography = db.Column(db.Text())
birthday = db.Column(db.Date())
deathday = db.Column(db.Date())
homepage = db.Column(db.Text())
name = db.Column(db.Text())
place_of_birth = db.Column(db.Text())
profile_path = db.Column(db.Text())
imdb_id = db.Column(db.Text())
def get_actor_metadata(self):
ret = dict()
ret['biography'] = self.biography
ret['birthday'] = self.birthday
ret['deathday'] = self.deathday
ret['homepage'] = self.homepage
ret['name'] = self.name
ret['place_of_birth'] = self.place_of_birth
ret['profile_path'] = self.profile_path
ret['imdb_id'] = self.imdb_id
return ret
class Site(db.Model):
__tablename__ = "site"
__table_args__ = {"useexisting": True}
nid = db.Column(db.Integer, primary_key=True)
site_name = db.Column(db.String(64), unique=True)
root_path = db.Column(db.String(256))
bind_domain = db.Column(db.String(256))
status = db.Column(db.Boolean, default=1)
note = db.Column(db.Text(), nullable=True)
created = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
def to_json(self):
json_site = {
"nid": self.nid,
"site_name": self.site_name,
"root_path": self.root_path,
"bind_domain": self.bind_domain,
"status": self.status,
"status_text": ("开启" if (self.status) else "关闭"),
"note": self.note,
"created": self.created.strftime("%Y-%m-%d %H:%M:%S")
}
return json_site
def add(self):
db.session.add(self)
return session_commit()
@classmethod
def delete(cls, nid):
cls.query.filter_by(nid=nid).delete()
return session_commit()
@classmethod
def update(cls, nid, update_dict):
cls.query.filter_by(nid=nid).update(update_dict)
return session_commit()
@classmethod
def get(cls, nid):
return cls.query.filter_by(nid=nid).first()
@classmethod
def search(cls, extra, bind_domain, page, num):
sites_temp = cls.query.filter_by(**extra)
if bind_domain:
sites_temp = sites_temp.filter(
cls.bind_domain.contains(bind_domain))
return sites_temp.paginate(page, num, error_out=False)
class Mysql(db.Model):
__tablename__ = "mysql"
__table_args__ = {"useexisting": True}
nid = db.Column(db.Integer, primary_key=True)
mysql_user = db.Column(db.String(64))
mysql_name = db.Column(db.String(64))
mysql_passwd = db.Column(db.String(256))
accept = db.Column(db.String(64), default="localhost")
status = db.Column(db.Boolean, default=1)
note = db.Column(db.Text(), nullable=True)
created = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
def to_json(self):
json_mysql = {
"nid": self.nid,
"mysql_user": self.mysql_user,
"mysql_name": self.mysql_name,
"mysql_passwd": self.mysql_passwd,
"accept": self.accept,
"status": self.status,
"note": self.note,
"created": self.created.strftime("%Y-%m-%d %H:%M:%S")
}
return json_mysql
def add(self):
db.session.add(self)
return session_commit()
@classmethod
def delete(cls, nid):
cls.query.filter_by(nid=nid).delete()
return session_commit()
@classmethod
def update(cls, nid, update_dict):
cls.query.filter_by(nid=nid).update(update_dict)
return session_commit()
@classmethod
def get(cls, nid):
return cls.query.filter_by(nid=nid).first()
@classmethod
def search(cls, extra, page, num):
return cls.query.filter_by(**extra).paginate(page,
num,
error_out=False)
class Ftp(db.Model):
__tablename__ = "ftp"
__table_args__ = {"useexisting": True}
nid = db.Column(db.Integer, primary_key=True)
ftp_user = db.Column(db.String(64), unique=True)
ftp_passwd = db.Column(db.String(256))
ftp_path = db.Column(db.String(256))
status = db.Column(db.Boolean, default=1)
note = db.Column(db.Text(), nullable=True)
created = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
def to_json(self):
json_ftp = {
"nid": self.nid,
"ftp_user": self.ftp_user,
"ftp_passwd": self.ftp_passwd,
"ftp_path": self.ftp_path,
"status": self.status,
"status_text": ("开启" if (self.status) else "关闭"),
"note": self.note,
"created": self.created.strftime("%Y-%m-%d %H:%M:%S")
}
return json_ftp
def add(self):
db.session.add(self)
return session_commit()
@classmethod
def delete(cls, nid):
cls.query.filter_by(nid=nid).delete()
return session_commit()
@classmethod
def update(cls, nid, update_dict):
cls.query.filter_by(nid=nid).update(update_dict)
return session_commit()
@classmethod
def get(cls, nid):
return cls.query.filter_by(nid=nid).first()
@classmethod
def search(cls, extra, page, num):
return cls.query.filter_by(**extra).paginate(page,
num,
error_out=False)
class CrawledDataListEntity(db.Model):
__tablename__ = 'CrawledDataListentity'
cid = db.Column(db.String(255), primary_key=True)
content = db.Column(db.Text())
timestamp = db.Column(db.Float())
def __repr__(self):
return '<CrawledDataListEntity {0} {1} {2}>'.format(self.cid, self.content, str(self.timestamp))
def __eq__(self, other):
if isinstance(other, CrawledDataListEntity):
return self.cid == other.cid and \
self.content == other.content and \
self.timestamp == other.timestamp
return False
class Soft(db.Model):
__tablename__ = "soft"
__table_args__ = {"useexisting": True}
nid = db.Column(db.Integer, primary_key=True)
soft_name = db.Column(db.String(64))
soft_ver = db.Column(db.String(64))
soft_desc = db.Column(db.Text(), nullable=True)
is_install = db.Column(db.Integer, default=0)
created = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
def to_json(self):
json_soft = {
"nid": self.nid,
"soft_name": self.soft_name,
"soft_ver": self.soft_ver,
"soft_desc": self.soft_desc,
"is_install": self.is_install,
"created": self.created.strftime("%Y-%m-%d %H:%M:%S")
}
return json_soft
def add(self):
db.session.add(self)
return session_commit()
@classmethod
def delete(cls, nid):
cls.query.filter_by(nid=nid).delete()
return session_commit()
@classmethod
def update(cls, nid, update_dict):
cls.query.filter_by(nid=nid).update(update_dict)
return session_commit()
@classmethod
def get(cls, nid):
return cls.query.filter_by(nid=nid).first()
@classmethod
def search(cls, extra, page, num):
return cls.query.filter_by(**extra).paginate(page,
num,
error_out=False)
class Movie(db.Model):
id = db.Column(db.Integer, primary_key=True)
query_class = MovieQuery
search_vector = db.Column(TSVectorType('title'))
# Movie Metadata
title = db.Column(db.Text())
status = db.Column(db.Text())
budget = db.Column(db.BigInteger())
imdb_id = db.Column(db.Text())
revenue = db.Column(db.BigInteger())
backdrop_path = db.Column(db.Text())
poster_path = db.Column(db.Text())
adult = db.Column(db.Boolean, default=False)
original_language = db.Column(db.Text())
overview = db.Column(db.Text())
release_date = db.Column(db.Date())
runtime = db.Column(db.Integer())
tagline = db.Column(db.Text())
homepage = db.Column(db.Text())
# Relationships
genres = db.relationship('Genre',
backref='movies',
secondary=movie_genre_lnk)
characters = db.relationship(
'Character', backref='found_in') # Should this be many to many?
videos = db.relationship('Video')
countries = db.relationship('Country',
backref='movies',
secondary=movie_country_lnk)
recommendations = db.relationship(
'Recommendation',
foreign_keys='Recommendation.recommendation_from',
backref='from_movie')
# Statistics
rating_sum = db.Column(db.Integer(), default=0) # Sum of all ratings
num_ratings = db.Column(db.Integer(),
default=0) # Number of non-NULL ratings
num_favourites = db.Column(db.Integer(), default=0)
num_completed = db.Column(db.Integer(), default=0)
num_ptw = db.Column(db.Integer(), default=0)
num_custom = db.Column(db.Integer(), default=0)
def add_completed_member(self, rating):
self.num_completed += 1
if rating:
self.rating_sum += rating
self.num_ratings += 1
def remove_completed_member(self, rating):
self.num_completed -= 1
if rating:
self.rating_sum -= rating
self.num_ratings -= 1
def add_ptw_member(self):
self.num_ptw += 1
def remove_ptw_member(self):
self.num_ptw -= 1
def get_movie_metadata(self):
ret = dict()
ret['title'] = self.title
ret['status'] = self.status
ret['budget'] = self.budget
ret['imdb_id'] = self.imdb_id
ret['revenue'] = self.revenue
ret['backdrop_path'] = self.backdrop_path
ret['poster_path'] = self.poster_path
ret['adult'] = self.adult
ret['orginal_language'] = self.original_language
ret['overview'] = self.overview
ret['release_date'] = self.release_date
ret['runtime'] = self.runtime
ret['tagline'] = self.tagline
ret['homepage'] = self.homepage
ret['genres'] = [g.genre for g in self.genres]
ret['characters'] = [{
'character_name': c.character_name,
'actor_name': c.actor_name,
'profile_path': c.profile_path,
'actor_id': c.actor_id,
'order': c.order
} for c in self.characters]
ret['videos'] = [{
'site': v.site,
'key': v.key,
'type': v.type,
'name': v.name
} for v in self.videos]
ret['countries'] = [c.name for c in self.countries]
return ret
def get_movie_statistics(self):
ret = dict()
ret['rating_sum'] = self.rating_sum
ret['num_ratings'] = self.num_ratings
ret['num_favourites'] = self.num_favourites
ret['num_completed'] = self.num_completed
ret['num_ptw'] = self.num_ptw
ret['num_custom'] = self.num_custom
return ret
class Country(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.Text())
iso_3166_1 = db.Column(db.String(2), unique=True, index=True)
class Genre(db.Model):
id = db.Column(db.Integer, primary_key=True)
genre = db.Column(db.Text(), unique=True)
class SiteInfo(db.Model):
__tablename__ = "siteinfo"
__table_args__ = {"useexisting": True}
extra_kwargs_dict = {
"rewrite": "",
"set_301": False,
"set_404": False,
"deny_ua": True,
"deny_referer": True,
"safe": True,
"cache": True
}
nid = db.Column(db.Integer, primary_key=True)
port = db.Column(db.Integer(), default=80)
is_ssl = db.Column(db.Boolean, default=0)
php_ver = db.Column(db.String(64), default="php7.0")
default_index = db.Column(
db.String(256),
default=
"index.php index.html index.htm default.php default.htm default.html")
is_log = db.Column(db.Boolean, default=0)
log_path = db.Column(db.String(256))
domain_301 = db.Column(db.String(256))
extra_kwargs = db.Column(db.Text(), default=json.dumps(extra_kwargs_dict))
sslcrt = db.Column(db.Text(), nullable=True, default="")
sslkey = db.Column(db.Text(), nullable=True, default="")
site_id = db.Column(db.Integer, db.ForeignKey("site.nid"))
siteinfo2site = db.relationship("Site",
backref="site2siteinfo",
uselist=False)
def to_json(self):
json_siteinfo = {
"nid": self.nid,
"port": self.port,
"is_ssl": self.is_ssl,
"php_ver": self.php_ver,
"default_index": self.default_index,
"is_log": self.is_log,
"log_path": self.log_path,
"domain_301": self.domain_301,
"extra_kwargs": json.loads(self.extra_kwargs),
"sslcrt": self.sslcrt,
"sslkey": self.sslkey
}
return json_siteinfo
def add(self):
db.session.add(self)
return session_commit()
@classmethod
def sdelete(cls, site_id):
cls.query.filter_by(site_id=site_id).delete()
return session_commit()
@classmethod
def supdate(cls, nid, update_dict):
cls.query.filter_by(site_id=nid).update(update_dict)
return session_commit()
@classmethod
def sget(cls, nid):
return cls.query.filter_by(site_id=nid).first()
