mirror of
https://github.com/hcengineering/platform.git
synced 2026-09-03 05:28:44 +02:00
Move services to public (#6156)
Signed-off-by: Andrey Sobolev <haiodo@gmail.com>
This commit is contained in:
Andrey Sobolev
@@ -0,0 +1,557 @@
|
||||
//
|
||||
// Copyright © 2023 Hardcore Engineering Inc.
|
||||
//
|
||||
import chunter, { ChatMessage } from '@hcengineering/chunter'
|
||||
import { PersonAccount } from '@hcengineering/contact'
|
||||
import core, {
|
||||
Account,
|
||||
AttachedData,
|
||||
Doc,
|
||||
DocumentUpdate,
|
||||
MeasureContext,
|
||||
Ref,
|
||||
TxOperations
|
||||
} from '@hcengineering/core'
|
||||
import { LiveQuery } from '@hcengineering/query'
|
||||
import github, { DocSyncInfo, GithubIntegrationRepository, GithubProject } from '@hcengineering/github'
|
||||
import { deepEqual } from 'fast-equals'
|
||||
import {
|
||||
ContainerFocus,
|
||||
DocSyncManager,
|
||||
ExternalSyncField,
|
||||
IntegrationContainer,
|
||||
IntegrationManager,
|
||||
githubExternalSyncVersion,
|
||||
githubSyncVersion
|
||||
} from '../types'
|
||||
import { collectUpdate, deleteObjects, errorToObj, getSince, isGHWriteAllowed } from './utils'
|
||||
|
||||
import { Analytics } from '@hcengineering/analytics'
|
||||
import { IssueComment, IssueCommentCreatedEvent, IssueCommentEvent } from '@octokit/webhooks-types'
|
||||
import config from '../config'
|
||||
import { syncConfig } from './syncConfig'
|
||||
|
||||
interface MessageData {
|
||||
message: string
|
||||
}
|
||||
|
||||
type CommentExternalData = Omit<IssueComment, 'author_association' | 'performed_via_github_app'>
|
||||
|
||||
export class CommentSyncManager implements DocSyncManager {
|
||||
provider!: IntegrationManager
|
||||
|
||||
createCommentPromise: Promise<DocumentUpdate<DocSyncInfo>> | undefined
|
||||
|
||||
externalDerivedSync = false
|
||||
|
||||
constructor (
|
||||
readonly ctx: MeasureContext,
|
||||
readonly client: TxOperations,
|
||||
readonly lq: LiveQuery
|
||||
) {}
|
||||
|
||||
async init (provider: IntegrationManager): Promise<void> {
|
||||
this.provider = provider
|
||||
}
|
||||
|
||||
eventSync = new Map<string, Promise<void>>()
|
||||
async handleEvent<T>(integration: IntegrationContainer, derivedClient: TxOperations, evt: T): Promise<void> {
|
||||
await this.createCommentPromise
|
||||
const event = evt as IssueCommentEvent
|
||||
this.ctx.info('comments:handleEvent', {
|
||||
action: event.action,
|
||||
login: event.sender.login,
|
||||
workspace: this.provider.getWorkspaceId().name
|
||||
})
|
||||
|
||||
if (event.sender.type === 'Bot') {
|
||||
// Ignore events from Bot if it is our bot
|
||||
// No need to handle event from ourself
|
||||
if (event.sender.login.includes(config.BotName)) {
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
await this.eventSync.get(event.issue.url)
|
||||
const promise = this.processEvent(event, derivedClient, integration)
|
||||
this.eventSync.set(event.issue.url, promise)
|
||||
await promise
|
||||
this.eventSync.delete(event.issue.url)
|
||||
}
|
||||
|
||||
async handleDelete (
|
||||
existing: Doc | undefined,
|
||||
info: DocSyncInfo,
|
||||
derivedClient: TxOperations,
|
||||
deleteExisting: boolean
|
||||
): Promise<boolean> {
|
||||
const container = await this.provider.getContainer(info.space)
|
||||
if (container === undefined) {
|
||||
return false
|
||||
}
|
||||
if (
|
||||
container?.container === undefined ||
|
||||
((container.project.projectNodeId === undefined ||
|
||||
!container.container.projectStructure.has(container.project._id)) &&
|
||||
syncConfig.MainProject)
|
||||
) {
|
||||
return false
|
||||
}
|
||||
|
||||
const commentExternal = info.external as CommentExternalData | undefined
|
||||
|
||||
if (commentExternal === undefined) {
|
||||
// No external issue yet, safe delete, since platform document will be deleted a well.
|
||||
return true
|
||||
}
|
||||
const account =
|
||||
existing?.createdBy ?? (await this.provider.getAccountU(commentExternal.user))?._id ?? core.account.System
|
||||
|
||||
if (commentExternal !== undefined) {
|
||||
try {
|
||||
await this.deleteGithubDocument(container, account, commentExternal.node_id)
|
||||
} catch (err: any) {
|
||||
let cnt = false
|
||||
if (Array.isArray(err.errors)) {
|
||||
for (const e of err.errors) {
|
||||
if (e.type === 'NOT_FOUND') {
|
||||
// Ok issue is already deleted
|
||||
cnt = true
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
if (!cnt) {
|
||||
Analytics.handleError(err)
|
||||
await derivedClient.update(info, { error: errorToObj(err) })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (existing !== undefined && deleteExisting) {
|
||||
await deleteObjects(this.ctx, this.client, [existing], account)
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
async deleteGithubDocument (container: ContainerFocus, account: Ref<Account>, id: string): Promise<void> {
|
||||
const okit = (await this.provider.getOctokit(account as Ref<PersonAccount>)) ?? container.container.octokit
|
||||
|
||||
const q = `mutation deleteComment($commentID: ID!) {
|
||||
deleteIssueComment(
|
||||
input: {id: $commentID}
|
||||
) {
|
||||
__typename
|
||||
}
|
||||
}`
|
||||
if (isGHWriteAllowed()) {
|
||||
await okit?.graphql(q, {
|
||||
commentID: id
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
private async processEvent (
|
||||
event: IssueCommentEvent,
|
||||
derivedClient: TxOperations,
|
||||
integration: IntegrationContainer
|
||||
): Promise<void> {
|
||||
const { repository } = await this.provider.getProjectAndRepository(event.repository.node_id)
|
||||
if (repository === undefined) {
|
||||
this.ctx.info('No project for repository', {
|
||||
repository: event.repository,
|
||||
workspace: this.provider.getWorkspaceId().name
|
||||
})
|
||||
return
|
||||
}
|
||||
|
||||
const account = (await this.provider.getAccountU(event.sender))?._id ?? core.account.System
|
||||
switch (event.action) {
|
||||
case 'created': {
|
||||
await this.createSyncData(event, derivedClient, repository)
|
||||
break
|
||||
}
|
||||
case 'deleted': {
|
||||
const syncData = await this.client.findOne(github.class.DocSyncInfo, {
|
||||
url: (event.comment.url ?? '').toLowerCase()
|
||||
})
|
||||
if (syncData !== undefined) {
|
||||
await derivedClient.update<DocSyncInfo>(syncData, { deleted: true, needSync: '' })
|
||||
this.provider.sync()
|
||||
}
|
||||
break
|
||||
}
|
||||
case 'edited': {
|
||||
const commentData = await this.client.findOne(github.class.DocSyncInfo, {
|
||||
url: (event.comment.url ?? '').toLowerCase()
|
||||
})
|
||||
|
||||
const messageData: MessageData = {
|
||||
message: await this.provider.getMarkup(integration, event.comment.body)
|
||||
}
|
||||
|
||||
if (commentData !== undefined) {
|
||||
const chatMessage: ChatMessage | undefined = await this.client.findOne<ChatMessage>(commentData.objectClass, {
|
||||
_id: commentData._id as unknown as Ref<ChatMessage>
|
||||
})
|
||||
if (chatMessage !== undefined) {
|
||||
const lastModified = new Date(event.comment.updated_at).getTime()
|
||||
await derivedClient.diffUpdate(
|
||||
commentData,
|
||||
{
|
||||
external: event.comment,
|
||||
current: messageData,
|
||||
needSync: githubSyncVersion,
|
||||
lastModified
|
||||
},
|
||||
lastModified
|
||||
)
|
||||
await this.client.diffUpdate(chatMessage, messageData, lastModified, account)
|
||||
this.provider.sync()
|
||||
}
|
||||
}
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async createSyncData (
|
||||
createdEvent: IssueCommentCreatedEvent,
|
||||
derivedClient: TxOperations,
|
||||
repo: GithubIntegrationRepository
|
||||
): Promise<void> {
|
||||
const commentData = await this.client.findOne(github.class.DocSyncInfo, {
|
||||
url: (createdEvent.comment.url ?? '').toLowerCase()
|
||||
})
|
||||
|
||||
if (commentData === undefined) {
|
||||
await derivedClient.createDoc(github.class.DocSyncInfo, repo.githubProject as Ref<GithubProject>, {
|
||||
url: (createdEvent.comment.url ?? '').toLowerCase(),
|
||||
needSync: '',
|
||||
githubNumber: 0,
|
||||
repository: repo._id,
|
||||
objectClass: chunter.class.ChatMessage,
|
||||
external: createdEvent.comment as CommentExternalData,
|
||||
externalVersion: githubExternalSyncVersion,
|
||||
parent: createdEvent.issue.url,
|
||||
lastModified: new Date(createdEvent.comment.updated_at).getTime()
|
||||
})
|
||||
this.provider.sync()
|
||||
}
|
||||
}
|
||||
|
||||
async sync (
|
||||
existing: Doc | undefined,
|
||||
info: DocSyncInfo,
|
||||
parent: DocSyncInfo | undefined,
|
||||
derivedClient: TxOperations
|
||||
): Promise<DocumentUpdate<DocSyncInfo> | undefined> {
|
||||
const container = await this.provider.getContainer(info.space)
|
||||
if (container?.container === undefined) {
|
||||
return {}
|
||||
}
|
||||
if (info.external === undefined) {
|
||||
// TODO: Use selected repository
|
||||
const repo = container.repository.find((it) => it._id === parent?.repository)
|
||||
if (repo?.nodeId === undefined) {
|
||||
// No need to sync if parent repository is not defined.
|
||||
return { needSync: githubSyncVersion }
|
||||
}
|
||||
|
||||
// If no external document, we need to create it.
|
||||
this.createCommentPromise = this.createGithubComment(container, existing, info, parent, derivedClient)
|
||||
return await this.createCommentPromise
|
||||
}
|
||||
const comment = info.external as CommentExternalData
|
||||
if (parent === undefined) {
|
||||
// Find parent by issue url
|
||||
parent = await this.client.findOne(github.class.DocSyncInfo, {
|
||||
url: (comment.html_url.split('#')?.[0] ?? '').toLowerCase()
|
||||
})
|
||||
}
|
||||
if (parent === undefined) {
|
||||
// no Sync until parent is found, parent should trigger all child's refresh.
|
||||
return { needSync: githubSyncVersion }
|
||||
}
|
||||
|
||||
const account = existing?.modifiedBy ?? (await this.provider.getAccountU(comment.user))?._id ?? core.account.System
|
||||
|
||||
const messageData: MessageData = {
|
||||
message: await this.provider.getMarkup(container.container, comment.body)
|
||||
}
|
||||
if (existing === undefined) {
|
||||
try {
|
||||
await this.createComment(info, messageData, parent, comment, account)
|
||||
return { needSync: githubSyncVersion, current: messageData }
|
||||
} catch (err: any) {
|
||||
Analytics.handleError(err)
|
||||
this.ctx.error(err)
|
||||
return { needSync: githubSyncVersion, error: errorToObj(err) }
|
||||
}
|
||||
} else {
|
||||
await this.handleDiffUpdate(existing, info, messageData, container, parent, comment, account)
|
||||
}
|
||||
return { current: messageData, needSync: githubSyncVersion }
|
||||
}
|
||||
|
||||
private async handleDiffUpdate (
|
||||
existing: Doc,
|
||||
info: DocSyncInfo,
|
||||
messageData: MessageData,
|
||||
container: ContainerFocus,
|
||||
parent: DocSyncInfo,
|
||||
comment: CommentExternalData,
|
||||
account: Ref<Account>
|
||||
): Promise<void> {
|
||||
const repository = container.repository.find((it) => it._id === info.repository)
|
||||
if (repository === undefined) {
|
||||
return
|
||||
}
|
||||
|
||||
const existingComment = existing as ChatMessage
|
||||
|
||||
const previousData: MessageData = info.current ?? ({} as unknown as MessageData)
|
||||
|
||||
const update = collectUpdate<ChatMessage>(previousData, messageData, Object.keys(messageData))
|
||||
|
||||
const platformUpdate = collectUpdate<ChatMessage>(previousData, existing, Object.keys(messageData))
|
||||
|
||||
// We should remove changes we already have from github changed.
|
||||
for (const [k, v] of Object.entries(update)) {
|
||||
if ((platformUpdate as any)[k] !== v) {
|
||||
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
|
||||
delete (platformUpdate as any)[k]
|
||||
}
|
||||
}
|
||||
// Remove current same values from update
|
||||
for (const [k, v] of Object.entries(existingComment)) {
|
||||
if ((update as any)[k] === v) {
|
||||
// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
|
||||
delete (update as any)[k]
|
||||
}
|
||||
}
|
||||
|
||||
if (Object.keys(platformUpdate).length > 0) {
|
||||
// Check and update body with external
|
||||
const okit =
|
||||
(await this.provider.getOctokit(existing.modifiedBy as Ref<PersonAccount>)) ?? container.container.octokit
|
||||
await okit?.rest.issues.updateComment({
|
||||
owner: repository.owner?.login as string,
|
||||
repo: repository.name,
|
||||
issue_number: parent.githubNumber,
|
||||
comment_id: comment.id,
|
||||
body: await this.provider.getMarkdown(existingComment.message),
|
||||
headers: {
|
||||
'X-GitHub-Api-Version': '2022-11-28'
|
||||
}
|
||||
})
|
||||
}
|
||||
if (Object.keys(update).length > 0) {
|
||||
await this.client.update(existing, update, false, new Date(comment.updated_at).getTime(), account)
|
||||
}
|
||||
}
|
||||
|
||||
private async createComment (
|
||||
info: DocSyncInfo,
|
||||
messageData: MessageData,
|
||||
parent: DocSyncInfo,
|
||||
comment: CommentExternalData,
|
||||
account: Ref<Account>
|
||||
): Promise<void> {
|
||||
const _id: Ref<ChatMessage> = info._id as unknown as Ref<ChatMessage>
|
||||
const value: AttachedData<ChatMessage> = {
|
||||
...messageData,
|
||||
attachments: 0
|
||||
}
|
||||
await this.client.addCollection(
|
||||
chunter.class.ChatMessage,
|
||||
info.space,
|
||||
parent._id,
|
||||
parent.objectClass,
|
||||
'comments',
|
||||
value,
|
||||
_id,
|
||||
new Date(comment.created_at).getTime(),
|
||||
account
|
||||
)
|
||||
}
|
||||
|
||||
async createGithubComment (
|
||||
container: ContainerFocus,
|
||||
existing: Doc | undefined,
|
||||
info: DocSyncInfo,
|
||||
parent: DocSyncInfo | undefined,
|
||||
derivedClient: TxOperations
|
||||
): Promise<DocumentUpdate<DocSyncInfo>> {
|
||||
// TODO: Use selected repository
|
||||
const repo = container.repository.find((it) => it._id === parent?.repository)
|
||||
if (repo?.nodeId === undefined) {
|
||||
// No need to sync if parent repository is not defined.
|
||||
return { needSync: githubSyncVersion }
|
||||
}
|
||||
|
||||
if (parent === undefined) {
|
||||
return {}
|
||||
}
|
||||
const chatMessage = existing as ChatMessage
|
||||
const okit =
|
||||
(await this.provider.getOctokit(chatMessage.modifiedBy as Ref<PersonAccount>)) ?? container.container.octokit
|
||||
|
||||
// No external version yet, create it.
|
||||
try {
|
||||
const result = await okit?.rest.issues.createComment({
|
||||
owner: repo.owner?.login as string,
|
||||
repo: repo.name,
|
||||
issue_number: parent.githubNumber,
|
||||
body: await this.provider.getMarkdown(chatMessage.message),
|
||||
headers: {
|
||||
'X-GitHub-Api-Version': '2022-11-28'
|
||||
}
|
||||
})
|
||||
const upd: DocumentUpdate<DocSyncInfo> = {
|
||||
parent: result?.data.html_url?.split('#')?.[0] ?? '',
|
||||
url: (result?.data.url ?? '').toLowerCase(),
|
||||
external: result?.data as CommentExternalData,
|
||||
current: result?.data,
|
||||
repository: repo._id
|
||||
}
|
||||
// We need to update in current promise, to prevent event changes.
|
||||
await derivedClient.update(info, upd)
|
||||
return {}
|
||||
} catch (err: any) {
|
||||
Analytics.handleError(err)
|
||||
this.ctx.error(err)
|
||||
return { needSync: githubSyncVersion, error: errorToObj(err) }
|
||||
}
|
||||
}
|
||||
|
||||
async externalSync (
|
||||
integration: IntegrationContainer,
|
||||
derivedClient: TxOperations,
|
||||
kind: ExternalSyncField,
|
||||
syncDocs: DocSyncInfo[],
|
||||
repository: GithubIntegrationRepository,
|
||||
project: GithubProject
|
||||
): Promise<void> {
|
||||
// No need to perform external sync for comments, so let's update marks
|
||||
const tx = derivedClient.apply('comments_github')
|
||||
for (const d of syncDocs) {
|
||||
await tx.update(d, { externalVersion: githubExternalSyncVersion })
|
||||
}
|
||||
await tx.commit()
|
||||
this.provider.sync()
|
||||
}
|
||||
|
||||
repositoryDisabled (integration: IntegrationContainer, repo: GithubIntegrationRepository): void {
|
||||
integration.synchronized.delete(`${repo._id}:comment`)
|
||||
}
|
||||
|
||||
async externalFullSync (
|
||||
integration: IntegrationContainer,
|
||||
derivedClient: TxOperations,
|
||||
projects: GithubProject[],
|
||||
repositories: GithubIntegrationRepository[]
|
||||
): Promise<void> {
|
||||
for (const repo of repositories) {
|
||||
const syncKey = `${repo._id}:comment`
|
||||
if (repo.githubProject === undefined || !repo.enabled || integration.synchronized.has(syncKey)) {
|
||||
if (!repo.enabled) {
|
||||
integration.synchronized.delete(syncKey)
|
||||
}
|
||||
continue
|
||||
}
|
||||
const prj = projects.find((it) => repo.githubProject === it._id)
|
||||
if (prj === undefined) {
|
||||
continue
|
||||
}
|
||||
|
||||
// Wait global project sync
|
||||
await integration.syncLock.get(prj._id)
|
||||
|
||||
const since = await getSince(this.client, chunter.class.ChatMessage, repo)
|
||||
|
||||
const i = integration.octokit.paginate.iterator(integration.octokit.rest.issues.listCommentsForRepo, {
|
||||
owner: repo.owner?.login as string,
|
||||
repo: repo.name,
|
||||
state: 'all',
|
||||
sort: 'updated',
|
||||
direction: 'asc',
|
||||
since,
|
||||
headers: {
|
||||
'X-GitHub-Api-Version': '2022-11-28'
|
||||
}
|
||||
})
|
||||
try {
|
||||
for await (const data of i) {
|
||||
const comments: CommentExternalData[] = data.data as any
|
||||
this.ctx.info('retrieve comments for', {
|
||||
repo: repo.name,
|
||||
comments: comments.length,
|
||||
used: data.headers['x-ratelimit-used'],
|
||||
limit: data.headers['x-ratelimit-limit'],
|
||||
workspace: this.provider.getWorkspaceId().name
|
||||
})
|
||||
await this.syncComments(repo, comments, derivedClient)
|
||||
this.provider.sync()
|
||||
}
|
||||
} catch (err: any) {
|
||||
Analytics.handleError(err)
|
||||
this.ctx.error(err)
|
||||
}
|
||||
integration.synchronized.add(syncKey)
|
||||
}
|
||||
}
|
||||
|
||||
async syncComments (
|
||||
repo: GithubIntegrationRepository,
|
||||
comments: CommentExternalData[],
|
||||
derivedClient: TxOperations
|
||||
): Promise<void> {
|
||||
if (repo.githubProject == null) {
|
||||
return
|
||||
}
|
||||
const syncInfo = await this.client.findAll<DocSyncInfo>(github.class.DocSyncInfo, {
|
||||
space: repo.githubProject,
|
||||
repository: repo._id,
|
||||
objectClass: chunter.class.ChatMessage,
|
||||
url: { $in: comments.map((it) => (it.url ?? '').toLowerCase()) }
|
||||
})
|
||||
|
||||
for (const comment of comments) {
|
||||
try {
|
||||
const existing = syncInfo.find((it) => it.url === comment.url.toLowerCase())
|
||||
const lastModified = new Date(comment.updated_at).getTime()
|
||||
if (existing === undefined) {
|
||||
await derivedClient.createDoc(github.class.DocSyncInfo, repo.githubProject, {
|
||||
url: comment.url.toLowerCase(),
|
||||
needSync: '',
|
||||
githubNumber: 0,
|
||||
objectClass: chunter.class.ChatMessage,
|
||||
external: comment,
|
||||
externalVersion: githubExternalSyncVersion,
|
||||
parent: comment.html_url.split('#')?.[0],
|
||||
repository: repo._id,
|
||||
lastModified
|
||||
})
|
||||
} else {
|
||||
if (!deepEqual(existing.external, comment) || existing.externalVersion !== githubExternalSyncVersion) {
|
||||
await derivedClient.diffUpdate(
|
||||
existing,
|
||||
{
|
||||
needSync: '',
|
||||
external: comment,
|
||||
externalVersion: githubExternalSyncVersion,
|
||||
lastModified
|
||||
},
|
||||
lastModified
|
||||
)
|
||||
this.provider.sync()
|
||||
}
|
||||
}
|
||||
} catch (err: any) {
|
||||
Analytics.handleError(err)
|
||||
this.ctx.error(err)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user