mirror of
https://github.com/hcengineering/platform.git
synced 2025-05-13 10:53:06 +00:00
380 lines
13 KiB
TypeScript
380 lines
13 KiB
TypeScript
//
|
|
// Copyright © 2024 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 { ChatMessage } from '@hcengineering/chunter'
|
|
import { AttachedDoc, Tx, TxCreateDoc, TxCUD } from '@hcengineering/core'
|
|
import { ActivityInboxNotification, MentionInboxNotification } from '@hcengineering/notification'
|
|
import { TriggerControl } from '@hcengineering/server-core'
|
|
|
|
// async function isDirectAvailable (direct: DirectMessage, control: TriggerControl): Promise<boolean> {
|
|
// const { members } = direct
|
|
|
|
// if (!members.includes(aiBot.account.AIBot)) {
|
|
// return false
|
|
// }
|
|
|
|
// const personAccounts = await control.modelDb.findAll(contact.class.PersonAccount, {
|
|
// _id: { $in: members as PersonId[] }
|
|
// })
|
|
// const persons = new Set(personAccounts.map((account) => account.person))
|
|
|
|
// return persons.size === 2
|
|
// }
|
|
|
|
// async function getMessageDoc (message: ChatMessage, control: TriggerControl): Promise<Doc | undefined> {
|
|
// if (control.hierarchy.isDerived(message._class, chunter.class.ThreadMessage)) {
|
|
// const thread = message as ThreadMessage
|
|
// const _id = thread.objectId
|
|
// const _class = thread.objectClass
|
|
|
|
// return (await control.findAll(control.ctx, _class, { _id }))[0]
|
|
// } else {
|
|
// const _id = message.attachedTo
|
|
// const _class = message.attachedToClass
|
|
|
|
// return (await control.findAll(control.ctx, _class, { _id }))[0]
|
|
// }
|
|
// }
|
|
|
|
// function getMessageData (doc: Doc, message: ChatMessage, email: string): AIMessageEventRequest {
|
|
// return {
|
|
// type: AIEventType.Message,
|
|
// createdOn: message.createdOn ?? message.modifiedOn,
|
|
// objectId: message.attachedTo,
|
|
// objectClass: message.attachedToClass,
|
|
// objectSpace: doc.space,
|
|
// collection: message.collection,
|
|
// messageClass: message._class,
|
|
// messageId: message._id,
|
|
// message: message.message,
|
|
// user: message.createdBy ?? message.modifiedBy,
|
|
// email
|
|
// }
|
|
// }
|
|
|
|
// function getThreadMessageData (message: ThreadMessage, email: string): AIMessageEventRequest {
|
|
// return {
|
|
// type: AIEventType.Message,
|
|
// createdOn: message.createdOn ?? message.modifiedOn,
|
|
// objectId: message.attachedTo,
|
|
// objectClass: message.attachedToClass,
|
|
// objectSpace: message.space,
|
|
// collection: message.collection,
|
|
// messageClass: message._class,
|
|
// message: message.message,
|
|
// messageId: message._id,
|
|
// user: message.createdBy ?? message.modifiedBy,
|
|
// email
|
|
// }
|
|
// }
|
|
|
|
// async function getThreadParent (control: TriggerControl, message: ChatMessage): Promise<Ref<ChatMessage> | undefined> {
|
|
// if (!control.hierarchy.isDerived(message.attachedToClass, chunter.class.ChatMessage)) {
|
|
// return undefined
|
|
// }
|
|
|
|
// const parentInfo = (
|
|
// await control.findAll(control.ctx, message.attachedToClass, {
|
|
// _id: message.attachedTo as Ref<ChatMessage>,
|
|
// [aiBot.mixin.TransferredMessage]: { $exists: true }
|
|
// })
|
|
// )[0]
|
|
|
|
// if (parentInfo !== undefined) {
|
|
// return control.hierarchy.as(parentInfo, aiBot.mixin.TransferredMessage).messageId
|
|
// }
|
|
|
|
// return message.attachedTo as Ref<ChatMessage>
|
|
// }
|
|
|
|
// async function createTransferEvent (
|
|
// control: TriggerControl,
|
|
// message: ChatMessage,
|
|
// account: any,
|
|
// data: AIMessageEventRequest
|
|
// ): Promise<AITransferEventRequest | undefined> {
|
|
// if (account.role !== AccountRole.Owner) {
|
|
// return
|
|
// }
|
|
|
|
// const supportWorkspaceId = getSupportWorkspaceId()
|
|
|
|
// if (supportWorkspaceId === undefined) {
|
|
// return
|
|
// }
|
|
|
|
// return {
|
|
// type: AIEventType.Transfer,
|
|
// createdOn: message.createdOn ?? message.modifiedOn,
|
|
// messageClass: data.messageClass,
|
|
// message: message.message,
|
|
// collection: data.collection,
|
|
// toWorkspace: supportWorkspaceId,
|
|
// toPersonId: account,
|
|
// fromWorkspace: control.workspace.uuid,
|
|
// // fromWorkspaceName: control.workspace.workspaceName,
|
|
// fromWorkspaceUrl: control.workspace.url,
|
|
// messageId: message._id,
|
|
// parentMessageId: await getThreadParent(control, message)
|
|
// }
|
|
// }
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
async function onBotDirectMessageSend (control: TriggerControl, message: ChatMessage): Promise<void> {
|
|
// TODO: FIXME
|
|
// const account = control.modelDb.findAllSync(contact.class.PersonAccount, {
|
|
// _id: (message.createdBy ?? message.modifiedBy) as PersonId
|
|
// })[0]
|
|
// if (account === undefined) {
|
|
// return
|
|
// }
|
|
// const direct = (await getMessageDoc(message, control)) as DirectMessage
|
|
// if (direct === undefined) {
|
|
// return
|
|
// }
|
|
// const isAvailable = await isDirectAvailable(direct, control)
|
|
// if (!isAvailable) {
|
|
// return
|
|
// }
|
|
// let messageEvent: AIMessageEventRequest
|
|
// if (control.hierarchy.isDerived(message._class, chunter.class.ThreadMessage)) {
|
|
// messageEvent = getThreadMessageData(message as ThreadMessage, account.email)
|
|
// } else {
|
|
// messageEvent = getMessageData(direct, message, account.email)
|
|
// }
|
|
// const transferEvent = await createTransferEvent(control, message, account, messageEvent)
|
|
// const events = transferEvent !== undefined ? [messageEvent, transferEvent] : [messageEvent]
|
|
// await sendAIEvents(events, control.workspace.uuid, control.ctx)
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/no-unused-vars
|
|
async function onSupportWorkspaceMessage (control: TriggerControl, message: ChatMessage): Promise<void> {
|
|
// TODO: FIXME
|
|
// const supportWorkspaceId = getSupportWorkspaceId()
|
|
// if (supportWorkspaceId === undefined) {
|
|
// return
|
|
// }
|
|
// if (control.workspace.uuid !== supportWorkspaceId) {
|
|
// return
|
|
// }
|
|
// if (!control.hierarchy.isDerived(message.attachedToClass, analyticsCollector.class.OnboardingChannel)) {
|
|
// return
|
|
// }
|
|
// const channel = (await getMessageDoc(message, control)) as OnboardingChannel
|
|
// if (channel === undefined) {
|
|
// return
|
|
// }
|
|
// const { workspaceId, email } = channel
|
|
// const account = control.modelDb.findAllSync(contact.class.PersonAccount, {
|
|
// _id: (message.createdBy ?? message.modifiedBy) as PersonId
|
|
// })[0]
|
|
// let data: AIMessageEventRequest
|
|
// if (control.hierarchy.isDerived(message._class, chunter.class.ThreadMessage)) {
|
|
// data = getThreadMessageData(message as ThreadMessage, account.email)
|
|
// } else {
|
|
// data = getMessageData(channel, message, account.email)
|
|
// }
|
|
// const transferEvent: AITransferEventRequest = {
|
|
// type: AIEventType.Transfer,
|
|
// createdOn: data.createdOn,
|
|
// messageClass: data.messageClass,
|
|
// message: message.message,
|
|
// collection: data.collection,
|
|
// toEmail: email,
|
|
// toWorkspace: workspaceId,
|
|
// fromWorkspace: control.workspace.uuid,
|
|
// fromWorkspaceUrl: control.workspace.url,
|
|
// // fromWorkspaceName: control.workspace.workspaceName,
|
|
// messageId: message._id,
|
|
// parentMessageId: await getThreadParent(control, message)
|
|
// }
|
|
// await sendAIEvents([transferEvent], control.workspace.uuid, control.ctx)
|
|
}
|
|
|
|
export async function OnMessageSend (originTxs: TxCUD<AttachedDoc>[], control: TriggerControl): Promise<Tx[]> {
|
|
// TODO: FIXME
|
|
// const { hierarchy } = control
|
|
// const txes = originTxs.filter(
|
|
// (it) =>
|
|
// it._class === core.class.TxCreateDoc &&
|
|
// hierarchy.isDerived(it.objectClass, chunter.class.ChatMessage) &&
|
|
// !(it.modifiedBy === aiBot.account.AIBot || it.modifiedBy === core.account.System)
|
|
// )
|
|
// if (txes.length === 0) {
|
|
// return []
|
|
// }
|
|
// for (const tx of txes) {
|
|
// const isThread = hierarchy.isDerived(tx.objectClass, chunter.class.ThreadMessage)
|
|
// const message = TxProcessor.createDoc2Doc(tx as TxCreateDoc<ChatMessage>)
|
|
//
|
|
// const docClass = isThread ? (message as ThreadMessage).objectClass : message.attachedToClass
|
|
//
|
|
// if (!hierarchy.isDerived(docClass, chunter.class.ChunterSpace)) {
|
|
// continue
|
|
// }
|
|
//
|
|
// if (docClass === chunter.class.DirectMessage) {
|
|
// await onBotDirectMessageSend(control, message)
|
|
// }
|
|
//
|
|
// if (docClass === analyticsCollector.class.OnboardingChannel) {
|
|
// await onSupportWorkspaceMessage(control, message)
|
|
// }
|
|
// }
|
|
|
|
return []
|
|
}
|
|
|
|
export async function OnMention (tx: TxCreateDoc<MentionInboxNotification>[], control: TriggerControl): Promise<Tx[]> {
|
|
// Note: temporally commented until open ai will be added
|
|
// if (tx.objectClass !== notification.class.MentionInboxNotification || tx._class !== core.class.TxCreateDoc) {
|
|
// return []
|
|
// }
|
|
//
|
|
// const mention = TxProcessor.createDoc2Doc(tx)
|
|
//
|
|
// if (mention.user !== aiBot.account.AIBot) {
|
|
// return []
|
|
// }
|
|
//
|
|
// if (!control.hierarchy.isDerived(mention.mentionedInClass, chunter.class.ChatMessage)) {
|
|
// return []
|
|
// }
|
|
//
|
|
// const message = (
|
|
// await control.findAll<ChatMessage>(mention.mentionedInClass, { _id: mention.mentionedIn as Ref<ChatMessage> })
|
|
// )[0]
|
|
//
|
|
// if (message === undefined) {
|
|
// return []
|
|
// }
|
|
//
|
|
// await createResponseEvent(message, control)
|
|
|
|
return []
|
|
}
|
|
|
|
export async function OnMessageNotified (
|
|
tx: TxCreateDoc<ActivityInboxNotification>[],
|
|
control: TriggerControl
|
|
): Promise<Tx[]> {
|
|
// Note: temporally commented until open ai will be added
|
|
// if (tx.objectClass !== notification.class.ActivityInboxNotification || tx._class !== core.class.TxCreateDoc) {
|
|
// return []
|
|
// }
|
|
//
|
|
// const doc = TxProcessor.createDoc2Doc(tx)
|
|
//
|
|
// if (doc.user !== aiBot.account.AIBot) {
|
|
// return []
|
|
// }
|
|
//
|
|
// if (!control.hierarchy.isDerived(doc.attachedToClass, chunter.class.ChatMessage)) {
|
|
// return []
|
|
// }
|
|
//
|
|
// const personAccount = await control.modelDb.findOne(contact.class.PersonAccount, { email: aiBotAccountEmail })
|
|
//
|
|
// if (personAccount === undefined) {
|
|
// return []
|
|
// }
|
|
//
|
|
// const message = (
|
|
// await control.findAll<ChatMessage>(doc.attachedToClass, { _id: doc.attachedTo as Ref<ChatMessage> })
|
|
// )[0]
|
|
//
|
|
// if (message === undefined) {
|
|
// return []
|
|
// }
|
|
//
|
|
// if (isDocMentioned(personAccount.person, message.message)) {
|
|
// return await createResponseEvent(message, control)
|
|
// }
|
|
//
|
|
// if (!control.hierarchy.isDerived(message._class, chunter.class.ThreadMessage)) {
|
|
// return []
|
|
// }
|
|
//
|
|
// const thread = message as ThreadMessage
|
|
// TODO: do we really need to find parent???
|
|
// const parent = (await control.findAll(thread.attachedToClass, { _id: thread.attachedTo }))[0]
|
|
//
|
|
// if (parent === undefined) {
|
|
// return []
|
|
// }
|
|
//
|
|
// if (parent.createdBy === aiBot.account.AIBot) {
|
|
// return await createResponseEvent(message, control)
|
|
// }
|
|
|
|
return []
|
|
}
|
|
|
|
export async function OnUserStatus (txes: Tx[], control: TriggerControl): Promise<Tx[]> {
|
|
// TODO: FIXME
|
|
return [] // Not implemented
|
|
// for (const originTx of txes) {
|
|
// const tx = originTx as TxCUD<UserStatus>
|
|
|
|
// if (
|
|
// tx.objectClass !== core.class.UserStatus ||
|
|
// ![core.class.TxCreateDoc, core.class.TxUpdateDoc].includes(tx._class)
|
|
// ) {
|
|
// continue
|
|
// }
|
|
|
|
// if (tx._class === core.class.TxCreateDoc) {
|
|
// const createTx = tx as TxCreateDoc<UserStatus>
|
|
// const status = TxProcessor.createDoc2Doc(createTx)
|
|
// if (status.user === aiBot.account.AIBot || status.user === core.account.System || !status.online) {
|
|
// continue
|
|
// }
|
|
// }
|
|
|
|
// if (tx._class === core.class.TxUpdateDoc) {
|
|
// const updateTx = tx as TxUpdateDoc<UserStatus>
|
|
// const val = updateTx.operations.online
|
|
// if (val !== true) {
|
|
// continue
|
|
// }
|
|
|
|
// const status = (await control.findAll(control.ctx, core.class.UserStatus, { _id: updateTx.objectId }))[0]
|
|
// if (status === undefined || status.user === aiBot.account.AIBot || status.user === core.account.System) {
|
|
// continue
|
|
// }
|
|
// }
|
|
|
|
// const account = control.modelDb.findAllSync(contact.class.PersonAccount, { email: aiBotAccountEmail })[0]
|
|
|
|
// if (account !== undefined) {
|
|
// continue
|
|
// }
|
|
|
|
// await createAccountRequest(control.workspace, control.ctx)
|
|
// }
|
|
|
|
// return []
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
|
|
export default async () => ({
|
|
trigger: {
|
|
OnMessageSend,
|
|
OnMention,
|
|
OnMessageNotified,
|
|
OnUserStatus
|
|
}
|
|
})
|