chore: release version v1.15.1

.devcontainer/Dockerfile

@@ -1,12 +1,7 @@
-FROM elixir:1.16-otp-25
+FROM elixir:1.17-otp-27
 
-RUN apt update -yq
-RUN apt install -yq curl gnupg mc inotify-tools
+RUN apt install -yq curl gnupg
 RUN apt --fix-broken install
-RUN apt remove -y nodejs nodejs-doc
-RUN curl -sL https://deb.nodesource.com/setup_18.x  | bash -
-RUN apt install -y nodejs
-RUN npm install --global yarn
 
 RUN mix local.hex --force
 

.devcontainer/docker-compose.yml

@@ -2,7 +2,7 @@ version: "0.1"
 
 services:
   db:
-    image: postgres:14.3
+    image: postgres:13-alpine
     restart: always
     environment:
       POSTGRES_USER: postgres
@@ -10,13 +10,13 @@ services:
     ports:
       - "5432:5432"
     volumes:
-      - db:/var/lib/postgresql/data
+      - db-new:/var/lib/postgresql/data
 
   wanderer:
     environment:
       PORT: 8000
       DB_HOST: db
-      WEB_APP_URL: "http://localhost:4444"
+      WEB_APP_URL: "http://localhost:8000"
       ERL_AFLAGS: "-kernel shell_history enabled"
     build:
       context: .
@@ -33,4 +33,4 @@ services:
 
 volumes:
   elixir-artifacts: {}
-  db: {}
+  db-new: {}

CHANGELOG.md

@@ -2,6 +2,42 @@
 
 <!-- changelog -->
 
+## [v1.15.1](https://github.com/wanderer-industries/wanderer/compare/v1.15.0...v1.15.1) (2024-11-07)
+
+
+
+
+### Bug Fixes:
+
+* Dev: Update .devcontainer instructions
+
+## [v1.15.0](https://github.com/wanderer-industries/wanderer/compare/v1.14.1...v1.15.0) (2024-11-07)
+
+
+
+
+### Features:
+
+* Connections: Add connection mark EOL time (#56)
+
+## [v1.14.1](https://github.com/wanderer-industries/wanderer/compare/v1.14.0...v1.14.1) (2024-11-06)
+
+
+
+
+### Bug Fixes:
+
+* Core: Fix character tracking permissions
+
+## [v1.14.0](https://github.com/wanderer-industries/wanderer/compare/v1.13.12...v1.14.0) (2024-11-05)
+
+
+
+
+### Features:
+
+* ACL: Add an ability to assign member role without DnD
+
 ## [v1.13.12](https://github.com/wanderer-industries/wanderer/compare/v1.13.11...v1.13.12) (2024-11-04)
 
 

README.md

@@ -54,7 +54,14 @@ Now you can visit [`localhost:8000`](http://localhost:8000) from your browser.
 #### Using .devcontainer
 
 - Run devcontainer
-- See how to start server in #setup section
+- Install additional dependencies inside Dev container
+
+`root@0d0a785313b6:/app# apt update`
+`root@0d0a785313b6:/app# curl -sL https://deb.nodesource.com/setup_18.x  | bash -`
+`root@0d0a785313b6:/app# apt-get install nodejs inotify-tools -y`
+`root@0d0a785313b6:/app# mix setup`
+
+- See how to run server in #Run section
 
 #### Using nix flakes
 

assets/js/hooks/Mapper/components/mapRootContent/components/Connections/Connections.tsx

@@ -1,13 +1,20 @@
 import classes from './Connections.module.scss';
 import { Sidebar } from 'primereact/sidebar';
-import { useEffect, useMemo, useState } from 'react';
+import { useEffect, useMemo, useState, useCallback } from 'react';
 import { useMapRootState } from '@/hooks/Mapper/mapRootProvider';
 import { VirtualScroller, VirtualScrollerTemplateOptions } from 'primereact/virtualscroller';
 import clsx from 'clsx';
-import { ConnectionOutput, OutCommand, Passage, SolarSystemConnection } from '@/hooks/Mapper/types';
+import {
+  ConnectionOutput,
+  ConnectionInfoOutput,
+  OutCommand,
+  Passage,
+  SolarSystemConnection,
+} from '@/hooks/Mapper/types';
 import { PassageCard } from './PassageCard';
 import { InfoDrawer, SystemView } from '@/hooks/Mapper/components/ui-kit';
 import { kgToTons } from '@/hooks/Mapper/utils/kgToTons.ts';
+import { TimeAgo } from '@/hooks/Mapper/components/ui-kit';
 
 const sortByDate = (a: string, b: string) => new Date(a).getTime() - new Date(b).getTime();
 
@@ -69,25 +76,44 @@ export const Connections = ({ selectedConnection, onHide }: OnTheMapProps) => {
   }, [connections, selectedConnection]);
 
   const [passages, setPassages] = useState<Passage[]>([]);
+  const [info, setInfo] = useState<ConnectionInfoOutput>(null);
+
+  const loadInfo = useCallback(
+    async (connection: SolarSystemConnection) => {
+      const result = await outCommand<ConnectionInfoOutput>({
+        type: OutCommand.getConnectionInfo,
+        data: {
+          from: connection.source,
+          to: connection.target,
+        },
+      });
+
+      setInfo(result);
+    },
+    [outCommand],
+  );
+
+  const loadPassages = useCallback(
+    async (connection: SolarSystemConnection) => {
+      const result = await outCommand<ConnectionOutput>({
+        type: OutCommand.getPassages,
+        data: {
+          from: connection.source,
+          to: connection.target,
+        },
+      });
+
+      setPassages(result.passages.sort((a, b) => sortByDate(b.inserted_at, a.inserted_at)));
+    },
+    [outCommand],
+  );
 
   useEffect(() => {
     if (!selectedConnection) {
       return;
     }
-
-    const loadInfo = async () => {
-      const result = await outCommand<ConnectionOutput>({
-        type: OutCommand.getPassages,
-        data: {
-          from: selectedConnection.source,
-          to: selectedConnection.target,
-        },
-      });
-
-      setPassages(result.passages.sort((a, b) => sortByDate(b.inserted_at, a.inserted_at)));
-    };
-
-    loadInfo();
+    loadInfo(selectedConnection);
+    loadPassages(selectedConnection);
   }, [selectedConnection]);
 
   const approximateMass = useMemo(() => {
@@ -132,6 +158,10 @@ export const Connections = ({ selectedConnection, onHide }: OnTheMapProps) => {
             {kgToTons(approximateMass)}
           </InfoDrawer>
 
+          <InfoDrawer title="Mark EOL Time" rightSide>
+            {info?.marl_eol_time ? <TimeAgo timestamp={info.marl_eol_time} /> : ' unknown '}
+          </InfoDrawer>
+
           <div className="flex gap-2"></div>
         </div>
 

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

@@ -11,6 +11,10 @@ export type Passage = {
   character: PassageLimitedCharacterType;
 };
 
+export type ConnectionInfoOutput = {
+  marl_eol_time: string;
+};
+
 export type ConnectionOutput = {
   passages: Passage[];
 };

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

@@ -118,6 +118,7 @@ export enum OutCommand {
   getCharacterJumps = 'get_character_jumps',
   getSignatures = 'get_signatures',
   getSystemStaticInfos = 'get_system_static_infos',
+  getConnectionInfo = 'get_connection_info',
   updateConnectionTimeStatus = 'update_connection_time_status',
   updateConnectionMassStatus = 'update_connection_mass_status',
   updateConnectionShipSizeType = 'update_connection_ship_size_type',

assets/js/hooks/drag.ts

@@ -8,7 +8,7 @@ export default {
     const selector = '#' + this.el.id;
 
     const droppable = new Droppable(containers, {
-      delay: 150,
+      delay: 100,
       draggable: '.draggable',
       dropzone: '.dropzone',
       mirror: {

lib/wanderer_app/api/calculations/calc_map_permissions.ex

@@ -4,8 +4,6 @@ defmodule WandererApp.Api.Calculations.CalcMapPermissions do
   use Ash.Resource.Calculation
   require Ash.Query
 
-  import Bitwise
-
   @impl true
   def load(_query, _opts, _context) do
     [
@@ -17,116 +15,8 @@ defmodule WandererApp.Api.Calculations.CalcMapPermissions do
   end
 
   @impl true
-  def calculate([record], _opts, %{actor: actor}) do
-    characters = actor.characters
-
-    character_ids = characters |> Enum.map(& &1.id)
-    character_eve_ids = characters |> Enum.map(& &1.eve_id)
-
-    character_corporation_ids =
-      characters |> Enum.map(& &1.corporation_id) |> Enum.map(&to_string/1)
-
-    character_alliance_ids = characters |> Enum.map(& &1.alliance_id) |> Enum.map(&to_string/1)
-
-    result =
-      record.acls
-      |> Enum.reduce([0, 0], fn acl, acc ->
-        is_owner? = acl.owner_id in character_ids
-
-        is_character_member? =
-          acl.members |> Enum.any?(fn member -> member.eve_character_id in character_eve_ids end)
-
-        is_corporation_member? =
-          acl.members
-          |> Enum.any?(fn member -> member.eve_corporation_id in character_corporation_ids end)
-
-        is_alliance_member? =
-          acl.members
-          |> Enum.any?(fn member -> member.eve_alliance_id in character_alliance_ids end)
-
-        if is_owner? || is_character_member? || is_corporation_member? || is_alliance_member? do
-          case acc do
-            [_, -1] ->
-              [-1, -1]
-
-            [-1, char_acc] ->
-              char_acl_mask =
-                acl.members
-                |> Enum.filter(fn member ->
-                  member.eve_character_id in character_eve_ids
-                end)
-                |> Enum.reduce(0, fn member, acc ->
-                  case acc do
-                    -1 -> -1
-                    _ -> WandererApp.Permissions.calc_role_mask(member.role, acc)
-                  end
-                end)
-
-              char_acc =
-                case char_acl_mask do
-                  -1 -> -1
-                  _ -> char_acc ||| char_acl_mask
-                end
-
-              [-1, char_acc]
-
-            [any_acc, char_acc] ->
-              any_acl_mask =
-                acl.members
-                |> Enum.filter(fn member ->
-                  member.eve_character_id in character_eve_ids ||
-                    member.eve_corporation_id in character_corporation_ids ||
-                    member.eve_alliance_id in character_alliance_ids
-                end)
-                |> Enum.reduce(0, fn member, acc ->
-                  case acc do
-                    -1 -> -1
-                    _ -> WandererApp.Permissions.calc_role_mask(member.role, acc)
-                  end
-                end)
-
-              char_acl_mask =
-                acl.members
-                |> Enum.filter(fn member ->
-                  member.eve_character_id in character_eve_ids
-                end)
-                |> Enum.reduce(0, fn member, acc ->
-                  case acc do
-                    -1 -> -1
-                    _ -> WandererApp.Permissions.calc_role_mask(member.role, acc)
-                  end
-                end)
-
-              any_acc =
-                case any_acl_mask do
-                  -1 -> -1
-                  _ -> any_acc ||| any_acl_mask
-                end
-
-              char_acc =
-                case char_acl_mask do
-                  -1 -> -1
-                  _ -> char_acc ||| char_acl_mask
-                end
-
-              [any_acc, char_acc]
-          end
-        else
-          acc
-        end
-      end)
-
-    case result do
-      [_, -1] ->
-        [-1]
-
-      [-1, char_acc] ->
-        [char_acc]
-
-      [any_acc, _char_acc] ->
-        [any_acc]
-    end
-  end
+  def calculate([record], _opts, %{actor: actor}),
+    do: WandererApp.Permissions.check_characters_access(actor.characters, record.acls)
 
   @impl true
   def calculate(_records, _opts, _context) do

lib/wanderer_app/map.ex

@@ -8,6 +8,7 @@ defmodule WandererApp.Map do
   defstruct map_id: nil,
             name: nil,
             scope: :none,
+            owner_id: nil,
             characters: [],
             systems: Map.new(),
             hubs: [],
@@ -16,11 +17,12 @@ defmodule WandererApp.Map do
             characters_limit: nil,
             hubs_limit: nil
 
-  def new(%{id: map_id, name: name, scope: scope, acls: acls, hubs: hubs}) do
+  def new(%{id: map_id, name: name, scope: scope, owner_id: owner_id, acls: acls, hubs: hubs}) do
     map =
       struct!(__MODULE__,
         map_id: map_id,
         scope: scope,
+        owner_id: owner_id,
         name: name,
         acls: acls,
         hubs: hubs

lib/wanderer_app/map/map_server.ex

@@ -183,6 +183,12 @@ defmodule WandererApp.Map.Server do
       |> map_pid!
       |> GenServer.cast({&Impl.delete_connection/2, [connection_info]})
 
+  def get_connection_info(map_id, connection_info) when is_binary(map_id),
+    do:
+      map_id
+      |> map_pid!
+      |> GenServer.call({&Impl.get_connection_info/2, [connection_info]}, :timer.minutes(1))
+
   def update_connection_time_status(map_id, connection_info) when is_binary(map_id),
     do:
       map_id

lib/wanderer_app/map/map_server_impl.ex

@@ -77,6 +77,7 @@ defmodule WandererApp.Map.Server.Impl do
   # @unknown 100_100
 
   @systems_cleanup_timeout :timer.minutes(30)
+  @characters_cleanup_timeout :timer.minutes(1)
   @connections_cleanup_timeout :timer.minutes(2)
 
   @connection_time_status_eol 1
@@ -112,20 +113,28 @@ defmodule WandererApp.Map.Server.Impl do
   end
 
   def load_state(%__MODULE__{map_id: map_id} = state) do
-    with {:ok, map} <- WandererApp.MapRepo.get(map_id, [:acls, :characters]),
+    with {:ok, map} <-
+           WandererApp.MapRepo.get(map_id, [
+             :owner,
+             :characters,
+             acls: [
+               :owner_id,
+               members: [:role, :eve_character_id, :eve_corporation_id, :eve_alliance_id]
+             ]
+           ]),
          {:ok, systems} <- WandererApp.MapSystemRepo.get_visible_by_map(map_id),
          {:ok, connections} <- WandererApp.MapConnectionRepo.get_by_map(map_id),
          {:ok, subscription_settings} <-
            WandererApp.Map.SubscriptionManager.get_active_map_subscription(map_id) do
       state
-      |> _init_map(
+      |> init_map(
         map,
         subscription_settings,
         systems,
         connections
       )
-      |> _init_map_systems(systems)
-      |> _init_map_cache()
+      |> init_map_systems(systems)
+      |> init_map_cache()
     else
       error ->
         @logger.error("Failed to load map state: #{inspect(error, pretty: true)}")
@@ -144,7 +153,8 @@ defmodule WandererApp.Map.Server.Impl do
       Process.send_after(self(), :update_tracked_characters, 100)
       Process.send_after(self(), :update_presence, @update_presence_timeout)
       Process.send_after(self(), :cleanup_connections, 5000)
-      Process.send_after(self(), :cleanup_systems, 10000)
+      Process.send_after(self(), :cleanup_systems, 10_000)
+      Process.send_after(self(), :cleanup_characters, :timer.minutes(5))
       Process.send_after(self(), :backup_state, @backup_state_timeout)
 
       WandererApp.Cache.insert("map_#{map_id}:started", true)
@@ -169,7 +179,7 @@ defmodule WandererApp.Map.Server.Impl do
     :telemetry.execute([:wanderer_app, :map, :stopped], %{count: 1})
 
     state
-    |> _maybe_stop_rtree()
+    |> maybe_stop_rtree()
   end
 
   def get_map(%{map: map} = _state), do: {:ok, map}
@@ -249,37 +259,37 @@ defmodule WandererApp.Map.Server.Impl do
         state,
         update
       ),
-      do: state |> _update_system(:update_name, [:name], update)
+      do: state |> update_system(:update_name, [:name], update)
 
   def update_system_description(
         state,
         update
       ),
-      do: state |> _update_system(:update_description, [:description], update)
+      do: state |> update_system(:update_description, [:description], update)
 
   def update_system_status(
         state,
         update
       ),
-      do: state |> _update_system(:update_status, [:status], update)
+      do: state |> update_system(:update_status, [:status], update)
 
   def update_system_tag(
         state,
         update
       ),
-      do: state |> _update_system(:update_tag, [:tag], update)
+      do: state |> update_system(:update_tag, [:tag], update)
 
   def update_system_locked(
         state,
         update
       ),
-      do: state |> _update_system(:update_locked, [:locked], update)
+      do: state |> update_system(:update_locked, [:locked], update)
 
   def update_system_labels(
         state,
         update
       ),
-      do: state |> _update_system(:update_labels, [:labels], update)
+      do: state |> update_system(:update_labels, [:labels], update)
 
   def update_system_position(
         %{rtree_name: rtree_name} = state,
@@ -287,7 +297,7 @@ defmodule WandererApp.Map.Server.Impl do
       ),
       do:
         state
-        |> _update_system(
+        |> update_system(
           :update_position,
           [:position_x, :position_y],
           update,
@@ -435,12 +445,34 @@ defmodule WandererApp.Map.Server.Impl do
     state
   end
 
+  def get_connection_info(
+        %{map_id: map_id} = _state,
+        %{
+          solar_system_source_id: solar_system_source_id,
+          solar_system_target_id: solar_system_target_id
+        } = _connection_info
+      ) do
+    WandererApp.Map.find_connection(
+      map_id,
+      solar_system_source_id,
+      solar_system_target_id
+    )
+    |> case do
+      {:ok, %{id: connection_id}} ->
+        connection_mark_eol_time = get_connection_mark_eol_time(map_id, connection_id, nil)
+        {:ok, %{marl_eol_time: connection_mark_eol_time}}
+
+      _ ->
+        {:error, :not_found}
+    end
+  end
+
   def update_connection_time_status(
         %{map_id: map_id} = state,
         connection_update
       ),
       do:
-        _update_connection(state, :update_time_status, [:time_status], connection_update, fn
+        update_connection(state, :update_time_status, [:time_status], connection_update, fn
           %{id: connection_id, time_status: time_status} ->
             case time_status == @connection_time_status_eol do
               true ->
@@ -459,25 +491,25 @@ defmodule WandererApp.Map.Server.Impl do
         state,
         connection_update
       ),
-      do: _update_connection(state, :update_mass_status, [:mass_status], connection_update)
+      do: update_connection(state, :update_mass_status, [:mass_status], connection_update)
 
   def update_connection_ship_size_type(
         state,
         connection_update
       ),
-      do: _update_connection(state, :update_ship_size_type, [:ship_size_type], connection_update)
+      do: update_connection(state, :update_ship_size_type, [:ship_size_type], connection_update)
 
   def update_connection_locked(
         state,
         connection_update
       ),
-      do: _update_connection(state, :update_locked, [:locked], connection_update)
+      do: update_connection(state, :update_locked, [:locked], connection_update)
 
   def update_connection_custom_info(
         state,
         connection_update
       ),
-      do: _update_connection(state, :update_custom_info, [:custom_info], connection_update)
+      do: update_connection(state, :update_custom_info, [:custom_info], connection_update)
 
   def import_settings(%{map_id: map_id} = state, settings, user_id) do
     WandererApp.Cache.put(
@@ -487,9 +519,9 @@ defmodule WandererApp.Map.Server.Impl do
 
     state =
       state
-      |> _maybe_import_systems(settings, user_id, nil)
-      |> _maybe_import_connections(settings, user_id)
-      |> _maybe_import_hubs(settings, user_id)
+      |> maybe_import_systems(settings, user_id, nil)
+      |> maybe_import_connections(settings, user_id)
+      |> maybe_import_hubs(settings, user_id)
 
     WandererApp.Cache.take("map_#{map_id}:importing")
 
@@ -509,11 +541,11 @@ defmodule WandererApp.Map.Server.Impl do
     |> Enum.map(fn character_id ->
       Task.start_link(fn ->
         character_updates =
-          _maybe_update_online(map_id, character_id) ++
-            _maybe_update_location(map_id, character_id) ++
-            _maybe_update_ship(map_id, character_id) ++
-            _maybe_update_alliance(map_id, character_id) ++
-            _maybe_update_corporation(map_id, character_id)
+          maybe_update_online(map_id, character_id) ++
+            maybe_update_location(map_id, character_id) ++
+            maybe_update_ship(map_id, character_id) ++
+            maybe_update_alliance(map_id, character_id) ++
+            maybe_update_corporation(map_id, character_id)
 
         character_updates
         |> Enum.filter(fn update -> update != :skip end)
@@ -521,7 +553,7 @@ defmodule WandererApp.Map.Server.Impl do
           update
           |> case do
             {:character_location, location_info, old_location_info} ->
-              _update_location(
+              update_location(
                 character_id,
                 location_info,
                 old_location_info,
@@ -537,9 +569,25 @@ defmodule WandererApp.Map.Server.Impl do
               :broadcast
 
             {:character_alliance, _info} ->
+              WandererApp.Cache.insert_or_update(
+                "map_#{map_id}:invalidate_character_ids",
+                [character_id],
+                fn ids ->
+                  [character_id | ids]
+                end
+              )
+
               :broadcast
 
             {:character_corporation, _info} ->
+              WandererApp.Cache.insert_or_update(
+                "map_#{map_id}:invalidate_character_ids",
+                [character_id],
+                fn ids ->
+                  [character_id | ids]
+                end
+              )
+
               :broadcast
 
             _ ->
@@ -590,29 +638,37 @@ defmodule WandererApp.Map.Server.Impl do
   def handle_event(:update_presence, %{map_id: map_id} = state) do
     Process.send_after(self(), :update_presence, @update_presence_timeout)
 
-    _update_presence(map_id)
+    update_presence(map_id)
 
     state
   end
 
   def handle_event(:backup_state, state) do
     Process.send_after(self(), :backup_state, @backup_state_timeout)
-    {:ok, _map_state} = state |> _save_map_state()
+    {:ok, _map_state} = state |> save_map_state()
 
     state
   end
 
-  def handle_event({:map_acl_updated, added_acls, removed_acls}, %{map: old_map} = state) do
-    {:ok, map} = WandererApp.MapRepo.get(old_map.map_id, [:acls])
+  def handle_event(
+        {:map_acl_updated, added_acls, removed_acls},
+        %{map_id: map_id, map: old_map} = state
+      ) do
+    {:ok, map} =
+      WandererApp.MapRepo.get(map_id,
+        acls: [
+          :owner_id,
+          members: [:role, :eve_character_id, :eve_corporation_id, :eve_alliance_id]
+        ]
+      )
 
     track_acls(added_acls)
 
     result =
-      [added_acls | removed_acls]
-      |> List.flatten()
+      (added_acls ++ removed_acls)
       |> Task.async_stream(
         fn acl_id ->
-          _update_acl(acl_id)
+          update_acl(acl_id)
         end,
         max_concurrency: 10,
         timeout: :timer.seconds(15)
@@ -641,29 +697,45 @@ defmodule WandererApp.Map.Server.Impl do
               }
 
             error ->
-              @logger.error(
-                "Failed to update map #{old_map.map_id} acl: #{inspect(error, pretty: true)}"
-              )
+              @logger.error("Failed to update map #{map_id} acl: #{inspect(error, pretty: true)}")
 
               acc
           end
         end
       )
 
-    _broadcast_acl_updates({:ok, result})
+    map_update = %{acls: map.acls, scope: map.scope}
 
-    %{state | map: %{old_map | acls: map.acls, scope: map.scope}}
+    WandererApp.Map.update_map(map_id, map_update)
+
+    broadcast_acl_updates({:ok, result}, map_id)
+
+    %{state | map: Map.merge(old_map, map_update)}
   end
 
-  def handle_event({:acl_updated, %{acl_id: acl_id}}, %{map: map} = state) do
+  def handle_event({:acl_updated, %{acl_id: acl_id}}, %{map_id: map_id, map: old_map} = state) do
+    {:ok, map} =
+      WandererApp.MapRepo.get(map_id,
+        acls: [
+          :owner_id,
+          members: [:role, :eve_character_id, :eve_corporation_id, :eve_alliance_id]
+        ]
+      )
+
     if map.acls |> Enum.map(& &1.id) |> Enum.member?(acl_id) do
+      map_update = %{acls: map.acls}
+
+      WandererApp.Map.update_map(map_id, map_update)
+
       :ok =
         acl_id
-        |> _update_acl()
-        |> _broadcast_acl_updates()
-    end
+        |> update_acl()
+        |> broadcast_acl_updates(map_id)
 
-    state
+      state
+    else
+      state
+    end
   end
 
   def handle_event(:cleanup_connections, %{map_id: map_id} = state) do
@@ -752,6 +824,76 @@ defmodule WandererApp.Map.Server.Impl do
     state
   end
 
+  def handle_event(:cleanup_characters, %{map_id: map_id, map: %{owner_id: owner_id}} = state) do
+    Process.send_after(self(), :cleanup_characters, @characters_cleanup_timeout)
+
+    {:ok, character_ids} =
+      WandererApp.Cache.lookup(
+        "map_#{map_id}:invalidate_character_ids",
+        []
+      )
+
+    character_ids
+    |> Task.async_stream(
+      fn character_id ->
+        character_id
+        |> WandererApp.Character.get_character()
+        |> case do
+          {:ok, character} ->
+            acls =
+              map_id
+              |> WandererApp.Map.get_map!()
+              |> Map.get(:acls, [])
+
+            [character_permissions] =
+              WandererApp.Permissions.check_characters_access([character], acls)
+
+            map_permissions =
+              WandererApp.Permissions.get_map_permissions(
+                character_permissions,
+                owner_id,
+                [character_id]
+              )
+
+            case map_permissions do
+              %{view_system: false} ->
+                {:remove_character, character_id}
+
+              %{track_character: false} ->
+                {:remove_character, character_id}
+
+              _ ->
+                :ok
+            end
+
+          _ ->
+            :ok
+        end
+      end,
+      timeout: :timer.seconds(60),
+      max_concurrency: System.schedulers_online(),
+      on_timeout: :kill_task
+    )
+    |> Enum.each(fn
+      {:ok, {:remove_character, character_id}} ->
+        state |> remove_and_untrack_characters([character_id])
+        :ok
+
+      {:ok, _result} ->
+        :ok
+
+      {:error, reason} ->
+        @logger.error("Error in cleanup_characters: #{inspect(reason)}")
+    end)
+
+    WandererApp.Cache.insert(
+      "map_#{map_id}:invalidate_character_ids",
+      []
+    )
+
+    state
+  end
+
   def handle_event(:cleanup_systems, %{map_id: map_id} = state) do
     Process.send_after(self(), :cleanup_systems, @systems_cleanup_timeout)
 
@@ -830,30 +972,50 @@ defmodule WandererApp.Map.Server.Impl do
   end
 
   def broadcast!(map_id, event, payload \\ nil) do
-    if _can_broadcast?(map_id) do
+    if can_broadcast?(map_id) do
       @pubsub_client.broadcast!(WandererApp.PubSub, map_id, %{event: event, payload: payload})
     end
 
     :ok
   end
 
-  defp get_connection_mark_eol_time(map_id, connection_id) do
+  defp remove_and_untrack_characters(%{map_id: map_id} = state, character_ids) do
+    map_id
+    |> _untrack_characters(character_ids)
+
+    case WandererApp.Api.MapCharacterSettings.tracked_by_map(%{
+           map_id: map_id,
+           character_ids: character_ids
+         }) do
+      {:ok, settings} ->
+        settings
+        |> Enum.map(fn s ->
+          s |> WandererApp.Api.MapCharacterSettings.untrack()
+          state |> remove_character(s.character_id)
+        end)
+
+      _ ->
+        :ok
+    end
+  end
+
+  defp get_connection_mark_eol_time(map_id, connection_id, default \\ DateTime.utc_now()) do
     WandererApp.Cache.get("map_#{map_id}:conn_#{connection_id}:mark_eol_time")
     |> case do
       nil ->
-        DateTime.utc_now()
+        default
 
       value ->
         value
     end
   end
 
-  defp _can_broadcast?(map_id),
+  defp can_broadcast?(map_id),
     do:
       not WandererApp.Cache.lookup!("map_#{map_id}:importing", false) and
         WandererApp.Cache.lookup!("map_#{map_id}:started", false)
 
-  defp _update_location(
+  defp update_location(
          character_id,
          location,
          old_location,
@@ -881,7 +1043,7 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _maybe_update_location(map_id, character_id) do
+  defp maybe_update_location(map_id, character_id) do
     WandererApp.Cache.lookup!(
       "character:#{character_id}:location_started",
       false
@@ -932,7 +1094,7 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _maybe_update_alliance(map_id, character_id) do
+  defp maybe_update_alliance(map_id, character_id) do
     with {:ok, old_alliance_id} <-
            WandererApp.Cache.lookup("map:#{map_id}:character:#{character_id}:alliance_id"),
          {:ok, %{alliance_id: alliance_id}} <-
@@ -956,7 +1118,7 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _maybe_update_corporation(map_id, character_id) do
+  defp maybe_update_corporation(map_id, character_id) do
     with {:ok, old_corporation_id} <-
            WandererApp.Cache.lookup("map:#{map_id}:character:#{character_id}:corporation_id"),
          {:ok, %{corporation_id: corporation_id}} <-
@@ -980,7 +1142,7 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _maybe_update_online(map_id, character_id) do
+  defp maybe_update_online(map_id, character_id) do
     with {:ok, old_online} <-
            WandererApp.Cache.lookup("map:#{map_id}:character:#{character_id}:online"),
          {:ok, %{online: online}} <-
@@ -1004,7 +1166,7 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _maybe_update_ship(map_id, character_id) do
+  defp maybe_update_ship(map_id, character_id) do
     with {:ok, old_ship_type_id} <-
            WandererApp.Cache.lookup("map:#{map_id}:character:#{character_id}:ship_type_id"),
          {:ok, old_ship_name} <-
@@ -1036,7 +1198,7 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _update_connection(
+  defp update_connection(
          %{map_id: map_id} = state,
          update_method,
          attributes,
@@ -1052,7 +1214,7 @@ defmodule WandererApp.Map.Server.Impl do
              solar_system_source_id,
              solar_system_target_id
            ),
-         {:ok, update_map} <- _get_update_map(update, attributes),
+         {:ok, update_map} <- get_update_map(update, attributes),
          :ok <-
            WandererApp.Map.update_connection(
              map_id,
@@ -1078,7 +1240,7 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _update_system(
+  defp update_system(
          %{map_id: map_id} = state,
          update_method,
          attributes,
@@ -1091,7 +1253,7 @@ defmodule WandererApp.Map.Server.Impl do
              map_id,
              update.solar_system_id
            ),
-         {:ok, update_map} <- _get_update_map(update, attributes) do
+         {:ok, update_map} <- get_update_map(update, attributes) do
       {:ok, updated_system} =
         apply(WandererApp.MapSystemRepo, update_method, [
           system,
@@ -1102,7 +1264,7 @@ defmodule WandererApp.Map.Server.Impl do
         callback_fn.(updated_system)
       end
 
-      _update_map_system_last_activity(map_id, updated_system)
+      update_map_system_last_activity(map_id, updated_system)
 
       state
     else
@@ -1112,7 +1274,7 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _get_update_map(update, attributes),
+  defp get_update_map(update, attributes),
     do:
       {:ok,
        Enum.reduce(attributes, Map.new(), fn attribute, map ->
@@ -1218,7 +1380,7 @@ defmodule WandererApp.Map.Server.Impl do
     state
   end
 
-  defp _save_map_state(%{map_id: map_id} = _state) do
+  defp save_map_state(%{map_id: map_id} = _state) do
     systems_last_activity =
       map_id
       |> WandererApp.Map.list_systems!()
@@ -1252,7 +1414,7 @@ defmodule WandererApp.Map.Server.Impl do
     })
   end
 
-  defp _maybe_stop_rtree(%{rtree_name: rtree_name} = state) do
+  defp maybe_stop_rtree(%{rtree_name: rtree_name} = state) do
     case Process.whereis(rtree_name) do
       nil ->
         :ok
@@ -1264,7 +1426,7 @@ defmodule WandererApp.Map.Server.Impl do
     state
   end
 
-  defp _init_map_cache(%__MODULE__{map_id: map_id} = state) do
+  defp init_map_cache(%__MODULE__{map_id: map_id} = state) do
     case WandererApp.Api.MapState.by_map_id(map_id) do
       {:ok,
        %{
@@ -1296,9 +1458,9 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _init_map(
+  defp init_map(
          state,
-         %{characters: characters} = initial_map,
+         %{id: map_id, characters: characters} = initial_map,
          subscription_settings,
          systems,
          connections
@@ -1319,12 +1481,19 @@ defmodule WandererApp.Map.Server.Impl do
         map_options |> Map.get("store_custom_labels", "false") |> String.to_existing_atom()
     ]
 
+    character_ids =
+      map_id
+      |> WandererApp.Map.get_map!()
+      |> Map.get(:characters, [])
+
+    WandererApp.Cache.insert("map_#{map_id}:invalidate_character_ids", character_ids)
+
     %{state | map: map, map_opts: map_opts}
   end
 
-  defp _init_map_systems(state, [] = _systems), do: state
+  defp init_map_systems(state, [] = _systems), do: state
 
-  defp _init_map_systems(%__MODULE__{map_id: map_id, rtree_name: rtree_name} = state, systems) do
+  defp init_map_systems(%__MODULE__{map_id: map_id, rtree_name: rtree_name} = state, systems) do
     systems
     |> Enum.each(fn %{id: system_id, solar_system_id: solar_system_id} = system ->
       @ddrt.insert(
@@ -1342,7 +1511,7 @@ defmodule WandererApp.Map.Server.Impl do
     state
   end
 
-  def _maybe_import_systems(state, %{"systems" => systems} = _settings, user_id, character_id) do
+  def maybe_import_systems(state, %{"systems" => systems} = _settings, user_id, character_id) do
     state =
       systems
       |> Enum.reduce(state, fn %{
@@ -1386,7 +1555,7 @@ defmodule WandererApp.Map.Server.Impl do
     |> delete_systems(removed_system_ids, user_id, character_id)
   end
 
-  def _maybe_import_connections(state, %{"connections" => connections} = _settings, _user_id) do
+  def maybe_import_connections(state, %{"connections" => connections} = _settings, _user_id) do
     connections
     |> Enum.reduce(state, fn %{
                                "source" => source,
@@ -1422,7 +1591,7 @@ defmodule WandererApp.Map.Server.Impl do
     end)
   end
 
-  def _maybe_import_hubs(state, %{"hubs" => hubs} = _settings, _user_id) do
+  def maybe_import_hubs(state, %{"hubs" => hubs} = _settings, _user_id) do
     hubs
     |> Enum.reduce(state, fn hub, acc ->
       solar_system_id = hub |> String.to_integer()
@@ -1432,7 +1601,7 @@ defmodule WandererApp.Map.Server.Impl do
     end)
   end
 
-  defp _update_map_system_last_activity(
+  defp update_map_system_last_activity(
          map_id,
          updated_system
        ) do
@@ -1526,7 +1695,7 @@ defmodule WandererApp.Map.Server.Impl do
     end
   end
 
-  defp _update_presence(map_id) do
+  defp update_presence(map_id) do
     case WandererApp.Cache.lookup!("map_#{map_id}:started", false) and
            WandererApp.Cache.get_and_remove!("map_#{map_id}:presence_updated", false) do
       true ->
@@ -1544,7 +1713,7 @@ defmodule WandererApp.Map.Server.Impl do
             not Enum.member?(presence_character_ids, character_id)
           end)
 
-        _track_characters(presence_character_ids, map_id)
+        track_characters(presence_character_ids, map_id)
 
         map_id
         |> _untrack_characters(not_present_character_ids)
@@ -1566,31 +1735,29 @@ defmodule WandererApp.Map.Server.Impl do
   defp track_acls([]), do: :ok
 
   defp track_acls([acl_id | rest]) do
-    _track_acl(acl_id)
+    track_acl(acl_id)
     track_acls(rest)
   end
 
-  defp _track_acl(acl_id),
+  defp track_acl(acl_id),
+    do: @pubsub_client.subscribe(WandererApp.PubSub, "acls:#{acl_id}")
+
+  defp track_characters([], _map_id), do: :ok
+
+  defp track_characters([character_id | rest], map_id) do
+    track_character(character_id, map_id)
+    track_characters(rest, map_id)
+  end
+
+  defp track_character(character_id, map_id),
     do:
-      WandererApp.PubSub
-      |> @pubsub_client.subscribe("acls:#{acl_id}")
-
-  defp _track_characters([], _map_id), do: :ok
-
-  defp _track_characters([character_id | rest], map_id) do
-    _track_character(character_id, map_id)
-    _track_characters(rest, map_id)
-  end
-
-  defp _track_character(character_id, map_id) do
-    WandererApp.Character.TrackerManager.update_track_settings(character_id, %{
-      map_id: map_id,
-      track: true,
-      track_online: true,
-      track_location: true,
-      track_ship: true
-    })
-  end
+      WandererApp.Character.TrackerManager.update_track_settings(character_id, %{
+        map_id: map_id,
+        track: true,
+        track_online: true,
+        track_location: true,
+        track_ship: true
+      })
 
   defp _update_character(map_id, character_id) do
     {:ok, character} = WandererApp.Character.get_character(character_id)
@@ -1773,13 +1940,14 @@ defmodule WandererApp.Map.Server.Impl do
        |> WandererApp.Map.find_system_by_location(old_location)
        |> WandererApp.Map.PositionCalculator.get_new_system_position(rtree_name, opts)}
 
-  defp _broadcast_acl_updates(
+  defp broadcast_acl_updates(
          {:ok,
           %{
             eve_character_ids: eve_character_ids,
             eve_corporation_ids: eve_corporation_ids,
             eve_alliance_ids: eve_alliance_ids
-          }}
+          }},
+         map_id
        ) do
     eve_character_ids
     |> Enum.uniq()
@@ -1811,12 +1979,19 @@ defmodule WandererApp.Map.Server.Impl do
       )
     end)
 
+    character_ids =
+      map_id
+      |> WandererApp.Map.get_map!()
+      |> Map.get(:characters, [])
+
+    WandererApp.Cache.insert("map_#{map_id}:invalidate_character_ids", character_ids)
+
     :ok
   end
 
-  defp _broadcast_acl_updates(_), do: :ok
+  defp broadcast_acl_updates(_, _map_id), do: :ok
 
-  defp _update_acl(acl_id) do
+  defp update_acl(acl_id) do
     {:ok, %{owner: owner, members: members}} =
       WandererApp.AccessListRepo.get(acl_id, [:owner, :members])
 

lib/wanderer_app/permissions.ex

@@ -87,4 +87,113 @@ defmodule WandererApp.Permissions do
       delete_map: check_permission(user_permissions, @delete_map)
     }
   end
+
+  def check_characters_access(characters, acls) do
+    character_ids = characters |> Enum.map(& &1.id)
+    character_eve_ids = characters |> Enum.map(& &1.eve_id)
+
+    character_corporation_ids =
+      characters |> Enum.map(& &1.corporation_id) |> Enum.map(&to_string/1)
+
+    character_alliance_ids = characters |> Enum.map(& &1.alliance_id) |> Enum.map(&to_string/1)
+
+    result =
+      acls
+      |> Enum.reduce([0, 0], fn acl, acc ->
+        is_owner? = acl.owner_id in character_ids
+
+        is_character_member? =
+          acl.members |> Enum.any?(fn member -> member.eve_character_id in character_eve_ids end)
+
+        is_corporation_member? =
+          acl.members
+          |> Enum.any?(fn member -> member.eve_corporation_id in character_corporation_ids end)
+
+        is_alliance_member? =
+          acl.members
+          |> Enum.any?(fn member -> member.eve_alliance_id in character_alliance_ids end)
+
+        if is_owner? || is_character_member? || is_corporation_member? || is_alliance_member? do
+          case acc do
+            [_, -1] ->
+              [-1, -1]
+
+            [-1, char_acc] ->
+              char_acl_mask =
+                acl.members
+                |> Enum.filter(fn member ->
+                  member.eve_character_id in character_eve_ids
+                end)
+                |> Enum.reduce(0, fn member, acc ->
+                  case acc do
+                    -1 -> -1
+                    _ -> calc_role_mask(member.role, acc)
+                  end
+                end)
+
+              char_acc =
+                case char_acl_mask do
+                  -1 -> -1
+                  _ -> char_acc ||| char_acl_mask
+                end
+
+              [-1, char_acc]
+
+            [any_acc, char_acc] ->
+              any_acl_mask =
+                acl.members
+                |> Enum.filter(fn member ->
+                  member.eve_character_id in character_eve_ids ||
+                    member.eve_corporation_id in character_corporation_ids ||
+                    member.eve_alliance_id in character_alliance_ids
+                end)
+                |> Enum.reduce(0, fn member, acc ->
+                  case acc do
+                    -1 -> -1
+                    _ -> calc_role_mask(member.role, acc)
+                  end
+                end)
+
+              char_acl_mask =
+                acl.members
+                |> Enum.filter(fn member ->
+                  member.eve_character_id in character_eve_ids
+                end)
+                |> Enum.reduce(0, fn member, acc ->
+                  case acc do
+                    -1 -> -1
+                    _ -> calc_role_mask(member.role, acc)
+                  end
+                end)
+
+              any_acc =
+                case any_acl_mask do
+                  -1 -> -1
+                  _ -> any_acc ||| any_acl_mask
+                end
+
+              char_acc =
+                case char_acl_mask do
+                  -1 -> -1
+                  _ -> char_acc ||| char_acl_mask
+                end
+
+              [any_acc, char_acc]
+          end
+        else
+          acc
+        end
+      end)
+
+    case result do
+      [_, -1] ->
+        [-1]
+
+      [-1, char_acc] ->
+        [char_acc]
+
+      [any_acc, _char_acc] ->
+        [any_acc]
+    end
+  end
 end

lib/wanderer_app_web/live/access_lists/access_lists_live.ex

@@ -1,4 +1,5 @@
 defmodule WandererAppWeb.AccessListsLive do
+  alias Pathex.Builder.Viewer
   use WandererAppWeb, :live_view
 
   require Logger
@@ -89,7 +90,10 @@ defmodule WandererAppWeb.AccessListsLive do
       |> assign(:page_title, "Access Lists - Members")
       |> assign(:selected_acl_id, acl_id)
       |> assign(:access_list, access_list)
-      |> assign(:members, members)
+      |> assign(
+        :members,
+        members
+      )
     else
       _ ->
         socket
@@ -145,7 +149,7 @@ defmodule WandererAppWeb.AccessListsLive do
           :send_after,
           [self(), {:search, text}, 100],
           "member_search_#{socket.assigns.selected_acl_id}",
-          500
+          250
         )
 
         [%{label: "Loading...", value: :loading, disabled: true}]
@@ -288,7 +292,11 @@ defmodule WandererAppWeb.AccessListsLive do
   end
 
   @impl true
-  def handle_event("dropped", %{"draggedId" => dragged_id, "dropzoneId" => dropzone_id}, socket) do
+  def handle_event(
+        "dropped",
+        %{"draggedId" => dragged_id, "dropzoneId" => dropzone_id},
+        %{assigns: %{access_list: access_list, members: members}} = socket
+      ) do
     role_atom =
       [:admin, :manager, :member, :viewer, :blocked]
       |> Enum.find(fn role_atom -> to_string(role_atom) == dropzone_id end)
@@ -299,13 +307,27 @@ defmodule WandererAppWeb.AccessListsLive do
 
       role_atom ->
         member =
-          socket.assigns.members
+          members
           |> Enum.find(&(&1.id == dragged_id))
 
-        {:noreply, socket |> maybe_update_role(member, role_atom, socket.assigns.access_list)}
+        {:noreply, socket |> maybe_update_role(member, role_atom, access_list)}
     end
   end
 
+  @impl true
+  def handle_info(
+        {"update_role", %{member_id: member_id, role: role}},
+        %{assigns: %{access_list: access_list, members: members}} = socket
+      ) do
+    role_atom = role |> String.to_existing_atom()
+
+    member =
+      members
+      |> Enum.find(&(&1.id == member_id))
+
+    {:noreply, socket |> maybe_update_role(member, role_atom, access_list)}
+  end
+
   @impl true
   def handle_event("noop", _, socket) do
     {:noreply, socket}
@@ -325,10 +347,33 @@ defmodule WandererAppWeb.AccessListsLive do
       |> Enum.map(& &1.id)
       |> Enum.at(0)
 
-    {:ok, options} = search(active_character_id, text)
+    uniq_search_req_id = UUID.uuid4(:default)
 
-    send_update(LiveSelect.Component, options: options, id: socket.assigns.member_search_id)
-    {:noreply, socket |> assign(member_search_options: options)}
+    Task.async(fn ->
+      {:ok, options} = search(active_character_id, text)
+
+      {:search_results, uniq_search_req_id, options}
+    end)
+
+    {:noreply, socket |> assign(uniq_search_req_id: uniq_search_req_id)}
+  end
+
+  def handle_info(
+        {ref, result},
+        %{assigns: %{member_search_id: member_search_id, uniq_search_req_id: uniq_search_req_id}} =
+          socket
+      )
+      when is_reference(ref) do
+    Process.demonitor(ref, [:flush])
+
+    case result do
+      {:search_results, ^uniq_search_req_id, options} ->
+        send_update(LiveSelect.Component, options: options, id: member_search_id)
+        {:noreply, socket |> assign(member_search_options: options)}
+
+      _ ->
+        {:noreply, socket}
+    end
   end
 
   @impl true
@@ -403,6 +448,7 @@ defmodule WandererAppWeb.AccessListsLive do
       _ ->
         socket
         |> put_flash(:error, "You're not allowed to assign this role")
+        |> push_navigate(to: ~p"/access-lists/#{socket.assigns.selected_acl_id}")
     end
   end
 
@@ -411,10 +457,11 @@ defmodule WandererAppWeb.AccessListsLive do
          _member,
          _role_atom,
          _access_list
-       ) do
-    socket
-    |> put_flash(:info, "Only Characters can have Admin or Manager roles")
-  end
+       ),
+       do:
+         socket
+         |> put_flash(:info, "Only Characters can have Admin or Manager roles")
+         |> push_navigate(to: ~p"/access-lists/#{socket.assigns.selected_acl_id}")
 
   defp characters_has_role?(character_eve_ids, access_list, role_atom) do
     access_list.members
@@ -614,27 +661,6 @@ defmodule WandererAppWeb.AccessListsLive do
     """
   end
 
-  def member_item(assigns) do
-    ~H"""
-    <div class="flex items-center gap-2">
-      <.icon :if={not is_nil(@member.role)} name={member_role_icon(@member.role)} class="w-6 h-6" />
-      <div class="avatar">
-        <div class="rounded-md w-8 h-8">
-          <img src={member_icon_url(@member)} alt={@member.name} />
-        </div>
-      </div>
-      <%= @member.name %>
-    </div>
-    """
-  end
-
-  def member_role_icon(:admin), do: "hero-user-group-solid"
-  def member_role_icon(:manager), do: "hero-academic-cap-solid"
-  def member_role_icon(:member), do: "hero-user-solid"
-  def member_role_icon(:viewer), do: "hero-eye-solid"
-  def member_role_icon(:blocked), do: "hero-no-symbol-solid text-red-500"
-  def member_role_icon(_), do: "hero-cake-solid"
-
   def search_member_icon_url(%{character: true} = option),
     do: member_icon_url(%{eve_character_id: option.value})
 

lib/wanderer_app_web/live/access_lists/access_lists_live.html.heex

@@ -82,14 +82,20 @@
           id="acl_members"
         >
           <div
-            :for={member <- @members |> Enum.sort(&(&1.name < &2.name))}
+            :for={member <- @members |> Enum.sort_by(&{&1.role, &1.name}, &<=/2)}
             draggable="true"
             id={member.id}
             class="draggable !p-1 h-10 cursor-move bg-black bg-opacity-25 hover:text-white"
             data-dropzone="pool"
           >
             <div class="flex justify-between relative">
-              <.member_item member={member} />
+              <.live_component
+                module={WandererAppWeb.AclMember}
+                id={"select_role_" <> member.id}
+                notify_to={self()}
+                member={member}
+                event_name="update_role"
+              />
               <button
                 :if={can_delete_member?(member, @access_list, @current_user)}
                 class="z-10 absolute top-0 right-2"
@@ -150,6 +156,71 @@
   show
   on_cancel={JS.patch(~p"/access-lists/#{@selected_acl_id}")}
 >
+  <%!-- <div class="mt-4 mb-2 p-tabmenu p-component " data-pc-section="tabmenu">
+    <ul
+      class="p-tabmenu-nav border-none h-[25px] w-full flex"
+      role="menubar"
+      data-pc-section="menu"
+    >
+      <li
+        id="pr_id_17_0"
+        class="p-tabmenuitem p-highlight"
+        role="presentation"
+        data-p-highlight="true"
+        data-p-disabled="false"
+        data-pc-section="menuitem"
+      >
+        <a
+          href="#"
+          role="menuitem"
+          aria-label="Router Link"
+          tabindex="0"
+          class="p-menuitem-link"
+          data-pc-section="action"
+        >
+          <span class="p-menuitem-text" data-pc-section="label">Character</span>
+        </a>
+      </li>
+      <li
+        id="pr_id_17_1"
+        class="p-tabmenuitem"
+        role="presentation"
+        data-p-highlight="false"
+        data-p-disabled="false"
+        data-pc-section="menuitem"
+      >
+        <a
+          href="#"
+          role="menuitem"
+          aria-label="Programmatic"
+          tabindex="-1"
+          class="p-menuitem-link"
+          data-pc-section="action"
+        >
+          <span class="p-menuitem-text" data-pc-section="label">Corporation</span>
+        </a>
+      </li>
+      <li
+        id="pr_id_17_2"
+        class="p-tabmenuitem"
+        role="presentation"
+        data-p-highlight="false"
+        data-p-disabled="false"
+        data-pc-section="menuitem"
+      >
+        <a
+          href="#"
+          role="menuitem"
+          aria-label="External"
+          tabindex="-1"
+          class="p-menuitem-link"
+          data-pc-section="action"
+        >
+          <span class="p-menuitem-text" data-pc-section="label">Alliance</span>
+        </a>
+      </li>
+    </ul>
+  </div> --%>
   <.form :let={f} for={@member_form} phx-submit={@live_action}>
     <.live_select
       field={f[:member_id]}

lib/wanderer_app_web/live/access_lists/components/acl_member.ex

@@ -0,0 +1,86 @@
+defmodule WandererAppWeb.AclMember do
+  use WandererAppWeb, :live_component
+
+  use LiveViewEvents
+
+  @roles [
+    :admin,
+    :manager,
+    :member,
+    :viewer,
+    :blocked
+  ]
+
+  @impl true
+  def mount(socket) do
+    {:ok, socket |> assign(roles: get_roles())}
+  end
+
+  @impl true
+  def update(
+        %{
+          member: member
+        } = assigns,
+        socket
+      ) do
+    socket = handle_info_or_assign(socket, assigns)
+
+    {:ok,
+     socket
+     |> assign(member: member, form: to_form(%{"role" => member.role}))}
+  end
+
+  @impl true
+  def render(assigns) do
+    ~H"""
+    <div id={@id} class="flex items-center gap-2">
+      <.icon :if={not is_nil(@member.role)} name={member_role_icon(@member.role)} class="w-6 h-6" />
+      <.form :let={f} id={"role_form_" <> @id} for={@form} phx-change="select" phx-target={@myself}>
+        <.input
+          type="select"
+          field={f[:role]}
+          class="select h-8 min-h-[0px] !pt-1 !pb-1 text-sm bg-neutral-900 w-[70px]"
+          placeholder="Select a role..."
+          options={Enum.map(@roles, fn role -> {role.label, role.value} end)}
+        />
+      </.form>
+      <div class="avatar">
+        <div class="rounded-md w-8 h-8">
+          <img src={member_icon_url(@member)} alt={@member.name} />
+        </div>
+      </div>
+      <%= @member.name %>
+    </div>
+    """
+  end
+
+  @impl true
+  def handle_event(
+        "select",
+        %{"role" => role} = _params,
+        %{assigns: %{event_name: event_name, member: member, notify_to: notify_to}} = socket
+      ) do
+    notify_to(notify_to, event_name, %{
+      member_id: member.id,
+      role: role
+    })
+
+    {:noreply, socket}
+  end
+
+  def member_role_icon(:admin), do: "hero-user-group-solid"
+  def member_role_icon(:manager), do: "hero-academic-cap-solid"
+  def member_role_icon(:member), do: "hero-user-solid"
+  def member_role_icon(:viewer), do: "hero-eye-solid"
+  def member_role_icon(:blocked), do: "hero-no-symbol-solid text-red-500"
+  def member_role_icon(_), do: "hero-cake-solid"
+
+  def member_role_title(:admin), do: "Admin"
+  def member_role_title(:manager), do: "Manager"
+  def member_role_title(:member), do: "Member"
+  def member_role_title(:viewer), do: "Viewer"
+  def member_role_title(:blocked), do: "-blocked-"
+  def member_role_title(_), do: "-"
+
+  defp get_roles(), do: @roles |> Enum.map(&%{label: member_role_title(&1), value: &1})
+end

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

@@ -162,6 +162,16 @@ defmodule WandererAppWeb.MapConnectionsEventHandler do
     {:noreply, socket}
   end
 
+  def handle_ui_event(
+        "get_connection_info",
+        %{"from" => from, "to" => to} = _event,
+        %{assigns: %{map_id: map_id}} = socket
+      ) do
+    {:ok, info} = map_id |> get_connection_info(from, to)
+
+    {:reply, info, socket}
+  end
+
   def handle_ui_event(
         "get_passages",
         %{"from" => from, "to" => to} = _event,
@@ -194,4 +204,19 @@ defmodule WandererAppWeb.MapConnectionsEventHandler do
 
     {:ok, %{passages: passages}}
   end
+
+  defp get_connection_info(map_id, from, to) do
+    map_id
+    |> WandererApp.Map.Server.get_connection_info(%{
+      solar_system_source_id: "#{from}" |> String.to_integer(),
+      solar_system_target_id: "#{to}" |> String.to_integer()
+    })
+    |> case do
+      {:ok, info} ->
+        {:ok, info}
+
+      _ ->
+        {:ok, %{}}
+    end
+  end
 end

lib/wanderer_app_web/live/maps/map_event_handler.ex

@@ -61,6 +61,7 @@ defmodule WandererAppWeb.MapEventHandler do
   @map_connection_ui_events [
     "manual_add_connection",
     "manual_delete_connection",
+    "get_connection_info",
     "get_passages",
     "update_connection_time_status",
     "update_connection_mass_status",
@@ -153,7 +154,7 @@ defmodule WandererAppWeb.MapEventHandler do
 
   def handle_ui_event(event, body, socket)
       when event in @map_characters_ui_events,
-      do: MapSystemsEventHandler.handle_ui_event(event, body, socket)
+      do: MapCharactersEventHandler.handle_ui_event(event, body, socket)
 
   def handle_ui_event(event, body, socket)
       when event in @map_system_ui_events,

mix.exs

@@ -2,7 +2,7 @@ defmodule WandererApp.MixProject do
   use Mix.Project
 
   @source_url "https://github.com/wanderer-industries/wanderer"
-  @version "1.13.12"
+  @version "1.15.1"
 
   def project do
     [

priv/repo/migrations/20240922090429_install_ash-functions_extension_4.exs

@@ -1,54 +0,0 @@
-defmodule WandererApp.Repo.Migrations.InstallAshFunctionsExtension420240922090427 do
-  @moduledoc """
-  Installs any extensions that are mentioned in the repo's `installed_extensions/0` callback
-
-  This file was autogenerated with `mix ash_postgres.generate_migrations`
-  """
-
-  use Ecto.Migration
-
-  def up do
-    execute("""
-    CREATE OR REPLACE FUNCTION uuid_generate_v7()
-    RETURNS UUID
-    AS $$
-    DECLARE
-      timestamp    TIMESTAMPTZ;
-      microseconds INT;
-    BEGIN
-      timestamp    = clock_timestamp();
-      microseconds = (cast(extract(microseconds FROM timestamp)::INT - (floor(extract(milliseconds FROM timestamp))::INT * 1000) AS DOUBLE PRECISION) * 4.096)::INT;
-
-      RETURN encode(
-        set_byte(
-          set_byte(
-            overlay(uuid_send(gen_random_uuid()) placing substring(int8send(floor(extract(epoch FROM timestamp) * 1000)::BIGINT) FROM 3) FROM 1 FOR 6
-          ),
-          6, (b'0111' || (microseconds >> 8)::bit(4))::bit(8)::int
-        ),
-        7, microseconds::bit(8)::int
-      ),
-      'hex')::UUID;
-    END
-    $$
-    LANGUAGE PLPGSQL
-    VOLATILE;
-    """)
-
-    execute("""
-    CREATE OR REPLACE FUNCTION timestamp_from_uuid_v7(_uuid uuid)
-    RETURNS TIMESTAMP WITHOUT TIME ZONE
-    AS $$
-      SELECT to_timestamp(('x0000' || substr(_uuid::TEXT, 1, 8) || substr(_uuid::TEXT, 10, 4))::BIT(64)::BIGINT::NUMERIC / 1000);
-    $$
-    LANGUAGE SQL
-    IMMUTABLE PARALLEL SAFE STRICT;
-    """)
-  end
-
-  def down do
-    # Uncomment this if you actually want to uninstall the extensions
-    # when this migration is rolled back:
-    execute("DROP FUNCTION IF EXISTS uuid_generate_v7(), timestamp_from_uuid_v7(uuid)")
-  end
-end