class User(db.Model):
""" User Model for storing user related details """
__tablename__ = "User"
id = db.Column(db.Integer, primary_key=True, autoincrement=True)
username = db.Column(db.String(255), unique=True, nullable=False)
useremail = db.Column(db.String(255), nullable=False)
password = db.Column(db.String(255), nullable=False)
class Comments(db.Model):
__tablename__ = "Comments"
id = db.Column(db.Integer, primary_key=True)
body = db.Column(db.Text, nullable=False)
author_id = db.Column(db.Integer, db.ForeignKey("user.id"))
comment_author = db.relationship("User", back_populates="comments")
class WeiBoOauth(db.Model):
"""创建微博第三方登录"""
# 添加外键约束
id = db.Column(db.Integer, primary_key=True)
wb_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
openid = db.Column(db.String(128), nullable=False)
class QQOauth(db.Model):
"""创建QQ第三方登录"""
# 添加外键约束
id = db.Column(db.Integer, primary_key=True)
# 创建外键,参照主表的id
qq_user_id = db.Column(db.Integer,
db.ForeignKey('user.id'),
nullable=False)
openid = db.Column(db.String(128), nullable=False)
class User(UserMixin, db.Model):
__tablename__ = "user"
id = db.Column(db.Integer,
primary_key=True,
nullable=False,
auto_increment=True)
user_name = db.Column(db.String(length=30), nullable=False, unique=True)
email = db.Column(db.String(length=50), nullable=False, unique=True)
password_hash = db.Column(db.String(length=60), nullable=False)
blog_post = db.relationship('BlogPost', back_populates="author")
comments = db.relationship("Comments", back_populates="comment_author")
class User(db.Model):
"""创建用户表"""
id = db.Column(db.Integer(), primary_key=True) # 整型主键
username = db.Column(db.String(30))
phone = db.Column(db.String(11), nullable=False)
password = db.Column(db.String(30), nullable=False)
# 多对一关系,如果想要一对一,添加uselist=False
# backref:反向引用,在QQOauth类型上声明一个新属性,用于QQOauth的实例通过该属性访问该模型实例
# lazy决定了sqlalchemy何时从数据库中加载数据, dynamic懒加载,返回查询对象,可进一步过滤后hit数据库
qq_auth = db.relationship('QQOauth', backref='user', lazy='dynamic')
def __init__(self, username, phone, password):
self.username = username
self.phone = phone
self.password = password
def __repr__(self):
return f"<[User] username:{self.username}, phone: {self.phone}"
class BlogPost(db.Model):
__tablename__ = "blog_posts"
id = db.Column(db.Integer, primary_key=True)
title = db.Column(db.String(250), unique=True, nullable=False)
subtitle = db.Column(db.String(250), nullable=False)
date = db.Column(db.String(250), nullable=False)
body = db.Column(db.Text, nullable=False)
img_url = db.Column(db.String(250), nullable=False)
author_id = db.Column(db.Integer(), db.ForeignKey('user.id'))
author = db.relationship("User", back_populates="blog_post")
class SessionModel(db.Model):
id = db.Column(db.Integer, primary_key=True)
access_token = db.Column(db.String(), unique=True)
refresh_token = db.Column(db.String(), unique=True)
@property
def get_access_token(self):
return self.access_token
@property
def get_refresh_token(self):
return self.refresh_token
def save(self):
db.session.add(self)
db.session.commit()
@staticmethod
def delete():
db.session.query(SessionModel).delete()
db.session.commit()
class KeyModel(db.Model):
id_ = db.Column(db.Integer, primary_key=True)
provider_type_ = db.Column(db.Integer)
p_id_ = db.Column(db.Integer)
policy_ = db.Column(db.Integer)
key_pair_ = db.Column(db.LargeBinary)
user_blind_sig_ = db.Column(db.String)
interval_timestamp_ = db.Column(db.Integer)
proof_hash_ = db.Column(db.String)
def __init__(self, provider_type: int, p_id: int, policy: int = 1, signer: UserBlindSignature = None,
interval: int = None):
check = KeyModel.query.filter_by(provider_type_=provider_type, p_id_=p_id, policy_=policy,
interval_timestamp_=interval)
if check.first() is not None:
raise Exception("KeyModel already exists")
else:
self.type = provider_type
self.p_id_ = p_id
self.policy_ = policy
self.key_pair_ = ECC.generate(curve='P-256').export_key(format='DER')
self.user_blind_sig_ = signer.encode() if signer is not None else None
self.interval_timestamp_ = interval
@property
def id(self) -> int:
return self.id_
@property
def signer(self) -> UserBlindSignature:
return UserBlindSignature().decode(self.user_blind_sig_)
@signer.setter
def signer(self, signer) -> None:
self.user_blind_sig_ = signer.encode() if signer is not None else None
@property
def type(self) -> str:
if self.provider_type_ == 1:
return 'CP'
elif self.provider_type_ == 2:
return 'AP'
else:
raise ValueError("Unexpected value for provider_type in user.KeyModel")
@type.setter
def type(self, p_type: str):
if p_type == 'CP':
self.provider_type_ = 1
elif p_type == 'AP':
self.provider_type_ = 2
else:
raise Exception('Invalid provider_type assignment in user.KeyModel')
@property
def p_id(self) -> int:
"""
:return: cp: String
"""
return self.p_id_
@property
def key_pair(self) -> ECC:
"""
:return: ECC object
"""
return ECC.import_key(encoded=self.key_pair_)
@property
def public_key(self) -> bytes:
"""
Returns a DER encoded copy of the public key stored
:return: (bytes)
"""
key = self.key_pair
return key.public_key().export_key(format='DER')
@property
def interval_timestamp(self) -> int:
"""
:return: POSIX timestamp: int
"""
return self.interval_timestamp_
@property
def policy(self) -> int:
return self.policy_
@property
def proof_hash(self) -> int:
return int(self.proof_hash_)
@proof_hash.setter
def proof_hash(self, hs: int or str) -> None:
self.proof_hash_ = str(hs)
def sign(self, y:str) -> Tuple[int, int]:
key = self.key_pair
msg_hash = SHA256.new(bytes.fromhex(y))
signer = DSS.new(key, 'fips-186-3')
signature = signer.sign(msg_hash)
return Conversion.OS2IP(msg_hash.digest()), Conversion.OS2IP(signature)
def generate_blind_signature(self, proof):
signer = self.signer
proof = SigConversion.convert_dict_modint(proof)
return signer.gen_signature(proof)
def save_to_db(self):
db.session.add(self)
db.session.commit()
def delete(self):
pass
