feat: implementions of announcement creation function

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

@@ -0,0 +1,19 @@
+import type {
+  IPage, IUser, IUserHasId, Ref,
+} from '@growi/core';
+
+import { type IAnnouncement, type ParamsForAnnouncement } from '~/interfaces/announcement';
+
+import { apiv3Post } from '../../../../client/util/apiv3-client';
+import { toastError } from '../../../../client/util/toastr';
+
+export const createAnnouncement = async(params: ParamsForAnnouncement): Promise<void> => {
+
+  try {
+    await apiv3Post('/announcement/doAnnouncement', params);
+  }
+  catch (err) {
+    toastError(err);
+  }
+
+};

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 type { IAnnouncement } from '../../../../interfaces/announcement';
 import { getOrCreateModel } from '../../../../server/util/mongoose-utils';
 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) as IAnnouncement;
+
+  return announcement;
+};
+
 const Announcement = getOrCreateModel<AnnouncementDocument, AnnouncementModel>('Announcement', AnnouncementSchema);
 
 export { Announcement };

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

@@ -0,0 +1,79 @@
+import type { IPage } from '@growi/core';
+
+import { Announcement, AnnouncementStatuses } from '~/features/announcement';
+import type { IAnnouncement, ParamsForAnnouncement } from '~/interfaces/announcement';
+
+import type Crowi from '../../../../server/crowi';
+import type { ActivityDocument } from '../../../../server/models/activity';
+import type { PreNotifyProps } from '../../../../server/service/pre-notify';
+
+export default 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() => {};
+
+  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);
+
+    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);
+
+  };
+
+}
+
+module.exports = AnnouncementService;

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/interfaces/announcement.ts

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

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

@@ -98,6 +98,7 @@ class Crowi {
     this.commentService = null;
     this.questionnaireService = null;
     this.questionnaireCronService = null;
+    this.announcementService = null;
 
     this.tokens = null;
 
@@ -162,6 +163,7 @@ Crowi.prototype.init = async function() {
     this.setupSyncPageStatusService(),
     this.setupQuestionnaireService(),
     this.setUpCustomize(), // depends on pluginService
+    this.setupAnnouncementService(),
   ]);
 
   await Promise.all([
@@ -775,6 +777,13 @@ Crowi.prototype.setupG2GTransferService = async function() {
   }
 };
 
+Crowi.prototype.setupAnnouncementService = async function() {
+  const AnnouncementService = require('../../features/announcement/server/service/announcement');
+  if (this.announcementService == null) {
+    this.announcementService = new AnnouncementService(this);
+  }
+};
+
 // execute after setupPassport
 Crowi.prototype.setupExternalAccountService = function() {
   instanciateExternalAccountService(this.passportService);

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

@@ -0,0 +1,59 @@
+import type { Router } from 'express';
+import {
+  body, param, query, validationResult,
+} from 'express-validator';
+
+import { SupportedTargetModel, SupportedAction } from '~/interfaces/activity';
+import type { ParamsForAnnouncement } from '~/interfaces/announcement';
+import type { CrowiRequest } from '~/interfaces/crowi-request';
+import type Crowi from '~/server/crowi';
+
+
+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 }),
+      body('comment').optional({ nullable: true }).isString(),
+      body('emoji').optional({ nullable: true }).isString(),
+      body('isReadReceiptTrackingEnabled').exists().isBoolean(),
+      body('pageId').exists({ checkFalsy: true }),
+      body('receivers').exists({ checkFalsy: true }).isArray(),
+    ],
+  };
+
+  router.post('/doAnnouncement', loginRequiredStrictly, validators.doAnnouncement, async(req: CrowiRequest) => {
+
+    const params: ParamsForAnnouncement = req.body;
+
+    const page = await Page.findById(params.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);
+
+    crowi.announcementService.doAnnounce(activity, page, params);
+
+  });
+
+  return router;
+
+};

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('./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);

apps/app/src/server/service/activity.ts

@@ -1,14 +1,16 @@
 import type { IPage } from '@growi/core';
 import mongoose from 'mongoose';
 
+import type { IActivity, SupportedActionType } from '~/interfaces/activity';
 import {
-  IActivity, SupportedActionType, AllSupportedActions, ActionGroupSize,
+  AllSupportedActions, ActionGroupSize,
   AllEssentialActions, AllSmallGroupActions, AllMediumGroupActions, AllLargeGroupActions,
 } from '~/interfaces/activity';
-import Activity, { ActivityDocument } from '~/server/models/activity';
+import type { ActivityDocument } from '~/server/models/activity';
+import Activity from '~/server/models/activity';
 
 import loggerFactory from '../../utils/logger';
-import Crowi from '../crowi';
+import type Crowi from '../crowi';
 
 
 import type { GeneratePreNotify, GetAdditionalTargetUsers } from './pre-notify';

apps/app/src/server/service/pre-notify.ts

@@ -2,7 +2,7 @@ import type {
   IPage, IUser, Ref,
 } from '@growi/core';
 
-import { ActivityDocument } from '../models/activity';
+import type { ActivityDocument } from '../models/activity';
 import Subscription from '../models/subscription';
 import { getModelSafely } from '../util/mongoose-utils';