From d1df683a2ba71edcdb93e1a495d7f7dd01fa4f55 Mon Sep 17 00:00:00 2001
From: Julian Jelfs <julian.jelfs@gmail.com>
Date: Tue, 23 Jan 2024 18:40:16 +0000
Subject: [PATCH] changes to the admin area

---
 .../admin/ReviewTranslationCorrections.svelte | 208 +++++++++++++-----
 .../src/services/openchatAgent.ts             |  28 ++-
 frontend/openchat-client/src/openchat.ts      | 154 ++++++++-----
 frontend/openchat-shared/src/domain/i18n.ts   |   4 +-
 frontend/openchat-shared/src/domain/worker.ts |   7 +-
 frontend/openchat-worker/src/worker.ts        |   2 +-
 6 files changed, 283 insertions(+), 120 deletions(-)

diff --git a/frontend/app/src/components/home/admin/ReviewTranslationCorrections.svelte b/frontend/app/src/components/home/admin/ReviewTranslationCorrections.svelte
index 1a334f6e25..73ae9b2591 100644
--- a/frontend/app/src/components/home/admin/ReviewTranslationCorrections.svelte
+++ b/frontend/app/src/components/home/admin/ReviewTranslationCorrections.svelte
@@ -1,9 +1,23 @@
 <script lang="ts">
     import { _ } from "svelte-i18n";
-    import type { OpenChat, TranslationCorrection, TranslationCorrections } from "openchat-client";
+    import MenuIcon from "../../MenuIcon.svelte";
+    import Hamburger from "svelte-material-icons/Menu.svelte";
+    import Check from "svelte-material-icons/Check.svelte";
+    import EyeOutline from "svelte-material-icons/EyeOutline.svelte";
+    import Send from "svelte-material-icons/Send.svelte";
+    import Translate from "svelte-material-icons/Translate.svelte";
+    import Close from "svelte-material-icons/Close.svelte";
+    import HoverIcon from "../../HoverIcon.svelte";
+    import Menu from "../../Menu.svelte";
+    import MenuItem from "../../MenuItem.svelte";
+    import type {
+        OpenChat,
+        TranslationCorrection,
+        TranslationCorrections,
+        TranslationRejectionReason,
+    } from "openchat-client";
     import { getContext, onMount } from "svelte";
-    import Button from "../../Button.svelte";
-    import ButtonGroup from "../../ButtonGroup.svelte";
+    import { iconSize } from "../../../stores/iconSize";
 
     const client = getContext<OpenChat>("client");
 
@@ -21,23 +35,48 @@
     });
 
     function flattenCorrections(corrections: TranslationCorrections): TranslationCorrection[] {
+        // return [
+        //     {
+        //         locale: "fr",
+        //         key: "group.welcome",
+        //         value: "Ta mère était fossoyeuse {groupName}",
+        //         proposedBy: "cpmcr-yeaaa-aaaaa-qaala-cai",
+        //         proposedAt: Date.now(),
+        //         status: "pending",
+        //     },
+        // ];
         return Object.values(corrections)
             .flatMap((val) => Object.values(val))
-            .filter((c) => !c.approved);
+            .filter((c) => c.status !== "deployed");
     }
 
     function approveCorrection(correction: TranslationCorrection) {
+        // correction.status = "approved";
+        // corrections = corrections;
         client
             .approveTranslationCorrection(correction)
             .then((res) => (corrections = flattenCorrections(res)));
     }
 
-    function rejectCorrection(correction: TranslationCorrection) {
+    function markDeployed(correction: TranslationCorrection) {
+        console.log("Let's deploy: ", correction);
+    }
+
+    function rejectCorrection(
+        correction: TranslationCorrection,
+        reason: TranslationRejectionReason,
+    ) {
         client
-            .rejectTranslationCorrection(correction)
+            .rejectTranslationCorrection(correction, reason)
             .then((res) => (corrections = flattenCorrections(res)));
     }
 
+    function previewCorrection(correction: TranslationCorrection) {
+        // This will pretend that the value is english and apply it to the english i18n dictionary temporarily.
+        // This is just so that we have the option to look at it in the UI to check for layout problems
+        client.previewTranslationCorrection({ ...correction, locale: "en" });
+    }
+
     function verifyCorrection(correction: TranslationCorrection) {
         verifying = { ...correction };
         verifying.value = "Translating to English ...";
@@ -77,50 +116,107 @@
     <table class="data">
         <thead>
             <tr>
-                <th>Locale</th>
-                <th>Key</th>
-                <th>English value</th>
-                <th>Current value</th>
-                <th>Proposed value</th>
-                <th>Proposed by</th>
-                <th>Proposed at</th>
+                <th class="locale">Locale</th>
+                <th class="key">Key</th>
+                <th class="english">English value</th>
+                <th class="current">Current value</th>
+                <th class="proposed">Suggested value</th>
+                <th class="proposed_by">Proposed by</th>
+                <th class="proposed_at">Proposed at</th>
+                <th class="action"></th>
             </tr>
         </thead>
         <tbody>
             {#each corrections as correction}
-                <tr>
-                    <td>{correction.locale}</td>
-                    <td>{correction.key}</td>
-                    <td>{$_(correction.key, { locale: "en" })}</td>
-                    <td>{$_(correction.key, { locale: correction.locale })}</td>
-                    <td>
-                        <div class="suggestion">
-                            {#if verifying !== undefined && verifying.locale === correction.locale && verifying.key === correction.key}
-                                {verifying.value}
-                            {:else}
-                                {correction.value}
-                            {/if}
-                        </div>
-                        <div class="review">
-                            {#if verifying !== undefined && verifying.locale === correction.locale && verifying.key === correction.key}
-                                <ButtonGroup align="fill">
-                                    <Button secondary on:click={() => (verifying = undefined)} tiny
-                                        >Show Proposed
-                                    </Button>
-                                    <Button tiny on:click={() => rejectCorrection(correction)}
-                                        >Reject</Button>
-                                    <Button tiny on:click={() => approveCorrection(correction)}
-                                        >Approve</Button>
-                                </ButtonGroup>
-                            {:else}
-                                <Button on:click={() => verifyCorrection(correction)} tiny
-                                    >Show English
-                                </Button>
-                            {/if}
-                        </div>
+                <tr class={correction.status}>
+                    <td class="locale">{correction.locale}</td>
+                    <td class="key">{correction.key}</td>
+                    <td class="english">{$_(correction.key, { locale: "en" })}</td>
+                    <td class="current">{$_(correction.key, { locale: correction.locale })}</td>
+                    <td class="proposed">
+                        {#if verifying !== undefined && verifying.locale === correction.locale && verifying.key === correction.key}
+                            {verifying.value}
+                        {:else}
+                            {correction.value}
+                        {/if}
+                    </td>
+                    <td class="proposed_by"
+                        >{$userStore[correction.proposedBy]?.username ?? correction.proposedBy}</td>
+                    <td class="proposed_at"
+                        >{client.toDatetimeString(new Date(correction.proposedAt))}</td>
+                    <td class="action">
+                        <MenuIcon position="bottom" align="end">
+                            <span slot="icon">
+                                <HoverIcon>
+                                    <Hamburger size={$iconSize} color={"var(--txt)"} />
+                                </HoverIcon>
+                            </span>
+                            <span slot="menu">
+                                <Menu>
+                                    {#if correction.status === "pending"}
+                                        <MenuItem on:click={() => previewCorrection(correction)}>
+                                            <EyeOutline
+                                                size={$iconSize}
+                                                color={"var(--icon-inverted-txt)"}
+                                                slot="icon" />
+                                            <span slot="text">Preview</span>
+                                        </MenuItem>
+                                        {#if verifying !== undefined && verifying.locale === correction.locale && verifying.key === correction.key}
+                                            <MenuItem on:click={() => (verifying = undefined)}>
+                                                <Translate
+                                                    size={$iconSize}
+                                                    color={"var(--icon-inverted-txt)"}
+                                                    slot="icon" />
+                                                <span slot="text">Show proposed</span>
+                                            </MenuItem>
+                                        {:else}
+                                            <MenuItem on:click={() => verifyCorrection(correction)}>
+                                                <Translate
+                                                    size={$iconSize}
+                                                    color={"var(--icon-inverted-txt)"}
+                                                    slot="icon" />
+                                                <span slot="text">Show suggestion in English</span>
+                                            </MenuItem>
+                                        {/if}
+                                        <MenuItem on:click={() => approveCorrection(correction)}>
+                                            <Check
+                                                size={$iconSize}
+                                                color={"var(--icon-inverted-txt)"}
+                                                slot="icon" />
+                                            <span slot="text">Approve</span>
+                                        </MenuItem>
+                                        <MenuItem
+                                            on:click={() =>
+                                                rejectCorrection(correction, "bad_translation")}>
+                                            <Close
+                                                size={$iconSize}
+                                                color={"var(--icon-inverted-txt)"}
+                                                slot="icon" />
+                                            <span slot="text">Reject - bad translation</span>
+                                        </MenuItem>
+                                        <MenuItem
+                                            on:click={() =>
+                                                rejectCorrection(correction, "layout_problem")}>
+                                            <Close
+                                                size={$iconSize}
+                                                color={"var(--icon-inverted-txt)"}
+                                                slot="icon" />
+                                            <span slot="text">Reject - layout problem</span>
+                                        </MenuItem>
+                                    {/if}
+                                    {#if correction.status === "approved"}
+                                        <MenuItem on:click={() => markDeployed(correction)}>
+                                            <Send
+                                                size={$iconSize}
+                                                color={"var(--icon-inverted-txt)"}
+                                                slot="icon" />
+                                            <span slot="text">Deploy</span>
+                                        </MenuItem>
+                                    {/if}
+                                </Menu>
+                            </span>
+                        </MenuIcon>
                     </td>
-                    <td>{$userStore[correction.proposedBy]?.username ?? correction.proposedBy}</td>
-                    <td>{client.toDatetimeString(new Date(correction.proposedAt))}</td>
                 </tr>
             {/each}
         </tbody>
@@ -150,6 +246,13 @@
 
     tr {
         border-bottom: 1px solid var(--bd);
+
+        &.pending {
+            background-color: #e91e63;
+        }
+        &.approved {
+            background-color: #66bb6a;
+        }
     }
 
     td,
@@ -164,19 +267,22 @@
     td {
         padding: $sp3;
         text-align: left;
+        vertical-align: middle;
     }
 
     th {
         background-color: var(--button-bg);
         color: var(--button-txt);
-    }
 
-    tr {
-        cursor: pointer;
-    }
+        &.locale,
+        &.action {
+            width: 40px;
+        }
 
-    tr:hover {
-        background-color: rgba(255, 255, 255, 0.1);
+        &.proposed_by,
+        &.proposed_at {
+            width: 150px;
+        }
     }
 
     .suggestion {
diff --git a/frontend/openchat-agent/src/services/openchatAgent.ts b/frontend/openchat-agent/src/services/openchatAgent.ts
index 9d8cf1f886..f0b7fc1f60 100644
--- a/frontend/openchat-agent/src/services/openchatAgent.ts
+++ b/frontend/openchat-agent/src/services/openchatAgent.ts
@@ -216,6 +216,7 @@ import {
 import { AnonUserClient } from "./user/anonUser.client";
 import { excludeLatestKnownUpdateIfBeforeFix } from "./common/replicaUpToDateChecker";
 import { ICPCoinsClient } from "./icpcoins/icpcoins.client";
+import type { TranslationRejectionReason } from "openchat-shared";
 
 export class OpenChatAgent extends EventTarget {
     private _userIndexClient: UserIndexClient;
@@ -409,7 +410,9 @@ export class OpenChatAgent extends EventTarget {
             ) {
                 return this.userClient.sendMessageWithTransferToChannel(
                     chatId,
-                    event.event.content.kind !== "p2p_swap_content_initial" ? event.event.content.transfer.recipient : undefined,
+                    event.event.content.kind !== "p2p_swap_content_initial"
+                        ? event.event.content.transfer.recipient
+                        : undefined,
                     user,
                     event,
                     threadRootMessageIndex,
@@ -438,7 +441,9 @@ export class OpenChatAgent extends EventTarget {
             ) {
                 return this.userClient.sendMessageWithTransferToGroup(
                     chatId,
-                    event.event.content.kind !== "p2p_swap_content_initial" ? event.event.content.transfer.recipient : undefined,
+                    event.event.content.kind !== "p2p_swap_content_initial"
+                        ? event.event.content.transfer.recipient
+                        : undefined,
                     user,
                     event,
                     threadRootMessageIndex,
@@ -3091,8 +3096,9 @@ export class OpenChatAgent extends EventTarget {
 
     rejectTranslationCorrection(
         correction: TranslationCorrection,
+        reason: TranslationRejectionReason,
     ): Promise<TranslationCorrections> {
-        console.log("Rejecting translation correction: ", correction);
+        console.log("Rejecting translation correction: ", correction, reason);
         // TODO - for now I'm just going to record these corrections in indexed db
         // eventually we will want an api, but let's get the shape right first
         return this.getTranslationCorrections();
@@ -3113,7 +3119,11 @@ export class OpenChatAgent extends EventTarget {
         return this._userIndexClient.reportedMessages(userId);
     }
 
-    acceptP2PSwap(chatId: ChatIdentifier, threadRootMessageIndex: number | undefined, messageId: bigint): Promise<AcceptP2PSwapResponse> {
+    acceptP2PSwap(
+        chatId: ChatIdentifier,
+        threadRootMessageIndex: number | undefined,
+        messageId: bigint,
+    ): Promise<AcceptP2PSwapResponse> {
         if (chatId.kind === "channel") {
             return this.communityClient(chatId.communityId).acceptP2PSwap(
                 chatId.channelId,
@@ -3128,9 +3138,13 @@ export class OpenChatAgent extends EventTarget {
         } else {
             return this.userClient.acceptP2PSwap(chatId.userId, messageId);
         }
-    }    
+    }
 
-    cancelP2PSwap(chatId: ChatIdentifier, threadRootMessageIndex: number | undefined, messageId: bigint): Promise<CancelP2PSwapResponse> {
+    cancelP2PSwap(
+        chatId: ChatIdentifier,
+        threadRootMessageIndex: number | undefined,
+        messageId: bigint,
+    ): Promise<CancelP2PSwapResponse> {
         if (chatId.kind === "channel") {
             return this.communityClient(chatId.communityId).cancelP2PSwap(
                 chatId.channelId,
@@ -3145,5 +3159,5 @@ export class OpenChatAgent extends EventTarget {
         } else {
             return this.userClient.cancelP2PSwap(chatId.userId, messageId);
         }
-    }    
+    }
 }
diff --git a/frontend/openchat-client/src/openchat.ts b/frontend/openchat-client/src/openchat.ts
index 450f303c89..ebc9bdbd45 100644
--- a/frontend/openchat-client/src/openchat.ts
+++ b/frontend/openchat-client/src/openchat.ts
@@ -459,6 +459,7 @@ import {
 import type { SendMessageResponse } from "openchat-shared";
 import { applyTranslationCorrection } from "./stores/i18n";
 import { getUserCountryCode } from "./utils/location";
+import type { TranslationRejectionReason } from "openchat-shared";
 
 const UPGRADE_POLL_INTERVAL = 1000;
 const MARK_ONLINE_INTERVAL = 61 * 1000;
@@ -3196,27 +3197,31 @@ export class OpenChat extends OpenChatAgentWorker {
 
         // TODO - what about mentions?
         this.sendMessageCommon(
-            chat, 
+            chat,
             messageContext,
             retryEvent,
             [],
             rulesAccepted,
-            communityRulesAccepted);
+            communityRulesAccepted,
+        );
     }
 
     private async sendMessageCommon(
         chat: ChatSummary,
-        messageContext: MessageContext, 
-        eventWrapper: EventWrapper<Message>, 
+        messageContext: MessageContext,
+        eventWrapper: EventWrapper<Message>,
         mentioned: User[] = [],
         rulesAccepted: number | undefined = undefined,
-        communityRulesAccepted: number | undefined = undefined): Promise<void> {
-
-        const {chatId, threadRootMessageIndex} = messageContext;
+        communityRulesAccepted: number | undefined = undefined,
+    ): Promise<void> {
+        const { chatId, threadRootMessageIndex } = messageContext;
 
         const canRetry = this.canRetryMessage(eventWrapper.event.content);
 
-        const messageFilterFailed = doesMessageFailFilter(eventWrapper.event, get(messageFiltersStore));
+        const messageFilterFailed = doesMessageFailFilter(
+            eventWrapper.event,
+            get(messageFiltersStore),
+        );
 
         this.sendRequest({
             kind: "sendMessage",
@@ -3229,59 +3234,59 @@ export class OpenChat extends OpenChatAgentWorker {
             communityRulesAccepted,
             messageFilterFailed,
         })
-        .then(([resp, msg]) => {
-            if (resp.kind === "success" || resp.kind === "transfer_success") {
-                this.onSendMessageSuccess(chatId, resp, msg, threadRootMessageIndex);
-                if (msg.kind === "message" && msg.content.kind === "crypto_content") {
-                    this.refreshAccountBalance(msg.content.transfer.ledger);
-                }
-                if (threadRootMessageIndex !== undefined) {
-                    trackEvent("sent_threaded_message");
-                } else {
-                    if (chat.kind === "direct_chat") {
-                        trackEvent("sent_direct_message");
+            .then(([resp, msg]) => {
+                if (resp.kind === "success" || resp.kind === "transfer_success") {
+                    this.onSendMessageSuccess(chatId, resp, msg, threadRootMessageIndex);
+                    if (msg.kind === "message" && msg.content.kind === "crypto_content") {
+                        this.refreshAccountBalance(msg.content.transfer.ledger);
+                    }
+                    if (threadRootMessageIndex !== undefined) {
+                        trackEvent("sent_threaded_message");
                     } else {
-                        if (chat.public) {
-                            trackEvent("sent_public_group_message");
+                        if (chat.kind === "direct_chat") {
+                            trackEvent("sent_direct_message");
                         } else {
-                            trackEvent("sent_private_group_message");
+                            if (chat.public) {
+                                trackEvent("sent_public_group_message");
+                            } else {
+                                trackEvent("sent_private_group_message");
+                            }
                         }
                     }
-                }
-                if (msg.repliesTo !== undefined) {
-                    // double counting here which I think is OK since we are limited to string events
-                    trackEvent("replied_to_message");
-                }
-            } else {
-                if (resp.kind == "rules_not_accepted") {
-                    this.markChatRulesAcceptedLocally(false);
-                }
+                    if (msg.repliesTo !== undefined) {
+                        // double counting here which I think is OK since we are limited to string events
+                        trackEvent("replied_to_message");
+                    }
+                } else {
+                    if (resp.kind == "rules_not_accepted") {
+                        this.markChatRulesAcceptedLocally(false);
+                    }
 
-                if (resp.kind == "community_rules_not_accepted") {
-                    this.markCommunityRulesAcceptedLocally(false);
-                }
+                    if (resp.kind == "community_rules_not_accepted") {
+                        this.markCommunityRulesAcceptedLocally(false);
+                    }
 
+                    this.onSendMessageFailure(
+                        chatId,
+                        msg.messageId,
+                        threadRootMessageIndex,
+                        eventWrapper,
+                        canRetry,
+                        resp,
+                    );
+                }
+            })
+            .catch((err) => {
                 this.onSendMessageFailure(
                     chatId,
-                    msg.messageId,
+                    eventWrapper.event.messageId,
                     threadRootMessageIndex,
                     eventWrapper,
                     canRetry,
-                    resp,
+                    undefined,
+                    err,
                 );
-            }
-        })
-        .catch((err) => {
-            this.onSendMessageFailure(
-                chatId,
-                eventWrapper.event.messageId,
-                threadRootMessageIndex,
-                eventWrapper,
-                canRetry,
-                undefined,
-                err,
-            );
-        });
+            });
     }
 
     private canRetryMessage(content: MessageContent): boolean {
@@ -3396,12 +3401,13 @@ export class OpenChat extends OpenChatAgentWorker {
         };
 
         this.sendMessageCommon(
-            chat, 
+            chat,
             messageContext,
             event,
             mentioned,
             rulesAccepted,
-            communityRulesAccepted);
+            communityRulesAccepted,
+        );
 
         this.postSendMessage(chat, event, threadRootMessageIndex);
     }
@@ -5069,14 +5075,26 @@ export class OpenChat extends OpenChatAgentWorker {
             });
     }
 
-    acceptP2PSwap(chatId: ChatIdentifier, threadRootMessageIndex: number | undefined, messageId: bigint): Promise<AcceptP2PSwapResponse> {
+    acceptP2PSwap(
+        chatId: ChatIdentifier,
+        threadRootMessageIndex: number | undefined,
+        messageId: bigint,
+    ): Promise<AcceptP2PSwapResponse> {
         localMessageUpdates.setP2PSwapStatus(messageId, {
             kind: "p2p_swap_reserved",
             reservedBy: this._liveState.user.userId,
         });
-        return this.sendRequest({ kind: "acceptP2PSwap", chatId, threadRootMessageIndex, messageId })
+        return this.sendRequest({
+            kind: "acceptP2PSwap",
+            chatId,
+            threadRootMessageIndex,
+            messageId,
+        })
             .then((resp) => {
-                localMessageUpdates.setP2PSwapStatus(messageId, mapAcceptP2PSwapResponseToStatus(resp, this._liveState.user.userId));
+                localMessageUpdates.setP2PSwapStatus(
+                    messageId,
+                    mapAcceptP2PSwapResponseToStatus(resp, this._liveState.user.userId),
+                );
                 return resp;
             })
             .catch((err) => {
@@ -5086,13 +5104,25 @@ export class OpenChat extends OpenChatAgentWorker {
             });
     }
 
-    cancelP2PSwap(chatId: ChatIdentifier, threadRootMessageIndex: number | undefined, messageId: bigint): Promise<CancelP2PSwapResponse> {
+    cancelP2PSwap(
+        chatId: ChatIdentifier,
+        threadRootMessageIndex: number | undefined,
+        messageId: bigint,
+    ): Promise<CancelP2PSwapResponse> {
         localMessageUpdates.setP2PSwapStatus(messageId, {
             kind: "p2p_swap_cancelled",
         });
-        return this.sendRequest({ kind: "cancelP2PSwap", chatId, threadRootMessageIndex, messageId })
+        return this.sendRequest({
+            kind: "cancelP2PSwap",
+            chatId,
+            threadRootMessageIndex,
+            messageId,
+        })
             .then((resp) => {
-                localMessageUpdates.setP2PSwapStatus(messageId, mapCancelP2PSwapResponseToStatus(resp));
+                localMessageUpdates.setP2PSwapStatus(
+                    messageId,
+                    mapCancelP2PSwapResponseToStatus(resp),
+                );
                 return resp;
             })
             .catch((err) => {
@@ -5625,14 +5655,18 @@ export class OpenChat extends OpenChatAgentWorker {
         return community.localUserIndex;
     }
 
+    previewTranslationCorrection(correction: TranslationCorrection): void {
+        applyTranslationCorrection(correction);
+    }
+
     setTranslationCorrection(locale: string, key: string, value: string): Promise<boolean> {
-        const correction = {
+        const correction: TranslationCorrection = {
             locale,
             key,
             value,
             proposedBy: this._liveState.user.userId,
             proposedAt: Date.now(),
-            approved: false,
+            status: "pending",
         };
         return this.sendRequest({
             kind: "setTranslationCorrection",
@@ -5653,10 +5687,12 @@ export class OpenChat extends OpenChatAgentWorker {
 
     rejectTranslationCorrection(
         correction: TranslationCorrection,
+        reason: TranslationRejectionReason
     ): Promise<TranslationCorrections> {
         return this.sendRequest({
             kind: "rejectTranslationCorrection",
             correction,
+            reason
         });
     }
 
diff --git a/frontend/openchat-shared/src/domain/i18n.ts b/frontend/openchat-shared/src/domain/i18n.ts
index 631e93e96a..863ca896f9 100644
--- a/frontend/openchat-shared/src/domain/i18n.ts
+++ b/frontend/openchat-shared/src/domain/i18n.ts
@@ -6,9 +6,11 @@ export type TranslationCorrection = {
     value: string;
     proposedBy: string;
     proposedAt: number;
-    approved: boolean;
+    status: "pending" | "approved" | "rejected" | "deployed";
 };
 
+export type TranslationRejectionReason = "bad_translation" | "layout_problem";
+
 /**
  * This is a flattened version of what gets stored in the i18n translation dictionaries. These corrections
  * will get merged with the default translations at runtime
diff --git a/frontend/openchat-shared/src/domain/worker.ts b/frontend/openchat-shared/src/domain/worker.ts
index 32382f4dc1..301a47b4ed 100644
--- a/frontend/openchat-shared/src/domain/worker.ts
+++ b/frontend/openchat-shared/src/domain/worker.ts
@@ -147,7 +147,11 @@ import type { CandidateProposal } from "./proposals";
 import type { OptionUpdate } from "./optionUpdate";
 import type { AccountTransactionResult, CryptocurrencyDetails, TokenExchangeRates } from "./crypto";
 import type { DexId } from "./dexes";
-import type { TranslationCorrection, TranslationCorrections } from "./i18n";
+import type {
+    TranslationCorrection,
+    TranslationCorrections,
+    TranslationRejectionReason,
+} from "./i18n";
 /**
  * Worker request types
  */
@@ -338,6 +342,7 @@ type ApproveTranslationCorrection = {
 type RejectTranslationCorrection = {
     kind: "rejectTranslationCorrection";
     correction: TranslationCorrection;
+    reason: TranslationRejectionReason;
 };
 
 type LoadSavedCryptoAccounts = {
diff --git a/frontend/openchat-worker/src/worker.ts b/frontend/openchat-worker/src/worker.ts
index 0b3287cb87..3c5f012db0 100644
--- a/frontend/openchat-worker/src/worker.ts
+++ b/frontend/openchat-worker/src/worker.ts
@@ -1465,7 +1465,7 @@ self.addEventListener("message", (msg: MessageEvent<CorrelatedWorkerRequest>) =>
                 executeThenReply(
                     payload,
                     correlationId,
-                    agent.rejectTranslationCorrection(payload.correction),
+                    agent.rejectTranslationCorrection(payload.correction, payload.reason),
                 );
                 break;