1676 lines
40 KiB
JavaScript
1676 lines
40 KiB
JavaScript
// 云端基础URL
|
||
const BASE_URL = 'https://cloud.yuxindazhineng.com'
|
||
// const BASE_URL = 'https://cloudtest.yuxindazhineng.com'
|
||
// const BASE_URL = 'https://yxdpqj.yuxindazhineng.com'
|
||
|
||
// 登录请求
|
||
export const login = async (username, password) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/login`,
|
||
method: "POST",
|
||
data: {
|
||
"username": username,
|
||
"password": password,
|
||
"login_type": "phone"
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const token = res.data.access_token
|
||
if (token) {
|
||
uni.setStorageSync('token', token)
|
||
resolve(token)
|
||
} else {
|
||
const msg = res.data.error || '检查用户名和密码'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`请求失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 历史会话请求
|
||
export const getUserConversations = async (token) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/get_user_conversations`,
|
||
method: "POST",
|
||
data: {
|
||
"access_token": token
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const conversations = res.data.conversations
|
||
resolve(conversations)
|
||
|
||
} else {
|
||
reject(`请求失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 获取与AI的对话内容
|
||
export const getConversationMessages = async (token, conversatio_id) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/get_conversation_messages`,
|
||
method: 'POST',
|
||
data: {
|
||
"access_token": token,
|
||
"login_type": "phone",
|
||
"conversation_id": conversatio_id
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const messagesInfo = res.data
|
||
if (messagesInfo) {
|
||
console.log("工作区id为：", messagesInfo.workspace_id || '(无)');
|
||
if (messagesInfo.workspace_id) {
|
||
uni.setStorageSync('workspace_id', messagesInfo.workspace_id)
|
||
}
|
||
resolve(messagesInfo.messages)
|
||
} else {
|
||
const msg = res.data.error || '获取消息出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`请求失败：${res.statusCode}`)
|
||
}
|
||
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 用户发送消息（ai不接收/回复）
|
||
export const addMessageDict = async (token, role, conversation_id, message) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/add_message_dict`,
|
||
method: "POST",
|
||
data: {
|
||
"access_token": token,
|
||
"conversation_id": conversation_id,
|
||
"message": {
|
||
"role": role,
|
||
"content": message
|
||
}
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const message_id = res.data.message_id
|
||
if (message_id) {
|
||
resolve(message_id)
|
||
} else {
|
||
const msg = res.data.error || '用户发送消息出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`用户发送失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 获取工作区信息（非内容）
|
||
export const getWorkspaceByConversation = async (token, conversation_id) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/get_workspace_by_conversation`,
|
||
method: "POST",
|
||
data: {
|
||
"access_token": token,
|
||
"conversation_id": conversation_id
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const workspaceInfo = res.data
|
||
if (workspaceInfo?.success) {
|
||
resolve(workspaceInfo.workspace_id)
|
||
} else {
|
||
const msg = res.data.error || '获取工作区信息出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取工作区信息失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
|
||
|
||
})
|
||
}
|
||
|
||
|
||
// 创建工作区id
|
||
export const createWorkspace = async (token, name) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/create_workspace`,
|
||
method: "POST",
|
||
data: {
|
||
"access_token": token,
|
||
"name": name
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const workspaceId = res.data.workspace_id
|
||
if (workspaceId) {
|
||
resolve(workspaceId)
|
||
} else {
|
||
const msg = res.data.error || '创建工作区id出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`创建工作区id失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 创建新对话
|
||
export const createConversation = async (token, workspaceId, title, sender) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/create_conversation`,
|
||
method: "POST",
|
||
data: {
|
||
"access_token": token,
|
||
"workspace_id": workspaceId,
|
||
"title": title,
|
||
"sender": sender
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const conversationId = res.data.conversation_id
|
||
if (conversationId) {
|
||
resolve(conversationId)
|
||
} else {
|
||
const msg = res.data.error || '创建新对话id出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`创建新对话失败：${res.statusCode}`)
|
||
}
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
// 删除会话
|
||
export const deleteConversation = async (token, conversation_ids) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/delete_conversation`,
|
||
method: "POST",
|
||
data: {
|
||
"access_token": token,
|
||
"conversation_ids": conversation_ids
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond?.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond.failed_ids.error || '删除对话出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`删除对话失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 获取用户信息
|
||
export const getUserInfo = async (token) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/get_user_info`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond?._id) {
|
||
uni.setStorageSync('userId', respond._id)
|
||
resolve(respond)
|
||
} else {
|
||
const msg = respond?.detail?.[0]?.msg || '获取用户信息出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取用户信息失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 获取用户头像（自己or好友组）
|
||
export const getUserAvatar = (token, userIds) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/get_user_avatar`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"user_ids": userIds
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.users)
|
||
} else {
|
||
const msg = respond?.error || '获取用户头像出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取用户头像失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
// 通过用户名或邮箱来去查询用户
|
||
export const searchUsers = (token, keyword) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/search_users`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"keyword": keyword
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.users)
|
||
} else {
|
||
const msg = respond?.error || '通过用户名或邮箱来去查询用户出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`通过用户名或邮箱来去查询用户失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 工作区
|
||
// 获取工作区文件目录
|
||
export const getWorkspaceList = (token, workspacesId) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/phone/workspace/list`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"workspaces_id": workspacesId,
|
||
"format": "tree",
|
||
"parent_path": "",
|
||
"filter_type": ""
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.data)
|
||
} else {
|
||
const msg = respond?.error || '获取工作区文件目录出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取工作区文件目录失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 删除工作区文件
|
||
export const daleteWorkspace = (token, workspacesId, path) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/phone/workspace/delete`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"workspaces_id": workspacesId,
|
||
"file_path": path
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '删除工作区文件出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`删除工作区文件失败：${res.statusCode}`)
|
||
}
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 创建工作区文件夹（目录）
|
||
export const createWorkspaceFolder = (token, workspacesId, path) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/phone/workspace/create`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"workspaces_id": workspacesId,
|
||
"dir_path": path
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '创建工作区文件夹出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`创建工作区文件夹失败：${res.statusCode}`)
|
||
}
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 获取工作区文件的URL
|
||
export const getWorkspaceFileURL = (token, workspacesId, path) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/phone/workspace/downloadFile`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"workspaces_id": workspacesId,
|
||
"file_path": path
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
// 兼容两种返回格式：{success: true, message: [...]} 或直接返回数组
|
||
if (respond.success) {
|
||
resolve(respond.message || respond.data)
|
||
} else if (Array.isArray(respond)) {
|
||
resolve(respond)
|
||
} else {
|
||
const msg = respond?.error || '获取工作区文URL出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取工作区文URL失败：${res.statusCode}`)
|
||
}
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 上传文件（通过url）到工作区
|
||
export const workspaceUploadFileByURL = (token, workspacesId, urls, dirPath) => {
|
||
return new Promise((resolve, reject) => {
|
||
// urls 支持字符串或数组
|
||
const urlList = Array.isArray(urls) ? urls : (urls ? [urls] : []);
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/phone/workspace/upload`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"workspaces_id": workspacesId,
|
||
"dir_path": dirPath || '/',
|
||
"urls": urlList
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data;
|
||
// 接口返回: { success, total_files, success_count, failed_count, results: [{ url, success, error }], summary }
|
||
if (respond.success) {
|
||
resolve(respond);
|
||
} else {
|
||
// 部分/全部失败时，收集失败信息
|
||
const failedItems = (respond.results || [])
|
||
.filter(r => !r.success)
|
||
.map(r => r.error || '未知错误');
|
||
const msg = failedItems.length > 0
|
||
? `上传失败 ${respond.failed_count}/${respond.total_files}：${failedItems[0]}`
|
||
: (respond.summary || respond?.error || '上传文件到工作区出错啦');
|
||
reject(msg);
|
||
}
|
||
} else {
|
||
reject(`上传文件到工作区失败：${res.statusCode}`);
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误';
|
||
reject(msg);
|
||
}
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
|
||
// 上传文件（到短存云端）获取URL
|
||
// files: 文件数组，每个元素为 { path, name } 或字符串路径
|
||
// 返回格式: [{ url: "https://...", success: true }]
|
||
export const uploadFileToShortStorage = (workspacesId, files, filePath) => {
|
||
return new Promise((resolve, reject) => {
|
||
// 统一转为文件数组
|
||
const fileList = Array.isArray(files) ? files : [files];
|
||
|
||
// 构建 files 数组供 uni.uploadFile 使用
|
||
const uploadFiles = fileList.map((file) => {
|
||
const fileUri = typeof file === 'string' ? file : (file.tempFilePath || file.path || file);
|
||
return {
|
||
name: 'files',
|
||
uri: fileUri
|
||
};
|
||
});
|
||
|
||
console.log('uploadFileToShortStorage 参数:', { workspacesId, fileCount: uploadFiles.length, filePath });
|
||
|
||
uni.uploadFile({
|
||
url: `${BASE_URL}/cloud_api/file/temp/upload`,
|
||
method: "POST",
|
||
formData: {
|
||
workspaces_id: workspacesId,
|
||
file_path: filePath || '/',
|
||
overwrite: 'true'
|
||
},
|
||
files: uploadFiles,
|
||
success: (res) => {
|
||
console.log('uploadFileToShortStorage 响应状态:', res.statusCode, '数据:', res.data);
|
||
if (res.statusCode === 200) {
|
||
try {
|
||
const respond = JSON.parse(res.data);
|
||
// 接口返回 [{ url, success }] 数组
|
||
if (Array.isArray(respond) && respond.length > 0) {
|
||
// 返回完整的 results 数组，调用方可遍历
|
||
resolve(respond);
|
||
} else if (respond.success) {
|
||
// 兼容 { success: true, url: "..." } 格式
|
||
resolve([{ url: respond.url || respond.message, success: true }]);
|
||
} else {
|
||
const msg = respond?.error || respond?.message || '上传文件（到短存云端）获取URL出错啦';
|
||
reject(msg);
|
||
}
|
||
} catch (e) {
|
||
reject('接口返回数据格式异常: ' + res.data);
|
||
}
|
||
} else {
|
||
reject(`上传文件（到短存云端）获取URL失败：${res.statusCode} - ${res.data}`);
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误';
|
||
reject(msg);
|
||
}
|
||
});
|
||
});
|
||
};
|
||
|
||
// 重命名工作区文件/文件夹(电脑端)
|
||
export const updateWorkspaceFileName = (token, workspacesId, oldPath, newName) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/workspace/file/rename`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"workspaces_id": workspacesId,
|
||
"file_path": oldPath,
|
||
"new_name": newName
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data;
|
||
if (respond.success) {
|
||
resolve(respond.message || respond);
|
||
} else {
|
||
const msg = respond?.error || '重命名工作区文件出错啦';
|
||
reject(msg);
|
||
}
|
||
} else {
|
||
reject(`重命名工作区文件失败：${res.statusCode}`);
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误';
|
||
reject(msg);
|
||
}
|
||
});
|
||
});
|
||
};
|
||
|
||
// 上传用户头像
|
||
export const uploadUserAvatar = (token, userId, username, email, avatarURL) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/user/file/upload`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"file": file,
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.upload_url)
|
||
} else {
|
||
const msg = respond?.error || '上传用户头像出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`上传用户头像失败：${res.statusCode}`)
|
||
}
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
// 修改用户信息
|
||
export const updateUserInfo = (token, userId, username, email, avatarURL) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/update_user_profile`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"user_id": userId,
|
||
"username": username,
|
||
"email:": email,
|
||
"avatar": avatarURL
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '修改用户信息出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`修改用户信息失败：${res.statusCode}`)
|
||
}
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// ============================云端文件管理=========================
|
||
// 获取云端个人/团队文件列表
|
||
export const getCloudFileList = (token, type, path = "/", teamId = "") => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/file/list`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"path": path,
|
||
"type": type,
|
||
"team_id": teamId
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.data)
|
||
} else {
|
||
const msg = respond?.error || '获取工作区文件目录出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取工作区文件目录失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 下载云端文件，通过文件id获取下载url
|
||
export const getCloudFileUrl = (token, fileId) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/file/download`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"file_id": fileId,
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.data.download_url)
|
||
} else {
|
||
const msg = respond?.error || '获取云端文件url出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取云端文件url失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
// 删除云端文件
|
||
export const deleteCloudFile = (token, fileId) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/file/delete`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"file_id": fileId
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '删除云端文件出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`删除云端文件失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 批量上传云端文件
|
||
export const uploadCloudFile = (token, type, path, files, team_id) => {
|
||
return new Promise((resolve, reject) => {
|
||
// 处理参数：team_id 转为字符串，空值置空
|
||
const teamIdStr = team_id == null ? "" : String(team_id);
|
||
|
||
uni.uploadFile({
|
||
url: `${BASE_URL}/cloud_api/file/upload`,
|
||
method: "POST",
|
||
// 不要手动设置 Content-Type，浏览器自动生成 multipart/form-data
|
||
header: {
|
||
// 如果后端把token放header就写这里，放表单里就写到formData
|
||
},
|
||
// 普通文本参数（对应form-data里的文本项）
|
||
formData: {
|
||
access_token: token,
|
||
path: path || "/",
|
||
type: type,
|
||
team_id: teamIdStr
|
||
},
|
||
// 多文件：每个文件name都叫files，和Postman保持一致
|
||
files: files.map(fileItem => ({
|
||
uri: fileItem.tempFilePath, // 文件本地临时路径
|
||
name: "files"
|
||
})),
|
||
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
try {
|
||
const respond = JSON.parse(res.data);
|
||
if (respond.success) {
|
||
resolve(respond.message);
|
||
} else {
|
||
const msg = respond?.error || '获取云端文件url出错啦';
|
||
reject(msg);
|
||
}
|
||
} catch (e) {
|
||
reject("接口返回数据格式异常");
|
||
}
|
||
} else {
|
||
reject(`获取云端文件url失败：${res.statusCode}`);
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误';
|
||
reject(msg);
|
||
}
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
// 获取用户可访问的团队列表
|
||
export const getTeamList = async (token) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/team/list`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
access_token: token,
|
||
team_name: ""
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
const teamsList = respond.teams
|
||
// 去掉第1条数据（系统团队），从下标1开始截取剩余所有
|
||
const newList = teamsList.slice(1)
|
||
resolve(newList)
|
||
} else {
|
||
const msg = res.data.error || '获取用户可访问的团队列表出错啦'
|
||
reject(msg)
|
||
}
|
||
|
||
} else {
|
||
reject(`获取用户可访问的团队列表失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 获取团队全部成员
|
||
export const getTeamAllMember = (token, teamId) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/team/get_all_member`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"team_id": teamId
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
const members = respond.team?.result || []
|
||
resolve(members)
|
||
} else {
|
||
const msg = respond?.error || '获取团队全部成员出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取团队全部成员失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
// 删除团队
|
||
export const deleteTeam = (token, teamId) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/team/delete`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"team_id": teamId
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '删除团队出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`删除团队失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 添加团队成员
|
||
export const addTeamMember = (token, teamId, userIds) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/team/add_member`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"team_id": teamId,
|
||
"user_ids": userIds,
|
||
"role": "admin"
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '添加团队成员出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`添加团队成员失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 修改团队信息
|
||
export const updateTeamInfo = (token, teamId, data) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/team/update`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"team_id": teamId,
|
||
...data
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '修改团队信息出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`修改团队信息失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 移除团队成员
|
||
export const removeTeamMember = (token, teamId, userIds) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/team/remove_member`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"team_id": teamId,
|
||
"user_ids": userIds
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '移除团队成员出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`移除团队成员失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 调整团员身份
|
||
export const updateTeamMemberRole = (token, teamId, userId, role) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/team/adjust_member_role`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"team_id": teamId,
|
||
"user_id": userId,
|
||
"role": role
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '调整团员身份出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`调整团员身份失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// ============================云端数据库=========================
|
||
|
||
// 获取用户可访问的数据库列表
|
||
export const getCloudDbList = (token) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/list`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
// "databases": [
|
||
// {
|
||
// "database_name": "测试3",
|
||
// "table_count": 0,
|
||
// "file_path": "/home/yxd/yxd-agent-cloud/databases/6a446df3060ba5feae589c22.db",
|
||
// "modified_time": 1782869492.6399229,
|
||
// "database_id": "6a446df3060ba5feae589c22",
|
||
// "user_id": "690c72a6b8ffa329af2d5607",
|
||
// "access_level": 2
|
||
// },
|
||
// {
|
||
// "database_name": "database1",
|
||
// "table_count": 0,
|
||
// "file_path": "/home/yxd/yxd-agent-cloud/databases/6a446bfa1db19f3506901d2d.db",
|
||
// "modified_time": 1782868987.3745258,
|
||
// "database_id": "6a446bfa1db19f3506901d2d",
|
||
// "team_id": "6a02f6f0d99a03faefd1f437",
|
||
// "access_level": 2
|
||
// }
|
||
// ],
|
||
resolve(respond.databases)
|
||
} else {
|
||
const msg = respond?.error || '获取用户可访问的数据库列表出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取用户可访问的数据库列表失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 创建数据库(仅个人可创建)
|
||
export const createCloudDb = (token, databaseName) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/create`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"database_name": databaseName
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '创建数据库出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`创建数据库失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 上传db文件（.db / .sqlite 等数据库文件）
|
||
export const uploadCloudDbFile = (token, filePath) => {
|
||
return new Promise((resolve, reject) => {
|
||
// filePath 可能是字符串路径或 { tempFilePath, name } 对象
|
||
const fileUri = typeof filePath === 'string' ? filePath : (filePath.tempFilePath || filePath.path ||
|
||
filePath);
|
||
const fileName = typeof filePath === 'string' ?
|
||
filePath.split('/').pop() || 'database.db' :
|
||
(filePath.name || 'database.db');
|
||
|
||
uni.uploadFile({
|
||
url: `${BASE_URL}/cloud_api/database/upload/db`,
|
||
method: "POST",
|
||
header: {},
|
||
formData: {
|
||
access_token: token
|
||
},
|
||
file: {
|
||
name: fileName,
|
||
uri: fileUri
|
||
},
|
||
files: [{
|
||
name: 'file',
|
||
uri: fileUri
|
||
}],
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
try {
|
||
const respond = JSON.parse(res.data);
|
||
if (respond.success) {
|
||
resolve(respond.message);
|
||
} else {
|
||
const msg = respond?.error || '上传db出错啦';
|
||
reject(msg);
|
||
}
|
||
} catch (e) {
|
||
reject("接口返回数据格式异常");
|
||
}
|
||
} else {
|
||
reject(`上传db失败：${res.statusCode}`);
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误';
|
||
reject(msg);
|
||
}
|
||
});
|
||
});
|
||
};
|
||
|
||
|
||
|
||
// 删除数据库(仅个人可创建)
|
||
export const deleteCloudDb = (token, databaseId) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/delete`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"database_id": databaseId
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond?.error || '删除数据库出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`删除数据库失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 获取数据库中的表列表
|
||
export const getCloudDbTables = (token, databaseId, isDetail) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/tables`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"database_id": databaseId,
|
||
"is_detail": isDetail
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.tables)
|
||
} else {
|
||
const msg = respond?.error || '获取用户可访问的数据库列表出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取用户可访问的数据库列表失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 获取表数据
|
||
export const getCloudDbTableData = (token, databaseId, tableName, limit = "20", offset = "0") => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/table/data`,
|
||
method: "POST",
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
data: {
|
||
"access_token": token,
|
||
"database_id": databaseId,
|
||
"table_name": tableName,
|
||
"limit": limit,
|
||
"offset": offset
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond.success) {
|
||
resolve(respond.data)
|
||
} else {
|
||
const msg = respond?.error || '获取表数据出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`获取表数据失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
// 删除数据库中的表
|
||
export const deleteCloudDbTable = async (token, databaseId, tableName) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/table/drop`,
|
||
method: "POST",
|
||
data: {
|
||
"access_token": token,
|
||
"database_id": databaseId,
|
||
"table_name": tableName
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond?.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond.error || '删除数据库中的表出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`删除数据库中的表失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 更新表数据
|
||
export const updateCloudDbTableData = (token, databaseId, tableName, whereData, updateData) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/table/update/by/id`,
|
||
method: "POST",
|
||
data: {
|
||
"access_token": token,
|
||
"database_id": databaseId,
|
||
"table_name": tableName,
|
||
"where_data": whereData,
|
||
"update_data": updateData
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond?.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond.error || '更新表数据出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`更新表数据失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
|
||
// 导入文件到数据库
|
||
export const importFileToCloudDb = (token, forceOverwrite, databaseId, filePath, tableName) => {
|
||
return new Promise((resolve, reject) => {
|
||
// filePath 可能是字符串路径或 { tempFilePath, name } 对象
|
||
const fileUri = typeof filePath === 'string' ? filePath : (filePath.tempFilePath || filePath.path ||
|
||
filePath);
|
||
const fileName = typeof filePath === 'string' ?
|
||
filePath.split('/').pop() || 'file' :
|
||
(filePath.name || 'file');
|
||
|
||
uni.uploadFile({
|
||
url: `${BASE_URL}/cloud_api/database/import`,
|
||
method: "POST",
|
||
header: {},
|
||
formData: {
|
||
access_token: token,
|
||
force_overwrite: forceOverwrite,
|
||
database_id: databaseId,
|
||
table_name: tableName
|
||
},
|
||
// uni.uploadFile 的 file 参数需要是对象格式：{ name, uri }
|
||
file: {
|
||
name: fileName,
|
||
uri: fileUri
|
||
},
|
||
// 同时用 files 方式兜底
|
||
files: [{
|
||
name: 'file',
|
||
uri: fileUri
|
||
}],
|
||
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
try {
|
||
const respond = JSON.parse(res.data);
|
||
if (respond.success) {
|
||
resolve(respond.message);
|
||
} else {
|
||
const msg = respond?.error || '导入文件到数据库出错啦';
|
||
reject(msg);
|
||
}
|
||
} catch (e) {
|
||
reject("接口返回数据格式异常");
|
||
}
|
||
} else {
|
||
reject(`导入文件到数据库失败：${res.statusCode}`);
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误';
|
||
reject(msg);
|
||
}
|
||
});
|
||
});
|
||
};
|
||
|
||
// 查看 个人/团队 数据库权限信息
|
||
export const getCloudDbPermission = (token, databaseId, type, id) => {
|
||
return new Promise((resolve, reject) => {
|
||
const requestData = {
|
||
"access_token": token,
|
||
"database_id": databaseId
|
||
};
|
||
// type 只能是 user_id 或 team_id
|
||
if (type === 'user_id') {
|
||
requestData.user_id = id;
|
||
} else if (type === 'team_id') {
|
||
requestData.team_id = id;
|
||
}
|
||
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/permission/info`,
|
||
method: "POST",
|
||
data: requestData,
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond?.success) {
|
||
// team_id 格式: { success: true, data: [...] }
|
||
resolve(respond.data)
|
||
} else if (Array.isArray(respond)) {
|
||
// user_id 格式: 直接返回数组 [...]
|
||
resolve(respond)
|
||
} else {
|
||
const msg = respond?.error || '查看 个人/团队 数据库权限信息出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`查看 个人/团队 数据库权限信息失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 删除 团队/用户 对数据库权限
|
||
export const deleteCloudDbPermission = (token, databaseId, type, id) => {
|
||
return new Promise((resolve, reject) => {
|
||
const requestData = {
|
||
"access_token": token,
|
||
"database_id": databaseId
|
||
};
|
||
if (type === 'user_id') {
|
||
requestData.user_id = id;
|
||
} else if (type === 'team_id') {
|
||
requestData.team_id = id;
|
||
}
|
||
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/permission/delete`,
|
||
method: "POST",
|
||
data: requestData,
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond?.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond.error || '删除 团队/用户 对数据库权限出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`删除 团队/用户 对数据库权限失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 修改/增加 团队/用户 对数据库权限
|
||
export const updateCloudDbPermission = (token, databaseId, type, id, level) => {
|
||
return new Promise((resolve, reject) => {
|
||
const requestData = {
|
||
"access_token": token,
|
||
"database_id": databaseId,
|
||
"access_level": level
|
||
};
|
||
if (type === 'user_id') {
|
||
requestData.user_id = id;
|
||
} else if (type === 'team_id') {
|
||
requestData.team_id = id;
|
||
}
|
||
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/permission/update`,
|
||
method: "POST",
|
||
data: requestData,
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond?.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond.error || '修改/增加 团队/用户 对数据库权限出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`修改/增加 团队/用户 对数据库权限失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
}
|
||
|
||
// 个人数据库移交团队
|
||
export const dbTransferToTeam = async (token, databaseId, teamId) => {
|
||
return new Promise((resolve, reject) => {
|
||
uni.request({
|
||
url: `${BASE_URL}/cloud_api/database/transfer_to_team`,
|
||
method: "POST",
|
||
data: {
|
||
"access_token": token,
|
||
"database_id": databaseId,
|
||
"team_id": teamId
|
||
},
|
||
header: {
|
||
'Content-Type': 'application/json'
|
||
},
|
||
success: (res) => {
|
||
if (res.statusCode === 200) {
|
||
const respond = res.data
|
||
if (respond?.success) {
|
||
resolve(respond.message)
|
||
} else {
|
||
const msg = respond.error || '个人数据库移交团队出错啦'
|
||
reject(msg)
|
||
}
|
||
} else {
|
||
reject(`个人数据库移交团队失败：${res.statusCode}`)
|
||
}
|
||
},
|
||
fail: (err) => {
|
||
const msg = err.errMsg || '网络错误'
|
||
reject(msg)
|
||
}
|
||
})
|
||
})
|
||
} |