scroll happend error

album.ex

defmodule MyappWeb.AlbumController do
  use MyappWeb, :controller
  use Filterable.Phoenix.Controller
  import ShorterMaps
  alias Myapp.Accounts
  alias Myapp.Accounts.Album

  action_fallback(MyappWeb.FallbackController)
  filterable(Myapp.AlbumFilters)

  def index(conn, _params) do
    user = Guardian.Plug.current_resource(conn)

    with {:ok, query, filter_values} <- apply_filters(Album, conn),
         albums <- Accounts.list_albums(query) do
      album_iszan =
        albums
        |> Enum.map(fn %{album: album} ->
          Map.get(album, :id)
        end)
        |> Accounts.album_iszan(user.id)

      albums =
        albums
        |> Myapp.EctoHelper.strip_meta()
        |> Enum.map(fn %{album: album, comment_count: comment_count, like_count: like_count} ->
          album
          |> Map.merge(%{
            comment_count: comment_count,
            like_count: like_count,
            is_zan: album.id in album_iszan
          })
        end)

      json(conn, %{message: "ok", albums: albums, code: 1} |> Map.merge(filter_values))
    end
  end

  def create(conn, %{"images"=>images,"desc"=>desc} = params) do
    now = Timex.now(:local) |> DateTime.to_naive()
    user = Guardian.Plug.current_resource(conn)

    params =
      params
      |> Map.merge(%{
        "create_time" => now,
        "user_id" => user.id,
        "images" =>
          images
          |> Enum.filter(fn x -> x != "" end)
          |> Enum.join("||")
      })

    with :ok <- Myapp.Image.check_txt!(desc),
         {:ok, _} <- Accounts.create_album(params) do
      Myapp.Goods.set_images_used(user, images)

      user
      |> Ecto.Changeset.change(score: user.score + 20)
      |> Repo.update()

      json(conn, %{message: "ok", code: 1})
    else
      :error ->
        json(conn, %{message: "error message", code: 10_002})

      _ ->
        json(conn, %{message: "error message", code: 10_002})
    end
  end

  def show(conn, %{"id" => id}) do
    user = Guardian.Plug.current_resource(conn)

    case Accounts.get_album(id, user.id) do
      nil ->
        json(conn, %{message: "album not exist", code: 10_002})

      album ->
        album = Myapp.EctoHelper.strip_meta(album)
        json(conn, Map.merge(album, %{message: "ok", code: 1}))
    end
  end

  def update(conn, %{"id"=>id,"desc"=>desc,"images"=>images} = params) do
    user = Guardian.Plug.current_resource(conn)
    album = Myapp.Repo.get!(Album, id)

    if album.user_id != user.id do
      json(conn, %{message: "not can", code: 10_002})
    else
      old_images = album.images |> String.split("||") |> MapSet.new()
      new_images = MapSet.new(images)

      params =
        params
        |> Map.delete("id")
        |> Map.put("images", Enum.join(images, "||"))

      with :ok <- Myapp.Image.check_txt!(desc),
           {:ok, %Album{} = album} <- Myapp.Accounts.update_album(album, params) do
        Myapp.Goods.set_images_used(user, images)

        old_images
        |> MapSet.difference(new_images)
        |> Enum.each(fn img ->
          Myapp.Image.delete(img)
          image = Myapp.Goods.get_image(user, img)
          Myapp.Goods.delete_image(image)
        end)

        album = Myapp.EctoHelper.strip_meta(album)
        json(conn, %{message: "ok", album: album, code: 1})
      else
        :error ->
          json(conn, %{message: "error message", code: 10_002})

        _ ->
          json(conn, %{message: "update fail", code: 10_002})
      end
    end
  end

  def like(conn, %{"id" => id}) do
    user = Guardian.Plug.current_resource(conn)
    id = String.to_integer(id)
    Accounts.like_album(user.id, id)
    json(conn, %{message: "ok", code: 1})
  end

  #
  # def delete(conn, %{"id" => id}) do
  #   album = Accounts.get_album!(id)
  #   with {:ok, %Album{}} <- Accounts.delete_album(album) do
  #     send_resp(conn, :no_content, "")
  #   end
  # end
end