Comment correctement chaîner des promesses conditionnelles (?) Avec Q.js

J'ai pas encore tout à fait arrivés à une compréhension complète de promesses alors, toutes mes excuses si c'est un simple malentendu.

J'ai une fonction pour la suppression d'un élément sur une page mais j'ai un comportement spécifique en fonction de l'état de la page. Pseudo code-sage, il est quelque chose comme ceci:

Does the page have changes?
    If yes - prompt to save changes first
         If yes - save changes
         If no - exit function
    If no - continue
Prompt to confirm delete
    If yes - delete item and reload data
    If no - exit function

J'espère que ça a du sens. Essentiellement, si il y a des changements, les données doivent être enregistrées en premier. Ensuite, si les données ont été enregistrées, ou s'il n'y avait pas de changements pour commencer, invite l'utilisateur à confirmer la suppression. Le problème est que je suis en utilisant durandal et la brise, et je n'arrive pas à enchaîner les promesses qu'ils reviennent ensemble correctement.

Ma fonction ressemble actuellement, ce que je sais, c'est mal, mais j'ai du mal à résoudre.

if (this.hasChanges()) {
    app.showMessage('Changes must be saved before removing external accounts.  Would you like to save your changes now?', 'Unsaved Changes...', ['Yes', 'No'])
        .then(function (selectedOption) {
             if (selectedOption === 'Yes') {
                 return this.save();
             } else {
                 Q.resolve()
             }
         });
}
app.showMessage('Are you sure you want to delete this item?', 'Delete?', ['Yes', 'No'])
    .then(function (selectedOption) {
        if (selectedOption === 'Yes') {
            item.entityAspect.setDeleted();
            datacontext.saveChanges()
                .then(function () {
                    logger.logNotificationInfo('Item deleted.', '', router.activeInstruction().config.moduleId);
                    Q.resolve(this.refresh(true));
                }.bind(this));
            }
       }.bind(this));

L'application.showMessage appel de durandal retourne une promesse, alors la ce.enregistrer retourne une promesse, et, enfin, de la ce.actualiser renvoie également une promesse.

Donc je suppose que j'ai besoin de vérifier la hasChanges, puis, si nécessaire, appeler la méthode save, et de le résoudre.
Puis, après que la condition de la section a fini de se résoudre, à l'appel de la deuxième invite de commandes, puis résoudre toutes les promesses.

Je suis désolé, je ne pense pas que ce soit super clair, mais je pense que venant du fait que je ne suis pas complètement à la suite de la chaînes ici.

Toute aide appréciée! Merci.

source d'informationauteur Adam

  1. 11

    Kris est correct. Vous n'aurez pas besoin de le Q. résoudre des appels.

    Btw, le retour d'une promesse avec la valeur résolue true ou false est dénuée de sens dans votre situation. J'ai peur, vous êtes sous l'impression erronée que le retour false permettrait d'éviter l'enchaînement then() d'être appelé. Pas si! Résolue promesse d'une valeur de false est toujours une bonne promesse ... comme on le voit dans le code suivant, qui déclenche la boîte de message d'alerte:

    Q(false) //same as Q.resolve(false)
 .then(function () { alert('resolve(false) triggered then()') })

    Si vous voulez mettre la même promesse, dans un état d'échec (et vous n'avez pas de soins sur la valeur de l'erreur), vous devez retourner Q.reject().

    Je ne sais pas ce this est dans votre code, mais ça va être rien, mais la peine que vous exécutez l'intérieur des fonctions. Capture dans une variable afin que vous ne soyez pas perdu et de la lutte avec compensation bind(this) logique.

    Je ne suis pas entièrement sûr de ce que vous essayez de faire. Il semble que vous ne procédera pas à la suppression d'un point, tandis qu'il y a des modifications non enregistrées. Vous pourrez enregistrer les modifications non enregistrées si l'utilisateur de l'Oxus. Alors vous allez demander à l'utilisateur de confirmer la suppression. Si l'utilisateur refuse d'enregistrer les modifications en attente, vous ne devriez pas même de commencer le processus de suppression.

    Si je comprends bien, je pense que vous voulez quelque chose comme ceci:

    var self = this; //WHAT IS THIS? I don't know but capture it as 'self'

function saveBeforeDeleting() {
  return saveIfNeeded().then(deleteIfConfirmed);
}

function saveIfNeeded() {
  //no need to save; return resolved promise
  if (!self.hasChanges()) return Q();

  var dialogPromise = app.showMessage(
    'Changes must be saved before removing external accounts. '+
    'Would you like to save your changes now?', 
    'Unsaved Changes...', ['Yes', 'No']
  );

  //When the user replies, either save or return a rejected promise
  //(which stops the flow)
  return dialogPromise.then(function (selectedOption) {
    return (selectedOption === 'Yes') ? self.save() : Q.reject();
  });
}

function deleteIfConfirmed() {
  var dialogPromise = app.showMessage(
    'Are you sure you want to delete this item?', 
    'Delete?',
    ['Yes', 'No']
  );

  return dialogPromise.then(function (selectedOption) {
    return (selectedOption === 'Yes') ? deleteIt() : Q.reject();
  });

  function deleteIt() {
     item.entityAspect.setDeleted();
     return datacontext.saveChanges().then(logAndRefresh);
  }

  function logAndRefresh() {
     logger.logNotificationInfo(
       'Item deleted.',
       '', 
       router.activeInstruction().config.moduleId
     );
     return self.refresh(true));
  }
}

    Évidemment, je n'ai pas testé ce code. Pensez à elle comme source d'inspiration.

  2. 7

    Si vous jetez une erreur dans une promesse, le processus va passer directement à la première .fail/.gestionnaire catch en ignorant tout .thens() entre les deux. 

    function AbortError() {}

MyClass.prototype.delete = function() {
    var p = Q();
    var self = this;
    if( this.hasChanges() ) {
        p = app.showMessage('...', '...', ['Yes', 'No'])
        .then(function(answer){
            if( answer === "Yes") {
                return self.save(); //I assume save returns a promise
            }
            throw new AbortError();
        });
    }
    return p
    .then(function() {
        return app.showMessage('...', '...', ['Yes', 'No'])
    })
    .then(function(answer) {
        if( answer === "yes") {
            item.entityAspect.setDeleted();
            return datacontext.saveChanges();
        }
        throw new AbortError();
    })
    .then(function(){
        logger.logNotificationInfo('Item deleted.', '', router.activeInstruction().config.moduleId);
        self.refresh(true);
    })
    .fail(function(e){
        //kris please provide typed .catch feature :(
        if( !(e instanceof AbortError) ) {
            throw e;
        }
    });
};
  3. 2

    En général, vous souhaitez créer des fonctions pour effectuer votre travail qui retournent TOUJOURS une promesse, même si c'est un résolue immédiatement, c'est à dire "retour Q. résoudre(someData)".

    Donc je voudrais essayer quelque chose comme ce qui suit. Note le "retour" des déclarations ci-dessous. 

    function complexSave() {
   return saveIfNeeded().then(confirmDelete);
}

//returns a promise
function saveIfNeeded() {
  if (this.hasChanges()) {
    return app.showMessage('Changes must be saved before removing external accounts.  Would you like    to  save your changes now?', 'Unsaved Changes...', ['Yes', 'No']).
      then(function (selectedOption) {
         if (selectedOption === 'Yes') {
             return this.save();
         } else {
             return Q.resolve(false)
         }
     });
  else {
    return Q.resolve(false);
  }
}

//returns a promise
function confirmDelete() {
  return app.showMessage('Are you sure you want to delete this item?', 'Delete?', ['Yes', 'No'])
    .then(function (selectedOption) {
       if (selectedOption === 'Yes') {
          item.entityAspect.setDeleted();
          return datacontext.saveChanges()
            .then(function () {
                logger.logNotificationInfo('Item deleted.', '', router.activeInstruction().config.moduleId);
                return Q.resolve(this.refresh(true));
            }.bind(this));
        } else {
          return Q.resolve(false);
        }
   }.bind(this));
}