class TrendMakerNews(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
topic = db.Column(db.String(20))
start_ts = db.Column(db.BigInteger(20, unsigned=True))
end_ts = db.Column(db.BigInteger(20, unsigned=True))
news_id = db.Column(db.Text)
timestamp = db.Column(db.BigInteger(20, unsigned=True))
weight = db.Column(db.Float)
news_info = db.Column(db.Text)
def __init__(self, topic, start_ts, end_ts, news_id, timestamp, weight, news_info):
self.topic = topic
self.start_ts = start_ts
self.end_ts = end_ts
self.news_id = news_id
self.timestamp = timestamp
self.weight = weight
self.news_info = news_info
class TopicStatus(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
module = db.Column(
db.String(10)) # 显示是哪个模块---moodlens/evolution/propagate/identify
status = db.Column(
db.Integer) # 1: completed 0: computing, -1:not compute, -2:delete
topic = db.Column(db.Text)
start = db.Column(db.BigInteger(10, unsigned=True)) #起始时间
end = db.Column(db.BigInteger(10, unsigned=True)) #终止时间
db_date = db.Column(db.BigInteger(10, unsigned=True)) #入库时间❯
def __init__(self, module, status, topic, start, end, db_date):
self.module = module
self.status = status
self.topic = topic
self.start = start
self.end = end
self.db_date = db_date
class Harvest(db.Model):
__Tablename__ = "harvests"
id = db.Column(db.Integer, primary_key=True)
year = db.Column(db.Integer)
harvest_yield = db.Column(db.String(255))
crop_id = db.Column(db.Integer, db.ForeignKey('crop.id'), nullable=False)
crop = db.relationship('Crop',
foreign_keys=[crop_id],
backref="crops_harvest",
cascade="all")
field_id = db.Column(db.Integer, db.ForeignKey('field.id'), nullable=False)
field = db.relationship('Field',
foreign_keys=[field_id],
backref="fields_harvest",
cascade="all")
harvest_that_have_field = db.relationship('Field',
lazy='dynamic',
secondary=field_harvest_table)
class Credential(db.Model):
__tablename__ = 'credential'
__table_args__ = {'extend_existing': True}
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
cpassword = db.Column(db.String(300), nullable=True)
def __init__(self, user_id, password):
self.user_id = user_id
self.cpassword = password
def serialize(self):
return {
'id': self.id,
'user_id': self.user_id,
'cpassword': self.cpassword
}
class Idea(db.Model):
__tablename__="ideas"
idea_id = db.Column(db.Integer, primary_key = True)
content = db.Column(db.String(255))
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now())
author_id = db.Column(db.Integer, db.ForeignKey("users.user_id"), nullable = False)
author = db.relationship("User", foreign_keys = [author_id], backref = "user_ideas", cascade = "all")
liked_by = db.relationship("User", secondary = "user_likes")
# class Follow(db.Model):
# __tablename__="follows"
# id=db.Column(db.Integer, primary_key=True)
# user_id=db.Column(db.Integer, db.ForeignKey("users.user_id"))
# user=db.relationship("User",backref="likes", cascade="all")
# user_id=db.Column(db.Integer, db.ForeignKey("users.user_id"))
# user=db.relationship("User",backref="likes", cascade="all")
# created_at=db.Column(db.DateTime, server_default=func.now())
class Food(db.Model):
id = db.Column(db.Integer, primary_key=True)
calories = db.Column(db.Float)
name = db.Column(db.String(100), nullable=False)
carbs = db.Column(db.Float, nullable=False)
fat = db.Column(db.Float, nullable=False)
protein = db.Column(db.Float, nullable=False)
quantity = db.Column(db.Float, nullable=False)
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
meal_id = db.Column(db.Integer, db.ForeignKey('meal.id', ondelete='cascade'), nullable=False)
meal = db.relationship('Meal', foreign_keys=[meal_id])
# class methods
@classmethod
def validate_food(cls, user_data):
is_valid = True
if len(user_data['food_name']) < 1:
is_valid = False
flash("Please Enter A Food Name", "food_error")
if profanity.contains_profanity(user_data['food_name']) == True:
is_valid = False
flash("Please Enter an Appropriate Food Name", "food_error");
if user_data['calories'] == '':
is_valid = False
flash("Please Enter Calories for Food Item", "food_error")
if user_data['carbs'] == '' or float(user_data['carbs']) <0:
is_valid = False
flash("Please Enter Carbs for Food Item", "food_error")
if user_data['fat'] == '' or float(user_data['fat']) <0:
is_valid = False
flash("Please Enter Fat for Food Item", "food_error")
if user_data['protein'] == '' or float(user_data['protein']) <0:
is_valid = False
flash("Please Enter Protein for Food Item", "food_error")
if user_data['quantity'] == '' or float(user_data['quantity']) <=0:
is_valid = False
flash("Please Enter Quantity of Food Items", "food_error")
return is_valid
@classmethod
def create_food(cls, user_data, meal_id):
food = Food(calories=user_data['calories'], name=user_data['food_name'], carbs=user_data['carbs'], fat=user_data['fat'], protein=user_data['protein'], quantity=user_data['quantity'],meal_id=int(meal_id))
db.session.add(food)
db.session.commit()
return food
class Ideas(db.Model):
# f__tablename__ = "users" # optional
id = db.Column(db.Integer, primary_key=True, nullable=False)
idea = db.Column(db.String(145))
user_id = db.Column(db.Integer, db.ForeignKey('users.id'))
liked = db.relationship('Likes', backref= 'idea_liked')
created_at = db.Column(db.DateTime, server_default=func.now())
updated_at = db.Column(db.DateTime, server_default=func.now(), onupdate=func.now())
@classmethod
def validate_idea(cls, user_data):
is_valid = True
if len(user_data["idea"]) < 3:
is_valid = False
flash("Please provide your idea, it should be at least 3 words!")
return is_valid
@classmethod
def add_new_idea(cls, user_data):
print(user_data["user_id"])
print("***************************")
user_owner = Users.query.get(user_data["user_id"])
idea_to_add = cls(idea=user_data["idea"], owner = user_owner)
db.session.add(idea_to_add)
db.session.commit()
return idea_to_add
@classmethod
def delete_idea(cls, user_data):
idea_to_delete = Ideas.query.filter_by(id=user_data['which_idea']).first()
# existing_wish = Wishes.query.get(user_data['removed_id'])
# user_wished = Users.query.get(user_data["user_id"])
# existing_wish.wishes_of_user.remove(user_wished)
# user_wished.user_wishes.remove(existing_wish)
db.session.delete(idea_to_delete)
db.session.commit()
return idea_to_delete
class Artist(db.Model):
__tablename__ = 'Artist'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
city = db.Column(db.String(120))
state = db.Column(db.String(120))
phone = db.Column(db.String(120))
genres = db.Column(db.String(120))
image_link = db.Column(db.String(500))
facebook_link = db.Column(db.String(120))
website_link = db.Column(db.String(120))
seeking_venue = db.Column(db.Boolean)
seeking_description = db.Column(db.String(500))
shows = db.relationship('Show', backref='artist')
@property
def upcoming_shows(self):
return list(
filter(lambda show: show.start_time >= datetime.today(),
self.shows))
@property
def upcoming_shows_count(self):
return len(
list(
filter(lambda show: show.start_time >= datetime.today(),
self.shows)))
@property
def past_shows(self):
return list(
filter(lambda show: show.start_time < datetime.today(),
self.shows))
@property
def past_shows_count(self):
return len(
list(
filter(lambda show: show.start_time < datetime.today(),
self.shows)))
class Menu(DaoOperations, OutputMixin, db.Model):
RELATIONSHIPS_TO_DICT = True
MENU_REQUIRED_PARAMS = [
'name',
]
mid = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50), nullable=False)
def __init__(self, **kwargs):
self.name = kwargs['name']
@staticmethod
def get_all_menus():
return Menu.query.all()
@staticmethod
def get_menu_by_id(menu_id):
return Menu.query.filter_by(mid=menu_id).first()
class Team(db.Model):
__tablename__ = 'globals'
id = db.Column(db.Integer, primary_key=True)
team_id = db.Column(db.String(16), unique=True)
contents = db.Column(db.Text)
def __init__(self, team_id):
self.team_id = team_id
self.contents = '{}'
def __repr__(self):
return '<Character [{}]>'.format(self.name)
def get_contents(self):
return json.loads(self.contents)
def set_contents(self, contents):
self.contents = json.dumps(contents)
class Items(db.Model):
__tablename__ = "items"
"""
Represents items
field id: Primary key
type id: Integer
"""
id = db.Column(db.Integer, primary_key=True)
itemTitle = db.Column(db.String(220), nullable=False)
categoryId = db.Column( db.ForeignKey('category.id'), nullable=False)
itemDescription = db.Column(db.Text, nullable=True)
itemPrice = db.Column(db.Float(precision=2), nullable=False)
status = db.Column(db.Boolean, default=True)
createdAt = db.Column(db.DateTime,default=datetime.datetime.utcnow())
updatedAt = db.Column(db.DateTime, onupdate=datetime.datetime.utcnow())
class FollowUp(db.Model):
__tablename__ = 'followup'
id = db.Column(db.Integer, primary_key=True)
followupInstructions = db.Column(db.Text)
diagnosis = db.Column(db.Text)
treatment = db.Column(db.Text)
dateAssessed = db.Column(db.BigInteger, nullable=False)
healthcareWorkerId = db.Column(db.ForeignKey(User.id), nullable=False)
specialInvestigations = db.Column(db.Text)
medicationPrescribed = db.Column(
db.Text) # those medication names can get pretty long ...
followupNeeded = db.Column(db.Boolean)
# reading = db.relationship('Reading', backref=db.backref('referral', lazy=True, uselist=False))
healthcareWorker = db.relationship(User,
backref=db.backref('followups',
lazy=True))
followupFrequencyValue = db.Column(db.Float)
followupFrequencyUnit = db.Column(db.Enum(frequencyUnitEnum))
dateFollowupNeededTill = db.Column(db.String(50))
class Events(db.Model):
__tablename__ = 'EVENTS'
id_event = db.Column(db.Integer(), primary_key=True)
name = db.Column(db.String(256), nullable=False)
def __init__(self, data):
self.name = data.get('name')
@staticmethod
def get_all():
return Events.query.all()
def create(self):
db.session.add(self)
db.session.commit()
@staticmethod
def get_one(id_event):
return Events.query.get(id_event)
class ReaderGrade(db.Model):
'''读者等级表'''
__tablename__ = "reader_grade" #表名
id = db.Column(db.Integer, primary_key=True, autoincrement=True) #id 主键自增
grand_name = db.Column(db.String(50), nullable=True) # 级别名字
quan_tity = db.Column(db.Integer, nullable=True) # 可借数量2本
max_maney = db.Column(db.Float(), nullable=True) # 最大金额/押金
date_amount = db.Column(db.Integer, nullable=True) # 还书期限
#
'''
作者1--N书
Author：books = db.relationship('Book', backref='author')
Book:author_id = db.Column(db.Integer,db.ForeignKey('authors.id')) #或者是, Author.id
'''
# 读者返回来引用 级别
readers = db.relationship('Reader', backref='grade') #指定读者对象，引用级别的别名！
def __str__(self):
return self.grand_name
class Module(db.Model):
__tablename__ = 'module'
id = db.Column(db.Integer(), primary_key=True, comment='主键，自增')
name = db.Column(db.String(64), nullable=True, comment='接口模块')
num = db.Column(db.Integer(), nullable=True, comment='模块序号')
project_id = db.Column(db.Integer,
db.ForeignKey('project.id'),
comment='所属的项目id')
api_msg = db.relationship('ApiMsg',
order_by='ApiMsg.num.asc()',
lazy='dynamic')
created_time = db.Column(db.DateTime,
index=True,
default=datetime.now,
comment='创建时间')
update_time = db.Column(db.DateTime,
index=True,
default=datetime.now,
onupdate=datetime.now)
class Opinion(db.Model): #观点
id = db.Column(db.Integer, primary_key=True)
opinionTopic = db.Column(db.Integer) #话题、观点对应表中id字段
start = db.Column(db.BigInteger(20, unsigned=True)) #开始时间
end = db.Column(db.BigInteger(20, unsigned=True)) #结束时间
count = db.Column(db.Integer) #所占微博数量
opinionWord = db.Column(db.String(20)) #关键词
positive = db.Column(db.Float) #正极性情绪比例
nagetive = db.Column(db.Float) #负极性情绪比例
def __init__(self, opinionTopic, start, end, count, opinionWord, positive,
nagetive):
self.opinionTopic = opinionTopic
self.start = start
self.end = end
self.count = count
self.opinionWord = opinionWord
self.positive = positive
self.nagetive = nagetive
class QuotaSensitivity(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
topic = db.Column(db.String(20))
start_ts = db.Column(db.BigInteger(10, unsigned=True))
end_ts = db.Column(db.BigInteger(10, unsigned=True))
classfication = db.Column(db.Integer(
1, unsigned=True)) # ['category':1, 'word':2, 'place':3]
score = db.Column(db.Float) # 1<=score<=5
def __init__(self, topic, start_ts, end_ts, classfication, score):
self.topic = topic
self.start_ts = start_ts
self.end_ts = end_ts
self.classfication = classfication
self.score = score
@classmethod
def _name(cls):
return u'QuotaSensitivity'
class Session(db.Model):
def __gen_id():
return token_hex(16)
__tablename__ = 'Session'
session_id = db.Column(db.String(32), primary_key=True, default=__gen_id)
#user_id = db.Column(db.Integer, db.ForeignKey('user.user_id'), nullable=False)
user_id = db.Column(db.Integer, nullable=False) # STUB
created_at = db.Column(db.DateTime,
default=datetime.utcnow,
nullable=False)
expires = db.Column(db.DateTime, nullable=False)
def __init__(self, user_id, expires):
self.user_id = user_id
self.expires = expires
def is_expired(self):
return (self.expires < datetime.utcnow())
class User(db.Model):
__tablename__ = 'User'
user_id = db.Column(UUID(as_uuid=True), default=uuid.uuid4, primary_key=True)
email = db.Column(db.Unicode(254), unique=True, nullable=False)
_password = db.Column('password', db.String(255), nullable=False)
name = db.Column(db.Unicode(120), nullable=False)
registered_events = db.relationship('Event', lazy=True)
notifications_sent = db.relationship('Notification', lazy='dynamic', foreign_keys='Notification.sender_id')
notifications_received = db.relationship('Notification', lazy='dynamic', foreign_keys='Notification.receiver_id')
#registrations_sent = db.relationship('Registration', lazy='dynamic', foreign_keys='Registration.sender_id')
registrations_received = db.relationship('Registration', lazy='dynamic', foreign_keys='Registration.register_id')
roles = db.relationship('Role', lazy='dynamic')
sessions = db.relationship('Session', lazy='dynamic')
@classmethod
def schema(cls):
class Schema(SQLAlchemySchema):
class Meta:
model = User
name = auto_field()
roles = Nested(Role.schema(), many=True)
if (not hasattr(cls, '_schema')): cls._schema = Schema()
return cls._schema
@property
def password(self):
return self._password
@password.setter
def password(self, password):
self._password = ph.hash(password)
def verify_password(self, password):
try:
return ph.verify(self._password, password)
except (VerifyMismatchError):
return False
def dump(self):
return User.schema().dump(self)
class DeviceConfig(db.Model):
__tablename__ = 'device_config'
device_config_id = db.Column(db.Integer, primary_key=True)
device_config_name = db.Column(db.String(32))
buttons = db.relationship(
"RCButton",
backref="device_config",
single_parent=True,
order_by="desc(RCButton.rc_type)",
)
devices = db.relationship(
"Device",
backref="device_config",
single_parent=True,
order_by="desc(Device.model_num)",
)
timestamp = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
class User(db.Model):
''' The data model'''
# table name
__tablename__ = 'users'
id = db.Column(db.Integer(), primary_key=True, autoincrement=True)
name = db.Column(db.String(200), nullable=False)
email = db.Column(db.String(255), nullable=False)
cell = db.Column(db.String(15), nullable=False)
phone = db.Column(db.String(15), nullable=False)
gender = db.Column(db.String(10), nullable=False)
nat = db.Column(db.String(2), nullable=False)
def as_dict(self):
return {c.name: getattr(self, c.name) for c in self.__table__.columns}
class Venue(db.Model):
__tablename__ = 'Venue'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String)
city = db.Column(db.String(120))
genres = db.Column(db.String(120))
state = db.Column(db.String(120))
address = db.Column(db.String(120))
phone = db.Column(db.String(120))
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, nullable=False)
seeking_description = db.Column(db.Text, nullable=True)
shows = db.relationship('Show', backref='venue', lazy=True)
def __repr__(self):
return f'<Venue {self.id} {self.name}>'
@property
def past_shows(self):
return [{
'artist_id': show.artist.id,
'artist_name': show.artist.name,
'artist_image_link': show.artist.image_link,
'start_time': show.start_time.strftime(DATETIME_FORMAT)
} for show in Show.query.filter(Show.start_time < datetime.now(),
Show.venue_id == self.id).all()]
@property
def upcoming_shows(self):
return [{
'artist_id': show.artist.id,
'artist_name': show.artist.name,
'artist_image_link': show.artist.image_link,
'start_time': show.start_time.strftime(DATETIME_FORMAT)
} for show in Show.query.filter(Show.start_time >= datetime.now(),
Show.venue_id == self.id).all()]
class Trip(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255))
user_id = db.Column(db.Integer,
db.ForeignKey('user.id', ondelete='cascade'),
nullable=False)
user = db.relationship('User', foreign_keys=[user_id], backref='trips')
start_time = db.Column(db.DateTime, server_default=func.now())
end_time = db.Column(db.DateTime)
def ordered_finds(self):
ordered = Find.query.filter_by(trip_id=self.id).order_by(
Find.found_at.asc()).all()
return ordered
def end_trip(self):
self.end_time = func.now()
db.session.commit()
@classmethod
def validate_trip(cls, form):
if len(form['tn']) < 1:
flash('Please enter a name for your trip', 'tn')
else:
trips = cls.query.filter_by(user_id=session['uid'],
name=form['tn']).all()
if trips:
flash('You already have a trip by that name!', 'tn')
if '_flashes' in session.keys():
return False
return True
@classmethod
def start_trip(cls, form):
new_trip = cls(name=form['tn'], user_id=session['uid'])
db.session.add(new_trip)
db.session.commit()
@classmethod
def current_trip(cls, id):
trip = cls.query.get(id)
return trip
class LocalBridge(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
topic = db.Column(db.String(20))
date = db.Column(db.Date)
windowsize = db.Column(db.Integer, default=1)
a_node = db.Column(db.BigInteger(11, unsigned=True))
b_node = db.Column(db.BigInteger(11, unsigned=True))
span_ab = db.Column(db.Integer)
def __init__(self, topic, date, windowsize, a_node, b_node, span_ab):
self.topic = topic
self.date = date
self.windowsize = windowsize
self.a_node = a_node
self.b_node = b_node
self.span_ab = span_ab
@classmethod
def _name(cls):
return u'LocalBridge'
class DsClosenessCentralityUser(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
topic = db.Column(db.String(20))
date = db.Column(db.Date)
windowsize = db.Column(db.Integer, default=1)
rank = db.Column(db.Integer)
userid = db.Column(db.BigInteger(11, unsigned=True))
cc = db.Column(db.Float)
def __init__(self, topic, date, windowsize, rank, userid, cc):
self.topic = topic
self.date = date
self.windowsize = windowsize
self.rank = rank
self.userid = userid
self.cc = cc
@classmethod
def _name(cls):
return u'DsClosenessCentralityUser'
class SentimentWeibos(db.Model): #情绪微博--已改
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
query = db.Column(db.String(100))
end = db.Column(db.BigInteger(10, unsigned=True))
range = db.Column(db.BigInteger(10, unsigned=True))
limit = db.Column(db.BigInteger(10, unsigned=True))
sentiment = db.Column(db.Integer(1, unsigned=True))
weibos = db.Column(db.Text)
def __init__(self, query, range, limit, end, sentiment, weibos):
self.query = query
self.range = range
self.limit = limit
self.end = end
self.sentiment = sentiment
self.weibos = weibos
@classmethod
def _name(cls):
return u'SentimentWeibos'
class TsRank(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
topic = db.Column(db.String(20))
rank = db.Column(db.Integer)
uid = db.Column(db.BigInteger(11, unsigned=True))
date = db.Column(db.Date)
windowsize = db.Column(db.Integer, default=1)
tr = db.Column(db.Float)
def __init__(self, topic, rank, uid, date, windowsize, tr):
self.topic = topic
self.rank = rank
self.uid = uid
self.date = date
self.windowsize = windowsize
self.tr = tr
@classmethod
def _name(cls):
return u'TsRank'
class PropagateNews(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
topic = db.Column(db.String(100))
end = db.Column(db.BigInteger(10, unsigned=True))
range = db.Column(db.BigInteger(10, unsigned=True))
mtype = db.Column(db.Integer(1, unsigned=True))
limit = db.Column(db.BigInteger(10, unsigned=True), primary_key=True)
news = db.Column(db.Text) # news=[news]
def __init__(self, topic, end, range, mtype, limit, news):
self.topic = topic
self.end = end
self.range = range
self.mtype = mtype
self.limit = limit
self.news = news
@classmethod
def _name(cls):
return u'PropagateNews'
class PropagateKeywords(db.Model):
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
topic = db.Column(db.String(100))
end = db.Column(db.BigInteger(10, unsigned=True))
range = db.Column(db.BigInteger(10, unsigned=True))
mtype = db.Column(db.Integer(1, unsigned=True))
limit = db.Column(db.BigInteger(10, unsigned=True), primary_key=True)
kcount = db.Column(db.Text) # kcount=[terms]
def __init__(self, topic, end, range, mtype, limit, kcount):
self.topic = topic
self.end = end
self.range = range
self.limit = limit
self.mtype = mtype
self.kcount = kcount
@classmethod
def _name(cls):
return u'PropagateKeywords'
class Migration(db.Model):
"""Save all activity
[description]
Extends:
db.Model
Variables:
__tablename__ {str} -- [description]
id {[type]} -- [description]
migration {[type]} -- [description]
batch {[type]} -- [description]
"""
__tablename__ = "migrations"
id = db.Column(db.Integer, primary_key=True)
migration = db.Column(db.String(255), nullable=False)
batch = db.Column(db.Integer, nullable=False)
