mirror of
https://github.com/hcengineering/platform.git
synced 2025-04-04 23:11:15 +00:00
548 lines
15 KiB
TypeScript
548 lines
15 KiB
TypeScript
//
|
|
// Copyright © 2020, 2021 Anticrm Platform Contributors.
|
|
// Copyright © 2021, 2022 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 activity, {
|
|
type ActivityMessage,
|
|
type DisplayDocUpdateMessage,
|
|
type DocUpdateMessage
|
|
} from '@hcengineering/activity'
|
|
import { activityMessagesComparator, combineActivityMessages } from '@hcengineering/activity-resources'
|
|
import {
|
|
SortingOrder,
|
|
getCurrentAccount,
|
|
type Class,
|
|
type Doc,
|
|
type DocumentUpdate,
|
|
type Ref,
|
|
type TxOperations,
|
|
type WithLookup
|
|
} from '@hcengineering/core'
|
|
import notification, {
|
|
notificationId,
|
|
type ActivityInboxNotification,
|
|
type Collaborators,
|
|
type DisplayInboxNotification,
|
|
type DocNotifyContext,
|
|
type InboxNotification,
|
|
type MentionInboxNotification
|
|
} from '@hcengineering/notification'
|
|
import { MessageBox, getClient } from '@hcengineering/presentation'
|
|
import { getLocation, navigate, showPopup, type Location, type ResolvedLocation } from '@hcengineering/ui'
|
|
import { get } from 'svelte/store'
|
|
|
|
import { InboxNotificationsClientImpl } from './inboxNotificationsClient'
|
|
import { type InboxData, type InboxNotificationsFilter } from './types'
|
|
|
|
export async function hasDocNotifyContextPinAction (docNotifyContext: DocNotifyContext): Promise<boolean> {
|
|
if (docNotifyContext.hidden) {
|
|
return false
|
|
}
|
|
return docNotifyContext.isPinned !== true
|
|
}
|
|
|
|
export async function hasDocNotifyContextUnpinAction (docNotifyContext: DocNotifyContext): Promise<boolean> {
|
|
if (docNotifyContext.hidden) {
|
|
return false
|
|
}
|
|
return docNotifyContext.isPinned === true
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
*/
|
|
export async function canReadNotifyContext (doc: DocNotifyContext): Promise<boolean> {
|
|
const inboxNotificationsClient = InboxNotificationsClientImpl.getClient()
|
|
|
|
return (
|
|
get(inboxNotificationsClient.inboxNotificationsByContext)
|
|
.get(doc._id)
|
|
?.some(({ isViewed }) => !isViewed) ?? false
|
|
)
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
*/
|
|
export async function canUnReadNotifyContext (doc: DocNotifyContext): Promise<boolean> {
|
|
const canReadContext = await canReadNotifyContext(doc)
|
|
return !canReadContext
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
*/
|
|
export async function readNotifyContext (doc: DocNotifyContext): Promise<void> {
|
|
const inboxClient = InboxNotificationsClientImpl.getClient()
|
|
const inboxNotifications = get(inboxClient.inboxNotificationsByContext).get(doc._id) ?? []
|
|
|
|
const doneOp = await getClient().measure('readNotifyContext')
|
|
const ops = getClient().apply(doc._id)
|
|
try {
|
|
await inboxClient.readNotifications(
|
|
ops,
|
|
inboxNotifications.map(({ _id }) => _id)
|
|
)
|
|
await ops.update(doc, { lastViewedTimestamp: Date.now() })
|
|
} finally {
|
|
await ops.commit()
|
|
await doneOp()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
*/
|
|
export async function unReadNotifyContext (doc: DocNotifyContext): Promise<void> {
|
|
const inboxClient = InboxNotificationsClientImpl.getClient()
|
|
const inboxNotifications = get(inboxClient.inboxNotificationsByContext).get(doc._id) ?? []
|
|
const notificationsToUnread = inboxNotifications.filter(({ isViewed }) => isViewed)
|
|
|
|
if (notificationsToUnread.length === 0) {
|
|
return
|
|
}
|
|
|
|
const doneOp = await getClient().measure('unReadNotifyContext')
|
|
const ops = getClient().apply(doc._id)
|
|
|
|
try {
|
|
await inboxClient.unreadNotifications(
|
|
ops,
|
|
notificationsToUnread.map(({ _id }) => _id)
|
|
)
|
|
const toUnread = inboxNotifications.find(isActivityNotification)
|
|
|
|
if (toUnread !== undefined) {
|
|
const createdOn = (toUnread as WithLookup<ActivityInboxNotification>)?.$lookup?.attachedTo?.createdOn
|
|
|
|
if (createdOn === undefined || createdOn === 0) {
|
|
return
|
|
}
|
|
|
|
await ops.diffUpdate(doc, { lastViewedTimestamp: createdOn - 1 })
|
|
}
|
|
} finally {
|
|
await ops.commit()
|
|
await doneOp()
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
*/
|
|
export async function deleteContextNotifications (doc?: DocNotifyContext): Promise<void> {
|
|
if (doc === undefined) {
|
|
return
|
|
}
|
|
|
|
const doneOp = await getClient().measure('deleteContextNotifications')
|
|
const ops = getClient().apply(doc._id)
|
|
|
|
try {
|
|
const notifications = await ops.findAll(
|
|
notification.class.InboxNotification,
|
|
{ docNotifyContext: doc._id },
|
|
{ projection: { _id: 1, _class: 1, space: 1 } }
|
|
)
|
|
|
|
for (const notification of notifications) {
|
|
await ops.removeDoc(notification._class, notification.space, notification._id)
|
|
}
|
|
await ops.update(doc, { lastViewedTimestamp: Date.now() })
|
|
} finally {
|
|
await ops.commit()
|
|
await doneOp()
|
|
}
|
|
}
|
|
|
|
enum OpWithMe {
|
|
Add = 'add',
|
|
Remove = 'remove'
|
|
}
|
|
|
|
async function updateMeInCollaborators (
|
|
client: TxOperations,
|
|
docClass: Ref<Class<Doc>>,
|
|
docId: Ref<Doc>,
|
|
op: OpWithMe
|
|
): Promise<void> {
|
|
const me = getCurrentAccount()._id
|
|
const hierarchy = client.getHierarchy()
|
|
const target = await client.findOne(docClass, { _id: docId })
|
|
if (target !== undefined) {
|
|
if (hierarchy.hasMixin(target, notification.mixin.Collaborators)) {
|
|
const collab = hierarchy.as(target, notification.mixin.Collaborators)
|
|
let collabUpdate: DocumentUpdate<Collaborators> | undefined
|
|
|
|
if (collab.collaborators.includes(me) && op === OpWithMe.Remove) {
|
|
collabUpdate = {
|
|
$pull: {
|
|
collaborators: me
|
|
}
|
|
}
|
|
} else if (!collab.collaborators.includes(me) && op === OpWithMe.Add) {
|
|
collabUpdate = {
|
|
$push: {
|
|
collaborators: me
|
|
}
|
|
}
|
|
}
|
|
|
|
if (collabUpdate !== undefined) {
|
|
await client.updateMixin(
|
|
collab._id,
|
|
collab._class,
|
|
collab.space,
|
|
notification.mixin.Collaborators,
|
|
collabUpdate
|
|
)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
*/
|
|
export async function unsubscribe (object: DocNotifyContext): Promise<void> {
|
|
const client = getClient()
|
|
await updateMeInCollaborators(client, object.attachedToClass, object.attachedTo, OpWithMe.Remove)
|
|
await client.remove(object)
|
|
}
|
|
|
|
/**
|
|
* @public
|
|
*/
|
|
export async function subscribe (docClass: Ref<Class<Doc>>, docId: Ref<Doc>): Promise<void> {
|
|
const client = getClient()
|
|
await updateMeInCollaborators(client, docClass, docId, OpWithMe.Add)
|
|
}
|
|
|
|
export async function pinDocNotifyContext (object: DocNotifyContext): Promise<void> {
|
|
const client = getClient()
|
|
|
|
await client.updateDoc(object._class, object.space, object._id, {
|
|
isPinned: true
|
|
})
|
|
}
|
|
|
|
export async function unpinDocNotifyContext (object: DocNotifyContext): Promise<void> {
|
|
const client = getClient()
|
|
|
|
await client.updateDoc(object._class, object.space, object._id, {
|
|
isPinned: false
|
|
})
|
|
}
|
|
|
|
export async function archiveAll (): Promise<void> {
|
|
const client = InboxNotificationsClientImpl.getClient()
|
|
|
|
showPopup(
|
|
MessageBox,
|
|
{
|
|
label: notification.string.ArchiveAllConfirmationTitle,
|
|
message: notification.string.ArchiveAllConfirmationMessage
|
|
},
|
|
'top',
|
|
(result?: boolean) => {
|
|
if (result === true) {
|
|
void client.deleteAllNotifications()
|
|
}
|
|
}
|
|
)
|
|
}
|
|
|
|
export async function readAll (): Promise<void> {
|
|
const client = InboxNotificationsClientImpl.getClient()
|
|
|
|
await client.readAllNotifications()
|
|
}
|
|
|
|
export async function unreadAll (): Promise<void> {
|
|
const client = InboxNotificationsClientImpl.getClient()
|
|
|
|
await client.unreadAllNotifications()
|
|
}
|
|
|
|
export function isActivityNotification (doc?: InboxNotification): doc is ActivityInboxNotification {
|
|
if (doc === undefined) return false
|
|
return doc._class === notification.class.ActivityInboxNotification
|
|
}
|
|
|
|
export function isMentionNotification (doc?: InboxNotification): doc is MentionInboxNotification {
|
|
if (doc === undefined) return false
|
|
return doc._class === notification.class.MentionInboxNotification
|
|
}
|
|
|
|
export async function getDisplayInboxNotifications (
|
|
notifications: Array<WithLookup<InboxNotification>>,
|
|
filter: InboxNotificationsFilter = 'all',
|
|
objectClass?: Ref<Class<Doc>>
|
|
): Promise<DisplayInboxNotification[]> {
|
|
const result: DisplayInboxNotification[] = []
|
|
const activityNotifications: Array<WithLookup<ActivityInboxNotification>> = []
|
|
|
|
for (const notification of notifications) {
|
|
if (filter === 'unread' && notification.isViewed) {
|
|
continue
|
|
}
|
|
|
|
if (filter === 'read' && !notification.isViewed) {
|
|
continue
|
|
}
|
|
|
|
if (isActivityNotification(notification)) {
|
|
activityNotifications.push(notification)
|
|
} else {
|
|
result.push(notification)
|
|
}
|
|
}
|
|
|
|
const messages: ActivityMessage[] = activityNotifications
|
|
.map((activityNotification) => activityNotification.$lookup?.attachedTo)
|
|
.filter((message): message is ActivityMessage => {
|
|
if (message === undefined) {
|
|
return false
|
|
}
|
|
if (objectClass === undefined) {
|
|
return true
|
|
}
|
|
if (message._class !== activity.class.DocUpdateMessage) {
|
|
return false
|
|
}
|
|
|
|
return (message as DocUpdateMessage).objectClass === objectClass
|
|
})
|
|
|
|
const combinedMessages = await combineActivityMessages(
|
|
messages.sort(activityMessagesComparator),
|
|
SortingOrder.Descending
|
|
)
|
|
|
|
for (const message of combinedMessages) {
|
|
if (message._class === activity.class.DocUpdateMessage) {
|
|
const displayMessage = message as DisplayDocUpdateMessage
|
|
const ids: Array<Ref<ActivityMessage>> = displayMessage.combinedMessagesIds ?? [displayMessage._id]
|
|
const activityNotification = activityNotifications.find(({ attachedTo }) => attachedTo === message._id)
|
|
|
|
if (activityNotification === undefined) {
|
|
continue
|
|
}
|
|
|
|
const displayNotification = {
|
|
...activityNotification,
|
|
combinedIds: activityNotifications.filter(({ attachedTo }) => ids.includes(attachedTo)).map(({ _id }) => _id)
|
|
}
|
|
|
|
result.push(displayNotification)
|
|
} else {
|
|
const activityNotification = activityNotifications.find(({ attachedTo }) => attachedTo === message._id)
|
|
if (activityNotification !== undefined) {
|
|
result.push({
|
|
...activityNotification,
|
|
combinedIds: [activityNotification._id]
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
return result.sort(
|
|
(notification1, notification2) =>
|
|
(notification2.createdOn ?? notification2.modifiedOn) - (notification1.createdOn ?? notification1.modifiedOn)
|
|
)
|
|
}
|
|
|
|
export async function getDisplayInboxData (
|
|
notificationsByContext: Map<Ref<DocNotifyContext>, InboxNotification[]>,
|
|
filter: InboxNotificationsFilter = 'all',
|
|
objectClass?: Ref<Class<Doc>>
|
|
): Promise<InboxData> {
|
|
const result: InboxData = new Map()
|
|
|
|
for (const key of notificationsByContext.keys()) {
|
|
const notifications = notificationsByContext.get(key) ?? []
|
|
|
|
const displayNotifications = await getDisplayInboxNotifications(notifications, filter, objectClass)
|
|
|
|
if (displayNotifications.length > 0) {
|
|
result.set(key, displayNotifications)
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
export async function hasInboxNotifications (
|
|
notificationsByContext: Map<Ref<DocNotifyContext>, InboxNotification[]>
|
|
): Promise<boolean> {
|
|
const unreadInboxData = await getDisplayInboxData(notificationsByContext, 'unread')
|
|
|
|
return unreadInboxData.size > 0
|
|
}
|
|
|
|
export async function getNotificationsCount (
|
|
context: DocNotifyContext | undefined,
|
|
notifications: InboxNotification[] = []
|
|
): Promise<number> {
|
|
if (context === undefined || notifications.length === 0) {
|
|
return 0
|
|
}
|
|
|
|
const unreadNotifications = await getDisplayInboxNotifications(notifications, 'unread')
|
|
|
|
return unreadNotifications.length
|
|
}
|
|
|
|
export async function resolveLocation (loc: Location): Promise<ResolvedLocation | undefined> {
|
|
if (loc.path[2] !== notificationId) {
|
|
return undefined
|
|
}
|
|
|
|
const [_id, _class] = decodeObjectURI(loc.path[3])
|
|
|
|
if (_id === undefined || _class === undefined) {
|
|
return {
|
|
loc: {
|
|
path: [loc.path[0], loc.path[1], notificationId],
|
|
fragment: undefined
|
|
},
|
|
defaultLocation: {
|
|
path: [loc.path[0], loc.path[1], notificationId],
|
|
fragment: undefined
|
|
}
|
|
}
|
|
}
|
|
|
|
return await generateLocation(loc, _id, _class)
|
|
}
|
|
|
|
async function generateLocation (
|
|
loc: Location,
|
|
_id: Ref<Doc>,
|
|
_class: Ref<Class<Doc>>
|
|
): Promise<ResolvedLocation | undefined> {
|
|
const client = getClient()
|
|
|
|
const appComponent = loc.path[0] ?? ''
|
|
const workspace = loc.path[1] ?? ''
|
|
const threadId = loc.path[4] as Ref<ActivityMessage> | undefined
|
|
|
|
const thread =
|
|
threadId !== undefined ? await client.findOne(activity.class.ActivityMessage, { _id: threadId }) : undefined
|
|
|
|
if (thread === undefined) {
|
|
return {
|
|
loc: {
|
|
path: [appComponent, workspace, notificationId, encodeObjectURI(_id, _class)],
|
|
fragment: undefined,
|
|
query: { ...loc.query }
|
|
},
|
|
defaultLocation: {
|
|
path: [appComponent, workspace, notificationId, encodeObjectURI(_id, _class)],
|
|
fragment: undefined,
|
|
query: { ...loc.query }
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
loc: {
|
|
path: [appComponent, workspace, notificationId, encodeObjectURI(_id, _class), threadId as string],
|
|
fragment: undefined,
|
|
query: { ...loc.query }
|
|
},
|
|
defaultLocation: {
|
|
path: [appComponent, workspace, notificationId, encodeObjectURI(_id, _class), threadId as string],
|
|
fragment: undefined,
|
|
query: { ...loc.query }
|
|
}
|
|
}
|
|
}
|
|
|
|
export function decodeObjectURI (value: string): [Ref<Doc>, Ref<Class<Doc>>] {
|
|
return decodeURIComponent(value).split('|') as [Ref<Doc>, Ref<Class<Doc>>]
|
|
}
|
|
|
|
function encodeObjectURI (_id: Ref<Doc>, _class: Ref<Class<Doc>>): string {
|
|
return encodeURIComponent([_id, _class].join('|'))
|
|
}
|
|
|
|
export function openInboxDoc (
|
|
_id?: Ref<Doc>,
|
|
_class?: Ref<Class<Doc>>,
|
|
thread?: Ref<ActivityMessage>,
|
|
message?: Ref<ActivityMessage>
|
|
): void {
|
|
const loc = getLocation()
|
|
|
|
if (loc.path[2] !== notificationId) {
|
|
return
|
|
}
|
|
|
|
if (_id === undefined || _class === undefined) {
|
|
loc.query = { message: null }
|
|
loc.path.length = 3
|
|
navigate(loc)
|
|
return
|
|
}
|
|
|
|
loc.path[3] = encodeObjectURI(_id, _class)
|
|
|
|
if (thread !== undefined) {
|
|
loc.path[4] = thread
|
|
loc.path.length = 5
|
|
} else {
|
|
loc.path[4] = ''
|
|
loc.path.length = 4
|
|
}
|
|
|
|
loc.query = { ...loc.query, message: message ?? null }
|
|
|
|
navigate(loc)
|
|
}
|
|
|
|
export async function checkPermission (value: boolean): Promise<boolean> {
|
|
if (!value) return true
|
|
if ('Notification' in window) {
|
|
if (Notification?.permission === 'denied') return false
|
|
if (Notification?.permission === 'granted') return true
|
|
if (Notification?.permission === 'default') {
|
|
const res = await Notification?.requestPermission()
|
|
return res === 'granted'
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
export async function askPermission (): Promise<void> {
|
|
if ('Notification' in window && Notification?.permission === 'default') {
|
|
await Notification?.requestPermission()
|
|
}
|
|
}
|
|
|
|
export function notify (title: string, body: string, _id?: string, onClick?: () => void): void {
|
|
if ('Notification' in window && Notification?.permission === 'granted') {
|
|
const req: NotificationOptions = {
|
|
body
|
|
}
|
|
if (_id !== undefined) {
|
|
req.tag = _id
|
|
}
|
|
const notification = new Notification(title, req)
|
|
if (onClick !== undefined) {
|
|
notification.onclick = onClick
|
|
}
|
|
}
|
|
}
|