class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
input = db.Column(db.String(200), nullable=False)
date_posted = db.Column(db.DateTime(),
nullable=False,
default=datetime.utcnow())
generated = db.Column(db.Text, nullable=False)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
class Post(db.Model):
id = db.Column(db.Integer,primary_key=True)
body = db.Column(db.String(140))
timestamp = db.Column(db.DateTime)
user_id = db.Column(db.Integer,db.ForeignKey('user.id'))
def __repr__(self):
return '<post %r>' %(self.body)
class Product(db.Model):
__tablename__ = 'products'
id = db.Column(db.Integer, primary_key=True)
code = db.Column(db.String(10))
quantity = db.Column(db.Integer)
name = db.Column(db.String)
category = db.Column(db.Enum(ProductCategory))
class Tag(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(255), nullable=False)
stuff_id = db.Column(db.Integer, db.ForeignKey('stuff.id'))
stuff = db.relationship('Stuff', backref='tags')
def __repr__(self):
return "%s" % (self.name)
class Post(db.Model):
id = db.Column(db.Integer, primary_key=True)
blog_id = db.Column(db.Integer, db.ForeignKey('blog.id'))
author_id = db.Column(db.Integer, db.ForeignKey('author.id'))
title = db.Column(db.String(80))
body = db.Column(db.Text)
image = db.Column(db.String(255))
slug = db.Column(db.String(256), unique=True)
publish_date = db.Column(db.DateTime)
live = db.Column(
db.Boolean) # to avoid deleting post. If false -> just hide it
category_id = db.Column(db.Integer, db.ForeignKey('category.id'))
category = db.relationship('Category',
backref=db.backref('posts', lazy='dynamic'))
@property
def imgsrc(self):
return uploaded_images.url(self.image)
def __init__(self,
blog,
author,
title,
body,
category,
image=None,
slug=None,
publish_date=None,
live=True):
self.blog_id = blog.id
self.author_id = author.id
self.title = title
self.body = body
self.category_id = category.id
self.image = image
self.slug = slug
if publish_date is None:
self.publish_date = datetime.utcnow()
else:
self.publish_date = publish_date
self.live = live
def __repr__(self):
return '<Post %r>' % self.title
class User(db.Model, UserMixin):
id = db.Column(db.Integer, primary_key=True)
email = db.Column(db.String(255), unique=True)
name = db.Column(db.String(255), nullable=False)
phone_number = db.Column(db.String(255))
photo = db.Column(db.String(255))
about = db.Column(db.String(1000))
why = db.Column(db.String(1000))
password = db.Column(db.String(255))
active = db.Column(db.Boolean(), default=False)
approved = db.Column(db.Boolean(), default=False)
confirmed_at = db.Column(db.DateTime())
roles = db.relationship('Role', secondary=roles_users, backref=db.backref('users', lazy='dynamic'))
registered_at = db.Column(db.DateTime, default=datetime.now)
@property
def is_logged_in(self):
return False if self.is_anonymous() else True
@property
def is_admin(self):
return self.roles and self.roles[0].name == 'admin'
def __repr__(self):
return self.name
@property
def admin_url(self):
return "%s/%s/%s" % (app.config['ADMIN_URL'], 'user', self.id)
@property
def url(self):
return "%s/%s/" % ('profiles', self.name)
class iEvent(db.Model):
__tablename__ = 'i_event'
# event_id_seq = db.Sequence('event_id_seq', metadata=Base.metadata, start=5001)
# event_id = db.Column(db.BigInteger, event_id_seq, server_default=event_id_seq.next_value(), nullable=False, autoincrement=True, primary_key=True)
event_id = db.Column(db.BigInteger,
nullable=False,
autoincrement=True,
primary_key=True)
event_name = db.Column(db.String(128), nullable=False)
start_date = db.Column(db.DateTime, nullable=False, default=datetime.now())
end_date = db.Column(db.DateTime, nullable=False, default=datetime.now())
location = db.Column(db.String(128), nullable=True)
target_user = db.Column(db.String(128), nullable=True)
created_user_id = db.Column(db.String(128), nullable=False)
participant_limit_num = db.Column(db.Integer, nullable=False)
event_detail = db.Column(db.Text)
target_user_type_list = db.relationship(
"iEventTargetUserType",
order_by="iEventTargetUserType.target_user_type_id.asc()",
cascade="all, delete, delete-orphan",
primaryjoin="iEvent.event_id == iEventTargetUserType.event_id",
uselist=True,
lazy="joined")
tag_list = db.relationship(
"iEventTag",
cascade="all, delete, delete-orphan",
primaryjoin="iEvent.event_id == iEventTag.event_id",
uselist=True,
lazy="joined")
users_list = db.relationship(
"iParticipateEvent",
cascade="all, delete, delete-orphan",
primaryjoin="iEvent.event_id == iParticipateEvent.event_id",
uselist=True,
lazy="joined")
def __repr__(self):
return f"<event_id='{self.event_id}' tag_id={self.event_name} start_date={self.get_start_date()} end_date={self.get_end_date()}>"
def get_start_date(self):
return self.start_date.strftime("%Y-%m-%d %H:%M")
def get_end_date(self):
return self.end_date.strftime("%Y-%m-%d %H:%M")
class UserInfo(db.Model):
__tablename__ = 'user_info'
id = db.Column(db.Integer, primary_key=True)
uid = db.Column(db.Integer, nullable=False)
country = db.Column(db.String(30)) # used for trans country code with phone
nationality = db.Column(db.String(30)) # used for id-card verify
email = db.Column(db.String(120))
phone = db.Column(db.String(20))
id_card = db.Column(db.String(128)) # save file path
bill = db.Column(db.String(60)) # save file path
family_name = db.Column(db.String(30)) # 姓氏
first_name = db.Column(db.String(30)) # 本名
sex = db.Column(db.String(10))
birthday = db.Column(db.DateTime)
class WithDrawTicket(db.Model):
__tablename__ = 'withdraw_ticket'
id = db.Column(db.Integer, primary_key=True)
uid = db.Column(db.Integer, nullable=False)
bank_account = db.Column(db.Integer, nullable=False)
td = db.Column(db.String(90))
amount = db.Column(db.Numeric(20, 10))
status = db.Column(db.Integer, default=4) # 0:SUCCESS 1:CREATE 2:PADDING 3:CANCEL 4:IN_PROCCESS 5:FAIL
create_time = db.Column(db.DateTime, default=func.now())
class Tweet(db.Model):
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.String(140))
create_time = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'))
def __repr__(self):
return "id={}, body={}, tweet={}, create at {}, user_id={}".format(
self.id, self.body, self.create_time, self.user_id)
class ForumPost(db.Model):
__tablename__ = 'ForumPost'
post_id = db.Column(db.Integer, primary_key=True)
comment = db.Column(db.String(2048))
title = db.Column(db.String(100))
insert_time = db.Column(db.DateTime, default=datetime.now)
user_id = db.Column(db.Integer)
video_id = db.Column(db.Integer)
# tag: taiwan,car,...
tag = db.Column(db.String(2048))
def __init__(self, title, comment, user_id, video_id, tag):
self.title = title
self.comment = comment
self.user_id = user_id
self.video_id = video_id
self.tag = tag
class DeviceDemo(db.Model):
id = db.Column(
db.Integer,
autoincrement=True) # primary keys are required by SQLAlchemy
# email = db.Column(db.String(100), unique=True)
status = db.Column(db.Boolean(), default=False)
name = db.Column(db.String(1000), primary_key=True)
is_active = db.Column(db.Boolean(), default=False)
command = db.Column(db.Integer, default=-1)
class Categories(Base):
__tablename__ = 'categories'
name = db.Column('name', db.String(50), primary_key=True)
events = relationship('Events')
@staticmethod
def build_cat_dict(category):
result = {'name': category.name}
return result
class userTable(db.Model):
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(4096))
user_id = db.Column(db.Integer)
authkey = db.Column(db.String(4096))
login = db.Column(db.Integer)
read_access = db.Column(db.Integer)
write_access = db.Column(db.Integer)
def __init__(self, name, user_id, authkey, login, read_access,
write_access):
self.name = name
self.user_id = user_id
self.authkey = authkey
self.login = login
self.read_access = read_access
self.write_access = write_access
class UserInfo(db.Model):
__tablename__ = 'userinfo'
nid = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(32), unique=True)
password = db.Column(db.String(32))
email = db.Column(db.String(32), unique=True)
# ctime = db.Column(db.TIMESTAMP)
ctime = db.Column(db.DateTime,
nullable=False,
default=datetime.utcnow,
onupdate=datetime.utcnow)
__table_args__ = (
db.Index('ix_user_pwd', 'username', 'password'),
db.Index('ix_email_pwd', 'email', 'password'),
)
class UserProfile(db.Model):
id = db.Column(db.Integer, primary_key=True)
# User information
portfolio = db.Column(db.String(500), nullable=False, default='')
def __repr__(self):
return '<id: {}, portfolio: {}' \
.format(self.id, self.portfolio)
class Module(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(40))
content = db.Column(db.String(5000))
score = db.Column(db.Float)
module_id = db.Column(db.Integer)
paste_id = db.Column(db.Integer, db.ForeignKey('paste.id'))
def __init__(self, name, score, content, module_id, paste_id):
self.name = name
self.content = content
self.score = score
self.module_id = module_id
self.paste_id = paste_id
def __repr__(self):
return '<Module %r (%r) with score %r, connected to paste %r>' % (
self.name, self.id, self.score, self.paste_id)
class Fish(db.Model):
__tablename__ = 'fish'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(80), nullable=False)
feed_name = db.Column(db.String, db.ForeignKey('feed.name'))
def __init__(self, name):
self.name = name
class Question(db.Model): #A question class which associates each question with an id and question string
__tablename__ = "Question"
question_id = db.Column(db.Integer,primary_key=True,autoincrement=True) #primary key is true for id inorder to have unique question ids
question_string = db.Column(db.String(200),unique=True) #corresponding question string attached to class
def __init__(self,question_id,question_string): #constructor function for the class
self.question_id = question_id
self.question_string = question_string
class Category(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(50))
def __init__(self, name):
self.name = name
def __repr__(self):
return self.name
class intake(db.Model):
__tablename__ = 'Intakes'
id = db.Column(db.String(100), primary_key=True)
user_id = db.Column(db.ForeignKey(u'users.id', ondelete=u'CASCADE'),
nullable=False)
image_name = db.Column(db.String(100), nullable=False)
calories = db.Column(db.String)
user = relationship(u'User')
def transform(self):
return {
'id': self.id,
'image_name': self.image_name,
'calories': self.calories,
'user': self.user.transform()
}
class User(db.Model, UserMixin):
id = db.Column(db.Integer(), primary_key=True)
email = db.Column(db.String(255), unique=True)
password = db.Column(db.String(255))
scores = db.Column(db.Integer(), default=0)
active = db.Column(db.Boolean(), default=True)
roles = db.relationship('Role',
secondary=role_user_link,
backref=db.backref('users', lazy='dynamic'))
palindromes = db.relationship('Palindrome',
secondary=palindrome_user_link,
backref=db.backref('users', lazy='dynamic'))
def __repr__(self):
return 'ID: {}, Email: {}'.format(self.id, self.email)
class Users(UserMixin, db.Model):
id = db.Column(db.Integer, primary_key=True, nullable=False)
surname = db.Column(db.String(1000), nullable=False)
name = db.Column(db.String(1000), nullable=False)
patronymic = db.Column(db.String(1000), nullable=False)
department = db.Column(db.String(1000), nullable=False)
experience = db.Column(db.String(1000), nullable=False)
salary = db.Column(db.Integer, nullable=False)
login = db.Column(db.String(1000), unique=True, nullable=False)
password = db.Column(db.String(1000), nullable=False)
photo = db.Column(db.String(1000000), nullable=True)
class Todo(db.Model):
__tablename__ = 'todo'
id = db.Column(db.Integer, primary_key=True)
content = db.Column(db.String(200), nullable=False)
date_created = db.Column(db.DateTime, default=datetime.utcnow)
user_id = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
def __repr__(self):
return f'<Task {self.id:d}>'
class EngineType(db.Model):
'''
Engine class.
(name)
'''
__tablename__ = "engine_types"
engine_type_id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(60), nullable=False, unique=True)
engines = db.relationship('Engine', backref='engine_type')
class Answers(db.Model):
id = db.Column(db.Integer, primary_key=True)
answer = db.Column(db.String(120))
question_id = db.Column(db.Integer, db.ForeignKey('questions.id'))
direction_id = db.Column(db.Integer, db.ForeignKey('directions.id'))
def __init__(self, answer, question_id, direction_id):
self.answer = answer
self.question_id = question_id
self.direction_id = direction_id
class mEventTag(db.Model):
__tablename__ = 'm_event_tag'
# tag_id_seq = db.Sequence('tag_id_seq', metadata=Base.metadata, start=1001)
# tag_id = db.Column(db.BigInteger, tag_id_seq, server_default=tag_id_seq.next_value(), nullable=False, autoincrement=True, primary_key=True)
tag_id = db.Column(db.BigInteger,
nullable=False,
autoincrement=True,
primary_key=True)
tag_name = db.Column(db.String(128), nullable=False)
class Type(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
def __init__(self, id, name):
self.id = id
self.name = name
def __repr__(self):
return '<Type %s>' % self.name
class Pokemon(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(30))
rarity = db.Column(db.Integer)
ability_id = db.Column(db.Integer)
type_id_1 = db.Column(db.Integer)
type_1 = db.Column(db.String(20))
type_id_2 = db.Column(db.Integer)
type_2 = db.Column(db.String(20))
weight = db.Column(db.Integer)
height = db.Column(db.Integer)
hp = db.Column(db.Integer)
attack = db.Column(db.Integer)
defense = db.Column(db.Integer)
sp_attack = db.Column(db.Integer)
sp_defense = db.Column(db.Integer)
speed = db.Column(db.Integer)
description = db.Column(db.String(500))
def __init__(self, id, name, rarity, ability_id, type_id_1, type_1,
type_id_2, type_2, weight, height, hp, attack, defense,
sp_attack, sp_defense, speed, description):
self.id = id
self.name = name
self.rarity = rarity
self.ability_id = ability_id
self.type_id_1 = type_id_1
self.type_1 = type_1
self.type_id_2 = type_id_2
self.type_2 = type_2
self.weight = weight
self.height = height
self.hp = hp
self.attack = attack
self.defense = defense
self.sp_attack = sp_attack
self.sp_defense = sp_defense
self.speed = speed
self.description = description
def __repr__(self):
return '<Pokemon %s>' % self.name
class Feed(db.Model):
__tablename__ = 'feeds'
id = db.Column(db.String(100), primary_key=True)
title = db.Column(db.Text)
url = db.Column(db.Text)
rss_url = db.Column(db.Text)
app_id = db.Column(db.ForeignKey(u'apps.id', ondelete=u'CASCADE'),
nullable=False)
icon = db.Column(db.Text)
domain = db.Column(db.String(100))
alexa_rank = db.Column(db.Integer)
feed_updated_at = db.Column(db.DateTime,
nullable=False,
server_default=func.now())
created_at = db.Column(db.DateTime,
nullable=False,
server_default=func.now())
updated_at = db.Column(db.DateTime,
nullable=False,
onupdate=func.now(),
default=func.now())
categories = db.relationship("Category",
secondary=feed_article_category_table,
back_populates="feeds")
def category_list(self, categories):
dic = []
for category in categories:
dic.append(category.transform())
return dic
def transform(self):
return {
'id': self.id,
'title': self.title,
'url': self.rss_url,
'icon': self.icon,
'category': self.category_list(self.categories),
'alexa_rank': self.alexa_rank,
}
