Ai-je besoin d'un aller-retour supplémentaire vers Firestore pour lire les champs d'horodatage créés et mis à jour ?

Lorsque vous utilisez Firestore, vous vous demandez peut-être si des allers-retours supplémentaires sont nécessaires pour lire les champs d'horodatage créés et mis à jour. La réponse est non. Firestore fournit automatiquement des horodatages de création et de mise à jour pour chaque document, et vous pouvez obtenir les informations temporelles correspondantes en référençant ces champs. De cette façon, vous n'avez pas besoin d'opérations supplémentaires pour lire le champ d'horodatage et vous pouvez obtenir plus facilement l'heure de création et de mise à jour du document. Cette conception rend le processus de développement plus efficace et simplifié, évitant ainsi le code et les requêtes inutiles.

Contenu des questions

1. D'accord, me voici go 中有一个 rest api ，它使用 firestore 存储 ticket Ressources. Pour cela j'utilise : firestore go client

2. Je veux pouvoir trier mes documents par date 创建/更新日期 donc selon le document, je stocke ces 2 champs comme horodatages dans le document.

3. J'utilise l'étiquette servertimestamp sur les deux champs. En faisant cela, la valeur devrait être le temps nécessaire au serveur Firestore pour traiter la demande.

4. La réponse http pour l'opération de mise à jour doit contenir le corps suivant :

{
 "ticket": {
   "id": "af41766e-76ea-43b5-86c1-8ba382edd4dc",
   "title": "ticket updated title",
   "price": 9,
   "date_created": "2023-01-06 09:07:24",
   "date_updated": "2023-01-06 10:08:24"
 }
}

Cela signifie qu'après avoir mis à jour le document du ticket, rien d'autre que la valeur du champ title 或 price 之外，我还需要更新 date_updated mis à jour.

Cela fonctionne actuellement, mais je suis curieux de savoir si la façon dont je code est la bonne façon de le faire. Comme vous pouvez le voir dans l'exemple de code, j'utilise une transaction pour mettre à jour le ticket. Je ne trouve pas de moyen de récupérer la valeur mise à jour du champ dateupdated autre que de relire le ticket mis à jour.

Les entités de domaine sont définies comme suit :

package tixer

import (
    "context"
    "time"

    "github.com/google/uuid"
)

type (

    // ticketid represents a unique identifier for a ticket.
    // it's a domain type.
    ticketid uuid.uuid

    // ticket represents an individual ticket in the system.
    // it's a domain type.
    ticket struct {
        id          ticketid
        title       string
        price       float64
        datecreated time.time
        dateupdated time.time
    }

)

Je joindrai ici la communication avec Firestore du point de vue de la création et de la mise à jour :

// Storer persists tickets in Firestore.
type Storer struct {
    client *firestore.Client
}

func NewStorer(client *firestore.Client) *Storer {
    return &Storer{client}
}

func (s *Storer) CreateTicket(ctx context.Context, ticket *tixer.Ticket) error {
    writeRes, err := s.client.Collection("tickets").Doc(ticket.ID.String()).Set(ctx, createTicket{
        Title: ticket.Title,
        Price: ticket.Price,
    })

    // In this case writeRes.UpdateTime is the time the document was created.
    ticket.DateCreated = writeRes.UpdateTime

    return err
}

func (s *Storer) UpdateTicket(ctx context.Context, ticket *tixer.Ticket) error {
    docRef := s.client.Collection("tickets").Doc(ticket.ID.String())
    err := s.client.RunTransaction(ctx, func(ctx context.Context, tx *firestore.Transaction) error {
        doc, err := tx.Get(docRef)
        if err != nil {
            switch {
            case status.Code(err) == codes.NotFound:
                return tixer.ErrTicketNotFound
            default:
                return err
            }
        }
        var t persistedTicket
        if err := doc.DataTo(&t); err != nil {
            return err
        }
        t.ID = doc.Ref.ID

        if ticket.Title != "" {
            t.Title = ticket.Title
        }
        if ticket.Price != 0 {
            t.Price = ticket.Price
        }

        return tx.Set(docRef, updateTicket{
            Title:       t.Title,
            Price:       t.Price,
            DateCreated: t.DateCreated,
        })
    })
    if err != nil {
        return err
    }

    updatedTicket, err := s.readTicket(ctx, ticket.ID)
    if err != nil {
        return err
    }
    *ticket = updatedTicket

    return nil
}

func (s *Storer) readTicket(ctx context.Context, id tixer.TicketID) (tixer.Ticket, error) {
    doc, err := s.client.Collection("tickets").Doc(id.String()).Get(ctx)
    if err != nil {
        switch {
        case status.Code(err) == codes.NotFound:
            return tixer.Ticket{}, tixer.ErrTicketNotFound
        default:
            return tixer.Ticket{}, err
        }
    }

    var t persistedTicket
    if err := doc.DataTo(&t); err != nil {
        return tixer.Ticket{}, err
    }
    t.ID = doc.Ref.ID

    return toDomainTicket(t), nil
}

type (
    // persistedTicket represents a stored ticket in Firestore.
    persistedTicket struct {
        ID          string    `firestore:"id"`
        Title       string    `firestore:"title"`
        Price       float64   `firestore:"price"`
        DateCreated time.Time `firestore:"dateCreated"`
        DateUpdated time.Time `firestore:"dateUpdate"`
    }

    // createTicket contains the data needed to create a Ticket in Firestore.
    createTicket struct {
        Title       string    `firestore:"title"`
        Price       float64   `firestore:"price"`
        DateCreated time.Time `firestore:"dateCreated,serverTimestamp"`
        DateUpdated time.Time `firestore:"dateUpdate,serverTimestamp"`
    }
    // updateTicket contains the data needed to update a Ticket in Firestore.
    updateTicket struct {
        Title       string    `firestore:"title"`
        Price       float64   `firestore:"price"`
        DateCreated time.Time `firestore:"dateCreated"`
        DateUpdated time.Time `firestore:"dateUpdate,serverTimestamp"`
    }
)

func toDomainTicket(t persistedTicket) tixer.Ticket {
    return tixer.Ticket{
        ID:          tixer.TicketID(uuid.MustParse(t.ID)),
        Title:       t.Title,
        Price:       t.Price,
        DateCreated: t.DateCreated,
        DateUpdated: t.DateUpdated,
    }
}

Solution de contournement

Si je comprends bien, le champ DateUpdated est un horodatage côté serveur, ce qui signifie que sa valeur est déterminée par le serveur lorsqu'il écrit la valeur dans la couche de stockage (ce qu'on appelle la transformation de champ). Étant donné qu'une opération d'écriture dans le SDK Firestore ne renvoie pas les données de résultat de l'opération, le seul moyen de récupérer cette valeur dans l'application est en fait d'effectuer une opération de lecture supplémentaire après l'écriture pour l'obtenir.

Le SDK n'effectuera pas automatiquement cette lecture car il s'agit d'une opération payante et n'est pas nécessaire dans de nombreux cas. Ainsi, en demandant à votre code d'effectuer cette lecture, vous pouvez décider d'engager ou non ce coût.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!