import {
|
Base64
|
} from 'js-base64';
|
import {
|
wxDecryptData
|
} from '@/common/WXBizDataCrypt.js'
|
|
import {
|
|
login as loginOrg,
|
loginWeChat,
|
loginDingTalk,
|
getDingToken,
|
getWeChatToken,
|
getFileSvrInfo
|
|
} from "./org.js"
|
import {
|
httpRequest,
|
} from "./gungho/index.js"
|
import {
|
token as tokenFeishu,
|
accesstoken as accesstokenFeishu,
|
getCode as getCodeFeishu,
|
getUserInfo as getUserInfoFeishu,
|
|
} from "./request/feishu.js"
|
import {
|
getAuthCode as getDingAuthCode,
|
|
} from "./request/ding.js"
|
|
import {
|
getCode as getCodeWxQy,
|
checkSession as checkSessionWxQy,
|
getMobile as getMobileWxQy,
|
|
} from "./request/wxqy.js"
|
|
import {
|
getUploadUrl,
|
putFile,
|
uploadTask,
|
callback,
|
getDownloadUrl
|
|
} from "./request/minio.js"
|
|
|
export const getDingAutoLoginInfo = () => {
|
return new Promise(async (resolve, reject) => {
|
try {
|
const app = getApp()
|
|
const code = await getDingAuthCode() || ""
|
const tokenRes = await getDingToken()
|
const access_token = tokenRes.token || ""
|
if (!access_token) {
|
return reject("服务端没有配置钉钉应用相关信息，请联系管理员配置！")
|
}
|
app.globalData.dingding = {
|
access_token: access_token,
|
authCode: code,
|
}
|
let sUrl =
|
`https://oapi.dingtalk.com/topapi/v2/user/getuserinfo?access_token=${access_token}`
|
let dataStr = `code=${code}`
|
|
let res = await httpRequest(sUrl, "POST", dataStr)
|
const userId = res.userid || ""
|
|
dataStr = `userid=${userId}`
|
sUrl = `https://oapi.dingtalk.com/topapi/v2/user/get?access_token=${access_token}`
|
const user = await httpRequest(sUrl, "POST", dataStr) || {}
|
if (user.mobile) {
|
let sMobile = user.mobile
|
let nFind = user.mobile.indexOf("+86");
|
if (nFind == 0) {
|
sMobile = user.mobile.substr(3)
|
}
|
resolve({
|
user_id: user.userid,
|
mobile: sMobile
|
})
|
|
} else {
|
reject("你没有获取用户ID和手机号权限，请联系管理员开通！")
|
}
|
|
} catch (ex) {
|
reject(ex)
|
}
|
})
|
}
|
|
/**
|
* 钉钉用户自动登录
|
* @returns
|
*/
|
|
export const autoLoginDing = () => {
|
return new Promise(async (resolve, reject) => {
|
try {
|
let info = await getDingAutoLoginInfo()
|
let res = await loginDingTalk(info.user_id, info.mobile)
|
res.mobile = info.mobile
|
res.user_id = info.user_id
|
resolve(res)
|
} catch (ex) {
|
reject(ex)
|
}
|
})
|
}
|
/**
|
* 飞书用户自动登录
|
* @returns
|
*/
|
export const autoLoginFeiShu = () => {
|
return new Promise(async (resolve, reject) => {
|
try {
|
const app = getApp()
|
const code = await getCodeFeishu()
|
const token = await tokenFeishu()
|
if (!token) {
|
return reject("访问飞书失败，请联系小程序开发商！")
|
}
|
const access_token = await accesstokenFeishu(code, token) || ""
|
if (!access_token) {
|
return reject("访问飞书失败，请联系小程序开发商！")
|
}
|
const user = await getUserInfoFeishu(access_token)
|
if (user.mobile) {
|
let sMobile = user.mobile
|
let nFind = user.mobile.indexOf("+86");
|
if (nFind == 0) {
|
sMobile = user.mobile.substr(3)
|
}
|
const res3 = await loginWeChat(user.user_id, sMobile)
|
res3.mobile = sMobile
|
res3.user_id = user.user_id
|
resolve(res3)
|
} else {
|
return reject("你没有获取用户ID和手机号权限，请联系管理员开通！")
|
}
|
|
} catch (ex) {
|
reject(ex)
|
}
|
})
|
}
|
|
/**
|
* 企业微信用户自动登录
|
* @returns
|
*/
|
export const loginWxQy = () => {
|
return new Promise(async (resolve, reject) => {
|
try {
|
const app = getApp()
|
const code = await getCodeWxQy()
|
const tokenRes = await getWeChatToken()
|
const token = tokenRes.token || ""
|
if (!token) {
|
return reject("服务端没有配置企业微信应用相关信息，请联系管理员配置！")
|
}
|
let sUrl =
|
'https://qyapi.weixin.qq.com/cgi-bin/miniprogram/jscode2session?access_token=' +
|
token + '&js_code=' + code + '&grant_type=authorization_code'
|
let dataStr = `code=${code}`
|
const resWx = await httpRequest(sUrl) || {}
|
app.globalData.qyWx.userid = resWx.userid
|
app.globalData.qyWx.session_key = resWx.session_key
|
resolve(resWx)
|
} catch (ex) {
|
reject(ex)
|
}
|
})
|
}
|
|
|
/**
|
* 企业微信用户自动登录
|
* @returns
|
*/
|
export const autoLoginWxQy = () => {
|
return new Promise(async (resolve, reject) => {
|
try {
|
const app = getApp()
|
const bRet = await checkSessionWxQy()
|
if (!bRet) {
|
await loginWxQy()
|
}
|
const res = await getMobileWxQy()
|
const res2 = await wxDecryptData(app.globalData.appid, app.globalData.qyWx
|
.session_key, res
|
.encryptedData, res.iv)
|
const res3 = await loginWeChat(app.globalData.qyWx.userid, res2.mobile)
|
res3.mobile = res2.mobile
|
res3.user_id = user.user_id
|
resolve(res3)
|
} catch (ex) {
|
reject(ex)
|
}
|
})
|
}
|
|
|
/**
|
* 上传文件至minio
|
* @param {*} file
|
*/
|
export const uploadFile3 = (file) => {
|
return new Promise(async (resolve, reject) => {
|
try {
|
// 准备用户信息
|
const app = getApp()
|
const userInfo = app.globalData.userdata
|
// 得到文件服务器信息
|
let fileSFlag = app.globalData.files_flag || userInfo.files_info?.flag
|
const fileSvrInfo = await getFileSvrInfo(fileSFlag)
|
// 准备文件信息
|
let md5 = file.md5
|
// 得到接口地址
|
let ip = fileSvrInfo.exter_ip || fileSvrInfo?.inter_ip
|
let port = fileSvrInfo.exter_port || fileSvrInfo?.inter_port
|
let isSSL = fileSvrInfo?.is_ssl || false
|
let svrUrl = `${isSSL?'https':'http'}://${ip}:${port}`
|
|
if (!ip) throw new Error(`文件服务器“${fileSFlag}”配置不正确，exter_ip为空`)
|
if (!port) throw new Error(`文件服务器“${fileSFlag}”配置不正确，exter_port为空`)
|
// 得到文件上传地址
|
|
|
let uploadUrlInfo = await getUploadUrl(svrUrl, Base64.encode(JSON.stringify(fileSvrInfo
|
.minio)), file
|
.name)
|
// 上传文件
|
|
await putFile(uploadUrlInfo.uldurl, file)
|
|
let res = await callback(
|
svrUrl,
|
uploadUrlInfo.savepath,
|
file.size,
|
file.name,
|
md5,
|
userInfo.user_login,
|
userInfo.user_name,
|
fileSvrInfo.minio.access,
|
fileSvrInfo.minio.secret
|
)
|
// 文件id
|
let {
|
id,
|
createtime
|
} = res
|
let downloadUrlInfo = await getDownloadUrl(svrUrl, Base64.encode(JSON
|
.stringify(fileSvrInfo.minio)),
|
id, file.name)
|
let url = downloadUrlInfo.dldurl
|
resolve({
|
id,
|
filesflag: fileSFlag,
|
name: file.name,
|
url: url,
|
size: file.size,
|
md5,
|
createtime
|
})
|
} catch (ex) {
|
let tip = typeof ex == 'string' ? ex : ex.message
|
console.log(ex)
|
throw new Error(`上传文件至minio服务器失败：${tip}`)
|
}
|
})
|
}
|
|
|
export const uploadFile = async (file, cbSuccess, cbProgress, cbFail) => {
|
try {
|
// 准备用户信息
|
const app = getApp()
|
const userInfo = app.globalData.userdata
|
|
// 得到文件服务器信息
|
let fileSFlag = app.globalData.files_flag || userInfo.files_info?.flag
|
if (!fileSFlag) {
|
return cbFail({
|
errMsg: `未设置文件服务标识`,
|
path: file.path
|
})
|
}
|
const fileSvrInfo = await getFileSvrInfo(fileSFlag)
|
|
// 准备文件信息
|
let md5 = file.md5
|
// 得到接口地址
|
let ip = fileSvrInfo.exter_ip || fileSvrInfo?.inter_ip
|
let port = fileSvrInfo.exter_port || fileSvrInfo?.inter_port
|
let isSSL = fileSvrInfo?.is_ssl || false
|
let svrUrl = `${isSSL?'https':'http'}://${ip}:${port}`
|
if (!ip) {
|
return cbFail({
|
errMsg: `文件服务器“${fileSFlag}”配置不正确，exter_ip为空`,
|
path: file.path
|
})
|
}
|
if (!port) {
|
return cbFail({
|
errMsg: `文件服务器“${fileSFlag}”配置不正确，exter_port为空`,
|
path: file.path
|
})
|
}
|
if (fileSvrInfo?.is_ssl)
|
fileSvrInfo.minio.is_ssl = true
|
// 得到文件上传地址
|
let uploadUrlInfo = await getUploadUrl(svrUrl, Base64.encode(JSON.stringify(fileSvrInfo.minio)), file
|
.name, file.public)
|
|
// 上传文件
|
const task = uploadTask(uploadUrlInfo.uldurl, file, uploadUrlInfo.formdata, async (param) => {
|
// 写数据库
|
let res = await callback(
|
svrUrl,
|
uploadUrlInfo.savepath,
|
file.size,
|
file.name,
|
md5,
|
userInfo.user_login,
|
userInfo.user_name,
|
fileSvrInfo.minio.access,
|
fileSvrInfo.minio.secret
|
)
|
|
// 文件id
|
let {
|
id,
|
createtime
|
} = res
|
|
// let downloadUrlInfo = await getDownloadUrl(svrUrl, Base64.encode(JSON.stringify(
|
// fileSvrInfo.minio)),
|
// id, file.name)
|
let url = file.path // downloadUrlInfo.dldurl
|
if (file.public) {
|
url = `/${uploadUrlInfo.bucketname}/${uploadUrlInfo.savepath}`
|
}
|
|
if (typeof cbSuccess == "function") {
|
console.log(url)
|
cbSuccess({
|
id,
|
filesflag: fileSFlag,
|
name: file.name,
|
url,
|
size: file.size,
|
md5,
|
createtime,
|
savepath: uploadUrlInfo.savepath,
|
})
|
|
}
|
|
}, (param1, param2) => {
|
if (typeof cbProgress == "function") {
|
cbProgress(param1, param2)
|
}
|
}, (param) => {
|
console.log(cbFail)
|
if (typeof cbFail == "function") {
|
cbFail(param)
|
}
|
})
|
return task
|
|
} catch (ex) {
|
let tip = typeof ex == 'string' ? ex : ex.message
|
console.log(ex)
|
cbFail({
|
errMsg: `上传文件至minio服务器失败：${tip}`,
|
path: file.path
|
})
|
}
|
}
|
/**
|
* minio public文件访问地址
|
* @returns
|
*/
|
export const publicFileUrl = async (fileSFlag, subUrl) => {
|
try {
|
|
if (!fileSFlag) return subUrl
|
// 得到文件服务器信息
|
const fileSvrInfo = await getFileSvrInfo(fileSFlag)
|
console.log("publicFileUrl",fileSvrInfo)
|
// 得到接口地址
|
let ip = fileSvrInfo?.minio?.exter_ip || fileSvrInfo?.minio?.inter_ip
|
let port = fileSvrInfo?.minio?.exter_port || fileSvrInfo?.minio?.inter_port
|
let isSSL = fileSvrInfo?.is_ssl || false
|
let svrUrl = `${isSSL?'https':'http'}://${ip}:${port}`
|
if (!ip) return subUrl
|
if (!port) return subUrl
|
let url = `${svrUrl}${subUrl}`
|
return url
|
} catch (ex) {
|
return subUrl
|
}
|
}
|
/**
|
* minio下载文件
|
* @param {*} fileId
|
* @param {*} fileName
|
* @param {*} fileServer
|
* @returns
|
*/
|
export const downloadFileUrl = async (fileId, fileName, fileSFlag) => {
|
try {
|
if (!fileSFlag) throw new Error('未指定文件服务器标识')
|
// 得到文件服务器信息
|
const fileSvrInfo = await getFileSvrInfo(fileSFlag)
|
console.log("downloadFileUrl",fileSvrInfo)
|
// 得到接口地址
|
let ip = fileSvrInfo.exter_ip || fileSvrInfo?.inter_ip
|
let port = fileSvrInfo.exter_port || fileSvrInfo?.inter_port
|
let isSSL = fileSvrInfo?.is_ssl || false
|
let svrUrl = `${isSSL?'https':'http'}://${ip}:${port}`
|
if (!ip) throw new Error(`文件服务器“${fileSFlag}”配置不正确，exter_ip为空`)
|
if (!port) throw new Error(`文件服务器“${fileSFlag}”配置不正确，exter_port为空`)
|
if (fileSvrInfo?.is_ssl)
|
fileSvrInfo.minio.is_ssl = true
|
fileId = fileId.replace("{", "").replace("}", "");
|
// 得到文件下载地址
|
let downloadUrlInfo = await getDownloadUrl(svrUrl, Base64.encode(JSON.stringify(fileSvrInfo.minio)),
|
fileId, fileName)
|
let url = downloadUrlInfo.dldurl
|
return url
|
} catch (ex) {
|
let tip = typeof ex === 'string' ? ex : ex.errMsg || ex.message
|
throw new Error(`minio下载文件失败：${tip}`)
|
}
|
}
|
|
export const downloadFileTask = (url, cbSuccess, cbProgress, cbFail) => {
|
const app = getApp()
|
const downloadTask = uni.downloadFile({
|
url,
|
success: (result) => {
|
//#ifdef MP-MP-WEIXIN || MP-LARK
|
if (result.statusCode === 200) {
|
console.log("downloadTaskFile success", result)
|
var res = {}
|
res.url = url;
|
res.path = result.tempFilePath
|
cbSuccess(res)
|
} else {
|
console.log("downloadTaskFile err", result)
|
var res = {}
|
res.errMsg = result.data || '下载未知错误!';
|
res.url = url;
|
cbFail(res);
|
}
|
return
|
// #endif
|
console.log("downloadTaskFile success", result)
|
var res = {}
|
res.url = url;
|
res.path = result.tempFilePath
|
cbSuccess(res)
|
},
|
fail: (result) => {
|
console.log("downloadTaskFile fail", result)
|
var res = {}
|
res.url = url;
|
res.errMsg = '下载文件失败!';
|
cbFail(res);
|
}
|
})
|
downloadTask.onProgressUpdate((res) => {
|
if (res.progress != null) {
|
console.log('下载进度', res.progress);
|
console.log('已经下载的数据长度', res.totalBytesWritten);
|
console.log('预期需要下载的数据总长度', res.totalBytesExpectedToWrite);
|
res.url = url;
|
cbProgress(res, downloadTask)
|
}
|
|
});
|
}
|
