mirror of
https://github.com/outline/outline.git
synced 2026-11-20 21:23:06 +03:00
* feat: Show export completion in the notifications center Exports now create an in-app notification with the export name, status, format and a download button. Export emails are sent from the notification with a one-minute delay, so they are skipped once the notification is read. * fix: Avoid nested button in export notification and keep it after delete * fix: Revoke export notifications when access to the source is lost * fix: Remove icon from export notification download cue
360 lines
10 KiB
TypeScript
360 lines
10 KiB
TypeScript
import type { TFunction } from "i18next";
|
|
import { action, computed, observable } from "mobx";
|
|
import type { NotificationData } from "@shared/types";
|
|
import { FileOperationState, NotificationEventType } from "@shared/types";
|
|
import {
|
|
collectionPath,
|
|
commentPath,
|
|
documentPath,
|
|
settingsPath,
|
|
} from "~/utils/routeHelpers";
|
|
import Collection from "./Collection";
|
|
import Comment from "./Comment";
|
|
import Document from "./Document";
|
|
import FileOperation from "./FileOperation";
|
|
import Group from "./Group";
|
|
import User from "./User";
|
|
import Model from "./base/Model";
|
|
import Field from "./decorators/Field";
|
|
import Relation from "./decorators/Relation";
|
|
|
|
export type NotificationFilter =
|
|
| "all"
|
|
| "mentions"
|
|
| "comments"
|
|
| "reactions"
|
|
| "documents"
|
|
| "collections"
|
|
| "system";
|
|
|
|
class Notification extends Model {
|
|
static modelName = "Notification";
|
|
|
|
constructor(fields: Record<string, unknown>, store: Model["store"]) {
|
|
super(fields, store);
|
|
this.initialize(fields);
|
|
}
|
|
|
|
static filterCategories: Record<NotificationFilter, NotificationEventType[]> =
|
|
{
|
|
all: [],
|
|
mentions: [
|
|
NotificationEventType.MentionedInDocument,
|
|
NotificationEventType.MentionedInComment,
|
|
NotificationEventType.GroupMentionedInDocument,
|
|
NotificationEventType.GroupMentionedInComment,
|
|
],
|
|
comments: [
|
|
NotificationEventType.CreateComment,
|
|
NotificationEventType.ResolveComment,
|
|
NotificationEventType.ReactionsCreate,
|
|
],
|
|
reactions: [NotificationEventType.ReactionsCreate],
|
|
documents: [
|
|
NotificationEventType.PublishDocument,
|
|
NotificationEventType.UpdateDocument,
|
|
NotificationEventType.CreateRevision,
|
|
NotificationEventType.AddUserToDocument,
|
|
NotificationEventType.RequestDocumentAccess,
|
|
],
|
|
collections: [
|
|
NotificationEventType.CreateCollection,
|
|
NotificationEventType.AddUserToCollection,
|
|
],
|
|
system: [
|
|
NotificationEventType.InviteAccepted,
|
|
NotificationEventType.Onboarding,
|
|
NotificationEventType.Features,
|
|
NotificationEventType.ExportCompleted,
|
|
NotificationEventType.AddUserToGroup,
|
|
NotificationEventType.RemoveUserFromGroup,
|
|
],
|
|
};
|
|
|
|
/**
|
|
* The date the notification was marked as read.
|
|
*/
|
|
@Field
|
|
@observable
|
|
viewedAt: Date | null;
|
|
|
|
/**
|
|
* The date the notification was archived.
|
|
*/
|
|
@Field
|
|
@observable
|
|
archivedAt: Date | null;
|
|
|
|
/**
|
|
* Request ID on notifications for access requests.
|
|
*/
|
|
@Field
|
|
@observable
|
|
accessRequestId?: string = undefined;
|
|
/**
|
|
* Status of the associated access request.
|
|
*/
|
|
@Field
|
|
@observable
|
|
accessRequestStatus?: string = undefined;
|
|
/**
|
|
* The user that triggered the notification.
|
|
*/
|
|
@Relation(() => User)
|
|
actor?: User;
|
|
|
|
/**
|
|
* The document ID that the notification is associated with.
|
|
*/
|
|
documentId?: string;
|
|
|
|
/**
|
|
* The document that the notification is associated with.
|
|
*/
|
|
@Relation(() => Document, { onDelete: "cascade" })
|
|
document?: Document;
|
|
|
|
/**
|
|
* The collection ID that the notification is associated with.
|
|
*/
|
|
collectionId?: string;
|
|
|
|
/**
|
|
* The collection that the notification is associated with.
|
|
*/
|
|
@Relation(() => Collection, { onDelete: "cascade" })
|
|
collection?: Collection;
|
|
|
|
/**
|
|
* The group ID that the notification is associated with.
|
|
*/
|
|
groupId?: string;
|
|
|
|
/**
|
|
* The group that the notification is associated with.
|
|
*/
|
|
@Relation(() => Group, { onDelete: "cascade" })
|
|
group?: Group;
|
|
|
|
/**
|
|
* The file operation ID that the notification is associated with.
|
|
*/
|
|
fileOperationId?: string;
|
|
|
|
/**
|
|
* The file operation that the notification is associated with.
|
|
*/
|
|
@Relation(() => FileOperation, { onDelete: "ignore" })
|
|
fileOperation?: FileOperation;
|
|
|
|
commentId?: string;
|
|
|
|
/**
|
|
* The comment that the notification is associated with.
|
|
*/
|
|
@Relation(() => Comment, { onDelete: "cascade" })
|
|
comment?: Comment;
|
|
|
|
/**
|
|
* The type of notification.
|
|
*/
|
|
event: NotificationEventType;
|
|
|
|
/**
|
|
* Additional data associated with the notification.
|
|
*/
|
|
data: NotificationData;
|
|
|
|
/**
|
|
* Mark the notification as read or unread
|
|
*
|
|
* @returns A promise that resolves when the notification has been saved.
|
|
*/
|
|
@action
|
|
toggleRead() {
|
|
return this.save({ viewedAt: this.viewedAt ? null : new Date() });
|
|
}
|
|
|
|
/**
|
|
* Mark the notification as read
|
|
*
|
|
* @returns A promise that resolves when the notification has been saved.
|
|
*/
|
|
@action
|
|
markAsRead() {
|
|
if (this.viewedAt) {
|
|
return;
|
|
}
|
|
|
|
return this.save({ viewedAt: new Date() });
|
|
}
|
|
|
|
/**
|
|
* Archive the notification
|
|
*
|
|
* @returns A promise that resolves when the notification has been archived.
|
|
*/
|
|
@action
|
|
archive() {
|
|
if (this.archivedAt) {
|
|
return;
|
|
}
|
|
|
|
return this.save({ archivedAt: new Date() });
|
|
}
|
|
|
|
/**
|
|
* Returns translated text that describes the notification
|
|
*
|
|
* @param t - The translation function
|
|
* @returns The event text
|
|
*/
|
|
eventText(t: TFunction): string {
|
|
switch (this.event) {
|
|
case NotificationEventType.PublishDocument:
|
|
return t("published");
|
|
case NotificationEventType.UpdateDocument:
|
|
case NotificationEventType.CreateRevision:
|
|
return t("edited");
|
|
case NotificationEventType.CreateCollection:
|
|
return t("created the collection");
|
|
case NotificationEventType.MentionedInDocument:
|
|
case NotificationEventType.MentionedInComment:
|
|
return t("mentioned you in");
|
|
case NotificationEventType.GroupMentionedInComment:
|
|
case NotificationEventType.GroupMentionedInDocument:
|
|
return t("mentioned your group in");
|
|
case NotificationEventType.CreateComment:
|
|
return t("left a comment on");
|
|
case NotificationEventType.ResolveComment:
|
|
return t("resolved a comment on");
|
|
case NotificationEventType.ReactionsCreate:
|
|
return t("reacted {{ emoji }} to your comment on", {
|
|
emoji: this.data.emoji,
|
|
});
|
|
case NotificationEventType.AddUserToDocument:
|
|
return t("shared");
|
|
case NotificationEventType.AddUserToCollection:
|
|
return t("invited you to");
|
|
case NotificationEventType.AddUserToGroup:
|
|
return t("added you to the group");
|
|
case NotificationEventType.RemoveUserFromGroup:
|
|
return t("removed you from the group");
|
|
case NotificationEventType.ExportCompleted:
|
|
switch (this.fileOperation?.state) {
|
|
case FileOperationState.Complete:
|
|
return t("export completed");
|
|
case FileOperationState.Error:
|
|
return t("export failed");
|
|
default:
|
|
return t("export is no longer available");
|
|
}
|
|
case NotificationEventType.RequestDocumentAccess:
|
|
if (this.accessRequestStatus === "approved") {
|
|
return t("was granted access to");
|
|
}
|
|
if (this.accessRequestStatus === "dismissed") {
|
|
return t("requested access to");
|
|
}
|
|
return t("is requesting access to");
|
|
default:
|
|
return this.event;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns translated text for the subject of the notification. This is the
|
|
* name of the associated document, collection, group, or export.
|
|
*
|
|
* @param t - The translation function.
|
|
* @returns The subject.
|
|
*/
|
|
subject(t: TFunction): string {
|
|
if (this.fileOperationId) {
|
|
return this.fileOperation?.displayName ?? t("Your");
|
|
}
|
|
if (this.documentId) {
|
|
return this.document?.title ?? t("a document");
|
|
}
|
|
if (this.collectionId) {
|
|
return this.collection?.displayName ?? t("a collection");
|
|
}
|
|
if (this.groupId) {
|
|
return this.group?.name ?? t("a group");
|
|
}
|
|
return t("Unknown");
|
|
}
|
|
|
|
/**
|
|
* Returns the URL to download the file of the notification, if available.
|
|
*
|
|
* @returns The download URL.
|
|
*/
|
|
@computed
|
|
get downloadUrl(): string | undefined {
|
|
return this.fileOperation?.state === FileOperationState.Complete
|
|
? this.fileOperation.downloadUrl
|
|
: undefined;
|
|
}
|
|
|
|
/**
|
|
* Returns the path to the model associated with the notification that can be
|
|
* used with the router.
|
|
*
|
|
* @returns The router path.
|
|
*/
|
|
@computed
|
|
get path() {
|
|
switch (this.event) {
|
|
case NotificationEventType.PublishDocument:
|
|
case NotificationEventType.UpdateDocument:
|
|
case NotificationEventType.CreateRevision: {
|
|
return this.document ? documentPath(this.document) : "";
|
|
}
|
|
case NotificationEventType.AddUserToCollection:
|
|
case NotificationEventType.CreateCollection: {
|
|
const collection = this.collectionId
|
|
? this.store.rootStore.collections.get(this.collectionId)
|
|
: undefined;
|
|
return collection ? collectionPath(collection) : "";
|
|
}
|
|
case NotificationEventType.RequestDocumentAccess:
|
|
case NotificationEventType.AddUserToDocument:
|
|
case NotificationEventType.GroupMentionedInDocument:
|
|
case NotificationEventType.MentionedInDocument: {
|
|
return this.document?.path;
|
|
}
|
|
case NotificationEventType.GroupMentionedInComment:
|
|
case NotificationEventType.MentionedInComment:
|
|
case NotificationEventType.ResolveComment:
|
|
case NotificationEventType.CreateComment:
|
|
case NotificationEventType.ReactionsCreate: {
|
|
return this.document && this.comment
|
|
? commentPath(this.document, this.comment)
|
|
: this.document?.path;
|
|
}
|
|
case NotificationEventType.InviteAccepted: {
|
|
return settingsPath("users");
|
|
}
|
|
case NotificationEventType.Onboarding:
|
|
case NotificationEventType.Features: {
|
|
return "";
|
|
}
|
|
case NotificationEventType.ExportCompleted: {
|
|
return settingsPath("export");
|
|
}
|
|
case NotificationEventType.AddUserToGroup:
|
|
case NotificationEventType.RemoveUserFromGroup: {
|
|
return this.groupId
|
|
? settingsPath("groups", this.groupId, "members")
|
|
: "";
|
|
}
|
|
default:
|
|
this.event satisfies never;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
export default Notification;
|