class House(BaseModel):
__tablename__ = 'ihome_python_house_info'
id = db.Column(db.Integer, primary_key=True)
# 在多表中建立外键
user_id = db.Column(db.Integer, db.ForeignKey('ihome_python_user_profile.id'), nullable=False)
area_id = db.Column(db.Integer, db.ForeignKey('ihome_python_area_info.id'), nullable=False)
title = db.Column(db.String(64), nullable=False) # 标题
price = db.Column(db.Integer, default=0) # 单价，单位：分
address = db.Column(db.String(512), default="") # 地址
room_count = db.Column(db.Integer, default=1) # 房间数目
acreage = db.Column(db.Integer, default=0) # 房屋面积
unit = db.Column(db.String(32), default="") # 房屋单元， 如几室几厅
capacity = db.Column(db.Integer, default=1) # 房屋容纳的人数
beds = db.Column(db.String(64), default="") # 房屋床铺的配置
deposit = db.Column(db.Integer, default=0) # 房屋押金
min_days = db.Column(db.Integer, default=1) # 最少入住天数
max_days = db.Column(db.Integer, default=0) # 最多入住天数，0表示不限制
order_count = db.Column(db.Integer, default=0) # 预订完成的该房屋的订单数
index_image_url = db.Column(db.String(256), default="") # 房屋主图片的路径
facilities = db.relationship('Facility', secondary=house_facility)
images = db.relationship('HouseImage')
orders = db.relationship('Order', backref='house')
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True) # 用户编号
name = db.Column(db.String(32), unique=True, nullable=False) # 用户暱称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 身份证号
avatar_url = db.Column(db.String(128)) # 用户头像路径
houses = db.relationship("House", backref="user") # 用户发布的房屋
orders = db.relationship("Order", backref="user") # 用户下的订单
@property
def password(self):
# return self.password_hash
raise AttributeError('改属性只能设置，不能读取')
@password.setter
def password(self, origin_password):
self.password_hash = generate_password_hash(origin_password)
def __repr__(self):
return f'<User: {self.name}>'
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True) # 用户编号
name = db.Column(db.String(32), unique=True, nullable=False) # 用户暱称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 身份证号
avatar_url = db.Column(db.String(128)) # 用户头像路径
houses = db.relationship("House", backref="user") # 用户发布的房屋
orders = db.relationship("Order", backref="user") # 用户下的订单
@property
def password(self):
raise AttributeError("不允许此操作")
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def chek_password(self, value):
return check_password_hash(self.password_hash, value)
def to_dict(self):
return {
"name": self.name,
"mobile": self.mobile,
"real_name": self.real_name,
"id_card": self.id_card
}
class House(BaseModel, db.Model):
'''房屋信息'''
__tablename__ = "ih_house_info"
id = db.Column(db.Integer, primary_key=True) #房屋编号
user_id = db.Column(db.Integer,
db.ForeignKey("ih_user_profile.id"),
nullable=False) #房屋主人的用户编号
area_id = db.Column(db.Integer,
db.ForeignKey("ih_area_info.id"),
nullable=False) #归属地的区域编号
title = db.Column(db.String(64), nullable=False) #标题
price = db.Column(db.Integer, default=0) # 单价，单位：分
address = db.Column(db.String(512), default='') #地址
room_count = db.Column(db.Integer, default=1) #房间数目
acreage = db.Column(db.Integer, default=0) #房屋面积
unit = db.Column(db.String(32), default='') #房屋单元，如几室几厅
capacity = db.Column(db.Integer, default=1) #房屋容纳的人数
beds = db.Column(db.String(64), default='') #房屋床铺的配置
deposit = db.Column(db.Integer, default=0) #房屋押金
min_days = db.Column(db.Integer, default=1) #最少入住天数
max_days = db.Column(db.Integer, default=0) #最多入住天数，0表示不限制
order_count = db.Column(db.Integer, default=0) #预订完成的该房屋的订单数
index_image_url = db.Column(db.String(256), default="") #房屋主图片的路径
# secondary相当于找中间表
# 所有的relationship都表中都是没有的，ForeignKey到时会在表中建一个字段
facilities = db.relationship("Facility", secondary=house_facilyty) #房屋的设施
images = db.relationship("HouseImage") #房屋的图片
orders = db.relationship("Order", backref='house') #房屋的订单
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True) # 用户编号
name = db.Column(db.String(32), unique=True, nullable=False) # 用户暱称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 身份证号
avatar_url = db.Column(db.String(128)) # 用户头像路径
# 在一的一方, 添加relationship, 同时添加反向引用
houses = db.relationship("House", backref="user") # 用户发布的房屋
orders = db.relationship("Order", backref="user") # 用户下的订单
# 在User下方增加以下函数
# 通过property装饰器, 将password函数提升为属性
@property
def password(self):
# 在属性的getter方法中, 禁止访问密码数据
raise AttributeError('禁止访问用户密码')
@password.setter
def password(self, value):
# 在属性的setter方法中执行加密处理
# 直接传入value即可, 默认sha256, 并会生成随机的8位盐值
self.password_hash = generate_password_hash(value)
# 在User下方增加以下函数
def check_password(self, value):
"""检查用户密码， value 是用户填写密码"""
return check_password_hash(self.password_hash, value)
def to_dict(self):
"""将对象转换为字典数据"""
user_dict = {
"user_id":
self.id,
"name":
self.name,
"mobile":
self.mobile,
"avatar":
constants.QINIU_URL_DOMAIN +
self.avatar_url if self.avatar_url else '',
"create_time":
self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_dict
def auth_dict(self):
'''将实名信息转换为字典数据'''
auth_dict = {
"user_id": self.id,
"real_name": self.real_name,
"id_card": self.id_card
}
return auth_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True) # 用户编号
name = db.Column(db.String(32), unique=True, nullable=False) # 用户暱称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 身份证号
avatar_url = db.Column(db.String(128)) # 用户头像路径
# 在一的一方, 添加relationship, 同时添加反向引用
houses = db.relationship("House", backref="user") # 用户发布的房屋
orders = db.relationship("Order", backref="user") # 用户下的订单
# 提升函数为属性 --> 默认是getter方法
@property
def password(self):
"""关于密码不需要别人获取"""
raise AttributeError('不支持读取操作')
@password.setter
def password(self, value):
# 属性的setter方法, 需要传入用户的密码
self.password_hash = generate_password_hash(value)
# 检查密码的函数
def check_password_hash(self, value):
# 需要传入之前的加密项, 及现在的密码
return check_password_hash(self.password_hash, value)
def to_dict(self):
"""将对象转换为字典数据"""
user_dict = {
"user_id":
self.id,
"name":
self.name,
"mobile":
self.mobile,
"avatar":
constants.QINIU_URL_DOMAIN +
self.avatar_url if self.avatar_url else "",
"create_time":
self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_dict
def auth_to_dict(self):
"""将实名信息转换为字典数据"""
auth_dict = {
"user_id": self.id,
"real_name": self.real_name,
"id_card": self.id_card
}
return auth_dict
class User(BaseModel, db.Model):
"""用户模型"""
__tablename__ = 'ih_user_profile'
id = db.Column(db.Integer, primary_key=True) # 用户编号
name = db.Column(db.String(32), unique=True, nullable=False) # 用户昵称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 证件号
avatar_url = db.Column(db.String(128)) # 头像路径
houses = db.relationship('House', backref='user') # 用户发布的房屋
orders = db.relationship('Order', backref='user') # 用户下的订单
@property
def password(self):
raise AttributeError('这个属性只能设置不能读取')
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def check_password(self, password):
return check_password_hash(self.password_hash, password)
def to_dict(self):
"""
将对象转换为字典数据
:return:
"""
user_dict = {
'user_id':
self.id,
'name':
self.name,
'mobile':
self.mobile,
'avatar':
constants.QINIU_URL_DOMAIN +
self.avatar_url if self.avatar_url else "",
'create_time':
self.create_time.strftime('%Y-%m-%d %H:%M:%S')
}
return user_dict
def auth_to_dict(self):
"""
将实名信息转为字典数据
:return:
"""
auth_dict = {
'user_id': self.id,
'real_name': self.real_name,
'id_card': self.id_card
}
return auth_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True, nullable=False)
password_hash = db.Column(db.String(128), nullable=False)
mobile = db.Column(db.String(11), unique=True, nullable=False)
real_name = db.Column(db.String(32))
id_card = db.Column(db.String(20))
avatar_url = db.Column(db.String(128))
houses = db.relationship("House", backref="user")
orders = db.relationship("Order", backref="user")
@property
def password(self):
raise AttributeError("此属性只能设置，不可读取")
@password.setter
def password(self, value):
self.password_hash = generate_password_hash(value)
def check_passed(self, passwd):
"""
检验密码正确性
:param passwd: 用户登录时填写的原始密码
:return:如果正确返回True，否则返回False
"""
return check_password_hash(self.password_hash, passwd)
def to_dict(self):
"""将对象转换为字典数据"""
user_dict = {
"user_id":
self.id,
"name":
self.name,
"mobile":
self.mobile,
"avatar":
constants.QINIU_URL_DOMAIN +
self.avatar_url if self.avatar_url else "",
"create_time":
self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_dict
def auth_to_dict(self):
"""将实名信息转换为字典数据"""
auth_dict = {
"user_id": self.id,
"real_name": self.real_name,
"id_card": self.id_card
}
return auth_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True) # 用户编号
name = db.Column(db.String(32), unique=True, nullable=False) # 用户暱称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 身份证号
avatar_url = db.Column(db.String(128)) # 用户头像路径
houses = db.relationship("House", backref="user") # 用户发布的房屋
orders = db.relationship("Order", backref="user") # 用户下的订单
@property
def password(self):
"""对应password属性的读取操作"""
raise AttributeError("不支持读取操作")
@password.setter
def password(self, value):
"""对应password属性的设置操作, value用户设置的密码值"""
self.password_hash = generate_password_hash(value)
def check_password(self, value):
"""检查用户密码， value 是用户填写密码"""
return check_password_hash(self.password_hash, value)
def to_dict(self):
"""将对象转换为字典数据"""
user_dict = {
"user_id":
self.id,
"name":
self.name,
"mobile":
self.mobile,
"avatar":
constants.QINIU_URL_DOMAIN +
self.avatar_url if self.avatar_url else "",
"create_time":
self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_dict
def auth_to_dict(self):
"""将实名信息转换为字典数据"""
auth_dict = {
"user_id": self.id,
"real_name": self.real_name,
"id_card": self.id_card
}
return auth_dict
class User(BaseModel, db.Model):
__tablename__ = 'ihome_python_user_profile'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True, nullable=False)
password_hash = db.Column(db.String(128), unique=True, nullable=False)
mobile = db.Column(db.String(11), unique=True, nullable=False)
real_name = db.Column(db.String(32))
id_card = db.Column(db.String(20))
# 用户头像路径
avatar_url = db.Column(db.String(128))
# 在一表中，或者多表中写relationship
houses = db.relationship('House', backref='user')
orders = db.relationship('Order', backref='user')
@property
def password(self):
raise AttributeError
@password.setter
def password(self, pwd):
#self.password_hash = generate_password_hash(pwd)
self.password_hash = pwd
def check_password(self, pwd):
#return check_password_hash(self.password_hash, pwd)
return self.password_hash == pwd
def to_dict(self):
user_dict = {
"user_id":
self.id,
"name":
self.name,
"mobile":
self.mobile,
"avatar":
constants.QINIU_URL_DOMAIN +
self.avatar_url if self.avatar_url else "",
"create_time":
self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_dict
def auth_to_dict(self):
auth_dict = {
'user_id': self.id,
'real_name': self.real_name,
'id_card': self.id_card
}
return auth_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True) # 用户编号
name = db.Column(db.String(32), unique=True, nullable=False) # 用户暱称
password_hash = db.Column(db.String(128), nullable=False) # 加密的密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机号
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 身份证号
avatar_url = db.Column(db.String(128)) # 用户头像路径
# 在一的一方, 添加relationship, 同时添加反向引用
houses = db.relationship("House", backref="user") # 用户发布的房屋
orders = db.relationship("Order", backref="user") # 用户下的订单
# 希望再提供一个password属性, 能够直接进行密码的设置
# @property: 将下面的函数提升为属性(getter)
@property
def password(self):
raise AttributeError('不允许访问密码')
@password.setter
def password(self, value):
# 在属性的setter方法中进行密码加密处理
self.password_hash = generate_password_hash(value)
# 在User下方增加以下函数
def check_password(self, value):
"""检查用户密码， value 是用户填写密码"""
return check_password_hash(self.password_hash, value)
def to_dict(self):
"""将对象转换为字典数据"""
# 根据前端的需求, 返回对应字段的信息
user_dict = {
"user_id": self.id,
"name": self.name,
"mobile": self.mobile,
"avatar": constants.QINIU_URL_DOMAIN + self.avatar_url if self.avatar_url else "",
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_dict
def auth_to_dict(self):
"""将实名信息转换为字典数据"""
auth_dict = {
"user_id": self.id,
"real_name": self.real_name,
"id_card": self.id_card
}
return auth_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__= 'ihome_user'
id = db.Column(db.INTEGER, primary_key=True)
phone = db.Column(db.String(11), unique=True)
pwd_hash = db.Column(db.String(200))
name = db.Column(db.String(30), unique=True)
avatar_url = db.Column(db.String(100))
real_name = db.Column(db.String(30))
real_id_card = db.Column(db.String(18), unique=True)
houses = db.relationship('House', backref='user')
orders = db.relationship('Order', backref='user')
#读
@property
def password(self):
return ''
#写
@password.setter
def password(self, pwd):
self.pwd_hash = generate_password_hash(pwd)
#对比
def check_password(self, pwd):
return check_password_hash(self.pwd_hash, pwd)
def to_basic_dict(self):
return {
'id': self.id,
'avatar': current_app.config['QINIU_URL']+self.avatar_url if self.avatar_url else '',
'name': self.name,
'phone': self.phone
}
def to_dict(self):
"""将对象转换为字典数据"""
user_dict = {
"user_id": self.id,
"name": self.name,
"mobile": self.phone,
"avatar": constants.QINIU_URL_DOMAIN + self.avatar_url if self.avatar_url else "",
"create_time": self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_dict
def auth_to_dict(self):
return {
'real_name': self.real_name,
'id_card': self.real_id_card
}
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = 'ih_user_profile'
id = db.Column(db.Integer, primary_key=True) # 编号
name = db.Column(db.String(32), unique=True, nullable=False) # 昵称
password_hash = db.Column(db.String(128), unique=True, nullable=False) # 哈希密码
mobile = db.Column(db.String(11), unique=True, nullable=False) # 手机
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 身份证号
avatar_url = db.Column(db.String(120)) # 用户头像路径
houses = db.relationship("House", backref="user") # 用户发布的房屋
orders = db.relationship("Order", backref="user") # 用户下的订单
class Area(BaseModel):
__tablename = 'ihome_python_area_info'
id = db.Column(db.Integer, primary_key=True) # 区域编号
name = db.Column(db.String(32), nullable=False) # 区域名字
houses = db.relationship('House', backref='area')
class Area(BaseModel, db.Model):
"""城区"""
__tablename__ = 'ih_area_info'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), nullable=False)
house = db.relationship("House", backref="area")
class User(BaseModel, db.Model):
__tablename__ = 'ihome_python_user_profile'
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True, nullable=False)
password_hash = db.Column(db.String(128), unique=True, nullable=False)
mobile = db.Column(db.String(11), unique=True, nullable=False)
real_name = db.Column(db.String(32))
id_card = db.Column(db.String(20))
# 用户头像路径
avatar_url = db.Column(db.String(128))
# 在一表中，或者多表中写relationship
houses = db.relationship('House', backref='user')
orders = db.relationship('Order', backref='user')
class User(BaseModel,db.Model):
"""用户"""
__tablename__ = "i_user"
id = db.Column(db.Integer,primary_key=True) # 用户编号
name = db.Column(db.String(32), unique=True, nullable=False) # 用户暱称
password_hash = db.Column(db.String(128),nullable=False) # 加密的密码
mobile= db.Column(db.String(11),unique=True,nullable=False) # 用户手机号
real_name = db.Column(db.String(32)) # 真实姓名
id_card = db.Column(db.String(20)) # 身份证号码
avatar_url = db.Column(db.String(128)) # 用户头像路径
houses = db.relationship("House",backref="user") # 用户发布的房屋
orders = db.relationship("Order",backref="user") # 用户下的订单
@property
def password(self):
"""读取属性的函数行为"""
raise AttributeError("这个属性只能设置，不能读取")
@password.setter
def password(self,value):
"""设置属性的值，对密码进行加密操作"""
self.password_hash = generate_password_hash(value)
def check_password(self,passwd):
"""验证密码正确性"""
return check_password_hash(self.password_hash,passwd)
def to_dict(self):
"""将基本信息转换为字典数据"""
user_dict = {
"user_id":self.id,
"name":self.name,
"mobile":self.molile,
"avater": constants.QINIU_URL_DOMAIN + self.avatar_url if self.avatar_url else "",
"cerate_time":self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_dict
def auth_to_dict(self):
"""将实名信息转化为字典数据"""
auth_dict = {
"user_id":self.id,
"real_name":self.real_name,
"id_card":self.id_card
}
class Area(BaseModel, db.Model):
"""城区"""
__tablename__ = "ih_area_info"
id = db.Column(db.Integer, primary_key=True) # 区域编号
name = db.Column(db.String(32), nullable=False) # 区域名字
houses = db.relationship("House", backref="area") # 区域的房屋
def to_dict(self):
return {"aid": self.id, "aname": self.name}
class Area(BaseModel, db.Model):
__tablename__ = 'ihome_python_area_info'
id = db.Column(db.Integer, primary_key=True) # 区域编号
name = db.Column(db.String(32), nullable=False) # 区域名字
houses = db.relationship('House', backref='area', lazy='dynamic')
def to_dict(self):
d = {'aid': self.id, 'aname': self.name}
return d
class Area(BaseModel, db.Model):
"""城区"""
__tablename__ = "ih_area_info"
area_id = db.Column(db.Integer, primary_key=True) # 区域编号
area_name = db.Column(db.String(32), nullable=False) # 区域名字
houses = db.relationship("House", backref="area") # 区域的房屋
# 将对象转换为字典
def to_dic(self):
dic = {"id": self.area_id, "name": self.area_name}
return dic
class Area(BaseModel, db.Model):
"""城区模型类"""
__tablename__ = "ih_area_info"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), nullable=False)
house = db.relationship("House", backref="area")
def to_dict(self):
"""将对象转换为字典"""
d = {"aid": self.id, "aname": self.name}
return d
class Area(BaseModel, db.Model):
"""城区"""
__tablename__ = 'ih_area_info'
id = db.Column(db.Integer, primary_key=True) # 区域编号
name = db.Column(db.String(32), nullable=False) # 城区名字
hourses = db.relationship('House', backref='area') # 城区的房屋
def to_dict(self):
area_dict = {'aid': self.id, 'aname': self.name}
return area_dict
class User(BaseModel, db.Model):
"""用户"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True) #用户编号
name = db.Column(db.String(32), unique=True, nullable=False) #用户姓名
password_hash = db.Column(db.String(128), nullable=False) #用户密码
mobile = db.Column(db.String(11), nullable=False) #手机号
real_name = db.Column(db.String(20)) #真实姓名
id_card = db.Column(db.String(18)) #身份证号
avatar_url = db.Column(db.String(128)) #用户图像路径
houses = db.relationship("House", backref="user") #用户发布的房屋
orders = db.relationship("Order", backref="user") #用户下的订单
@property
def password(self):
"""获取password属性时被调用"""
raise AttributeError("不可读")
@password.setter
def password(self, passwd):
"""设置password属性时被调用，设置加密功能"""
self.password_hash = generate_password_hash(passwd)
def check_password(self, passwd):
"""检查密码的正确性"""
return check_password_hash(self.password_hash, passwd)
def to_dict(self):
"""将实名信息转换为字典"""
auth_dict = {
"user_id": self.id,
"real_name": self.real_name,
"id_card": self.id_card
}
return auth_dict
class House(BaseModel, db.Model):
"""房屋信息"""
__tablename__ = "ih_house_info"
id = db.Column(db.Integer, primary_key=True) # 房屋编号
title = db.Column(db.String(64), nullable=False) # 标题
price = db.Column(db.Integer, default=0) # 单价，单位：分
address = db.Column(db.String(512), default="") # 地址
room_count = db.Column(db.Integer, default=1) # 房间数目
acreage = db.Column(db.Integer, default=0) # 房屋面积
unit = db.Column(db.String(32), default="") # 房屋单元， 如几室几厅
capacity = db.Column(db.Integer, default=1) # 房屋容纳的人数
beds = db.Column(db.String(64), default="") # 房屋床铺的配置
deposit = db.Column(db.Integer, default=0) # 房屋押金
min_days = db.Column(db.Integer, default=1) # 最少入住天数
max_days = db.Column(db.Integer, default=0) # 最多入住天数，0表示不限制
order_count = db.Column(db.Integer, default=0) # 预订完成的该房屋的订单数
index_image_url = db.Column(db.String(256), default="") # 房屋主图片的路径
user_id = db.Column(db.Integer,
db.ForeignKey("ih_user_profile.id"),
nullable=False) # 房屋主人的用户编号
area_id = db.Column(db.Integer,
db.ForeignKey("ih_area_info.id"),
nullable=False) # 归属地的区域编号
# 如果是多对多, 只需要在一方增加relationship, 同时需要告诉他第三张表的名字
facilities = db.relationship("Facility", secondary=house_facility) # 房屋的设施
images = db.relationship("HouseImage") # 房屋的图片
orders = db.relationship("Order", backref="house") # 房屋的订单
def to_base_dict(self):
house_dict = {
"house_id":
self.id,
"title":
self.title,
"price":
self.price,
"area_name":
self.area.name,
"img_url":
constants.QINIU_URL_DOMAIN +
self.index_image_url if self.index_image_url else "",
"room_count":
self.room_count,
"order_count":
self.order_count,
"address":
self.address,
"user_avatar":
constants.QINIU_URL_DOMAIN +
self.user.avatar_url if self.user.avatar_url else "",
"ctime":
self.create_time.strftime("%Y-%m-%d")
}
return house_dict
def to_full_dict(self):
"""将详细信息转换为字典数据"""
house_dict = {
"hid":
self.id,
"user_id":
self.user_id,
"user_name":
self.user.name,
"user_avatar":
constants.QINIU_URL_DOMAIN +
self.user.avatar_url if self.user.avatar_url else "",
"title":
self.title,
"price":
self.price,
"address":
self.address,
"room_count":
self.room_count,
"acreage":
self.acreage,
"unit":
self.unit,
"capacity":
self.capacity,
"beds":
self.beds,
"deposit":
self.deposit,
"min_days":
self.min_days,
"max_days":
self.max_days,
}
# 房屋图片
img_urls = []
for image in self.images:
img_urls.append(constants.QINIU_URL_DOMAIN + image.url)
house_dict["img_urls"] = img_urls
# 房屋设施
facilities = []
for facility in self.facilities:
facilities.append(facility.id)
house_dict["facilities"] = facilities
# 评论信息
comments = []
orders = Order.query.filter(Order.house_id == self.id, Order.status == "COMPLETE", Order.comment != None) \
.order_by(Order.update_time.desc()).limit(constants.HOUSE_DETAIL_COMMENT_DISPLAY_COUNTS)
for order in orders:
comment = {
"comment":
order.comment, # 评论的内容
"user_name":
order.user.name
if order.user.name != order.user.mobile else "匿名用户", # 发表评论的用户
"ctime":
order.update_time.strftime("%Y-%m-%d %H:%M:%S") # 评价的时间
}
comments.append(comment)
house_dict["comments"] = comments # [{},{},{}]
return house_dict
class House(BaseModel,db.Model):
"""房屋信息"""
__tablename__ = "i_house"
id = db.Column(db.Integer,primary_key=True) # 房屋编号
user_id = db.Column(db.Integer,db.ForeignKey("i_user.id")) # 房屋主人用户编号的
area_id = db.Column(db.Integer,db.ForeignKey("i_area.id")) # 所属城区的区域编号
title = db.Column(db.String(64),nullable=False) # 房屋标题
price = db.Column(db.Integer,default=0) #单价
address = db.Column(db.String(512),default="") # 地址
room_count = db.Column(db.Integer, default=1) # 房间数目
acreage = db.Column(db.Integer, default=0) # 房屋面积
unit = db.Column(db.String(32), default="") # 房屋单元， 如几室几厅
capacity = db.Column(db.Integer, default=1) # 房屋容纳的人数
beds = db.Column(db.String(64),default="") # 房屋床铺的配置
deposit = db.Column(db.Integer,default=0) # 房屋押金
min_days = db.Column(db.Integer,default=1) # 最少入住天数
max_days = db.Column(db.Integer,default=0) # 最多入住天数，0表示不限制
order_count = db.Column(db.Integer,default=0) # 预定完成的该房间订单数
index_image_url= db.Column(db.String(256),default="") # 房间图片地址
facilities = db.relationship("Facility", secondary=house_facility) # 房屋的设施
images = db.relationship("HouseImage") # 房屋的图片
orders = db.relationship("Order", backref="house") # 房屋的订单
def to_basic_dict(self):
"""将基本信息转化为字典数据"""
house_dict = {
"house_id":self.id,
"title":self.title,
"price":self.price,
"area_name":self.area.name,
"img_url": constants.QINIU_URL_DOMAIN + self.index_image_url if self.index_image_url else "",
"room_count": self.room_count,
"order_count": self.order_count,
"address": self.address,
"ctime":self.create_time.strtime("%Y-%m-%d")
}
return house_dict
def to_full_dict(self):
"""将详细信息转换为字典数据"""
house_dict = {
"hid":self.id,
"user_id":self.user_id,
"user_name":self.user.name,
"user_avatar": constants.QINIU_URL_DOMAIN + self.user.avatar_url if self.user.avatar_url else "",
"title":self.title,
"price":self.price,
"address":self.address,
"room_count":self.room_count,
"acreage":self.acreage,
"unit":self.unit,
"capactiy":self.capacity,
"min_days":self.min_days,
"max_days":self.max_days,
}
#房屋图片
img_urls = []
for img in self.images:
img_urls.append(constants.QINIU_URL_DOMAIN + img.url)
house_dict["img_urls"] = img_urls
#房屋设施
facilities = []
for facility in self.facilities:
facilities.append(facilities.id)
house_dict["facilities"] = facilities
#评论信息
comments = []
orders = Order.query.filter(Order.house_id==self.id,Order.comment != None)\
.order_by(Order.update_time.desc())\
.limit(constants.HOUSE_DETAIL_COMMENT_DISPLAY_COUNTS)
house_dict["comments"] = comments
class House(BaseModel, db.Model):
"""房屋信息"""
__tablename__ = "ih_house_info"
id = db.Column(db.Integer, primary_key=True) # 房屋编号
user_id = db.Column(db.Integer,
db.ForeignKey("ih_user_profile.id"),
nullable=False) # 房屋主人的用户编号
area_id = db.Column(db.Integer,
db.ForeignKey("ih_area_info.id"),
nullable=False) # 归属地的区域编号
title = db.Column(db.String(64), nullable=False) # 标题
price = db.Column(db.Integer, default=0) # 单价，单位：分
address = db.Column(db.String(512), default="") # 地址
room_count = db.Column(db.Integer, default=1) # 房间数目
acreage = db.Column(db.Integer, default=0) # 房屋面积
unit = db.Column(db.String(32), default="") # 房屋单元， 如几室几厅
capacity = db.Column(db.Integer, default=1) # 房屋容纳的人数
beds = db.Column(db.String(64), default="") # 房屋床铺的配置
deposit = db.Column(db.Integer, default=0) # 房屋押金
min_days = db.Column(db.Integer, default=1) # 最少入住天数
max_days = db.Column(db.Integer, default=0) # 最多入住天数，0表示不限制
order_count = db.Column(db.Integer, default=0) # 预订完成的该房屋的订单数
index_image_url = db.Column(db.String(256), default="") # 房屋主图片的路径
facilities = db.relationship("Facility", secondary=house_facility) # 房屋的设施
images = db.relationship("HouseImage") # 房屋的图# 接单片
orders = db.relationship("Order", backref="house") # 房屋的订单
def to_basic_dict(self):
return {
"house_id":
self.id,
"title":
self.title,
"price":
self.price,
"area_name":
self.area.name,
"img_url":
constants.QINIU_USER_ACCESS_DOMAIN_URL +
self.index_image_url if self.index_image_url else "",
"room_count":
self.room_count,
"order_count":
self.order_count,
"address":
self.address,
"user_avatar":
constants.QINIU_USER_ACCESS_DOMAIN_URL +
self.user.avatar_url if self.user.avatar_url else "",
"ctime":
self.create_time.strftime("%Y-%m-%d")
}
def to_full_dict(self):
"""将详细信息转换为字典数据"""
house_dict = {
"hid":
self.id,
"user_id":
self.user_id,
"user_name":
self.user.name,
"user_avatar":
constants.QINIU_USER_ACCESS_DOMAIN_URL +
self.user.avatar_url if self.user.avatar_url else "",
"title":
self.title,
"price":
self.price,
"address":
self.address,
"room_count":
self.room_count,
"acreage":
self.acreage,
"unit":
self.unit,
"capacity":
self.capacity,
"beds":
self.beds,
"deposit":
self.deposit,
"min_days":
self.min_days,
"max_days":
self.max_days,
}
# 房屋图片
house_dict["image_urls"] = [
constants.QINIU_USER_ACCESS_DOMAIN_URL + image.url
for image in self.images
]
# 房屋设施
house_dict["facilities"] = [
facilitie.id for facilitie in self.facilities
]
# 评论数据
orders = Order.query.filter(
Order.house_id == self.id, Order.comment != None,
Order.status == "COMPLETE").order_by(
Order.create_time.desc()).limit(
constants.HOUSE_DETAIL_COMMENT_DISPLAY_COUNTS)
house_dict["comments"] = [{
"comment_user": order.user.name,
"comment_time": str(order.update_time),
"comment_content": order.comment
} for order in orders]
return house_dict
class House(BaseModel, db.Model):
"""房屋信息"""
__tablename__ = "ih_house_info"
id = db.Column(db.Integer, primary_key=True) # 房屋编号
user_id = db.Column(db.Integer, db.ForeignKey(
"ih_user_profile.id"), nullable=False) # 房屋主人的用户编号
area_id = db.Column(db.Integer, db.ForeignKey(
"ih_area_info.id"), nullable=False) # 归属地的区域编号
title = db.Column(db.String(64), nullable=False) # 标题
price = db.Column(db.Integer, default=0) # 单价，单位：分
address = db.Column(db.String(512), default="") # 地址
room_count = db.Column(db.Integer, default=1) # 房间数目
acreage = db.Column(db.Integer, default=0) # 房屋面积
unit = db.Column(db.String(32), default="") # 房屋单元， 如几室几厅
capacity = db.Column(db.Integer, default=1) # 房屋容纳的人数
beds = db.Column(db.String(64), default="") # 房屋床铺的配置
deposit = db.Column(db.Integer, default=0) # 房屋押金
min_days = db.Column(db.Integer, default=1) # 最少入住天数
max_days = db.Column(db.Integer, default=0) # 最多入住天数，0表示不限制
order_count = db.Column(db.Integer, default=0) # 预订完成的该房屋的订单数
index_image_url = db.Column(db.String(256), default="") # 房屋主图片的路径
facilities = db.relationship("Facility", secondary=house_facility) # 房屋的设施
images = db.relationship("HouseImage") # 房屋的图片
orders = db.relationship("Order", backref="house") # 房屋的订单
def __repr__(self):
return f'<House: {self.title}>'
def to_basic_dict(self):
return {
'id': self.id,
'user_avatar': constants.QINIU_URL_DOMAIN + self.user.avatar_url if self.user.avatar_url else "",
'area_name': self.area.name,
'address': self.address,
'title': self.title,
'room_count': self.room_count,
'order_count': self.order_count,
'price': '%.2f' % (self.price/100),
'create_time': self.create_time.strftime('%Y-%m-%d %H:%M:%S'),
'update_time': self.update_time.strftime('%Y-%m-%d %H:%M:%S'),
'index_image_url': constants.QINIU_URL_DOMAIN + self.index_image_url if self.index_image_url else ""
}
def to_full_dict(self):
house_dict = {
'hid': self.id,
'uid': self.user_id,
'uname': self.user.name,
'user_avatar': constants.QINIU_URL_DOMAIN + self.user.avatar_url if self.user.avatar_url else "",
'title': self.title,
'price': '%.2f' % (self.price/100),
'address': self.address,
'room_count': self.room_count,
'acreage': self.acreage,
'unit': self.unit,
'capacity': self.capacity,
'beds': self.beds,
'deposit': '%.2f' % (self.deposit/100),
'min_days': self.min_days,
'max_days': self.max_days,
}
# 获取房屋图片url
image_urls = []
for image in self.images:
image_urls.append(constants.QINIU_URL_DOMAIN + image.url)
house_dict['image_urls'] = image_urls
# 设备信息
facilities = []
for facility in self.facilities:
facilities.append(facility.id)
house_dict['facilities'] = facilities
# 评论信息
# 订单完成，且评论不为空的最新20跳评论
comments = []
orders = Order.query.filter(Order.house_id == self.id,
Order.status == 'COMPLETE',
Order.comment != None).order_by(
Order.create_time.desc()).limit(constants.HOUSE_DETAIL_COMMENTS_DISPLAY_COUNT)
for order in orders:
comment = {
'user_name': order.user.name if order.user.name != order.user.mobile else '匿名用户',
'comment': order.comment,
'ctime': order.update_time.strftime('%Y-%m-%d %H:%M:%S')
}
comments.append(comment)
house_dict['comments'] = comments
return house_dict
class House(BaseModel, db.Model):
"""房屋信息模型类"""
__tablename__ = "ih_house_info"
id = db.Column(db.Integer, primary_key=True)
user_id = db.Column(db.Integer,
db.ForeignKey("ih_user_profile.id"),
nullable=False)
area_id = db.Column(db.Integer,
db.ForeignKey("ih_area_info.id"),
nullable=False)
title = db.Column(db.String(64), nullable=False)
price = db.Column(db.Integer, default=0) # 单价，单位：分/晚
address = db.Column(db.String(512), default="")
index_image_url = db.Column(db.String(256), default="")
deposit = db.Column(db.Integer, default=0) # 入住押金
room_count = db.Column(db.Integer, default=1) # 房间数目
acreage = db.Column(db.Integer, default=0) # 房屋面积
unite = db.Column(db.String(32), default="") # 房屋单元，如几室几厅
capacity = db.Column(db.Integer, default=1) # 房屋容纳人数
beds = db.Column(db.String(64), default="") # 房屋床铺配置
min_days = db.Column(db.Integer, default=1) # 最少入住天数，默认一晚
max_days = db.Column(db.Integer, default=0) # 最多入住天数，0表示无限制
order_count = db.Column(db.Integer, default=0) # 房屋已完成订单总数
order = db.relationship("Order", backref="house") # 房屋的订单情况
images = db.relationship("HouseImage") # 房屋的所有图片
facilities = db.relationship("Facility", secondary=house_facility) # 房屋的设施
def to_basic_dict(self):
"""将对象转换为字典"""
house_dict = {
"house_id":
self.id,
"title":
self.title,
"price":
self.price,
"address":
self.address,
"area_name":
self.area.name,
"image_url":
constants.QINIU_URL_DOMAIN +
self.index_image_url if self.index_image_url else "",
"room_count":
self.room_count,
"order_count":
self.order_count,
"user_avatar":
constants.QINIU_URL_DOMAIN +
self.user.avatar_url if self.user.avatar_url else "",
"creat_time":
self.create_time.strftime("%Y-%m-%d")
}
return house_dict
def to_full_dict(self):
"""将对象转换为字典"""
house_dict = {
"hid":
self.id,
"user_id":
self.user_id,
"user_name":
self.user.name,
"user_avatar":
constants.QINIU_URL_DOMAIN +
self.user.avatar_url if self.user.avatar_url else "",
"title":
self.title,
"price":
self.price,
"address":
self.address,
"deposit":
self.deposit,
"room_count":
self.room_count,
"acreage":
self.acreage,
"unit":
self.unite,
"capacity":
self.capacity,
"beds":
self.beds,
"min_days":
self.min_days,
"max_days":
self.max_days
}
# 房屋图片处理
img_urls = []
for image in self.images:
img_urls.append(constants.QINIU_URL_DOMAIN + img_url)
house_dict["img_urls"] = img_urls
# 房屋设施处理
facilities = []
for facility in self.facilities:
facilities.append(facility.id)
house_dict["facilities"] = facilities
# 评论信息处理
comments = []
orders = Order.query.filter(Order.house_id == self.id, Order.status == "COMPLETE", Order.comment != None).\
order_by(Order.updata_time.desc()).limit(constants.HOUSE_DETAIL_COMMENT_DISPLAY_COUNTS)
for order in orders:
comment = {
"comment":
order.comment, # 获取评论
"user_name":
order.user.name if order.user.name != order.user.name else
"匿名用户", # 设置用户手机号码隐私
"ctime":
order.update_time.strftime("%Y-%m-%d %H:%M:%S") # 设置时间格式
}
comments.append(comment)
house_dict["comments"] = comments
return house_dict
class House(BaseModel, db.Model):
__tablename__ = 'ihome_python_house_info'
id = db.Column(db.Integer, primary_key=True)
# 在多表(从表)中建立外键
user_id = db.Column(db.Integer,
db.ForeignKey('ihome_python_user_profile.id'),
nullable=False)
area_id = db.Column(db.Integer,
db.ForeignKey('ihome_python_area_info.id'),
nullable=False)
title = db.Column(db.String(64), nullable=False) # 标题
price = db.Column(db.Integer, default=0) # 单价，单位：分
address = db.Column(db.String(512), default="") # 地址
room_count = db.Column(db.Integer, default=1) # 房间数目
acreage = db.Column(db.Integer, default=0) # 房屋面积
unit = db.Column(db.String(32), default="") # 房屋单元， 如几室几厅
capacity = db.Column(db.Integer, default=1) # 房屋容纳的人数
beds = db.Column(db.String(64), default="") # 房屋床铺的配置
deposit = db.Column(db.Integer, default=0) # 房屋押金
min_days = db.Column(db.Integer, default=1) # 最少入住天数
max_days = db.Column(db.Integer, default=0) # 最多入住天数，0表示不限制
order_count = db.Column(db.Integer, default=0) # 预订完成的该房屋的订单数
index_image_url = db.Column(db.String(256), default="") # 房屋主图片的路径
facilities = db.relationship('Facility',
backref='house',
secondary=house_facility) #
images = db.relationship('HouseImage')
orders = db.relationship('Order', backref='house')
def to_basic_dict(self):
basic_dict = {
'house_id':
self.id,
'img_url':
constants.QINIU_URL_DOMAIN +
self.index_image_url if self.index_image_url else "",
'title':
self.title,
'price':
self.price,
'area_name':
self.area.name,
'ctime':
self.create_time.strftime('%Y-%m-%d')
}
return basic_dict
def to_detail_dict(self):
detail_dict = {
'hid':
self.id,
'house_id':
self.id,
'img_url':
constants.QINIU_URL_DOMAIN +
self.index_image_url if self.index_image_url else "",
'title':
self.title,
'price':
self.price,
'area_name':
self.area.name,
'ctime':
self.create_time.strftime('%Y-%m-%d'),
'user_avatar':
constants.QINIU_URL_DOMAIN +
self.user.avatar_url if self.user.avatar_url else '',
'user_name':
self.user.name,
'user_id':
self.user_id,
'room_count':
self.room_count,
'acreage':
self.acreage,
'unit':
self.unit,
'capacity':
self.capacity,
'beds':
self.beds,
'deposit':
self.deposit,
'min_days':
self.min_days,
'max_days':
self.max_days,
'order_count':
self.order_count,
'index_image_url':
constants.QINIU_URL_DOMAIN +
self.index_image_url if self.index_image_url else '',
# 'comments': [{'user_name': 'wwwww', 'ctime': self.create_time.strftime('%Y-%m-%d'), 'comment': '很好'}],
'facilities': [facility.id for facility in self.facilities],
'img_urls':
[constants.QINIU_URL_DOMAIN + image.url for image in self.images],
}
try:
comments = [{
"user_name": house_order.user.name,
"ctime": self.create_time.strftime('%Y-%m-%d'),
"comment": house_order.comment
} for house_order in self.orders]
except Exception as e:
current_app.logger.error(e)
comments = None
return jsonify(errno=RET.DBERR, errmsg='get comments err from db')
detail_dict.setdefault('comments', comments)
return detail_dict
class User(BaseModel, db.Model):
"""用户模型类"""
__tablename__ = "ih_user_profile"
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(32), unique=True, nullable=False)
password_hash = db.Column(db.String(128), nullable=False)
mobile = db.Column(db.String(11), unique=True, nullable=False)
# 用户认证真实信息
real_name = db.Column(db.String(32))
id_card = db.Column(db.String(20))
avatar_url = db.Column(db.String(128)) # 用户头像地址
houses = db.relationship("House", backref="user")
orders = db.relationship("Order", backref="user")
# 加上property装饰器，将方法变为属性
@property
def password(self):
"""读取属性的函数行为"""
# 这个属性只能设置，不能读写
raise AttributeError
@password.setter
def password(self, password):
"""
对密码进行设置
:param: the origin password
"""
self.password_hash = generate_password_hash(password)
def check_password(self, passwd):
"""
检验密码的正确性
:param passwd: 用户登录填写的原始密码
:return:
"""
return check_password_hash(self.password_hash, passwd)
def to_dict(self):
"""将用户对象转换为字典数据"""
user_dict = {
"user_id":
self.id,
"name":
self.name,
"mobile":
self.mobile,
"avatar":
constants.QINIU_URL_DOMAIN +
self.avatar_url if self.avatar_url else "",
"create_time":
self.create_time.strftime("%Y-%m-%d %H:%M:%S")
}
return user_dict
def auth_to_dict(self):
"""将实名信息转换为字典数据"""
auth_dict = {
"user_id": self.id,
"real_name": self.real_name,
"id_card": self.id_card
}
return auth_dict
