404页面也设置成首页

云对象右键运行一定要配置运行参数，参考：[https://uniapp.dcloud.net.cn/uniCloud/cloud-obj.html#run-local](https://uniapp.dcloud.net.cn/uniCloud/cloud-obj.html#run-local)

## 最新更新（2023-12-29）

unicloud已支持扩展存储，具有更强大的自定义权限控制，更便宜的cdn流量价格，流量按阶梯收费，越用越便宜，具体算来下比用传统cdn流量包还便宜。

而且不管空间是包月的还是按量计费的都能开通扩展存储。

扩展存储是DCloud联合业内其它主流CDN厂商，单独提供了价格更便宜、功能更强大的uniCloud扩展存储

扩展存储文档: [https://doc.dcloud.net.cn/uniCloud/ext-storage/intro.html](https://doc.dcloud.net.cn/uniCloud/ext-storage/intro.html)

扩展存储开通指南: [https://doc.dcloud.net.cn/uniCloud/ext-storage/service.html](https://doc.dcloud.net.cn/uniCloud/ext-storage/service.html)


## 以下是2023-06-05日的回答

1、首先阿里云的云存储没有权限管理而url是固定的，如果存入一些敏感信息比如身份证照片，其他人有没有遍历我的阿里云的服务空间找出这些身份证的能力？

答：目前阿里云空间云储存因为是公开权限,不适合直接将身份证储存到云储存, 但我们可以通过在云函数把身份证图片转成base64后,再将base64进行AES加密, 得到的密文转二进制后上传到云储存。这样即使被扫描，对方也无法破解图片。
当你需要看身份证时，通过云函数去解密得到原始的base64，就可以显示图片了。

2、如果我使用腾讯云虽然有权限限制但是要获取url好像必须使用uniCloud.getTempFileURL函数实现，那么带来的问题是这个函数调用应该是计费的

答： 是的，会消耗CDN流量和下载次数

3、用腾讯云每个地方都要套一层uniCloud.getTempFileURL？

答：是的，不过腾讯云如果设置公共读权限，则获取到的临时url其实是永久有效的。

4、上面说"阿里云不支持此API，前端运行此API会报权限错误"，那么在云函数中是否可以使用此api。

答：云函数中可以使用此api。

5、最后如果用户恶意大量上传数据有没有办法阻止？

答：目前没办法阻止，只要提供了前端直传能力的oss，就没办法阻止用户上传（不过可以联系官方帮你把你空间上传功能关闭了），但用户只上传的话，影响比较小，毕竟可以去控制台删除。云储存的费用大头是CDN流量，上传不会扣CDN流量，访问才扣，同时当你流量超过1G了，第二天可以开通CDN安全管理，可以封访问量过大的IP,UA等等。

HBuilderX 4.25.2024081703-alpha 已修复。

选Nginx,其中证书内容就是.pem文件里的全部内容, 私钥就是.key文件里的全部内容

暂时不支持排序功能。如果想查看所有文件。可以通过js去获取,然后进行排序

### 1、在```network``` 中找到```https://unicloud-api.dcloud.net.cn/unicloud/api/file/list```这个接口，右击 ```copy``` - ```Copy as Fetch```
** 插入的附件 **
### 2、创建一个js, 复制下方js
```js
const fs = require('fs');

async function fetchAllPagesWithProgress() {
let allData = [];
let nextToken = null;
let pageCount = 0;

do {
console.log(`正在获取第 ${pageCount + 1} 页...`);
// 复制到的fetch 方法粘贴到这里
// const response = await fetch(xxxxx)
const response = await

const data = await response.json();
allData = allData.concat(data.data.files);
nextToken = data.data.nextToken;
pageCount++;
console.log(`已获取 ${allData.length} 个项目...\n`);
} while (nextToken);

// 按照 created_at 时间降序排序数据
allData.sort((a, b) => new Date(b.created_at) - new Date(a.created_at));

return allData;
}

fetchAllPagesWithProgress().then(data => {
fs.writeFileSync('output.json', JSON.stringify(data, null, 2));
console.log('数据已写入 output.json');
}).catch(error => {
console.error(error);
});

```

### 3、将复制到的```fetch```方法粘贴到js中
```js
const response = await fetch(`https://unicloud-api.dcloud.net.cn/unicloud/api/file/list?%2F&mode=DIRECTORY${nextToken ? `&nextToken=${nextToken}` : ''}`, {
headers: {
accept: 'application/json, text/plain, */*',
'accept-language': 'zh-CN,zh;q=0.9',
'cache-control': 'no-cache',
pragma: 'no-cache',
'sec-ch-ua': '"Google Chrome";v="123", "Not:A-Brand";v="8", "Chromium";v="123"',
'sec-ch-ua-mobile': '?0',
'sec-ch-ua-platform': '"macOS"',
'sec-fetch-dest': 'empty',
'sec-fetch-mode': 'cors',
'sec-fetch-site': 'same-site',
token: 'token',
Referer: 'https://unicloud.dcloud.net.cn/',
'Referrer-Policy': 'strict-origin-when-cross-origin',
},
method: 'GET',
body: null,
});
```
### 4、改造fetch方法的url
将```&nextToken=```修改为：${nextToken ? `&nextToken=${nextToken}` : ''}`
将```pageSize=20```修改为： ```100```
### 5、npm i 安装axios、发起请求


** 插入的附件 **

** 插入的附件 **

## 支付宝前端托管，暂时不支持删除非空文件夹。如果想递归删除所有文件。可以通过以下JS来实现

# 1、进入需要删除的目录（```这一步很重要，用于确定要删除的根目录，别搞错了```。否则 ```rm -rf /``` 就G了）
** 插入的附件 **
## 2、在```network``` 中找到```https://unicloud-api.dcloud.net.cn/unicloud/api/host/file-list```这个接口，右击 ```copy``` - ```Copy as Fetch```

** 插入的附件 **

## 2、创建一个js, 复制下方js

```
async function recursiveDelete(initialUrl, { headers: initialHeaders }) {
const urlParams = new URL(initialUrl).searchParams;
const commonParams = {
appid: urlParams.get('appid') || "",
provider: urlParams.get('provider') || "",
spaceId: urlParams.get('spaceId') || ""
};
const rootFolder = urlParams.get('folder');

async function makeRequest(url, options = {}) {
try {
const response = await fetch(url, {
headers: {
...initialHeaders,
'Content-Type': 'application/json;charset=UTF-8',
...options.headers
},
...options
});
return await response.json();
} catch (error) {
console.error(`请求错误:`, error.message);
return null;
}
}

function normalizePath(path) {
return path.startsWith('/') ? path.slice(1) : path;
}

async function deleteFile(file, folderPath) {
console.log('{ 【 folderPath 】 }:>>>>>>>>>>>> createFold.js:32', folderPath);
const normalizedPath = `${folderPath}${`/${folderPath}` === rootFolder ? '/' : ''}${file.name}`;
console.log(`尝试删除文件: ${normalizedPath}`);

const deleteResponse = await makeRequest('https://unicloud-api.dcloud.net.cn/unicloud/api/host/delete-file', {
method: 'POST',
body: JSON.stringify({ ...commonParams, fileId: file.id, filePath: normalizedPath })
});

if (deleteResponse?.ret === 0) {
console.log(`成功删除文件: ${normalizedPath}`);
return true;
}
console.error(`删除文件失败: ${normalizedPath}，错误信息：${deleteResponse}`);
return false;
}

async function processFolder(folderUrl) {
console.log(`处理文件夹: ${folderUrl}`);
const listResponse = await makeRequest(folderUrl);

if (!listResponse || listResponse.ret !== 0) {
console.error(`无法列出文件夹内容: ${folderUrl}`);
return false;
}

const { directories, files } = listResponse.data;
const currentFolder = normalizePath(new URL(folderUrl).searchParams.get('folder'));

console.log(`文件夹 ${currentFolder} 包含 ${files.length} 个文件和 ${directories.length} 个子文件夹`);

await Promise.all(files.map(file => deleteFile(file, currentFolder)));

await Promise.all(directories.map(dir =>
processFolder(folderUrl.replace(/folder=[^&]+/, `folder=${encodeURIComponent(dir.prefix)}`))
));

await deleteFolderAttempt(currentFolder);
}

async function deleteFolderAttempt(folderPath) {
const normalizedPath = normalizePath(folderPath);
console.log(`尝试删除文件夹: ${normalizedPath}`);

const deleteResponse = await makeRequest('https://unicloud-api.dcloud.net.cn/unicloud/api/host/delete-directory', {
method: 'POST',
body: JSON.stringify({ ...commonParams, folder: normalizedPath })
});

if (deleteResponse && deleteResponse.ret === 0) {
console.log(`成功删除文件夹: ${normalizedPath}`);
} else {
console.log(`无法删除文件夹: ${normalizedPath}，错误信息：${deleteResponse}`);
}
}

await processFolder(initialUrl);
console.log('递归删除过程完成');
}

```
## 3、将复制到的```fetch```方法粘贴到js中,并将```fetch```方法名修改为```recursiveDelete```

```
recursiveDelete("https://unicloud-api.dcloud.net.cn/unicloud/api/host/file-list?appid=&provider=alipay&spaceId=", {
"headers": {
"accept": "application/json, text/plain, */*",
"accept-language": "zh-CN,zh;q=0.9",
"cache-control": "no-cache",
"pragma": "no-cache",
"priority": "u=1, i",
"sec-ch-ua": "\"Chromium\";v=\"130\", \"Google Chrome\";v=\"130\", \"Not?A_Brand\";v=\"99\"",
"sec-ch-ua-mobile": "?0",
"sec-ch-ua-platform": "\"macOS\"",
"sec-fetch-dest": "empty",
"sec-fetch-mode": "cors",
"sec-fetch-site": "same-site",
"token": ""
},
"referrer": "https://unicloud.dcloud.net.cn/",
"referrerPolicy": "strict-origin-when-cross-origin",
"body": null,
"method": "GET",
"mode": "cors",
"credentials": "include"
});

```
## 5、执行此方法
```
node recursiveDelete.js
```

** 插入的附件 **


## 备注：为了验证这个脚本的可用性。可以先创建一个文件夹来测试。这里附上一个```shell```用于创建复杂嵌套的目录结构供参考
```
#!/bin/bash

# 设置基本参数
BASE_DIR="highly_complex_nested_structure"
MAX_DEPTH=7
MIN_DEPTH=2
MIN_FILES=1
MAX_FILES=5
MIN_FOLDERS=1
MAX_FOLDERS=5
MIN_SIBLING_FOLDERS=2
MAX_SIBLING_FOLDERS=5

# 创建基础目录
mkdir -p $BASE_DIR
cd $BASE_DIR

# 创建.gitignore文件
cat << EOF > .gitignore
*.log
*.tmp
.DS_Store
node_modules/
*.swp
EOF

generate_lorem_ipsum() {
local words=$1
curl -s "https://loripsum.net/api/1/short/plaintext" | tr -d '\n' | cut -d' ' -f1-$words | sed 's/$/\./'
}

create_random_file() {
local dir=$1
local file_type=$2
local filename

case $file_type in
"text")
filename=$(openssl rand -hex 8).txt
generate_lorem_ipsum 50 > "$dir/$filename"
;;
"markdown")
filename=$(openssl rand -hex 8).md
cat << EOF > "$dir/$filename"
# $(generate_lorem_ipsum 3)

## $(generate_lorem_ipsum 4)

$(generate_lorem_ipsum 20)

## $(generate_lorem_ipsum 4)

- $(generate_lorem_ipsum 5)
- $(generate_lorem_ipsum 5)
- $(generate_lorem_ipsum 5)

### $(generate_lorem_ipsum 3)

$(generate_lorem_ipsum 30)
EOF
;;
"json")
filename=$(openssl rand -hex 8).json
cat << EOF > "$dir/$filename"
{
"id": "$RANDOM",
"name": "$(generate_lorem_ipsum 2)",
"description": "$(generate_lorem_ipsum 10)",
"details": {
"category": "$(generate_lorem_ipsum 1)",
"tags": [
"$(generate_lorem_ipsum 1)",
"$(generate_lorem_ipsum 1)",
"$(generate_lorem_ipsum 1)"
],
"created_at": "$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
},
"is_active": $( (( RANDOM % 2 )) && echo "true" || echo "false" )
}
EOF
;;
"image")
filename=$(openssl rand -hex 8).svg
local colors=("red" "blue" "green" "yellow" "purple" "orange")
local color=${colors[$RANDOM % ${#colors[@]}]}
local shape=$((RANDOM % 3))
case $shape in
0) # Circle
cat << EOF > "$dir/$filename"
<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
<circle cx="50" cy="50" r="40" stroke="black" stroke-width="3" fill="$color" />
</svg>
EOF
;;
1) # Rectangle
cat << EOF > "$dir/$filename"
<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
<rect width="80" height="80" x="10" y="10" stroke="black" stroke-width="3" fill="$color" />
</svg>
EOF
;;
2) # Triangle
cat << EOF > "$dir/$filename"
<svg width="100" height="100" xmlns="http://www.w3.org/2000/svg">
<polygon points="50,10 10,90 90,90" stroke="black" stroke-width="3" fill="$color" />
</svg>
EOF
;;
esac
;;
esac

echo "Created $file_type file: $dir/$filename"
}

create_files_in_folder() {
local current_path=$1
local num_files=$((RANDOM % (MAX_FILES - MIN_FILES + 1) + MIN_FILES))

for ((i=1; i<=num_files; i++)); do
local file_type=$((RANDOM % 4))
case $file_type in
0) create_random_file "$current_path" "text" ;;
1) create_random_file "$current_path" "markdown" ;;
2) create_random_file "$current_path" "json" ;;
3) create_random_file "$current_path" "image" ;;
esac
done

# 随机创建隐藏文件或文件夹
if [ $((RANDOM % 4)) -eq 0 ]; then
if [ $((RANDOM % 2)) -eq 0 ]; then
local hidden_file=".hidden_file_$RANDOM"
generate_lorem_ipsum 20 > "${current_path}/${hidden_file}"
echo "Created hidden file: ${current_path}/${hidden_file}"
else
local hidden_folder=".hidden_folder_$RANDOM"
mkdir -p "${current_path}/${hidden_folder}"
create_files_in_folder "${current_path}/${hidden_folder}"
echo "Created hidden folder: ${current_path}/${hidden_folder}"
fi
fi
}

create_nested_structure() {
local current_depth=$1
local current_path=$2
local max_depth=$((MIN_DEPTH + RANDOM % (MAX_DEPTH - MIN_DEPTH + 1)))

if [ $current_depth -gt $max_depth ]; then
return
fi

# 确保当前文件夹有内容
create_files_in_folder "$current_path"

# 创建子文件夹并递归
local num_folders=$((RANDOM % (MAX_FOLDERS - MIN_FOLDERS + 1) + MIN_FOLDERS))
for ((i=1; i<=num_folders; i++)); do
local sub_folder="folder_${current_depth}_${i}"
local new_path="${current_path}/${sub_folder}"
mkdir -p "$new_path"
echo "Created folder: $new_path"
create_nested_structure $((current_depth + 1)) "$new_path"
done

# 创建平级文件夹
local num_sibling_folders=$((RANDOM % (MAX_SIBLING_FOLDERS - MIN_SIBLING_FOLDERS + 1) + MIN_SIBLING_FOLDERS))
for ((i=1; i<=num_sibling_folders; i++)); do
local sibling_folder="sibling_${current_depth}_${i}"
local sibling_path="${current_path}/${sibling_folder}"
mkdir -p "$sibling_path"
echo "Created sibling folder: $sibling_path"
create_files_in_folder "$sibling_path"
done
}

create_complex_structure() {
local base_path=$1
local num_main_branches=$((RANDOM % (MAX_SIBLING_FOLDERS - MIN_SIBLING_FOLDERS + 1) + MIN_SIBLING_FOLDERS))

for ((i=1; i<=num_main_branches; i++)); do
local branch_name="main_branch_${i}"
local branch_path="${base_path}/${branch_name}"
mkdir -p "$branch_path"
echo "Created main branch: $branch_path"
create_nested_structure 1 "$branch_path"
done
}

# 开始创建目录
create_complex_structure "."
```

问题1已修复，更新uni-pay插件，重新上传uni-pay公共模块即可

问题2是支付宝云bug，数据库执行 _.unshift 会报错， 如果比较急，可以先把 _.unshift 改成 _.push 支付宝云预计1个月内会修复

HBuilderX 4.41.2024121203-alpha 已修复。

问题已确认，已反馈支付宝云排查修复。

排查下你用户的token的数组长度是不是很长，这个会导致写入变多。因为1KB = 1次写入

因为uni-id-users表有字段级别的权限，比如password，token等等，所以无法这样查询，需要写明你要获取的字段名，然后字段名不可包含password等

如：
```js
let dbRes = await dbJQL.collection("uni-id-users").where({
'wx_openid.mp': openid
}).field({
'_id': true,
'nickname': true
}).get();
```