Dovrei emulare '. $ Promessa' oggetti?

Question

Sto lavorando su un'app ad amministratore con angolari. L'app recupera i suoi dati dal server utilizzando $ risorsa. Finisco con gli oggetti di dati contenenti proprietà "$ Promise" per determinare quando i dati sono stati recuperati. Tutto va bene.

Ora, questa app admin può anche creare nuovi oggetti. Questi nuovi oggetti sono gestiti dagli stessi controller di quello che di solito provengono da "$ risorsa".

Allora ora ho 2 tipi di oggetti:

.
• oggetti con $ Promise Property. Dovrei usare $ Promise.then () Prima di manipolareli con i dati completi
• oggetti semplici. Non hanno una proprietà promessa $, il loro valore è accessibile all'istante

Vorrei ridurre il codice e avere un singolo caso uso, non dover controllare se i dati dell'oggetto vengono risolti, o se non è una promessa.

C'è qualche problema nella costruzione dei miei oggetti "semplici" aggiungendo loro una proprietà "$ Promise" che è già stata risolta da sé? In questo modo, userei sempre "MyObject $ Promise.then () '.

C'è qualche modello comune per gestire questa situazione? Non sono riuscito a trovare alcun metodo 'standard' per creare questo tipo di oggetti con angolare.

Answer 1

È possibile utilizzare $ Q.Quals se non è sicuro se il l'oggetto ha una promessa o no.

(obj.$promise ? obj.$promise || $q.when(objResult)).then(function(result){
          //handle success case.
          //Incase of object not having the $promise property result will be object itself
}) 

.

Se la proprietà risultante non ha una promessa, questo si risolverà con la promessa.

.

avvolge un oggetto che potrebbe essere un valore o una (terza parte) promessa quindi in una promessa $ Q. Questo è utile quando si ha a che fare con un oggetto che potrebbe o non potrebbe essere una promessa, o se la promessa proviene da una fonte che non può essere fidata.

Non è necessario creare sempre una promessa e allegarla sui dati che vengono trasferiti, invece è possibile effettuare i tuoi metodi che restituisce la promessa aiutandoti a implementare il modello di promessa e astrarre la logica della promessa sul tuo servizio stesso. Esempio: -

   function getCurrentUserData(userId){
       var defered = $q.defer();
       ... 
       //Check in my cache if this is already there, then get it from cache and resolve it
       defered.resolve(objectFromCache);
      //my else condition
      //It is not in cache so let me make the call.
      $http.get('myurl').then(function(result){
            //Do validation with data and if it doesnot match then reject it
            defered.reject(reason);
             //Else Do something with the data put it into the cache, mapping logic etc..
             defered.resolve(dto);


      }).catch(function(error){
            //do something with error and then reject
            defered.reject(reasonDerived);
      });
      return defered.promise;
   }

.

Ecco una versione semplificata e meno esplicita (Credito: Benjamin Gruenbaum):

var cached = null;
function getCurrentUserData(userId){
    return cached = cached || $http.get('myurl').then(function(result){
        if(isNotValid(result)) return $q.reject(reason); // alternatively `throw`
        return transformToDto(result);
    }, function(response){
     if(checkforsomethingonstatusandreject)
       return $q.reject('Errored Out')
     //do some actions to notify the error scenarios and return default actions
     return someDefaults; });
    }

.

Puoi ovviamente return $q.reject(derivedReason) qui piuttosto che restituire il motivo e trasformarlo in base a ulteriori controlli, l'idea sta memorizzando nella cache la promessa piuttosto che il valore. Ciò ha anche il vantaggio di non effettuare più richieste HTTP se il metodo viene chiamato prima che ritorni una volta.

Ora potresti sempre fare: -

    getCurrentUserData(userid).then(function(user){

    }).catch(function(error){

    });

.

Le promesse possono essere incatenate anche. Quindi potresti anche farlo: -

   return $resource('myresource').$promise.then(function(result){
          //Do some mapping and return mapped data
         return mappedResult;
    });

.

Answer 2

A + promesse dovrebbe offrire un metodo statico:

Promise.resolve(val);

.

... che genera una promessa pre-risolta.Dovresti restituire uno di questi se la tua libreria promessa offre questo.Grande.Lo faccio frequentemente per evitare la duplicazione dell'interfaccia.