Insert or update with separated results

Phoenix Forum Questions / Help
, ,
1

I have an API that allows users to update and insert items with a single request. It works by supplying a list of JSON objects to an endpoint that will update items where the primary key exists, and insert new items where the primary key doesn’t exist. I have this working with:

def create_machines(attrs) do
    x =
      attrs
      |> Enum.map(fn x -> get_changeset(x) end)
      |> Enum.map(fn x -> Repo.insert_or_update(x) end)
  end

  defp get_changeset(params) do
    case Repo.get_by(Machine, name: params["name"]) do
      nil ->
        # Insert a new machine
        Machine.changeset(%Machine{}, params)

      machine ->
        # Update the machine data
        Machine.changeset(machine, params)
    end
  end

I get back a list of {ok: Machine} items. What I would like to have though is a list of updated machines and a list of new machines so that the returned JSON is something like

{
  "new": 
    [
      {"name": "machine1", ...}, {...}
    ], 
  "updated": 
    [
      {"name": "machine2", ....}, .{...} 
    ] 
}

I’m just not sure how best to approach generating this result properly. I’ve tried inserting or updating the changeset in the get_changeset function so that I can return something like {:update, machine} and {:create, machine} but then I got stuck with trying to convert

[{:update, machine1}, {:update, machine2}, {:created, machine3}]

Into the format above for display.
Any advice on what the best approach is for this? thanks

2

Enum.group_by will get you close to what you want:

iex(4)> [{:updated, "foo"}, {:updated, "bar"}, {:created, "baz"}, {:updated, "wat"}] |> Enum.group_by(fn {x, _} -> x end)
%{
  created: [created: "baz"],
  updated: [updated: "foo", updated: "bar", updated: "wat"]
}

This would still require some postprocessing of the individual lists to remove the {:created, _} wrappers around the internal elements.

Alternatively, you could use Enum.reduce with an initial state of %{new: [], updated: []} and compute what you want directly.

1 Like
3

Thank you for your reply. I ended up going with the reduce as it seemed simpler

attrs
    |> Enum.reduce(%{new: [], updated: []}, fn x, acc ->
      case Repo.get_by(Machine, name: x["name"]) do
        nil ->
          # Insert a new machine
          {:ok, machine} = Repo.insert(Machine.changeset(%Machine{}, x))
          new_list = acc.new ++ [machine]
          %{new: new_list, updated: acc.updated}

        machine ->
          # Update the machine data
          {:ok, machine} = Repo.update(Machine.changeset(machine, x))
          updated_list = acc.updated ++ [machine]
          %{new: acc.new, updated: updated_list}
      end
    end)