หน้านี้ได้รับการแปลโดย Cloud Translation API

Switch to English

Cloud Firestore iOS Codelab

1. ภาพรวม

เป้าหมาย

ใน Codelab นี้ คุณจะสร้างแอปแนะนำร้านอาหารที่ได้รับการสนับสนุนจาก Firestore บน iOS ใน Swift คุณจะได้เรียนรู้วิธีการ:

อ่านและเขียนข้อมูลไปยัง Firestore จากแอป iOS
ฟังการเปลี่ยนแปลงในข้อมูล Firestore แบบเรียลไทม์
ใช้ Firebase Authentication และกฎความปลอดภัยเพื่อรักษาความปลอดภัยข้อมูล Firestore
เขียนคำสั่ง Firestore ที่ซับซ้อน

ข้อกำหนดเบื้องต้น

ก่อนเริ่ม Codelab นี้ ตรวจสอบให้แน่ใจว่าคุณได้ติดตั้ง:

Xcode เวอร์ชัน 14.0 (หรือสูงกว่า)
CocoaPods 1.12.0 (หรือสูงกว่า)

2. สร้างโครงการคอนโซล Firebase

เพิ่ม Firebase ในโครงการ

ไปที่ คอนโซล Firebase
เลือก สร้างโครงการใหม่ และตั้งชื่อโครงการของคุณว่า "Firestore iOS Codelab"

3. รับโครงการตัวอย่าง

ดาวน์โหลดรหัส

เริ่มต้นด้วยการโคลน โปรเจ็กต์ตัวอย่าง และเรียกใช้การ pod update ในไดเร็กทอรีโปรเจ็กต์:

git clone https://github.com/firebase/friendlyeats-ios
cd friendlyeats-ios
pod update

เปิด FriendlyEats.xcworkspace ใน Xcode แล้วรัน (Cmd+R) แอปควรคอมไพล์อย่างถูกต้องและหยุดทำงานทันทีเมื่อเปิดใช้ เนื่องจากไม่มีไฟล์ GoogleService-Info.plist เราจะแก้ไขในขั้นตอนต่อไป

ตั้งค่า Firebase

ทำตาม เอกสารประกอบ เพื่อสร้างโครงการ Firestore ใหม่ เมื่อคุณมีโปรเจ็กต์แล้ว ให้ดาวน์โหลดไฟล์ GoogleService-Info.plist ของโปรเจ็กต์จาก คอนโซล Firebase แล้วลากไปที่รูทของโปรเจ็กต์ Xcode เรียกใช้โครงการอีกครั้งเพื่อให้แน่ใจว่าแอปกำหนดค่าอย่างถูกต้องและไม่ขัดข้องเมื่อเปิดตัวอีกต่อไป หลังจากเข้าสู่ระบบแล้ว คุณจะเห็นหน้าจอว่างดังตัวอย่างด้านล่าง หากคุณไม่สามารถเข้าสู่ระบบได้ ตรวจสอบให้แน่ใจว่าคุณได้เปิดใช้งานวิธีการลงชื่อเข้าใช้ด้วยอีเมล/รหัสผ่านในคอนโซล Firebase ภายใต้การรับรองความถูกต้อง

4. เขียนข้อมูลไปยัง Firestore

ในส่วนนี้ เราจะเขียนข้อมูลบางส่วนไปยัง Firestore เพื่อให้เราสามารถเติมข้อมูลใน UI ของแอปได้ ซึ่งสามารถทำได้ด้วยตนเองผ่าน คอนโซล Firebase แต่เราจะทำในแอปเองเพื่อสาธิตการเขียน Firestore ขั้นพื้นฐาน

วัตถุโมเดลหลักในแอปของเราคือร้านอาหาร ข้อมูล Firestore แบ่งออกเป็นเอกสาร คอลเล็กชัน และคอลเล็กชันย่อย เราจะจัดเก็บร้านอาหารแต่ละแห่งเป็นเอกสารในคอลเลกชันระดับบนสุดที่เรียกว่า restaurants หากคุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับโมเดลข้อมูล Firestore โปรดอ่านเกี่ยวกับเอกสารและคอลเล็กชันใน เอกสารประกอบ

ก่อนที่เราจะสามารถเพิ่มข้อมูลไปยัง Firestore ได้ เราต้องได้รับข้อมูลอ้างอิงไปยังคอลเลคชันร้านอาหาร เพิ่มสิ่งต่อไปนี้ในวงในสำหรับวงในเมธอด RestaurantsTableViewController.didTapPopulateButton(_:)

let collection = Firestore.firestore().collection("restaurants")

ตอนนี้เรามีการอ้างอิงการรวบรวมแล้ว เราสามารถเขียนข้อมูลบางอย่างได้ เพิ่มสิ่งต่อไปนี้หลังโค้ดบรรทัดสุดท้ายที่เราเพิ่ม:

let collection = Firestore.firestore().collection("restaurants")

// ====== ADD THIS ======
let restaurant = Restaurant(
  name: name,
  category: category,
  city: city,
  price: price,
  ratingCount: 0,
  averageRating: 0
)

collection.addDocument(data: restaurant.dictionary)

โค้ดด้านบนจะเพิ่มเอกสารใหม่ในคอลเลกชันร้านอาหาร ข้อมูลเอกสารมาจากพจนานุกรมซึ่งเราได้รับจากโครงสร้างร้านอาหาร

เราใกล้จะถึงแล้ว ก่อนที่เราจะเขียนเอกสารไปยัง Firestore ได้ เราต้องเปิดกฎความปลอดภัยของ Firestore และอธิบายว่าส่วนใดของฐานข้อมูลของเราที่ผู้ใช้ควรเขียนได้ สำหรับตอนนี้ เราจะอนุญาตให้เฉพาะผู้ใช้ที่ได้รับการรับรองความถูกต้องเท่านั้นที่สามารถอ่านและเขียนฐานข้อมูลทั้งหมดได้ นี่เป็นการอนุญาตเล็กน้อยเกินไปสำหรับแอปที่ใช้งานจริง แต่ในระหว่างกระบวนการสร้างแอป เราต้องการบางสิ่งที่ผ่อนคลายเพียงพอ เพื่อที่เราจะไม่พบปัญหาการตรวจสอบสิทธิ์อย่างต่อเนื่องในขณะทำการทดลอง ในตอนท้ายของ Codelab นี้ เราจะพูดถึงวิธีทำให้กฎความปลอดภัยของคุณเข้มงวดขึ้นและจำกัดความเป็นไปได้ของการอ่านและเขียนโดยไม่ได้ตั้งใจ

ใน แท็บกฎ ของคอนโซล Firebase ให้เพิ่มกฎต่อไปนี้แล้วคลิก เผยแพร่

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      //
      // WARNING: These rules are insecure! We will replace them with
      // more secure rules later in the codelab
      //
      allow read, write: if request.auth != null;
    }
  }
}

เราจะหารือเกี่ยวกับกฎความปลอดภัยในรายละเอียดในภายหลัง แต่ถ้าคุณรีบ ให้ดูที่ เอกสารกฎความปลอดภัย

เรียกใช้แอปและลงชื่อเข้าใช้ จากนั้นแตะปุ่ม " เติมข้อมูล " ที่ด้านซ้ายบน ซึ่งจะสร้างชุดเอกสารร้านอาหาร แม้ว่าคุณจะยังไม่เห็นสิ่งนี้ในแอปก็ตาม

จากนั้น ไปที่ แท็บข้อมูล Firestore ในคอนโซล Firebase ตอนนี้คุณควรเห็นรายการใหม่ในคอลเลกชันร้านอาหาร:

ภาพหน้าจอ 2017-07-06 เวลา 12.45.38 น.png

ขอแสดงความยินดี คุณเพิ่งเขียนข้อมูลไปยัง Firestore จากแอป iOS! ในส่วนถัดไป คุณจะได้เรียนรู้วิธีดึงข้อมูลจาก Firestore และแสดงในแอป

5. แสดงข้อมูลจาก Firestore

ในส่วนนี้ คุณจะได้เรียนรู้วิธีดึงข้อมูลจาก Firestore และแสดงในแอป ขั้นตอนสำคัญสองขั้นตอนคือการสร้างคิวรีและเพิ่มสแนปช็อตฟัง ผู้ฟังนี้จะได้รับแจ้งข้อมูลที่มีอยู่ทั้งหมดที่ตรงกับข้อความค้นหาและรับการอัปเดตตามเวลาจริง

ขั้นแรก เรามาสร้างแบบสอบถามที่จะให้บริการรายการร้านอาหารเริ่มต้นที่ไม่มีการกรอง ดูการใช้งานของ RestaurantsTableViewController.baseQuery() :

return Firestore.firestore().collection("restaurants").limit(to: 50)

ข้อความค้นหานี้เรียกร้านอาหารจากคอลเลกชันระดับบนสุดที่ชื่อว่า "ร้านอาหาร" ได้สูงสุด 50 ร้าน ตอนนี้เรามีคำถามแล้ว เราต้องแนบสแนปช็อตฟังเพื่อโหลดข้อมูลจาก Firestore ลงในแอปของเรา เพิ่มโค้ดต่อไปนี้ในเมธอด RestaurantsTableViewController.observeQuery() หลังการเรียก stopObserving()

listener = query.addSnapshotListener { [unowned self] (snapshot, error) in
  guard let snapshot = snapshot else {
    print("Error fetching snapshot results: \(error!)")
    return
  }
  let models = snapshot.documents.map { (document) -> Restaurant in
    if let model = Restaurant(dictionary: document.data()) {
      return model
    } else {
      // Don't use fatalError here in a real app.
      fatalError("Unable to initialize type \(Restaurant.self) with dictionary \(document.data())")
    }
  }
  self.restaurants = models
  self.documents = snapshot.documents

  if self.documents.count > 0 {
    self.tableView.backgroundView = nil
  } else {
    self.tableView.backgroundView = self.backgroundView
  }

  self.tableView.reloadData()
}

โค้ดด้านบนดาวน์โหลดคอลเล็กชันจาก Firestore และจัดเก็บไว้ในอาร์เรย์ในเครื่อง การเรียก addSnapshotListener(_:) จะเพิ่มสแน็ปช็อตฟังให้กับแบบสอบถามที่จะอัปเดตตัวควบคุมมุมมองทุกครั้งที่มีการเปลี่ยนแปลงข้อมูลบนเซิร์ฟเวอร์ เราได้รับการอัปเดตโดยอัตโนมัติและไม่ต้องพุชการเปลี่ยนแปลงด้วยตนเอง โปรดจำไว้ว่าฟังสแน็ปช็อตนี้สามารถเรียกใช้ได้ทุกเมื่อเนื่องจากการเปลี่ยนแปลงฝั่งเซิร์ฟเวอร์ ดังนั้นแอปของเราจึงต้องจัดการกับการเปลี่ยนแปลงจึงเป็นเรื่องสำคัญ

หลังจากแมปพจนานุกรมของเรากับโครงสร้าง (ดูที่ Restaurant.swift ) การแสดงข้อมูลเป็นเพียงเรื่องของการกำหนดพร็อพเพอร์ตี้บางรายการเท่านั้น เพิ่มบรรทัดต่อไปนี้ใน RestaurantTableViewCell.populate(restaurant:) ใน RestaurantsTableViewController.swift

nameLabel.text = restaurant.name
cityLabel.text = restaurant.city
categoryLabel.text = restaurant.category
starsView.rating = Int(restaurant.averageRating.rounded())
priceLabel.text = priceString(from: restaurant.price)

เมธอดเติมข้อมูลนี้ถูกเรียกจากเมธอด tableView(_:cellForRowAtIndexPath:) ของแหล่งข้อมูลมุมมองตาราง ซึ่งจะดูแลการแมปคอลเลกชันของประเภทค่าจากก่อนหน้าไปยังเซลล์มุมมองตารางแต่ละเซลล์

เรียกใช้แอปอีกครั้งและตรวจสอบว่าร้านอาหารที่เราเห็นก่อนหน้านี้ในคอนโซลสามารถมองเห็นได้บนเครื่องจำลองหรืออุปกรณ์ หากคุณดำเนินการส่วนนี้สำเร็จ แอปของคุณกำลังอ่านและเขียนข้อมูลด้วย Cloud Firestore!

6. การเรียงลำดับและการกรองข้อมูล

ขณะนี้แอปของเราแสดงรายชื่อร้านอาหาร แต่ผู้ใช้ไม่สามารถกรองตามความต้องการได้ ในส่วนนี้ คุณจะใช้การสอบถามขั้นสูงของ Firestore เพื่อเปิดใช้งานการกรอง

ต่อไปนี้คือตัวอย่างข้อความค้นหาง่ายๆ เพื่อดึงร้านติ่มซำทั้งหมด:

let filteredQuery = query.whereField("category", isEqualTo: "Dim Sum")

ตามชื่อของมัน เมธอด whereField(_:isEqualTo:) จะทำให้การค้นหาของเราดาวน์โหลดเฉพาะสมาชิกของคอลเลกชันที่มีฟิลด์ตรงตามข้อจำกัดที่เราตั้งไว้ ในกรณีนี้ จะดาวน์โหลดเฉพาะร้านอาหารที่มี category เป็น "Dim Sum"

ในแอปนี้ ผู้ใช้สามารถเชื่อมโยงตัวกรองหลายตัวเข้าด้วยกันเพื่อสร้างข้อความค้นหาเฉพาะ เช่น "พิซซ่าในซานฟรานซิสโก" หรือ "อาหารทะเลในลอสแองเจลิสที่สั่งตามความนิยม"

เปิด RestaurantsTableViewController.swift และเพิ่มบล็อกโค้ดต่อไปนี้ที่ตรงกลางของ query(withCategory:city:price:sortBy:) :

if let category = category, !category.isEmpty {
  filtered = filtered.whereField("category", isEqualTo: category)
}

if let city = city, !city.isEmpty {
  filtered = filtered.whereField("city", isEqualTo: city)
}

if let price = price {
  filtered = filtered.whereField("price", isEqualTo: price)
}

if let sortBy = sortBy, !sortBy.isEmpty {
  filtered = filtered.order(by: sortBy)
}

ข้อมูลโค้ดด้านบนเพิ่มคำสั่ง whereField และ order หลายรายการเพื่อสร้างข้อความค้นหาแบบผสมเดียวตามข้อมูลที่ผู้ใช้ป้อน ขณะนี้ข้อความค้นหาของเราจะส่งคืนเฉพาะร้านอาหารที่ตรงกับความต้องการของผู้ใช้เท่านั้น

ดำเนินโครงการของคุณและตรวจสอบว่าคุณสามารถกรองตามราคา เมือง และหมวดหมู่ (อย่าลืมพิมพ์ชื่อหมวดหมู่และเมืองให้ตรงกันทุกประการ) ขณะทดสอบ คุณอาจพบข้อผิดพลาดในบันทึกที่มีลักษณะดังนี้:

Error fetching snapshot results: Error Domain=io.grpc Code=9 
"The query requires an index. You can create it here: https://console.firebase.google.com/project/project-id/database/firestore/indexes?create_composite=..." 
UserInfo={NSLocalizedDescription=The query requires an index. You can create it here: https://console.firebase.google.com/project/project-id/database/firestore/indexes?create_composite=...}

นี่เป็นเพราะ Firestore ต้องการดัชนีสำหรับข้อความค้นหาแบบผสมส่วนใหญ่ การกำหนดดัชนีในการสืบค้นทำให้ Firestore รวดเร็วตามขนาด การเปิดลิงก์จากข้อความแสดงข้อผิดพลาดจะเปิด UI การสร้างดัชนีโดยอัตโนมัติในคอนโซล Firebase โดยกรอกพารามิเตอร์ที่ถูกต้อง หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับดัชนีใน Firestore โปรดไปที่เอกสารประกอบ

7. การเขียนข้อมูลในการทำธุรกรรม

ในส่วนนี้ เราจะเพิ่มความสามารถให้ผู้ใช้สามารถส่งรีวิวไปยังร้านอาหารได้ จนถึงตอนนี้ งานเขียนทั้งหมดของเราเป็นแบบปรมาณูและค่อนข้างเรียบง่าย หากมีข้อผิดพลาดเกิดขึ้น เราน่าจะแจ้งให้ผู้ใช้ลองอีกครั้งหรือลองใหม่โดยอัตโนมัติ

ในการเพิ่มคะแนนให้กับร้านอาหาร เราจำเป็นต้องประสานการอ่านและเขียนหลายๆ ก่อนอื่นต้องส่งบทวิจารณ์ จากนั้นจึงจำเป็นต้องอัปเดตจำนวนคะแนนของร้านอาหารและคะแนนเฉลี่ย หากข้อใดข้อหนึ่งล้มเหลวแต่อีกข้อหนึ่งล้มเหลว เราจะอยู่ในสถานะที่ไม่สอดคล้องกันโดยที่ข้อมูลในส่วนหนึ่งของฐานข้อมูลไม่ตรงกับข้อมูลในอีกส่วนหนึ่ง

โชคดีที่ Firestore มีฟังก์ชันธุรกรรมที่ช่วยให้เราทำการอ่านและเขียนได้หลายครั้งในการดำเนินการแบบอะตอมเดียว เพื่อให้มั่นใจว่าข้อมูลของเรายังคงสอดคล้องกัน

เพิ่มโค้ดต่อไปนี้ด้านล่างการประกาศให้ทั้งหมดใน RestaurantDetailViewController.reviewController(_:didSubmitFormWithReview:)

let firestore = Firestore.firestore()
firestore.runTransaction({ (transaction, errorPointer) -> Any? in

  // Read data from Firestore inside the transaction, so we don't accidentally
  // update using stale client data. Error if we're unable to read here.
  let restaurantSnapshot: DocumentSnapshot
  do {
    try restaurantSnapshot = transaction.getDocument(reference)
  } catch let error as NSError {
    errorPointer?.pointee = error
    return nil
  }

  // Error if the restaurant data in Firestore has somehow changed or is malformed.
  guard let data = restaurantSnapshot.data(),
        let restaurant = Restaurant(dictionary: data) else {

    let error = NSError(domain: "FireEatsErrorDomain", code: 0, userInfo: [
      NSLocalizedDescriptionKey: "Unable to write to restaurant at Firestore path: \(reference.path)"
    ])
    errorPointer?.pointee = error
    return nil
  }

  // Update the restaurant's rating and rating count and post the new review at the 
  // same time.
  let newAverage = (Float(restaurant.ratingCount) * restaurant.averageRating + Float(review.rating))
      / Float(restaurant.ratingCount + 1)

  transaction.setData(review.dictionary, forDocument: newReviewReference)
  transaction.updateData([
    "numRatings": restaurant.ratingCount + 1,
    "avgRating": newAverage
  ], forDocument: reference)
  return nil
}) { (object, error) in
  if let error = error {
    print(error)
  } else {
    // Pop the review controller on success
    if self.navigationController?.topViewController?.isKind(of: NewReviewViewController.self) ?? false {
      self.navigationController?.popViewController(animated: true)
    }
  }
}

ภายในบล็อกการอัปเดต การดำเนินการทั้งหมดที่เราดำเนินการโดยใช้ออบเจกต์ธุรกรรมจะถือว่าเป็นการอัปเดตปรมาณูเดียวโดย Firestore หากการอัปเดตบนเซิร์ฟเวอร์ล้มเหลว Firestore จะลองอีกครั้งโดยอัตโนมัติสองสามครั้ง ซึ่งหมายความว่าเงื่อนไขข้อผิดพลาดของเรามักจะเป็นข้อผิดพลาดเดียวที่เกิดขึ้นซ้ำๆ เช่น หากอุปกรณ์ออฟไลน์โดยสมบูรณ์ หรือผู้ใช้ไม่ได้รับอนุญาตให้เขียนไปยังเส้นทางที่ผู้ใช้พยายามเขียนถึง

8. กฎความปลอดภัย

ผู้ใช้แอปของเราไม่ควรอ่านและเขียนข้อมูลทุกชิ้นในฐานข้อมูลของเรา ตัวอย่างเช่น ทุกคนควรสามารถดูการให้คะแนนของร้านอาหารได้ แต่ควรอนุญาตให้เฉพาะผู้ใช้ที่ผ่านการตรวจสอบสิทธิ์เท่านั้นที่โพสต์การให้คะแนนได้ การเขียนโค้ดที่ดีในไคลเอ็นต์นั้นไม่เพียงพอ เราจำเป็นต้องระบุโมเดลความปลอดภัยของข้อมูลของเราบนแบ็กเอนด์เพื่อความปลอดภัยอย่างสมบูรณ์ ในส่วนนี้ เราจะเรียนรู้วิธีใช้กฎความปลอดภัยของ Firebase เพื่อปกป้องข้อมูลของเรา

ก่อนอื่น มาดูกฎความปลอดภัยที่เราเขียนไว้ตอนเริ่มต้นของ Codelab ให้ละเอียดยิ่งขึ้น เปิดคอนโซล Firebase และไปที่ ฐานข้อมูล > กฎในแท็บ Firestore

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /{document=**} {
      // Only authenticated users can read or write data
      allow read, write: if request.auth != null;
    }
  }
}

ตัวแปร request ในกฎด้านบนเป็นตัวแปรส่วนกลางที่มีอยู่ในกฎทั้งหมด และเงื่อนไขที่เราเพิ่มเข้าไปทำให้มั่นใจว่าคำขอนั้นได้รับการรับรองความถูกต้องก่อนที่จะอนุญาตให้ผู้ใช้ดำเนินการใดๆ วิธีนี้จะป้องกันไม่ให้ผู้ใช้ที่ไม่ได้รับอนุญาตใช้ Firestore API เพื่อทำการเปลี่ยนแปลงข้อมูลของคุณโดยไม่ได้รับอนุญาต นี่เป็นการเริ่มต้นที่ดี แต่เราสามารถใช้กฎของ Firestore เพื่อทำสิ่งที่มีประสิทธิภาพมากขึ้นได้

มาจำกัดการเขียนรีวิวเพื่อให้ ID ผู้ใช้ของรีวิวต้องตรงกับ ID ของผู้ใช้ที่ผ่านการรับรองความถูกต้อง สิ่งนี้ทำให้มั่นใจได้ว่าผู้ใช้ไม่สามารถแอบอ้างเป็นกันและกันและแสดงความคิดเห็นที่เป็นการฉ้อโกงได้ แทนที่กฎความปลอดภัยของคุณด้วยสิ่งต่อไปนี้:

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /restaurants/{any}/ratings/{rating} {
      // Users can only write ratings with their user ID
      allow read;
      allow write: if request.auth != null 
                   && request.auth.uid == request.resource.data.userId;
    }
  
    match /restaurants/{any} {
      // Only authenticated users can read or write data
      allow read, write: if request.auth != null;
    }
  }
}

คำสั่งการจับคู่แรกจะตรงกับคอลเลกชันย่อยที่ชื่อ ratings ของเอกสารใดๆ ที่เป็นของคอลเลกชัน restaurants เงื่อนไข allow write จะป้องกันไม่ให้มีการส่งรีวิวใดๆ หาก ID ผู้ใช้ของรีวิวไม่ตรงกับของผู้ใช้ คำสั่งการจับคู่ที่สองช่วยให้ผู้ใช้ที่ผ่านการรับรองความถูกต้องสามารถอ่านและเขียนร้านอาหารลงในฐานข้อมูลได้

วิธีนี้ใช้ได้ผลดีกับรีวิวของเรา เนื่องจากเราใช้กฎความปลอดภัยเพื่อระบุการรับประกันโดยปริยายที่เราเขียนลงในแอปของเราก่อนหน้านี้อย่างชัดแจ้ง นั่นคือผู้ใช้สามารถเขียนรีวิวของตนเองได้เท่านั้น หากเราต้องเพิ่มฟังก์ชันแก้ไขหรือลบสำหรับรีวิว กฎชุดเดียวกันนี้จะป้องกันไม่ให้ผู้ใช้แก้ไขหรือลบรีวิวของผู้ใช้รายอื่นด้วย แต่กฎของ Firestore ยังสามารถนำมาใช้ในรูปแบบที่ละเอียดยิ่งขึ้นเพื่อจำกัดการเขียนในแต่ละฟิลด์ภายในเอกสารแทนที่จะเป็นเอกสารทั้งหมด เราสามารถใช้ข้อมูลนี้เพื่อให้ผู้ใช้อัปเดตเฉพาะคะแนน คะแนนเฉลี่ย และจำนวนคะแนนสำหรับร้านอาหาร โดยลบความเป็นไปได้ที่ผู้ใช้ที่ประสงค์ร้ายจะเปลี่ยนชื่อร้านอาหารหรือสถานที่ตั้ง

rules_version = '2';
service cloud.firestore {
  match /databases/{database}/documents {
    match /restaurants/{restaurant} {
      match /ratings/{rating} {
        allow read: if request.auth != null;
        allow write: if request.auth != null 
                     && request.auth.uid == request.resource.data.userId;
      }
    
      allow read: if request.auth != null;
      allow create: if request.auth != null;
      allow update: if request.auth != null
                    && request.resource.data.name == resource.data.name
                    && request.resource.data.city == resource.data.city
                    && request.resource.data.price == resource.data.price
                    && request.resource.data.category == resource.data.category;
    }
  }
}

ที่นี่เราได้แบ่งสิทธิ์ในการเขียนของเราเป็นการสร้างและอัปเดต เพื่อให้เราสามารถเจาะจงมากขึ้นว่าการดำเนินการใดควรได้รับอนุญาต ผู้ใช้ทุกคนสามารถเขียนร้านอาหารลงในฐานข้อมูล โดยคงฟังก์ชันการทำงานของปุ่มเติมข้อมูลที่เราสร้างไว้ตอนเริ่มต้นของ Codelab แต่เมื่อร้านอาหารถูกเขียนชื่อ ที่ตั้ง ราคา และหมวดหมู่แล้ว จะไม่สามารถเปลี่ยนแปลงได้ โดยเฉพาะอย่างยิ่ง กฎข้อสุดท้ายกำหนดให้การดำเนินการอัปเดตร้านอาหารเพื่อรักษาชื่อ เมือง ราคา และหมวดหมู่ของฟิลด์ที่มีอยู่แล้วในฐานข้อมูล

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับสิ่งที่คุณทำได้ด้วยกฎความปลอดภัย โปรดดูที่ เอกสารประกอบ

9. บทสรุป

ใน Codelab นี้ คุณได้เรียนรู้วิธีการอ่านและเขียนขั้นพื้นฐานและขั้นสูงด้วย Firestore รวมถึงวิธีรักษาความปลอดภัยการเข้าถึงข้อมูลด้วยกฎความปลอดภัย คุณสามารถค้นหาโซลูชันทั้งหมดได้ที่ สาขา codelab-complete

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ Firestore โปรดไปที่แหล่งข้อมูลต่อไปนี้: