邀您一起看：ikuuu

海阔视界规则分享，当前分享的是：二级页面详情￥page_detail￥ikuuu@@{"data":"{\"associatedModelsMapForJoinTable\":{},\"associatedModelsMapWithFK\":{},\"associatedModelsMapWithoutFK\":{},\"fieldsToSetToDefault\":[],\"id\":0,\"last_chapter_rule\":\"\",\"listToClearAssociatedFK\":[],\"listToClearSelfFK\":[],\"pageList\":[{\"col_type\":\"long_text\",\"name\":\"测试执行云函数\",\"path\":\"test_run\",\"rule\":\"js:\\nlet {task,host} = MY_PARAMS;\\nconst {color, small} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\nconst {taskCall, taskRun,taskReq} = $.require(\\\"hiker://page/utils?rule=\\\"+MY_RULE.title);\\n// log('规则名:'+MY_RULE.title);\\nString.prototype.strip = function () { return this.replace(/(^\\\\s*)|(\\\\s*$)/g, \\\"\\\"); }\\nsetPageTitle(\\\"执行「\\\"+task.name+\\\"」\\\");\\naddListener('onClose', $.toString(()=>{\\n    clearVar(\\\"task_box.test_result\\\");\\n    clearVar(\\\"task_box.func_name\\\");\\n    clearVar(\\\"task_box.test_params\\\");\\n}));\\nlet d = [];\\nd.push({\\n    title: \\\"函数说明:\\\",\\n    desc:small(task.note),\\n    url: \\\"hiker://empty\\\",\\n    col_type: \\\"text_1\\\"\\n});\\nd.push({\\n    title: \\\"测试代码，点击复制\\\",\\n    desc:small('注意字符串参数必须双引号，不支持单引号\\\\n')+small(task.test_code),\\n    url: \\\"copy://\\\"+task.test_code,\\n    col_type: \\\"text_1\\\"\\n});\\nd.push({\\n    title: \\\"运行模式:\\\"+getVar('task_box.test_mode','call'),\\n    url: $(['call','run'],1).select(_ => {\\n        putVar('task_box.test_mode',input);\\n        if(input==='run'){\\n            clearVar(\\\"task_box.test_params\\\");\\n        }\\n        refreshPage(true);\\n        return \\\"toast://你选择了\\\"+input\\n    }),\\n    col_type: \\\"text_1\\\"\\n})\\nif(getVar('task_box.test_mode','call')==='call'){\\n    let match_func = ret = task.pycode.match(/.*?def.*?[\\\\S]\\\\(/g);\\n    let default_func = match_func&&match_func.length>0?match_func[0].split('def')[1].split('(')[0].strip():\\\"\\\";\\n    let default_parmas = task.test_code&&task.test_code.indexOf('=>')>-1?task.test_code.split('=>')[1].strip():task.test_code;\\n    if(getVar('task_box.test_mode')==='run'){\\n        default_parmas = '[]';\\n    }\\n    d.push({\\n        title: '函数名',\\n        desc: \\\"请输入欲调用的函数名\\\",\\n        extra: {\\n            onChange: \\\"putVar('task_box.func_name',input)\\\",\\n            titleVisible: true,\\n            defaultValue: getVar('task_box.func_name', '')||default_func||\\\"\\\"\\n        },\\n        url:$.toString(() => {\\n            var func_name = getVar('task_box.func_name');\\n            return 'toast://你输入的是:'+func_name;\\n        }),\\n        col_type: \\\"input\\\"\\n    })\\n\\n    d.push({\\n        desc: \\\"传参列表,[参数1,参数2,参数3,......]\\\",\\n        col_type: 'input',\\n        extra: {\\n            titleVisible: false,\\n            defaultValue: getVar('task_box.test_params', '')||default_parmas||\\\"[]\\\",\\n            type: \\\"textarea\\\",\\n            height:-1,\\n            onChange: 'putVar(\\\"task_box.test_params\\\",input)'\\n        }\\n    });\\n}\\nd.push({\\n    title: \\\"▶️执行\\\",\\n    col_type: \\\"text_center_1\\\",\\n    url: $(host+\\\"/hikerule/task/run/\\\"+task.id).lazyRule((task,taskReq) => {\\n        let call_params = [];\\n        String.prototype.strip = function () { return this.replace(/(^\\\\s*)|(\\\\s*$)/g, \\\"\\\"); }\\n        let test_mode = getVar('task_box.test_mode','call'), func_name=getVar('task_box.func_name'),test_params=getVar('task_box.test_params');\\n        try {\\n            call_params = JSON.parse(test_params||'[]');\\n        }\\n        catch (e) {\\n            return \\\"toast://参数格式错误，必须为[]列表形式\\\\n\\\" + test_params;\\n        }\\n        if(func_name&&task.pycode.indexOf(func_name)===-1){\\n            return \\\"toast://调用函数\\\"+func_name+\\\"错误\\\\n\\\" + \\\"没找到代码包含此函数\\\";\\n        }\\n        let real_params = JSON.stringify(call_params).strip();\\n        if(!(real_params.startsWith('[')&&real_params.endsWith(']'))){\\n            return \\\"toast://参数格式错误，可不填或者必须[开头,]结束\\\\n\\\" + JSON.stringify(call_params);\\n        }\\n        let result = taskReq(input,{mode:test_mode,func:func_name,params:call_params});\\n        log(result);\\n        if (result.status !== 0) {\\n            putVar('task_box.test_result',result.detail);\\n            refreshPage(true);\\n            return \\\"toast://\\\" + result.detail;\\n        }\\n        putVar('task_box.test_result',result.result||\\\"None\\\");\\n        refreshPage(true);\\n        return \\\"toast://执行完毕,结果为:\\\"+ result.result;\\n    },task,taskReq)\\n});\\nd.push({\\n    title:'运行结果',\\n    col_type:'text_1',\\n    url:'hiker://empty'\\n});\\nd.push({\\n    title:getVar('task_box.test_result',''),\\n    col_type:'long_text'\\n});\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"工具类函数\",\"path\":\"utils\",\"rule\":\"js:\\n    String.prototype.strip = function () { return this.replace(/(^\\\\s*)|(\\\\s*$)/g, \\\"\\\"); };\\nfunction task_req(task_api,task) { // 通用发送仓库post调用任务请求\\n    const {getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let houseFile = getFile||false;\\n    if(!houseFile){\\n        setItem('is_house_vip', 'false');\\n    }\\n    let house_data = houseFile();\\n    let result = request(task_api, {\\n        headers: {\\n            'content-type': 'application/json'\\n        },\\n        body: JSON.stringify({\\n            \\\"params\\\": {\\n                \\\"data\\\": {\\n                    \\\"type\\\": task.mode||'run',\\n                    \\\"func\\\": task.func||'',\\n                    \\\"params\\\": task.params||[]\\n                },\\n                \\\"auth\\\": {\\n                    \\\"name\\\": house_data.username||\\\"\\\",\\n                    \\\"password\\\": house_data.password||\\\"\\\"\\n                }\\n            }\\n        }),\\n        method: 'POST'\\n    });\\n    return JSON.parse(result).result;\\n}\\n\\nfunction task_upload(task){ // 通用任务发布新增及修改功能\\n    const {api,getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let houseFile = getFile||false;\\n    if(!houseFile){\\n        setItem('is_house_vip', 'false');\\n    }\\n    let api_url = api.host+'/hikerule/task/add';\\n    let house_data = houseFile();\\n    let result = request(api_url, {\\n        headers: {\\n            'content-type': 'application/json'\\n        },\\n        body: JSON.stringify({\\n            \\\"params\\\": {\\n                \\\"data\\\": {\\n                    \\\"name\\\": task.name,\\n                    \\\"pycode\\\": task.pycode,\\n                    \\\"note\\\": task.note,\\n                    \\\"test_code\\\": task.test_code,\\n                },\\n                \\\"auth\\\": {\\n                    \\\"name\\\": house_data.username||\\\"\\\",\\n                    \\\"password\\\": house_data.password||\\\"\\\"\\n                }\\n            }\\n        }),\\n        method: 'POST'\\n    });\\n    return JSON.parse(result).result;\\n}\\n\\nfunction task_call(id,func,params){\\n    const {api} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let task_api = api.host+'/hikerule/task/run/'+id;\\n    let task = {\\n        mode:'call',\\n        func:func,\\n        params:params||[]\\n    };\\n    return task_req(task_api,task);\\n}\\n\\nfunction task_rename(id,new_task_name){\\n    const {api,getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let houseFile = getFile||false;\\n    if(!houseFile){\\n        setItem('is_house_vip', 'false');\\n    }\\n    let house_data = houseFile();\\n    let task_api = api.host+'/hikerule/task/rename/'+id;\\n    task_api = task_api+'?name='+house_data.username+'&password='+house_data.password+'&task_name='+new_task_name;\\n    try {\\n        let result = JSON.parse(fetch(task_api,{}));\\n        if(result.status==0){\\n            return  result.detail\\n        }else{\\n            return result.result+''+result.detail\\n        }\\n    }catch (e) {\\n        log(e.message);\\n        return ''+e.message\\n    }\\n}\\n\\nfunction task_change_state(id){\\n    const {api,getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let houseFile = getFile||false;\\n    if(!houseFile){\\n        setItem('is_house_vip', 'false');\\n    }\\n    let house_data = houseFile();\\n    let task_api = api.host+'/hikerule/task/change_state/'+id;\\n    task_api = task_api+'?name='+house_data.username+'&password='+house_data.password;\\n    try {\\n        let result = JSON.parse(fetch(task_api,{}));\\n        if(result.status==0){\\n            return  result.detail\\n        }else{\\n            return result.result+''+result.detail\\n        }\\n    }catch (e) {\\n        log(e.message);\\n        return ''+e.message\\n    }\\n}\\n\\nfunction task_change_visible(id){\\n    const {api,getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let houseFile = getFile||false;\\n    if(!houseFile){\\n        setItem('is_house_vip', 'false');\\n    }\\n    let house_data = houseFile();\\n    let task_api = api.host+'/hikerule/task/change_visible/'+id;\\n    task_api = task_api+'?name='+house_data.username+'&password='+house_data.password;\\n    try {\\n        let result = JSON.parse(fetch(task_api,{}));\\n        if(result.status===0){\\n            return  result.detail\\n        }else{\\n            return result.result+''+result.detail\\n        }\\n    }catch (e) {\\n        log(e.message);\\n        return ''+e.message\\n    }\\n}\\n\\nfunction task_run(id){\\n    const {api} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\n    let task_api = api.host+'/hikerule/task/run/'+id;\\n    let task = {};\\n    return task_req(task_api,task);\\n}\\n\\n$.exports.taskCall = task_call;\\n$.exports.taskRun = task_run;\\n$.exports.taskReq = task_req;\\n$.exports.taskUpload = task_upload;\\n$.exports.taskRename = task_rename;\\n$.exports.taskChangeState = task_change_state;\\n$.exports.taskChangeVisible = task_change_visible;\"},{\"name\":\"任务管理发布\",\"path\":\"publish_task\",\"rule\":\"js:\\nlet {host,house_data} = MY_PARAMS;\\nsetPageTitle(\\\"任务管理「\\\"+house_data.username+\\\"」\\\");\\nlet d = [];\\nd.push({\\n    title:'🗒新建/更新✏',\\n    col_type:'flex_button',\\n    url:'hiker://page/new_task#noHistory#',\\n});\\n\\nlet url = host+'/hikerule/task/get_by_dev?name='+house_data.username+'&password='+house_data.password;\\ntry {\\n    let result = JSON.parse(fetch(url,{}));\\n    d.push({\\n        title:result.detail,\\n        col_type:'text_center_1',\\n        url:'hiker://empty',\\n    });\\n\\n    if(result.status===0){\\n        let tasks = result.result;\\n        for(var task of tasks){\\n            d.push({\\n                title:'🐉'+task.name+'(id:'+task.id+')',\\n                col_type:'text_2',\\n                url:'hiker://page/task_info#noHistory#',\\n                extra:{url:host+'/hikerule/task/get_info/'+task.id+'?name='+house_data.username+'&password='+house_data.password,\\n                can_update:true,can_delete:true,\\n                },\\n            });\\n        }\\n    }\\n}catch (e) {\\n    log(e.message);\\n}\\nsetResult(d);\"},{\"col_type\":\"movie_3\",\"name\":\"任务详情\",\"path\":\"task_info\",\"rule\":\"js:\\n    const {color, small,api,getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\nlet {url,can_update,can_delete} = MY_PARAMS;\\nlog(url);\\nfunction req(url,data) { // 通用发送仓库post请求\\n    let result = request(url, {\\n        headers: {\\n            'content-type': 'application/json'\\n        },\\n        body: JSON.stringify(data),\\n        method: 'POST'\\n    });\\n    return JSON.parse(result).result;\\n}\\nlet houseFile = getFile||false;\\nif(!houseFile){\\n    setItem('is_house_vip', 'false');\\n}\\nlet house_data = houseFile();\\n\\nlet res = {};\\nlet items = [];\\nlet back_code = fetch(url,{});\\nback_code = JSON.parse(back_code);\\nif(back_code.status===0){\\n    let task = back_code.result;\\n    let tips = can_delete?' (点击删除)':'';\\n    items.push(\\n        {\\n            title:task.name+tips,\\n            desc:'id:'+task.id+'  可视状态:'+task.visible+'\\\\n作者:'+task.dev_name+' 分享状态:'+task.state+'\\\\n更新时间'+task.publish_time,\\n            col_type:'movie_1_vertical_pic',\\n            pic_url:'https://api.mtyqx.cn/api/random.php?t='+Math.random(),\\n            url:!can_delete?'hiker://empty':$(\\\"确认删除?\\\").confirm((task,host,house_data)=>{\\n                let del_url = host+'/hikerule/task/delete/'+task.id+'?name='+house_data.username+'&password='+house_data.password;\\n                try {\\n                    let result = JSON.parse(fetch(del_url,{}));\\n                    if(result.status===0){\\n                        back(true);\\n                        return \\\"toast://\\\"+result.detail;\\n                    }\\n                }catch (e) {\\n                    return \\\"toast://出错了:\\\\n\\\"+e.message;\\n                }\\n\\n            },task,api.host,house_data),\\n        }\\n    );\\n    let ruleCode = \\\"海阔视界本地文件分享￥file_url￥hiker://files/rules/dzHouse/python/\\\"+task.name+\\\".py@\\\"+MY_URL+\\\"&debug=1\\\";\\n    let importUrl = 'rule://' + base64Encode(ruleCode);\\n\\n    items.push(\\n        {\\n            title:'📥导入',\\n            col_type: 'flex_button',\\n            url:importUrl\\n        }\\n    );\\n\\n    items.push(\\n        {\\n            title:'📝本地编辑',\\n            col_type: 'flex_button',\\n            url:$().lazyRule((task) => {\\n                return 'editFile://hiker://files/rules/dzHouse/python/'+task.name+'.py';\\n            },task)\\n        }\\n    );\\n\\n    items.push(\\n        {\\n            title:'▶️测试执行',\\n            col_type: 'flex_button',\\n            url:\\\"hiker://page/test_run#noHistory#\\\",\\n            extra: {\\n                task:task,\\n                host:api.host,\\n                house_data:house_data\\n            }\\n        }\\n    );\\n\\n    if(can_update){\\n        items.push(\\n            {\\n                title:'▶重发布',\\n                col_type: 'flex_button',\\n                url:'hiker://page/new_task#noHistory#',\\n                extra: {\\n                    task:task,\\n                    // host:api.host,\\n                    // house_data:house_data\\n                }\\n            }\\n        );\\n        items.push(\\n            {\\n                title:'🍇任务改名',\\n                col_type: 'flex_button',\\n                url:$(task.name, \\\"输入新的任务名称\\\").input((task) => {\\n                    return $(\\\"确认将\\\"+task.name+\\\"修改为:\\\"+input+' ?').confirm((input,task)=>{\\n                        // log(task.id);\\n                        const {taskRename} = $.require(\\\"hiker://page/utils?rule=\\\"+MY_RULE.title);\\n                        let result = taskRename(task.id,input);\\n                        refreshPage(true);\\n                        // back(true);\\n                        return \\\"toast://\\\"+result;\\n                    },input,task);\\n                },task),\\n            }\\n        );\\n\\n        items.push(\\n            {\\n                title:'🍰更改分享状态',\\n                col_type: 'flex_button',\\n                url:$().lazyRule((task) => {\\n                    const {taskChangeState} = $.require(\\\"hiker://page/utils?rule=\\\"+MY_RULE.title);\\n                    let result = taskChangeState(task.id);\\n                    refreshPage(true);\\n                    return 'toast://'+result;\\n                },task),\\n            }\\n        );\\n\\n        items.push(\\n            {\\n                title:task.visible?'👀可视':'👀不可视',\\n                col_type: 'flex_button',\\n                url:$().lazyRule((task) => {\\n                    const {taskChangeVisible} = $.require(\\\"hiker://page/utils?rule=\\\"+MY_RULE.title);\\n                    let result = taskChangeVisible(task.id);\\n                    refreshPage(true);\\n                    return 'toast://'+result;\\n                },task),\\n            }\\n        );\\n    }\\n\\n    items.push(\\n        {\\n            title:'备注',\\n            desc:small(task.note),\\n            col_type: 'text_1',\\n            url:'toast://'+task.note\\n        }\\n    );\\n\\n    items.push({\\n        title:'✍python代码:',\\n        col_type:'text_1',\\n        url:'hiker://empty'\\n    })\\n\\n    items.push(\\n        {\\n            title:task.pycode,\\n            col_type:'long_text'\\n        }\\n    );\\n}\\nres.data = items;\\nsetHomeResult(res);\"},{\"name\":\"新建任务\",\"path\":\"new_task\",\"rule\":\"js:\\n\\nconst {taskUpload} = $.require(\\\"hiker://page/utils?rule=\\\"+MY_RULE.title);\\nlet {task} = MY_PARAMS;\\nif(!task){\\n    task = {}\\n}else{\\n    if(!getVar('task_box.new_task_name')){\\n        putVar('task_box.new_task_name',task.name);\\n    }\\n    if(!getVar('task_box.new_task_note')){\\n        putVar('task_box.new_task_note',task.note);\\n    }\\n    if(!getVar('task_box.new_task_pycode')){\\n        putVar('task_box.new_task_pycode',task.pycode);\\n    }\\n    if(!getVar('task_box.new_task_test_code')){\\n        putVar('task_box.new_task_test_code',task.test_code);\\n    }\\n}\\nString.prototype.strip = function () { return this.replace(/(^\\\\s*)|(\\\\s*$)/g, \\\"\\\"); }\\nsetPageTitle(\\\"新建任务\\\");\\naddListener('onClose', $.toString(()=>{\\n    // clearVar(\\\"task_box.new_task_name\\\");\\n    clearVar(\\\"task_box.new_task_note\\\");\\n    clearVar(\\\"task_box.new_task_pycode\\\");\\n    clearVar(\\\"task_box.new_task_test_code\\\");\\n}));\\nlet d = [];\\nd.push({\\n    title: '任务名称',\\n    desc: \\\"任务名称,如ikuuu签到\\\",\\n    extra: {\\n        onChange: \\\"putVar('task_box.new_task_name',input)\\\",\\n        titleVisible: true,\\n        defaultValue: getVar('task_box.new_task_name', '')||task.name||\\\"\\\"\\n    },\\n    url:$.toString(() => {\\n        let task_name = getVar('task_box.new_task_name');\\n        return 'toast://你输入的是:'+task_name;\\n    }),\\n    col_type: \\\"input\\\"\\n});\\nd.push({\\n    desc: \\\"备注\\\",\\n    col_type: 'input',\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getVar('task_box.new_task_note', '')||task.note||\\\"\\\",\\n        type: \\\"textarea\\\",\\n        height:-1,\\n        onChange: 'putVar(\\\"task_box.new_task_note\\\",input)'\\n    }\\n});\\nd.push({\\n    desc: \\\"测试代码\\\",\\n    col_type: 'input',\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getVar('task_box.new_task_test_code', '')||task.test_code||\\\"\\\",\\n        type: \\\"textarea\\\",\\n        height:-1,\\n        onChange: 'putVar(\\\"task_box.new_task_test_code\\\",input)'\\n    }\\n});\\nd.push({\\n    title:'py代码:📝本地编辑',\\n    col_type:'flex_button',\\n    url:$().lazyRule(() => {\\n        if(!getVar('task_box.new_task_name', '')){\\n            return 'toast://本地编辑必须先填写任务名称'\\n        }\\n        let filepath = 'hiker://files/rules/dzHouse/python/'+getVar('task_box.new_task_name', '')+'.py';\\n        if(!fileExist(filepath)){\\n            writeFile(filepath, '# python3\\\\n');\\n        }\\n        return 'editFile://'+filepath;\\n    })\\n});\\nd.push({\\n    title:'🔄刷新代码框',\\n    col_type:'flex_button',\\n    url:$().lazyRule(() => {\\n        if(!getVar('task_box.new_task_name', '')){\\n            return 'toast://刷新必须先填写任务名称'\\n        }\\n        let file_path = 'hiker://files/rules/dzHouse/python/'+getVar('task_box.new_task_name', '')+'.py';\\n        putVar('task_box.new_task_pycode',fetch(file_path));\\n        refreshPage(true);\\n        return 'toast://已刷新';\\n    })\\n});\\nd.push({\\n    title:'📲发布',\\n    col_type:'flex_button',\\n    url:$().lazyRule((taskUpload) => {\\n        if(!getVar('task_box.new_task_name', '')||!getVar('task_box.new_task_pycode', '')){\\n            return 'toast://发布任务必须保证任务名称及代码填写'\\n        }\\n        let task = {\\n            name:getVar('task_box.new_task_name', ''),\\n            pycode:getVar('task_box.new_task_pycode', ''),\\n            note:getVar('task_box.new_task_note', ''),\\n            test_code:getVar('task_box.new_task_test_code', ''),\\n        };\\n        let result = taskUpload(task);\\n        if(result.status===0){\\n            return 'toast://'+result.detail;\\n        }else{\\n            return 'toast://'+result.result+result.detail;\\n        }\\n    },taskUpload)\\n});\\n\\nd.push({\\n    desc: \\\"任务代码\\\",\\n    col_type: 'input',\\n    extra: {\\n        titleVisible: false,\\n        defaultValue: getVar('task_box.new_task_pycode', '')||task.pycode||\\\"\\\",\\n        type: \\\"textarea\\\",\\n        height:-1,\\n        onChange: 'putVar(\\\"task_box.new_task_pycode\\\",input)'\\n    }\\n});\\nsetResult(d);\"},{\"name\":\"emoji表情\",\"path\":\"emoji\",\"rule\":\"js:\\nlet d = [];\\nlet Data = [];\\nlet cate_urls = ['1','2'];\\nif(!getVar('now_emoji_url')){\\n    putVar('now_emoji_url','http://www.fhdq.net/emoji/8.html');\\n}\\nfor(var cate of cate_urls){\\n    Data.push({\\n        url: 'http://www.fhdq.net/emoji/list_'+cate+'.html',\\n        options: {\\n            headers: {\\n                \\\"User-Agent\\\": \\\"Dart/2.13 (dart:io)\\\"\\n            },\\n            timeout: 5000\\n        }\\n    });\\n}\\nvar bhtml = batchFetch(Data);\\nfor(var bth of bhtml){\\n    let emoji_cate = pdfa(bth,'.listbox&&li');\\n    // log(emoji_cate);\\n    for(let cate of emoji_cate){\\n        try {\\n            let title = pdfh(cate,'li&&Text');\\n            if(title.replace(/[\\\\s]/g,'').length>0){\\n                let url = 'http://www.fhdq.net'+pdfh(cate,'a&&href');\\n                let tips = getVar('now_emoji_url')===url?'✌':'';\\n                title = title.replace('emoji','')+tips;\\n                d.push(\\n                    {\\n                        title:title,\\n                        url:$().lazyRule((url,title) => {\\n                            putVar('now_emoji_url',url);\\n                            refreshPage(true);\\n                            return 'toast://当前emoji分类:'+title;\\n                        },url,title),\\n                        col_type:'scroll_button'\\n                    }\\n                );\\n            }\\n        }\\n        catch (e) {\\n\\n        }\\n    }\\n}\\n\\nlet html=fetch(getVar('now_emoji_url'));\\nlet emoji_list = pdfa(html,'.emojilistpc&&li');\\nfor(var emoji of emoji_list){\\n    let title = pdfh(emoji,'li&&Text');\\n    d.push({\\n        title:title,\\n        col_type:'flex_button',\\n        url:'copy://'+title\\n    });\\n}\\nsetResult(d);\"}],\"params\":\"{\\\"url\\\":\\\"http://hiker.nokia.press/hikerule/task/get_info/23?username=undefined&password=undefined\\\"}\",\"saved\":false,\"title\":\"任务仓库\",\"version\":0,\"url\":\"http://hiker.nokia.press/hikerule/task/get_info/23?username=undefined&password=undefined\",\"col_type\":\"movie_3\",\"find_rule\":\"js:\\n    const {color, small,api,getFile} = $.require(\\\"hiker://page/utiliy?rule=道长仓库Pro\\\");\\nlet {url,can_update,can_delete} = MY_PARAMS;\\nlog(url);\\nfunction req(url,data) { // 通用发送仓库post请求\\n    let result = request(url, {\\n        headers: {\\n            'content-type': 'application/json'\\n        },\\n        body: JSON.stringify(data),\\n        method: 'POST'\\n    });\\n    return JSON.parse(result).result;\\n}\\nlet houseFile = getFile||false;\\nif(!houseFile){\\n    setItem('is_house_vip', 'false');\\n}\\nlet house_data = houseFile();\\n\\nlet res = {};\\nlet items = [];\\nlet back_code = fetch(url,{});\\nback_code = JSON.parse(back_code);\\nif(back_code.status===0){\\n    let task = back_code.result;\\n    let tips = can_delete?' (点击删除)':'';\\n    items.push(\\n        {\\n            title:task.name+tips,\\n            desc:'id:'+task.id+'  可视状态:'+task.visible+'\\\\n作者:'+task.dev_name+' 分享状态:'+task.state+'\\\\n更新时间'+task.publish_time,\\n            col_type:'movie_1_vertical_pic',\\n            pic_url:'https://api.mtyqx.cn/api/random.php?t='+Math.random(),\\n            url:!can_delete?'hiker://empty':$(\\\"确认删除?\\\").confirm((task,host,house_data)=>{\\n                let del_url = host+'/hikerule/task/delete/'+task.id+'?name='+house_data.username+'&password='+house_data.password;\\n                try {\\n                    let result = JSON.parse(fetch(del_url,{}));\\n                    if(result.status===0){\\n                        back(true);\\n                        return \\\"toast://\\\"+result.detail;\\n                    }\\n                }catch (e) {\\n                    return \\\"toast://出错了:\\\\n\\\"+e.message;\\n                }\\n\\n            },task,api.host,house_data),\\n        }\\n    );\\n    let ruleCode = \\\"海阔视界本地文件分享￥file_url￥hiker://files/rules/dzHouse/python/\\\"+task.name+\\\".py@\\\"+MY_URL+\\\"&debug=1\\\";\\n    let importUrl = 'rule://' + base64Encode(ruleCode);\\n\\n    items.push(\\n        {\\n            title:'📥导入',\\n            col_type: 'flex_button',\\n            url:importUrl\\n        }\\n    );\\n\\n    items.push(\\n        {\\n            title:'📝本地编辑',\\n            col_type: 'flex_button',\\n            url:$().lazyRule((task) => {\\n                return 'editFile://hiker://files/rules/dzHouse/python/'+task.name+'.py';\\n            },task)\\n        }\\n    );\\n\\n    items.push(\\n        {\\n            title:'▶️测试执行',\\n            col_type: 'flex_button',\\n            url:\\\"hiker://page/test_run#noHistory#\\\",\\n            extra: {\\n                task:task,\\n                host:api.host,\\n                house_data:house_data\\n            }\\n        }\\n    );\\n\\n    if(can_update){\\n        items.push(\\n            {\\n                title:'▶重发布',\\n                col_type: 'flex_button',\\n                url:'hiker://page/new_task#noHistory#',\\n                extra: {\\n                    task:task,\\n                    // host:api.host,\\n                    // house_data:house_data\\n                }\\n            }\\n        );\\n        items.push(\\n            {\\n                title:'🍇任务改名',\\n                col_type: 'flex_button',\\n                url:$(task.name, \\\"输入新的任务名称\\\").input((task) => {\\n                    return $(\\\"确认将\\\"+task.name+\\\"修改为:\\\"+input+' ?').confirm((input,task)=>{\\n                        // log(task.id);\\n                        const {taskRename} = $.require(\\\"hiker://page/utils?rule=\\\"+MY_RULE.title);\\n                        let result = taskRename(task.id,input);\\n                        refreshPage(true);\\n                        // back(true);\\n                        return \\\"toast://\\\"+result;\\n                    },input,task);\\n                },task),\\n            }\\n        );\\n\\n        items.push(\\n            {\\n                title:'🍰更改分享状态',\\n                col_type: 'flex_button',\\n                url:$().lazyRule((task) => {\\n                    const {taskChangeState} = $.require(\\\"hiker://page/utils?rule=\\\"+MY_RULE.title);\\n                    let result = taskChangeState(task.id);\\n                    refreshPage(true);\\n                    return 'toast://'+result;\\n                },task),\\n            }\\n        );\\n\\n        items.push(\\n            {\\n                title:task.visible?'👀可视':'👀不可视',\\n                col_type: 'flex_button',\\n                url:$().lazyRule((task) => {\\n                    const {taskChangeVisible} = $.require(\\\"hiker://page/utils?rule=\\\"+MY_RULE.title);\\n                    let result = taskChangeVisible(task.id);\\n                    refreshPage(true);\\n                    return 'toast://'+result;\\n                },task),\\n            }\\n        );\\n    }\\n\\n    items.push(\\n        {\\n            title:'备注',\\n            desc:small(task.note),\\n            col_type: 'text_1',\\n            url:'toast://'+task.note\\n        }\\n    );\\n\\n    items.push({\\n        title:'✍python代码:',\\n        col_type:'text_1',\\n        url:'hiker://empty'\\n    })\\n\\n    items.push(\\n        {\\n            title:task.pycode,\\n            col_type:'long_text'\\n        }\\n    );\\n}\\nres.data = items;\\nsetHomeResult(res);\",\"group\":\"#️⃣仓库\",\"ua\":\"mobile\",\"preRule\":\"\",\"pages\":\"[{\\\"col_type\\\":\\\"long_text\\\",\\\"name\\\":\\\"测试执行云函数\\\",\\\"path\\\":\\\"test_run\\\",\\\"rule\\\":\\\"js:\\\\nlet {task,host} = MY_PARAMS;\\\\nconst {color, small} = $.require(\\\\\\\"hiker://page/utiliy?rule=道长仓库Pro\\\\\\\");\\\\nconst {taskCall, taskRun,taskReq} = $.require(\\\\\\\"hiker://page/utils?rule=\\\\\\\"+MY_RULE.title);\\\\n// log('规则名:'+MY_RULE.title);\\\\nString.prototype.strip = function () { return this.replace(/(^\\\\\\\\s*)|(\\\\\\\\s*$)/g, \\\\\\\"\\\\\\\"); }\\\\nsetPageTitle(\\\\\\\"执行「\\\\\\\"+task.name+\\\\\\\"」\\\\\\\");\\\\naddListener('onClose', $.toString(()=>{\\\\n    clearVar(\\\\\\\"task_box.test_result\\\\\\\");\\\\n    clearVar(\\\\\\\"task_box.func_name\\\\\\\");\\\\n    clearVar(\\\\\\\"task_box.test_params\\\\\\\");\\\\n}));\\\\nlet d = [];\\\\nd.push({\\\\n    title: \\\\\\\"函数说明:\\\\\\\",\\\\n    desc:small(task.note),\\\\n    url: \\\\\\\"hiker://empty\\\\\\\",\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nd.push({\\\\n    title: \\\\\\\"测试代码，点击复制\\\\\\\",\\\\n    desc:small('注意字符串参数必须双引号，不支持单引号\\\\\\\\n')+small(task.test_code),\\\\n    url: \\\\\\\"copy://\\\\\\\"+task.test_code,\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n});\\\\nd.push({\\\\n    title: \\\\\\\"运行模式:\\\\\\\"+getVar('task_box.test_mode','call'),\\\\n    url: $(['call','run'],1).select(_ => {\\\\n        putVar('task_box.test_mode',input);\\\\n        if(input==='run'){\\\\n            clearVar(\\\\\\\"task_box.test_params\\\\\\\");\\\\n        }\\\\n        refreshPage(true);\\\\n        return \\\\\\\"toast://你选择了\\\\\\\"+input\\\\n    }),\\\\n    col_type: \\\\\\\"text_1\\\\\\\"\\\\n})\\\\nif(getVar('task_box.test_mode','call')==='call'){\\\\n    let match_func = ret = task.pycode.match(/.*?def.*?[\\\\\\\\S]\\\\\\\\(/g);\\\\n    let default_func = match_func&&match_func.length>0?match_func[0].split('def')[1].split('(')[0].strip():\\\\\\\"\\\\\\\";\\\\n    let default_parmas = task.test_code&&task.test_code.indexOf('=>')>-1?task.test_code.split('=>')[1].strip():task.test_code;\\\\n    if(getVar('task_box.test_mode')==='run'){\\\\n        default_parmas = '[]';\\\\n    }\\\\n    d.push({\\\\n        title: '函数名',\\\\n        desc: \\\\\\\"请输入欲调用的函数名\\\\\\\",\\\\n        extra: {\\\\n            onChange: \\\\\\\"putVar('task_box.func_name',input)\\\\\\\",\\\\n            titleVisible: true,\\\\n            defaultValue: getVar('task_box.func_name', '')||default_func||\\\\\\\"\\\\\\\"\\\\n        },\\\\n        url:$.toString(() => {\\\\n            var func_name = getVar('task_box.func_name');\\\\n            return 'toast://你输入的是:'+func_name;\\\\n        }),\\\\n        col_type: \\\\\\\"input\\\\\\\"\\\\n    })\\\\n\\\\n    d.push({\\\\n        desc: \\\\\\\"传参列表,[参数1,参数2,参数3,......]\\\\\\\",\\\\n        col_type: 'input',\\\\n        extra: {\\\\n            titleVisible: false,\\\\n            defaultValue: getVar('task_box.test_params', '')||default_parmas||\\\\\\\"[]\\\\\\\",\\\\n            type: \\\\\\\"textarea\\\\\\\",\\\\n            height:-1,\\\\n            onChange: 'putVar(\\\\\\\"task_box.test_params\\\\\\\",input)'\\\\n        }\\\\n    });\\\\n}\\\\nd.push({\\\\n    title: \\\\\\\"▶️执行\\\\\\\",\\\\n    col_type: \\\\\\\"text_center_1\\\\\\\",\\\\n    url: $(host+\\\\\\\"/hikerule/task/run/\\\\\\\"+task.id).lazyRule((task,taskReq) => {\\\\n        let call_params = [];\\\\n        String.prototype.strip = function () { return this.replace(/(^\\\\\\\\s*)|(\\\\\\\\s*$)/g, \\\\\\\"\\\\\\\"); }\\\\n        let test_mode = getVar('task_box.test_mode','call'), func_name=getVar('task_box.func_name'),test_params=getVar('task_box.test_params');\\\\n        try {\\\\n            call_params = JSON.parse(test_params||'[]');\\\\n        }\\\\n        catch (e) {\\\\n            return \\\\\\\"toast://参数格式错误，必须为[]列表形式\\\\\\\\n\\\\\\\" + test_params;\\\\n        }\\\\n        if(func_name&&task.pycode.indexOf(func_name)===-1){\\\\n            return \\\\\\\"toast://调用函数\\\\\\\"+func_name+\\\\\\\"错误\\\\\\\\n\\\\\\\" + \\\\\\\"没找到代码包含此函数\\\\\\\";\\\\n        }\\\\n        let real_params = JSON.stringify(call_params).strip();\\\\n        if(!(real_params.startsWith('[')&&real_params.endsWith(']'))){\\\\n            return \\\\\\\"toast://参数格式错误，可不填或者必须[开头,]结束\\\\\\\\n\\\\\\\" + JSON.stringify(call_params);\\\\n        }\\\\n        let result = taskReq(input,{mode:test_mode,func:func_name,params:call_params});\\\\n        log(result);\\\\n        if (result.status !== 0) {\\\\n            putVar('task_box.test_result',result.detail);\\\\n            refreshPage(true);\\\\n            return \\\\\\\"toast://\\\\\\\" + result.detail;\\\\n        }\\\\n        putVar('task_box.test_result',result.result||\\\\\\\"None\\\\\\\");\\\\n        refreshPage(true);\\\\n        return \\\\\\\"toast://执行完毕,结果为:\\\\\\\"+ result.result;\\\\n    },task,taskReq)\\\\n});\\\\nd.push({\\\\n    title:'运行结果',\\\\n    col_type:'text_1',\\\\n    url:'hiker://empty'\\\\n});\\\\nd.push({\\\\n    title:getVar('task_box.test_result',''),\\\\n    col_type:'long_text'\\\\n});\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"工具类函数\\\",\\\"path\\\":\\\"utils\\\",\\\"rule\\\":\\\"js:\\\\n    String.prototype.strip = function () { return this.replace(/(^\\\\\\\\s*)|(\\\\\\\\s*$)/g, \\\\\\\"\\\\\\\"); };\\\\nfunction task_req(task_api,task) { // 通用发送仓库post调用任务请求\\\\n    const {getFile} = $.require(\\\\\\\"hiker://page/utiliy?rule=道长仓库Pro\\\\\\\");\\\\n    let houseFile = getFile||false;\\\\n    if(!houseFile){\\\\n        setItem('is_house_vip', 'false');\\\\n    }\\\\n    let house_data = houseFile();\\\\n    let result = request(task_api, {\\\\n        headers: {\\\\n            'content-type': 'application/json'\\\\n        },\\\\n        body: JSON.stringify({\\\\n            \\\\\\\"params\\\\\\\": {\\\\n                \\\\\\\"data\\\\\\\": {\\\\n                    \\\\\\\"type\\\\\\\": task.mode||'run',\\\\n                    \\\\\\\"func\\\\\\\": task.func||'',\\\\n                    \\\\\\\"params\\\\\\\": task.params||[]\\\\n                },\\\\n                \\\\\\\"auth\\\\\\\": {\\\\n                    \\\\\\\"name\\\\\\\": house_data.username||\\\\\\\"\\\\\\\",\\\\n                    \\\\\\\"password\\\\\\\": house_data.password||\\\\\\\"\\\\\\\"\\\\n                }\\\\n            }\\\\n        }),\\\\n        method: 'POST'\\\\n    });\\\\n    return JSON.parse(result).result;\\\\n}\\\\n\\\\nfunction task_upload(task){ // 通用任务发布新增及修改功能\\\\n    const {api,getFile} = $.require(\\\\\\\"hiker://page/utiliy?rule=道长仓库Pro\\\\\\\");\\\\n    let houseFile = getFile||false;\\\\n    if(!houseFile){\\\\n        setItem('is_house_vip', 'false');\\\\n    }\\\\n    let api_url = api.host+'/hikerule/task/add';\\\\n    let house_data = houseFile();\\\\n    let result = request(api_url, {\\\\n        headers: {\\\\n            'content-type': 'application/json'\\\\n        },\\\\n        body: JSON.stringify({\\\\n            \\\\\\\"params\\\\\\\": {\\\\n                \\\\\\\"data\\\\\\\": {\\\\n                    \\\\\\\"name\\\\\\\": task.name,\\\\n                    \\\\\\\"pycode\\\\\\\": task.pycode,\\\\n                    \\\\\\\"note\\\\\\\": task.note,\\\\n                    \\\\\\\"test_code\\\\\\\": task.test_code,\\\\n                },\\\\n                \\\\\\\"auth\\\\\\\": {\\\\n                    \\\\\\\"name\\\\\\\": house_data.username||\\\\\\\"\\\\\\\",\\\\n                    \\\\\\\"password\\\\\\\": house_data.password||\\\\\\\"\\\\\\\"\\\\n                }\\\\n            }\\\\n        }),\\\\n        method: 'POST'\\\\n    });\\\\n    return JSON.parse(result).result;\\\\n}\\\\n\\\\nfunction task_call(id,func,params){\\\\n    const {api} = $.require(\\\\\\\"hiker://page/utiliy?rule=道长仓库Pro\\\\\\\");\\\\n    let task_api = api.host+'/hikerule/task/run/'+id;\\\\n    let task = {\\\\n        mode:'call',\\\\n        func:func,\\\\n        params:params||[]\\\\n    };\\\\n    return task_req(task_api,task);\\\\n}\\\\n\\\\nfunction task_rename(id,new_task_name){\\\\n    const {api,getFile} = $.require(\\\\\\\"hiker://page/utiliy?rule=道长仓库Pro\\\\\\\");\\\\n    let houseFile = getFile||false;\\\\n    if(!houseFile){\\\\n        setItem('is_house_vip', 'false');\\\\n    }\\\\n    let house_data = houseFile();\\\\n    let task_api = api.host+'/hikerule/task/rename/'+id;\\\\n    task_api = task_api+'?name='+house_data.username+'&password='+house_data.password+'&task_name='+new_task_name;\\\\n    try {\\\\n        let result = JSON.parse(fetch(task_api,{}));\\\\n        if(result.status==0){\\\\n            return  result.detail\\\\n        }else{\\\\n            return result.result+''+result.detail\\\\n        }\\\\n    }catch (e) {\\\\n        log(e.message);\\\\n        return ''+e.message\\\\n    }\\\\n}\\\\n\\\\nfunction task_change_state(id){\\\\n    const {api,getFile} = $.require(\\\\\\\"hiker://page/utiliy?rule=道长仓库Pro\\\\\\\");\\\\n    let houseFile = getFile||false;\\\\n    if(!houseFile){\\\\n        setItem('is_house_vip', 'false');\\\\n    }\\\\n    let house_data = houseFile();\\\\n    let task_api = api.host+'/hikerule/task/change_state/'+id;\\\\n    task_api = task_api+'?name='+house_data.username+'&password='+house_data.password;\\\\n    try {\\\\n        let result = JSON.parse(fetch(task_api,{}));\\\\n        if(result.status==0){\\\\n            return  result.detail\\\\n        }else{\\\\n            return result.result+''+result.detail\\\\n        }\\\\n    }catch (e) {\\\\n        log(e.message);\\\\n        return ''+e.message\\\\n    }\\\\n}\\\\n\\\\nfunction task_change_visible(id){\\\\n    const {api,getFile} = $.require(\\\\\\\"hiker://page/utiliy?rule=道长仓库Pro\\\\\\\");\\\\n    let houseFile = getFile||false;\\\\n    if(!houseFile){\\\\n        setItem('is_house_vip', 'false');\\\\n    }\\\\n    let house_data = houseFile();\\\\n    let task_api = api.host+'/hikerule/task/change_visible/'+id;\\\\n    task_api = task_api+'?name='+house_data.username+'&password='+house_data.password;\\\\n    try {\\\\n        let result = JSON.parse(fetch(task_api,{}));\\\\n        if(result.status===0){\\\\n            return  result.detail\\\\n        }else{\\\\n            return result.result+''+result.detail\\\\n        }\\\\n    }catch (e) {\\\\n        log(e.message);\\\\n        return ''+e.message\\\\n    }\\\\n}\\\\n\\\\nfunction task_run(id){\\\\n    const {api} = $.require(\\\\\\\"hiker://page/utiliy?rule=道长仓库Pro\\\\\\\");\\\\n    let task_api = api.host+'/hikerule/task/run/'+id;\\\\n    let task = {};\\\\n    return task_req(task_api,task);\\\\n}\\\\n\\\\n$.exports.taskCall = task_call;\\\\n$.exports.taskRun = task_run;\\\\n$.exports.taskReq = task_req;\\\\n$.exports.taskUpload = task_upload;\\\\n$.exports.taskRename = task_rename;\\\\n$.exports.taskChangeState = task_change_state;\\\\n$.exports.taskChangeVisible = task_change_visible;\\\"},{\\\"name\\\":\\\"任务管理发布\\\",\\\"path\\\":\\\"publish_task\\\",\\\"rule\\\":\\\"js:\\\\nlet {host,house_data} = MY_PARAMS;\\\\nsetPageTitle(\\\\\\\"任务管理「\\\\\\\"+house_data.username+\\\\\\\"」\\\\\\\");\\\\nlet d = [];\\\\nd.push({\\\\n    title:'🗒新建/更新✏',\\\\n    col_type:'flex_button',\\\\n    url:'hiker://page/new_task#noHistory#',\\\\n});\\\\n\\\\nlet url = host+'/hikerule/task/get_by_dev?name='+house_data.username+'&password='+house_data.password;\\\\ntry {\\\\n    let result = JSON.parse(fetch(url,{}));\\\\n    d.push({\\\\n        title:result.detail,\\\\n        col_type:'text_center_1',\\\\n        url:'hiker://empty',\\\\n    });\\\\n\\\\n    if(result.status===0){\\\\n        let tasks = result.result;\\\\n        for(var task of tasks){\\\\n            d.push({\\\\n                title:'🐉'+task.name+'(id:'+task.id+')',\\\\n                col_type:'text_2',\\\\n                url:'hiker://page/task_info#noHistory#',\\\\n                extra:{url:host+'/hikerule/task/get_info/'+task.id+'?name='+house_data.username+'&password='+house_data.password,\\\\n                can_update:true,can_delete:true,\\\\n                },\\\\n            });\\\\n        }\\\\n    }\\\\n}catch (e) {\\\\n    log(e.message);\\\\n}\\\\nsetResult(d);\\\"},{\\\"col_type\\\":\\\"movie_3\\\",\\\"name\\\":\\\"任务详情\\\",\\\"path\\\":\\\"task_info\\\",\\\"rule\\\":\\\"js:\\\\n    const {color, small,api,getFile} = $.require(\\\\\\\"hiker://page/utiliy?rule=道长仓库Pro\\\\\\\");\\\\nlet {url,can_update,can_delete} = MY_PARAMS;\\\\nlog(url);\\\\nfunction req(url,data) { // 通用发送仓库post请求\\\\n    let result = request(url, {\\\\n        headers: {\\\\n            'content-type': 'application/json'\\\\n        },\\\\n        body: JSON.stringify(data),\\\\n        method: 'POST'\\\\n    });\\\\n    return JSON.parse(result).result;\\\\n}\\\\nlet houseFile = getFile||false;\\\\nif(!houseFile){\\\\n    setItem('is_house_vip', 'false');\\\\n}\\\\nlet house_data = houseFile();\\\\n\\\\nlet res = {};\\\\nlet items = [];\\\\nlet back_code = fetch(url,{});\\\\nback_code = JSON.parse(back_code);\\\\nif(back_code.status===0){\\\\n    let task = back_code.result;\\\\n    let tips = can_delete?' (点击删除)':'';\\\\n    items.push(\\\\n        {\\\\n            title:task.name+tips,\\\\n            desc:'id:'+task.id+'  可视状态:'+task.visible+'\\\\\\\\n作者:'+task.dev_name+' 分享状态:'+task.state+'\\\\\\\\n更新时间'+task.publish_time,\\\\n            col_type:'movie_1_vertical_pic',\\\\n            pic_url:'https://api.mtyqx.cn/api/random.php?t='+Math.random(),\\\\n            url:!can_delete?'hiker://empty':$(\\\\\\\"确认删除?\\\\\\\").confirm((task,host,house_data)=>{\\\\n                let del_url = host+'/hikerule/task/delete/'+task.id+'?name='+house_data.username+'&password='+house_data.password;\\\\n                try {\\\\n                    let result = JSON.parse(fetch(del_url,{}));\\\\n                    if(result.status===0){\\\\n                        back(true);\\\\n                        return \\\\\\\"toast://\\\\\\\"+result.detail;\\\\n                    }\\\\n                }catch (e) {\\\\n                    return \\\\\\\"toast://出错了:\\\\\\\\n\\\\\\\"+e.message;\\\\n                }\\\\n\\\\n            },task,api.host,house_data),\\\\n        }\\\\n    );\\\\n    let ruleCode = \\\\\\\"海阔视界本地文件分享￥file_url￥hiker://files/rules/dzHouse/python/\\\\\\\"+task.name+\\\\\\\".py@\\\\\\\"+MY_URL+\\\\\\\"&debug=1\\\\\\\";\\\\n    let importUrl = 'rule://' + base64Encode(ruleCode);\\\\n\\\\n    items.push(\\\\n        {\\\\n            title:'📥导入',\\\\n            col_type: 'flex_button',\\\\n            url:importUrl\\\\n        }\\\\n    );\\\\n\\\\n    items.push(\\\\n        {\\\\n            title:'📝本地编辑',\\\\n            col_type: 'flex_button',\\\\n            url:$().lazyRule((task) => {\\\\n                return 'editFile://hiker://files/rules/dzHouse/python/'+task.name+'.py';\\\\n            },task)\\\\n        }\\\\n    );\\\\n\\\\n    items.push(\\\\n        {\\\\n            title:'▶️测试执行',\\\\n            col_type: 'flex_button',\\\\n            url:\\\\\\\"hiker://page/test_run#noHistory#\\\\\\\",\\\\n            extra: {\\\\n                task:task,\\\\n                host:api.host,\\\\n                house_data:house_data\\\\n            }\\\\n        }\\\\n    );\\\\n\\\\n    if(can_update){\\\\n        items.push(\\\\n            {\\\\n                title:'▶重发布',\\\\n                col_type: 'flex_button',\\\\n                url:'hiker://page/new_task#noHistory#',\\\\n                extra: {\\\\n                    task:task,\\\\n                    // host:api.host,\\\\n                    // house_data:house_data\\\\n                }\\\\n            }\\\\n        );\\\\n        items.push(\\\\n            {\\\\n                title:'🍇任务改名',\\\\n                col_type: 'flex_button',\\\\n                url:$(task.name, \\\\\\\"输入新的任务名称\\\\\\\").input((task) => {\\\\n                    return $(\\\\\\\"确认将\\\\\\\"+task.name+\\\\\\\"修改为:\\\\\\\"+input+' ?').confirm((input,task)=>{\\\\n                        // log(task.id);\\\\n                        const {taskRename} = $.require(\\\\\\\"hiker://page/utils?rule=\\\\\\\"+MY_RULE.title);\\\\n                        let result = taskRename(task.id,input);\\\\n                        refreshPage(true);\\\\n                        // back(true);\\\\n                        return \\\\\\\"toast://\\\\\\\"+result;\\\\n                    },input,task);\\\\n                },task),\\\\n            }\\\\n        );\\\\n\\\\n        items.push(\\\\n            {\\\\n                title:'🍰更改分享状态',\\\\n                col_type: 'flex_button',\\\\n                url:$().lazyRule((task) => {\\\\n                    const {taskChangeState} = $.require(\\\\\\\"hiker://page/utils?rule=\\\\\\\"+MY_RULE.title);\\\\n                    let result = taskChangeState(task.id);\\\\n                    refreshPage(true);\\\\n                    return 'toast://'+result;\\\\n                },task),\\\\n            }\\\\n        );\\\\n\\\\n        items.push(\\\\n            {\\\\n                title:task.visible?'👀可视':'👀不可视',\\\\n                col_type: 'flex_button',\\\\n                url:$().lazyRule((task) => {\\\\n                    const {taskChangeVisible} = $.require(\\\\\\\"hiker://page/utils?rule=\\\\\\\"+MY_RULE.title);\\\\n                    let result = taskChangeVisible(task.id);\\\\n                    refreshPage(true);\\\\n                    return 'toast://'+result;\\\\n                },task),\\\\n            }\\\\n        );\\\\n    }\\\\n\\\\n    items.push(\\\\n        {\\\\n            title:'备注',\\\\n            desc:small(task.note),\\\\n            col_type: 'text_1',\\\\n            url:'toast://'+task.note\\\\n        }\\\\n    );\\\\n\\\\n    items.push({\\\\n        title:'✍python代码:',\\\\n        col_type:'text_1',\\\\n        url:'hiker://empty'\\\\n    })\\\\n\\\\n    items.push(\\\\n        {\\\\n            title:task.pycode,\\\\n            col_type:'long_text'\\\\n        }\\\\n    );\\\\n}\\\\nres.data = items;\\\\nsetHomeResult(res);\\\"},{\\\"name\\\":\\\"新建任务\\\",\\\"path\\\":\\\"new_task\\\",\\\"rule\\\":\\\"js:\\\\n\\\\nconst {taskUpload} = $.require(\\\\\\\"hiker://page/utils?rule=\\\\\\\"+MY_RULE.title);\\\\nlet {task} = MY_PARAMS;\\\\nif(!task){\\\\n    task = {}\\\\n}else{\\\\n    if(!getVar('task_box.new_task_name')){\\\\n        putVar('task_box.new_task_name',task.name);\\\\n    }\\\\n    if(!getVar('task_box.new_task_note')){\\\\n        putVar('task_box.new_task_note',task.note);\\\\n    }\\\\n    if(!getVar('task_box.new_task_pycode')){\\\\n        putVar('task_box.new_task_pycode',task.pycode);\\\\n    }\\\\n    if(!getVar('task_box.new_task_test_code')){\\\\n        putVar('task_box.new_task_test_code',task.test_code);\\\\n    }\\\\n}\\\\nString.prototype.strip = function () { return this.replace(/(^\\\\\\\\s*)|(\\\\\\\\s*$)/g, \\\\\\\"\\\\\\\"); }\\\\nsetPageTitle(\\\\\\\"新建任务\\\\\\\");\\\\naddListener('onClose', $.toString(()=>{\\\\n    // clearVar(\\\\\\\"task_box.new_task_name\\\\\\\");\\\\n    clearVar(\\\\\\\"task_box.new_task_note\\\\\\\");\\\\n    clearVar(\\\\\\\"task_box.new_task_pycode\\\\\\\");\\\\n    clearVar(\\\\\\\"task_box.new_task_test_code\\\\\\\");\\\\n}));\\\\nlet d = [];\\\\nd.push({\\\\n    title: '任务名称',\\\\n    desc: \\\\\\\"任务名称,如ikuuu签到\\\\\\\",\\\\n    extra: {\\\\n        onChange: \\\\\\\"putVar('task_box.new_task_name',input)\\\\\\\",\\\\n        titleVisible: true,\\\\n        defaultValue: getVar('task_box.new_task_name', '')||task.name||\\\\\\\"\\\\\\\"\\\\n    },\\\\n    url:$.toString(() => {\\\\n        let task_name = getVar('task_box.new_task_name');\\\\n        return 'toast://你输入的是:'+task_name;\\\\n    }),\\\\n    col_type: \\\\\\\"input\\\\\\\"\\\\n});\\\\nd.push({\\\\n    desc: \\\\\\\"备注\\\\\\\",\\\\n    col_type: 'input',\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        defaultValue: getVar('task_box.new_task_note', '')||task.note||\\\\\\\"\\\\\\\",\\\\n        type: \\\\\\\"textarea\\\\\\\",\\\\n        height:-1,\\\\n        onChange: 'putVar(\\\\\\\"task_box.new_task_note\\\\\\\",input)'\\\\n    }\\\\n});\\\\nd.push({\\\\n    desc: \\\\\\\"测试代码\\\\\\\",\\\\n    col_type: 'input',\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        defaultValue: getVar('task_box.new_task_test_code', '')||task.test_code||\\\\\\\"\\\\\\\",\\\\n        type: \\\\\\\"textarea\\\\\\\",\\\\n        height:-1,\\\\n        onChange: 'putVar(\\\\\\\"task_box.new_task_test_code\\\\\\\",input)'\\\\n    }\\\\n});\\\\nd.push({\\\\n    title:'py代码:📝本地编辑',\\\\n    col_type:'flex_button',\\\\n    url:$().lazyRule(() => {\\\\n        if(!getVar('task_box.new_task_name', '')){\\\\n            return 'toast://本地编辑必须先填写任务名称'\\\\n        }\\\\n        let filepath = 'hiker://files/rules/dzHouse/python/'+getVar('task_box.new_task_name', '')+'.py';\\\\n        if(!fileExist(filepath)){\\\\n            writeFile(filepath, '# python3\\\\\\\\n');\\\\n        }\\\\n        return 'editFile://'+filepath;\\\\n    })\\\\n});\\\\nd.push({\\\\n    title:'🔄刷新代码框',\\\\n    col_type:'flex_button',\\\\n    url:$().lazyRule(() => {\\\\n        if(!getVar('task_box.new_task_name', '')){\\\\n            return 'toast://刷新必须先填写任务名称'\\\\n        }\\\\n        let file_path = 'hiker://files/rules/dzHouse/python/'+getVar('task_box.new_task_name', '')+'.py';\\\\n        putVar('task_box.new_task_pycode',fetch(file_path));\\\\n        refreshPage(true);\\\\n        return 'toast://已刷新';\\\\n    })\\\\n});\\\\nd.push({\\\\n    title:'📲发布',\\\\n    col_type:'flex_button',\\\\n    url:$().lazyRule((taskUpload) => {\\\\n        if(!getVar('task_box.new_task_name', '')||!getVar('task_box.new_task_pycode', '')){\\\\n            return 'toast://发布任务必须保证任务名称及代码填写'\\\\n        }\\\\n        let task = {\\\\n            name:getVar('task_box.new_task_name', ''),\\\\n            pycode:getVar('task_box.new_task_pycode', ''),\\\\n            note:getVar('task_box.new_task_note', ''),\\\\n            test_code:getVar('task_box.new_task_test_code', ''),\\\\n        };\\\\n        let result = taskUpload(task);\\\\n        if(result.status===0){\\\\n            return 'toast://'+result.detail;\\\\n        }else{\\\\n            return 'toast://'+result.result+result.detail;\\\\n        }\\\\n    },taskUpload)\\\\n});\\\\n\\\\nd.push({\\\\n    desc: \\\\\\\"任务代码\\\\\\\",\\\\n    col_type: 'input',\\\\n    extra: {\\\\n        titleVisible: false,\\\\n        defaultValue: getVar('task_box.new_task_pycode', '')||task.pycode||\\\\\\\"\\\\\\\",\\\\n        type: \\\\\\\"textarea\\\\\\\",\\\\n        height:-1,\\\\n        onChange: 'putVar(\\\\\\\"task_box.new_task_pycode\\\\\\\",input)'\\\\n    }\\\\n});\\\\nsetResult(d);\\\"},{\\\"name\\\":\\\"emoji表情\\\",\\\"path\\\":\\\"emoji\\\",\\\"rule\\\":\\\"js:\\\\nlet d = [];\\\\nlet Data = [];\\\\nlet cate_urls = ['1','2'];\\\\nif(!getVar('now_emoji_url')){\\\\n    putVar('now_emoji_url','http://www.fhdq.net/emoji/8.html');\\\\n}\\\\nfor(var cate of cate_urls){\\\\n    Data.push({\\\\n        url: 'http://www.fhdq.net/emoji/list_'+cate+'.html',\\\\n        options: {\\\\n            headers: {\\\\n                \\\\\\\"User-Agent\\\\\\\": \\\\\\\"Dart/2.13 (dart:io)\\\\\\\"\\\\n            },\\\\n            timeout: 5000\\\\n        }\\\\n    });\\\\n}\\\\nvar bhtml = batchFetch(Data);\\\\nfor(var bth of bhtml){\\\\n    let emoji_cate = pdfa(bth,'.listbox&&li');\\\\n    // log(emoji_cate);\\\\n    for(let cate of emoji_cate){\\\\n        try {\\\\n            let title = pdfh(cate,'li&&Text');\\\\n            if(title.replace(/[\\\\\\\\s]/g,'').length>0){\\\\n                let url = 'http://www.fhdq.net'+pdfh(cate,'a&&href');\\\\n                let tips = getVar('now_emoji_url')===url?'✌':'';\\\\n                title = title.replace('emoji','')+tips;\\\\n                d.push(\\\\n                    {\\\\n                        title:title,\\\\n                        url:$().lazyRule((url,title) => {\\\\n                            putVar('now_emoji_url',url);\\\\n                            refreshPage(true);\\\\n                            return 'toast://当前emoji分类:'+title;\\\\n                        },url,title),\\\\n                        col_type:'scroll_button'\\\\n                    }\\\\n                );\\\\n            }\\\\n        }\\\\n        catch (e) {\\\\n\\\\n        }\\\\n    }\\\\n}\\\\n\\\\nlet html=fetch(getVar('now_emoji_url'));\\\\nlet emoji_list = pdfa(html,'.emojilistpc&&li');\\\\nfor(var emoji of emoji_list){\\\\n    let title = pdfh(emoji,'li&&Text');\\\\n    d.push({\\\\n        title:title,\\\\n        col_type:'flex_button',\\\\n        url:'copy://'+title\\\\n    });\\\\n}\\\\nsetResult(d);\\\"}]\"}","picUrl":"https://api.mtyqx.cn/api/random.php?t=0.1409814217743407","title":"ikuuu"}