var db: Firestore!

override func viewDidLoad() {

super.viewDidLoad()

// [START setup]

let settings = FirestoreSettings()

Firestore.firestore().settings = settings

// [END setup]

db = Firestore.firestore()

}

@IBAction func didTouchSmokeTestButton(_ sender: AnyObject) {

// Quickstart

Task {

await addAdaLovelace()

await addAlanTuring()

await getCollection()

listenForUsers()

}

// Structure Data

demonstrateReferences()

// Save Data

Task {

await setDocument()

await dataTypes()

setData()

await addDocument()

newDocument()

await updateDocument()

createIfMissing()

await updateDocumentNested()

await deleteDocument()

deleteCollection()

await deleteField()

await serverTimestamp()

serverTimestampOptions()

await simpleTransaction()

await transaction()

await writeBatch()

}

// Retrieve Data

Task {

exampleData()

exampleDataCollectionGroup()

await getDocument()

await customClassGetDocument()

listenDocument()

listenDocumentLocal()

listenWithMetadata()

await getMultiple()

await getMultipleAll()

listenMultiple()

listenDiffs()

listenState()

detachListener()

handleListenErrors()

}

// Query Data

simpleQueries()

exampleFilters()

onlyCapitals()

chainFilters()

validRangeFilters()

// IN Queries

arrayContainsAnyQueries()

inQueries()

// Can't run this since it throws a fatal error

// invalidRangeFilters()

orderAndLimit()

orderAndLimitDesc()

orderMultiple()

filterAndOrder()

validFilterAndOrder()

// Can't run this since it throws a fatal error

// invalidFilterAndOrder()

// Enable Offline

// Can't run this since it throws a fatal error

// enableOffline()

listenToOffline()

toggleOffline()

setupCacheSize()

// Cursors

simpleCursor()

snapshotCursor()

paginate()

multiCursor()

}

@IBAction func didTouchDeleteButton(_ sender: AnyObject) {

deleteCollection(collection: "users")

deleteCollection(collection: "cities")

}

private func deleteCollection(collection: String) {

db.collection(collection).getDocuments() { (querySnapshot, err) in

if let err = err {

print("Error getting documents: \(err)")

return

}

for document in querySnapshot!.documents {

print("Deleting \(document.documentID) => \(document.data())")

document.reference.delete()

}

}

}

private func setupCacheSize() {

// [START fs_setup_cache]

let settings = Firestore.firestore().settings

// Set cache size to 100 MB

settings.cacheSettings = PersistentCacheSettings(sizeBytes: 100 * 1024 * 1024 as NSNumber)

Firestore.firestore().settings = settings

// [END fs_setup_cache]

}

// =======================================================================================

// ======== https://firebase.google.com/preview/firestore/client/quickstart ==============

// =======================================================================================

private func addAdaLovelace() async {

// [START add_ada_lovelace]

// Add a new document with a generated ID

do {

let ref = try await db.collection("users").addDocument(data: [

"first": "Ada",

"last": "Lovelace",

"born": 1815

])

print("Document added with ID: \(ref.documentID)")

} catch {

print("Error adding document: \(error)")

}

// [END add_ada_lovelace]

}

private func addAlanTuring() async {

// [START add_alan_turing]

// Add a second document with a generated ID.

do {

let ref = try await db.collection("users").addDocument(data: [

"first": "Alan",

"middle": "Mathison",

"last": "Turing",

"born": 1912

])

print("Document added with ID: \(ref.documentID)")

} catch {

print("Error adding document: \(error)")

}

// [END add_alan_turing]

}

private func getCollection() async {

// [START get_collection]

do {

let snapshot = try await db.collection("users").getDocuments()

for document in snapshot.documents {

print("\(document.documentID) => \(document.data())")

}

} catch {

print("Error getting documents: \(error)")

}

// [END get_collection]

}

private func listenForUsers() {

// [START listen_for_users]

// Listen to a query on a collection.

//

// We will get a first snapshot with the initial results and a new

// snapshot each time there is a change in the results.

db.collection("users")

.whereField("born", isLessThan: 1900)

.addSnapshotListener { querySnapshot, error in

guard let snapshot = querySnapshot else {

print("Error retreiving snapshots \(error!)")

return

}

print("Current users born before 1900: \(snapshot.documents.map { $0.data() })")

}

// [END listen_for_users]

}

// =======================================================================================

// ======= https://firebase.google.com/preview/firestore/client/structure-data ===========

// =======================================================================================

private func demonstrateReferences() {

// [START doc_reference]

let alovelaceDocumentRef = db.collection("users").document("alovelace")

// [END doc_reference]

print(alovelaceDocumentRef)

// [START collection_reference]

let usersCollectionRef = db.collection("users")

// [END collection_reference]

print(usersCollectionRef)

// [START subcollection_reference]

let messageRef = db

.collection("rooms").document("roomA")

.collection("messages").document("message1")

// [END subcollection_reference]

print(messageRef)

// [START path_reference]

let aLovelaceDocumentReference = db.document("users/alovelace")

// [END path_reference]

print(aLovelaceDocumentReference)

}

// =======================================================================================

// ========= https://firebase.google.com/preview/firestore/client/save-data ==============

// =======================================================================================

private func setDocument() async {

// [START set_document]

// Add a new document in collection "cities"

do {

try await db.collection("cities").document("LA").setData([

"name": "Los Angeles",

"state": "CA",

"country": "USA"

])

print("Document successfully written!")

} catch {

print("Error writing document: \(error)")

}

// [END set_document]

}

private func setDocumentWithCodable() {

// [START set_document_codable]

let city = City(name: "Los Angeles",

state: "CA",

country: "USA",

isCapital: false,

population: 5000000)

do {

try db.collection("cities").document("LA").setData(from: city)

} catch let error {

print("Error writing city to Firestore: \(error)")

}

// [END set_document_codable]

}

private func dataTypes() async {

// [START data_types]

let docData: [String: Any] = [

"stringExample": "Hello world!",

"booleanExample": true,

"numberExample": 3.14159265,

"dateExample": Timestamp(date: Date()),

"arrayExample": [5, true, "hello"],

"nullExample": NSNull(),

"objectExample": [

"a": 5,

"b": [

"nested": "foo"

]

]

]

do {

try await db.collection("data").document("one").setData(docData)

print("Document successfully written!")

} catch {

print("Error writing document: \(error)")

}

// [END data_types]

}

private func setData() {

let data: [String: Any] = [:]

// [START set_data]

db.collection("cities").document("new-city-id").setData(data)

// [END set_data]

}

private func addDocument() async {

// [START add_document]

// Add a new document with a generated id.

do {

let ref = try await db.collection("cities").addDocument(data: [

"name": "Tokyo",

"country": "Japan"

])

print("Document added with ID: \(ref.documentID)")

} catch {

print("Error adding document: \(error)")

}

// [END add_document]

}

private func newDocument() {

// [START new_document]

let newCityRef = db.collection("cities").document()

// later...

newCityRef.setData([

// [START_EXCLUDE]

"name": "Some City Name"

// [END_EXCLUDE]

])

// [END new_document]

}

private func updateDocument() async {

// [START update_document]

let washingtonRef = db.collection("cities").document("DC")

// Set the "capital" field of the city 'DC'

do {

try await washingtonRef.updateData([

"capital": true

])

print("Document successfully updated")

} catch {

print("Error updating document: \(error)")

}

// [END update_document]

}

private func updateDocumentArray() {

// [START update_document_array]

let washingtonRef = db.collection("cities").document("DC")

// Atomically add a new region to the "regions" array field.

washingtonRef.updateData([

"regions": FieldValue.arrayUnion(["greater_virginia"])

])

// Atomically remove a region from the "regions" array field.

washingtonRef.updateData([

"regions": FieldValue.arrayRemove(["east_coast"])

])

// [END update_document_array]

}

private func updateDocumentIncrement() {

// [START update_document-increment]

let washingtonRef = db.collection("cities").document("DC")

// Atomically increment the population of the city by 50.

// Note that increment() with no arguments increments by 1.

washingtonRef.updateData([

"population": FieldValue.increment(Int64(50))

])

// [END update_document-increment]

}

private func createIfMissing() {

// [START create_if_missing]

// Update one field, creating the document if it does not exist.

db.collection("cities").document("BJ").setData([ "capital": true ], merge: true)

// [END create_if_missing]

}

private func updateDocumentNested() async {

// [START update_document_nested]

// Create an initial document to update.

let frankDocRef = db.collection("users").document("frank")

do {

try await frankDocRef.setData([

"name": "Frank",

"favorites": [ "food": "Pizza", "color": "Blue", "subject": "recess" ],

"age": 12

])

// To update age and favorite color:

try await frankDocRef.updateData([

"age": 13,

"favorites.color": "Red"

])

print("Document successfully updated")

} catch {

print("Error updating document: \(error)")

}

// [END update_document_nested]

}

private func deleteDocument() async {

// [START delete_document]

do {

try await db.collection("cities").document("DC").delete()

print("Document successfully removed!")

} catch {

print("Error removing document: \(error)")

}

// [END delete_document]

}

private func deleteCollection() {

// [START delete_collection]

func delete(collection: CollectionReference, batchSize: Int = 100, completion: @escaping (Error?) -> ()) {

// Limit query to avoid out-of-memory errors on large collections.

// When deleting a collection guaranteed to fit in memory, batching can be avoided entirely.

collection.limit(to: batchSize).getDocuments { (docset, error) in

// An error occurred.

guard let docset = docset else {

completion(error)

return

}

// There's nothing to delete.

guard docset.count > 0 else {

completion(nil)

return

}

let batch = collection.firestore.batch()

docset.documents.forEach { batch.deleteDocument($0.reference) }

batch.commit { (batchError) in

if let batchError = batchError {

// Stop the deletion process and handle the error. Some elements

// may have been deleted.

completion(batchError)

} else {

delete(collection: collection, batchSize: batchSize, completion: completion)

}

}

}

}

// [END delete_collection]

}

private func deleteField() async {

// [START delete_field]

do {

try await db.collection("cities").document("BJ").updateData([

"capital": FieldValue.delete(),

])

print("Document successfully updated")

} catch {

print("Error updating document: \(error)")

}

// [END delete_field]

}

private func serverTimestamp() async {

// [START server_timestamp]

do {

try await db.collection("objects").document("some-id").updateData([

"lastUpdated": FieldValue.serverTimestamp(),

])

print("Document successfully updated")

} catch {

print("Error updating document: \(error)")

}

// [END server_timestamp]

}

private func serverTimestampOptions() {

// [START server_timestamp_options]

// Perform an update followed by an immediate read without waiting for the update to

// complete. Due to the snapshot options we will get two results: one with an estimated

// timestamp and one with a resolved server timestamp.

let docRef = db.collection("objects").document("some-id")

docRef.updateData(["timestamp": FieldValue.serverTimestamp()])

docRef.addSnapshotListener { (snapshot, error) in

guard let timestamp = snapshot?.data(with: .estimate)?["timestamp"] else { return }

guard let pendingWrites = snapshot?.metadata.hasPendingWrites else { return }

print("Timestamp: \(timestamp), pending: \(pendingWrites)")

}

// [END server_timestamp_options]

}

private func simpleTransaction() async {

// [START simple_transaction]

let sfReference = db.collection("cities").document("SF")

do {

let _ = try await db.runTransaction({ (transaction, errorPointer) -> Any? in

let sfDocument: DocumentSnapshot

do {

try sfDocument = transaction.getDocument(sfReference)

} catch let fetchError as NSError {

errorPointer?.pointee = fetchError

return nil

}

guard let oldPopulation = sfDocument.data()?["population"] as? Int else {

let error = NSError(

domain: "AppErrorDomain",

code: -1,

userInfo: [

NSLocalizedDescriptionKey: "Unable to retrieve population from snapshot \(sfDocument)"

]

)

errorPointer?.pointee = error

return nil

}

// Note: this could be done without a transaction

// by updating the population using FieldValue.increment()

transaction.updateData(["population": oldPopulation + 1], forDocument: sfReference)

return nil

})

print("Transaction successfully committed!")

} catch {

print("Transaction failed: \(error)")

}

// [END simple_transaction]

}

private func transaction() async {

// [START transaction]

let sfReference = db.collection("cities").document("SF")

do {

let object = try await db.runTransaction({ (transaction, errorPointer) -> Any? in

let sfDocument: DocumentSnapshot

do {

try sfDocument = transaction.getDocument(sfReference)

} catch let fetchError as NSError {

errorPointer?.pointee = fetchError

return nil

}

guard let oldPopulation = sfDocument.data()?["population"] as? Int else {

let error = NSError(

domain: "AppErrorDomain",

code: -1,

userInfo: [

NSLocalizedDescriptionKey: "Unable to retrieve population from snapshot \(sfDocument)"

]

)

errorPointer?.pointee = error

return nil

}

// Note: this could be done without a transaction

// by updating the population using FieldValue.increment()

let newPopulation = oldPopulation + 1

guard newPopulation <= 1000000 else {

let error = NSError(

domain: "AppErrorDomain",

code: -2,

userInfo: [NSLocalizedDescriptionKey: "Population \(newPopulation) too big"]

)

errorPointer?.pointee = error

return nil

}

transaction.updateData(["population": newPopulation], forDocument: sfReference)

return newPopulation

})

print("Population increased to \(object!)")

} catch {

print("Error updating population: \(error)")

}

// [END transaction]

}

private func writeBatch() async {

// [START write_batch]

// Get new write batch

let batch = db.batch()

// Set the value of 'NYC'

let nycRef = db.collection("cities").document("NYC")

batch.setData([:], forDocument: nycRef)

// Update the population of 'SF'

let sfRef = db.collection("cities").document("SF")

batch.updateData(["population": 1000000 ], forDocument: sfRef)

// Delete the city 'LA'

let laRef = db.collection("cities").document("LA")

batch.deleteDocument(laRef)

// Commit the batch

do {

try await batch.commit()

print("Batch write succeeded.")

} catch {

print("Error writing batch: \(error)")

}

// [END write_batch]

}

// =======================================================================================

// ======= https://firebase.google.com/preview/firestore/client/retrieve-data ============

// =======================================================================================

private func exampleData() {

// [START example_data]

let citiesRef = db.collection("cities")

citiesRef.document("SF").setData([

"name": "San Francisco",

"state": "CA",

"country": "USA",

"capital": false,

"population": 860000,

"regions": ["west_coast", "norcal"]

])

citiesRef.document("LA").setData([

"name": "Los Angeles",

"state": "CA",

"country": "USA",

"capital": false,

"population": 3900000,

"regions": ["west_coast", "socal"]

])

citiesRef.document("DC").setData([

"name": "Washington D.C.",

"country": "USA",

"capital": true,

"population": 680000,

"regions": ["east_coast"]

])

citiesRef.document("TOK").setData([

"name": "Tokyo",

"country": "Japan",

"capital": true,

"population": 9000000,

"regions": ["kanto", "honshu"]

])

citiesRef.document("BJ").setData([

"name": "Beijing",

"country": "China",

"capital": true,

"population": 21500000,

"regions": ["jingjinji", "hebei"]

])

// [END example_data]

}

private func exampleDataCollectionGroup() {

// [START fs_collection_group_query_data_setup]

let citiesRef = db.collection("cities")

var data = ["name": "Golden Gate Bridge", "type": "bridge"]

citiesRef.document("SF").collection("landmarks").addDocument(data: data)

data = ["name": "Legion of Honor", "type": "museum"]

citiesRef.document("SF").collection("landmarks").addDocument(data: data)

data = ["name": "Griffith Park", "type": "park"]

citiesRef.document("LA").collection("landmarks").addDocument(data: data)

data = ["name": "The Getty", "type": "museum"]

citiesRef.document("LA").collection("landmarks").addDocument(data: data)

data = ["name": "Lincoln Memorial", "type": "memorial"]

citiesRef.document("DC").collection("landmarks").addDocument(data: data)

data = ["name": "National Air and Space Museum", "type": "museum"]

citiesRef.document("DC").collection("landmarks").addDocument(data: data)

data = ["name": "Ueno Park", "type": "park"]

citiesRef.document("TOK").collection("landmarks").addDocument(data: data)

data = ["name": "National Museum of Nature and Science", "type": "museum"]

citiesRef.document("TOK").collection("landmarks").addDocument(data: data)

data = ["name": "Jingshan Park", "type": "park"]

citiesRef.document("BJ").collection("landmarks").addDocument(data: data)

data = ["name": "Beijing Ancient Observatory", "type": "museum"]

citiesRef.document("BJ").collection("landmarks").addDocument(data: data)

// [END fs_collection_group_query_data_setup]

}

private func getDocument() async {

// [START get_document]

let docRef = db.collection("cities").document("SF")

do {

let document = try await docRef.getDocument()

if document.exists {

let dataDescription = document.data().map(String.init(describing:)) ?? "nil"

print("Document data: \(dataDescription)")

} else {

print("Document does not exist")

}

} catch {

print("Error getting document: \(error)")

}

// [END get_document]

}

private func getDocumentWithOptions() async {

// [START get_document_options]

let docRef = db.collection("cities").document("SF")

do {

// Force the SDK to fetch the document from the cache. Could also specify

// FirestoreSource.server or FirestoreSource.default.

let document = try await docRef.getDocument(source: .cache)

if document.exists {

let dataDescription = document.data().map(String.init(describing:)) ?? "nil"

print("Cached document data: \(dataDescription)")

} else {

print("Document does not exist in cache")

}

} catch {

print("Error getting document: \(error)")

}

// [END get_document_options]

}

private func customClassGetDocument() async {

// [START custom_type]

let docRef = db.collection("cities").document("BJ")

do {

let city = try await docRef.getDocument(as: City.self)

print("City: \(city)")

} catch {

print("Error decoding city: \(error)")

}

// [END custom_type]

}

private func listenDocument() {

// [START listen_document]

db.collection("cities").document("SF")

.addSnapshotListener { documentSnapshot, error in

guard let document = documentSnapshot else {

print("Error fetching document: \(error!)")

return

}

guard let data = document.data() else {

print("Document data was empty.")

return

}

print("Current data: \(data)")

}

// [END listen_document]

}

private func listenDocumentLocal() {

// [START listen_document_local]

db.collection("cities").document("SF")

.addSnapshotListener { documentSnapshot, error in

guard let document = documentSnapshot else {

print("Error fetching document: \(error!)")

return

}

let source = document.metadata.hasPendingWrites ? "Local" : "Server"

print("\(source) data: \(document.data() ?? [:])")

}

// [END listen_document_local]

}

private func listenWithMetadata() {

// [START listen_with_metadata]

// Listen to document metadata.

db.collection("cities").document("SF")

.addSnapshotListener(includeMetadataChanges: true) { documentSnapshot, error in

// ...

}

// [END listen_with_metadata]

}

private func getMultiple() async {

// [START get_multiple]

do {

let querySnapshot = try await db.collection("cities").whereField("capital", isEqualTo: true)

.getDocuments()

for document in querySnapshot.documents {

print("\(document.documentID) => \(document.data())")

}

} catch {

print("Error getting documents: \(error)")

}

// [END get_multiple]

}

private func getMultipleAll() async {

// [START get_multiple_all]

do {

let querySnapshot = try await db.collection("cities").getDocuments()

for document in querySnapshot.documents {

print("\(document.documentID) => \(document.data())")

}

} catch {

print("Error getting documents: \(error)")

}

// [END get_multiple_all]

}

private func getMultipleAllSubcollection() async {

// [START get_multiple_all_subcollection]

do {

let querySnapshot = try await db.collection("cities/SF/landmarks").getDocuments()

for document in querySnapshot.documents {

print("\(document.documentID) => \(document.data())")

}

} catch {

print("Error getting documents: \(error)")

}

// [END get_multiple_all_subcollection]

}

private func listenMultiple() {

// [START listen_multiple]

db.collection("cities").whereField("state", isEqualTo: "CA")

.addSnapshotListener { querySnapshot, error in

guard let documents = querySnapshot?.documents else {

print("Error fetching documents: \(error!)")

return

}

let cities = documents.compactMap { $0["name"] }

print("Current cities in CA: \(cities)")

}

// [END listen_multiple]

}

private func listenDiffs() {

// [START listen_diffs]

db.collection("cities").whereField("state", isEqualTo: "CA")

.addSnapshotListener { querySnapshot, error in

guard let snapshot = querySnapshot else {

print("Error fetching snapshots: \(error!)")

return

}

snapshot.documentChanges.forEach { diff in

if (diff.type == .added) {

print("New city: \(diff.document.data())")

}

if (diff.type == .modified) {

print("Modified city: \(diff.document.data())")

}

if (diff.type == .removed) {

print("Removed city: \(diff.document.data())")

}

}

}

// [END listen_diffs]

}

private func listenState() {

// [START listen_state]

db.collection("cities").whereField("state", isEqualTo: "CA")

.addSnapshotListener { querySnapshot, error in

guard let snapshot = querySnapshot else {

print("Error fetching documents: \(error!)")

return

}

snapshot.documentChanges.forEach { diff in

if (diff.type == .added) {

print("New city: \(diff.document.data())")

}

}

if !snapshot.metadata.isFromCache {

print("Synced with server state.")

}

}

// [END listen_state]

}

private func detachListener() {

// [START detach_listener]

let listener = db.collection("cities").addSnapshotListener { querySnapshot, error in

// [START_EXCLUDE]

// [END_EXCLUDE]

}

// ...

// Stop listening to changes

listener.remove()

// [END detach_listener]

}

private func handleListenErrors() {

// [START handle_listen_errors]

db.collection("cities")

.addSnapshotListener { querySnapshot, error in

if let error = error {

print("Error retreiving collection: \(error)")

}

}

// [END handle_listen_errors]

}

// =======================================================================================

// ======== https://firebase.google.com/preview/firestore/client/query-data ==============

// =======================================================================================

private func simpleQueries() {

// [START simple_queries]

// Create a reference to the cities collection

let citiesRef = db.collection("cities")

// Create a query against the collection.

let query = citiesRef.whereField("state", isEqualTo: "CA")

// [END simple_queries]

// [START simple_query_not_equal]

let notEqualQuery = citiesRef.whereField("capital", isNotEqualTo: false)

// [END simple_query_not_equal]

print(query)

}

private func exampleFilters() {

let citiesRef = db.collection("cities")

// [START example_filters]

let stateQuery = citiesRef.whereField("state", isEqualTo: "CA")

let populationQuery = citiesRef.whereField("population", isLessThan: 100000)

let nameQuery = citiesRef.whereField("name", isGreaterThanOrEqualTo: "San Francisco")

// [END example_filters]

}

private func onlyCapitals() {

// [START only_capitals]

let capitalCities = db.collection("cities").whereField("capital", isEqualTo: true)

// [END only_capitals]

print(capitalCities)

}

private func arrayContainsFilter() {

let citiesRef = db.collection("cities")

// [START array_contains_filter]

citiesRef

.whereField("regions", arrayContains: "west_coast")

// [END array_contains_filter]

}

private func chainFilters() {

let citiesRef = db.collection("cities")

// [START chain_filters]

citiesRef

.whereField("state", isEqualTo: "CO")

.whereField("name", isEqualTo: "Denver")

citiesRef

.whereField("state", isEqualTo: "CA")

.whereField("population", isLessThan: 1000000)

// [END chain_filters]

}

private func validRangeFilters() {

let citiesRef = db.collection("cities")

// [START valid_range_filters]

citiesRef

.whereField("state", isGreaterThanOrEqualTo: "CA")

.whereField("state", isLessThanOrEqualTo: "IN")

citiesRef

.whereField("state", isEqualTo: "CA")

.whereField("population", isGreaterThan: 1000000)

// [END valid_range_filters]

}

private func invalidRangeFilters() throws {

let citiesRef = db.collection("cities")

// [START invalid_range_filters]

citiesRef

.whereField("state", isGreaterThanOrEqualTo: "CA")

.whereField("population", isGreaterThan: 1000000)

// [END invalid_range_filters]