Aquí podría ser tu PUBLICIDAD


Cómo optimizar Firestore operación de lectura / escritura

votos
0

Trato de hacer el monitoreo de la aplicación donde los usuarios pueden hacer Alertque el cambio de precio.

Tengo Stockdocumento en el que voy a buscar a partir API tercera parte periódicamente. Tras la Stockactualización voy a buscar todo Alertlo que se cumple la condición y notificar a los usuarios con la mensajería Firebase.

Aquí es mis modelos.

/stocks/{stockId}
id: String
price: Number

/alerts/{alertId}
stockId: String
price: Number
condition: [moreThan, lessThan]
uid: String // User who create alert

/users/{userId}
id: String
fcmToken: String

Cada 5 minutos me traen últimas acciones precio y actualización de la acción = documento de number of stockconsulta de escritura.

function updateStockPrice(): Promise<FirebaseFirestore.WriteResult[]> {
  const db = admin.firestore();

  const options = {
    // Options for stock api
  };

  return client(options)
  .then(function(body) {
    let batch = db.batch()

    for(var stock in body){
      let data = // create data from json response
      let docRef = db.collection(stocks).doc(//id from 3rd party api)
      batch.set(docRef, data)
    }

    return batch.commit()
  });
}

En la actualización de la escritura, de bucle a través de alertas a buscar simbólico FCM de usuario relacionados con envían notificaciones push = ( alert query+ number of alerts matched condition for user query) xnumber of stock update

export const onStocksUpdate = functions.firestore.document('stocks/{stockId}').onWrite(function(change, context) {

  const db = admin.firestore()

  const newValue = change.after.data();
  const previousValue = change.before.data();

  const stockId = Number(context.params.stockId)

  let p1 = db.collection(alerts)
      .where(stockId, ==, stockId)
      .where(condition, ==, moreThan) 
      .where(price, <=, newValue.lastPrice)
      .get()
      .then(function(querySnapshot) {
        const promises = []
        querySnapshot.forEach(function(doc) {

          let data = doc.data()
          let user = db.collection(users).doc(data.uid).get()

          user.then(function(snapshot) {
            let userData = snapshot.data()

            return userData.fcmToken
          }).then(function(fcmToken) {
            const payload = {
              notification: {
                title: // title,
                body: // body
              },
              token: fcmToken
            }

            return admin.messaging().send(payload)
          }).catch(function(error) {
            console.log(error)
          })

          promises.push(user)
        })

        return Promise.all(promises)
      }).then((response) => {
        // Response is a message ID string.
        console.log('Successfully sent message:', response);
      })
      .catch((error) => {
        console.log('Error sending message:', error);
      });

      return p1
})

Total = escritura number of stock de lectura total = ( alert query+ number of alerts matched condition for user query) xnumber of stock update

Decir que tengo 20 acciones, 1 usuario con 3 alertas.

Cada 5 minutos I utilizarán 20 consulta de escritura y (1 + 3) x 20 = 80 de lectura

En 1 día = 5760 de escritura y lectura 23.040

Esto parece demasiado operaciones para una pequeña ejemplos tales. ¿Es este el camino correcto que debería diseñar la estructura de datos? ¿O hay una mejor manera de hacer esto?

Publicado el 03/06/2018 a las 02:13
fuente por usuario sarunw

Aquí podría ser tu PUBLICIDAD





Aquí
podría
ser
tu

PUBLICIDAD