Fix copy version: add missing assocs and assign skill to characters

apps/configurator/lib/configurator_web/controllers/home_html/home.html.heex

@@ -3,8 +3,8 @@
     Welcome to Champions of Mirra Configurator
   </.header>
 
-  <.link href={~p"/versions/new"}>
-    <.button>New Version</.button>
+  <.link href={~p"/versions/copy"}>
+    <.button>Copy Version</.button>
   </.link>
   <.link href={~p"/versions/show_current_version"}>
     <.button>See Current Version</.button>

apps/configurator/lib/configurator_web/controllers/version_controller.ex

@@ -1,29 +1,48 @@
 defmodule ConfiguratorWeb.VersionController do
   use ConfiguratorWeb, :controller
 
+  require Logger
   alias GameBackend.Configuration
-  alias GameBackend.Configuration.Version
-  alias Configurator.Utils
 
   def index(conn, _params) do
     versions = Configuration.list_versions()
     render(conn, :index, versions: versions)
   end
 
-  def new(conn, _params) do
-    last_version = GameBackend.Configuration.get_current_version()
-    skills = Utils.list_curse_skills_by_version_grouped_by_type(last_version.id)
+  def copy(conn, _params) do
+    versions = Configuration.list_versions()
+    render(conn, :copy, versions: versions)
+  end
+
+  def create_copy(conn, params) do
+    selected_version = Configuration.get_preloaded_version!(params["version_id"])
 
     params =
-      Map.from_struct(last_version)
-      |> Map.put(:characters, schema_to_map(last_version.characters))
-      |> Map.put(:consumable_items, schema_to_map(last_version.consumable_items))
-      |> Map.put(:game_configuration, schema_to_map(last_version.game_configuration))
-      |> Map.put(:map_configurations, schema_to_map(last_version.map_configurations))
-      |> Map.put(:skills, schema_to_map(last_version.skills))
-
-    changeset = Configuration.change_version(%Version{}, params)
-    render(conn, :new, changeset: changeset, last_version: last_version, skills: skills)
+      Map.from_struct(selected_version)
+      |> Map.put(:characters, schema_to_map(selected_version.characters))
+      |> Map.put(:consumable_items, schema_to_map(selected_version.consumable_items))
+      |> Map.put(:game_configuration, schema_to_map(selected_version.game_configuration))
+      |> Map.put(:map_configurations, schema_to_map(selected_version.map_configurations))
+      |> Map.put(:skills, schema_to_map(selected_version.skills))
+      |> Map.put(:name, params["name"])
+      |> Map.put(:current, false)
+
+    case Configuration.copy_version(params) do
+      {:ok, %{version: version}} ->
+        conn
+        |> put_flash(:info, "Version created successfully.")
+        |> redirect(to: ~p"/versions/#{version}")
+
+      {:error, :version, %Ecto.Changeset{} = changeset, _changes_so_far} ->
+        Logger.info("Insertion failed. Changeset: #{changeset}")
+        versions = Configuration.list_versions()
+        render(conn, :index, versions: versions)
+
+      {:error, :link_character_skills, %Ecto.Changeset{} = changeset, _changes_so_far} ->
+        Logger.info("Link character skills failed. Changeset: #{changeset}")
+        versions = Configuration.list_versions()
+        render(conn, :index, versions: versions)
+    end
   end
 
   # TODO: We have a cycle in our Skill.Mechanic assocs so this is to end that loop.
@@ -42,6 +61,16 @@ defmodule ConfiguratorWeb.VersionController do
 
   def schema_to_map(%_struct{} = schema) do
     schema
+    |> Map.reject(fn {k, _v} ->
+      k in [
+        :on_arrival_mechanic_id,
+        :parent_mechanic_id,
+        :version_id,
+        :dash_skill_id,
+        :ultimate_skill_id,
+        :basic_skill_id
+      ]
+    end)
     |> Map.from_struct()
     |> Enum.map(fn {key, value} -> {key, schema_to_map(value)} end)
     |> Enum.into(%{})
@@ -59,36 +88,6 @@ defmodule ConfiguratorWeb.VersionController do
 
   def schema_to_map(value), do: value
 
-  def create(conn, %{"version" => version_params}) do
-    version_params =
-      case Map.get(version_params, "map_configurations") do
-        nil ->
-          version_params
-
-        map_configurations ->
-          Map.put(
-            version_params,
-            "map_configurations",
-            Map.new(map_configurations, fn {key, map_params} ->
-              {key, Utils.parse_json_params(map_params)}
-            end)
-          )
-      end
-
-    case Configuration.create_version(version_params) do
-      {:ok, version} ->
-        conn
-        |> put_flash(:info, "Version created successfully.")
-        |> redirect(to: ~p"/versions/#{version}")
-
-      {:error, %Ecto.Changeset{} = changeset} ->
-        last_version = GameBackend.Configuration.get_current_version()
-        skills = Utils.list_curse_skills_by_version_grouped_by_type(last_version.id)
-
-        render(conn, :new, changeset: changeset, last_version: last_version, skills: skills)
-    end
-  end
-
   def show(conn, %{"id" => id}) do
     version = Configuration.get_version!(id)
     render(conn, :show, version: version)

apps/configurator/lib/configurator_web/controllers/version_html/copy.html.heex

@@ -0,0 +1,22 @@
+<.simple_form :let={f} for={%{}} action="/versions/create_copy">
+  <.header>
+    Copy version
+    <:subtitle>Use this form to create a new version record in your database.</:subtitle>
+  </.header>
+
+  <.input
+    field={f[:version_id]}
+    type="select"
+    options={Enum.map(@versions, fn version -> {version.name, version.id} end)}
+    label="Version to copy from"
+    value={Enum.find(@versions, %{}, fn version -> version.current end) |> Map.get(:id)}
+  />
+
+  <.input field={f[:name]} type="text" label="New copy version name" />
+
+  <:actions>
+    <.button>Create new copy version</.button>
+  </:actions>
+</.simple_form>
+
+<.back navigate={~p"/versions"}>Back to versions</.back>

apps/configurator/lib/configurator_web/controllers/version_html/index.html.heex

@@ -1,8 +1,8 @@
 <.header>
   Listing Versions
   <:actions>
-    <.link href={~p"/versions/new"}>
-      <.button>New Version</.button>
+    <.link href={~p"/versions/copy_current_version"} data-confirm="You're about to create a new Version. Proceed?">
+      <.button>Copy Current Version</.button>
     </.link>
   </:actions>
 </.header>

apps/configurator/lib/configurator_web/router.ex

@@ -57,7 +57,9 @@ defmodule ConfiguratorWeb.Router do
 
     scope "/versions" do
       get "/show_current_version", VersionController, :show_current_version
-      resources "/", VersionController
+      get "/copy", VersionController, :copy
+      post "/create_copy", VersionController, :create_copy
+      resources "/", VersionController, except: [:new]
       put "/:id/current", VersionController, :mark_as_current
 
       scope "/:version_id" do

apps/configurator/test/configurator_web/controllers/version_controller_test.exs

@@ -17,15 +17,8 @@
     end
   end
 
-  describe "new version" do
-    test "renders form", %{conn: conn} do
-      conn = get(conn, ~p"/versions/new")
-      assert html_response(conn, 200) =~ "New Version"
-    end
-  end
-
   describe "create version" do
     test "redirects to show when data is valid", %{conn: conn} do
       conn = post(conn, ~p"/versions", version: @create_attrs)
 
       assert %{id: id} = redirected_params(conn)
@@ -35,7 +28,7 @@
       assert html_response(conn, 200) =~ "Version #{id}"
     end
 
     test "renders errors when data is invalid", %{conn: conn} do
       conn = post(conn, ~p"/versions", version: @invalid_attrs)
       assert html_response(conn, 200) =~ "New Version"
     end

apps/game_backend/lib/game_backend/configuration.ex

@@ -407,6 +407,33 @@ defmodule GameBackend.Configuration do
   """
   def get_version!(id), do: Repo.get!(Version, id)
 
+  def get_preloaded_version!(id) do
+    consumable_items_preload =
+      from(ci in GameBackend.Items.ConsumableItem,
+        preload: [
+          mechanics: [:on_arrival_mechanic, :on_explode_mechanics, :parent_mechanic]
+        ]
+      )
+
+    q =
+      from(v in Version,
+        where: v.id == ^id,
+        preload: [
+          [consumable_items: ^consumable_items_preload],
+          [skills: [mechanics: [:on_arrival_mechanic, :on_explode_mechanics]]],
+          :map_configurations,
+          :game_configuration,
+          characters: [
+            [basic_skill: [mechanics: [:on_arrival_mechanic, :on_explode_mechanics, :parent_mechanic]]],
+            [ultimate_skill: [mechanics: [:on_arrival_mechanic, :on_explode_mechanics, :parent_mechanic]]],
+            [dash_skill: [mechanics: [:on_arrival_mechanic, :on_explode_mechanics, :parent_mechanic]]]
+          ]
+        ]
+      )
+
+    Repo.one!(q)
+  end
+
   @doc """
   Creates a version.
 
@@ -425,6 +452,41 @@ defmodule GameBackend.Configuration do
     |> Repo.insert()
   end
 
+  def copy_version(attrs \\ %{}) do
+    Multi.new()
+    |> Multi.insert(
+      :version,
+      %Version{}
+      |> Version.changeset(attrs)
+    )
+    |> Multi.run(:link_character_skills, fn repo, changes ->
+      characters = changes.version.characters
+      skills = changes.version.skills
+
+      characters
+      |> Enum.each(fn character ->
+        character
+        |> Character.changeset(%{})
+        |> Ecto.Changeset.put_change(
+          :basic_skill_id,
+          Enum.find(skills, fn skill -> skill.name == character.basic_skill.name end).id
+        )
+        |> Ecto.Changeset.put_change(
+          :dash_skill_id,
+          Enum.find(skills, fn skill -> skill.name == character.dash_skill.name end).id
+        )
+        |> Ecto.Changeset.put_change(
+          :ultimate_skill_id,
+          Enum.find(skills, fn skill -> skill.name == character.ultimate_skill.name end).id
+        )
+        |> repo.update!()
+      end)
+
+      {:ok, :ok}
+    end)
+    |> Repo.transaction()
+  end
+
   @doc """
   Updates a arena_server.
 

apps/game_backend/lib/game_backend/units/characters/character.ex

@@ -104,8 +104,9 @@ defmodule GameBackend.Units.Characters.Character do
       :ultimate_skill_id,
       :version_id
     ])
-    |> cast_assoc(:basic_skill)
-    |> cast_assoc(:ultimate_skill)
+    |> cast_assoc(:basic_skill, with: &Skill.assoc_changeset/2)
+    |> cast_assoc(:dash_skill, with: &Skill.assoc_changeset/2)
+    |> cast_assoc(:ultimate_skill, with: &Skill.assoc_changeset/2)
     |> unique_constraint([:game_id, :name, :version_id])
     |> validate_required([:game_id, :name, :active, :faction])
     |> mana_recovery_strategy_validation()