iOS Swift Tutorial¶

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

class Task: Object {
    @Persisted(primaryKey: true) var _id: ObjectId
    @Persisted var name: String = ""
    @Persisted var owner: String?
    @Persisted var status: String = ""
    var statusEnum: TaskStatus {
        get {
            return TaskStatus(rawValue: status) ?? .Open
        }
        set {
            status = newValue.rawValue
        }
    }
    convenience init(name: String) {
        self.init()
        self.name = name
    }
}

self.userRealm = try! Realm(configuration: userRealmConfiguration)
super.init(nibName: nil, bundle: nil)

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

required init(realmConfiguration: Realm.Configuration, title: String) {
    self.realm = try! Realm(configuration: realmConfiguration)
    
    // 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(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)
    }
}

@objc func signIn() {
    // Go to the list of tasks in the user object contained in the user realm.
    var config = Realm.Configuration.defaultConfiguration
    // This configuration step is not really needed, but if we add Sync later,
    // this allows us to keep the tasks we made.
    config.fileURL!.deleteLastPathComponent()
    config.fileURL!.appendPathComponent("project=\(self.username!)")
    config.fileURL!.appendPathExtension("realm")
    navigationController!.pushViewController(
        TasksViewController(realmConfiguration: config, title: "\(username!)'s Tasks"),
        animated: true
    )
}

let app = App(id: "<your-realm-app-ID-here>")

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

class User: Object {
    @Persisted(primaryKey: true) var _id: String = ""
    @Persisted var name: String = ""
    @Persisted var memberOf: List<Project>
}

let passwordField = UITextField()
let signInButton = UIButton(type: .roundedRect)
let signUpButton = UIButton(type: .roundedRect)

var password: String? {
    get {
        return passwordField.text
    }
}

infoLabel.text = "Please enter an email and password."

// Configure the username text input field.
usernameField.placeholder = "Email"

// Configure the password text input field.
passwordField.placeholder = "Password"
passwordField.isSecureTextEntry = true
passwordField.borderStyle = .roundedRect
container.addArrangedSubview(passwordField)

// Configure the sign up button.
signUpButton.setTitle("Sign Up", for: .normal)
signUpButton.addTarget(self, action: #selector(signUp), for: .touchUpInside)
container.addArrangedSubview(signUpButton)

usernameField.isEnabled = !loading
passwordField.isEnabled = !loading
signInButton.isEnabled = !loading
signUpButton.isEnabled = !loading

@objc func signUp() {
    setLoading(true)
    app.emailPasswordAuth.registerUser(email: username!, 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: \(username!)")
    setLoading(true)
    
    app.login(credentials: Credentials.emailPassword(email: username!, 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.
                let configuration = user.configuration(partitionValue: "user=\(user.id)")
                // 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:
                            // Go to the list of projects in the user object contained in the user realm.
                            self!.navigationController!.pushViewController(ProjectsViewController(userRealmConfiguration: configuration), animated: true)
                        }
                    }
                }
            }
        }
    }
}

@objc func logOutButtonDidClick() {
    let alertController = UIAlertController(title: "Log Out", message: "", preferredStyle: .alert)
    alertController.addAction(UIAlertAction(title: "Yes, Log Out", style: .destructive, handler: {
        _ -> Void in
        print("Logging out...")
        self.navigationController?.popViewController(animated: true)
        app.currentUser?.logOut { (_) 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)
}

self.userRealm = try! Realm(configuration: userRealmConfiguration)
super.init(nibName: nil, bundle: nil)
// There should only be one user in my realm - that is myself
let usersInRealm = userRealm.objects(User.self)
notificationToken = usersInRealm.observe { [weak self, usersInRealm] (_) 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()
}

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")
    let configuration = user.configuration(partitionValue: project.partition!)
    Realm.asyncOpen(configuration: configuration) { [weak self] (result) in
        switch result {
        case .failure(let error):
            fatalError("Failed to open realm: \(error)")
        case .success(let realm):
            self?.navigationController?.pushViewController(
                TasksViewController(realmConfiguration: configuration, title: "\(project.name!)'s Tasks"),
                animated: true
            )
        }
    }
}

// Returns true if these are the user's own tasks.
func isOwnTasks() -> Bool {
    let partitionValue = self.realm.configuration.syncConfiguration?.partitionValue?.stringValue
    return partitionValue != nil && partitionValue == "project=\(app.currentUser!.id)"
}

@objc func manageTeamButtonDidClick() {
    present(UINavigationController(rootViewController: ManageTeamViewController()), animated: true)
}

if isOwnTasks() {
    // Only set up the manage team button if these are tasks the user owns.
    toolbarItems = [
        UIBarButtonItem(title: "Manage Team", style: .plain, target: self, action: #selector(manageTeamButtonDidClick))
    ]
    navigationController?.isToolbarHidden = false
}

import UIKit
import RealmSwift
class ManageTeamViewController: UIViewController, UITableViewDelegate, UITableViewDataSource {
   let tableView = UITableView()
   var activityIndicator = UIActivityIndicatorView(style: .large)
   var members: [Member] = []
   override func viewDidLoad() {
       super.viewDidLoad()
       title = "My Team"
       navigationItem.leftBarButtonItem = UIBarButtonItem(barButtonSystemItem: .close, target: self, action: #selector(closeButtonDidClick))
       navigationItem.rightBarButtonItem = UIBarButtonItem(barButtonSystemItem: .add, target: self, action: #selector(addButtonDidClick))
       tableView.dataSource = self
       tableView.delegate = self
       tableView.frame = self.view.frame
       view.addSubview(tableView)
       activityIndicator.center = view.center
       view.addSubview(activityIndicator)
       fetchTeamMembers()
   }
   @objc func closeButtonDidClick() {
       presentingViewController!.dismiss(animated: true)
   }
   @objc func addButtonDidClick() {
       let alertController = UIAlertController(title: "Add Team Member", message: "Enter your team member's email address.", preferredStyle: .alert)
       // When the user clicks the add button, present them with a dialog to enter the member's email address.
       alertController.addAction(UIAlertAction(title: "Add", style: .default, handler: {
           [weak self] _ -> Void in
           let textField = alertController.textFields![0]
           self!.addTeamMember(email: textField.text!)
       }))
       alertController.addAction(UIAlertAction(title: "Cancel", style: .cancel, handler: nil))
       alertController.addTextField(configurationHandler: { (textField: UITextField!) -> Void in
           textField.placeholder = "someone@example.com"
       })
       // Show the dialog.
       self.present(alertController, animated: true, completion: nil)
   }
   func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
       return members.count
   }
   func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
       let member = members[indexPath.row]
       let cell = tableView.dequeueReusableCell(withIdentifier: "Cell") ?? UITableViewCell(style: .default, reuseIdentifier: "Cell")
       cell.selectionStyle = .none
       cell.textLabel?.text = member.name
       return cell
   }
   func tableView(_ tableView: UITableView, commit editingStyle: UITableViewCell.EditingStyle, forRowAt indexPath: IndexPath) {
       guard editingStyle == .delete else { return }
       removeTeamMember(email: members[indexPath.row].name)
   }
   // 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)
   }
   private func onTeamMemberOperationComplete(result: AnyBSON?, realmError: Error?) {
       DispatchQueue.main.async { [self] in
           // Always be sure to stop the activity indicator
           activityIndicator.stopAnimating()
           // There are two kinds of errors:
           // - The Realm function call itself failed (for example, due to network error)
           // - The Realm function call succeeded, but our business logic within the function returned an error,
           //   (for example, user is not a member of the team).
           var errorMessage: String?
           if realmError != nil {
               // Error from Realm (failed function call, network error...)
               errorMessage = realmError!.localizedDescription
           } else if let resultDocument = result?.documentValue {
               // Check for user error. The addTeamMember function we defined returns an object
               // with the `error` field set if there was a user error.
               errorMessage = resultDocument["error"]??.stringValue
           } else {
               // The function call did not fail but the result was not a document.
               // This is unexpected.
               errorMessage = "Unexpected result returned from server"
           }
           // Present error message if any
           guard errorMessage == nil else {
               print("Team operation failed: \(errorMessage!)")
               let alertController = UIAlertController(
                   title: "Error",
                   message: errorMessage!,
                   preferredStyle: .alert
               )
               alertController.addAction(UIAlertAction(title: "OK", style: .cancel))
               present(alertController, animated: true)
               return
           }
           // Otherwise, fetch new team members list
           print("Team operation successful")
           fetchTeamMembers()
       }
   }
}

   // 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)
   }