feat: implement send email on release notes publish (#102)

viv-helix · web-flow · commit 3caa2a2f7881 · 2026-06-11T10:52:34.000+05:30
* feat: implement send email for release notes publish

* fix: rename unsubscribe function and update related tests

* fix: Add email notification features for release notes

* fix: add proptype for sendemail

* fix: simplify unsubscribe functionality by removing token parameter
diff --git a/src/index.jsx b/src/index.jsx
@@ -26,6 +26,7 @@ import {
 import initializeStore from './store';
 import CourseAuthoringRoutes from './CourseAuthoringRoutes';
 import ReleaseNotes from './release-notes/ReleaseNotes';
+import ReleaseNoteUnsubscribe from './release-notes/unsubscribe/ReleaseNoteUnsubscribe';
 import Head from './head/Head';
 import { StudioHome } from './studio-home';
 import CourseRerun from './course-rerun';
@@ -97,6 +98,7 @@ const App = () => {
         {getConfig().ENABLE_RELEASE_NOTES === 'true' && (
           <Route path="/release-notes" element={<ReleaseNotes />} />
         )}
+        <Route path="/release-notes/unsubscribe" element={<ReleaseNoteUnsubscribe />} />
         {getConfig().ENABLE_ACCESSIBILITY_PAGE === 'true' && (
           <Route path="/accessibility" element={<AccessibilityPage />} />
         )}
diff --git a/src/release-notes/ReleaseNotes.jsx b/src/release-notes/ReleaseNotes.jsx
@@ -36,6 +36,7 @@ const ReleaseNotes = () => {
     requestType,
     notes,
     hasAccess,
+    canSendReleaseNoteEmails,
     notesInitialValues,
     isFormOpen,
     isDeleteModalOpen,
@@ -277,6 +278,7 @@ const ReleaseNotes = () => {
             initialValues={notesInitialValues}
             close={closeForm}
             onSubmit={handleUpdatesSubmit}
+            canSendReleaseNoteEmails={canSendReleaseNoteEmails}
             savingStatuses={savingStatuses}
             isDirtyCheckRef={isDirtyCheckRef}
             showUnsavedModalRef={showUnsavedModalRef}
diff --git a/src/release-notes/ReleaseNotes.test.jsx b/src/release-notes/ReleaseNotes.test.jsx
@@ -22,6 +22,7 @@ const mockUseReleaseNotes = {
   requestType: null,
   notes: [],
   hasAccess: false,
+  canSendReleaseNoteEmails: false,
   notesInitialValues: {},
   isFormOpen: false,
   isDeleteModalOpen: false,
diff --git a/src/release-notes/data/api.js b/src/release-notes/data/api.js
@@ -5,6 +5,7 @@ const getApiBaseUrl = () => getConfig().STUDIO_BASE_URL;
 
 const getReleaseNotesApiUrl = () => new URL('/api/release_notes/v1/posts/', getApiBaseUrl()).href;
 const getReleaseNoteApiUrl = (id) => new URL(`/api/release_notes/v1/posts/${id}/`, getApiBaseUrl()).href;
+const getUnsubscribeApiUrl = () => new URL('/api/release_notes/v1/email/unsubscribe/', getApiBaseUrl()).href;
 
 export async function getReleaseNotes() {
   const { data } = await getAuthenticatedHttpClient().get(getReleaseNotesApiUrl());
@@ -25,3 +26,8 @@ export async function deleteReleaseNote(id) {
   const { data } = await getAuthenticatedHttpClient().delete(getReleaseNoteApiUrl(id));
   return camelCaseObject(data);
 }
+
+export async function unsubscribeFromReleaseNoteEmails() {
+  const { data } = await getAuthenticatedHttpClient().get(getUnsubscribeApiUrl());
+  return camelCaseObject(data);
+}
diff --git a/src/release-notes/data/api.test.js b/src/release-notes/data/api.test.js
@@ -4,7 +4,11 @@ import MockAdapter from 'axios-mock-adapter';
 
 import { initializeMocks } from '../../testUtils';
 import {
-  getReleaseNotes, createReleaseNote, editReleaseNote, deleteReleaseNote,
+  getReleaseNotes,
+  createReleaseNote,
+  editReleaseNote,
+  deleteReleaseNote,
+  unsubscribeFromReleaseNoteEmails,
 } from './api';
 
 describe('release-notes api', () => {
@@ -53,4 +57,12 @@ describe('release-notes api', () => {
     mock.onGet(url).reply(500, {});
     await expect(getReleaseNotes()).rejects.toBeTruthy();
   });
+
+  test('unsubscribeFromReleaseNoteEmails issues authenticated GET', async () => {
+    const expectedUrl = new URL('/api/release_notes/v1/email/unsubscribe/', getConfig().STUDIO_BASE_URL).href;
+    mock.onGet(expectedUrl).reply(200, { message: 'unsubscribed' });
+    const res = await unsubscribeFromReleaseNoteEmails();
+    expect(res.message).toBe('unsubscribed');
+    expect(mock.history.get[0].url).toBe(expectedUrl);
+  });
 });
diff --git a/src/release-notes/data/selectors.js b/src/release-notes/data/selectors.js
@@ -1,5 +1,6 @@
 export const getReleaseNotes = (state) => state.releaseNotes.releaseNotes;
 export const getHasAccess = (state) => state.releaseNotes.hasAccess;
+export const getCanSendReleaseNoteEmails = (state) => state.releaseNotes.canSendReleaseNoteEmails;
 export const getSavingStatuses = (state) => state.releaseNotes.savingStatuses;
 export const getLoadingStatuses = (state) => state.releaseNotes.loadingStatuses;
 export const getErrors = (state) => state.releaseNotes.errors;
diff --git a/src/release-notes/data/slice.js b/src/release-notes/data/slice.js
@@ -5,6 +5,7 @@ import { sortBy } from 'lodash';
 const initialState = {
   releaseNotes: [],
   hasAccess: false,
+  canSendReleaseNoteEmails: false,
   savingStatuses: {
     createReleaseNoteQuery: '',
     editReleaseNoteQuery: '',
@@ -28,6 +29,7 @@ const slice = createSlice({
     fetchReleaseNotesSuccess: (state, { payload }) => {
       state.releaseNotes = payload.notes || payload;
       state.hasAccess = payload.hasAccess || false;
+      state.canSendReleaseNoteEmails = payload.canSendReleaseNoteEmails || false;
     },
     createReleaseNote: (state, { payload }) => {
       state.releaseNotes = [payload, ...state.releaseNotes];
diff --git a/src/release-notes/data/thunk.js b/src/release-notes/data/thunk.js
@@ -16,26 +16,34 @@ import {
   updateSavingStatuses,
 } from './slice';
 
+function normalizeReleaseNote(note) {
+  return {
+    id: note.id,
+    title: note.title,
+    description: note.rawHtmlContent,
+    published_at: note.publishedAt,
+    created_by: note.createdBy,
+    sendEmail: Boolean(note.sendEmailOnPublish),
+  };
+}
+
 export function fetchReleaseNotesQuery() {
   return async (dispatch) => {
     try {
       dispatch(updateLoadingStatuses({ fetchReleaseNotesQuery: RequestStatus.IN_PROGRESS }));
       const response = await getReleaseNotes();
       const notesList = Array.isArray(response) ? response : (response.results || []);
       const hasAccess = response.hasAccess || false;
-      const normalized = (notesList || []).map((n) => ({
-        id: n.id,
-        title: n.title,
-        description: n.rawHtmlContent,
-        published_at: n.publishedAt,
-        created_by: n.createdBy,
-      }))
+      const canSendReleaseNoteEmails = response.canSendReleaseNoteEmails || false;
+      const normalized = (notesList || []).map(normalizeReleaseNote)
         .sort((a, b) => {
           const ta = a.published_at ? Date.parse(a.published_at) : -Infinity;
           const tb = b.published_at ? Date.parse(b.published_at) : -Infinity;
           return tb - ta;
         });
-      dispatch(fetchReleaseNotesSuccess({ notes: normalized, hasAccess }));
+      dispatch(fetchReleaseNotesSuccess({
+        notes: normalized, hasAccess, canSendReleaseNoteEmails,
+      }));
       dispatch(updateLoadingStatuses({
         status: { fetchReleaseNotesQuery: RequestStatus.SUCCESSFUL },
         error: { loadingNotes: false },
@@ -57,20 +65,15 @@ export function createReleaseNoteQuery(data) {
         error: {},
       }));
       dispatch(showProcessingNotification(NOTIFICATION_MESSAGES.saving));
+      const { sendEmail, ...noteData } = data;
       const payload = {
-        ...data,
-        raw_html_content: data.description,
+        ...noteData,
+        raw_html_content: noteData.description,
+        send_email_on_publish: sendEmail || false,
       };
       delete payload.description;
       const note = await createReleaseNote(payload);
-      const normalized = {
-        id: note.id,
-        title: note.title,
-        description: note.rawHtmlContent,
-        published_at: note.publishedAt,
-        created_by: note.createdBy,
-      };
-      dispatch(createReleaseNoteAction(normalized));
+      dispatch(createReleaseNoteAction(normalizeReleaseNote(note)));
       dispatch(hideProcessingNotification());
       dispatch(updateSavingStatuses({
         status: { createReleaseNoteQuery: RequestStatus.SUCCESSFUL },
@@ -96,20 +99,15 @@ export function editReleaseNoteQuery(data) {
         error: {},
       }));
       dispatch(showProcessingNotification(NOTIFICATION_MESSAGES.saving));
+      const { sendEmail, ...noteData } = data;
       const payload = {
-        ...data,
-        raw_html_content: data.description,
+        ...noteData,
+        raw_html_content: noteData.description,
+        send_email_on_publish: sendEmail || false,
       };
       delete payload.description;
       const note = await editReleaseNote(payload);
-      const normalized = {
-        id: note.id,
-        title: note.title,
-        description: note.rawHtmlContent,
-        published_at: note.publishedAt,
-        created_by: note.createdBy,
-      };
-      dispatch(editReleaseNoteAction(normalized));
+      dispatch(editReleaseNoteAction(normalizeReleaseNote(note)));
       dispatch(hideProcessingNotification());
       dispatch(updateSavingStatuses({
         status: { editReleaseNoteQuery: RequestStatus.SUCCESSFUL },
diff --git a/src/release-notes/data/thunk.test.js b/src/release-notes/data/thunk.test.js
@@ -43,11 +43,58 @@ describe('release-notes thunks', () => {
     expect(success.payload.notes[0].id).toBe(2);
     expect(success.payload.notes[0]).toEqual(expect.objectContaining({ description: '<p>b</p>', published_at: expect.any(String), created_by: 'b@x' }));
     expect(success.payload.hasAccess).toBe(false);
+    expect(success.payload.canSendReleaseNoteEmails).toBe(false);
     const last = actions[actions.length - 1];
     expect(last.type).toBe(updateLoadingStatuses.type);
     expect(last.payload.status.fetchReleaseNotesQuery).toBe(RequestStatus.SUCCESSFUL);
   });
 
+  test('fetchReleaseNotesQuery maps sendEmailOnPublish to sendEmail', async () => {
+    jest.spyOn(api, 'getReleaseNotes').mockResolvedValue([
+      {
+        id: 1,
+        title: 'a',
+        rawHtmlContent: '<p>a</p>',
+        publishedAt: '2025-01-01T00:00:00Z',
+        createdBy: 'a@x',
+        sendEmailOnPublish: true,
+      },
+      {
+        id: 2,
+        title: 'b',
+        rawHtmlContent: '<p>b</p>',
+        publishedAt: '2025-01-02T00:00:00Z',
+        createdBy: 'b@x',
+        sendEmailOnPublish: false,
+      },
+    ]);
+    const { actions, dispatch } = collectActions();
+
+    await fetchReleaseNotesQuery()(dispatch);
+
+    const success = actions.find(a => a.type === fetchReleaseNotesSuccess.type);
+    expect(success.payload.notes.find(n => n.id === 1).sendEmail).toBe(true);
+    expect(success.payload.notes.find(n => n.id === 2).sendEmail).toBe(false);
+  });
+
+  test('fetchReleaseNotesQuery reads hasAccess and canSendReleaseNoteEmails from paginated response', async () => {
+    jest.spyOn(api, 'getReleaseNotes').mockResolvedValue({
+      results: [{
+        id: 1, title: 'a', rawHtmlContent: '<p>a</p>', publishedAt: '2025-01-01T00:00:00Z', createdBy: 'a@x',
+      }],
+      hasAccess: true,
+      canSendReleaseNoteEmails: true,
+    });
+    const { actions, dispatch } = collectActions();
+
+    await fetchReleaseNotesQuery()(dispatch);
+
+    const success = actions.find(a => a.type === fetchReleaseNotesSuccess.type);
+    expect(success.payload.hasAccess).toBe(true);
+    expect(success.payload.canSendReleaseNoteEmails).toBe(true);
+    expect(success.payload.notes).toHaveLength(1);
+  });
+
   test('fetchReleaseNotesQuery failure sets FAILED', async () => {
     jest.spyOn(api, 'getReleaseNotes').mockRejectedValue(new Error('boom'));
     const { actions, dispatch } = collectActions();
@@ -60,11 +107,20 @@ describe('release-notes thunks', () => {
 
   test('createReleaseNoteQuery success creates note and sets SUCCESSFUL', async () => {
     jest.spyOn(api, 'createReleaseNote').mockResolvedValue({
-      id: 9, title: 't', rawHtmlContent: '<p>x</p>', publishedAt: '2025-01-01T00:00:00Z', createdBy: 'u',
+      id: 9,
+      title: 't',
+      rawHtmlContent: '<p>x</p>',
+      publishedAt: '2025-01-01T00:00:00Z',
+      createdBy: 'u',
+      sendEmailOnPublish: true,
     });
     const { actions, dispatch } = collectActions();
-    await createReleaseNoteQuery({ id: 9, title: 't', description: '<p>x</p>' })(dispatch);
-    expect(actions.find(a => a.type === createReleaseNoteAction.type)).toBeTruthy();
+    await createReleaseNoteQuery({
+      id: 9, title: 't', description: '<p>x</p>', sendEmail: true,
+    })(dispatch);
+    const created = actions.find(a => a.type === createReleaseNoteAction.type);
+    expect(created).toBeTruthy();
+    expect(created.payload.sendEmail).toBe(true);
     const last = actions[actions.length - 1];
     expect(last.type).toBe(updateSavingStatuses.type);
     expect(last.payload.status.createReleaseNoteQuery).toBe(RequestStatus.SUCCESSFUL);
@@ -92,11 +148,20 @@ describe('release-notes thunks', () => {
 
   test('editReleaseNoteQuery success edits note and sets SUCCESSFUL', async () => {
     jest.spyOn(api, 'editReleaseNote').mockResolvedValue({
-      id: 5, title: 't2', rawHtmlContent: '<p>y</p>', publishedAt: '2025-01-03T00:00:00Z', createdBy: 'v',
+      id: 5,
+      title: 't2',
+      rawHtmlContent: '<p>y</p>',
+      publishedAt: '2025-01-03T00:00:00Z',
+      createdBy: 'v',
+      sendEmailOnPublish: true,
     });
     const { actions, dispatch } = collectActions();
-    await editReleaseNoteQuery({ id: 5, title: 't2', description: '<p>y</p>' })(dispatch);
-    expect(actions.find(a => a.type === editReleaseNoteAction.type)).toBeTruthy();
+    await editReleaseNoteQuery({
+      id: 5, title: 't2', description: '<p>y</p>', sendEmail: true,
+    })(dispatch);
+    const edited = actions.find(a => a.type === editReleaseNoteAction.type);
+    expect(edited).toBeTruthy();
+    expect(edited.payload.sendEmail).toBe(true);
     const last = actions[actions.length - 1];
     expect(last.type).toBe(updateSavingStatuses.type);
     expect(last.payload.status.editReleaseNoteQuery).toBe(RequestStatus.SUCCESSFUL);
@@ -157,4 +222,38 @@ describe('release-notes thunks', () => {
     expect(spy).toHaveBeenCalledWith(expect.objectContaining({ raw_html_content: '<p>y</p>' }));
     expect(spy).toHaveBeenCalledWith(expect.not.objectContaining({ description: expect.anything() }));
   });
+
+  test('createReleaseNoteQuery maps sendEmail to send_email_on_publish (true)', async () => {
+    const spy = jest.spyOn(api, 'createReleaseNote').mockResolvedValue({ id: 1, title: 't', rawHtmlContent: '<p>x</p>' });
+    const { dispatch } = collectActions();
+    await createReleaseNoteQuery({
+      id: 1, title: 't', description: '<p>x</p>', sendEmail: true,
+    })(dispatch);
+    expect(spy).toHaveBeenCalledWith(expect.objectContaining({ send_email_on_publish: true }));
+    expect(spy).toHaveBeenCalledWith(expect.not.objectContaining({ sendEmail: expect.anything() }));
+  });
+
+  test('createReleaseNoteQuery defaults send_email_on_publish to false when sendEmail absent', async () => {
+    const spy = jest.spyOn(api, 'createReleaseNote').mockResolvedValue({ id: 1, title: 't', rawHtmlContent: '<p>x</p>' });
+    const { dispatch } = collectActions();
+    await createReleaseNoteQuery({ id: 1, title: 't', description: '<p>x</p>' })(dispatch);
+    expect(spy).toHaveBeenCalledWith(expect.objectContaining({ send_email_on_publish: false }));
+  });
+
+  test('editReleaseNoteQuery maps sendEmail to send_email_on_publish (true)', async () => {
+    const spy = jest.spyOn(api, 'editReleaseNote').mockResolvedValue({ id: 2, title: 't2', rawHtmlContent: '<p>y</p>' });
+    const { dispatch } = collectActions();
+    await editReleaseNoteQuery({
+      id: 2, title: 't2', description: '<p>y</p>', sendEmail: true,
+    })(dispatch);
+    expect(spy).toHaveBeenCalledWith(expect.objectContaining({ send_email_on_publish: true }));
+    expect(spy).toHaveBeenCalledWith(expect.not.objectContaining({ sendEmail: expect.anything() }));
+  });
+
+  test('editReleaseNoteQuery defaults send_email_on_publish to false when sendEmail absent', async () => {
+    const spy = jest.spyOn(api, 'editReleaseNote').mockResolvedValue({ id: 2, title: 't2', rawHtmlContent: '<p>y</p>' });
+    const { dispatch } = collectActions();
+    await editReleaseNoteQuery({ id: 2, title: 't2', description: '<p>y</p>' })(dispatch);
+    expect(spy).toHaveBeenCalledWith(expect.objectContaining({ send_email_on_publish: false }));
+  });
 });
diff --git a/src/release-notes/hooks.jsx b/src/release-notes/hooks.jsx
@@ -13,6 +13,7 @@ import {
 import {
   getReleaseNotes as selectReleaseNotes,
   getHasAccess,
+  getCanSendReleaseNoteEmails,
   getLoadingStatuses,
   getSavingStatuses,
   getErrors,
@@ -31,6 +32,7 @@ const useReleaseNotes = () => {
 
   const notes = useSelector(selectReleaseNotes) || [];
   const hasAccess = useSelector(getHasAccess);
+  const canSendReleaseNoteEmails = useSelector(getCanSendReleaseNoteEmails);
   const loadingStatuses = useSelector(getLoadingStatuses);
   const savingStatuses = useSelector(getSavingStatuses);
   const errors = useSelector(getErrors);
@@ -105,6 +107,7 @@ const useReleaseNotes = () => {
     requestType,
     notes,
     hasAccess,
+    canSendReleaseNoteEmails,
     notesInitialValues,
     isMainFormOpen: isFormOpen && requestType !== REQUEST_TYPES.edit_update,
     isInnerFormOpen: (id) => (
diff --git a/src/release-notes/messages.js b/src/release-notes/messages.js
@@ -106,6 +106,14 @@ const messages = defineMessages({
     id: 'release-notes.form.error.description.required',
     defaultMessage: 'Enter post content',
   },
+  sendEmailCheckboxLabel: {
+    id: 'release-notes.form.send-email.label',
+    defaultMessage: 'Send email notification to all course authors',
+  },
+  sendEmailCheckboxHelp: {
+    id: 'release-notes.form.send-email.help',
+    defaultMessage: 'When checked, an email will be sent to all course authors on the platform notifying them of this release note.',
+  },
 });
 
 export default messages;
diff --git a/src/release-notes/unsubscribe/ReleaseNoteUnsubscribe.jsx b/src/release-notes/unsubscribe/ReleaseNoteUnsubscribe.jsx
diff --git a/src/release-notes/unsubscribe/ReleaseNoteUnsubscribe.test.jsx b/src/release-notes/unsubscribe/ReleaseNoteUnsubscribe.test.jsx
diff --git a/src/release-notes/unsubscribe/messages.js b/src/release-notes/unsubscribe/messages.js
diff --git a/src/release-notes/update-form/ReleaseNoteForm.jsx b/src/release-notes/update-form/ReleaseNoteForm.jsx
diff --git a/src/release-notes/update-form/ReleaseNoteForm.test.jsx b/src/release-notes/update-form/ReleaseNoteForm.test.jsx
