Enum.reduce refactor with multi

Hey there,

I have this function:

  defp add_same_price(order, ids) do
    filtered_order_book = get_incomplete_orders(ids, order.command)

    same_price_orders =
      filtered_order_book
      |> Enum.filter(fn x -> Decimal.cmp(x.price, order.price) == :eq and x.id != order.id end)

    summed_order =
      Enum.reduce(same_price_orders, order, fn x, acc ->
        amount_sum = Decimal.add(x.amount, acc.amount)

        LimitOrder.changeset_update_amount_completed(x, %{completed: true, amount: x.amount})
        |> Repo.update()

        Map.put(acc, :amount, amount_sum)
      end)

    LimitOrder.changeset_update_amount_completed(order, %{
      completed: summed_order.completed,
      amount: summed_order.amount
    })
    |> Repo.update()
  end

This works well, but I think that doing the transaction inside the reduce is not great, because this way if the last transaction fails the previous ones wont be rolled back.
How can I refactor this using multi?
Usually when I use multi that is my acc, but i need the result of this reduce function as well.
I think that if i would just have the multi as my acc here too, i’d need to update the order, that happens as the last thing currently, inside the reduce as well, and then get(how?) it from the multi. Is this in the good direction? Thoughts?

If you need results of previous steps consider Ecto.Multi.run and Ecto.Multi.merge. Those should give you options to do what you need to do.

Edit: Maybe I’ve misunderstood the question a bit. Your reduce function can hold any value, so it can hold a multi struct and the summed amouns:

Enum.reduce(orders, %{order: order, multi: multi}, fn x, %{order: order, multi: multi} -> 
  # To stuff
  %{order: order, multi: multi}
end)
5 Likes

yeah, this might work as well

I ended up with this:

  defp add_same_price(order, ids) do
    filtered_order_book = get_incomplete_orders(ids, order.command)

    same_price_orders =
      filtered_order_book
      |> Enum.filter(fn x -> Decimal.cmp(x.price, order.price) == :eq and x.id != order.id end)

    %{order: summed_order, multi: multi} =
      Enum.reduce(same_price_orders, %{order: order, multi: Multi.new()}, fn x,
                                                                             %{
                                                                               order: order,
                                                                               multi: multi
                                                                             } ->
        amount_sum = Decimal.add(x.amount, order.amount)

        multi =
          multi
          |> Multi.update(
            x.id,
            LimitOrder.changeset_update_amount_completed(x, %{completed: true, amount: x.amount})
          )

        order = Map.put(order, :amount, amount_sum)
        %{order: order, multi: multi}
      end)

    multi
    |> Multi.update(
      summed_order.id,
      LimitOrder.changeset_update_amount_completed(order, %{
        completed: summed_order.completed,
        amount: summed_order.amount
      })
    )
    |> Repo.transaction()
  end

for some reason the formatting is on the ugly side

  %{order: summed_order, multi: multi} =
    Enum.reduce(same_price_orders, %{order: order, multi: Multi.new()}, fn x, acc ->
      amount_sum = Decimal.add(x.amount, acc.order.amount)

      changeset =
        LimitOrder.changeset_update_amount_completed(x, %{
          completed: true,
          amount: x.amount
        })

      %{
        order: Map.put(acc.order, :amount, amount_sum),
        multi: Multi.update(acc.multi, x.id, changeset)
      }
    end)
1 Like