mirror of
https://github.com/hcengineering/platform.git
synced 2025-04-04 23:11:15 +00:00
803 lines
22 KiB
TypeScript
803 lines
22 KiB
TypeScript
//
|
|
// Copyright © 2020, 2021 Anticrm Platform Contributors.
|
|
// Copyright © 2021 Hardcore Engineering Inc.
|
|
//
|
|
// Licensed under the Eclipse Public License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License. You may
|
|
// obtain a copy of the License at https://www.eclipse.org/legal/epl-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
//
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
import { MeasureContext, WorkspaceId, metricsAggregate } from '@hcengineering/core'
|
|
import { MinioService } from '@hcengineering/minio'
|
|
import { Token, decodeToken } from '@hcengineering/server-token'
|
|
import bp from 'body-parser'
|
|
import cors from 'cors'
|
|
import express, { Response } from 'express'
|
|
import fileUpload, { UploadedFile } from 'express-fileupload'
|
|
import expressStaticGzip from 'express-static-gzip'
|
|
import https from 'https'
|
|
import morgan from 'morgan'
|
|
import { extname, join, resolve } from 'path'
|
|
import { cwd } from 'process'
|
|
import sharp from 'sharp'
|
|
import { v4 as uuid } from 'uuid'
|
|
import { preConditions } from './utils'
|
|
|
|
const cacheControlValue = 'public, max-age=365d'
|
|
const cacheControlMaxAge = '365d'
|
|
|
|
async function minioUpload (
|
|
ctx: MeasureContext,
|
|
minio: MinioService,
|
|
workspace: WorkspaceId,
|
|
file: UploadedFile
|
|
): Promise<string> {
|
|
const id = uuid()
|
|
const meta: any = {
|
|
'Content-Type': file.mimetype
|
|
}
|
|
|
|
const resp = await ctx.with(
|
|
'storage upload',
|
|
{ file: file.name, contentType: file.mimetype },
|
|
async () => await minio.put(workspace, id, file.data, file.size, meta)
|
|
)
|
|
|
|
await ctx.info('minio upload', resp)
|
|
return id
|
|
}
|
|
|
|
function getRange (range: string, size: number): [number, number] {
|
|
const [startStr, endStr] = range.replace(/bytes=/, '').split('-')
|
|
|
|
let start = parseInt(startStr, 10)
|
|
let end = endStr !== undefined ? parseInt(endStr, 10) : size - 1
|
|
|
|
if (!isNaN(start) && isNaN(end)) {
|
|
end = size - 1
|
|
}
|
|
|
|
if (isNaN(start) && !isNaN(end)) {
|
|
start = size - end
|
|
end = size - 1
|
|
}
|
|
|
|
return [start, end]
|
|
}
|
|
|
|
async function getFileRange (
|
|
ctx: MeasureContext,
|
|
range: string,
|
|
client: MinioService,
|
|
workspace: WorkspaceId,
|
|
uuid: string,
|
|
res: Response
|
|
): Promise<void> {
|
|
const stat = await ctx.with('stats', {}, async () => await client.stat(workspace, uuid))
|
|
|
|
const size: number = stat.size
|
|
|
|
const [start, end] = getRange(range, size)
|
|
|
|
if (start >= size || end >= size) {
|
|
res.writeHead(416, {
|
|
'Content-Range': `bytes */${size}`
|
|
})
|
|
res.end()
|
|
return
|
|
}
|
|
|
|
await ctx.with(
|
|
'write',
|
|
{ contentType: stat.metaData['content-type'] },
|
|
async (ctx) => {
|
|
try {
|
|
const dataStream = await ctx.with(
|
|
'partial',
|
|
{},
|
|
async () => await client.partial(workspace, uuid, start, end - start + 1),
|
|
{}
|
|
)
|
|
res.writeHead(206, {
|
|
Connection: 'keep-alive',
|
|
'Content-Range': `bytes ${start}-${end}/${size}`,
|
|
'Accept-Ranges': 'bytes',
|
|
'Content-Length': end - start + 1,
|
|
'Content-Type': stat.metaData['content-type'],
|
|
Etag: stat.etag,
|
|
'Last-Modified': stat.lastModified.toISOString()
|
|
})
|
|
|
|
dataStream.pipe(res)
|
|
|
|
await new Promise<void>((resolve, reject) => {
|
|
dataStream.on('end', () => {
|
|
dataStream.destroy()
|
|
res.end()
|
|
resolve()
|
|
})
|
|
dataStream.on('error', (err) => {
|
|
console.error(err)
|
|
res.end()
|
|
reject(err)
|
|
})
|
|
dataStream.on('close', () => {
|
|
res.end()
|
|
})
|
|
})
|
|
} catch (err: any) {
|
|
if (err?.code === 'NoSuchKey' || err?.code === 'NotFound') {
|
|
console.log('No such key', workspace.name, uuid)
|
|
res.status(404).send()
|
|
return
|
|
} else {
|
|
console.log(err)
|
|
}
|
|
res.status(500).send()
|
|
}
|
|
},
|
|
{ ...stat.metaData, uuid, start, end: end - start + 1, ...stat.metaData }
|
|
)
|
|
}
|
|
|
|
async function getFile (
|
|
ctx: MeasureContext,
|
|
client: MinioService,
|
|
workspace: WorkspaceId,
|
|
uuid: string,
|
|
req: Request,
|
|
res: Response
|
|
): Promise<void> {
|
|
const stat = await ctx.with('stat', {}, async () => await client.stat(workspace, uuid))
|
|
|
|
const etag = stat.etag
|
|
|
|
if (
|
|
preConditions.IfNoneMatch(req.headers, { etag }) === 'notModified' ||
|
|
preConditions.IfMatch(req.headers, { etag }) === 'notModified' ||
|
|
preConditions.IfModifiedSince(req.headers, { lastModified: stat.lastModified }) === 'notModified'
|
|
) {
|
|
// Matched, return not modified
|
|
res.statusCode = 304
|
|
res.end()
|
|
return
|
|
}
|
|
if (preConditions.IfUnmodifiedSince(req.headers, { lastModified: stat.lastModified }) === 'failed') {
|
|
// Send 412 (Precondition Failed)
|
|
res.statusCode = 412
|
|
res.end()
|
|
return
|
|
}
|
|
|
|
await ctx.with(
|
|
'write',
|
|
{ contentType: stat.metaData['content-type'] },
|
|
async (ctx) => {
|
|
try {
|
|
const dataStream = await ctx.with('readable', {}, async () => await client.get(workspace, uuid))
|
|
res.writeHead(200, {
|
|
'Content-Type': stat.metaData['content-type'],
|
|
Etag: stat.etag,
|
|
'Last-Modified': stat.lastModified.toISOString(),
|
|
'Cache-Control': cacheControlValue
|
|
})
|
|
|
|
dataStream.on('data', function (chunk) {
|
|
res.write(chunk)
|
|
})
|
|
await new Promise<void>((resolve, reject) => {
|
|
dataStream.on('end', function () {
|
|
res.end()
|
|
dataStream.destroy()
|
|
resolve()
|
|
})
|
|
dataStream.on('error', function (err) {
|
|
res.status(500).send()
|
|
console.log(err)
|
|
reject(err)
|
|
})
|
|
})
|
|
} catch (err: any) {
|
|
console.log(err)
|
|
res.status(500).send()
|
|
}
|
|
},
|
|
{ ...stat.metaData }
|
|
)
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
* @param port -
|
|
*/
|
|
export function start (
|
|
ctx: MeasureContext,
|
|
config: {
|
|
transactorEndpoint: string
|
|
elasticUrl: string
|
|
minio: MinioService
|
|
accountsUrl: string
|
|
uploadUrl: string
|
|
modelVersion: string
|
|
rekoniUrl: string
|
|
telegramUrl: string
|
|
gmailUrl: string
|
|
calendarUrl: string
|
|
collaboratorUrl: string
|
|
collaboratorApiUrl: string
|
|
title?: string
|
|
languages: string
|
|
defaultLanguage: string
|
|
lastNameFirst?: string
|
|
},
|
|
port: number,
|
|
extraConfig?: Record<string, string>
|
|
): () => void {
|
|
const app = express()
|
|
|
|
app.use(cors())
|
|
app.use(fileUpload())
|
|
app.use(bp.json())
|
|
app.use(bp.urlencoded({ extended: true }))
|
|
|
|
class MyStream {
|
|
write (text: string): void {
|
|
void ctx.info(text)
|
|
}
|
|
}
|
|
|
|
const myStream = new MyStream()
|
|
|
|
app.use(morgan('short', { stream: myStream }))
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-misused-promises
|
|
app.get('/config.json', async (req, res) => {
|
|
const data = {
|
|
ACCOUNTS_URL: config.accountsUrl,
|
|
UPLOAD_URL: config.uploadUrl,
|
|
MODEL_VERSION: config.modelVersion,
|
|
REKONI_URL: config.rekoniUrl,
|
|
TELEGRAM_URL: config.telegramUrl,
|
|
GMAIL_URL: config.gmailUrl,
|
|
CALENDAR_URL: config.calendarUrl,
|
|
COLLABORATOR_URL: config.collaboratorUrl,
|
|
COLLABORATOR_API_URL: config.collaboratorApiUrl,
|
|
TITLE: config.title,
|
|
LANGUAGES: config.languages,
|
|
DEFAULT_LANGUAGE: config.defaultLanguage,
|
|
LAST_NAME_FIRST: config.lastNameFirst,
|
|
...(extraConfig ?? {})
|
|
}
|
|
res.set('Cache-Control', cacheControlValue)
|
|
res.status(200)
|
|
res.json(data)
|
|
})
|
|
|
|
app.get('/api/v1/statistics', (req, res) => {
|
|
try {
|
|
const token = req.query.token as string
|
|
const payload = decodeToken(token)
|
|
const admin = payload.extra?.admin === 'true'
|
|
res.writeHead(200, { 'Content-Type': 'application/json' })
|
|
|
|
const json = JSON.stringify({
|
|
metrics: metricsAggregate((ctx as any).metrics),
|
|
statistics: {
|
|
activeSessions: {}
|
|
},
|
|
admin
|
|
})
|
|
res.end(json)
|
|
} catch (err) {
|
|
console.error(err)
|
|
res.writeHead(404, {})
|
|
res.end()
|
|
}
|
|
})
|
|
|
|
const dist = resolve(process.env.PUBLIC_DIR ?? cwd(), 'dist')
|
|
console.log('serving static files from', dist)
|
|
app.use(
|
|
expressStaticGzip(dist, {
|
|
serveStatic: {
|
|
maxAge: '365d',
|
|
etag: true,
|
|
lastModified: true
|
|
}
|
|
})
|
|
)
|
|
|
|
async function handleHead (ctx: MeasureContext, req: any, res: Response): Promise<void> {
|
|
try {
|
|
const token = req.query.token as string
|
|
const payload = decodeToken(token)
|
|
let uuid = req.query.file as string
|
|
const size = req.query.size as 'inline' | 'tiny' | 'x-small' | 'small' | 'medium' | 'large' | 'x-large' | 'full'
|
|
|
|
uuid = await getResizeID(size, uuid, config, payload)
|
|
const stat = await config.minio.stat(payload.workspace, uuid)
|
|
|
|
const fileSize = stat.size
|
|
|
|
res.writeHead(200, {
|
|
'accept-ranges': 'bytes',
|
|
'content-length': fileSize,
|
|
Etag: stat.etag,
|
|
'Last-Modified': stat.lastModified.toISOString()
|
|
})
|
|
res.status(200)
|
|
|
|
res.end()
|
|
} catch (error: any) {
|
|
if (error?.code === 'NoSuchKey' || error?.code === 'NotFound') {
|
|
console.log('No such key', req.query.file)
|
|
res.status(404).send()
|
|
return
|
|
} else {
|
|
await ctx.error('error-handle-files', error)
|
|
}
|
|
res.status(500).send()
|
|
}
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-misused-promises
|
|
app.head('/files', (req, res) => {
|
|
void ctx.with(
|
|
'head-handle-file',
|
|
{},
|
|
async (ctx) => {
|
|
await handleHead(ctx, req, res)
|
|
},
|
|
{ url: req.path, query: req.query }
|
|
)
|
|
})
|
|
// eslint-disable-next-line @typescript-eslint/no-misused-promises
|
|
app.head('/files/*', (req, res) => {
|
|
void ctx.with(
|
|
'head-handle-file',
|
|
{},
|
|
async (ctx) => {
|
|
await handleHead(ctx, req, res)
|
|
},
|
|
{ url: req.path, query: req.query }
|
|
)
|
|
})
|
|
|
|
const filesHandler = async (ctx: MeasureContext, req: any, res: Response): Promise<void> => {
|
|
try {
|
|
const cookies = ((req?.headers?.cookie as string) ?? '').split(';').map((it) => it.trim().split('='))
|
|
|
|
const token = cookies.find((it) => it[0] === 'presentation-metadata-Token')?.[1]
|
|
const payload =
|
|
token !== undefined
|
|
? decodeToken(token)
|
|
: { email: 'guest', workspace: { name: req.query.workspace as string, productId: '' } }
|
|
|
|
let uuid = req.query.file as string
|
|
if (token === undefined) {
|
|
try {
|
|
const d = await ctx.with(
|
|
'notoken-stat',
|
|
{ workspace: payload.workspace.name },
|
|
async () => await config.minio.stat(payload.workspace, uuid)
|
|
)
|
|
if (!((d.metaData['content-type'] as string) ?? '').includes('image')) {
|
|
// Do not allow to return non images with no token.
|
|
if (token === undefined) {
|
|
res.status(403).send()
|
|
return
|
|
}
|
|
}
|
|
} catch (err) {}
|
|
}
|
|
|
|
const size = req.query.size as 'inline' | 'tiny' | 'x-small' | 'small' | 'medium' | 'large' | 'x-large' | 'full'
|
|
|
|
uuid = await ctx.with('resize', {}, async () => await getResizeID(size, uuid, config, payload))
|
|
|
|
const range = req.headers.range
|
|
if (range !== undefined) {
|
|
await ctx.with('file-range', { workspace: payload.workspace.name }, async (ctx) => {
|
|
await getFileRange(ctx, range, config.minio, payload.workspace, uuid, res)
|
|
})
|
|
} else {
|
|
await ctx.with(
|
|
'file',
|
|
{ workspace: payload.workspace.name },
|
|
async (ctx) => {
|
|
await getFile(ctx, config.minio, payload.workspace, uuid, req, res)
|
|
},
|
|
{ uuid }
|
|
)
|
|
}
|
|
} catch (error: any) {
|
|
if (error?.code === 'NoSuchKey' || error?.code === 'NotFound') {
|
|
console.log('No such key', req.query.file)
|
|
res.status(404).send()
|
|
return
|
|
} else {
|
|
await ctx.error('error-handle-files', error)
|
|
}
|
|
res.status(500).send()
|
|
}
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-misused-promises
|
|
app.get('/files', (req, res) => {
|
|
void ctx.with(
|
|
'handle-file',
|
|
{},
|
|
async (ctx) => {
|
|
await filesHandler(ctx, req, res)
|
|
},
|
|
{ url: req.path, query: req.query }
|
|
)
|
|
})
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-misused-promises
|
|
app.get('/files/*', (req, res) => {
|
|
void ctx.with(
|
|
'handle-file*',
|
|
{},
|
|
async (ctx) => {
|
|
await filesHandler(ctx, req, res)
|
|
},
|
|
{ url: req.path, query: req.query }
|
|
)
|
|
})
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-misused-promises
|
|
app.post('/files', async (req, res) => {
|
|
await ctx.with(
|
|
'post-file',
|
|
{},
|
|
async (ctx) => {
|
|
const file = req.files?.file as UploadedFile
|
|
|
|
if (file === undefined) {
|
|
res.status(400).send()
|
|
return
|
|
}
|
|
|
|
const authHeader = req.headers.authorization
|
|
if (authHeader === undefined) {
|
|
res.status(403).send()
|
|
return
|
|
}
|
|
|
|
try {
|
|
const token = authHeader.split(' ')[1]
|
|
const payload = decodeToken(token)
|
|
const uuid = await minioUpload(ctx, config.minio, payload.workspace, file)
|
|
|
|
res.status(200).send(uuid)
|
|
} catch (error: any) {
|
|
await ctx.error('error-post-files', error)
|
|
res.status(500).send()
|
|
}
|
|
},
|
|
{ url: req.path, query: req.query }
|
|
)
|
|
})
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-misused-promises
|
|
app.delete('/files', async (req, res) => {
|
|
try {
|
|
const authHeader = req.headers.authorization
|
|
if (authHeader === undefined) {
|
|
res.status(403).send()
|
|
return
|
|
}
|
|
|
|
const token = authHeader.split(' ')[1]
|
|
const payload = decodeToken(token)
|
|
const uuid = req.query.file as string
|
|
if (uuid === '') {
|
|
res.status(500).send()
|
|
return
|
|
}
|
|
|
|
// TODO: We need to allow delete only of user attached documents. (https://front.hc.engineering/workbench/platform/tracker/TSK-1081)
|
|
await config.minio.remove(payload.workspace, [uuid])
|
|
|
|
const extra = await config.minio.list(payload.workspace, uuid)
|
|
if (extra.length > 0) {
|
|
await config.minio.remove(
|
|
payload.workspace,
|
|
Array.from(extra.entries()).map((it) => it[1].name)
|
|
)
|
|
}
|
|
|
|
res.status(200).send()
|
|
} catch (error) {
|
|
console.log(error)
|
|
res.status(500).send()
|
|
}
|
|
})
|
|
|
|
// todo remove it after update all customers chrome extensions
|
|
app.get('/import', (req, res) => {
|
|
try {
|
|
const authHeader = req.headers.authorization
|
|
if (authHeader === undefined) {
|
|
res.status(403).send()
|
|
return
|
|
}
|
|
const token = authHeader.split(' ')[1]
|
|
const payload = decodeToken(token)
|
|
const url = req.query.url as string
|
|
const cookie = req.query.cookie as string | undefined
|
|
// const attachedTo = req.query.attachedTo as Ref<Doc> | undefined
|
|
if (url === undefined) {
|
|
res.status(500).send('URL param is not defined')
|
|
return
|
|
}
|
|
|
|
console.log('importing from', url)
|
|
console.log('cookie', cookie)
|
|
|
|
const options =
|
|
cookie !== undefined
|
|
? {
|
|
headers: {
|
|
Cookie: cookie
|
|
}
|
|
}
|
|
: {}
|
|
|
|
https
|
|
.get(url, options, (response) => {
|
|
console.log('status', response.statusCode)
|
|
if (response.statusCode !== 200) {
|
|
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
|
|
res.status(500).send(`server returned ${response.statusCode}`)
|
|
return
|
|
}
|
|
const id = uuid()
|
|
const contentType = response.headers['content-type']
|
|
const meta = {
|
|
'Content-Type': contentType
|
|
}
|
|
const data: Buffer[] = []
|
|
response
|
|
.on('data', function (chunk) {
|
|
data.push(chunk)
|
|
})
|
|
.on('end', function () {
|
|
const buffer = Buffer.concat(data)
|
|
config.minio
|
|
.put(payload.workspace, id, buffer, 0, meta)
|
|
.then(async (objInfo) => {
|
|
console.log('uploaded uuid', id, objInfo.etag)
|
|
|
|
res.status(200).send({
|
|
id,
|
|
contentType,
|
|
size: buffer.length
|
|
})
|
|
})
|
|
.catch((err) => {
|
|
if (err !== null) {
|
|
console.log('minio putObject error', err)
|
|
res.status(500).send(err)
|
|
}
|
|
})
|
|
})
|
|
.on('error', function (err) {
|
|
res.status(500).send(err)
|
|
})
|
|
})
|
|
.on('error', (e) => {
|
|
console.error(e)
|
|
res.status(500).send(e)
|
|
})
|
|
} catch (error) {
|
|
console.log(error)
|
|
res.status(500).send()
|
|
}
|
|
})
|
|
|
|
app.post('/import', (req, res) => {
|
|
try {
|
|
const authHeader = req.headers.authorization
|
|
if (authHeader === undefined) {
|
|
res.status(403).send()
|
|
return
|
|
}
|
|
const token = authHeader.split(' ')[1]
|
|
const payload = decodeToken(token)
|
|
const { url, cookie } = req.body
|
|
if (url === undefined) {
|
|
res.status(500).send('URL param is not defined')
|
|
return
|
|
}
|
|
|
|
console.log('importing from', url)
|
|
console.log('cookie', cookie)
|
|
|
|
const options =
|
|
cookie !== undefined
|
|
? {
|
|
headers: {
|
|
Cookie: cookie
|
|
}
|
|
}
|
|
: {}
|
|
|
|
https.get(url, options, (response) => {
|
|
console.log('status', response.statusCode)
|
|
if (response.statusCode !== 200) {
|
|
// eslint-disable-next-line @typescript-eslint/restrict-template-expressions
|
|
res.status(500).send(`server returned ${response.statusCode}`)
|
|
return
|
|
}
|
|
const id = uuid()
|
|
const contentType = response.headers['content-type']
|
|
const meta = {
|
|
'Content-Type': contentType
|
|
}
|
|
const data: Buffer[] = []
|
|
response
|
|
.on('data', function (chunk) {
|
|
data.push(chunk)
|
|
})
|
|
.on('end', function () {
|
|
const buffer = Buffer.concat(data)
|
|
// eslint-disable-next-line @typescript-eslint/no-misused-promises
|
|
config.minio
|
|
.put(payload.workspace, id, buffer, 0, meta)
|
|
.then(async () => {
|
|
console.log('uploaded uuid', id)
|
|
|
|
// if (attachedTo !== undefined) {
|
|
// const elastic = await createElasticAdapter(config.elasticUrl, payload.workspace)
|
|
|
|
// const indexedDoc: IndexedDoc = {
|
|
// id: id as Ref<Doc>,
|
|
// _class: attachment.class.Attachment,
|
|
// space,
|
|
// modifiedOn: Date.now(),
|
|
// modifiedBy: 'core:account:System' as Ref<Account>,
|
|
// attachedTo,
|
|
// data: buffer.toString('base64')
|
|
// }
|
|
|
|
// await elastic.index(indexedDoc)
|
|
// }
|
|
|
|
res.status(200).send({
|
|
id,
|
|
contentType,
|
|
size: buffer.length
|
|
})
|
|
})
|
|
.catch((err) => {
|
|
console.log('minio putObject error', err)
|
|
res.status(500).send(err)
|
|
})
|
|
})
|
|
.on('error', function (err) {
|
|
res.status(500).send(err)
|
|
})
|
|
})
|
|
} catch (error) {
|
|
console.log(error)
|
|
res.status(500).send()
|
|
}
|
|
})
|
|
|
|
app.get('*', function (request, response) {
|
|
const url = request.path.split('/').filter((it) => it !== '')
|
|
if (url.length === 1) {
|
|
const ext = extname(url[0])
|
|
const notFoundResource = [
|
|
'.js',
|
|
'.js.gz',
|
|
'.svg',
|
|
'.webp',
|
|
'.woff',
|
|
'.woff2',
|
|
'.svg.gz',
|
|
'.css',
|
|
'.css.gz',
|
|
'.png',
|
|
'.avif'
|
|
]
|
|
if (notFoundResource.includes(ext)) {
|
|
response.sendStatus(404)
|
|
return
|
|
}
|
|
}
|
|
response.sendFile(join(dist, 'index.html'), {
|
|
maxAge: cacheControlMaxAge,
|
|
etag: true,
|
|
lastModified: true
|
|
})
|
|
})
|
|
|
|
const server = app.listen(port)
|
|
return () => {
|
|
server.close()
|
|
}
|
|
}
|
|
|
|
// export type IconSize =
|
|
// | 'inline'
|
|
// | 'tiny'
|
|
// | 'card'
|
|
// | 'x-small'
|
|
// | 'smaller'
|
|
// | 'small'
|
|
// | 'medium'
|
|
// | 'large'
|
|
// | 'x-large'
|
|
// | '2x-large'
|
|
// | 'full'
|
|
async function getResizeID (
|
|
size: string,
|
|
uuid: string,
|
|
config: { minio: MinioService },
|
|
payload: Token
|
|
): Promise<string> {
|
|
if (size !== undefined && size !== 'full') {
|
|
let width = 64
|
|
switch (size) {
|
|
case 'inline':
|
|
case 'tiny':
|
|
case 'card':
|
|
case 'x-small':
|
|
case 'smaller':
|
|
case 'small':
|
|
case 'medium':
|
|
width = 64
|
|
break
|
|
case 'large':
|
|
width = 256
|
|
break
|
|
case 'x-large':
|
|
width = 512
|
|
break
|
|
case '2x-large':
|
|
size = '2x-large_v2'
|
|
width = 1024
|
|
break
|
|
}
|
|
let hasSmall = false
|
|
const sizeId = uuid + `%size%${width}`
|
|
try {
|
|
const d = await config.minio.stat(payload.workspace, sizeId)
|
|
hasSmall = d !== undefined && d.size > 0
|
|
} catch (err: any) {
|
|
if (err.code !== 'NotFound') {
|
|
console.error(err)
|
|
}
|
|
}
|
|
if (hasSmall) {
|
|
// We have cached small document, let's proceed with it.
|
|
uuid = sizeId
|
|
} else {
|
|
// Let's get data and resize it
|
|
const data = Buffer.concat(await config.minio.read(payload.workspace, uuid))
|
|
|
|
const dataBuff = await sharp(data)
|
|
.resize({
|
|
width
|
|
})
|
|
.jpeg()
|
|
.toBuffer()
|
|
await config.minio.put(payload.workspace, sizeId, dataBuff, dataBuff.length, {
|
|
'Content-Type': 'image/jpeg'
|
|
})
|
|
uuid = sizeId
|
|
}
|
|
}
|
|
return uuid
|
|
}
|