Implementing Drag-and-Drop Ordering with Scriptcase: A Step-by-Step Guide

Introduction

---------

In this article, we will walk you through implementing a drag-and-drop ordering feature using Scriptcase in your Phoenix application. This feature allows users to reorder items on a page simply by dragging and dropping them into their desired position.

Prerequisites

------------

Before starting this tutorial, make sure you have the following prerequisites:

* You have already set up a new Phoenix project.

* Tailwind CSS is installed and configured in your project (see SPIKE: Drag-and-drop reordering of items in a list #4 for more information).

* Alpine.js has been added to your project.

Step 1: Create an Items Schema

------------------------------

First, we need to create a basic schema for our items. This will include only the necessary fields without any extra data or people. Here's how you can do it:

```elixir

defmodule App.Items.Schema.Item do

use Ecto.Schema

@primary_key {:id, :integer, ':auto_increment'}

# Add other fields here as needed

end

```

Step 2: Create a LiveView Page for Experimentation

----------------------------------------------

Next, we need to create a new Phoenix App called 'app' in our current project. This will serve as the base for our experimentation.

```bash

mix phoenix.new app --template minimal-static-elixir

cd app

# Add Tailwind and Alpine dependencies

yarn add @tailwindcss/essential-webpack5 postcss-import autoprefixer tailwindcss \

alpinejs moment-timezone moment-range moment-timezone-data-js

# Install LiveView if not already done

mix hex deps get --force live-view-rails/live_view_ruby_gem_support \

live_view_reloaded/livereload_javascript

# Start Phoenix server for development

elixir -i lib/app_web/endpoint.ex -r app_web/channels/push_notification_socket -p 4000 &

cd ..

```

Step 3: Implement the Drag-and-Drop Feature

---------------------------------------

Now that we have our basic setup in place, let's dive into implementing the actual drag-and-drop feature.

### A. Create a Phoenix App for Testing

Create a new Phoenix app called 'app' within your current project:

```bash

mix phoenix.new app --template minimal-static-elixir

cd app

```

### B. Add Dependencies and Setup Tailwind and Alpine

Add necessary dependencies to the `Gemfile`:

```ruby

# In Gemfile:

gem 'tailwindcss-rails', '~> 2.3'

```

Run Bundler to install these gems:

```bash

bundle install --without production test development integration acceptance ci

```

### C. Create a LiveView Component

Create a new directory called `lib/app_web/components` and inside it, create another directory named 'items':

```bash

mkdir -p lib/app_web/templates/lib/app_web/views/live_items_index.html.eex

touch app/javascripts/app.js

mix assets compile --watch=true

```

### D. Implement Drag-and-Drop Functionality

In `lib/app/web/templates/live_items/index.html.slim`, add the following code:

```html

#items-listing @items = assigns':items'

ul id='sortable'>

- items.each_with_index do |item, index|

li data-index='#{index}' draggable='true' class='list-group-item list-group-item-primary'

span title='Drag me!'> #{index} - #{item.name}

/span

/div>

```

### E. Handle Drag-and-Drop Events

In `app/javascripts/app.js`, add the following code to handle drag and drop events:

```javascript

import { $ } from 'jquery';

let dragged = null;

$(''data-index'').on('dragstart', function(event) {

var item_id = $(this).attr('id');

});

$(document).on('dragover', '.list-group-item', function(e){

e.preventDefault();

});

function updateOrdering() {

$.ajax({

type: 'POST',

url: '/items/update_ordering',

data: JSON.stringify({ items: $(''data-index'').map(function(index, item) { return $(item).attr('id')}); }),

success : function(data){ console.log('Success!'); },

error : function(xhr, status, message){

alert( 'Error while updating ordering.' );

}

});

}

function handleDrop(e) {

var source = e.target;

var destination = $('#items-listing').find('ul li:last');

if (source'0'.className === 'list-group-item') {

// Sort the list

$( '#' + source.attr('id')).insertBefore(destination);

updateOrdering();

}

$(document).on( 'drop', '.list-group-item', handleDrop );

```

### F. Update Your Controller to Handle Request

Finally, in your controller (for example `ItemsController`), you need to add an action that will process the request sent by our JavaScript code when a user drags and drops an item:

```elixir

def update_ordering(conn, _params) do

items = Items.list()

new_index_map = Enum.map(items, |item| {item.id, item.position})

for {id, position} <- new_index_map do

Item.update!(id,

position: position + if id == length(new_index_map), do: -1, else: 0

}

)

end

render json: %{success: true}

end

```

----------

In this article, we have walked through implementing a basic drag-and-drop ordering feature using Scriptcase in your Phoenix application. This guide covers setting up the necessary dependencies, creating an items schema and LiveView page for experimentation, handling drag and drop events on both client-side (JavaScript) and server-side (Elixir), and finally rendering the updated list after reordering.

Feel free to ask any questions or provide feedback if you encounter any issues following this tutorial. Happy coding!