Breezejs EntityManager MetadataStore e fetchEntityByKey

Question

Ho un'applicazione SPA (durandaljs), e ho un percorso specifico in cui mappare "id" dell'entità che voglio recuperare.

Il modello è "/ #/todoDetail /: id".

Ad esempio, "/ #/todoDetail/232" o "/ #/todoDetail/19".

Sulla funzione di attivazione di viewmodel, ottengo le informazioni sul percorso in modo da poter prendere l'id. Quindi creo una nuova istanza di breezejs EntityManager per ottenere l'entità con l'id specificato.

Il problema è quando chiamo manager.fetchEntityByKey ("Todos", id), l'EntityManager non ha ancora i metadati dal server, quindi genera un'eccezione "Impossibile trovare un 'Tipo' con il nome: Todos".

Funziona solo se prima eseguo una query sullo store (manager.executeQuery), prima di chiamare fetchEntityByKey.

È un comportamento previsto o un bug? Esiste un modo per auto-correggere i metadati durante l'istanziazione di EntityManager?

nota: Credo che sia difficile utilizzare un EntityManager condiviso nel mio caso, perché voglio consentire all'utente di digitare direttamente il percorso sul browser.

EDIT: Come soluzione temporanea, sto facendo questo:

BreezeService.prototype.get = function (id, callback) { 
    var self = this; 

    function queryFailed(error) { 
     app.showMessage(error.message); 
     callback({}); 
    } 

    /* first checking if metadatastore was already loaded */ 

    if (self.manager.metadataStore.isEmpty()) { 
     return self.manager.fetchMetadata() 
     .then(function (rawMetadata) { 
      return executeQuery(); 
     }).fail(queryFailed); 
    } else { 
     return executeQuery(); 
    } 

    /* Now I can fetch */ 
    function executeQuery() { 
     return self.manager.fetchEntityByKey(self.entityType, id, true) 
         .then(callback) 
         .fail(queryFailed); 
    } 
}; 

Answer 1

Hai imparato a conoscere fetchMetadata. È importante. Se l'applicazione può iniziare senza emettere una query, è necessario utilizzare fetchMetadata e attendere che venga restituita prima di poter eseguire qualsiasi operazione direttamente nella cache (ad esempio, il controllo di un'entità per chiave nella cache prima di tornare a una query di database).

Ma sento qualcos'altro in corso perché hai menzionato più gestori. Di default un nuovo manager non conosce i metadati di nessun altro gestore. Ma lo sapevi che puoi condividere un singolo metadataStore tra i gestori? Puoi.

Quello che faccio spesso (e lo vedrete nei test dei metadati nell'esempio DocCode), è ottenere un metadataStore per l'applicazione, scrivere una funzione di fabbrica EntityManager che crea nuovi gestori con quel metadataStore e quindi utilizzare il fabbrica ogni volta che creo nuovi manager ... come sembra che tu stia facendo quando fai girare un ViewModel per rivedere TodoDetail.

Answer 2

Provenendo da uno sfondo Silverlight in cui ho utilizzato molti servizi RIA WCF combinati con Caliburn Micro, ho utilizzato questo approccio per l'integrazione di Breeze con Durandal.

Ho creato una sottocartella denominata servizi nella cartella App dell'applicazione. In quella cartella ho creato un file javascript chiamato datacontext.js. Qui è un sottoinsieme del mio DataContext:

define(function (require) { 

    var breeze = require('lib/breeze'); // path to breeze 
    var app = require('durandal/app'); // path to durandal 

    breeze.NamingConvention.camelCase.setAsDefault(); 

    // service name is route to the Web API controller 
    var serviceName = 'api/TeamData', 

    // manager is the service gateway and cache holder 
    manager = new breeze.EntityManager(serviceName), 

    store = manager.metadataStore; 

    function queryFailed(error) { 
     app.showMessage("Query failed: " + error.message); 
    } 

    // constructor overrides here 

    // included one example query here 
    return datacontext = { 
     getSponsors: function (queryCompleted) { 
      var query = breeze.EntityQuery.from("Sponsors"); 
      return manager 
       .executeQuery(query) 
       .then(queryCompleted) 
       .fail(queryFailed) 
     } 
    }; 
} 

Poi nei modelli vista Durandal si può semplicemente richiedere i servizi/DataContext.Ad esempio, qui è parte di una vista del modello di esempio dalla mia app:

define(function (require) { 

    var datacontext = require('services/datacontext'); 

    var ctor = function() { 
     this.displayName = 'Sponsors', 
     this.sponsors = ko.observable(false) 
    }; 

    ctor.prototype.activate = function() { 
     var that = this; 
     return datacontext.getSponsors(function (data) { that.sponsors(data.results) }); 
    } 

    return ctor; 
}); 

Questo vi permetterà di non preoccuparsi per l'inizializzazione dei metadati in ogni modello di vista dal momento che è tutto fatto in un unico luogo.