class Comment(BaseModel, Model):
__tablename__ = 'comment'
user_id = Column(db.ForeignKey('user.id'), comment='用户id')
content = Column(db.String(200), comment='评论内容')
article_id = Column(db.ForeignKey('article.id'), comment='所属内容ID')
father_id = Column(db.ForeignKey('comment.id'), comment='父评论ID')
valid = Column(db.Boolean(), comment='有效性')
class OnOffPairs_Stops(db.Model):
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.DateTime)
rte = db.Column(db.Integer)
dir = db.Column(db.Integer)
#NOTE see nots from fixme above Stops model
on_stop = db.Column(db.Integer, db.ForeignKey("stops.gid"), nullable=False)
off_stop = db.Column(db.Integer,
db.ForeignKey("stops.gid"),
nullable=False)
on = orm.relationship("Stops", foreign_keys=on_stop)
off = orm.relationship("Stops", foreign_keys=off_stop)
user_id = db.Column(db.Text)
def __init__(self, date, rte, dir, on_stop, off_stop, user_id):
self.date = date
self.rte = rte
self.dir = dir
self.on_stop = on_stop
self.off_stop = off_stop
self.user_id = user_id
def __repr__(self):
return '<OnOffPairs: id:%r, on_id:%r, off_id:%r >' %\
(self.id, self.on_stop, self.off_stop)
class Registration(TimestampMixin, db.Model):
query_class = RegistrationQuery
__tablename__ = "registration"
class RegistrationStatus(object):
PENDING = "pending"
INCOMPLETE = "incomplete"
COMPLETE = "complete"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer, db.ForeignKey("user.id"))
user_phone = db.Column(db.String(50), nullable=False)
system_phone = db.Column(db.String(50), nullable=False)
partner_id = db.Column(db.Integer, db.ForeignKey("partner.id"))
program_id = db.Column(db.Integer, db.ForeignKey("program.id"))
district = db.Column(db.String(100))
state = db.Column(db.String(100))
parent_type = db.Column(db.String(50))
is_child_between_0_3 = db.Column(db.Boolean)
is_child_between_3_6 = db.Column(db.Boolean)
is_child_above_6 = db.Column(db.Boolean)
has_no_child = db.Column(db.Boolean)
has_smartphone = db.Column(db.Boolean)
has_dropped_missedcall = db.Column(db.Boolean)
has_received_callback = db.Column(db.Boolean)
status = db.Column(db.String(50))
signup_date = db.Column(db.DateTime)
@classmethod
def get_by_user_id(self, user_id):
return Registration.query.get_by_user_id(user_id)
class Comment(db.Model):
id = db.Column(db.Integer(), primary_key=True)
host_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
author_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
timestamp = db.Column(db.DateTime(), default=datetime.utcnow)
body = db.Column(db.String(512))
class Listing(db.Model):
# Columns
type = db.Column(
db.Enum(ListingTypes),
nullable=False,
primary_key=True
)
user_id = db.Column(
db.Integer,
db.ForeignKey('user.id'),
nullable=False,
primary_key=True
)
message_id = db.Column(
db.Integer,
db.ForeignKey('message.id'),
nullable=False,
primary_key=True
)
# Relations
user = db.relationship(
"User",
foreign_keys=user_id,
backref='listings'
)
message = db.relationship(
"Message",
foreign_keys=message_id,
backref='listings'
)
class Todo(AuditMixin, BaseMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
text = db.Column(db.String(80))
complete = db.Column(db.Boolean, default=False)
todo_list_id = db.Column(db.ForeignKey('todo_list.id'))
user_id = db.Column(db.ForeignKey('user.id'))
class PartnerSystemPhone(TimestampMixin, db.Model):
query_class = PartnerSystemPhoneQuery
__tablename__ = "partner_system_phone"
id = db.Column(db.Integer, primary_key=True)
partner_id = db.Column(db.Integer, db.ForeignKey("partner.id"))
system_phone_id = db.Column(db.Integer, db.ForeignKey("system_phone.id"))
status = db.Column(db.String(50))
class Review(db.Model):
"""Represents A Review Object."""
__tablename__ = "reviews"
id = db.Column(db.Integer, primary_key=True, index=True)
comment = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('users.id'), nullable=False)
business_id = db.Column(db.Integer, db.ForeignKey(
'businesses.id'), nullable=False)
created_at = db.Column(db.DateTime, default=datetime.utcnow())
updated_at = db.Column(db.DateTime, default=datetime.utcnow())
def create(self):
db.session.add(self)
db.session.commit()
def __repr__(self):
""""""
return "<Comment : {}>".format(self.id)
@staticmethod
def get_review(id):
review = Review.query.get(int(id))
return review
@staticmethod
def get_review_details(review):
return {'comment':review.comment, 'userId':review.user_id, 'businessId':review.business_id}
@staticmethod
def get_reviews():
reviews = Review.query.all()
return reviews
class History(db.Model):
"""History(time, UID, RID, rating, accompanies)"""
__tablename__ = "history"
time = db.Column(db.DateTime, primary_key=True)
UID = db.Column(db.Integer,
db.ForeignKey('mealpat_user.UID',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False)
RID = db.Column(db.Integer,
db.ForeignKey('restaurant.RID',
ondelete='CASCADE',
onupdate='CASCADE'),
primary_key=True,
nullable=False)
accompanies = db.Column(ARRAY(db.Integer))
rating = db.Column(db.Float)
def __init__(self, data):
self.time = data['time']
self.UID = data['UID']
self.RID = data['RID']
self.accompanies = data['accompanies']
self.rating = data['rating']
def __repr__(self):
return '<post {}>'.format(self.CID)
class Chatbot(db.Model):
id = db.Column(db.Integer, primary_key=True)
InterviewID = db.Column(db.Integer, db.ForeignKey(Interview.id))
PatientID = db.Column(db.Integer, db.ForeignKey(Patient.id))
DoctorID = db.Column(db.Integer)
Question = db.Column(db.String(500))
Answer = db.Column(db.String(500))
class Post(db.AlchemyBase):
__tablename__ = "post"
id = db.Column(db.Integer, primary_key=True)
entity_id = db.Column(db.Integer, nullable=False, index=True, unique=True)
user_id = db.Column(db.Integer, db.ForeignKey(User.id), nullable=False)
section_id = db.Column(db.Integer,
db.ForeignKey(Section.id),
nullable=False,
index=True)
title = db.Column(db.String(255), nullable=False)
text = db.Column(db.Text)
pin_teaser = db.Column(db.Text)
is_pinned = db.Column(db.Boolean,
nullable=False,
default=False,
index=True)
is_deleted = db.Column(db.Boolean,
nullable=False,
default=False,
index=True)
is_moderated = db.Column(db.Boolean, nullable=False, default=False)
is_legacy = db.Column(db.Boolean,
nullable=False,
default=False,
index=True)
original_title = db.Column(db.String(255))
original_text = db.Column(db.Text)
moderation_notes = db.Column(db.Text)
created = db.Column(db.DateTime, default=datetime.utcnow, index=True)
modified = db.Column(db.DateTime,
default=datetime.utcnow,
onupdate=datetime.utcnow)
user = db.relationship(User)
section = db.relationship(Section)
class DeckSelectedCard(db.AlchemyBase):
"""Tracks cards selected for use in First Five
`is_first_five` means cards that are explicitly included in the First Five. `is_paid_effect`
means that the player plans to pay the effect cost for that card in the first round.
`tutor_card_id` means that the card in `tutor_card_id` was used to fetch this card, which means
that it can functionally be either the First Sixth card and/or a paid effect cost.
"""
__tablename__ = "deck_selected_card"
deck_id = db.Column(db.Integer,
db.ForeignKey(Deck.id),
nullable=False,
primary_key=True)
card_id = db.Column(db.Integer,
db.ForeignKey(Card.id),
nullable=False,
primary_key=True)
tutor_card_id = db.Column(db.Integer,
nullable=False,
default=0,
primary_key=True)
is_first_five = db.Column(db.Boolean, nullable=False, default=False)
is_paid_effect = db.Column(db.Boolean, nullable=False, default=False)
deck = db.relationship(Deck,
backref=db.backref("selected_cards",
cascade="all, delete-orphan"))
class User(db.Model):
__tablename__ = 'company'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String, nullable=False)
rid = db.Column(db.Integer, db.ForeignKey('role.id'))
email = db.Column(db.String, index=True)
mobile = db.Column(db.String)
phone = db.Column(db.String)
first_name = db.Column(db.String)
last_name = db.Column(db.String)
sex = db.Column(db.Integer)
country = db.Column(db.String)
address = db.Column(db.String)
wechat = db.Column(db.String)
qq = db.Column(db.String)
weibo = db.Column(db.String)
avator = db.Column(db.String)
create_time = db.Column(db.DateTime)
create_ip = db.Column(db.String)
cid = db.Column(db.Integer, db.ForeignKey('company.id'))
post = db.Column(db.String)
def __init__(self, name):
super(User, self).__init__()
self.username = name
def to_json(self):
ret = {
'id': self.id,
'name': self.username
}
return ret
class BorrowsAssociation(db.Model):
__tablename__ = 'borrows'
borrowed = db.Column(db.Integer, primary_key=True)
borrower = db.Column(db.Integer, db.ForeignKey('user.id'))
owner_shelf_id = db.Column(db.Integer,
db.ForeignKey('bookshelf.bookshelf_id'))
bookid = db.Column(db.Integer, db.ForeignKey('books.book_id'))
status = db.Column(db.String)
startDate = db.Column(db.DateTime)
returnDate = db.Column(db.DateTime)
verification = db.Column(db.Boolean)
user = db.relationship('User', backref='borrowBookshelfs')
bookshelf = db.relationship('Bookshelf', backref='borrowUsers')
def __init__(self,
borrower='',
owner_shelf_id='',
status='',
bookid='',
verification='',
startDate='',
returnDate=''):
self.borrower = borrower
self.owner_shelf_id = owner_shelf_id
self.status = status
self.bookid = bookid
self.verification = verification
self.startDate = startDate
self.returnDate = returnDate
class DocumentTags(db.Model):
id = db.Column(db.Integer, primary_key=True)
itemId = db.Column(db.Integer, db.ForeignKey("documents.itemId"))
tagId = db.Column(db.Integer, db.ForeignKey("tags.tagId"))
def serialize(self):
return self.tagId
class InterestAssociation(db.Model):
__tablename__ = 'hasInterest'
interestId = db.Column(db.Integer, primary_key=True)
user_Id = db.Column(db.Integer, db.ForeignKey('user.id'))
genreId = db.Column(db.Integer, db.ForeignKey('genre.id_genre'))
user = db.relationship('User', backref='Interestuser')
genre = db.relationship('Genre', backref='Interestgenre')
class WaitingList(db.Model):
waiting_id = db.Column(db.Integer, primary_key=True)
approval = db.Column(db.Boolean, nullable=True)
method = db.Column(db.String)
date = db.Column(db.DateTime, default=datetime.datetime.today)
request_Date = db.Column(db.DateTime, nullable=True)
borrower = db.Column(db.Integer, db.ForeignKey('user.id'))
price = db.Column(db.Integer, nullable=True)
price_rate = db.Column(db.Integer, nullable=True)
owner_shelf_id = db.Column(db.Integer,
db.ForeignKey('bookshelf.bookshelf_id'))
bookid = db.Column(db.Integer, db.ForeignKey('books.book_id'))
user = db.relationship('User', backref='waitingUsers')
bookshelf = db.relationship('Bookshelf', backref='waitingBookshelf')
def __init__(self,
borrower='',
owner_shelf_id='',
price='',
price_rate='',
approval='',
method='',
bookid='',
request_Date=''):
self.borrower = borrower
self.owner_shelf_id = owner_shelf_id
self.approval = approval
self.price_rate = price_rate
self.price = price
self.bookid = bookid
self.method = method
self.request_Date = request_Date
class ProgramModule(TimestampMixin, db.Model):
query_class = ProgramModuleQuery
__tablename__ = "program_module"
id = db.Column(db.Integer, primary_key=True)
program_id = db.Column(db.Integer, db.ForeignKey("program.id"))
module_id = db.Column(db.Integer, db.ForeignKey("module.id"))
sequence = db.Column(db.Integer)
class ContainsAssociation(db.Model):
__tablename__ = 'contains'
contains_id = db.Column(db.Integer, primary_key=True)
quantity = db.Column(db.Integer)
availability = db.Column(db.String(3))
methods = db.Column(db.String(50))
price = db.Column(db.Integer)
date = db.Column(db.DateTime, default=datetime.datetime.today)
shelf_id = db.Column(db.Integer, db.ForeignKey('bookshelf.bookshelf_id'))
book_id = db.Column(db.Integer, db.ForeignKey('books.book_id'))
rateBooks = db.relationship('BookRateAssociation',
backref='books_rateBooks')
commentBooks = db.relationship('BookCommentAssociation',
backref='books_commentBooks')
bookshelfcontain = db.relationship('Bookshelf', backref='containingbooks')
containsbooks = db.relationship('Books', backref='booksBookshelf')
def __init__(self,
shelf_id='',
book_id='',
quantity='',
availability='',
methods='',
price=''):
self.shelf_id = shelf_id
self.book_id = book_id
self.quantity = quantity
self.methods = methods
self.price = price
self.availability = availability
class CustomListItem(db.Model):
id = db.Column(db.Integer, primary_key=True)
movie = db.relationship('Movie')
movie_id = db.Column(db.Integer(), db.ForeignKey('movie.id'))
list_id = db.Column(db.Integer(), db.ForeignKey('custom_list.id'))
notes = db.Column(db.String(64))
ordering = db.Column(db.Integer())
class LaudoEstudoDicomModel(db.Model):
__table_args__ = {'schema': 'radius_taas'}
__tablename__ = 'laudo_estudo_dicom'
identificador = db.Column(db.Integer, primary_key=True)
identificador_estudo_dicom = db.Column(
db.Integer,
db.ForeignKey('radius_taas.estudo_dicom.identificador'),
nullable=False)
estudo_dicom = db.relationship("EstudoDicomModel",
back_populates="laudo_estudo_dicom")
data_hora_emissao = db.Column(db.DateTime, nullable=False)
identificador_profissional_saude = db.Column(
db.Integer,
db.ForeignKey('public.profissional_saude.identificador'),
nullable=True)
identificador_profissional_saude_revisor = db.Column(
db.Integer,
db.ForeignKey('public.profissional_saude.identificador'),
nullable=True)
texto = db.Column(db.Text, nullable=False)
data_hora_revisao = db.Column(db.DateTime, nullable=False)
situacao = db.Column(db.String, nullable=False)
numero_exames_relacionados = db.Column(db.Integer, nullable=True)
situacao_envio_his = db.Column(db.String, nullable=False)
integrado = db.Column(db.Boolean, nullable=False)
class ApplicationAdNetworkModel(db.Model):
__tablename__ = 'application_adnetwork'
application_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('application.id',
onupdate="CASCADE",
ondelete="CASCADE"),
primary_key=True)
ad_network_id = db.Column(UUID(as_uuid=True),
db.ForeignKey('ad_network.id',
onupdate="CASCADE",
ondelete="CASCADE"),
primary_key=True)
score = db.Column(db.Float(), primary_key=True, default=0.0)
ad_network = db.relationship('AdNetworkModel')
last_update = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow)
@classmethod
def find_by_ids(cls, application_network_id, ad_network_id):
app_adn = cls.query.filter_by(application_id=application_network_id,
ad_network_id=ad_network_id).first()
return app_adn
def update_score(self, score):
self.score = score
self.last_update = datetime.utcnow()
try:
db.session.commit()
except Exception as e:
app.logger.error('Could not update score : {e}'.format(e=e))
db.session.rollback()
class ModuleContent(TimestampMixin, db.Model):
query_class = ModuleContentQuery
__tablename__ = "module_content"
id = db.Column(db.Integer, primary_key=True)
module_id = db.Column(db.Integer, db.ForeignKey("module.id"))
content_id = db.Column(db.Integer, db.ForeignKey("content.id"))
is_optional = db.Column(db.Boolean)
class CallbackTracker(TimestampMixin, db.Model):
__tablename__ = "callback_tracker"
id = db.Column(db.Integer, primary_key=True)
missed_call_log_id = db.Column(db.Integer, db.ForeignKey("user.id"))
program_id = db.Column(db.Integer, db.ForeignKey("program.id"))
preferred_time_slot = db.Column(db.String(50))
status = db.Column(db.String(50))
class BorrowModel(db.Model):
__tablename__ = 'borrows'
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
book_id = db.Column(db.Integer, db.ForeignKey('books.book_id'))
user_id = db.Column(db.Integer, db.ForeignKey('users.user_id'))
borrowing_date = db.Column(db.DateTime, default=datetime.utcnow)
till_date = db.Column(db.DateTime)
is_returned = db.Column(db.Boolean)
bill = db.relationship('BillingModel', backref='borrows', lazy='dynamic')
def __init__(self,
book_id,
user_id,
borrowing_date,
till_date,
is_returned=False):
self.book_id = book_id
self.user_id = user_id
self.borrowing_date = borrowing_date
self.till_date = till_date
self.is_returned = is_returned
def add(self):
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
class Post(db.Model):
"""Post(UID, RID, time, accompanies,CID)"""
__tablename__ = "post"
time = db.Column(db.DateTime)
title = db.Column(db.String(50))
PID = db.Column(db.Integer, unique=True, primary_key=True, nullable=False)
UID = db.Column(db.Integer,
db.ForeignKey('mealpat_user.UID', ondelete='CASCADE'),
nullable=False)
RID = db.Column(db.Integer,
db.ForeignKey('restaurant.RID', ondelete='CASCADE'),
nullable=False)
CID = db.Column(db.Integer,
db.ForeignKey('chatroom.CID', ondelete='CASCADE'),
unique=True,
nullable=False)
# identified by UIDs
accompanies = db.Column(ARRAY(db.Integer))
def __init__(self, data):
self.title = data['title']
self.time = data['time']
self.UID = data['UID']
self.RID = data['RID']
self.accompanies = data['accompanies']
self.CID = data['CID']
def __repr__(self):
return '<post {}>'.format(self.RID)
class Serves(db.Model):
serves_id = db.Column(db.Integer, unique=True, primary_key=True)
restaurant_id = db.Column(db.Integer,
db.ForeignKey("restaurant.restaurant_id"),
nullable=False)
cuisine_id = db.Column(db.Integer,
db.ForeignKey("cuisine.cuisine_id"),
nullable=False)
class TagItemRel(db.Model):
rel_id = db.Column(db.Integer, primary_key=True)
tag_id = db.Column(db.Integer, db.ForeignKey("tag.id"), nullable=False)
item_id = db.Column(db.Integer, db.ForeignKey("item.id"), nullable=False)
def __init__(self, tag_id, item_id):
self.tag_id = tag_id
self.item_id = item_id
class Like(db.Model):
id = db.Column(db.Integer, primary_key=True)
date_put = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
post_id = db.Column(db.Integer, db.ForeignKey('post.id'), nullable=False)
def __repr__(self):
return f"Like_by: ('{self.user_id}', liked_post: '{self.post_id}')"
class Checkins(db.Model):
user_id = db.Column(db.Integer,
db.ForeignKey("user.user_id"),
nullable=False)
location_id = db.Column(db.Integer,
db.ForeignKey("location.location_id"),
nullable=False)
checkin_id = db.Column(db.Integer, unique=True, primary_key=True)
timestamp = db.Column(db.DateTime)
