def adm_get_posts():
page = int(request.argget.all('page', 1))
pre = int(request.argget.all('pre', 10))
sort = json_to_pyseq(request.argget.all('sort'))
status = request.argget.all('status', 'is_issued')
matching_rec = request.argget.all('matching_rec')
time_range = int(request.argget.all('time_range', 0))
keyword = request.argget.all('keyword', '').strip()
fields = json_to_pyseq(request.argget.all('fields'))
unwanted_fields = json_to_pyseq(request.argget.all('unwanted_fields'))
# 不能同时使用fields 和 unwanted_fields
temp_field = {}
if fields:
for f in fields:
temp_field[f] = 1
elif unwanted_fields:
for f in unwanted_fields:
temp_field[f] = 0
data = get_posts_pr(field=temp_field,
page=page,
pre=pre,
sort=sort,
status=status,
time_range=time_range,
matching_rec=matching_rec,
keyword=keyword,
is_admin=True)
return data
def get_user_msgs(is_admin=None):
"""
api获取消息
:return:
"""
data = {}
ctype = json_to_pyseq(
request.argget.all("type", ["notice", "private_letter"]))
label = json_to_pyseq(request.argget.all("label"))
pre = str_to_num(request.argget.all("pre", 10))
page = str_to_num(request.argget.all("page", 1))
status_update = request.argget.all("status_update")
# admin api才有效的参数
is_sys_msg = str_to_num(request.argget.all("is_sys_msg", 1))
keyword = request.argget.all("keyword", "")
q = {"type": {"$in": ctype}}
if not is_admin:
q["user_id"] = current_user.str_id
else:
if is_sys_msg:
q["is_sys_msg"] = True
else:
q["is_sys_msg"] = False
if keyword:
keyword = {"$regex": keyword}
q["$or"] = [{
"title": keyword
}, {
"link": keyword
}, {
"content": keyword
}]
if label:
q["label"] = {"$in": label}
msgs = mdb_user.db.message.find(q)
data_cnt = msgs.count(True)
msgs = list(msgs.sort([("time", -1)]).skip(pre * (page - 1)).limit(pre))
ids = [msg["_id"] for msg in msgs]
data["msgs"] = objid_to_str(msgs)
data["msgs"] = datas_paging(pre=pre,
page_num=page,
data_cnt=data_cnt,
datas=data["msgs"])
if not is_admin:
# user_id为真,表示非管理端获取消息. 标记为已通知
q = {"user_id": current_user.str_id, "status": {"$ne": "have_read"}}
data["msgs"]["more"] = get_unread_num(q)
mdb_user.db.message.update_many(q, {"$set": {"status": "notified"}})
if status_update:
mdb_user.db.message.update_many({"_id": {
"$in": ids
}}, {"$set": {
"status": status_update
}})
return data
def get_posts():
page = str_to_num(request.argget.all('page', 1))
pre = str_to_num(request.argget.all('pre', get_config("post", "NUM_PAGE")))
sort = json_to_pyseq(request.argget.all('sort'))
status = request.argget.all('status', 'is_issued')
matching_rec = request.argget.all('matching_rec')
time_range = int(request.argget.all('time_range', 0))
keyword = request.argget.all('keyword', '').strip()
fields = json_to_pyseq(request.argget.all('fields'))
unwanted_fields = json_to_pyseq(request.argget.all('unwanted_fields'))
user_id = request.argget.all('user_id')
category_id = request.argget.all('category_id')
tag = request.argget.all('tag')
# 不能同时使用fields 和 unwanted_fields
temp_field = {}
if fields:
for f in fields:
temp_field[f] = 1
elif unwanted_fields:
for f in unwanted_fields:
temp_field[f] = 0
other_filter = {}
if user_id:
# 获取指定用户的post
other_filter["user_id"] = user_id
# 如果category_id为None， 则获取全部分类文章
if category_id:
try:
ObjectId(category_id)
# 指定分类
other_filter["category"] = category_id
except BaseException:
# 默认文集
other_filter["category"] = None
if tag:
other_filter["tags"] = tag
data = get_posts_pr(page=page,
field=temp_field,
pre=pre,
sort=sort,
status=status,
time_range=time_range,
matching_rec=matching_rec,
keyword=keyword,
other_filter=other_filter)
return data
def get(self, key, db_type=None):
'''
获取一个cache
:param key:
:param db_type: 不使用系统设置的db type时指定类型mongodb或redis
:return:default:获取不到时返回
'''
key = "{}{}".format(self.config['CACHE_KEY_PREFIX'], key)
if not db_type:
if self.config["CACHE_TYPE"] == "redis":
value = self.redis.get(key)
if value:
value = json_to_pyseq(value.decode("utf-8"))
return value
# 防止value为None时, 所以查询不到缓存时, 使用cache空类
return self.cache_none
else:
value = self.mdb_coll.find_one({"key": key}, {"_id": 0})
if value and value["expiration"] < time.time():
# 已过期
self.delete(key, db_type=db_type)
return self.cache_none
elif value:
return value["value"]
# 防止value为None时, 所以查询不到缓存时, 使用cache空类
return self.cache_none
else:
if db_type == "redis":
value = self.redis.get(key)
if value:
value = json_to_pyseq(value.decode("utf-8"))
return value
# 防止value为None时, 所以查询不到缓存时, 使用cache空类
return self.cache_none
elif db_type == "mongodb":
value = self.mdb_coll.find_one({"key": key}, {"_id": 0})
if value and value["expiration"] < time.time():
# 已过期
self.delete(key, db_type=db_type)
return self.cache_none
elif value:
return value["value"]
# 防止value为None时, 所以查询不到缓存时, 使用cache空类
return self.cache_none
def sign_in():
username = request.argget.all('username', '').strip()
password = request.argget.all('password', '').strip()
code = request.argget.all('code', '').strip()
code_url_obj = json_to_pyseq(request.argget.all('code_url_obj', {}))
remember_me = request.argget.all('remember_me', 0)
use_jwt_auth = str_to_num(request.argget.all('use_jwt_auth', 0))
try:
remember_me = int(remember_me)
except BaseException:
data = {
"d_msg": gettext("remember_me requires an integer"),
"d_msg_type": "e",
"custom_status": 400
}
return data
data = p_sign_in(username=username,
password=password,
code_url_obj=code_url_obj,
code=code,
remember_me=remember_me,
use_jwt_auth=use_jwt_auth)
return data
def del_goods():
'''
删除
:return:
'''
ids = json_to_pyseq(request.argget.all('ids'))
s, r = arg_verify([(gettext("ids"), ids)], required=True)
if not s:
return r
user_id = current_user.str_id
obj_ids = []
for id in ids:
obj_ids.append(ObjectId(id))
r = mdb_web.dbs["plug_warehouse_goods"].delete_many({
"_id": {
"$in": obj_ids
},
"user_id": user_id
})
if r.deleted_count:
data = {
"msg":
gettext("Successfully deleted {} goods").format(r.deleted_count),
"msg_type": "s",
"http_status": 204
}
else:
data = {
"msg": gettext("Failed to delete"),
"msg_type": "w",
"http_status": 400
}
return data
def unfollow():
'''
取消关注
:return:
'''
ids = json_to_pyseq(request.argget.all("ids", []))
s, r = arg_verify(reqargs=[("id", ids)], required=True)
if not s:
return r
for id in ids[:]:
if mdb_user.db.user_follow.find_one({"user_id":current_user.str_id, "type": "account", "follow":id}):
# 更新粉丝统计
update_one_user(user_id=str(id), updata={"$inc": {"fans_num": -1}})
else:
ids.remove(id)
delete_user_info_cache(user_id=id)
r = mdb_user.db.user_follow.update_one({"user_id":current_user.str_id, "type": "account"},
{"$pullAll": {"follow": ids}})
if r.modified_count:
# 更新关注统计
update_one_user(user_id=current_user.str_id,
updata={"$inc": {"follow_user_num": -len(ids)}})
delete_user_info_cache(user_id=current_user.str_id)
data = {"msg": gettext("Unfollow success"), "msg_type": "s", "http_status": 201}
else:
delete_user_info_cache(user_id=current_user.str_id)
data = {"msg": gettext("Unfollow failed"), "msg_type": "w", "http_status": 400}
return data
def category_delete(user_id=None):
if user_id == None:
user_id = current_user.str_id
ids = json_to_pyseq(request.argget.all('ids', []))
if not isinstance(ids, list):
ids = json.loads(ids)
for i in range(0, len(ids)):
ids[i] = ObjectId(ids[i])
r = mdb_web.db.category.delete_many({
"_id": {
"$in": ids
},
"user_id": user_id
})
if r.deleted_count > 0:
data = {
"msg": gettext("Delete the success,{}").format(r.deleted_count),
"msg_type": "s",
"http_status": 204
}
else:
data = {
"msg": gettext("Delete failed"),
"msg_type": "w",
"http_status": 400
}
return data
def adm_post_restore():
ids = json_to_pyseq(request.argget.all('ids', []))
for i, tid in enumerate(ids):
ids[i] = ObjectId(tid)
r = mdb_web.db.post.update_many({
"_id": {
"$in": ids
},
"is_delete": 3
}, {"$set": {
"is_delete": 0
}})
if r.modified_count:
data = {
"msg": gettext("Restore success, {}").format(r.modified_count),
"msg_type": "s",
"http_status": 201
}
else:
data = {
"msg": gettext("No match to relevant data"),
"msg_type": "w",
"http_status": 400
}
return data
def post_restore():
ids = json_to_pyseq(request.argget.all('ids', []))
if not isinstance(ids, list):
ids = json.loads(ids)
for i, tid in enumerate(ids):
ids[i] = ObjectId(tid)
r = mdbs["web"].db.post.update_one(
{
"_id": {
"$in": ids
},
"user_id": current_user.str_id,
"is_delete": 1
}, {"$set": {
"is_delete": 0
}})
if r.modified_count:
data = {
"msg": gettext("Restore success,{}").format(r.modified_count),
"msg_type": "s",
"custom_status": 201
}
else:
data = {
"msg": gettext("Restore failed"),
"msg_type": "w",
"custom_status": 400
}
return data
def get_tags():
"""
根据条件获取post tags
:return:
"""
last_days = str_to_num(request.argget.all('last_days', 360))
user_id = request.argget.all('user_id')
tlimit = str_to_num(request.argget.all('limit', 20))
tsort = json_to_pyseq(request.argget.all('sort', [{"tag_cnt": -1},
{"like": -1},
{"comment_num": -1}]))
# sort
sort = {}
for s in tsort:
sort = dict(sort, **s)
# 查看是否存在缓存
cache_key = cache.get_autokey(
fun="_get_tags",
key_base64=False,
db_type="redis",
user_id=user_id,
last_days=last_days,
tlimit=tlimit,
sort=sort)
data = cache.get(key=cache_key, db_type="redis")
if data != cache.cache_none:
return data
else:
# 调用生成缓存程序生成新缓存
async_get_tags(user_id, last_days, tlimit, sort)
# 然后返回最后一次的长期缓存
data = cache.get(key="LAST_POST_TAGS_CACHE", db_type="mongodb")
return data
def user_restore():
ids = json_to_pyseq(request.argget.all('ids', []))
noper = 0
re_ids = []
for i in range(0, len(ids)):
# 检查是否有权限
current_user_role = mdb_user.db.role.find_one({"_id": ObjectId(current_user.role_id)})
re_user = mdb_user.db.user.find_one({"_id": ObjectId(ids[i])}, {"role_id": 1})
re_user_role = mdb_user.db.role.find_one({"_id": ObjectId(re_user["role_id"])})
if get_num_digits(current_user_role["permissions"]) <= get_num_digits(re_user_role["permissions"]):
# 没有权限恢复
noper += 1
continue
re_ids.append(ObjectId(ids[i]))
update_data = {
'is_delete': 0
}
r = mdb_user.db.user.update_many({"_id": {"$in": re_ids}}, {"$set": update_data})
if r.modified_count:
data = {'msg': gettext(
"Restore the {} users,The other {} users have no power control".format(r.modified_count, noper)),
'msg_type': "s", "http_status":201}
else:
data = {'msg': gettext("Restore the failure.May not have permission"), 'msg_type': "w", "http_status":401}
return data
def follow_user():
"""
关注一个用户
:return:
"""
ids = json_to_pyseq(request.argget.all("ids", []))
s, r = arg_verify(reqargs=[("id", ids)], required=True)
if not s:
return r
cnt = 0
for tid in ids[:]:
if tid != current_user.str_id and get_one_user(user_id=str(tid)):
r = mdb_user.db.user_follow.update_one(
{
"user_id": current_user.str_id,
"type": "account"
}, {"$addToSet": {
"follow": tid
}},
upsert=True)
if r.modified_count or r.upserted_id:
cnt += 1
# 更新粉丝统计
update_one_user(user_id=str(tid),
updata={"$inc": {
"fans_num": 1
}})
delete_user_info_cache(user_id=tid)
if cnt:
# 更新关注统计
update_one_user(user_id=current_user.str_id,
updata={"$inc": {
"follow_user_num": cnt
}})
delete_user_info_cache(user_id=current_user.str_id)
data = {
"msg": gettext("Followed"),
"msg_type": "s",
"http_status": 201
}
elif len(ids) == 1 and ids[0] == current_user.str_id:
data = {
"msg": gettext("You can't follow yourself"),
"msg_type": "w",
"http_status": 400
}
else:
data = {
"msg": gettext("You are already following this user"),
"msg_type": "w",
"http_status": 400
}
return data
def get(self, key, db_type=None):
"""
获取一个cache
:param key:
:param db_type: 不使用系统设置的db type时指定类型mongodb或redis
:return:default:获取不到时返回
"""
key = "{}{}".format(self.config['CACHE_KEY_PREFIX'], key)
if (db_type == "redis" or (not db_type and self.config["CACHE_TYPE"] == "redis")) \
and not self.redis_exists_exception:
value = self.redis.get(key)
if value:
value = value.decode("utf-8")
if value == self.cache_none_obj.value:
return None
value = json_to_pyseq(value)
return value
# 防止value为None所以查询不到缓存时, 使用cache空类
return self.cache_none
elif db_type == "mongodb" or (not db_type and self.config["CACHE_TYPE"] == "mongodb") \
or self.redis_exists_exception:
value = self.mdb_coll.find_one({"key": key}, {"_id": 0})
if value and value["expiration"] < time.time():
# 已过期
self.delete(key, db_type=db_type)
return self.cache_none
elif value:
return value["value"]
# 防止value为None时, 所以查询不到缓存时, 使用cache空类
return self.cache_none
def get_medias(user_id=None):
"""
:param user_id: 媒体为管理端(系统)所有时需要传入user_id = 0
:return:
"""
if user_id is None:
user_id = current_user.str_id
keyword = request.argget.all("keyword")
category_id = request.argget.all("category_id")
ctype = request.argget.all("ctype")
page = str_to_num(request.argget.all("page", 1))
pre = str_to_num(request.argget.all("pre", 12))
sort = json_to_pyseq(request.argget.all('sort'))
s, r = arg_verify([(gettext("type"), ctype)],
only=get_config("category", "CATEGORY_TYPE").values())
if not s:
return r
data = {}
if category_id:
if category_id == "default":
category_id = {"$in": [None, ""]}
query = {"category_id": category_id, "type": ctype}
else:
query = {"type": ctype}
if keyword:
k_rule = {"$regex": keyword, "$options": "$i"}
query["$or"] = [{
"name": k_rule
}, {
"title": k_rule
}, {
"link": k_rule
}, {
"text": k_rule
}]
query["user_id"] = user_id
# sort
if sort:
for i, srt in enumerate(sort):
sort[i] = (list(srt.keys())[0], list(srt.values())[0])
else:
sort = [("time", -1)]
medias = mdb_web.db.media.find(query)
data_cnt = medias.count(True)
medias = list(medias.sort(sort).skip(pre * (page - 1)).limit(pre))
for d in medias:
d["_id"] = str(d["_id"])
if "url" in d and d["url"]:
d["url"] = get_file_url(d["url"])
data["medias"] = datas_paging(pre=pre,
page_num=page,
data_cnt=data_cnt,
datas=medias)
return data
def api_basic_report():
'''
GET:
获取网站的最基本报表数据
project:<array>,默认全部,可以是post, comment, user, message, plugin, media, inform
'''
project = json_to_pyseq(request.argget.all('project', []))
data = {}
if "post" in project or not project:
data["post"] = get_post_access()
if "comment" in project or not project:
data["comment"] = get_comment_access()
if "user" in project or not project:
data["user"] = get_user_access()
if "message" in project or not project:
data["message"] = get_message()
if "plugin" in project or not project:
data["plugin"] = get_plugin()
if "media" in project or not project:
data["media"] = get_media()
if "inform" in project or not project:
data["inform"] = get_inform_data()
return response_format(data)
def user_del():
ids = json_to_pyseq(request.argget.all('ids', []))
permanent = request.argget.all('permanent', 0)
try:
permanent = int(permanent)
except BaseException:
pass
noper = 0
temp_ids = ids[:]
ids = []
for tid in temp_ids:
# 检查是否有权限
current_user_role = mdbs["user"].db.role.find_one({"_id": ObjectId(current_user.role_id)})
rm_user = get_one_user(user_id=str(tid))
rm_user_role = mdbs["user"].db.role.find_one({"_id": ObjectId(rm_user["role_id"])})
if get_num_digits(current_user_role["permissions"]) <= get_num_digits(rm_user_role["permissions"]):
# 没有权限删除
continue
ids.append(ObjectId(tid))
if not permanent:
update_data = {
'is_delete': 1
}
r = mdbs["user"].db.user.update_many(
{"_id": {"$in": ids}}, {"$set": update_data})
if r.modified_count:
for uid in ids:
clean_get_one_user_cache(user_id=uid)
data = {
'msg': gettext("Has recovered {} users, {} users can not operate").format(
r.modified_count,
noper),
'msg_type': "s",
"custom_status": 201}
else:
data = {
'msg': gettext("Recycle user failed.May not have permission"),
'msg_type': "w",
"custom_status": 401}
else:
# 永久删除
r = mdbs["user"].db.user.delete_many(
{"_id": {"$in": ids}, "is_delete": {"$in": [1, True]}})
if r.deleted_count:
data = {
'msg': gettext(
"{} users have been deleted and {} users can not be deleted".format(
r.deleted_count,
noper)),
'msg_type': "s",
"custom_status": 204}
else:
data = {
'msg': gettext("Failed to delete.May not have permission"),
'msg_type': "w",
"custom_status": 401}
return data
def user_activation():
active = int(request.argget.all('active', 0))
ids = json_to_pyseq(request.argget.all('ids', []))
noper = 0
ac_ids = []
for i in range(0, len(ids)):
# 检查是否有权限
current_user_role = mdb_user.db.role.find_one({"_id": ObjectId(current_user.role_id)})
re_user = mdb_user.db.user.find_one({"_id": ObjectId(ids[i])}, {"role_id": 1})
re_user_role = mdb_user.db.role.find_one({"_id": ObjectId(re_user["role_id"])})
if get_num_digits(current_user_role["permissions"]) <= get_num_digits(re_user_role["permissions"]):
# 没有权限恢复
noper += 1
continue
ac_ids.append(ObjectId(ids[i]))
update_data = {
'active': active
}
r = mdb_user.db.user.update_many({"_id": {"$in": ac_ids}}, {"$set": update_data})
if r.modified_count:
data = {'msg': gettext(
"{} user activation is successful, {} no permission to operate".format(r.modified_count, noper)),
'msg_type': "s", "http_status":201}
else:
data = {'msg': gettext("Activation failed.May not have permission"), 'msg_type': "w", "http_status":401}
return data
def del_business():
'''
删除厂家
:return:
'''
ids = json_to_pyseq(request.argget.all('ids'))
s, r = arg_verify([(gettext("ids"), ids)], required=True)
if not s:
return r
user_id = current_user.str_id
obj_ids = []
faied_cnt = 0
for id in ids:
if mdb_web.dbs["plug_warehouse_goods"].find_one({"business_id":id, "user_id":user_id}):
faied_cnt += 1
continue
obj_ids.append(ObjectId(id))
r = mdb_web.dbs["plug_warehouse_business"].delete_many({"_id": {"$in": obj_ids}, "user_id":user_id})
if r.deleted_count:
data = {"msg": gettext("Successfully deleted {} business").format(r.deleted_count), "msg_type": "s",
"http_status": 204}
else:
data = {"msg": gettext("Failed to delete"), "msg_type": "w", "http_status": 400}
if faied_cnt:
data["msg"] = gettext("There are {} business below the goods, can not be deleted, can not be deleted").format(faied_cnt)
return data
def update_user_msgs():
"""
api更新消息
:return:
"""
ids = json_to_pyseq(request.argget.all("ids", []))
status_update = request.argget.all("status_update")
if status_update:
s, r = arg_verify(reqargs=[("status_update", status_update)],
only=["have_read"])
if not s:
return r
for i, tid in enumerate(ids):
ids[i] = ObjectId(tid)
# 标记
r = mdb_user.db.message.update_many({"_id": {
"$in": ids
}}, {"$set": {
"status": status_update
}})
if r.modified_count:
data = {
'msg': gettext("Update succeed"),
'msg_type': "s",
"http_status": 201
}
else:
data = {
'msg': gettext("No changes"),
'msg_type': "w",
"http_status": 201
}
return data
def del_navs():
ids = json_to_pyseq(request.argget.all("ids"))
s, r = arg_verify([(gettext("ids"), ids)], required=True)
if not s:
return r
del_ids = []
for id in ids:
del_ids.append(ObjectId(id))
r = mdbs["sys"].dbs["theme_nav_setting"].delete_many(
{"_id": {
"$in": del_ids
}})
if r.deleted_count:
data = {
"msg": gettext("Deleted successfully"),
"msg_type": "s",
"custom_status": 200
}
else:
data = {
"msg": gettext("Delete failed"),
"msg_type": "s",
"custom_status": 200
}
cache.delete_autokey(fun="get_global_theme_navs",
theme_name=".*",
lang=".*",
db_type="redis",
key_regex=True)
return data
def delete_sys_message():
'''
删除已发送邮件
:return:
'''
ids = json_to_pyseq(request.argget.all("ids", []))
for i in range(0, len(ids)):
ids[i] = ObjectId(ids[i])
q = {"_id": {"$in": ids}}
r = mdb_sys.db.sys_message.delete_many(q)
if r.deleted_count:
data = {
"msg": gettext("Successfully deleted"),
"msg_type": "s",
"http_status": 204
}
else:
data = {
"msg": gettext("Failed to delete"),
"msg_type": "w",
"http_status": 400
}
return data
def adm_post_delete():
ids = json_to_pyseq(request.argget.all('ids', []))
pending_delete = int(request.argget.all("pending_delete", 1))
for i, tid in enumerate(ids):
ids[i] = ObjectId(tid)
if pending_delete:
r = mdb_web.db.post.update_many({"_id": {
"$in": ids
}}, {"$set": {
"is_delete": 3
}})
if r.modified_count:
data = {
"msg":
gettext("Move to a permanently deleted area, {}").format(
r.modified_count),
"msg_type":
"s",
"http_status":
204
}
else:
data = {
"msg": gettext("No match to relevant data"),
"msg_type": "w",
"http_status": 400
}
else:
data = delete_post(ids=ids)
return data
def delete(self, key=None):
"""
删除当前的session中的key
:return:
"""
if self.config["SESSION_TYPE"] == "redis":
if key:
temp_value = self.redis.get(self.sid)
if temp_value:
temp_value = json_to_pyseq(temp_value.decode())
if key and key in temp_value:
del temp_value[key]
self.redis.set(self.sid, temp_value)
else:
self.redis.delete(self.sid)
else:
if key:
se = self.mdb_coll.find_one({"id": self.sid})
if se and key in se:
del se[key]
self.mdb_coll.update_one({"_id": se["_id"]}, {"$set": se})
else:
self.mdb_coll.delete_one({"id": self.sid})
def delete_user_msgs(is_admin=None):
"""
删除消息
is_admin:为True 的话, 只能删除系统发出的消息
:return:
"""
ids = json_to_pyseq(request.argget.all("ids", []))
for i, tid in enumerate(ids):
ids[i] = ObjectId(tid)
q = {"_id": {"$in": ids}}
if not is_admin:
q["user_id"] = current_user.str_id
else:
q["is_sys_msg"] = True
r = mdb_user.db.message.delete_many(q)
if r.deleted_count:
data = {
"msg": gettext("Successfully deleted"),
"msg_type": "s",
"http_status": 204
}
else:
data = {
"msg": gettext("Failed to delete"),
"msg_type": "w",
"http_status": 400
}
return data
def delete_url():
"""
删除url, 值允许删除页面路由
:return:
"""
ids = json_to_pyseq(request.argget.all("ids", []))
for i, tid in enumerate(ids):
ids[i] = ObjectId(tid)
url_pers = list(mdbs["sys"].db.sys_urls.find(
{"_id": {"$in": ids}}, {"url": 1}))
r = mdbs["sys"].db.sys_urls.delete_many(
{"_id": {"$in": ids}, "create": "manual"})
if r.deleted_count:
# 清除缓存
for url_per in url_pers:
cache.delete_autokey(
fun="get_sys_url",
db_type="redis",
url=url_per['url'].rstrip("/"))
data = {
"msg": gettext("Successfully deleted"),
"msg_type": "s",
"custom_status": 204}
else:
data = {
"msg": gettext("Delete failed"),
"msg_type": "w",
"custom_status": 400}
return data
def comments():
target_id = request.argget.all('target_id')
target_type = request.argget.all('target_type', "post")
status = request.argget.all('status', "is_issued")
sort = json_to_pyseq(request.argget.all('sort'))
page = int(request.argget.all('page', 1))
pre = get_config("comment", "NUM_PAGE")
pre = int(request.argget.all('pre', pre))
basic_query = {
'issued':
1,
'is_delete':
0,
'type':
target_type,
"target_id":
target_id,
'$or': [{
'reply_id': {
'$exists': False
}
}, {
'reply_id': {
'$in': [None, ""]
}
}]
}
data = find_comments(query_conditions=basic_query,
page=page,
pre=pre,
sort=sort,
status=status)
return data
def category_delete(user_id=None):
if user_id is None:
user_id = current_user.str_id
ids = json_to_pyseq(request.argget.all('ids', []))
if not isinstance(ids, list):
ids = json.loads(ids)
for i, tid in enumerate(ids):
ids[i] = ObjectId(tid)
r = mdbs["web"].db.theme_category.delete_many({
"_id": {
"$in": ids
},
"user_id": user_id
})
if r.deleted_count > 0:
data = {
"msg": gettext("Delete the success,{}").format(r.deleted_count),
"msg_type": "s",
"custom_status": 204
}
else:
data = {
"msg": gettext("Delete failed"),
"msg_type": "w",
"custom_status": 400
}
# theme_name = get_config("theme", "CURRENT_THEME_NAME")
theme_name = g.get_config("theme", "CURRENT_THEME_NAME")
data["theme_name"] = theme_name
return data
def get(self, key=None, default=None):
"""
获取一个session
:param key:
:return:default:获取不到时返回
"""
if self.config["SESSION_TYPE"] == "redis":
temp_value = self.redis.get(self.sid)
if temp_value:
temp_value = json_to_pyseq(temp_value.decode())
if key and key in temp_value:
return temp_value[key]
elif key:
return None
else:
return temp_value
else:
query = {"id": self.sid}
if key:
query[key] = {"$exists": True}
value = self.mdb_coll.find_one(query, {key: 1})
if value:
return value[key]
else:
value = self.mdb_coll.find_one(query, {"_id": 0})
if value:
return value
return default
def adm_comment_delete():
ids = json_to_pyseq(request.argget.all('ids', []))
pending_delete = int(request.argget.all("pending_delete", 1))
for i, tid in enumerate(ids):
ids[i] = ObjectId(tid)
if pending_delete:
r = mdb_web.db.comment.update_many(
{"_id": {"$in": ids}}, {"$set": {"is_delete": 2}})
if r.modified_count:
data = {"msg": gettext("Move to a permanently deleted area, {}").format(
r.modified_count), "msg_type": "s", "http_status": 204}
else:
data = {
"msg": gettext("Does not match the data to be deleted"),
"msg_type": "w",
"http_status": 400}
else:
for tid in ids:
mdb_user.db.user_like.update_many({"type": "comment", "values": str(tid)},
{"$pull": {"values": str(tid)}})
r = mdb_web.db.comment.delete_many(
{"_id": {"$in": ids}, "is_delete": {"$in": [1, 2]}})
if r.deleted_count:
data = {"msg": gettext("Removed from the database, {}").format(
r.deleted_count), "msg_type": "s", "http_status": 204}
else:
data = {"msg": gettext("No match to relevant data"),
"msg_type": "w", "http_status": 400}
return data
