Sigs character name (#182)

* feat(Signatures): Added character names

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/SystemSignatures.tsx

@@ -29,19 +29,19 @@ import { WdTooltipWrapper } from '@/hooks/Mapper/components/ui-kit/WdTooltipWrap
 import { useHotkey } from '@/hooks/Mapper/hooks';
 import { COMPACT_MAX_WIDTH } from './constants';
 
-export const SIGNATURE_SETTINGS_KEY = 'wanderer_system_signature_settings_v5_2';
+const SIGNATURE_SETTINGS_KEY = 'wanderer_system_signature_settings_v5_5';
 export const SHOW_DESCRIPTION_COLUMN_SETTING = 'show_description_column_setting';
 export const SHOW_UPDATED_COLUMN_SETTING = 'SHOW_UPDATED_COLUMN_SETTING';
+export const SHOW_CHARACTER_COLUMN_SETTING = 'SHOW_CHARACTER_COLUMN_SETTING';
 export const LAZY_DELETE_SIGNATURES_SETTING = 'LAZY_DELETE_SIGNATURES_SETTING';
 export const KEEP_LAZY_DELETE_SETTING = 'KEEP_LAZY_DELETE_ENABLED_SETTING';
-export const HIDE_LINKED_SIGNATURES_SETTING = 'HIDE_LINKED_SIGNATURES_SETTING';
 
 const SETTINGS: Setting[] = [
   { key: SHOW_UPDATED_COLUMN_SETTING, name: 'Show Updated Column', value: false, isFilter: false },
   { key: SHOW_DESCRIPTION_COLUMN_SETTING, name: 'Show Description Column', value: false, isFilter: false },
+  { key: SHOW_CHARACTER_COLUMN_SETTING, name: 'Show Character Column', value: false, isFilter: false },
   { key: LAZY_DELETE_SIGNATURES_SETTING, name: 'Lazy Delete Signatures', value: false, isFilter: false },
   { key: KEEP_LAZY_DELETE_SETTING, name: 'Keep "Lazy Delete" Enabled', value: false, isFilter: false },
-  { key: HIDE_LINKED_SIGNATURES_SETTING, name: 'Hide Linked Signatures', value: false, isFilter: false },
 
   { key: COSMIC_ANOMALY, name: 'Show Anomalies', value: true, isFilter: true },
   { key: COSMIC_SIGNATURE, name: 'Show Cosmic Signatures', value: true, isFilter: true },

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/SystemSignaturesContent/SystemSignaturesContent.tsx

@@ -19,6 +19,7 @@ import {
   LAZY_DELETE_SIGNATURES_SETTING,
   SHOW_DESCRIPTION_COLUMN_SETTING,
   SHOW_UPDATED_COLUMN_SETTING,
+  SHOW_CHARACTER_COLUMN_SETTING,
 } from '../SystemSignatures';
 import { COSMIC_SIGNATURE } from '../SystemSignatureSettingsDialog';
 import {
@@ -34,6 +35,16 @@ import { getSignatureRowClass } from '../helpers/rowStyles';
 import useMaxWidth from '@/hooks/Mapper/hooks/useMaxWidth';
 import { useClipboard, useHotkey } from '@/hooks/Mapper/hooks';
 
+type SystemSignaturesSortSettings = {
+  sortField: string;
+  sortOrder: SortOrder;
+};
+
+const SORT_DEFAULT_VALUES: SystemSignaturesSortSettings = {
+  sortField: 'inserted_at',
+  sortOrder: -1,
+};
+
 interface SystemSignaturesContentProps {
   systemId: string;
   settings: { key: string; value: boolean }[];
@@ -41,7 +52,7 @@ interface SystemSignaturesContentProps {
   selectable?: boolean;
   onSelect?: (signature: SystemSignature) => void;
   onLazyDeleteChange?: (value: boolean) => void;
-  onCountChange: (count: number) => void;
+  onCountChange?: (count: number) => void;
   onPendingChange?: (pending: ExtendedSystemSignature[], undo: () => void) => void;
 }
 
@@ -68,7 +79,7 @@ export function SystemSignaturesContent({
 
   const [sortSettings, setSortSettings] = useLocalStorageState<{ sortField: string; sortOrder: SortOrder }>(
     'window:signatures:sort',
-    { defaultValue: { sortField: 'inserted_at', sortOrder: -1 } },
+    { defaultValue: SORT_DEFAULT_VALUES },
   );
 
   const tableRef = useRef<HTMLDivElement>(null);
@@ -148,6 +159,7 @@ export function SystemSignaturesContent({
   const groupSettings = settings.filter(s => GROUPS_LIST.includes(s.key as SignatureGroup));
   const showDescriptionColumn = settings.find(s => s.key === SHOW_DESCRIPTION_COLUMN_SETTING)?.value;
   const showUpdatedColumn = settings.find(s => s.key === SHOW_UPDATED_COLUMN_SETTING)?.value;
+  const showCharacterColumn = settings.find(s => s.key === SHOW_CHARACTER_COLUMN_SETTING)?.value;
 
   const filteredSignatures = useMemo<ExtendedSystemSignature[]>(() => {
     return signatures.filter(sig => {
@@ -278,6 +290,16 @@ export function SystemSignaturesContent({
               sortable
             />
           )}
+
+          {showCharacterColumn && (
+            <Column
+              field="character_name"
+              header="Character"
+              bodyClassName="w-[70px] text-ellipsis overflow-hidden whitespace-nowrap"
+              sortable
+            ></Column>
+          )}
+
           {!selectable && (
             <Column
               header=""

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/types.ts

@@ -9,7 +9,7 @@ export interface UseSystemSignaturesDataProps {
   systemId: string;
   settings: { key: string; value: boolean }[];
   hideLinkedSignatures?: boolean;
-  onCountChange: (count: number) => void;
+  onCountChange?: (count: number) => void;
   onPendingChange?: (pending: ExtendedSystemSignature[], undo: () => void) => void;
   onLazyDeleteChange?: (value: boolean) => void;
 }
@@ -21,7 +21,6 @@ export interface UseFetchingParams {
   systemId: string;
   signaturesRef: React.MutableRefObject<ExtendedSystemSignature[]>;
   setSignatures: React.Dispatch<React.SetStateAction<ExtendedSystemSignature[]>>;
-  outCommand: OutCommandHandler;
   localPendingDeletions: ExtendedSystemSignature[];
 }
 
@@ -30,7 +29,6 @@ export interface UseFetchingParams {
  */
 export interface UsePendingDeletionParams {
   systemId: string;
-  outCommand: OutCommandHandler;
   setSignatures: React.Dispatch<React.SetStateAction<ExtendedSystemSignature[]>>;
 }
 

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/usePendingDeletions.ts

@@ -3,8 +3,10 @@ import { OutCommand } from '@/hooks/Mapper/types/mapHandlers';
 import { ExtendedSystemSignature, prepareUpdatePayload, scheduleLazyDeletionTimers } from '../helpers';
 import { UsePendingDeletionParams } from './types';
 import { FINAL_DURATION_MS } from '../constants';
+import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 
-export function usePendingDeletions({ systemId, outCommand, setSignatures }: UsePendingDeletionParams) {
+export function usePendingDeletions({ systemId, setSignatures }: UsePendingDeletionParams) {
+  const { outCommand } = useMapRootState();
   const [localPendingDeletions, setLocalPendingDeletions] = useState<ExtendedSystemSignature[]>([]);
   const [pendingDeletionMap, setPendingDeletionMap] = useState<
     Record<string, { finalUntil: number; finalTimeoutId: number }>

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/useSignatureFetching.ts

@@ -3,14 +3,19 @@ import { SystemSignature } from '@/hooks/Mapper/types';
 import { OutCommand } from '@/hooks/Mapper/types/mapHandlers';
 import { ExtendedSystemSignature, prepareUpdatePayload, getActualSigs } from '../helpers';
 import { UseFetchingParams } from './types';
+import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 
 export function useSignatureFetching({
   systemId,
   signaturesRef,
   setSignatures,
-  outCommand,
   localPendingDeletions,
 }: UseFetchingParams) {
+  const {
+    data: { characters },
+    outCommand,
+  } = useMapRootState();
+
   const handleGetSignatures = useCallback(async () => {
     if (!systemId) {
       setSignatures([]);
@@ -24,9 +29,12 @@ export function useSignatureFetching({
       data: { system_id: systemId },
     });
     const serverSigs = (resp.signatures ?? []) as SystemSignature[];
-    const extended = serverSigs.map(x => ({ ...x })) as ExtendedSystemSignature[];
+    const extended = serverSigs.map(s => ({
+      ...s,
+      character_name: characters.find(c => c.eve_id === s.character_eve_id)?.name,
+    })) as ExtendedSystemSignature[];
     setSignatures(extended);
-  }, [systemId, localPendingDeletions, outCommand, setSignatures]);
+  }, [characters, systemId, localPendingDeletions, outCommand, setSignatures]);
 
   const handleUpdateSignatures = useCallback(
     async (newList: ExtendedSystemSignature[], updateOnly: boolean, skipUpdateUntouched?: boolean) => {
@@ -37,14 +45,12 @@ export function useSignatureFetching({
         skipUpdateUntouched,
       );
 
-      const resp = await outCommand({
+      await outCommand({
         type: OutCommand.updateSignatures,
         data: prepareUpdatePayload(systemId, added, updated, removed),
       });
-      const final = (resp.signatures ?? []) as SystemSignature[];
-      setSignatures(final.map(x => ({ ...x })) as ExtendedSystemSignature[]);
     },
-    [systemId, signaturesRef, outCommand, setSignatures],
+    [systemId, signaturesRef, outCommand],
   );
 
   return {

assets/js/hooks/Mapper/components/mapInterface/widgets/SystemSignatures/hooks/useSystemSignaturesData.ts

@@ -33,7 +33,6 @@ export function useSystemSignaturesData({
   const { localPendingDeletions, setLocalPendingDeletions, processRemovedSignatures, clearPendingDeletions } =
     usePendingDeletions({
       systemId,
-      outCommand,
       setSignatures,
     });
 
@@ -46,7 +45,6 @@ export function useSystemSignaturesData({
     systemId,
     signaturesRef,
     setSignatures,
-    outCommand,
     localPendingDeletions,
   });
 
@@ -191,7 +189,7 @@ export function useSystemSignaturesData({
   }, [systemId, handleGetSignatures, setSignatures]);
 
   useEffect(() => {
-    onCountChange(signatures.length);
+    onCountChange?.(signatures.length);
   }, [signatures, onCountChange]);
 
   return {

assets/js/hooks/Mapper/helpers/sortWHClasses.ts

@@ -2,12 +2,13 @@ import { WORMHOLES_ADDITIONAL_INFO } from '@/hooks/Mapper/components/map/constan
 import { WormholeDataRaw } from '@/hooks/Mapper/types';
 
 export const sortWHClasses = (wormholesData: Record<string, WormholeDataRaw>, statics: string[]) => {
-  if (!statics) {
+  if (!statics || !wormholesData) {
     return [];
   }
 
   return statics
     .map(x => wormholesData[x])
+    .filter(x => !!x)
     .map(x => ({ name: x.name, ...WORMHOLES_ADDITIONAL_INFO[x.dest] }))
     .sort((a, b) => a.wormholeClassID - b.wormholeClassID)
     .map(x => x.name);

assets/js/hooks/Mapper/types/signatures.ts

@@ -1,4 +1,4 @@
-import { SolarSystemStaticInfoRaw } from '@/hooks/Mapper/types';
+import { CharacterTypeRaw, SolarSystemStaticInfoRaw } from '@/hooks/Mapper/types';
 
 export enum SignatureGroup {
   CosmicSignature = 'Cosmic Signature',
@@ -33,6 +33,8 @@ export type SignatureCustomInfo = {
 
 export type SystemSignature = {
   eve_id: string;
+  character_eve_id: string;
+  character_name?: string;
   kind: SignatureKind;
   name: string;
   // SignatureCustomInfo

assets/js/hooks/Mapper/utils/contextStore/useContextStore.ts

@@ -1,18 +1,31 @@
-import { useCallback, useRef, useState } from 'react';
+import { useCallback, useRef, useState, useEffect } from 'react';
 
-import { ContextStoreDataOpts, ProvideConstateDataReturnType, ContextStoreDataUpdate } from './types';
+import { ContextStoreDataOpts, ProvideConstateDataReturnType, ContextStoreDataUpdate, UpdateFunc } from './types';
 
 export const useContextStore = <T>(
   initialValue: T,
   { notNeedRerender = false, handleBeforeUpdate, onAfterAUpdate }: ContextStoreDataOpts<T> = {},
 ): ProvideConstateDataReturnType<T> => {
   const ref = useRef<T>(initialValue);
+  const queueRef = useRef<{ valOrFunc: Partial<T> | UpdateFunc<T>; force: boolean }[]>([]);
   const [, setRerenderKey] = useState(0);
 
   const refWrapper = useRef({ notNeedRerender, handleBeforeUpdate, onAfterAUpdate });
   refWrapper.current = { notNeedRerender, handleBeforeUpdate, onAfterAUpdate };
 
   const update: ContextStoreDataUpdate<T> = useCallback((valOrFunc, force = false) => {
+    queueRef.current.push({ valOrFunc, force });
+  }, []);
+
+  const processNextQueue = useCallback(() => {
+    const next = queueRef.current.shift();
+
+    if (!next) {
+      return;
+    }
+
+    const { valOrFunc, force } = next;
+
     // It need to force prevent unnecessary rerendering
     // update will create once
     const { notNeedRerender, handleBeforeUpdate, onAfterAUpdate } = refWrapper.current;
@@ -76,5 +89,19 @@ export const useContextStore = <T>(
     onAfterAUpdate?.(ref.current);
   }, []);
 
+  useEffect(() => {
+    let requestId: number;
+    const process = () => {
+      processNextQueue();
+      requestId = requestAnimationFrame(process);
+    };
+
+    process();
+
+    return () => {
+      cancelAnimationFrame(requestId);
+    };
+  });
+
   return { update, ref: ref.current };
 };

lib/wanderer_app/map/map_server.ex

@@ -237,6 +237,12 @@ defmodule WandererApp.Map.Server do
       |> map_pid!
       |> GenServer.cast({&Impl.update_connection_custom_info/2, [connection_info]})
 
+  def update_signatures(map_id, signatures_update) when is_binary(map_id),
+    do:
+      map_id
+      |> map_pid!
+      |> GenServer.cast({&Impl.update_signatures/2, [signatures_update]})
+
   @impl true
   def handle_continue(:load_state, state),
     do: {:noreply, state |> Impl.load_state(), {:continue, :start_map}}

lib/wanderer_app/map/server/map_server_impl.ex

@@ -4,7 +4,13 @@ defmodule WandererApp.Map.Server.Impl do
   """
   require Logger
 
-  alias WandererApp.Map.Server.{AclsImpl, CharactersImpl, ConnectionsImpl, SystemsImpl}
+  alias WandererApp.Map.Server.{
+    AclsImpl,
+    CharactersImpl,
+    ConnectionsImpl,
+    SystemsImpl,
+    SignaturesImpl
+  }
 
   @enforce_keys [
     :map_id
@@ -180,7 +186,9 @@ defmodule WandererApp.Map.Server.Impl do
 
   defdelegate update_connection_locked(state, connection_update), to: ConnectionsImpl
 
-  defdelegate update_connection_custom_info(state, connection_update), to: ConnectionsImpl
+  defdelegate update_connection_custom_info(state, signatures_update), to: ConnectionsImpl
+
+  defdelegate update_signatures(state, signatures_update), to: SignaturesImpl
 
   def import_settings(%{map_id: map_id} = state, settings, user_id) do
     WandererApp.Cache.put(

lib/wanderer_app/map/server/map_server_signatures_impl.ex

@@ -0,0 +1,150 @@
+defmodule WandererApp.Map.Server.SignaturesImpl do
+  @moduledoc false
+
+  require Logger
+
+  alias WandererApp.Map.Server.{Impl, ConnectionsImpl, SystemsImpl}
+
+  def update_signatures(
+        %{map_id: map_id} = state,
+        %{
+          solar_system_id: solar_system_id,
+          character: character,
+          user_id: user_id,
+          delete_connection_with_sigs: delete_connection_with_sigs,
+          added_signatures: added_signatures,
+          updated_signatures: updated_signatures,
+          removed_signatures: removed_signatures
+        } =
+          _signatures_update
+      ) do
+    WandererApp.Api.MapSystem.read_by_map_and_solar_system(%{
+      map_id: map_id,
+      solar_system_id: solar_system_id
+    })
+    |> case do
+      {:ok, system} ->
+        character_eve_id = character.eve_id
+
+        case not is_nil(character_eve_id) do
+          true ->
+            added_signatures =
+              added_signatures
+              |> parse_signatures(character_eve_id, system.id)
+
+            updated_signatures =
+              updated_signatures
+              |> parse_signatures(character_eve_id, system.id)
+
+            updated_signatures_eve_ids =
+              updated_signatures
+              |> Enum.map(fn s -> s.eve_id end)
+
+            removed_signatures_eve_ids =
+              removed_signatures
+              |> parse_signatures(character_eve_id, system.id)
+              |> Enum.map(fn s -> s.eve_id end)
+
+            WandererApp.Api.MapSystemSignature.by_system_id!(system.id)
+            |> Enum.filter(fn s -> s.eve_id in removed_signatures_eve_ids end)
+            |> Enum.each(fn s ->
+              if delete_connection_with_sigs && not is_nil(s.linked_system_id) do
+                state
+                |> ConnectionsImpl.delete_connection(%{
+                  solar_system_source_id: system.solar_system_id,
+                  solar_system_target_id: s.linked_system_id
+                })
+              end
+
+              if not is_nil(s.linked_system_id) do
+                state
+                |> SystemsImpl.update_system_linked_sig_eve_id(%{
+                  solar_system_id: s.linked_system_id,
+                  linked_sig_eve_id: nil
+                })
+              end
+
+              s
+              |> Ash.destroy!()
+            end)
+
+            WandererApp.Api.MapSystemSignature.by_system_id!(system.id)
+            |> Enum.filter(fn s -> s.eve_id in updated_signatures_eve_ids end)
+            |> Enum.each(fn s ->
+              updated = updated_signatures |> Enum.find(fn u -> u.eve_id == s.eve_id end)
+
+              if not is_nil(updated) do
+                s
+                |> WandererApp.Api.MapSystemSignature.update(
+                  updated
+                  |> Map.put(:updated, System.os_time())
+                )
+              end
+            end)
+
+            added_signatures
+            |> Enum.each(fn s ->
+              s |> WandererApp.Api.MapSystemSignature.create!()
+            end)
+
+            added_signatures_eve_ids =
+              added_signatures
+              |> Enum.map(fn s -> s.eve_id end)
+
+            if not is_nil(character) &&
+                 not (added_signatures_eve_ids |> Enum.empty?()) do
+              WandererApp.User.ActivityTracker.track_map_event(:signatures_added, %{
+                character_id: character.id,
+                user_id: user_id,
+                map_id: map_id,
+                solar_system_id: system.solar_system_id,
+                signatures: added_signatures_eve_ids
+              })
+            end
+
+            if not is_nil(character) &&
+                 not (removed_signatures_eve_ids |> Enum.empty?()) do
+              WandererApp.User.ActivityTracker.track_map_event(:signatures_removed, %{
+                character_id: character.id,
+                user_id: user_id,
+                map_id: map_id,
+                solar_system_id: system.solar_system_id,
+                signatures: removed_signatures_eve_ids
+              })
+            end
+
+            Impl.broadcast!(map_id, :signatures_updated, system.solar_system_id)
+
+            state
+
+          _ ->
+            state
+        end
+
+      _ ->
+        state
+    end
+  end
+
+  defp parse_signatures(signatures, character_eve_id, system_id),
+    do:
+      signatures
+      |> Enum.map(fn %{
+                       "eve_id" => eve_id,
+                       "name" => name,
+                       "kind" => kind,
+                       "group" => group
+                     } = signature ->
+        %{
+          system_id: system_id,
+          eve_id: eve_id,
+          name: name,
+          description: Map.get(signature, "description"),
+          kind: kind,
+          group: group,
+          type: Map.get(signature, "type"),
+          custom_info: Map.get(signature, "custom_info"),
+          character_eve_id: character_eve_id
+        }
+      end)
+end

lib/wanderer_app/map/server/map_server_systems_impl.ex

@@ -278,7 +278,7 @@ defmodule WandererApp.Map.Server.SystemsImpl do
 
     linked_system_ids
     |> Enum.each(fn linked_system_id ->
-      WandererApp.Map.Server.update_system_linked_sig_eve_id(map_id, %{
+      update_system_linked_sig_eve_id(state, %{
         solar_system_id: linked_system_id,
         linked_sig_eve_id: nil
       })

lib/wanderer_app_web/live/maps/event_handlers/map_signatures_event_handler.ex

@@ -89,133 +89,31 @@ defmodule WandererAppWeb.MapSignaturesEventHandler do
           }
         } = socket
       ) do
-    WandererApp.Api.MapSystem.read_by_map_and_solar_system(%{
-      map_id: map_id,
-      solar_system_id: solar_system_id |> String.to_integer()
-    })
-    |> case do
-      {:ok, system} ->
     first_character_eve_id =
       user_characters |> List.first()
 
-        case not is_nil(first_character_eve_id) do
+    character =
-          true ->
+      current_user.characters
-            added_signatures =
+      |> Enum.find(fn c -> c.eve_id === first_character_eve_id end)
-              added_signatures
-              |> parse_signatures(first_character_eve_id, system.id)
-
-            updated_signatures =
-              updated_signatures
-              |> parse_signatures(first_character_eve_id, system.id)
-
-            updated_signatures_eve_ids =
-              updated_signatures
-              |> Enum.map(fn s -> s.eve_id end)
-
-            removed_signatures_eve_ids =
-              removed_signatures
-              |> parse_signatures(first_character_eve_id, system.id)
-              |> Enum.map(fn s -> s.eve_id end)
 
     delete_connection_with_sigs =
       map_user_settings
       |> WandererApp.MapUserSettingsRepo.to_form_data!()
-              |> WandererApp.MapUserSettingsRepo.get_boolean_setting(
+      |> WandererApp.MapUserSettingsRepo.get_boolean_setting("delete_connection_with_sigs")
-                "delete_connection_with_sigs"
-              )
 
-            WandererApp.Api.MapSystemSignature.by_system_id!(system.id)
-            |> Enum.filter(fn s -> s.eve_id in removed_signatures_eve_ids end)
-            |> Enum.each(fn s ->
-              if delete_connection_with_sigs && not is_nil(s.linked_system_id) do
     map_id
-                |> WandererApp.Map.Server.delete_connection(%{
+    |> WandererApp.Map.Server.update_signatures(%{
-                  solar_system_source_id: system.solar_system_id,
+      solar_system_id: solar_system_id |> String.to_integer(),
-                  solar_system_target_id: s.linked_system_id
+      character: character,
-                })
-              end
-
-              if not is_nil(s.linked_system_id) do
-                map_id
-                |> WandererApp.Map.Server.update_system_linked_sig_eve_id(%{
-                  solar_system_id: s.linked_system_id,
-                  linked_sig_eve_id: nil
-                })
-              end
-
-              s
-              |> Ash.destroy!()
-            end)
-
-            WandererApp.Api.MapSystemSignature.by_system_id!(system.id)
-            |> Enum.filter(fn s -> s.eve_id in updated_signatures_eve_ids end)
-            |> Enum.each(fn s ->
-              updated = updated_signatures |> Enum.find(fn u -> u.eve_id == s.eve_id end)
-
-              if not is_nil(updated) do
-                s
-                |> WandererApp.Api.MapSystemSignature.update(
-                  updated
-                  |> Map.put(:updated, System.os_time())
-                )
-              end
-            end)
-
-            added_signatures
-            |> Enum.each(fn s ->
-              s |> WandererApp.Api.MapSystemSignature.create!()
-            end)
-
-            added_signatures_eve_ids =
-              added_signatures
-              |> Enum.map(fn s -> s.eve_id end)
-
-            first_tracked_character =
-              current_user.characters
-              |> Enum.find(fn c -> c.eve_id === first_character_eve_id end)
-
-            if not is_nil(first_tracked_character) &&
-                 not (added_signatures_eve_ids |> Enum.empty?()) do
-              WandererApp.User.ActivityTracker.track_map_event(:signatures_added, %{
-                character_id: first_tracked_character.id,
       user_id: current_user.id,
-                map_id: map_id,
+      delete_connection_with_sigs: delete_connection_with_sigs,
-                solar_system_id: system.solar_system_id,
+      added_signatures: added_signatures,
-                signatures: added_signatures_eve_ids
+      updated_signatures: updated_signatures,
-              })
+      removed_signatures: removed_signatures
-            end
-
-            if not is_nil(first_tracked_character) &&
-                 not (removed_signatures_eve_ids |> Enum.empty?()) do
-              WandererApp.User.ActivityTracker.track_map_event(:signatures_removed, %{
-                character_id: first_tracked_character.id,
-                user_id: current_user.id,
-                map_id: map_id,
-                solar_system_id: system.solar_system_id,
-                signatures: removed_signatures_eve_ids
-              })
-            end
-
-            Phoenix.PubSub.broadcast!(WandererApp.PubSub, map_id, %{
-              event: :signatures_updated,
-              payload: system.solar_system_id
     })
 
-            {:reply, %{signatures: get_system_signatures(system.id)}, socket}
-
-          _ ->
-            {:reply, %{signatures: []},
-             socket
-             |> put_flash(
-               :error,
-               "You should enable tracking for at least one character to work with signatures."
-             )}
-        end
-
-      _ ->
     {:noreply, socket}
   end
-  end
 
   def handle_ui_event(
         "get_signatures",
@@ -377,6 +275,7 @@ defmodule WandererAppWeb.MapSignaturesEventHandler do
         s
         |> Map.take([
           :eve_id,
+          :character_eve_id,
           :name,
           :description,
           :kind,
@@ -388,26 +287,4 @@ defmodule WandererAppWeb.MapSignaturesEventHandler do
         |> Map.put(:inserted_at, inserted_at |> Calendar.strftime("%Y/%m/%d %H:%M:%S"))
         |> Map.put(:updated_at, updated_at |> Calendar.strftime("%Y/%m/%d %H:%M:%S"))
       end)
-
-  defp parse_signatures(signatures, character_eve_id, system_id),
-    do:
-      signatures
-      |> Enum.map(fn %{
-                       "eve_id" => eve_id,
-                       "name" => name,
-                       "kind" => kind,
-                       "group" => group
-                     } = signature ->
-        %{
-          system_id: system_id,
-          eve_id: eve_id,
-          name: name,
-          description: Map.get(signature, "description"),
-          kind: kind,
-          group: group,
-          type: Map.get(signature, "type"),
-          custom_info: Map.get(signature, "custom_info"),
-          character_eve_id: character_eve_id
-        }
-      end)
 end

lib/wanderer_app_web/live/maps/map_event_handler.ex

@@ -166,6 +166,17 @@ defmodule WandererAppWeb.MapEventHandler do
       when event_name in @map_kills_events,
       do: MapKillsEventHandler.handle_server_event(event, socket)
 
+  def handle_event(
+        %{
+          assigns: %{
+            is_subscription_active?: false
+          }
+        } = socket,
+        %{event: event_name} = _event
+      )
+      when event_name in @map_kills_events,
+      do: socket
+
   def handle_event(socket, {ref, result}) when is_reference(ref) do
     Process.demonitor(ref, [:flush])