SwiftUI reorder CoreData Objects in List

Question

I want to change the order of the rows in a list that retrieves objects from the core data. Moving rows works, but the problem is that I can't save the changes. I don't know how to save the changed Index of the CoreData Object.

Here is my Code:

Core Data Class:

public class CoreItem: NSManagedObject, Identifiable{
    @NSManaged public var name: String

}

extension CoreItem{
    static func getAllCoreItems() -> NSFetchRequest <CoreItem> {
        let request: NSFetchRequest<CoreItem> = CoreItem.fetchRequest() as! NSFetchRequest<CoreItem>
        let sortDescriptor = NSSortDescriptor(key: "date", ascending: true)
        request.sortDescriptors = [sortDescriptor]
        return request
    }
}

extension Collection where Element == CoreItem, Index == Int {
    func move(set: IndexSet, to: Int,  from managedObjectContext: NSManagedObjectContext) {

        do {
            try managedObjectContext.save()
        } catch {
            let nserror = error as NSError
            fatalError("Unresolved error \(nserror), \(nserror.userInfo)")
        }
    }
} 

List:

struct CoreItemList: View {

    @Environment(\.managedObjectContext) var managedObjectContext

    @FetchRequest(fetchRequest: CoreItem.getAllCoreItems()) var CoreItems: FetchedResults<CoreItem>



var body: some View {
      NavigationView{
          List {
            ForEach(CoreItems, id: \.self){
                   coreItem in
                    CoreItemRow(coreItem: coreItem)
                  }.onDelete {
                  IndexSet in let deleteItem = self.CoreItems[IndexSet.first!]
                  self.managedObjectContext.delete(deleteItem)

                  do {
                      try self.managedObjectContext.save()
                  } catch {
                      print(error)
                     }
                  }
                .onMove {
                    self.CoreItems.move(set: $0, to: $1, from: self.managedObjectContext)
              }
            }
             .navigationBarItems(trailing: EditButton())
           }.navigationViewStyle(StackNavigationViewStyle())
        }
    }

Thank you for help.

Answer 1

Caveat: the answer below is untested, although I used parallel logic in a sample project and that project seems to be working.

There's a couple parts to the answer. As Joakim Danielson says, in order to persist the user's preferred order you will need to save the order in your CoreItem class. The revised class would look like:

public class CoreItem: NSManagedObject, Identifiable{
    @NSManaged public var name: String
    @NSManaged public var userOrder: Int16
}

The second part is to keep the items sorted based on the userOrder attribute. On initialization the userOrder would typically default to zero so it might be useful to also sort by name within userOrder. Assuming you want to do this, then in CoreItemList code:

@FetchRequest( entity: CoreItem.entity(),
                   sortDescriptors:
                   [
                       NSSortDescriptor(
                           keyPath: \CoreItem.userOrder,
                           ascending: true),
                       NSSortDescriptor(
                           keyPath:\CoreItem.name,
                           ascending: true )
                   ]
    ) var coreItems: FetchedResults<CoreItem>

The third part is that you need to tell swiftui to permit the user to revise the order of the list. As you show in your example, this is done with the onMove modifier. In that modifier you perform the actions needed to re-order the list in the user's preferred sequence. For example, you could call a convenience function called move so the modifier would read:

.onMove( perform: move )

Your move function will be passed an IndexSet and an Int. The index set contains all the items in the FetchRequestResult that are to be moved (typically that is just one item). The Int indicates the position to which they should be moved. The logic would be:

private func move( from source: IndexSet, to destination: Int) 
{
    // Make an array of items from fetched results
    var revisedItems: [ CoreItem ] = coreItems.map{ $0 }

    // change the order of the items in the array
    revisedItems.move(fromOffsets: source, toOffset: destination )

    // update the userOrder attribute in revisedItems to 
    // persist the new order. This is done in reverse order 
    // to minimize changes to the indices.
    for reverseIndex in stride( from: revisedItems.count - 1,
                                through: 0,
                                by: -1 )
    {
        revisedItems[ reverseIndex ].userOrder =
            Int16( reverseIndex )
    }
}

Technical reminder: the items stored in revisedItems are classes (i.e., by reference), so updating these items will necessarily update the items in the fetched results. The @FetchedResults wrapper will cause your user interface to reflect the new order.

Admittedly, I'm new to SwiftUI. There is likely to be a more elegant solution!

Paul Hudson (Hacking With Swift) has quite a bit more detail. Here is a link for info on moving data in a list. Here is a link for using core data with SwiftUI (it involves deleting items in a list, but is closely analogous to the onMove logic)

Answer 2

Below you can find a more generic approach to this problem. The algorithm minimises the number of CoreData entities that require an update, to the contrary of the accepted answer. My solution is inspired by the following article: https://www.appsdissected.com/order-core-data-entities-maximum-speed/

First I declare a protocol as follows to use with your model struct (or class):

protocol Sortable {
    var sortOrder: Int { get set }
}

As an example, assume we have a SortItem model which implements our Sortable protocol, defined as:

struct SortItem: Identifiable, Sortable {
    var id = UUID()
    var title = ""
    var sortOrder = 0
}

We also have a simple SwiftUI View with a related ViewModel defined as (stripped down version):

struct ItemsView: View {
    @ObservedObject private(set) var viewModel: ViewModel
    
    var body: some View {
        NavigationView {
            List {
                ForEach(viewModel.items) { item in
                    Text(item.title)
                }
                .onMove(perform: viewModel.move(from:to:))
            }
        }
        .navigationBarItems(trailing: EditButton())
    }
}

extension ItemsView {
    class ViewModel: ObservableObject {
        @Published var items = [SortItem]()
        
        func move(from source: IndexSet, to destination: Int) {
            items.move(fromOffsets: source, toOffset: destination)

            // Note: Code that updates CoreData goes here, see below
        }
    }
}

Before I continue to the algorithm, I want to note that the destination variable from the move function does not contain the new index when moving items down the list. Assuming that only a single item is moved, retrieving the new index (after the move is complete) can be achieved as follows:

func move(from source: IndexSet, to destination: Int) {
    items.move(fromOffsets: source, toOffset: destination)
    
    if let oldIndex = source.first, oldIndex != destination {
        let newIndex = oldIndex < destination ? destination - 1 : destination
        
        // Note: Code that updates CoreData goes here, see below
    }
}

The algorithm itself is implemented as an extension to Array for the case that the Element is of the Sortable type. It consists of a recursive updateSortOrder function as well as a private helper function enclosingIndices which retrieves the indices that enclose around a certain index of the array, whilst remaining within the array bounds. The complete algorithm is as follows (explained below):

extension Array where Element: Sortable {
    func updateSortOrder(around index: Int, for keyPath: WritableKeyPath<Element, Int> = \.sortOrder, spacing: Int = 32, offset: Int = 1, _ operation: @escaping (Int, Int) -> Void) {
        if let enclosingIndices = enclosingIndices(around: index, offset: offset) {
            if let leftIndex = enclosingIndices.first(where: { $0 != index }),
               let rightIndex = enclosingIndices.last(where: { $0 != index }) {
                let left = self[leftIndex][keyPath: keyPath]
                let right = self[rightIndex][keyPath: keyPath]
                
                if left != right && (right - left) % (offset * 2) == 0 {
                    let spacing = (right - left) / (offset * 2)
                    var sortOrder = left
                    for index in enclosingIndices.indices {
                        if self[index][keyPath: keyPath] != sortOrder {
                            operation(index, sortOrder)
                        }
                        sortOrder += spacing
                    }
                } else {
                    updateSortOrder(around: index, for: keyPath, spacing: spacing, offset: offset + 1, operation)
                }
            }
        } else {
            for index in self.indices {
                let sortOrder = index * spacing
                if self[index][keyPath: keyPath] != sortOrder {
                    operation(index, sortOrder)
                }
            }
        }
    }
    
    private func enclosingIndices(around index: Int, offset: Int) -> Range<Int>? {
        guard self.count - 1 >= offset * 2 else { return nil }
        var leftIndex = index - offset
        var rightIndex = index + offset
        
        while leftIndex < startIndex {
            leftIndex += 1
            rightIndex += 1
        }
        while rightIndex > endIndex - 1 {
            leftIndex -= 1
            rightIndex -= 1
        }
        
        return Range(leftIndex...rightIndex)
    }
}

First, the enclosingIndices function. It returns an optional Range<Int>. The offset argument defines the distance for the enclosing indices left and right of the index argument. The guard ensures that the complete enclosing indices are contained within the array. Further, in case the offset goes beyond the startIndex or endIndex of the array, the enclosing indices will be shifted to the right or left, respectively. Hence, at the boundaries of the array, the index is not necessarily located in the middle of the enclosing indices.

Second, the updateSortOrder function. It requires at least the index around which the update of the sorting order should be started. This is the new index from the move function in the ViewModel. Further, the updateSortOrder expects an @escaping closure providing two integers, which will be explained below. All other arguments are optional. The keyPath is defaulted to \.sortOrder in conformance with the expectations from the protocol. However, it can be specified if the model parameter for sorting differs. The spacing argument defines the sort order spacing that is typically used. The larger this value, the more sort operations can be performed without requiring any other CoreData update except for the moved item. The offset argument should not really be touched and is used in the recursion of the function.

The function first requests the enclosingIndices. In case these are not found, which happens immediately when the array is smaller than three items or either inside one of the recursions of the updateSortOrder function when the offset is such that it would go beyond the boundaries of the array; then the sort order of all items in the array are reset in the else case. In that case, if the sortOrder differs from the items existing value, the @escaping closure is called. It's implementation will be discussed further below.

When the enclosingIndices are found, both the left and right index of the enclosing indices not being the index of the moved item are determined. With these indices known, the existing 'sort order' values for these indices are obtained through the keyPath. It is then verified if these values are not equal (which could occur if the items were added with equal sort orders in the array) as well as if a division of the difference between the sort orders and the number of enclosing indices minus the moved item would result in a non-integer value. This basically checks whether there is a place left for the moved item's potentially new sort order value within the minimum spacing of 1. If this is not the case, the enclosing indices should be expanded to the next higher offset and the algorithm run again, hence the recursive call to updateSortOrder in that case.

When all was successful, the new spacing should be determined for the items between the enclosing indices. Then all enclosing indices are looped through and each item's sorting order is compared to the potentially new sorting order. In case it changed, the @escaping closure is called. For the next item in the loop the sort order value is updated again.

This algorithm results in the minimum amount of callbacks to the @escaping closure. Since this only happens when an item's sort order really needs to be updated.

Finally, as you perhaps guessed, the actual callbacks to CoreData will be handled in the closure. With the algorithm defined, the ViewModel move function is then updated as follows:

func move(from source: IndexSet, to destination: Int) {
    items.move(fromOffsets: source, toOffset: destination)
    
    if let oldIndex = source.first, oldIndex != destination {
        let newIndex = oldIndex < destination ? destination - 1 : destination
        items.updateSortOrder(around: newIndex) { [weak self] (index, sortOrder) in
            guard let self = self else { return }
            var item = self.items[index]
            item.sortOrder = sortOrder
            
            // Note: Callback to interactor / service that updates CoreData goes here
        }
    }
}

Please let me know if you have any questions regarding this approach. I hope you like it.