Raw Data Model

/// model of TodoItem
struct TodoItem {
    var primaryKey: String
    var dueDate: Date
    var name: String

    init(dueDate: Date, name: String) {
        self.primaryKey = Date().description
        self.dueDate = dueDate
        self.name = name
    }

    init(from entry: RealmTodoItem) {
        self.primaryKey = (entry.mainKey ?? "") as String
        self.dueDate = entry.date as Date? ?? Date()
        self.name = entry.name ?? ""
    }
}


extension TodoItem: Equatable {
    static func ==(left: TodoItem, right: TodoItem) -> Bool {
        return left.primaryKey == right.primaryKey
    }
}

Realm Data Model

• Data entry must be dynamic
• Primary key: unique ID for data query, only be String or Int

import Foundation
import RealmSwift

//fileprivate let PrimaryKey = "RealmTodoItem"
class RealmTodoItem: Object {
    dynamic var mainKey: NSString?
    dynamic var name: String?
    dynamic var date: NSDate?


    convenience init(mainKey: String, name: String,date: NSDate) {
        self.init()
        self.mainKey = mainKey as NSString?
        self.name = name
        self.date = date
        print("pri key: \(self.mainKey)")
    }

    convenience init(from entry: TodoItem) {
        self.init()
        self.mainKey = entry.primaryKey as NSString?
        self.name = entry.name
        self.date = entry.dueDate as NSDate
    }

    /// setting primary key
    /// Declaring a primary key allows objects to be looked up and updated efficiently and enforces uniqueness for each value. Once an object with a primary key is added to a Realm, the primary key cannot be changed.
    override static func primaryKey() -> String? {
        return "mainKey"
    }
}

Data Store

• this example operates RealmSwift in mainQueue

import Foundation
import RealmSwift

class RealmStore {

    /// fetch by NSPredicate
    public func fetchEntries(
        with predicate: NSPredicate,
        completion: ([TodoItem])->()) {

        var todoItems = Array<TodoItem>()
        guard let results = self.search(todoItem: predicate) else {
            completion(todoItems)
            //print("Realm.M: fail to object for \(predicate)")
            return
        }
        for element in results {
            let todoItem = TodoItem(from: element)
            todoItems.append(todoItem)

        }
        completion(todoItems)
    }

    // add new entry
    func save(_ entry: TodoItem) {
        self.setObject(with: entry)
    }

    // remove by entry
    func remove(todoItem entry: TodoItem) -> Bool {
        return removeObject(todoItem: entry)
    }

    // remove by primaryKey
    func remove(by primaryKey: String) -> Bool {
        return removeObject(key: primaryKey)
    }

    /// remove all
    public func removeAllObjects() {
        do {
            let realm = try Realm()
            try realm.write(){
                realm.deleteAll()
            }
            print("Realm.M: remove all")
        } catch let error as NSError{
            print("Realm.M: fail to remove all \(error.localizedDescription)")
        }
    }
}

// MARK: - private methods
private extension RealmStore {

    /// add entry
    func setObject(with entry: TodoItem) {

        let newModel = RealmTodoItem(from: entry)
        do {
            let realm = try Realm()
            try realm.write(){
                realm.add(newModel, update: true)
            }
            print("Realm.M: add to realm")
        } catch let error as NSError{
            print("Realm.M: fail to add \(error.localizedDescription)")
        }
    }


    /// remove by entry
    func removeObject(todoItem entry: TodoItem) -> Bool {
        let predicate = NSPredicate(format: "mainKey == %@", entry.primaryKey as NSString)
        guard let results = self.search(todoItem: predicate) else {
            print("Realm.M: fail to remove object for \(predicate)")
            return false
        }
        for element in results {
            remove(obj: element)
        }
        return true
    }

    /// remove by primarykey
    func removeObject(key primaryKey: String) -> Bool {
        let predicate = NSPredicate(format: "mainKey == %@", primaryKey as NSString)
        guard let results = self.search(todoItem: predicate) else {
            print("Realm.M: fail to remove key for \(predicate)")
            return false
        }
        for element in results {
            remove(obj: element)
        }
        return true
    }

    /// search model for key
    func search(todoItem predicate: NSPredicate) -> [RealmTodoItem]? {

        do {
            let realm = try Realm()
            let resModels = realm.objects(RealmTodoItem.self).filter(predicate).sorted(byKeyPath: "date", ascending: true)
            if !resModels.isEmpty {
                print("Realm.M: fetch in Realm")
                return Array<RealmTodoItem>(resModels)
            }
        } catch let error as NSError {
            print("Realm.M: fail search - \(error.localizedDescription)")

        }
        return nil
    }

    /// remove model for key
    func remove(obj: RealmTodoItem) {
        do {
            let realm = try Realm()
            try realm.write(){
                realm.delete(obj)
            }
            print("Realm.M: remove")
        } catch let error as NSError{
            print("Realm.M: fail to remove \(error.localizedDescription)")
        }
    }
}