feat: update homebase name

* feat: add new page | Homebase Name * refactor: extract accounts/tags selector component * refactor: move content * feat: update homebase name

Author: Ciensprog

src/components/menu/sidebar.tsx

@@ -98,6 +98,18 @@ export function SidebarMenu({
  Save Quests
  </Link>
  </li>
+ <li className="item-stw-operations">
+ <Link
+ to="/stw-operations/homebase-name"
+ className={currentClassNameHover}
+ activeProps={{
+ className: cn(activeClassName),
+ }}
+ onClick={goToPage}
+ >
+ Homebase Name
+ </Link>
+ </li>
  </ul>
  </div>
  <Title className="pb-0">Account Management</Title>

src/components/selectors/accounts/hooks.ts

@@ -0,0 +1,89 @@
+import type { SelectOption } from '../../../components/ui/third-party/extended/input-tags'
+
+import { defaultColor } from '../../../config/constants/colors'
+
+import { useGetAccounts } from '../../../hooks/accounts'
+import { useGetGroups } from '../../../hooks/groups'
+import { useGetTags } from '../../../hooks/tags'
+
+import { parseDisplayName } from '../../../lib/utils'
+
+export function useAccountSelectorData({
+ selectedAccounts,
+ selectedTags,
+}: {
+ selectedAccounts: Array<string>
+ selectedTags: Array<string>
+}) {
+ const { accountList, accountsArray } = useGetAccounts()
+ const { groupsArray } = useGetGroups()
+ const { tagsArray } = useGetTags()
+
+ const areThereAccounts = accountsArray.length > 0
+ const accounts: Array<SelectOption> = accountsArray.map((account) => {
+ const label = parseDisplayName(account)
+
+ return {
+ label,
+ color: defaultColor,
+ value: account.accountId,
+ }
+ })
+ const tags: Array<SelectOption> = tagsArray.map(([name, color]) => ({
+ color: color ?? defaultColor,
+ label: name,
+ value: name,
+ }))
+
+ const parsedSelectedAccounts: Array<SelectOption> = selectedAccounts.map(
+ (accountId) => {
+ const selected = accounts.find((item) => item.value === accountId)!
+
+ return {
+ color: defaultColor,
+ label: selected.label,
+ value: selected.value,
+ }
+ }
+ )
+ const parsedSelectedTags: Array<SelectOption> = selectedTags.map(
+ (tagName) => {
+ const selected = tags.find((item) => item.value === tagName)!
+
+ return {
+ color: selected.color,
+ label: selected.label,
+ value: selected.value,
+ }
+ }
+ )
+
+ const isSelectedEmpty =
+ parsedSelectedAccounts.length === 0 && parsedSelectedTags.length === 0
+
+ const getAccounts = () => {
+ const currentTags = parsedSelectedTags.map(({ value }) => value)
+ const accountIds = [
+ ...new Set([
+ ...parsedSelectedAccounts.map(({ value }) => value),
+ ...groupsArray
+ .filter(([, itemTags]) =>
+ currentTags.some((currentTag) => itemTags.includes(currentTag))
+ )
+ .map(([key]) => key),
+ ]),
+ ]
+ return accountIds.map((accountId) => accountList[accountId])
+ }
+
+ return {
+ accounts,
+ areThereAccounts,
+ isSelectedEmpty,
+ parsedSelectedAccounts,
+ parsedSelectedTags,
+ tags,
+
+ getAccounts,
+ }
+}

src/components/selectors/accounts/index.tsx

@@ -0,0 +1,40 @@
+import type { SelectOption } from '../../ui/third-party/extended/input-tags'
+
+import { SeparatorWithTitle } from '../../ui/extended/separator'
+import { InputTags } from '../../ui/third-party/extended/input-tags'
+
+export function AccountSelectors({
+ accounts,
+ tags,
+ onUpdateAccounts,
+ onUpdateTags,
+}: {
+ accounts: {
+ options: Array<SelectOption>
+ value: Array<SelectOption>
+ }
+ tags: {
+ options: Array<SelectOption>
+ value: Array<SelectOption>
+ }
+ onUpdateAccounts?: (value: Array<SelectOption>) => void
+ onUpdateTags?: (value: Array<SelectOption>) => void
+}) {
+ return (
+ <div className="grid gap-4">
+ <InputTags
+ placeholder="Select some accounts..."
+ options={accounts.options}
+ value={accounts.value}
+ onChange={onUpdateAccounts ?? (() => {})}
+ />
+ <SeparatorWithTitle>Or</SeparatorWithTitle>
+ <InputTags
+ placeholder="Select some tags..."
+ options={tags.options}
+ value={tags.value}
+ onChange={onUpdateTags ?? (() => {})}
+ />
+ </div>
+ )
+}

src/config/constants/main-process.ts

@@ -84,6 +84,9 @@ export enum ElectronAPIEventKeys {
  SetSaveQuests = 'save-quests:set',
  SaveQuestsNotification = 'save-quests:notification',
 
+ SetHombaseName = 'homebase-name:set',
+ HomebaseNameNotification = 'homebase-name:notification',
+
  /**
  * Party
  */

src/hooks/stw-operations/homebase-name.ts

@@ -0,0 +1,49 @@
+import type { SelectOption } from '../../components/ui/third-party/extended/input-tags'
+
+import { useShallow } from 'zustand/react/shallow'
+
+import { useHomebaseNameStore } from '../../state/stw-operations/homebase-name'
+
+export function useGetHomebaseNameData() {
+ const { accounts, tags } = useHomebaseNameStore(
+ useShallow((state) => ({
+ accounts: state.accounts,
+ tags: state.tags,
+ }))
+ )
+
+ return {
+ selectedAccounts: accounts,
+ selectedTags: tags,
+ }
+}
+
+export function useGetHomebaseNameActions() {
+ const { updateAccounts, updateTags } = useHomebaseNameStore(
+ useShallow((state) => ({
+ updateAccounts: state.updateAccounts,
+ updateTags: state.updateTags,
+ }))
+ )
+
+ const rawHomebaseNameUpdateAccounts = (value: Array<string>) => {
+ updateAccounts(value)
+ }
+ const homebaseNameUpdateAccounts = (value: Array<SelectOption>) => {
+ updateAccounts(value.map((item) => item.value))
+ }
+
+ const rawHomebaseNameUpdateTags = (value: Array<string>) => {
+ updateTags(value)
+ }
+ const homebaseNameUpdateTags = (value: Array<SelectOption>) => {
+ updateTags(value.map((item) => item.value))
+ }
+
+ return {
+ rawHomebaseNameUpdateAccounts,
+ rawHomebaseNameUpdateTags,
+ homebaseNameUpdateAccounts,
+ homebaseNameUpdateTags,
+ }
+}

src/kernel/core/mcp/homebase-name.ts

@@ -0,0 +1,91 @@
+import type { AccountData } from '../../../types/accounts'
+
+import { BrowserWindow } from 'electron'
+
+import { ElectronAPIEventKeys } from '../../../config/constants/main-process'
+
+import { NotificationHomebaseNameResponse } from '../../../kernel/preload-actions/mcp'
+
+import { Authentication } from '../authentication'
+
+import { setHomebaseName } from '../../../services/endpoints/mcp'
+
+export class MCPHomebaseName {
+ static async update(
+ currentWindow: BrowserWindow,
+ accounts: Array<AccountData>,
+ homebaseName: string
+ ) {
+ try {
+ const response = await Promise.allSettled(
+ accounts.map(async (account) => {
+ const result: NotificationHomebaseNameResponse = {
+ errorMessage: undefined,
+ }
+
+ try {
+ const accessToken =
+ await Authentication.verifyAccessToken(account)
+
+ if (!accessToken) {
+ result.errorMessage = 'Unknown Error'
+
+ return result
+ }
+
+ const { accountId } = account
+
+ const mcpResponse = await setHomebaseName({
+ accessToken,
+ accountId,
+ homebaseName,
+ })
+
+ if (!mcpResponse.data.profileChanges?.[0]) {
+ result.errorMessage = 'Unknown Error'
+ }
+
+ // eslint-disable-next-line @typescript-eslint/no-explicit-any
+ } catch (error: any) {
+ if (error?.response?.data.errorMessage) {
+ const errorMessage =
+ error.response?.data?.errorMessage ?? 'Unknown Error'
+
+ result.errorMessage = errorMessage
+ } else {
+ result.errorMessage = 'Unknown Error'
+ }
+ }
+
+ return result
+ })
+ )
+ const filteredResponse = response
+ .filter((result) => result.status === 'fulfilled')
+ .map((result) => result.value)
+ const commonError = filteredResponse.find(
+ (item) => item.errorMessage
+ )
+
+ currentWindow.webContents.send(
+ ElectronAPIEventKeys.HomebaseNameNotification,
+ (commonError
+ ? {
+ errorMessage: commonError.errorMessage,
+ }
+ : {}) as NotificationHomebaseNameResponse
+ )
+
+ return
+ } catch (error) {
+ //
+ }
+
+ currentWindow.webContents.send(
+ ElectronAPIEventKeys.HomebaseNameNotification,
+ {
+ errorMessage: 'Unknown Error',
+ } as NotificationHomebaseNameResponse
+ )
+ }
+}

src/kernel/core/mcp/index.ts

@@ -1 +1,2 @@
-export * from './client-quest-login'
+export { MCPClientQuestLogin } from './client-quest-login'
+export { MCPHomebaseName } from './homebase-name'

src/kernel/main.ts

@@ -19,7 +19,7 @@ import { AntiCheatProvider } from './core/anti-cheat-provider'
 import { Authentication } from './core/authentication'
 import { ClaimRewards } from './core/claim-rewards'
 import { FortniteLauncher } from './core/launcher'
-import { MCPClientQuestLogin } from './core/mcp'
+import { MCPClientQuestLogin, MCPHomebaseName } from './core/mcp'
 import { Manifest } from './core/manifest'
 import { Party } from './core/party'
 import { AccountsManager } from './startup/accounts'
@@ -234,6 +234,13 @@ app.on('ready', async () => {
  }
  )
 
+ ipcMain.on(
+ ElectronAPIEventKeys.SetHombaseName,
+ async (_, accounts: Array<AccountData>, homebaseName: string) => {
+ await MCPHomebaseName.update(currentWindow, accounts, homebaseName)
+ }
+ )
+
  /**
  * Party
  */

src/kernel/preload-actions/mcp/claim-rewards.ts

@@ -1,5 +1,4 @@
 import type { IpcRendererEvent } from 'electron'
-// import type { AccountData } from '../../../types/accounts'
 import type { RewardsNotification } from '../../../types/notifications'
 
 import { ipcRenderer } from 'electron'

src/kernel/preload-actions/mcp/homebase-name.ts

@@ -0,0 +1,44 @@
+import type { IpcRendererEvent } from 'electron'
+import type { AccountData } from '../../../types/accounts'
+
+import { ipcRenderer } from 'electron'
+
+import { ElectronAPIEventKeys } from '../../../config/constants/main-process'
+
+export type NotificationHomebaseNameResponse = {
+ errorMessage?: string
+}
+
+export function setHomebaseName(
+ accounts: Array<AccountData>,
+ homebaseName: string
+) {
+ ipcRenderer.send(
+ ElectronAPIEventKeys.SetHombaseName,
+ accounts,
+ homebaseName
+ )
+}
+
+export function notificationHomebaseName(
+ callback: (response: NotificationHomebaseNameResponse) => Promise<void>
+) {
+ const customCallback = (
+ _: IpcRendererEvent,
+ response: NotificationHomebaseNameResponse
+ ) => {
+ callback(response).catch(() => {})
+ }
+ const rendererInstance = ipcRenderer.on(
+ ElectronAPIEventKeys.HomebaseNameNotification,
+ customCallback
+ )
+
+ return {
+ removeListener: () =>
+ rendererInstance.removeListener(
+ ElectronAPIEventKeys.HomebaseNameNotification,
+ customCallback
+ ),
+ }
+}