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'))