def send_house_image_info(house_id):
image_data = request.files.get("house_image").read()
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询异常")
if not house:
return jsonify(errno=RET.NODATA, errmsg="该房屋不存在")
try:
image_name = image_storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="七牛云异常")
if not house.index_image_url:
house.index_image_url = image_name
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_name
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="图片上传异常")
def upload_house_image():
"""发布房屋图片
0.判断用户是否是登录 @login_required
1.接受参数：image_data, house_id， 并做校验
2.使用house_id查询house模型对象数据，因为如果查询不出来，就不需要上传图片了
3.调用上传图片的工具方法，发布房屋图片
4.将图片的七牛云的key,存储到数据库
5.响应结果：上传的房屋图片，需要立即刷新出来
"""
# 1.接受参数：image_data, house_id， 并做校验
try:
image_data = request.files.get('house_image')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='无法收到房屋图片')
house_id = request.form.get('house_id')
if not house_id:
return jsonify(errno=RET.PARAMERR, errmsg='缺少必传参数')
# 2.使用house_id查询house模型对象数据，因为如果查询不出来，就不需要上传图片了
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋数据失败')
if not house:
return jsonify(errno=RET.NODATA, errmsg='房屋不存在')
# 3.调用上传图片的工具方法，发布房屋图片
try:
key = upload_image(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='上传房屋图片失败')
# 4.将图片的七牛云的key,存储到数据库
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = key
# 选择一个图片，作为房屋的默认图片
if not house.index_image_url:
house.index_image_url = key
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='存储房屋图片失败')
# 5.响应结果：上传的房屋图片，需要立即刷新出来
image_url = constants.QINIU_DOMIN_PREFIX + key
return jsonify(errno=RET.OK,
errmsg='发布房屋图片成功',
data={'image_url': image_url})
def upload_house_image(house_id):
"""
1. 取到上传的图片
2. 进行七牛云上传
3. 将上传返回的图片地址存储
4. 进行返回
:return:
"""
# 1. 取到上传的图片
try:
house_image_file = request.files.get("house_image").read()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg="参数不全")
# 2. 查询房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询房屋失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 3. 上传到七牛云
try:
url = storage_image(house_image_file)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片失败")
# 4. 初始化房屋的图片模型
house_image = HouseImage()
# 设置相关数据
house_image.house_id = house.id
house_image.url = url
# 判断是否有首页图片
if not house.index_image_url:
# 保存图片地址
house.index_image_url = url
# 更新到数据库
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存数据失败")
return jsonify(errno=RET.OK,
errmsg="OK",
data={"url": QINIU_DOMIN_PREFIX + url})
def save_house_image():
"""
保存上传的房屋图片
1.接收房屋id和房屋文件对象
2.根据房屋id获取房屋的信息（如果获取不到，说明房屋不存在）
3.讲房屋图片上传到七牛云
4.创建HouseImage对象并保存房屋图片记录
5.放回应答
:return:
"""
# 1.接收房屋id和房屋文件对象
house_id = request.form.get('house_id')
image_file = request.files.get('house_image')
if not all([house_id, image_file]):
return jsonify(errno=RET.PARAMERR, errmsg='参数缺失')
# 2.根据房屋id获取房屋的信息（如果获取不到，说明房屋不存在）
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='获取房屋信息失败')
if not house:
return jsonify(errno=RET.NODATA, errmsg='房屋不存在')
# 3.讲房屋图片上传到七牛云
try:
key = storage_image(image_file.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='上传房屋图片失败')
# 4.创建HouseImage对象并保存房屋图片记录
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = key
if not house.index_image_url:
house.index_image_url = key
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='保存房屋图片记录失败')
# 5.放回应答
img_url = constants.QINIU_DOMIN_PREFIX + key
return jsonify(errno=RET.OK,
errmsg='上传房屋图片记录成功',
data={'img_url': img_url})
def save_house_image():
"""
保存上传房屋图片：
1.接收房屋id和房屋图片文件对象
2.根据房屋id获取房屋的信息（如果获取不到，说明房屋不存在）
3.将房屋的图片上传到七牛云
4.创建HouseImage对象并保存房屋图片记录
5.返回应答，上传成功
"""
# 1.接收房屋id和房屋图片文件对象
house_id = request.form.get("house_id")
file = request.files.get("house_image")
if not all([house_id, file]):
return jsonify(errno=RET.PARAMERR, errmsg="缺少参数")
# 2.根据房屋id获取房屋的信息（如果获取不到，说明房屋不存在）
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="获取房屋信息失败")
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 3.将房屋的图片上传到七牛云
try:
key = storage_image(file.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="上传房屋图片失败")
# 4.创建HouseImage对象并保存房屋图片记录
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = key
# 判断房屋是否设置了默认图片
if not house.index_image_url:
house.index_image_url = key
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="保存房屋图片记录失败")
# 5.返回应答，上传成功
img_url = constants.QINIU_DOMIN_PREFIX + key
print "img_url:", img_url
print 'RET.OK:', RET.OK
return jsonify(errno=RET.OK, errmsg="上传房屋图片成功", data={"img_url": img_url})
def save_house_image(house_id):
'''
保存房屋图片
1 获取图片文件内容 校验参数
2 根据house_id 查询数据库 校验结果
3 读取图片数据
4 调用骑牛运借口 上传图片
5 保存图片数据 到数据库当中 HouseImage() House() 把一条数据 存储到两张表里
6 如果发生异常 进行回滚
7 拼接路径 返回结果
'''
# 获取图片参数
image = request.files.get('house_image')
# 校验参数
if not image:
return jsonify(errno=RET.PARAMERR, errmsg='')
# 校验房屋存在
try:
house = House.query.filter_by(id=house_id).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋信息异常')
# 校验查询结果
if not house:
return jsonify(errno=RET.NODATA, errmsg='查询无数据')
# 读取图片数据
image_data = image.read()
# 调用骑牛运接口
try:
image_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='骑牛运上传文件失败')
# 保存图片数据到数据库中
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_name
# 提交模型类对象 到数据库
db.session.add(house_image)
# 房屋主图片如果没有设置 默认添加房屋第一章图片为主图片
if not house.index_image_url:
house.index_image_url = image_name
db.sesiion.add(house)
# 提交到数据库中
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存房屋图片失败')
# 拼接外链域名
image_url = constants.QINIU_DOMIN_PREFIX + image_name
return jsonify(errno=RET.OK, errmsg='OK', data=image_url)
def set_house_image():
# 1.判断登陆
# 2.获取上传图片数据,房屋id
# 3.调用七牛云
# 4.存储返回的存储照片的key
# 5.拼接访问图片的url
# 6.返回响应
# 2.获取上传图片数据
try:
house_image = request.files.get('house_image')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg=u'获取图片失败')
house_id = request.form.get('house_id')
if not house_id:
return jsonify(errno=RET.PARAMERR, errmsg='缺少必传参数')
# 3.调用七牛云
house_image_key = upload_image(house_image)
# 4.存储返回的存储照片的key
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'获取房屋数据失败')
if not house:
return jsonify(errno=RET.NODATA, errmsg=u'房屋信息不存在')
# 将图片存入HouseImage
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = house_image_key
# 设置首页显示的房源默认图片
house.index_image_url = house_image_key
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg=u'图片数据保存失败')
# 5.拼接访问图片的url
house_image_url = constants.QINIU_DOMIN_PREFIX + house_image_key
return jsonify(errno=RET.OK,
errmsg=u'OK',
data={'house_image_url': house_image_url})
def save_house_image():
"""
保存房屋的图片
:param: 图片数据,房屋id
:return:图片地址
"""
user_id = g.user_id
image_file = request.files.get('house_image')
house_id = request.form.get('house_id')
if not all([image_file, house_id]):
return jsonify(errno=RET.PARAMERR, errmsg='参数不完整')
# 判断房屋id是否正确
try:
house = House.query.filter(
and_(House.id == house_id, House.user_id == user_id)).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='数据库异常')
if house is None:
return jsonify(errno=RET.NODATA, errmsg='房屋不存在')
image_data = image_file.read()
# 保存图片到七牛
try:
file_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='保存图片失败')
# 保存图片地址到数据库
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = file_name
db.session.add(house_image)
# 添加房屋的主图片
if not house.index_image_url:
house.index_image_url = file_name
db.session.add(house)
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存图片数据库异常')
image_url = constants.QINIU_URL_DOMAIN + file_name
return jsonify(errno=RET.OK, errmsg='ok', data={'image_url': image_url})
def set_house_images(house_id):
"""
获取参数
1. 房屋图片
2. 判断是否有图片上传， 没有数据时返回错误信息
3. 若有数据，则图区图片数据
:return:
"""
# 1.获取图片对象
house_image = request.files.get('house_image')
# 2. 判断图片数据是否为空
if not house_image:
return jsonify(errno=RET.DATAERR, errmsg='没有图片数据')
# 校验house_id,查询对应的house信息
try:
house = House.query.filter_by(id=house_id).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg='查询房屋信息失败')
if not house:
return jsonify(errno=RET.DATAERR, errmsg='您查询的房屋不存在')
# 3. 如果有图片数据时，
house_image_data = house_image.read()
# 4. 将图片数据上传到七牛云服务, 返回图片再七牛云上的图片名称
try:
image_name = storage(house_image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='上传图片信息失败')
# 5. 将图片名称保存到数据库,包含house.index_image_url和HouseImage.url
if not house.index_image_url:
house.index_image_url = image_name
db.session.add(house)
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_name
db.session.add(house_image)
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='更新图片信息到数据库错误')
# 拼接完整的url返回给浏览器
image_url = constants.QINIU_DOMIN_PREFIX + image_name
return jsonify(errno=RET.OK, errmsg='OK', data={'url': image_url})
def upload_house_image(house_id):
"""上传房屋图片"""
#1.获取图片信息
house_image = request.files.get('house_image')
# 3.查询当前房屋是否有房屋主图片，没有就为其添加
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.DBERR, msg='查询房屋失败')
if not house:
return jsonify(re_code=RET.NODATA, msg='无该房屋')
if not house_image:
return jsonify(re_code=RET.PARAMERR, msg='图片不能为空')
# 读取图片数据
try:
house_image_data = house_image.read()
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.DATAERR, msg='数据读取错误')
#2.上传到七牛云,返回key
try:
key = upload_image(house_image_data)
except Exception as e:
current_app.logger.debug(e)
return jsonify(re_code=RET.THIRDERR, msg='上传房屋图片失败')
# if not house.index_image_url:
house.index_image_url = key
#4.添加数据到当前house_id的House_Image模型中
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = key
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
current_app.logger.debug(e)
db.session.rollback()
return jsonify(re_code=RET.DBERR, msg='保存房屋图片失败')
#5.响应数据
return jsonify(re_code=RET.OK,
msg='上传图片成功',
data={'url': constants.QINIU_DOMIN_PREFIX + key})
def save_house_image(house_id):
"""
保存房屋图片
1. 获取图片参数 house_image
2. 根据房屋id参数 确认房屋的存在
3. 读取图片数据, 调用七牛云, 上传图片
4. 保存房屋图片数据, 房屋图片表和房屋表默认图片
5. 拼接房屋图片的绝对地址
6. 返回图片的URL
:param house_id:
:return:
"""
image = request.files.get('house_image')
if not image:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
# 根据路径参数房屋id查询房屋
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询数据失败')
if not house:
return jsonify(errno=RET.NODATA, errmsg='没有找到房屋')
# 读取图片数据
image_byte = image.read()
try:
image_name = storage(image_byte)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='第三方异常')
# 保存房屋图片数据, 房屋表, 房屋图片表
house_img = HouseImage()
house_img.house_id = house_id
house_img.url = image_name
# 如果房屋未设置主图片
if not house.index_image_url:
house.index_image_url = image_name
try:
db.session.add_all([house_img, house])
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='数据保存失败')
# 拼接图片的绝对路径返回渲染
image_url = constants.QINIU_DOMIN_PREFIX + image_name
return jsonify(errno=RET.OK, errmsg='OK', data={'url': image_url})
def save_house_image(house_id):
#上传房屋图片
#获取要上传的文件
house_image = request.files.get('house_image')
#判断获取结果
if not house_image:
return jsonify(errno=RET.PARAMERR, errmsg='参数错误')
#根据house_id查询house是否存在
try:
house = House.query.filter_by(id=house_id).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, ermsg='查询房屋信息失败')
#判断查询结果
if not house:
return jsonify(errno=RET.NODATA, errmsg='没有查询到数据')
#读取文件数据
file_data = house_image.read()
#定义图片名称
image_name = house_image.filename
#调用阿里云接口，尝试上传图片
try:
bucket.put_object(image_name, file_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='上传房屋图片失败')
#构建模型类,准备存储数据
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_name
#添加到数据库会话对象
db.session.add(house_image)
#如果没有默认主图片，就设置当前图片为默认的主图片
if not house.index_image_url:
house.index_image_url = image_name
db.session.add(house)
#保存到数据库
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存房屋图片数据失败')
#拼接图片绝对路径
image_url = constants.ALIYUN_DOMIN_PREFIX + image_name
#返回结果
return jsonify(errno=RET.OK, errmsg='OK', data={'url': image_url})
def upload_hose_image(house_id):
# 获取参数，house_id,要上传的图片
# 查询对应id的房屋
# 在上传图片
# 保存图片，判断房屋的首页图片是否有值，如果没有，设置
try:
housee_image_file = request.files.get("house_image").read()
except Exception as e:
current_app.logger.error(e)
return jsonify(erron=RET.PARAMERR,errmsg="参数错误")
# 查询是否有对应的房屋信息
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(erron=RET.DBERR,errmsg="查询房屋信息失败")
if not house:
return jsonify(erron=RET.NODATA,errmsg="房屋信息不存在")
# 上传图片
try:
image_url = storage_image(housee_image_file)
except Exception as e:
current_app.looger.error(e)
return jsonify(erron=RET.THIRDERR,errmsg="上传图片失败")
# 初始化模型
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_url
#设置房屋头图
try:
if not house.index_image_url:
house.index_image_url = image_url
db.session.add(house_image)
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errom=RET.DBERR,errmsg="保存图片数据失败")
return jsonify(erron=RET.OK,errmsg="OK",data={"url":QINIU_DOMIN_PREFIX + image_url})
def upload_house_image(house_id):
"""
1. 取到上传的图片
2. 进行七牛云上传
3. 将上传返回的图片地址存储
4. 进行返回
:return:
"""
# 获取参数
house_image = request.files.get('images')
house_id = house_id
user = g.ih_user_profile
if not user:
return jsonify(errno=RET.SESSIONERR, errmsg="用户未登录")
# 将图片上传到七牛云
try:
image_name = storage_image(house_image.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="上传图片到七牛云异常")
# 图片名称没有值
if not image_name:
return jsonify(errno=RET.DBERR, errmsg="上传图片到七牛云异常")
image = HouseImage()
image.url = constants.QINIU_DOMIN_PREFIX + image_name
image.house_id = house_id
data = {
"url": image.url,
}
try:
db.session.add(image)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
# 数据库回滚
db.session.rollback()
return jsonify(errno=RET.DBERR, errormsg="保存数据对象异常")
return jsonify(error=RET.OK, errmsg="上传图片成功", data=data)
def set_house_image():
# 获取数据: image, house_id
image_file = request.files.get('house_image')
house_id = request.form.get('house_id')
# 数据校验
if not all([image_file, house_id]):
return jsonify(errno=RET.PARAMERR, errmsg=u'数据不完整')
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'数据库异常')
if house is None:
return jsonify(errno=RET.NODATA, errmsg=u'房屋不存在')
# 业务处理
image_data = image_file.read()
try:
file_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg=u'上传图片失败')
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = file_name
db.session.add(house_image)
if not house.index_image_url:
house.index_image_url = file_name
db.session.add(house)
try:
db.session.commit()
except Exception as e:
db.session.rollback()
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg=u'图片存储失败')
# 返回响应
image_url = constants.QINIU_URL_DOMIN+file_name
return jsonify(errno=RET.OK, errmsg=u'保存成功', data={'image_url': image_url})
def upload_house_image(house_id):
"""
1. 取到上传的图片
2. 进行七牛云上传
3. 将上传返回的图片地址存储
4. 进行返回
:return:
"""
house_id = house_id
images = request.files.get("house_image")
if not all([house_id, images]):
return jsonify(errno=RET.PARAMERR, errmsg="参数不足")
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询房间数据异常")
if house is None:
return jsonify(errno=RET.NODATA, errmsg="房间不存在")
images_data = images.read()
try:
file_name = storage_image(images_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传失败")
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = file_name
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存图片异常")
image_url = constants.QINIU_DOMIN_PREFIX + file_name
print(image_url)
return jsonify(errno=RET.OK, errmsg="OK", data={"url": image_url})
def save_house_image(house_id):
"""房东上传房屋照片"""
# 获取要保存的房屋id与照片
image = request.files.get("house_image")
if not image:
return jsonify(errno=RET.PARAMERR, errmsg="未传图片")
# 判断房屋是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DATAERR, errmsg="房屋不存在")
# 读取上传的文件内容，并上传到七牛
image_data = image.read()
try:
image_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片失败")
# 保存房屋图片数据到数据库中，在数据库中仅保存七牛上文件的路径（文件名），不保存七牛的服务器域名
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_name
db.session.add(house_image)
# 如果房屋的主图片尚未设置，则设置房屋的主图片
if not house.index_image_url:
house.index_image_url = image_name
db.session.add(house)
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存房屋图片失败")
# 将图片路径拼接完整，返回给前端
img_url = constants.QINIU_DOMIN_PREFIX + image_name
return jsonify(errno=RET.OK, errmsg="OK", data={"url": img_url})
def set_house_image():
user_id = int(g.user_id)
try:
image_files = request.files.get('house_image')
house_id = request.form.get('house_id')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.PARAMERR, errmsg='请求参数错误')
if not all([house_id, image_files]):
return jsonify(errno=RET.PARAMERR, errmsg='缺少请求参数')
try:
house = House.query.get(int(house_id))
if not house:
return jsonify(errno=RET.DATAEXIST, errmsg='请求参数信息错误')
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋数据失败')
try:
image_key = upload_image(image_files.read())
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='图片上传错误')
if not image_key:
return jsonify(errno=RET.DATAERR, errmsg='图片信息错误')
if not house.index_image_url:
house.index_image_url = image_key
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_key
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存数据库错误')
image_url = constants.QINIU_DOMIN_PREFIX + image_key
return jsonify(errno=RET.OK, errmsg='OK', image_url=image_url)
def set_house_image():
# 获取参数
house_id = request.form.get('house_id')
if not house_id:
return jsonify(errno=RET.PARAMERR, errmsg='缺少房屋信息')
try:
img_data = request.files.get('house_image')
except Exception as e:
return jsonify(errno=RET.PARAMERR, errmsg='获取图片失败')
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋信息失败')
if not house:
return jsonify(errno=RET.PARAMERR, errmsg='房屋不存在')
try:
key = upload_image(img_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='上传图片失败')
house_image = HouseImage()
house_image.house_id = house.id
house_image.url = key
if not house.index_image_url:
house.index_image_url = key
# 保存房屋信息
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存图片信息失败')
img_url = constants.QINIU_DOMIN_PREFIX + key
return jsonify(errno=RET.OK, errmsg='OK', data={'img_url': img_url})
def save_house_image(house_id):
"""
上传房屋图片
1/获取参数,image_data = request.files属性
2/判断获取结果
3/根据house_id查询数据库,House模型类,
4/判断查询结果,确认房屋的存在
5/读取图片数据
6/调用七牛云接口,上传图片
7/保存图片名称
8/构造HouseImage模型类对象,准备存储房屋图片数据
house_image = HouseImage()
house_image.house_id = house.id
house_image.url = image_name
db.session.add(house_image)
9/判断房屋默认图片是否设置,如未设置,默认添加当前图片为主图片;
10/保存房屋对象数据,db.session.add(house)
11/提交数据到数据库中
db.session.commit()
12/拼接图片的绝对路径
13/返回结果
:param house_id:
:return:
"""
# 获取图片文件
house_image = request.files.get("house_image")
# 检验参数的存在
if not house_image:
return jsonify(errno=RET.PARAMERR, errmsg="未上传房屋图片")
# 连接数据库，判断房屋的存在
try:
house = House.query.filter_by(id=house_id).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询房屋数据失败")
# 判断查询结果
if not house:
return jsonify(errno=RET.NODATA, errmsg="房屋不存在")
# 读取图片数据
house_image_data = house_image.read()
# 调用七牛云接口，上传房屋图片
try:
image_name = storage(house_image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="上传图片失败")
# 保存房屋图片数据，构建模型类对象
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_name
# 添加数据到数据库会话对象
db.session.add(house_image)
# 判断房屋朱图片是否设置，如未设置，添加当前图片为主图片
if not house.index_image_url:
house.index_image_url = image_name
db.session.add(house)
# 提交数据到mysql数据库
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存房屋图片数据失败")
# 拼接图片的绝对路径
image_url = constants.QINIU_DOMIN_PREFIX + image_name
# 返回数据
return jsonify(errno=RET.OK, errmsg="OK", data={"url": image_url})
def save_house_image(house_id):
"""
上传房屋图片信息
1.获取参数，用户上传的图片数据
2.校验参数的存在
3.根据house_id查询数据库，校验房屋的存在
4.读取图片数据
5.调用七牛云接口上传图片，保存返回的图片名字
6.构造模型类对象HouseImage，存储图片关联的房屋
7.临时提交图片数据到数据库
8.查询用户房屋主图片是否设置
9.如果没有设置，添加当期图片为主图片
10.提交图片数据到数据库中commit
11.拼接图片的url
12.返回结果
:param house_id:
:return:
"""
# 获取用户上传的图片
image = request.files.get('house_image')
# 检查参数是否存在
if not image:
return jsonify(errno=RET.PARAMERR, errmsg="图片未上传")
# 查询房屋信息是否存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询房屋信息异常")
# 判断查询结果
if not house:
return jsonify(errno=RET.NODATA, errmsg="无房屋数据")
# 读取图片数据
image_data = image.read()
# 调用七牛云接口，上传图片
try:
image_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg="图片上传失败")
# 构造模型类HouseImage对象
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_name
# 临时提交数据到house_image中
db.session.add(house_image)
# 判断房屋主图片是否设置，如未设置，进行设置
if not house.index_image_url:
house.index_image_url = image_name
# 临时提交数据到会话对象当中
db.session.add(house)
# 提交数据到数据库中
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="保存图片数据失败")
# 拼接图片的url（绝对路径）
image_url = constants.QINIU_DOMIN_PREFIX + image_name
# 返回结果
return jsonify(errno=RET.OK, errmsg="OK", data={'url': image_url})
def save_house_image(house_id):
"""
保存房屋图片
1/获取参数,request.files.get('house_image')
2/校验图片参数存在
3/根据house_id查询数据库,确认房屋的存在
4/校验查询结果
5/读取图片数据
6/调用七牛云接口,上传房屋图片
7/构造模型类对象,
house_image = HouseImage()
db.session.add(house_image)
8/判断房屋主图片是否设置,如未设置,默认添加用户上传的第一张房屋图片为主图片
if not house.index_image_url:
house.index_image_url = image_name
db.session.add(house)
9/提交数据到数据库中
10/拼接图片路径,七牛云的外链域名和图片名称
11/返回结果
:param house_id:
:return:
"""
# 获取图片参数
image = request.files.get('house_image')
# 校验参数的存在
if not image:
return jsonify(errno=RET.PARAMERR, errmsg='图片未上传')
# 根据house_id查询数据库,确认房屋的存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋数据失败')
# 校验查询结果
if not house:
return jsonify(errno=RET.NODATA, errmsg='无房屋数据')
# 读取图片数据
image_data = image.read()
# 调用七牛云接口,上传房屋图片
try:
image_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='上传房屋图片失败')
# 构造HouseImage模型类对象,保存房屋图片
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_name
# 把房屋图片数据存入数据库会话对象中
db.session.add(house_image)
# 判断房屋主图片是否设置
if not house.index_image_url:
house.index_image_url = image_name
# 把房屋图片数据存入数据库会话对象中
db.session.add(house)
# 提交数据到数据库中
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存房屋图片失败')
# 拼接图片绝对路径
image_url = constants.QINIU_DOMIN_PREFIX + image_name
# 返回结果
return jsonify(errno=RET.OK, errmsg='OK', data={'url': image_url})
def upload_house_images(house_id):
"""
1.获取参数
2.验证
3.通过house_id查询房屋对象
4.通过七牛云上传图片获取返回的url
5.设置房屋的默认图像图像
6.创建房屋图片对象
7.设置图片对象的房屋编号
8.更新数据库
9.返回,携带图片的url
:param house_id:
:return:
"""
# 1.获取参数
image_data = request.files.get("house_image").read()
# 2.验证
if not image_data:
return jsonify(errno=RET.PARAMERR, errmsg="请选择图片")
# 3.通过house_id查询房屋对象
try:
house = House.query.filter(House.id == house_id).first()
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg="查询房屋失败")
if not house:
return jsonify(errno=RET.DATAERR, errmsg="该房屋不存在")
# 4.通过七牛云上传图片获取返回的url
try:
image_url = image_storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errnp=RET.THIRDERR, errmsg="七牛云上传图片失败")
# 5.设置房屋的默认图像图像
if not house.index_image_url:
house.index_image_url = image_url
# 6.创建房屋图片对象
house_image = HouseImage()
house_image.url = image_url
# 7.设置图片对象的房屋编号
house_image.house_id = house_id
# 8.更新数据库
try:
db.session.add(house_image)
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg="房屋图片保存失败")
# 9.返回, 携带图片的url
house_image_url = constants.QINIU_DOMIN_PREFIX + image_url
return jsonify(errno=RET.OK,
errmsg="房屋图片保存失败",
data={"url": house_image_url})
def save_house_image(house_id):
"""
保存房屋图片:
1/获取参数,图片house_image
2/校验参数的存在
3/根据house_id查询数据库,确认房屋的存在
house = House.query.get(house_id)
4/读取图片数据
5/调用七牛云上传图片,保存返回的图片名称(相对路径)
6/构造模型类对象,HouseImage对象,存储图片关联的房屋,以及图片的名称
7/临时提交数据到HouseImage对象,db.session.add(house_image)
8/判断房屋主图片是否设置,如未设置默认添加当前的图片为房屋主图片
9/临时提交数据到House对象,db.session.add(house)
10/提交数据到数据库中,如果发生异常需要进行回滚
11/拼接图片的绝对路径
12/返回结果
:param house_id:
:return:
"""
# 获取参数,post请求的图片参数
image = request.files.get('house_image')
# 检查参数的存在
if not image:
return jsonify(errno=RET.PARAMERR, errmsg='图片未上传')
# 确认房屋的存在
try:
house = House.query.get(house_id)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.DBERR, errmsg='查询房屋信息异常')
# 校验查询结果
if not house:
return jsonify(errno=RET.NODATA, errmsg='无房屋数据')
# 读取图片数据
image_data = image.read()
# 调用七牛云接口,实现图片上传
try:
image_name = storage(image_data)
except Exception as e:
current_app.logger.error(e)
return jsonify(errno=RET.THIRDERR, errmsg='上传图片到七牛失败')
# 构造模型类对象,准备存储房屋图片数据
house_image = HouseImage()
house_image.house_id = house_id
house_image.url = image_name
# 临时提交图片数据到数据库会话对象中
db.session.add(house_image)
# 判断房屋主图片是否设置,如未设置默认添加当前图片为主图片
if not house.index_image_url:
house.index_image_url = image_name
# 临时提交图片数据到数据库会话对象中
db.session.add(house)
# 提交数据到数据库中
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return jsonify(errno=RET.DBERR, errmsg='保存图片失败')
# 拼接图片的url
image_url = constants.QINIU_DOMIN_PREFIX + image_name
# 返回结果
return jsonify(errno=RET.OK, errmsg='OK', data={'url': image_url})