class WorkPlace(db.Model):
__tablename__ = 'WorkPlace'
wp_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
wp_name = db.Column(db.String(45))
address = db.Column(db.String(255))
kakao_place_id = db.Column(db.String(45))
road_address = db.Column(db.String(255))
category_name = db.Column(db.String(255))
phone = db.Column(db.String(255))
bjd_code = db.Column(db.String(10))
building_name = db.Column(db.String(255))
business_code = db.Column(db.String(45))
owner = db.Column(db.String(45))
over_5employee = db.Column(db.Integer, server_default='1')
x = db.Column(db.Text)
y = db.Column(db.Text)
created_time = db.Column(db.DateTime, server_default=func.now())
updated_time = db.Column(db.DateTime)
class WorkCondition(db.Model):
__tablename__ = 'WorkCondition'
wcond_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
cont_id = db.Column(db.ForeignKey('WorkContract.cont_id',
ondelete='RESTRICT',
onupdate='RESTRICT'),
primary_key=True,
nullable=False,
index=True)
user_id = db.Column(db.Integer, nullable=False, index=True)
wp_id = db.Column(db.Integer, nullable=False)
target_ym = db.Column(db.String(6))
target_date = db.Column(db.String(2))
week_num = db.Column(db.Integer)
day_num = db.Column(db.Integer)
start_time = db.Column(db.Time)
end_time = db.Column(db.Time)
awork_time = db.Column(db.Time)
arest_time = db.Column(db.Time)
hourly_pay = db.Column(db.Integer)
daily_pay = db.Column(db.Integer)
tardy_code = db.Column(db.Integer, nullable=False, server_default='1')
wcond_status = db.Column(db.Integer, nullable=False, server_default='1')
created_time = db.Column(db.DateTime, server_default=func.now())
updated_time = db.Column(db.DateTime)
cont = db.relationship(
'WorkContract',
primaryjoin='WorkCondition.cont_id == WorkContract.cont_id',
backref='work_conditions')
class WorkContract(db.Model):
__tablename__ = 'WorkContract'
cont_id = db.Column(db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
user_id = db.Column(db.ForeignKey('User.user_id'),
nullable=False,
index=True)
wp_id = db.Column(db.ForeignKey('WorkPlace.wp_id'),
nullable=False,
index=True)
cont_date = db.Column(db.String(8), primary_key=True, nullable=False)
first_date = db.Column(db.String(8))
_1_start_pot = db.Column('1_start_pot', db.Time)
_1_end_pot = db.Column('1_end_pot', db.Time)
_1_rest_aot = db.Column('1_rest_aot', db.Time)
_2_start_pot = db.Column('2_start_pot', db.Time)
_2_end_pot = db.Column('2_end_pot', db.Time)
_2_rest_aot = db.Column('2_rest_aot', db.Time)
_3_start_pot = db.Column('3_start_pot', db.Time)
_3_end_pot = db.Column('3_end_pot', db.Time)
_3_rest_aot = db.Column('3_rest_aot', db.Time)
_4_start_pot = db.Column('4_start_pot', db.Time)
_4_end_pot = db.Column('4_end_pot', db.Time)
_4_rest_aot = db.Column('4_rest_aot', db.Time)
_5_start_pot = db.Column('5_start_pot', db.Time)
_5_end_pot = db.Column('5_end_pot', db.Time)
_5_rest_aot = db.Column('5_rest_aot', db.Time)
_6_start_pot = db.Column('6_start_pot', db.Time)
_6_end_pot = db.Column('6_end_pot', db.Time)
_6_rest_aot = db.Column('6_rest_aot', db.Time)
_7_start_pot = db.Column('7_start_pot', db.Time)
_7_end_pot = db.Column('7_end_pot', db.Time)
_7_rest_aot = db.Column('7_rest_aot', db.Time)
week_holiday = db.Column(db.Integer)
day_cnt = db.Column(db.Integer)
hourly_pay = db.Column(db.Integer)
monthly_pay = db.Column(db.Integer)
pinit_day = db.Column(db.Integer, server_default='1')
pay_day = db.Column(db.Integer, server_default='10')
time_offset = db.Column(db.Time, server_default='00:05:00')
having_photo = db.Column(db.String(255))
cont_status = db.Column(db.Integer, nullable=False, server_default='1')
created_time = db.Column(db.DateTime, server_default=func.now())
updated_time = db.Column(db.DateTime)
user = db.relationship('User',
primaryjoin='WorkContract.user_id == User.user_id',
backref='work_contracts')
wp = db.relationship('WorkPlace',
primaryjoin='WorkContract.wp_id == WorkPlace.wp_id',
backref='work_contracts')
class UserEntity(db.Model, UserMixin, CRUDMixin):
""" Stores the basic information about the user.
Implements the functions as required by:
https://flask-login.readthedocs.org/en/latest/
"""
__tablename__ = 'User'
id = db.Column("usrID", db.Integer, primary_key=True)
email = db.Column("usrEmail", db.String(255), nullable=False, unique=True)
first = db.Column("usrFirst", db.String(255), nullable=False)
last = db.Column("usrLast", db.String(255), nullable=False)
minitial = db.Column("usrMI", db.String(1), nullable=False)
added_at = db.Column("usrAddedAt",
db.DateTime,
nullable=False,
server_default='0000-00-00 00:00:00')
modified_at = db.Column("usrModifiedAt", db.TIMESTAMP, nullable=False)
email_confirmed_at = db.Column("usrEmailConfirmedAt",
db.DateTime,
nullable=False,
server_default='0000-00-00 00:00:00')
active = db.Column("usrIsActive",
db.Boolean(),
nullable=False,
server_default='1')
access_expires_at = db.Column("usrAccessExpiresAt",
db.DateTime,
nullable=False,
server_default='0000-00-00 00:00:00')
password_hash = db.Column("usrPasswordHash",
db.String(255),
nullable=False,
server_default='')
# @OneToMany
roles = db.relationship(RoleEntity,
secondary=UserRoleEntity.__tablename__,
backref=db.backref('users'),
lazy='dynamic')
"""
`lazy` defines when SQLAlchemy will load the data from the:
'select' (which is the default) means that SQLAlchemy will load the
data as necessary in one go using a standard select statement.
'joined' tells SQLAlchemy to load the relationship in the same query as the
parent using a JOIN statement.
'subquery' works like 'joined' but instead SQLAlchemy will use a subquery.
'dynamic' is special and useful if you have may items. Instead of loading
the items SQLAlchemy will return another query object which you can
further refine before loading them items. This is usually what you want
if you expect more than a handful of items for this relationship.
"""
def is_active(self):
""" An user can be blocked by setting a flag in the """
return self.active
def is_expired(self):
""" An user can be blocked by setting expiration date to yesterday"""
return self.access_expires_at < datetime.today()
def is_anonymous(self):
""" Flag instances of valid users """
return False
def is_authenticated(self):
""" Returns True if the user is authenticated, i.e. they have provided
valid credentials.
(Only authenticated users will fulfill the criteria of login_required.)
"""
return True
def get_id(self):
""" The id encrypted in the session """
return unicode(self.id)
def get_roles(self):
""" Return text representation of user roles """
return [role.name for role in self.roles]
def get_name(self):
"""
:rtype string
:return concat(first, ' ', last)
"""
return "{} {}".format(self.first.encode('utf-8'),
self.last.encode('utf-8'))
def get_email_verification_token(self, salt, secret):
"""
:rtype string
:return the email verification token stored in the
"""
return utils.get_email_token(self.email, salt, secret)
def serialize(self):
"""Return object data for jsonification"""
return {
'id':
self.id,
'email':
self.email,
'roles': [r.name for r in self.roles],
'first':
self.first,
'last':
self.last,
'minitial':
self.minitial,
'is_active':
True if self.active else False,
'is_expired':
True if self.is_expired() else False,
'added_at':
utils.localize_est_date(self.added_at),
'email_confirmed_at':
utils.localize_est_datetime(self.email_confirmed_at),
'access_expires_at':
utils.localize_est_datetime(self.access_expires_at)
}
def __repr__(self):
return "<UserEntity (usrID: {0.id}, usrEmail: {0.email}, " \
"usrIsActive: {0.active})>".format(self)
class Daily(db.Model):
__tablename__ = 'Daily'
daily_id = db.Column(db.String(50), primary_key=True, nullable=False)
wcond_id = db.Column(db.Integer, nullable=False)
cont_id = db.Column(db.String(45), nullable=False)
target_ym = db.Column(db.String(6), primary_key=True, nullable=False)
target_date = db.Column(db.String(2), primary_key=True, nullable=False)
week_num = db.Column(db.Integer)
day_num = db.Column(db.Integer)
work_start = db.Column(db.DateTime)
work_end = db.Column(db.DateTime)
act_work_time = db.Column(db.Time)
cont_work_time = db.Column(db.Time)
act_rest_time = db.Column(db.Time)
cont_rest_time = db.Column(db.Time)
over_time = db.Column(db.Time)
night_time = db.Column(db.Time)
holy_time = db.Column(db.Time)
tardy_time = db.Column(db.Time)
act_work_pay = db.Column(db.Integer)
cont_work_pay = db.Column(db.Integer)
over_pay = db.Column(db.Integer)
night_pay = db.Column(db.Integer)
holy_pay = db.Column(db.Integer)
tardy_pay = db.Column(db.Integer)
total_pay = db.Column(db.Integer)
created_time = db.Column(db.DateTime, server_default=func.now())
updated_time = db.Column(db.DateTime)
class User(db.Model):
"""
[summary]
Args:
UserMixin ([type]): [description]
db ([type]): [description]
"""
__tablename__ = "users"
id = db.Column(db.Integer, primary_key=True)
public_id = db.Column(db.String(50), unique=True)
username = db.Column(db.String(30), unique=True, nullable=False)
email = db.Column(db.String(100), unique=True, nullable=False)
name = db.Column(db.String(150), nullable=False)
admin = db.Column(db.Boolean, nullable=False, default=False)
password_hash = db.Column(db.String(100))
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = flask_bcrypt.generate_password_hash(password).decode('utf-8') if password else None
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password_hash, password)
@staticmethod
def encode_auth_token(user_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp': datetime.datetime.utcnow() + datetime.timedelta(days=1, seconds=5),
'iat': datetime.datetime.utcnow(),
'sub': user_id
}
return jwt.encode(
payload,
key,
algorithm='HS256'
)
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, key)
# is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)
# if is_blacklisted_token:
# return 'Token blacklisted. Please log in again.'
# else:
# return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
def __repr__(self):
return "<User '{}'>".format(self.username)
class User(db.Model, UserMixin):
"""
Description of User model.
Columns
-----------
:id: int [pk]
:username: varchar(128) [not NULL]
:password: varchar(128) [not NULL]
:first_name: varchar(255) [not NULL]
:last_name: varchar(255)
:dob: date
:email: varchar(255) [not NULL]
:fb_handle: varchar(255)
:twitter_handle: varchar(255)
:bio: text
:occupation: varchar(255)
:profile_picture: int
:last_login: timestamp
:creation_time: timestamp
:is_verified: boolean
# Relationships
:watch_list: Relationship -> Movies (one to Many)
:bucket_list: Relationship -> Movies (one to Many)
"""
# Columns
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(128), unique=True, nullable=False)
password = db.Column(db.String(128), nullable=False)
first_name = db.Column(db.String(255), default="")
last_name = db.Column(db.String(255), default="")
dob = db.Column(db.DateTime)
email = db.Column(db.String(255), nullable=False)
fb_handle = db.Column(db.String(255))
twitter_handle = db.Column(db.String(255))
instagram_handle = db.Column(db.String(255))
profile_picture = db.Column(db.Integer)
bio = db.Column(db.Text)
favourites = db.Column(db.JSON)
last_login = db.Column(db.DateTime)
creation_time = db.Column(db.DateTime, default=datetime.datetime.now())
is_verified = db.Column(db.Boolean, default=False)
seen_list_titles = db.Column(db.JSON, default={})
seen_list_IDs = db.Column(db.JSON, default={})
bucket_list_titles = db.Column(db.JSON, default={})
bucket_list_IDs = db.Column(db.JSON, default={})
recommend_list_titles = db.Column(db.JSON, default={})
recommend_list_IDs = db.Column(db.JSON, default={})
# Relationships
movie_list = db.relationship('Movie', backref="user")
posts = db.relationship('Post', backref="user")
# comments = db.relationship('Comment', backref="user")
def __init__(self, username, password, email):
self.username = username
self.password = generate_password_hash(password)
self.email = email
self.is_verified = False
self.profile_picture = 1
db.session.add(self)
db.session.commit()
@staticmethod
@login_manager.user_loader
def load_user(id):
return User.query.filter_by(id=id).first()
@staticmethod
@login_manager.request_loader
def load_user_from_request(request):
try:
token = request.headers.get('Authorization')
if token:
user_id = decode_token(token)
username = user_id['identity']
user = User.query.filter_by(username=username).first()
if user:
return user
except Exception as e:
print(e)
return None
def update_col(self, key, value):
setattr(self, key, value)
db.session.commit()
def check_password(self, password):
return check_password_hash(self.password, password)
def resetPassword(self, newPassword):
# Pass in a hashed password
self.password = generate_password_hash(newPassword)
db.session.commit()
def isVerified(self):
return self.is_verified
def setVerified(self):
self.is_verified = True
db.session.commit()
def add_to_movie_list(self, imdb_ID):
movie = Movie.query.filter_by(imdb_ID=imdb_ID).first()
self.movie_list.append(movie)
db.session.commit()
class Resource(TimestampMixin, db.Model):
__tablename__ = 'resources'
id = db.Column(db.BigInteger, primary_key=True)
category_id = db.Column(db.BigInteger,
db.ForeignKey('categories.id',
onupdate='CASCADE',
ondelete='RESTRICT'),
nullable=False)
category = db.relationship('Category', backref='resources')
user_id = db.Column(db.BigInteger,
db.ForeignKey('users.id',
onupdate='CASCADE',
ondelete='CASCADE'),
nullable=False)
user = db.relationship('User', backref='resources')
description = db.Column(db.UnicodeText(), nullable=True)
type = db.Column(sau.ChoiceType(USER_RESOURCE_TYPES), index=True)
quantity_available = db.Column(db.BigInteger)
quantity_needed = db.Column(db.BigInteger)
fulfilled = db.Column(db.Boolean,
nullable=False,
default=False,
server_default='0')
name = db.Column(db.UnicodeText(), nullable=False)
picture = db.Column(db.UnicodeText())
requested = db.Column(db.Boolean(), nullable=True, default=False)
def __setattr__(self, name, value):
if name == 'picture':
if value:
filename = '{}.{}'.format(self.id,
value.filename.split('.')[-1])
super().__setattr__(
'picture', upload_file(value, 'resource_pictures',
filename))
else:
super().__setattr__(name, value)
@property
def picture_url(self):
if not self.picture:
return None
return file_url(self.picture)
@property
def quantity_remaining(self):
if self.type != 'HAVE':
return None
fulfillment = ResourceFulfillment.query.filter(
ResourceFulfillment.fulfilling_resource == self,
ResourceFulfillment.confirmed_by_recipient == True,
)
return self.quantity_available - sum(
[f.fulfilled_quantity for f in fulfillment])
@property
def quantity_fulfilled(self):
if self.type != 'NEED':
return None
fulfillment = ResourceFulfillment.query.filter(
ResourceFulfillment.fulfilled_resource == self,
ResourceFulfillment.confirmed_by_recipient == True,
)
return self.quantity_needed - sum(
[f.fulfilled_quantity for f in fulfillment])
def serialize(self):
return {
'id': self.id,
'name': self.name,
'category': self.category.name,
'user_id': self.user.id,
'type': self.type.code,
'quantity_available': self.quantity_available,
'quantity_needed': self.quantity_needed,
'fulfilled': self.fulfilled,
}
class User(UserMixin, TimestampMixin, db.Model):
__tablename__ = 'users'
id = db.Column(db.BigInteger, primary_key=True)
name = db.Column(db.UnicodeText, nullable=False)
username = db.Column(db.Unicode(64), unique=True, nullable=False)
password = db.Column(db.UnicodeText, nullable=False)
email = db.Column(db.UnicodeText(), nullable=True)
phone = db.Column(db.Unicode(255), nullable=True)
secondary_phone = db.Column(db.Unicode(255), nullable=True)
bio = db.Column(db.UnicodeText, nullable=False)
association = db.Column(db.Unicode(64), nullable=True)
primary_role = db.Column(sau.ChoiceType(PRIMARY_ROLE))
language = db.Column(db.String(2), nullable=False)
country = db.Column(db.String(2), nullable=False)
picture = db.Column(db.UnicodeText())
def __setattr__(self, name, value):
if name == 'picture':
filename = '{}.{}'.format(self.id, value.filename.split('.')[-1])
super().__setattr__('picture',
upload_file(value, 'user_pictures', filename))
else:
super().__setattr__(name, value)
@property
def picture_url(self):
if not self.picture:
return None
return file_url(self.picture)
@login_manager.user_loader
def load_user(id):
return User.query.get(int(id))
def set_password(self, password):
self.password = generate_password_hash(password)
def check_password(self, password):
return check_password_hash(self.password, password)
@property
def resources_needed(self):
resources_needed = []
for resource in Resource.query.filter(Resource.user_id == self.id,
Resource.type == 'NEEDED'):
resources_needed.append(resource.name)
return ", ".join(resources_needed)
from random import sample
from sqlalchemy.ext.hybrid import hybrid_property
from sqlalchemy.sql import and_, join, or_, select
# from . import *
from app.main import db
from app.main.models.enums import PostType
# from app.main.models.users import User
from app.main.models.errors import LoginError
from app.main.models.imgLinks import ImgLink, imgPostJunction
from app.main.models.tags import Tag
postTagJunction = db.Table('postTagJunction',
db.Column('post_id', db.Integer,
db.ForeignKey('post.post_id'),
primary_key=True),
db.Column('tag_id', db.Integer,
db.ForeignKey('tag.id'),
primary_key=True)
)
class Post(db.Model):
"""
Description of Post model.
Rows
-----------
:post_id: int [pk]
:authorId: varchar [ref: > users.id]
:title: varchar
class Post(db.Model):
"""
Description of Post model.
Rows
-----------
:post_id: int [pk]
:authorId: varchar [ref: > users.id]
:title: varchar
:body: text
:post_time: timestamp [not null]
:avg_rating: float
:num_rating: int
"""
# Columns
post_id = db.Column(db.Integer, primary_key=True)
# _author_id = db.Column(db.String(256), db.ForeignKey(
# 'user.username'), nullable=False)
author_name = db.Column(db.String(256), nullable=False)
title = db.Column(db.String(128), nullable=False)
body = db.Column(db.Text, nullable=False)
post_time = db.Column(db.DateTime, default=datetime.datetime.now())
avg_rating = db.Column(db.Float, default=0.0)
num_rating = db.Column(db.Integer, default=0)
# Relationships
# author = db.relationship('User', backref='posts', lazy=False)
tags = db.relationship('Tag', secondary=postTagJunction, lazy='subquery',
backref=db.backref('posts', lazy=True))
images = db.relationship('ImgLink', secondary=imgPostJunction,
lazy='subquery')
def __init__(self, author, title, body):
self.author_name = author
self.title = title
self.body = body
db.session.add(self)
db.session.commit()
def delete(self):
db.session.delete(self)
db.session.commit()
@staticmethod
def getArticlesByTags(tagList, connector='OR'):
"""
Get all articles that have a tag in tagList.
If connector is AND intersection of all posts set for each tag will be
returned. If it is OR, union will be returned
"""
stmt = select([Post,
postTagJunction.c.post_id.label("pid"),
postTagJunction.c.tag_id]).distinct().where(and_(postTagJunction.c.post_id == Post.post_id,
postTagJunction.c.tag_id.in_(tagList)))
result = db.session.execute(stmt)
results = result.fetchall()
# return results
# taking only unique values
unique_results = dict()
# print(results.c)
for result in results:
# print(dict(result))
if unique_results.get(result.post_id, 0) == 0:
unique_results[result.post_id] = result
# print(unique_results[1].post_id)
return unique_results.values()
@staticmethod
def getArticles(post_id):
return Post.query.filter_by(post_id=post_id).first()
@staticmethod
def getRandomizedArticles(size):
return sample(Post.query.all(), size)
def addTags(self, list_of_tags):
self.tags.extend(list_of_tags)
db.session.commit()
def associateImage(self, imgId):
img = ImgLink.query.filter_by(id=imgId).first()
self.images.append(img)
db.session.commit()
def tagDump(self):
dump = []
for tag in self.tags:
dump.append(tag.name)
return dump
def linkDump(self):
dump = []
for img in self.images:
dump.append(img.link)
return dump
class Flavor(db.Model):
__bind_key__ = 'nova_api'
__tablename__ = 'flavors'
created_at = db.Column(db.DateTime)
updated_at = db.Column(db.DateTime)
name = db.Column(db.String(255), nullable=False, unique=True)
id = db.Column(db.Integer, primary_key=True)
memory_mb = db.Column(db.Integer, nullable=False)
vcpus = db.Column(db.Integer, nullable=False)
swap = db.Column(db.Integer, nullable=False)
vcpu_weight = db.Column(db.Integer)
flavorid = db.Column(db.String(255), nullable=False, unique=True)
rxtx_factor = db.Column(db.Float)
root_gb = db.Column(db.Integer)
ephemeral_gb = db.Column(db.Integer)
disabled = db.Column(db.Integer)
is_public = db.Column(db.Integer)
description = db.Column(db.Text)
class Student(db.Model):
"""
[summary]
Args:
UserMixin ([type]): [description]
db ([type]): [description]
"""
__tablename__ = 'student'
student_id = db.Column(db.Integer, primary_key=True, autoincrement=True)
student_name = db.Column(db.String(250), nullable=False)
student_email = db.Column(db.String(250), unique=True, nullable=False)
password_hash = db.Column(db.String(250), nullable=False)
student_img = db.Column(db.Text, nullable=True)
student_batch_id = db.Column(db.Integer,
db.ForeignKey('batch.batch_id'),
nullable=False)
student_gender = db.Column(db.String(50), nullable=True)
student_mobile = db.Column(db.Integer, nullable=True)
student_section_id = db.Column(db.Integer,
db.ForeignKey('section.section_id'),
nullable=True)
batch = db.relationship('Batch', backref=db.backref('student', lazy=True))
section = db.relationship('Section',
backref=db.backref('student', lazy=True))
@property
def password(self):
raise AttributeError('password: write-only field')
@password.setter
def password(self, password):
self.password_hash = flask_bcrypt.generate_password_hash(
password).decode('utf-8') if password else None
def check_password(self, password):
return flask_bcrypt.check_password_hash(self.password_hash, password)
@staticmethod
def encode_auth_token(admin_id):
"""
Generates the Auth Token
:return: string
"""
try:
payload = {
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(days=1, seconds=5),
'iat':
datetime.datetime.utcnow(),
'sub':
admin_id
}
return jwt.encode(payload, key, algorithm='HS256')
except Exception as e:
return e
@staticmethod
def decode_auth_token(auth_token):
"""
Decodes the auth token
:param auth_token:
:return: integer|string
"""
try:
payload = jwt.decode(auth_token, key)
# is_blacklisted_token = BlacklistToken.check_blacklist(auth_token)
# if is_blacklisted_token:
# return 'Token blacklisted. Please log in again.'
# else:
# return payload['sub']
except jwt.ExpiredSignatureError:
return 'Signature expired. Please log in again.'
except jwt.InvalidTokenError:
return 'Invalid token. Please log in again.'
def __repr__(self):
return "<User '{}'>".format(self.admin_email)
class FlightDetails(db.Model): __tablename__ = 'flight_details' id = db.Column(db.Integer, primary_key = True, autoincrement = True) flight_number = db.Column(db.String(100), primary_key = True) source = db.Column(db.String(200), nullable = False) destination = db.Column(db.String(200), nullable = False) flight_date = db.Column(db.Date, primary_key = True) departure_time = db.Column(db.Time(timezone = False), nullable = False) #departure from the source destination_arrival_time = db.Column(db.Time(timezone = False), nullable = False) #arrival at the destination total_seats = db.Column(db.Integer, nullable = False) booked_seats = db.Column(db.Integer, default = 0) created_at = db.Column(db.DateTime(timezone=False), default=datetime.now(), nullable=False) updated_at = db.Column(db.DateTime(timezone=False), default=datetime.now(), nullable=False)
class TUser(db.Model):
"""
用户表
"""
__tablename__ = 't_user'
user_id = db.Column(db.Integer,
primary_key=True,
autoincrement=True,
nullable=False)
account = db.Column(db.String(255))
password = db.Column(db.String(255))
nickname = db.Column(db.String(255))
avatar = db.Column(db.String(255))
is_login = db.Column(db.Integer)
role_id = db.Column(db.Integer)
is_disabled = db.Column(db.Integer)
create_time = db.Column(db.DateTime, default=datetime.datetime.now)
update_time = db.Column(db.DateTime,
default=datetime.datetime.now,
onupdate=datetime.datetime.now)
hometown = db.Column(db.String(255))
sex = db.Column(db.String(255))
open_id = db.Column(db.Integer)
def json_data(self):
"""
将对象转换为字典数据
:return:
"""
return {
'user_id': self.user_id,
'account': self.account,
'password': self.password,
'nickname': self.nickname,
'avatar': self.avatar,
'role_id': self.role_id,
'is_login': self.is_login,
'is_disabled': self.is_disabled,
'create_time': self.create_time,
'hometown': self.hometown,
'update_time': self.update_time,
'sex': self.sex,
'open_id': self.open_id,
}
def __repr__(self):
return '<TUser %r>' % self.account
class SmartClassOnlineAccountEvent(db.Model):
__tablename__ = 'smartclass_scheduler_online_account_events'
id = db.Column('id', db.Integer(), primary_key=True, autoincrement=True)
account_id = db.Column(
'account_id',
db.ForeignKey('smartclass_scheduler_online_accounts.id'),
nullable=False)
title = db.Column('title',
db.String(255),
nullable=False,
info={'label': u'กิจกรรม'})
start = db.Column('start',
db.DateTime(timezone=True),
nullable=False,
info={'label': u'เริ่ม'})
end = db.Column('end',
db.DateTime(timezone=True),
nullable=False,
info={'label': u'สิ้นสุด'})
occupancy = db.Column('occupancy',
db.Integer(),
info={'label': u'ผู้เข้าร่วม'})
approved = db.Column('approved', db.Boolean(), default=True)
created_at = db.Column('created_at',
db.DateTime(timezone=True),
server_default=func.now())
created_by = db.Column('created_by', db.ForeignKey('staff_account.id'))
creator = db.Column('creator',
db.String(),
nullable=True,
info={'label': u'ชื่อผู้ลงทะเบียน'})
updated_at = db.Column('updated_at',
db.DateTime(timezone=True),
server_default=None)
updated_by = db.Column('updated_by', db.ForeignKey('staff_account.id'))
cancelled_at = db.Column('cancelled_at',
db.DateTime(timezone=True),
server_default=None)
cancelled_by = db.Column('cancelled_by', db.ForeignKey('staff_account.id'))
approved_by = db.Column('approved_by', db.ForeignKey('staff_account.id'))
approved_at = db.Column('approved_at',
db.DateTime(timezone=True),
server_default=None)
note = db.Column('note', db.Text(), info={'label': u'หมายเหตุ'})
account = db.relationship(SmartClassOnlineAccount,
backref=db.backref('events'))
