iOS Swift Tutorial¶

git clone https://github.com/mongodb-university/realm-tutorial-ios-swift.git

cd realm-tutorial-ios-swift
pod install --repo-update

open "Task Tracker.xcworkspace"

let app = App(id: "tasktracker-qczfq")

class User: Object {
    @objc dynamic var _id: String = ""
    @objc dynamic var _partition: String = ""
    @objc dynamic var name: String = ""
    let memberOf = RealmSwift.List<Project>()
    override static func primaryKey() -> String? {
        return "_id"
    }
}

class Project: EmbeddedObject {
    @objc dynamic var name: String? = nil
    @objc dynamic var partition: String? = nil
    convenience init(partition: String, name: String) {
        self.init()
        self.partition = partition
        self.name = name
    }
}

class Task: Object {
    @objc dynamic var _id: ObjectId = ObjectId.generate()
    @objc dynamic var _partition: String = ""
    @objc dynamic var name: String = ""
    @objc dynamic var owner: String? = nil
    @objc dynamic var status: String = ""
    override static func primaryKey() -> String? {
        return "_id"
    }
    var statusEnum: TaskStatus {
        get {
            return TaskStatus(rawValue: status) ?? .Open
        }
        set {
            status = newValue.rawValue
        }
    }
    
    convenience init(partition: String, name: String) {
        self.init()
        self._partition = partition
        self.name = name
    }
}

@objc func signUp() {
    setLoading(true);
    app.emailPasswordAuth.registerUser(email: email!, password: password!, completion: { [weak self](error) in
        // Completion handlers are not necessarily called on the UI thread.
        // This call to DispatchQueue.main.async ensures that any changes to the UI,
        // namely disabling the loading indicator and navigating to the next page,
        // are handled on the UI thread:
        DispatchQueue.main.async {
            self!.setLoading(false);
            guard error == nil else {
                print("Signup failed: \(error!)")
                self!.errorLabel.text = "Signup failed: \(error!.localizedDescription)"
                return
            }
            print("Signup successful!")
            // Registering just registers. Now we need to sign in, but we can reuse the existing email and password.
            self!.errorLabel.text = "Signup successful! Signing in..."
            self!.signIn()
        }
    })
}

@objc func signIn() {
    print("Log in as user: \(email!)");
    setLoading(true);
    app.login(credentials: Credentials.emailPassword(email: email!, password: password!)) { [weak self](result) in
        // Completion handlers are not necessarily called on the UI thread.
        // This call to DispatchQueue.main.async ensures that any changes to the UI,
        // namely disabling the loading indicator and navigating to the next page,
        // are handled on the UI thread:
        DispatchQueue.main.async {
            self!.setLoading(false);
            switch result {
            case .failure(let error):
                // Auth error: user already exists? Try logging in as that user.
                print("Login failed: \(error)");
                self!.errorLabel.text = "Login failed: \(error.localizedDescription)"
                return
            case .success(let user):
                print("Login succeeded!");
                // Load again while we open the realm.
                self!.setLoading(true);
                // Get a configuration to open the synced realm.
                var configuration = user.configuration(partitionValue: "user=\(user.id)")
                // Only allow User objects in this partition.
                configuration.objectTypes = [User.self, Project.self]
                // Open the realm asynchronously so that it downloads the remote copy before
                // opening the local copy.
                Realm.asyncOpen(configuration: configuration) { [weak self](result) in
                    DispatchQueue.main.async {
                        self!.setLoading(false);
                        switch result {
                        case .failure(let error):
                            fatalError("Failed to open realm: \(error)")
                        case .success(let userRealm):
                            // Go to the list of projects in the user object contained in the user realm.
                            self!.navigationController!.pushViewController(ProjectsViewController(userRealm: userRealm), animated: true);
                        }
                    }
                }
            }
        }
    };
}

// There should only be one user in my realm - that is myself
let usersInRealm = userRealm.objects(User.self)
notificationToken = usersInRealm.observe { [weak self, usersInRealm] (changes) in
    self?.userData = usersInRealm.first
    guard let tableView = self?.tableView else { return }
    tableView.reloadData()
}

deinit {
    // Always invalidate any notification tokens when you are done with them.
    notificationToken?.invalidate()
}

@objc func logOutButtonDidClick() {
    let alertController = UIAlertController(title: "Log Out", message: "", preferredStyle: .alert);
    alertController.addAction(UIAlertAction(title: "Yes, Log Out", style: .destructive, handler: {
        alert -> Void in
        print("Logging out...");
        app.currentUser?.logOut() { (error) in
            DispatchQueue.main.async {
                print("Logged out!");
                self.navigationController?.popViewController(animated: true)
            }
        }
    }))
    alertController.addAction(UIAlertAction(title: "Cancel", style: .cancel, handler: nil))
    self.present(alertController, animated: true, completion: nil)
}

func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
    // You always have at least one project (your own)
    return userData?.memberOf.count ?? 1
}

func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "Cell") ?? UITableViewCell(style: .default, reuseIdentifier: "Cell")
    cell.selectionStyle = .none
    // User data may not have loaded yet. You always have your own project.
    let projectName = userData?.memberOf[indexPath.row].name ?? "My Project"
    cell.textLabel?.text = projectName
    
    return cell
}

func tableView(_ tableView: UITableView, didSelectRowAt indexPath: IndexPath) {
    let user = app.currentUser!
    let project = userData?.memberOf[indexPath.row] ?? Project(partition: "project=\(user.id)", name: "My Project")
    Realm.asyncOpen(configuration: user.configuration(partitionValue: project.partition!)) { [weak self] (result) in
        switch result {
        case .failure(let error):
            fatalError("Failed to open realm: \(error)")
        case .success(let realm):
            self?.navigationController?.pushViewController(
                TasksViewController(realm: realm, title: "\(project.name!)'s Tasks"),
                animated: true
            );
        }
    }
}

let tableView = UITableView()
let partitionValue: String
let realm: Realm
var notificationToken: NotificationToken?
let tasks: Results<Task>

required init(realm: Realm, title: String) {
    // Ensure the realm was opened with sync.
    guard let syncConfiguration = realm.configuration.syncConfiguration else {
        fatalError("Sync configuration not found! Realm not opened with sync?");
    }
    self.realm = realm
    // Partition value must be of string type.
    partitionValue = syncConfiguration.partitionValue!.stringValue!
    // Access all tasks in the realm, sorted by _id so that the ordering is defined.
    tasks = realm.objects(Task.self).sorted(byKeyPath: "_id")
    super.init(nibName: nil, bundle: nil)
    self.title = title
    // Observe the tasks for changes. Hang on to the returned notification token.
    notificationToken = tasks.observe { [weak self] (changes) in
        guard let tableView = self?.tableView else { return }
        switch changes {
        case .initial:
            // Results are now populated and can be accessed without blocking the UI
            tableView.reloadData()
        case .update(_, let deletions, let insertions, let modifications):
            // Query results have changed, so apply them to the UITableView.
            tableView.performBatchUpdates({
                // It's important to be sure to always update a table in this order:
                // deletions, insertions, then updates. Otherwise, you could be unintentionally
                // updating at the wrong index!
                tableView.deleteRows(at: deletions.map({ IndexPath(row: $0, section: 0) }),
                    with: .automatic)
                tableView.insertRows(at: insertions.map({ IndexPath(row: $0, section: 0) }),
                    with: .automatic)
                tableView.reloadRows(at: modifications.map({ IndexPath(row: $0, section: 0) }),
                    with: .automatic)
            })
        case .error(let error):
            // An error occurred while opening the Realm file on the background worker thread
            fatalError("\(error)")
        }
    }
}

deinit {
    // Always invalidate any notification tokens when you are done with them.
    notificationToken?.invalidate()
}

// Create a new Task with the text that the user entered.
let task = Task(partition: self.partitionValue, name: textField.text ?? "New Task")
// Any writes to the Realm must occur in a write block.
try! self.realm.write {
    // Add the Task to the Realm. That's it!
    self.realm.add(task)
}

// If the task is not in the Open state, we can set it to open. Otherwise, that action will not be available.
// We do this for the other two states -- InProgress and Complete.
if (task.statusEnum != .Open) {
    actionSheet.addAction(UIAlertAction(title: "Open", style: .default) { _ in
            // Any modifications to managed objects must occur in a write block.
            // When we modify the Task's state, that change is automatically reflected in the realm.
            try! self.realm.write {
                task.statusEnum = .Open
            }
        })
}
if (task.statusEnum != .InProgress) {
    actionSheet.addAction(UIAlertAction(title: "Start Progress", style: .default) { _ in
            try! self.realm.write {
                task.statusEnum = .InProgress
            }
        })
}
if (task.statusEnum != .Complete) {
    actionSheet.addAction(UIAlertAction(title: "Complete", style: .default) { _ in
            try! self.realm.write {
                task.statusEnum = .Complete
            }
        })
}

func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {
    guard editingStyle == .delete else { return }
    // User can swipe to delete items.
    let task = tasks[indexPath.row]
    
    // All modifications to a realm must happen in a write block.
    try! realm.write {
        // Delete the Task.
        realm.delete(task)
    }
}

// Returns true if these are the user's own tasks.
func isOwnTasks() -> Bool {
    return partitionValue == "project=\(app.currentUser!.id)"
}

// Calls a Realm function to fetch the team members and adds them to the list
func fetchTeamMembers() {
    // Start loading indicator
    activityIndicator.startAnimating()
    let user = app.currentUser!
    
    user.functions.getMyTeamMembers([]) { [weak self](result, error) in
        DispatchQueue.main.async {
            guard self != nil else {
                // This can happen if the view is dismissed 
                // before the operation completes
                print("Team members list no longer needed.");
                return
            }
            // Stop loading indicator
            self!.activityIndicator.stopAnimating()
            guard error == nil else {
                print("Fetch team members failed: \(error!.localizedDescription)")
                return
            }
            print("Fetch team members complete.")
            
            // Convert documents to members array
            self!.members = result!.arrayValue!.map({ (bson) in
                return Member(document: bson!.documentValue!)
            })
            
            // Notify UI of changed data
            self!.tableView.reloadData()
        }
    }
}

func addTeamMember(email: String) {
    print("Adding member: \(email)")
    activityIndicator.startAnimating()
    let user = app.currentUser!
    
    user.functions.addTeamMember([AnyBSON(email)], self.onTeamMemberOperationComplete)
}

func removeTeamMember(email: String) {
    print("Removing member: \(email)")
    activityIndicator.startAnimating()
    let user = app.currentUser!
    
    user.functions.removeTeamMember([AnyBSON(email)], self.onTeamMemberOperationComplete)
}