feat: implementions of announcement creation function

apps/app/src/features/announcement/client/utils/announcement-utils.ts

@@ -0,0 +1,14 @@
+import { apiv3Post } from '../../../../client/util/apiv3-client';
+import { toastError } from '../../../../client/util/toastr';
+import { type ParamsForAnnouncement } from '../../interfaces/announcement';
+
+export const createAnnouncement = async(params: ParamsForAnnouncement): Promise<void> => {
+
+  try {
+    await apiv3Post('/announcement/do-announcement', params);
+  }
+  catch (err) {
+    toastError(err);
+  }
+
+};

apps/app/src/features/announcement/interfaces/announcement.ts

@@ -0,0 +1,25 @@
+import type {
+  IUser, IPage, Ref, HasObjectId,
+} from '@growi/core';
+
+import type { AnnouncementStatusesType } from '../server/events/announcement-utils';
+
+export interface IAnnouncement {
+  sender: Ref<IUser>
+  comment?: string
+  emoji?: string
+  isReadReceiptTrackingEnabled: boolean
+  pageId: Ref<IPage>
+  receivers:
+  {
+    receiver: Ref<IUser>,
+    updatedAt?: Date,
+    readStatus: AnnouncementStatusesType,
+  }[]
+}
+
+export type IAnnouncementHasId = IAnnouncement & HasObjectId;
+
+export interface ParamsForAnnouncement extends Omit<IAnnouncement, 'receivers'> {
+  receivers: Ref<IUser>[]
+}

apps/app/src/features/announcement/routes/apiv3/announcement.ts

@@ -0,0 +1,83 @@
+import type { Router } from 'express';
+import { body } from 'express-validator';
+
+import { SupportedTargetModel, SupportedAction } from '~/interfaces/activity';
+import type { CrowiRequest } from '~/interfaces/crowi-request';
+import type Crowi from '~/server/crowi';
+
+import type { ParamsForAnnouncement } from '../../interfaces/announcement';
+import { announcementService } from '../../server/service/announcement';
+
+
+const express = require('express');
+
+const router = express.Router();
+
+module.exports = (crowi: Crowi): Router => {
+
+  const { Page } = crowi.models;
+
+  const loginRequiredStrictly = require('~/server/middlewares/login-required')(crowi);
+
+  const validators = {
+    doAnnouncement: [
+      body('sender')
+        .exists({ checkFalsy: true })
+        .withMessage('sender is required')
+        .isMongoId()
+        .withMessage('sender must be mongo id'),
+      body('comment')
+        .optional({ nullable: true })
+        .isString()
+        .withMessage('comment must be string'),
+      body('emoji')
+        .optional({ nullable: true })
+        .isString()
+        .withMessage('emoji must be string'),
+      body('isReadReceiptTrackingEnabled')
+        .exists()
+        .withMessage('isReadReceiptTrackingEnabled is required')
+        .isBoolean()
+        .withMessage('isReadReceiptTrackingEnabled must be boolean'),
+      body('pageId')
+        .exists({ checkFalsy: true })
+        .withMessage('pageId is required')
+        .isMongoId()
+        .withMessage('pageId must be mongo id'),
+      body('receivers')
+        .exists({ checkFalsy: true })
+        .withMessage('receivers is required')
+        .isArray()
+        .withMessage('receivers must be an array'),
+    ],
+  };
+
+  router.post('/do-announcement', loginRequiredStrictly, validators.doAnnouncement, async(req: CrowiRequest) => {
+
+    const params: ParamsForAnnouncement = req.body;
+
+    const pageId = params.pageId;
+
+    const page = await Page.findById(pageId);
+
+    const parametersForActivity = {
+      ip: req.ip,
+      endpoint: req.originalUrl,
+      user: req.user?._id,
+      target: page,
+      targetModel: SupportedTargetModel.MODEL_ANNOUNCEMENT,
+      action: SupportedAction.ACTION_USER_ANNOUNCE,
+      snapshot: {
+        username: req.user?.username,
+      },
+    };
+
+    const activity = await crowi.activityService.createActivity(parametersForActivity);
+
+    announcementService?.doAnnounce(activity, page, params);
+
+  });
+
+  return router;
+
+};

apps/app/src/features/announcement/server/events/announcement-utils.ts

@@ -4,4 +4,4 @@ export const AnnouncementStatuses = {
   STATUS_IGNORED: 'IGNORED',
 } as const;
 
-type AnnouncementStatuses = typeof AnnouncementStatuses[keyof typeof AnnouncementStatuses];
+export type AnnouncementStatusesType = typeof AnnouncementStatuses[keyof typeof AnnouncementStatuses];

apps/app/src/features/announcement/server/models/announcement.ts

@@ -1,13 +1,10 @@
-import {
-  Types, Document, Schema, Model,
-} from 'mongoose';
+import type { Types, Document, Model } from 'mongoose';
+import { Schema } from 'mongoose';
 
-import { IAnnouncement } from '../../../../interfaces/announcement';
 import { getOrCreateModel } from '../../../../server/util/mongoose-utils';
+import type { IAnnouncement } from '../../interfaces/announcement';
 import { AnnouncementStatuses } from '../events/announcement-utils';
 
-type AnnouncementStatuses = typeof AnnouncementStatuses;
-
 export interface AnnouncementDocument extends IAnnouncement, Document {
   _id: Types.ObjectId
 }
@@ -58,6 +55,12 @@ const AnnouncementSchema = new Schema<AnnouncementDocument>({
   ],
 }, {});
 
+AnnouncementSchema.statics.createByParameters = async function(parameters): Promise<IAnnouncement> {
+  const announcement = await this.create(parameters);
+
+  return announcement;
+};
+
 const Announcement = getOrCreateModel<AnnouncementDocument, AnnouncementModel>('Announcement', AnnouncementSchema);
 
 export { Announcement };

apps/app/src/features/announcement/server/service/announcement.ts

@@ -0,0 +1,87 @@
+import type { IPage } from '@growi/core';
+
+import { Announcement, AnnouncementStatuses } from '~/features/announcement';
+import loggerFactory from '~/utils/logger';
+
+import type Crowi from '../../../../server/crowi';
+import type { ActivityDocument } from '../../../../server/models/activity';
+import type { PreNotifyProps } from '../../../../server/service/pre-notify';
+import type { IAnnouncement, ParamsForAnnouncement } from '../../interfaces/announcement';
+
+const logger = loggerFactory('growi:service:inAppNotification');
+
+class AnnouncementService {
+
+  crowi!: Crowi;
+
+  activityEvent: any;
+
+  constructor(crowi: Crowi) {
+    this.crowi = crowi;
+    this.activityEvent = crowi.event('activity');
+
+    this.getReadRate = this.getReadRate.bind(this);
+    this.insertAnnouncement = this.insertAnnouncement.bind(this);
+    this.doAnnounce = this.doAnnounce.bind(this);
+
+  }
+
+  getReadRate = async() => { };
+
+  private insertAnnouncement = async(
+      params: ParamsForAnnouncement,
+  ): Promise<void> => {
+
+    const {
+      sender, comment, emoji, isReadReceiptTrackingEnabled, pageId, receivers,
+    } = params;
+
+    const announcement: IAnnouncement = {
+      sender,
+      comment,
+      emoji,
+      isReadReceiptTrackingEnabled,
+      pageId,
+      receivers: receivers.map((receiver) => {
+        return {
+          receiver,
+          readStatus: AnnouncementStatuses.STATUS_UNREAD,
+        };
+      }),
+    };
+
+    const operation = [{
+      insertOne: {
+        document: announcement,
+      },
+    }];
+
+    await Announcement.bulkWrite(operation);
+    logger.info('Announcement bulkWrite has run');
+
+    return;
+
+  };
+
+  doAnnounce = async(activity: ActivityDocument, target: IPage, params: ParamsForAnnouncement): Promise<void> => {
+
+    this.insertAnnouncement(params);
+
+    const preNotify = async(props: PreNotifyProps) => {
+
+      const { notificationTargetUsers } = props;
+
+      notificationTargetUsers?.push(...params.receivers);
+    };
+
+    this.activityEvent.emit('updated', activity, target, preNotify);
+
+  };
+
+}
+
+// eslint-disable-next-line import/no-mutable-exports
+export let announcementService: AnnouncementService | undefined; // singleton instance
+export function instanciate(crowi: Crowi): void {
+  announcementService = new AnnouncementService(crowi);
+}

apps/app/src/interfaces/activity.ts

@@ -3,6 +3,7 @@ import type { Ref, HasObjectId, IUser } from '@growi/core';
 // Model
 const MODEL_PAGE = 'Page';
 const MODEL_USER = 'User';
+const MODEL_ANNOUNCEMENT = 'Announcement';
 const MODEL_COMMENT = 'Comment';
 
 // Action
@@ -27,6 +28,7 @@ const ACTION_USER_PASSWORD_UPDATE = 'USER_PASSWORD_UPDATE';
 const ACTION_USER_API_TOKEN_UPDATE = 'USER_API_TOKEN_UPDATE';
 const ACTION_USER_EDITOR_SETTINGS_UPDATE = 'USER_EDITOR_SETTINGS_UPDATE';
 const ACTION_USER_IN_APP_NOTIFICATION_SETTINGS_UPDATE = 'USER_IN_APP_NOTIFICATION_SETTINGS_UPDATE';
+const ACTION_USER_ANNOUNCE = 'USER_ANNOUNCE';
 const ACTION_PAGE_VIEW = 'PAGE_VIEW';
 const ACTION_PAGE_USER_HOME_VIEW = 'PAGE_USER_HOME_VIEW';
 const ACTION_PAGE_NOT_FOUND = 'PAGE_NOT_FOUND';
@@ -166,6 +168,7 @@ const ACTION_ADMIN_SEARCH_INDICES_REBUILD = 'ADMIN_SEARCH_INDICES_REBUILD';
 export const SupportedTargetModel = {
   MODEL_PAGE,
   MODEL_USER,
+  MODEL_ANNOUNCEMENT,
 } as const;
 
 export const SupportedEventModel = {
@@ -206,6 +209,7 @@ export const SupportedAction = {
   ACTION_USER_API_TOKEN_UPDATE,
   ACTION_USER_EDITOR_SETTINGS_UPDATE,
   ACTION_USER_IN_APP_NOTIFICATION_SETTINGS_UPDATE,
+  ACTION_USER_ANNOUNCE,
   ACTION_PAGE_VIEW,
   ACTION_PAGE_USER_HOME_VIEW,
   ACTION_PAGE_FORBIDDEN,
@@ -358,6 +362,7 @@ export const EssentialActionGroup = {
   ACTION_PAGE_RECURSIVELY_REVERT,
   ACTION_COMMENT_CREATE,
   ACTION_USER_REGISTRATION_APPROVAL_REQUEST,
+  ACTION_USER_ANNOUNCE,
 } as const;
 
 export const ActionGroupSize = {
@@ -396,6 +401,7 @@ export const MediumActionGroup = {
   ACTION_USER_API_TOKEN_UPDATE,
   ACTION_USER_EDITOR_SETTINGS_UPDATE,
   ACTION_USER_IN_APP_NOTIFICATION_SETTINGS_UPDATE,
+  ACTION_USER_ANNOUNCE,
   ACTION_PAGE_LIKE,
   ACTION_PAGE_UNLIKE,
   ACTION_PAGE_BOOKMARK,

apps/app/src/server/crowi/index.js

@@ -17,12 +17,13 @@ import QuestionnaireCronService from '~/features/questionnaire/server/service/qu
 import loggerFactory from '~/utils/logger';
 import { projectRoot } from '~/utils/project-dir-utils';
 
+import { instanciate as instanciateAnnouncementService } from '../../features/announcement/server/service/announcement';
 import UserEvent from '../events/user';
 import { aclService as aclServiceSingletonInstance } from '../service/acl';
 import AppService from '../service/app';
 import AttachmentService from '../service/attachment';
 import { configManager as configManagerSingletonInstance } from '../service/config-manager';
-import { instanciate as instanciateExternalAccountService } from '../service/external-account';
+import { instanciate, instanciate as instanciateExternalAccountService } from '../service/external-account';
 import { FileUploader, getUploader } from '../service/file-uploader'; // eslint-disable-line no-unused-vars
 import { G2GTransferPusherService, G2GTransferReceiverService } from '../service/g2g-transfer';
 import { initializeImportService } from '../service/import';
@@ -102,6 +103,7 @@ class Crowi {
     this.commentService = null;
     this.questionnaireService = null;
     this.questionnaireCronService = null;
+    this.announcementService = null;
 
     this.tokens = null;
 
@@ -167,6 +169,7 @@ Crowi.prototype.init = async function() {
     this.setupSyncPageStatusService(),
     this.setupQuestionnaireService(),
     this.setUpCustomize(), // depends on pluginService
+    this.setupAnnouncementService(),
   ]);
 
   await Promise.all([
@@ -762,6 +765,10 @@ Crowi.prototype.setupG2GTransferService = async function() {
   }
 };
 
+Crowi.prototype.setupAnnouncementService = async function() {
+  instanciateAnnouncementService(this);
+};
+
 // execute after setupPassport
 Crowi.prototype.setupExternalAccountService = function() {
   instanciateExternalAccountService(this.passportService);

apps/app/src/server/routes/apiv3/index.js

@@ -97,6 +97,8 @@ module.exports = (crowi, app) => {
   router.use('/bookmarks', require('./bookmarks')(crowi));
   router.use('/attachment', require('./attachment')(crowi));
 
+  router.use('/announcement', require('../../../features/announcement/routes/apiv3/announcement')(crowi));
+
   router.use('/slack-integration', require('./slack-integration')(crowi));
 
   router.use('/staffs', require('./staffs')(crowi));

apps/app/src/server/routes/login.js

@@ -54,7 +54,9 @@ module.exports = function(crowi, app) {
     const preNotify = async(props) => {
       const adminUsers = await User.findAdmins();
 
-      props.push(...adminUsers);
+      const { notificationTargetUsers } = props;
+
+      notificationTargetUsers.push(...adminUsers);
     };
 
     await activityEvent.emit('updated', activity, user, preNotify);