${__pops.config.iconSVG.edit}
${__pops.config.iconSVG.delete}
`
)
});
Reflect.set($ruleItem, "data-rule", data);
let switchCheckedClassName = "pops-panel-switch-is-checked";
const {
$enable,
$enableSwitch,
$enableSwitchCore,
$enableSwitchInput,
$delete,
$edit
} = this.parseRuleItemElement($ruleItem);
if (this.option.itemControls.enable.enable) {
domUtils.on($enableSwitchCore, "click", async (event) => {
let isChecked = false;
if ($enableSwitch.classList.contains(switchCheckedClassName)) {
$enableSwitch.classList.remove(switchCheckedClassName);
isChecked = false;
} else {
$enableSwitch.classList.add(switchCheckedClassName);
isChecked = true;
}
$enableSwitchInput.checked = isChecked;
await this.option.itemControls.enable.callback(data, isChecked);
});
if (await this.option.itemControls.enable.getEnable(data)) {
$enableSwitch.classList.add(switchCheckedClassName);
}
} else {
$enable.remove();
}
if (this.option.itemControls.edit.enable) {
domUtils.on($edit, "click", (event) => {
utils.preventEvent(event);
this.showEditView(true, data, $shadowRoot, $ruleItem, (newData) => {
data = null;
data = newData;
});
});
} else {
$edit.remove();
}
if (this.option.itemControls.delete.enable) {
domUtils.on($delete, "click", (event) => {
utils.preventEvent(event);
let $askDialog = __pops.confirm({
title: {
text: "提示",
position: "center"
},
content: {
text: "确定删除该条数据？",
html: false
},
btn: {
ok: {
enable: true,
callback: async (popsEvent) => {
log.success("删除数据");
let flag = await this.option.itemControls.delete.deleteCallBack(
data
);
if (flag) {
Qmsg.success("成功删除该数据");
$ruleItem.remove();
await this.updateDeleteAllBtnText($shadowRoot);
$askDialog.close();
} else {
Qmsg.error("删除该数据失败");
}
}
},
cancel: {
text: "取消",
enable: true
}
},
mask: {
enable: true
},
width: "300px",
height: "200px"
});
});
} else {
$delete.remove();
}
return $ruleItem;
}
/**
* 添加一个规则元素
*/
async appendRuleItemElement($shadowRoot, data) {
let { $container } = this.parseViewElement($shadowRoot);
let $ruleItem = [];
let iteratorData = Array.isArray(data) ? data : [data];
for (let index = 0; index < iteratorData.length; index++) {
let item = iteratorData[index];
let $item = await this.createRuleItemElement(item, $shadowRoot);
$container.appendChild($item);
$ruleItem.push($item);
}
await this.updateDeleteAllBtnText($shadowRoot);
return $ruleItem;
}
/**
* 更新弹窗内容的元素
*/
async updateRuleContaienrElement($shadowRoot) {
this.clearContent($shadowRoot);
const { $container } = this.parseViewElement($shadowRoot);
let data = await this.option.data();
await this.appendRuleItemElement($shadowRoot, data);
await this.updateDeleteAllBtnText($shadowRoot);
}
/**
* 更新规则元素
*/
async updateRuleItemElement(data, $oldRuleItem, $shadowRoot) {
let $newRuleItem = await this.createRuleItemElement(data, $shadowRoot);
$oldRuleItem.after($newRuleItem);
$oldRuleItem.remove();
}
/**
* 清空内容
*/
clearContent($shadowRoot) {
const { $container } = this.parseViewElement($shadowRoot);
domUtils.html($container, "");
}
/**
* 设置删除按钮的文字
*/
setDeleteBtnText($shadowRoot, text, isHTML = false) {
const { $deleteBtn } = this.parseViewElement($shadowRoot);
if (isHTML) {
domUtils.html($deleteBtn, text);
} else {
domUtils.text($deleteBtn, text);
}
}
/**
* 更新【清空所有】的按钮的文字
* @param $shadowRoot
*/
async updateDeleteAllBtnText($shadowRoot) {
let data = await this.option.data();
this.setDeleteBtnText($shadowRoot, `清空所有(${data.length})`);
}
}
const XHSNetworkHook = {
__ajaxHooker: null,
get ajaxHooker() {
if (this.__ajaxHooker == null) {
this.__ajaxHooker = utils.ajaxHooker();
}
return this.__ajaxHooker;
}
};
class XHSArticleFilterBase {
/**
* 解析信息转为规则过滤的字典
* @param info 数据信息
* @param showLog 是否显示日志输出
*/
parseInfoDictData(info, showLog = false) {
let note_card = info?.note_card;
let articleId = info.id;
let display_title = note_card.display_title;
let isLike = Boolean(note_card?.interact_info?.liked);
let liked_count = 0;
let liked_count_str = info?.note_card?.interact_info?.liked_count;
if (typeof liked_count_str === "string") {
liked_count = parseInt(liked_count_str);
if (isNaN(liked_count)) {
liked_count = 0;
}
}
let nick_name = note_card?.user?.nick_name || note_card?.user?.nickname;
let user_id = note_card?.user?.user_id;
let isVideo = note_card?.type === "video";
let videoDuration = note_card?.video?.capa?.duration || 0;
return {
articleId,
display_title,
isLike,
liked_count,
nick_name,
user_id,
isVideo,
videoDuration
};
}
/**
* 根据视频信息，判断是否需要屏蔽
*/
checkFilterWithRule(details) {
if (details.infoValue == null) {
return false;
}
if (details.ruleValue == null) {
return false;
}
if (typeof details.infoValue === "string") {
if (Boolean(details.infoValue.match(details.ruleValue))) {
return true;
}
} else if (typeof details.infoValue === "object") {
if (Array.isArray(details.infoValue)) {
let findValue = details.infoValue.find((infoDictValue) => {
if (typeof infoDictValue === "string" && details.ruleValue != null) {
return Boolean(infoDictValue.match(details.ruleValue));
} else {
return false;
}
});
if (findValue) {
return true;
}
}
} else if (typeof details.infoValue === "number") {
if (typeof details.ruleValue === "string") {
let ruleValue = details.ruleValue.trim();
let compareNumberMatch = ruleValue.match(/(\d+)/);
if (!compareNumberMatch) {
log.warn("过滤器-解析比较大小的数字失败: ", details);
return false;
}
let compareNumber = Number(compareNumberMatch[1]);
if (ruleValue.startsWith(">")) {
if (ruleValue.startsWith(">=")) {
if (details.infoValue >= compareNumber) {
return true;
}
} else {
if (details.infoValue > compareNumber) {
return true;
}
}
} else if (ruleValue.startsWith("<")) {
if (ruleValue.startsWith("<=")) {
if (details.infoValue <= compareNumber) {
return true;
}
} else {
if (details.infoValue < compareNumber) {
return true;
}
}
} else if (ruleValue.startsWith("=")) {
if (details.infoValue === compareNumber) {
return true;
}
} else {
log.warn("视频过滤器-未经允许的比较符号: ", details);
return false;
}
}
} else if (typeof details.infoValue === "boolean") {
if (typeof details.ruleValue === "string") {
let trimRuleValue = details.ruleValue.trim();
return details.infoValue.toString() === trimRuleValue;
}
}
return false;
}
/**
* 检测视频是否可以屏蔽，可以屏蔽返回true
* @param rule 规则
* @param info 视频信息结构
*/
checkInfoIsFilter(rule, info) {
let transformInfo = this.parseInfoDictData(info);
let flag = false;
let matchedFilterOption = null;
outerLoop: for (let index = 0; index < rule.length; index++) {
const filterOption = rule[index];
const ruleNameList = Array.isArray(filterOption.data.ruleName) ? filterOption.data.ruleName : [filterOption.data.ruleName];
for (let ruleNameIndex = 0; ruleNameIndex < ruleNameList.length; ruleNameIndex++) {
const ruleName = ruleNameList[ruleNameIndex];
if (!Reflect.has(transformInfo, ruleName)) {
continue;
}
let tagKey = ruleName;
let tagValue = transformInfo[tagKey];
let details = {
infoKey: tagKey,
infoValue: tagValue,
ruleKey: filterOption.data.ruleName,
ruleValue: filterOption.data.ruleValue
};
flag = this.checkFilterWithRule(details);
if (flag) {
if (Array.isArray(filterOption.dynamicData) && filterOption.dynamicData.length) {
let dynamicDetailsList = [];
for (let dynamicIndex = 0; dynamicIndex < filterOption.dynamicData.length; dynamicIndex++) {
const dynamicOption = filterOption.dynamicData[dynamicIndex];
let dynamicTagKey = dynamicOption.ruleName;
let dynamicTagValue = transformInfo[dynamicTagKey];
let dynamicDetails = {
infoKey: dynamicTagKey,
infoValue: dynamicTagValue,
ruleKey: dynamicOption.ruleName,
ruleValue: dynamicOption.ruleValue
};
dynamicDetailsList.push(dynamicDetails);
let dynamicCheckFlag = this.checkFilterWithRule(dynamicDetails);
flag = flag && dynamicCheckFlag;
if (!flag) {
break;
}
}
if (flag) {
log.success([
`视频过滤器-多组 ==> ${filterOption.name}`,
transformInfo,
details,
dynamicDetailsList,
info,
filterOption
]);
}
} else {
log.success([
`视频过滤器 ==> ${filterOption.name}`,
transformInfo,
details,
info,
filterOption
]);
}
}
if (flag) {
matchedFilterOption = filterOption;
break outerLoop;
}
}
}
return {
/** 是否允许过滤 */
isFilter: flag,
/** 命中的过滤规则 */
matchedFilterOption,
/** 解析出的视频信息 */
transformInfo,
/** 原始视频信息 */
info
};
}
removeArticle(...args) {
if (args.length === 1) {
let $el = args[0];
if ($el != null && $el instanceof Element) {
$el.remove();
}
} else if (args.length === 2) {
let infoList = args[0];
let deleteIndex = args[1];
if (typeof deleteIndex === "number") {
let item = infoList[deleteIndex];
if (item != null && item instanceof Element) {
item.remove();
}
infoList.splice(deleteIndex, 1);
}
}
}
}
const XHSArticleFilter = {
$key: {
ENABLE_KEY: "shieldVideo-exec-network-enable"
},
$data: {
/** 已经过滤的信息 */
isFilterAwemeInfoList: new Utils.Dictionary(),
/**
* 网络接口的视频信息字典
*/
articleInfoMap: new Utils.Dictionary(),
__videoFilterRuleStorage: null,
get videoFilterRuleStorage() {
if (this.__videoFilterRuleStorage == null) {
this.__videoFilterRuleStorage = new RuleStorage(
{
STORAGE_API_KEY: "xhs-article-filter-rule"
}
);
}
return this.__videoFilterRuleStorage;
},
/**
* 当命中过滤规则，如果开启了仅显示被过滤的视频，则修改isFilter值
*/
get isReverse() {
return Panel.getValue(
"xhs-article-filter-only-show-filtered-video"
);
}
},
init() {
this.execFilter();
},
/**
* 执行过滤
*/
execFilter() {
Panel.execMenuOnce(this.$key.ENABLE_KEY, async () => {
log.info(`执行笔记过滤器`);
let filterBase = new XHSArticleFilterBase();
let checkFilterCallBack = (filterTransformInfoResult) => {
if (this.$data.isReverse) {
filterTransformInfoResult.isFilter = !filterTransformInfoResult.isFilter;
if (typeof filterTransformInfoResult.transformInfo.articleId === "string" && filterTransformInfoResult.matchedFilterOption) {
let filterOptionList = this.$data.isFilterAwemeInfoList.get(
filterTransformInfoResult.transformInfo.articleId
) || [];
filterOptionList.push(
filterTransformInfoResult.matchedFilterOption
);
this.$data.isFilterAwemeInfoList.set(
filterTransformInfoResult.transformInfo.articleId,
filterOptionList
);
}
}
if (typeof filterTransformInfoResult.transformInfo.articleId === "string") {
this.$data.articleInfoMap.set(
filterTransformInfoResult.transformInfo.articleId,
{
articleInfo: filterTransformInfoResult.info,
transformArticleInfo: filterTransformInfoResult.transformInfo
}
);
}
};
let queryScopeFilterOptionList = (scopeName) => {
if (!Panel.getValue(this.$key.ENABLE_KEY)) {
return [];
}
let filterOptionList = this.$data.videoFilterRuleStorage.getAllRule();
if (!filterOptionList.length) {
return [];
}
let scopeNameList = Array.isArray(scopeName) ? scopeName : [scopeName];
let matchedFilterOptionList = filterOptionList.filter(
(it) => it.enable && (it.data.scope.includes("all") || Array.from(scopeNameList).findIndex(
(item) => it.data.scope.includes(
item
)
) !== -1)
);
return matchedFilterOptionList;
};
let xhr_hook_callback_1 = (scopeName, request) => {
request.response = (response) => {
let filterOptionList = queryScopeFilterOptionList(scopeName);
if (!filterOptionList.length) {
return;
}
let data = utils.toJSON(response.responseText);
let items = data?.["data"]?.["items"];
if (Array.isArray(items)) {
for (let index = 0; index < items.length; index++) {
let awemeInfo = items[index] || {};
let filterResult = filterBase.checkInfoIsFilter(
filterOptionList,
awemeInfo
);
checkFilterCallBack(filterResult);
if (filterResult.isFilter) {
filterBase.removeArticle(items, index--);
}
}
response.responseText = JSON.stringify(data);
}
};
};
XHSNetworkHook.ajaxHooker.hook((request) => {
let url = CommonUtil.fixUrl(request.url);
let urlInst = new URL(url);
if (urlInst.pathname.startsWith("/api/sns/web/v1/homefeed")) {
xhr_hook_callback_1("xhr-explore", request);
}
});
});
},
/**
* 获取模板数据
*/
getTemplateData() {
return {
uuid: utils.generateUUID(),
enable: true,
name: "",
data: {
scope: [],
ruleName: "display_title",
ruleValue: "",
remarks: ""
},
dynamicData: []
};
},
/**
* 显示视图
*/
showView() {
let ruleView = this.getRuleViewInstance();
ruleView.showView();
},
/**
* 获取规则视图实例
*/
getRuleViewInstance() {
const that = this;
let panelHandlerComponents = __pops.config.PanelHandlerComponents();
function generateStorageApi(data) {
return {
get(key, defaultValue) {
return data[key] ?? defaultValue;
},
set(key, value) {
data[key] = value;
}
};
}
let ruleView = new RuleView({
title: "笔记过滤器",
data: () => {
return this.$data.videoFilterRuleStorage.getAllRule();
},
getAddData: () => {
return this.getTemplateData();
},
getDataItemName: (data) => {
return data["name"];
},
updateData: (data) => {
return this.$data.videoFilterRuleStorage.setRule(data);
},
deleteData: (data) => {
return this.$data.videoFilterRuleStorage.deleteRule(data);
},
getData: (data) => {
let allData = this.$data.videoFilterRuleStorage.getAllRule();
let findValue = allData.find((item) => item.uuid === data.uuid);
return findValue ?? data;
},
itemControls: {
enable: {
enable: true,
getEnable(data) {
return data.enable;
},
callback: (data, enable) => {
data.enable = enable;
this.$data.videoFilterRuleStorage.setRule(data);
}
},
edit: {
enable: true,
getView: (data, isEdit) => {
let $fragment = document.createDocumentFragment();
if (!isEdit) {
data = this.getTemplateData();
}
let enable_template = UISwitch("启用", "enable", true);
Reflect.set(
enable_template.props,
PROPS_STORAGE_API,
generateStorageApi(data)
);
let $enable = panelHandlerComponents.createSectionContainerItem_switch(
enable_template
);
let name_template = UIInput(
"规则名称",
"name",
"",
"",
void 0,
"必填"
);
Reflect.set(
name_template.props,
PROPS_STORAGE_API,
generateStorageApi(data)
);
let $name = panelHandlerComponents.createSectionContainerItem_input(
name_template
);
let scope_template = UISelectMultiple(
"作用域",
"scope",
[],
[
{
text: "所有",
value: "all"
},
{
text: "发现",
value: "xhr-explore"
}
].map((it) => {
let result = {
...it,
value: it.value
};
return result;
}),
void 0,
"选择需要在xxx上生效的作用域"
);
Reflect.set(
scope_template.props,
PROPS_STORAGE_API,
generateStorageApi(data.data)
);
let $scope = panelHandlerComponents.createSectionContainerItem_select_multiple_new(
scope_template
);
let keyNameHandlerInfo = [
"display_title",
"isLike",
"liked_count",
"nick_name",
"user_id",
"isVideo",
"videoDuration"
];
let getDynamicProp = (storageData) => {
let ruleNameDefaultValue = Array.isArray(storageData["ruleName"]) ? storageData["ruleName"] : [storageData["ruleName"]];
let ruleName_template = UISelectMultiple(
"属性名",
"ruleName",
ruleNameDefaultValue,
keyNameHandlerInfo.map((item) => {
return {
text: item,
value: item
};
}),
void 0,
"选择需要的属性名 "
);
Reflect.set(
ruleName_template.props,
PROPS_STORAGE_API,
generateStorageApi(storageData)
);
let $ruleName2 = panelHandlerComponents.createSectionContainerItem_select_multiple_new(
ruleName_template
);
let ruleValue_template = UITextArea(
"属性值",
"ruleValue",
"",
"如果是字符串，可正则，注意转义"
);
Reflect.set(
ruleValue_template.props,
PROPS_STORAGE_API,
generateStorageApi(storageData)
);
let $ruleValue2 = panelHandlerComponents.createSectionContainerItem_textarea(
ruleValue_template
);
let remarks_template = UITextArea(
"备注",
"remarks",
"",
""
);
Reflect.set(
remarks_template.props,
PROPS_STORAGE_API,
generateStorageApi(storageData)
);
let $remarks2 = panelHandlerComponents.createSectionContainerItem_textarea(
remarks_template
);
return {
$ruleName: $ruleName2,
$ruleValue: $ruleValue2,
$remarks: $remarks2
};
};
let $dynamicContainer = domUtils.createElement("div", {
className: "rule-form-ulist-dynamic",
innerHTML: (
/*html*/
`