network_updater.ex

defmodule Elevate.Networking.NetworkUpdater do
  alias Elevate.Networking.NetworkConnection, as: Connection
  alias Elevate.Networking.SubnetBuilder

  def disable_access(
        user_id: user_id,
        network_id: network_id,
        vlan_only_id: vlan_only_id,
        site_id: site_id
      ) do
    do_disable_access(%Connection{
      user_id: user_id,
      network_id: network_id,
      vlan_only_id: vlan_only_id,
      site_id: site_id
    })
  end

  def update_access(
        network_type: network_type,
        user_id: user_id,
        network_id: network_id,
        vlan_only_id: vlan_only_id,
        shared_vlan: shared_vlan,
        site_id: site_id,
        primary_site_id: primary_site_id,
        suite_number: suite_number,
        suite_name: suite_name,
        suite_label: suite_label,
        subnet: subnet
      ) do
    do_update_access(%Connection{
      network_type: network_type,
      network_id: network_id,
      vlan_only_id: vlan_only_id,
      network_vlan: nil,
      user_id: user_id,
      user_vlan: nil,
      shared_vlan: shared_vlan,
      site_id: site_id,
      primary_site_id: primary_site_id,
      suite_number: suite_number,
      suite_name: suite_name,
      suite_label: suite_label,
      subnet: subnet,
      on_primary_site: site_id == primary_site_id
    })
  end

  defp do_update_access(%{network_type: "shared"} = connection) do
    enable_shared_network(connection)
  end

  defp do_update_access(%{network_type: "dedicated"} = connection) do
    enable_dedicated_network(connection)
  end

  defp do_update_access(%{network_type: nil} = connection) do
    {:ok, connection}
  end

  defp do_disable_access(%{user_id: nil, network_id: nil} = connection) do
    {:ok, connection}
  end

  defp do_disable_access(%{network_id: nil, vlan_only_id: nil} = connection) do
    case delete_radius_user(connection) do
      {:ok, {:user_deleted, connection}} -> {:ok, connection}
      error -> error
    end
  end

  defp do_disable_access(%{vlan_only_id: nil}) do
    with {:ok, {:user_deleted, connection}} <- delete_radius_user(connection),
         {:ok, {:network_deleted, connection}} <- delete_network(connection) do
      {:ok, connection}
    else
      error -> error
    end
  end

  defp do_disable_access(connection) do
    with {:ok, {:user_deleted, connection}} <- delete_radius_user(connection),
         {:ok, {:vlan_only_deleted, connection}} <- delete_vlan_only(connection),
         {:ok, {:network_deleted, connection}} <- delete_network(connection) do
      {:ok, connection}
    else
      error -> error
    end
  end

  defp enable_shared_network(%{user_id: nil, network_id: nil} = connection) do
    case create_radius_user(connection) do
      {:ok, {:user_created, connection}} ->
        {:ok, connection}

      error ->
        error
    end
  end

  defp enable_shared_network(%{network_id: nil} = connection) do
    {:ok, connection}
  end

  defp enable_shared_network(%{vlan_only_id: nil}) do
    with {:ok, {:network_deleted, connection}} <- delete_network(connection),
         {:ok, {:user_updated, connection}} <- update_radius_user(connection) do
      {:ok, connection}
    else
      error -> error
    end
  end

  defp enable_shared_network(connection) do
    with {:ok, {:network_deleted, connection}} <- delete_network(connection),
         {:ok, {:vlan_only_deleted, connection}} <- delete_vlan_only(connection),
         {:ok, {:user_updated, connection}} <- update_radius_user(connection) do
      {:ok, connection}
    else
      error -> error
    end
  end

  defp enable_dedicated_network(
         %{user_id: nil, network_id: nil, on_primary_site: false} = connection
       ) do
    with {:ok, {:network_created, connection}} <- create_network(connection),
         {:ok, {:vlan_only_created, connection}} <- create_vlan_only(connection),
         {:ok, {:user_created, connection}} <- create_radius_user(connection) do
      {:ok, connection}
    else
      error -> error
    end
  end

  defp enable_dedicated_network(%{user_id: nil, network_id: nil} = connection) do
    with {:ok, {:network_created, connection}} <- create_network(connection),
         {:ok, {:user_created, connection}} <- create_radius_user(connection) do
      {:ok, connection}
    else
      error -> error
    end
  end

  defp enable_dedicated_network(%{network_id: nil, on_primary_site: false} = connection) do
    with {:ok, {:network_created, connection}} <- create_network(connection),
         {:ok, {:vlan_only_created, connection}} <- create_vlan_only(connection),
         {:ok, {:user_updated, connection}} <- update_radius_user(connection) do
      {:ok, connection}
    else
      error -> error
    end
  end

  defp enable_dedicated_network(%{network_id: nil} = connection) do
    with {:ok, {:network_created, connection}} <- create_network(connection),
         {:ok, {:user_updated, connection}} <- update_radius_user(connection) do
      {:ok, connection}
    else
      error -> error
    end
  end

  defp enable_dedicated_network(connection) do
    {:ok, connection}
  end

  defp create_radius_user(connection) do
    case Unifi.API.create_radius_user(
           connection.site_id,
           connection.suite_label,
           connection.network_vlan || connection.shared_vlan,
           Utilities.Randomizer.randomize(12)
         ) do
      {:ok, data} ->
        connection =
          struct(connection, %{
            user_id: data["_id"],
            user_vlan: data["vlan"]
          })

        {:ok, {:user_created, connection}}

      _ ->
        {:error, "Could not create RADIUS User"}
    end
  end

  defp create_network(connection) do
    case Unifi.API.create_network(
           connection.site_id,
           connection.suite_name,
           connection.suite_number,
           SubnetBuilder.dhcpd_ip_1(connection.subnet),
           SubnetBuilder.dhcpd_start(connection.subnet),
           SubnetBuilder.dhcpd_stop(connection.subnet),
           SubnetBuilder.ip_subnet(connection.subnet, 27)
         ) do
      {:ok, data} ->
        connection =
          struct(connection, %{
            network_id: data["_id"],
            network_vlan: data["vlan"]
          })

        {:ok, {:network_created, connection}}

      _ ->
        {:error, "Could not create Dedicated Network"}
    end
  end

  defp create_vlan_only(connection) do
    case Unifi.API.create_vlan_only(
           connection.site_id,
           connection.suite_name,
           connection.suite_number
         ) do
      {:ok, data} ->
        connection =
          struct(connection, %{
            vlan_only_id: data["_id"]
          })

        {:ok, {:vlan_only_created, connection}}

      _ ->
        {:error, "Could not create VLAN-only Network"}
    end
  end

  defp update_radius_user(connection) do
    case Unifi.API.update_radius_user(
           connection.site_id,
           connection.user_id,
           vlan: connection.network_vlan || connection.shared_vlan
         ) do
      {:ok, data} ->
        connection = Map.put(connection, :user_vlan, data["vlan"])
        {:ok, {:user_updated, connection}}

      _ ->
        {:error, "Could not update RADIUS User"}
    end
  end

  defp delete_radius_user(connection) do
    case Unifi.API.delete_radius_user(connection.site_id, connection.user_id) do
      :ok ->
        connection = Map.put(connection, :user_id, nil)
        {:ok, {:user_deleted, connection}}

      _ ->
        {:error, "Could not delete RADIUS User"}
    end
  end

  defp delete_network(connection) do
    case Unifi.API.delete_network(connection.site_id, connection.network_id) do
      :ok ->
        connection =
          struct(connection, %{
            network_id: nil,
            network_vlan: nil
          })

        {:ok, {:network_deleted, connection}}

      _ ->
        {:error, "Could not delete Dedicated Network"}
    end
  end

  defp delete_vlan_only(connection) do
    case Unifi.API.delete_network(connection.site_id, connection.vlan_only_id) do
      :ok ->
        connection =
          struct(connection, %{
            vlan_only_id: nil
          })

        {:ok, {:vlan_only_deleted, connection}}

      _ ->
        {:error, "Could not delete VLAN-only network"}
    end
  end
end