class Creator(FlagMixin, db.Model):
id = db.Column(db.Integer, primary_key=True)
role = db.Column(db.Enum(BookRoles))
book_id = db.Column(db.Integer, db.ForeignKey('book.id'))
person_id = db.Column(db.Integer, db.ForeignKey('person.id'))
@property
def is_incorrect(self):
return self.incorrect
def __eq__(self, other):
if isinstance(other, Creator):
return (self.role, self.person.id) == (other.role, other.person.id)
class Member(db.Model):
__table_args__ = ({'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'})
id = db.Column(db.VARCHAR(20), primary_key=True, nullable=False)
user_id = db.Column(db.Integer, default=None)
status = db.Column(db.Enum('REG', 'OWN', 'OPE'),
nullable=False,
default='REG')
nickname = db.Column(db.VARCHAR(360), nullable=False)
birthday = db.Column(db.DATE, default=None)
gender = db.Column(db.Enum('M', 'F'), nullable=False, default='M')
pref_code = db.Column(db.VARCHAR(2), nullable=False)
email = db.Column(db.VARCHAR(255), nullable=False)
email_status = db.Column(db.Enum('DELIVERY', 'UNDELIVERY', 'STOP'),
nullable=False,
default='STOP')
email_permission = db.Column(db.Enum('VLD', 'STP'),
nullable=False,
default='STP')
session_key = db.Column(db.VARCHAR(255), default=None)
is_delete = db.Column(TINYINT(1), nullable=False, default=0)
reg_datetime = db.Column(db.DATETIME, default=datetime.now)
mod_datetime = db.Column(db.DATETIME,
default=datetime.now,
onupdate=datetime.now)
class User(BaseModel):
""" 用户模型
"""
__tablename__ = "user"
name = Column("name",
db.String(32),
nullable=False,
comment="名字",
validator=(Schema(
And(str, lambda v: len(v) >= 3 and len(v) <= 20)),
"长度必须3~20位"))
nickname = Column("nickname", db.String(64), comment="昵称")
gender = Column("gender",
db.SmallInteger,
comment="性别",
validator=(Schema(lambda v: v in set([0, 1, 2])),
"值须为[0, 1, 2]之一"))
avatar = Column("avatar", db.String(256), comment="头像")
mobile = Column("mobile", db.String(16), comment="手机")
email = Column(
"email",
db.String(32),
comment="邮箱",
validator=(Regex(r"^[A-Za-z0-9\.\+_-]+@[A-Za-z0-9\._-]+\.[a-zA-Z]*$"),
"格式不正确"))
homepage = Column("homepage", db.String(256), comment="个人主页")
birthday = Column("birthday", db.Date, comment="生日")
height = Column("height", db.Float, comment="身高(cm)")
bloodType = Column(
"blood_type",
db.Enum("A", "B", "AB", "O", "NULL"),
comment="血型(ABO)",
validator=(Schema(lambda v: v in set(["A", "B", "AB", "O", "NULL"])),
"值必须为[A,B,AB,O,NULL]之一"))
notice = Column("notice", db.Text, comment="备注")
intro = Column("intro", db.Text, comment="简介")
address = Column("address", db.JSON, comment="地址")
lives = Column("lives", db.JSON, comment="生活轨迹")
tags = Column("tags", db.JSON, comment="标签")
luckyNumbers = Column("lucky_numbers", db.JSON, comment="幸运数字")
score = Column("score",
db.Integer,
comment="积分",
validator=(Schema(int), "必须为整数"))
userNo = Column("user_no", db.Integer, autoincrement=True, comment="编号")
roles = db.relationship('Role', secondary=user_role, backref="users")
class Auth(BaseModel):
""" 鉴权模型
"""
__tablename__ = "auth"
userId = Column("user_id",
db.String(64),
db.ForeignKey('user.id'),
nullable=False,
comment="用户ID")
user = db.relationship("User", backref="auths")
# user = db.relationship("User", back_populates="auths")
authType = Column("auth_type",
db.Enum("account", "email", "phone", "wechat", "weibo"),
nullable=False,
comment="鉴权类型")
authName = Column("auth_name",
db.String(128),
nullable=False,
comment="鉴权名称")
authCode = Column("auth_code", db.String(128), comment="鉴权识别码")
verifyTime = Column("verify_time", db.DateTime, comment="认证时间")
expireTime = Column("expire_time", db.DateTime, comment="过期时间")
isEnabled = Column("is_enabled", db.Boolean, default=True, comment="是否启用")
class Book(SearchableMixin, FlagMixin, db.Model):
__sayt__ = 'title'
id = db.Column(db.Integer, primary_key=True)
ISBN_REGEX = r'^(97(8|9))?\d{9}(\d|X)$'
isbn = db.Column(db.String(13), nullable=True)
title = db.Column(db.String(255), nullable=False)
origin_title = db.Column(db.String(255), nullable=True)
first_print = db.Column(db.Boolean(), nullable=True)
origin_language = db.Column(db.String(32), nullable=True) # enum?
pub_year = db.Column(db.String(32), nullable=True)
# pub_place = db.Column(db.String(64)) # do osobnego modelu m2m
first_edition = db.Column(db.String(64), nullable=True)
literary_form = db.Column(db.Enum(FormChoices), nullable=True)
genre = db.Column(db.String(64), nullable=True) # enum?
#fiction = db.Column(db.Enum(FictionChoices), nullable=True)
fiction = db.Column(db.Boolean(), nullable=True)
# subject = db.Column(db.String(64), nullable=True)
precision = db.Column(db.Text, nullable=True)
nukat = db.Column(db.Text, nullable=True)
publisher_id = db.Column(db.Integer,
db.ForeignKey('publisher.id'),
nullable=True)
city_id = db.Column(db.Integer, db.ForeignKey('city.id'), nullable=True)
serie_id = db.Column(db.Integer, db.ForeignKey('serie.id'), nullable=True)
creator = db.relationship('Creator', backref='book', lazy='dynamic')
copies = db.relationship('Copy', backref='book', lazy='dynamic')
def __str__(self):
return self.title
def print_authors(self):
authors = [c.person.name for c in self.creator if c.role._name_ == 'A']
# return authors
return ", ".join(authors)
def print_trans(self):
trans = [c.person.name for c in self.creator if c.role._name_ == 'T']
return ", ".join(trans)
def print_red(self):
red = [c.person.name for c in self.creator if c.role._name_ == 'R']
return ", ".join(red)
def print_intro(self):
intro = [c.person.name for c in self.creator if c.role._name_ == 'I']
return ", ".join(intro)
def person_authors(self):
return [c.person for c in self.creator.filter_by(role='A')]
def authors(self):
return Creator.query.filter_by(role='A', book=self)
def translators(self):
return Creator.query.filter_by(role='T', book=self)
def redaction(self):
return Creator.query.filter_by(role='R', book=self)
def introduction(self):
return Creator.query.filter_by(role='I', book=self)
def same_author_title(self, other):
'''Returns if two book instances has the same title and the same authors'''
if isinstance(other, Book):
return (self.authors().all()
== other.authors().all()) and (self.title == other.title)
@property
def is_incorrect(self):
return any(c.person.incorrect for c in self.creator)\
or self.city.incorrect or \
self.publisher.incorrect or self.incorrect
class GmoCredit(db.Model):
__table_args__ = ({'mysql_engine': 'InnoDB', 'mysql_charset': 'utf8'})
id = db.Column('credit_id',
db.Integer,
primary_key=True,
nullable=False,
autoincrement=True)
user_id = db.Column(INTEGER(unsigned=True), index=True, nullable=False)
gmo_member_id = db.Column('user_gmo_member_id',
db.VARCHAR(60, collation='utf8_unicode_ci'),
nullable=False)
status = db.Column('credit_status',
db.Enum('未決済', '即時売上', '取消', '実売上', '仮売上'),
nullable=False,
default='未決済')
error_code = db.Column('credit_error_code',
db.VARCHAR(100, collation='utf8_unicode_ci'),
default=None)
check_string = db.Column('credit_check_string',
db.VARCHAR(32, collation='utf8_unicode_ci'),
default=None)
access_id = db.Column('credit_access_id',
db.VARCHAR(32, collation='utf8_unicode_ci'),
default=None)
access_pass = db.Column('credit_access_pass',
db.VARCHAR(32, collation='utf8_unicode_ci'),
default=None)
forward = db.Column('credit_forward',
db.VARCHAR(10, collation='utf8_unicode_ci'),
default=None)
approve = db.Column('credit_approve',
db.VARCHAR(10, collation='utf8_unicode_ci'),
default=None)
order_id = db.Column('credit_order_id',
db.VARCHAR(30, collation='utf8_unicode_ci'),
default=None)
tran_id = db.Column('credit_tran_id',
db.VARCHAR(28, collation='utf8_unicode_ci'),
default=None)
tran_date = db.Column('credit_tran_date',
db.VARCHAR(14, collation='utf8_unicode_ci'),
default=None)
convenience = db.Column('credit_convenience',
db.VARCHAR(5, collation='utf8_unicode_ci'),
default=None)
receipt_no = db.Column('credit_receipt_no',
db.VARCHAR(32, collation='utf8_unicode_ci'),
default=None)
conf_no = db.Column('credit_conf_no',
db.VARCHAR(20, collation='utf8_unicode_ci'),
default=None)
encrypt_receipt_no = db.Column('credit_encrypt_receipt_no',
db.VARCHAR(128,
collation='utf8_unicode_ci'),
default=None)
bk_code = db.Column('credit_bk_code',
db.VARCHAR(5, collation='utf8_unicode_ci'),
default=None)
cust_id = db.Column('credit_cust_id',
db.VARCHAR(11, collation='utf8_unicode_ci'),
default=None)
payment_term = db.Column('credit_payment_term',
db.VARCHAR(14, collation='utf8_unicode_ci'),
default=None)
reg_datetime = db.Column('gmo_credit_reg_datetime',
db.DATETIME,
default=datetime.now)
mod_datetime = db.Column('gmo_credit_mod_datetime',
db.DATETIME,
default=datetime.now,
onupdate=datetime.now)
class StockTransaction(db.Model):
__tablename__ = "stock_transaction"
id = db.Column(db.Integer, primary_key=True)
"""StockTransaction's id"""
transaction_type = db.Column(db.Enum(StockTransactionType), nullable=False)
"""StockTransaction's transaction type"""
stock_symbol = db.Column(db.String(16), nullable=False)
"""StockTransaction's stock ticker symbol"""
cost_per_unit = db.Column(db.Integer, nullable=False)
"""StockTransaction's cost per unit of stock in cents"""
quantity = db.Column(db.Integer, nullable=False)
"""The quantity of the stock symbol in this stock transaction"""
trade_fee = db.Column(db.Integer, nullable=False)
"""StockTransaction's trade commission fee in cents"""
trade_date = db.Column(db.DateTime, nullable=False)
"""The date that this stock transaction occurred"""
account_id = db.Column(db.Integer, db.ForeignKey('investment_account.id'))
"""The investment account's id that this stock transaction belongs to"""
user_id = db.Column(db.Integer,
db.ForeignKey('portfolio_user.id'),
nullable=False)
"""The id of the user that made this stock transaction"""
DATA_KEYS = [
'transaction_type', 'stock_symbol', 'cost_per_unit', 'quantity',
'trade_fee', 'trade_date'
]
"""The names of the data fields that need to be serialized"""
def __iter__(self):
yield ('id', self.id)
yield ('transaction_type', self.transaction_type.name)
yield ('stock_symbol', self.stock_symbol)
yield ('cost_per_unit', str(Decimal(self.cost_per_unit) / 100))
yield ('quantity', self.quantity)
yield ('trade_fee', str(Decimal(self.trade_fee) / 100))
yield ('trade_date', self.trade_date.strftime('%Y-%m-%d'))
yield ('account_id', self.account_id)
@staticmethod
def serialize(data):
"""
Returns a dict with the fields formatted in the way the client
expects them
"""
return dict(id=data['id'],
transaction_type=data['transaction_type'].name,
stock_symbol=data['stock_symbol'].upper(),
cost_per_unit=str(Decimal(data['cost_per_unit']) / 100),
quantity=data['quantity'],
trade_fee=str(Decimal(data['trade_fee']) / 100),
trade_date=data['trade_date'].strftime('%Y-%m-%d'),
account_id=data['account_id'])
@staticmethod
def deserialize(data):
"""
Returns a dict with the fields formatt
Keyword arguments:
data -- a dict with the stock transaction fields in the client format
"""
transaction_key = data['transaction_type'].replace(' ', '_').lower()
data['transaction_type'] = StockTransactionType[transaction_key]
data['stock_symbol'] = data['stock_symbol'].upper()
data['cost_per_unit'] = int(Decimal(data['cost_per_unit']) * 100)
data['quantity'] = int(data['quantity'])
data['trade_fee'] = int(Decimal(data['trade_fee']) * 100)
data['trade_date'] = date.fromisoformat(data['trade_date'])
return apply_user_id(data)