Enum.reduce refactor with multi

benonymus

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?

4 comments

#ecto_multi #reduce

0 2116 4

2019-05-20 08:38:30 UTC

Showing Posts 1 to 4

Show Best Posts
Show All (oldest first)
Show All (newest first)

LostKobrakai

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)

Post #1

benonymus

yeah, this might work as well

Post #2

benonymus

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

Post #3

LostKobrakai

  %{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)

Post #4

— All posts loaded —