class CheckHandler(BaseHandler):
"""
检查用户是否是老用户: /passport/login/check
"""
rule = {
"mobile": Rule(mobile=True, allow_empty=False),
"country": Rule(direct_type=int, allow_empty=True, default=86)
}
@filter_params(get=rule)
def get(self, params):
result = {
"is_new": 0, # 是否是老用户：1是0否
"perfect_info_pwd": 0, # 是否需要完善密码：1是0否
}
mobile = params["mobile"]
user = UserAccountModel.query_account_by_mobile(mobile, params["country"], True)
# 1.用户是否存在 2.用户是否设置了密码
if user:
if not user.password:
result["perfect_info_pwd"] = 1
else:
result["is_new"] = 1
return json_success_response(result)
def post(self):
return json_fail_response(501)
class IndexHandler(BaseHandler):
rule = {
"share_id": Rule(direct_type=int),
"last_id": Rule(direct_type=int, allow_empty=True, default=0)
}
@filter_params(get=rule)
def get(self, params):
query = LikeModel.query.filter_by(share_id=params["share_id"],
status=1)
if params["last_id"]:
query = query.filter(LikeModel.like_id < params["last_id"])
like_model_list = query.order_by(
LikeModel.like_id.desc()).limit(20).all()
result = list()
for model in like_model_list:
user_info = UserInfoModel.query_user_model_by_id(model.user_id)
user_info = UserInfoModel.format_user_info(user_info)
user_info["like_id"] = model.like_id
result.append(user_info)
return json_success_response(result)
class ReportHandler(BaseHandler):
rule = {
"longitude": Rule(direct_type=float),
"latitude": Rule(direct_type=float)
}
@filter_params(post=rule)
def post(self, params):
user_location = UserLocationModel()
user_location.access_token = g.account.get("access_token")
user_location.user_id = g.account.get("user_id")
user_location.longitude = params["longitude"]
user_location.latitude = params["latitude"]
db.session.add(user_location)
db.session.commit()
# 更新用户信息
if g.account["user_id"]:
UserInfoModel.query.filter_by(user_id=g.account["user_id"]).update(
{"location_id": user_location.id})
return json_success_response("")
class IndexHandler(BaseHandler):
rule = {
"username": Rule(mobile=True),
"password": Rule(),
"country": Rule(direct_type=int, allow_empty=True, default=86)
}
@filter_params(post=rule)
def post(self, params):
account = UserAccountModel.query_account_by_mobile(params["username"], params["country"])
if not account:
return json_fail_response(2101)
if not check_password(account.id, params["password"], account.password):
return json_fail_response(2104)
# 当前token已经绑定了一个user_id，并且绑定的用户手机号，与当前手机号不同
cache_account = g.account
if cache_account["user_id"]:
if cache_account["mobile"] != str(params["username"]):
from .login_mobile import IndexHandler
# 生成新的token
new_access_token = IndexHandler.create_new_token_account(cache_account)
# 禁用旧的token
UserAccessTokenModel.forbid_by_token(cache_account["access_token"])
# 更新内存中的数据
cache_account["access_token"] = new_access_token.access_token
cache_account["salt"] = new_access_token.salt
# 执行token绑定
UserAccessTokenModel.bind_user_id(cache_account["access_token"], account.id)
# 刷新缓存
result = AccountDataModel.query_request_account_by_token(cache_account["access_token"], refresh=True)
result["perfect_info"] = 0
result["perfect_info_pwd"] = 0
relation = UserIdRelationModel.query_user_id_relation(account.id)
result["huanxin_uid"] = ""
if relation:
result["huanxin_uid"] = relation.str_id
if not result["gender"]:
result["perfect_info"] = 1
# 日活统计
open_log = OpenLogModel()
open_log.user_id = result.get("user_id", 0)
open_log.udid = result.get("udid", "")
open_log.access_token = result.get("access_token", "")
open_log.device_type = result.get("device_type", "")
open_log.version = result.get("version", "")
open_log.type = 3
db.session.add(open_log)
db.session.commit()
return json_success_response(result)
class IndexHandler(BaseHandler):
rule = {
"share_id": Rule(direct_type=int),
"last_id": Rule(direct_type=int, allow_empty=True, default=0),
}
@filter_params(get=rule)
def get(self, params):
result = CommentModel.query_share_comment_list(params["share_id"],
g.account["user_id"],
params["last_id"])
return json_success_response(result)
class GetListHandler(BaseHandler):
rule = {"last_id": Rule(direct_type=int, allow_empty=True, default=0)}
@login_required
@filter_params(get=rule)
def get(self, params):
login_user_id = g.account["user_id"]
RedisModel.reset_new_message(login_user_id, RedisModel.new_visitor)
visitor_list = list()
while not visitor_list:
visitor_list = VisitorRecordModel.query_visitor_list_by_day(
login_user_id, 20, params["last_id"])
params["last_id"] += 1
# 最多查询30天
if params["last_id"] > 30:
break
visitor_dict_list = list()
for visitor in visitor_list:
item = dict()
user_info = UserInfoModel.query_user_model_by_id(
visitor.visitor_user_id)
item["user_info"] = UserInfoModel.format_user_info(
user_info) if user_info else {}
item["time"] = visitor.created_time
visitor_dict_list.append(item)
return json_success_response({
"last_id": params["last_id"],
"list": visitor_dict_list
})
class GeneratePasswordHandler(BaseHandler):
rule = {'password': Rule()}
def get(self):
return json_fail_response(501)
@filter_params(post=rule)
def post(self, params):
account = g.account
if not account:
return json_fail_response(503)
password = params["password"]
if len(password) != 6:
return json_fail_response(2017)
if not re.match(r"[a-zA-Z0-9]{6}", password):
return json_fail_response(2018)
password = generate_password(account["user_id"], password)
UserAccountModel.update_account_password(account["user_id"],
account["mobile"],
account["country"], password)
return json_success_response()
class EaseMobHandler(BaseHandler):
rule = {"huanxin_uid": Rule()}
@login_required
@filter_params(get=rule)
def get(self, params):
user_id_relation = UserIdRelationModel.query_user_by_ease_mob_id(
params["huanxin_uid"])
if not user_id_relation:
return json_fail_response(2109)
result = EaseMobHandler.format_ease_mob_user(g.account["user_id"],
user_id_relation.user_id)
return json_success_response(result)
@staticmethod
def format_ease_mob_user(login_user_id, user_id):
user_info = UserInfoModel.query_user_model_by_id(user_id)
has_trade = UserConsumerModel.query_trade_relationship(
user_id, login_user_id)
follow_status = FollowModel.query_relation_to_user(
login_user_id, user_id)
remark_name = RemarkNameModel.query_remark_name(login_user_id, user_id)
result = {
"user_info": UserInfoModel.format_user_info(user_info),
"had_trade": has_trade,
"follow_status": follow_status,
"black_status": 0,
"remark_name": remark_name.remark_nickname if remark_name else ""
}
return result
class IndexHandler(BaseHandler):
per_page = 20
rule = {"limit": Rule(direct_type=int, allow_empty=True, default=1)}
@login_required
@filter_params(get=rule)
def get(self, params):
offset = IndexHandler.per_page * params["limit"]
user_black_list = UserBlackModel.query_user_black_list(
g.account["user_id"], 1, offset, IndexHandler.per_page)
user_id_list = array_column(user_black_list, "black_user_id")
result = list()
for user_id in user_id_list:
user_info = UserInfoModel.query_user_model_by_id(user_id)
if not user_info:
continue
item = dict()
item["user_id"] = user_info.user_id
item["nickname"] = user_info.nickname
item["avatar"] = UserInfoModel.format_user_avatar(user_info)
user_id_relation = UserIdRelationModel.query_user_id_relation(
user_info.user_id)
item[
"huanxin_uid"] = user_id_relation.str_id if user_id_relation else ""
result.append(item)
return json_success_response(result)
class GetListHandler(BaseHandler):
per_page = 20
rule = {
"user_id": Rule(direct_type=int),
"last_id": Rule(direct_type=int, allow_empty=True, default=0),
"type": Rule(direct_type=int, allow_empty=True, enum=(2, 3, 4)) # 2关注 3粉丝 4好友
}
@filter_params(get=rule)
def get(self, params):
params["limit"] = self.per_page
user_list = []
field = ""
# 关注
if params["type"] == 2:
user_list = FollowModel.query_follow_list(params)
field = "follow_id"
# 粉丝
elif params["type"] == 3:
user_list = FollowModel.query_fans_list(params)
field = "user_id"
# 好友
elif params["type"] == 4:
user_list = FollowModel.query_friends_list(params)
field = "follow_id"
if not user_list:
return json_success_response(user_list)
other_user_id_list = array_column(user_list, field)
user_relations_dict = FollowModel.query_relation_to_user_list(g.account["user_id"], other_user_id_list)
result = list()
for follow_model in user_list:
item = dict()
item["id"] = follow_model.id
user_id = getattr(follow_model, field)
item["relation_type"] = user_relations_dict.get(user_id, 0)
user_model = UserInfoModel.query_user_model_by_id(user_id)
item["user_info"] = UserInfoModel.format_user_info(user_model)
result.append(item)
return json_success_response(result)
class IndexHandler(BaseHandler):
rule = {
"user_id": Rule(direct_type=int),
"last_id": Rule(direct_type=int, allow_empty=True, default=0)
}
@filter_params(get=rule)
def get(self, params):
login_user_id = g.account["user_id"]
is_self = params["user_id"] == login_user_id
share_model_list = ShareModel.query_user_share_list(
params["user_id"] if not is_self else None,
login_user_id if is_self else 0, 20, params["last_id"])
result = ShareModel.format_share_model(share_model_list, login_user_id)
return json_success_response(result)
class SpendForMeHandler(BaseHandler):
rule = {"user_id": Rule(direct_type=int), "last_id": Rule(direct_type=int)}
@login_required
@filter_params(get=rule)
def get(self, params):
result = {
"list": list(),
"sum_cash": 0,
}
money = UserConsumerModel.query_relation_consumer_money(
g.account["user_id"], params["user_id"])
order_list = OrderMetaModel.query_order_with_others(
g.account["user_id"], params["user_id"], last_id=params["last_id"])
# 没有订单数据
if not order_list:
return json_success_response(result)
order_id_list = array_column(order_list, "order_id")
user_income_model_list = UserIncomeModel.query_order_income_list(
g.account["user_id"], order_id_list)
if not user_income_model_list:
return json_success_response(result)
item_list = list()
for model in user_income_model_list:
item = dict()
item["id"] = model.order_id
item["cash_amount"] = model.cash_amount / 100
item["time"] = model.created_time
item["type"] = model.type
item["message"] = order_type_message.get(model.type, "未知类型")
item["type_img"] = order_type_image_url.get(model.type, "")
item_list.append(item)
result["sum_cash"] = money / 100
result["list"] = item_list
return json_success_response(result)
class FriendStatusHandler(BaseHandler):
rule = {
"user_id": Rule(direct_type=int)
}
@login_required
@filter_params(get=rule)
def get(self, params):
relation = FollowModel.query_relation_to_user(g.account["user_id"], params["user_id"])
return json_success_response({"data": relation})
class IndexHandler(BaseHandler):
rule = {
"position": Rule(direct_type=int, allow_empty=True, default=0),
"share_id": Rule(direct_type=int, allow_empty=True, default=0)
}
@filter_params(get=rule)
def get(self, params):
# 查询到被推荐动态的id
share_id_list = ShareRecommendModel.query_share_recommend_id_list(
params["position"], g.account.get("user_id", 0),
params["share_id"])
# 根据动态id查询动态详细信息
share_list = ShareModel.query_share_info_list(share_id_list)
# 格式化动态
result = ShareModel.format_share_model(share_list,
account=g.account["user_id"])
# 返回结果
return json_success_response(result)
class IndexHandler(BaseHandler):
rule = {
"black_user_id": Rule(direct_type=int),
"status": Rule(direct_type=int)
}
@login_required
@filter_params(post=rule)
def post(self, params):
result = UserBlackModel.update_black_status(g.account["user_id"],
params["black_user_id"],
params["status"])
if not result:
return json_fail_response(2110)
UserBlackModel.query_black_people(g.account["user_id"], True)
return json_success_response(result)
class AddHandler(BaseHandler):
max_upload_image_count = 6
rule = {
"content": Rule(),
"system": Rule(),
"version": Rule(),
"type": Rule(direct_type=int, allow_empty=True, default=0),
"mobile_model": Rule(),
"user_id": Rule(direct_type=int, allow_empty=True, default=0)
}
@login_required
@filter_params(post=rule)
def post(self, params):
img_uploader = UploadImage()
img_id_list = list()
if img_uploader.images:
if len(img_uploader.images) > AddHandler.max_upload_image_count:
return json_fail_response(2407)
img_uploader.save_images()
for image_info in img_uploader.images:
img_model = image_info["image"]
img_model.user_id = g.account["user_id"]
img_model.type = 13
img_id_list.append(img_model.image_id)
db.session.commit()
json_data = {"image_id": img_id_list}
if params["type"] == 1:
json_data["user_id"] = params["user_id"]
user_feed_back = UserFeedBackModel()
user_feed_back.user_id = g.account["user_id"]
user_feed_back.type = params["type"]
user_feed_back.content = params["content"]
user_feed_back.system = params["system"]
user_feed_back.version = params["version"]
user_feed_back.mobile_model = params["mobile_model"]
user_feed_back.json_data = json.dumps(json_data)
db.session.add(user_feed_back)
result = {"data": 1, "message": "感谢您的反馈"}
if params["type"] == 1:
result["message"] = "投诉成功，我们会尽快处理！"
try:
db.session.commit()
except:
result["data"] = 0
if params["type"] == 1:
result["message"] = "投诉失败，请稍后重试！"
else:
result["message"] = "留言未受理"
return json_success_response(result)
class RemindAddHandler(BaseHandler):
rule = {
"user_id": Rule(direct_type=int),
"type": Rule(direct_type=int, enum=[11, 31])
}
@login_required
@filter_params(post=rule)
def post(self, params):
if params["user_id"] == g.account["user_id"]:
return json_fail_response(2411)
result = dict()
RedisModel.add_new_message(
params["user_id"], RedisModel.private_image_want
if params["type"] == 11 else RedisModel.private_video_want)
result["data"] = 1
result["message"] = "邀请成功"
return json_success_response(result)
class AddHandler(BaseHandler):
max_upload_image_count = 6
rule = {
"wechat": Rule(reg=r"^[_a-zA-Z0-9]{5,20}$"),
"price": Rule(direct_type=float, range=Range(99, 1314))
}
@login_required
@filter_params(post=rule)
def post(self, params):
permit = UserPermitModel.query_user_permit_model(g.account["user_id"])
if permit and permit.allow_post_wechat == 0:
return json_fail_response(2408)
wechat = UserWeChatModel()
wechat.user_id = g.account["user_id"]
wechat.wechat = params["wechat"]
wechat.price = params["price"] * 100
wechat.status = 1
db.session.add(wechat)
try:
db.session.commit()
UserInfoModel.query_user_model_by_id(g.account["user_id"], True)
return json_success_response({
"data": 1,
"message": "设置成功",
})
except:
return json_success_response({
"data": 0,
"message": "设置失败",
})
class IndexHandler(BaseHandler):
rule = {"last_id": Rule(direct_type=int, allow_empty=True, default=0)}
@login_required
@filter_params(get=rule)
def get(self, params):
user_id = g.account["user_id"]
follow_user_id_list = FollowModel.query_follow_user_list(user_id)
follow_user_id_list = list(set(follow_user_id_list))
share_model_list = ShareModel.query_user_share_list(
follow_user_id_list, user_id, 20, params["last_id"], 0)
share_info_list = ShareModel.format_share_model(
share_model_list, user_id)
return json_success_response(share_info_list)
class BlackStatusHandler(BaseHandler):
rule = {"black_user_id": Rule(direct_type=int)}
@login_required
@filter_params(get=rule)
def get(self, params):
code = UserBlackModel.check_black_status(g.account["user_id"],
params["black_user_id"])
result = {"data": code, "message": "无拉黑关系"}
if code == 1:
result["message"] = "我把它拉黑"
elif code == 2:
result["message"] = "他把我拉黑"
elif code == 3:
result["message"] = "已互相拉黑"
return json_success_response(result)
class PrivateInfoHandler(BaseHandler):
rule = {"user_id": Rule(direct_type=int)}
@login_required
@filter_params(get=rule)
def get(self, params):
pri_img_model = ImageModel.query.filter_by(user_id=params["user_id"],
type=11,
status=1).first()
pri_video_model = None
result = dict()
result["pri_image_status"] = 1 if pri_img_model else 0
result["pri_video_status"] = 1 if pri_video_model else 0
result["wechat_info"] = UserWeChatModel.full_wechat_info(
params["user_id"], g.account["user_id"])
return json_success_response(result)
class SoldListHandler(BaseHandler):
rule = {"last_id": Rule(direct_type=int, allow_empty=True, default=0)}
@login_required
@filter_params(get=rule)
def get(self, params):
query = OrderMetaModel.query.filter_by(seller_id=g.account["user_id"],
product_type=80)
query = query.filter(OrderMetaModel.order_status.in_([2, 3, 5, 6]),
OrderMetaModel.ship_status.in_([0, 2, 3]))
if params["last_id"]:
query = query.filter(OrderMetaModel.id < params["last_id"])
order_meta_list = query.order_by(
OrderMetaModel.id.desc()).limit(20).all()
result = UserWeChatModel.format_user_wechat_data(
order_meta_list, {"user_id", g.account["user_id"]}, "seller_id",
"buyer_id")
return json_success_response(result)
class TradeHandler(BaseHandler):
rule = {"user_id": Rule(direct_type=int)}
@login_required
@filter_params(get=rule)
def get(self, params):
from collections import OrderedDict
query_params = OrderedDict()
query_params["pay_status"] = 1
query_params["seller_id"] = params["user_id"]
query_params["buyer_id"] = g.account["user_id"]
order_meta = OrderMetaModel.query_order_meta(query_params)
result = {
"data": 1 if order_meta else 0,
"message": "已有消费" if order_meta else "尚未消费"
}
return json_success_response(result)
class ChangeHandler(BaseHandler):
rule = {"aha_id": Rule(length=Length(5, 20))}
@login_required
@filter_params(post=rule)
def post(self, params):
check_result = AhaAccountModel.check(params["aha_id"])
if not check_result["success"]:
return json_fail_response(2107, check_result["message"])
account = AhaAccountModel.query_aha_account_by_aha_id(params["aha_id"])
if account and account.changeable_aha == 0:
return json_fail_response(2108)
result = AhaAccountModel.update_aha_id(g.account["user_id"],
params["aha_id"])
if result:
return json_success_response({"data": 1, "message": "设置成功"})
else:
return json_success_response({"data": 0, "message": "设置失败"})
class AlbumHandler(BaseHandler):
rule = {
"user_id": Rule(direct_type=int)
}
@filter_params(get=rule)
def get(self, params):
social_page_info = SocialPageModel.query_social_page_model(params["user_id"])
result = dict()
result["user_banner"] = social_page_info.get("cover", "")
result["user_banner_type"] = social_page_info.get("cover_type", 0)
if result["user_banner_type"] == 2:
result["orientation"] = social_page_info.get("orientation", "")
result["user_banner_cover"] = social_page_info.get("video_img", "")
result["album"] = UserInfoModel.query_user_album(params["user_id"])
return result
class IndexHandler(BaseHandler):
rule = {
"share_id": Rule(direct_type=int),
}
@filter_params(get=rule)
def get(self, params):
share_model = ShareModel.query_share_model(params["share_id"],
status=status_private)
if not share_model:
return json_fail_response(2405)
share_info = ShareModel.format_share_model([share_model],
g.account["user_id"])[0]
like_list = LikeModel.query_like_list(params["share_id"], 0)
share_info["like_list"] = like_list
del share_info["price"]
del share_info["product_id"]
return json_success_response(share_info)
class IndexHandler(BaseHandler):
rule = {"user_id": Rule(direct_type=int, allow_empty=True, default=0)}
@filter_params(get=rule)
def get(self, params):
if params["user_id"] == 0:
return json_fail_response(2101)
user_info = UserInfoModel.query_user_model_by_id(params["user_id"])
result = UserInfoModel.format_user_info(user_info)
social_meta_info = SocialMetaModel.query_social_meta_info(
params["user_id"])
result["share_num"] = social_meta_info.share if social_meta_info else 0
result[
"follow_num"] = social_meta_info.following if social_meta_info else 0
result[
"fans_num"] = social_meta_info.follower if social_meta_info else 0
result["follow_status"] = FollowModel.query_relation_to_user(
g.account["user_id"], params["user_id"])
result["album"] = UserInfoModel.query_user_album(params["user_id"])
social_page_info = SocialPageModel.query_social_page_model(
params["user_id"])
result["user_banner"] = social_page_info.get("cover", "")
result["user_banner_type"] = social_page_info.get("cover_type", 1)
if result["user_banner_type"] == 2:
result["orientation"] = ""
result["user_banner_cover"] = ""
if params["user_id"] == g.account["user_id"]:
result["profit"] = IndexHandler.query_user_profit(
params["user_id"])
if result["identified"] == 1:
result["identify_title"] = "官方认证：" + result["identify_title"]
result["wechat_info"] = MeHandler.format_wechat_info(
params["user_id"],
social_meta_info.wechat_want if social_meta_info else 0)
user_location = UserLocationModel.query.filter(
UserLocationModel.id == user_info.location_id).first()
result["latitude"] = user_location.latitude if user_location else 0
result["longitude"] = user_location.longitude if user_location else 0
result["changeable_aha"] = 1
result["aha_id"] = ''
aha_info = AhaAccountModel.query_aha_account_by_id(params['user_id'],
auto_formated=False)
if aha_info:
result["changeable_aha"] = aha_info.changeable_aha
if aha_info.changeable_aha == 0:
result["aha_id"] = aha_info.aha_id
# 最近的动态
result["share_info"] = ShareModel.query_recent_share_photo(
params['user_id'], g.account["user_id"])
# 是否有交易记录
result["had_trade"] = 1
# 备注昵称
result["remark_name"] = ""
last_login = OpenLogModel.query_last_login(params["user_id"])
result["last_login"] = 0
if last_login:
result["last_login"] = time.time() - time.mktime(
last_login.created_time.timetuple())
# 插入访客记录
if g.account["user_id"] != 0 and g.account["user_id"] != params[
"user_id"]:
RedisModel.add_new_message(params["user_id"],
RedisModel.new_visitor)
VisitorRecordModel(user_id=params["user_id"],
visitor_user_id=g.account["user_id"])
return json_success_response(result)
@staticmethod
def query_user_profit(user_id):
user_profit = UserProfitModel.query_user_profit(user_id)
result = {
"all_money": user_profit.money if user_profit else 0,
"today_money": user_profit.today_money if user_profit else 0,
}
return result
class IndexHandler(BaseHandler):
rule = {
"content": Rule(allow_empty=True, default=""),
"type": Rule(direct_type=int,
enum=(10, 11, 20, 21, 30, 31, 70, 80, 90)),
"position": Rule(allow_empty=True, default=""),
"at_info": Rule(allow_empty=True, default=""),
"price": Rule(direct_type=float, allow_empty=True, default=0)
}
@login_required
@filter_params(post=rule)
def post(self, params):
img_upload = UploadImage()
video_upload = UploadVideo()
if params["type"] == 10:
if not img_upload.images:
return json_fail_response(2201)
img_upload.save_images()
elif params["type"] == 30:
if not video_upload.videos:
return json_fail_response(2202)
if not img_upload.images:
return json_fail_response(2203)
img_upload.save_images()
video_upload.save_videos()
share = ShareModel()
share.content = params["content"]
share.user_id = g.account["user_id"]
share.type_id = params["type"]
share.price = params["price"] * 100
share.position = params["position"]
# 默认需要进入审核状态
share.status = 3
share.data = params["at_info"]
db.session.add(share)
db.session.commit()
# 更新图片数据
if params["type"] == 10:
self.update_image(img_upload.images, share)
# 更新视频动态数据
elif params["type"] == 30:
img_model = img_upload.images[0]["image"]
video_model = video_upload.videos[0]["video"]
self.update_video(video_model, share, img_model)
# 更新social_meta
SocialMetaModel.update_social_meta_model(share.user_id, ["share"],
meta_add=True)
# 更新share_meta
ShareMetaModel.update_share_meta_model(share.share_id, share.user_id)
# 创建首页推荐数据
ShareRecommendModel(share.share_id,
share.user_id,
position=0,
status=3)
share_info = ShareModel.format_share_model([share])
return json_success_response(share_info)
def update_image(self, images, share, img_type=10):
for img in images:
img_model = img["image"]
img_model.share_id = share.share_id
img_model.user_id = share.user_id
img_model.type = img_type
db.session.commit()
def update_video(self, video_model, share_model, image_model):
# 更新video表
video_model.share_id = share_model.share_id
video_model.user_id = share_model.user_id
video_model.cover_id = image_model.image_id
video_model.screenshot_a = image_model.image_a
video_model.screenshot_b = image_model.image_b
video_model.screenshot_c = image_model.image_c
image_model.share_id = share_model.share_id
image_model.user_id = share_model.user_id
db.session.commit()
from app.modules.vendor.pre_request.flask import filter_params
from app.modules.vendor.pre_request.filter_rules import Rule
from app.modules.core import core
from app.modules.base.base_handler import BaseHandler
from app.models.core.app_version import AppVersionModel
from app.helper.response import *
"""
core/appversion/isopen
core/appversion/getversion
通用规则
"""
rule = {
"version": Rule(allow_empty=False),
"device_type": Rule(allow_empty=False)
}
class OpenHandler(BaseHandler):
"""
APP审核开关：/core/appversion/isopen
"""
ios_version = [
"1.0.1",
]
android_version = [
'baidu2.0.1',
]
class ChangeCoverHandler(BaseHandler):
rule = {"cover_type": Rule(direct_type=int)}
@login_required
@filter_params(post=rule)
def post(self, params):
img_upload = UploadImage()
print(params)
if params["cover_type"] == 1:
if not img_upload.images:
return json_fail_response(2402)
img_upload.save_images()
image_model = img_upload.images[0]["image"]
ChangeCoverHandler.change_cover_image(image_model)
else:
pass
cover_info = SocialPageModel.query_social_page_model(
g.account["user_id"])
result = {
"user_banner": cover_info.get("cover", ""),
"user_banner_type": cover_info.get("cover_type", 0)
}
if result.get("user_banner_type", 0) == 2:
result["orientation"] = cover_info.get("orientation")
result["user_banner_cover"] = cover_info.get("video_img", "")
UserInfoModel.query_user_model_by_id(g.account["user_id"], True)
return json_success_response(result)
@staticmethod
def change_cover_image(image_model):
"""
修改封面图片
"""
image_model.user_id = g.account["user_id"]
UserInfoModel.query.filter_by(user_id=g.account["user_id"],
status=1).update({
"cover": image_model.image_id,
"cover_type": 1,
})
social_page = SocialPageModel.query_social_page_model(
g.account["user_id"], auto_format=False)
if not social_page:
social_page = SocialPageModel()
social_page.user_id = g.account["user_id"]
social_page.cover = image_model.image_id
social_page.cover_type = 1
db.session.add(social_page)
else:
social_page.cover = image_model.image_id
social_page.cover_type = 1
db.session.commit()
@staticmethod
def change_cover_video(params):
pass
