Obsluga dwóch Promise w 1 metodzie

Hej, mam sobie taki program, ktory sklada zamowienia. Mam sobie metode zlozZamowienie ktora wsio robi w Promise.all:

let res;
        try{
            res = await Promise.all(promises.map(p => p.catch(e => e))).then((result) => {
                this.serverResponseHanler.handleResult(result);
                return result;
            }).catch((err) => {
                console.log("err w promiseall " + err);
                //utils.logWithTime('err w promise.all: ' + err);
            });
        }catch(e)
        {
            console.log("error!!!!!!!! " + e);
        }

        return res;

Tyle ze chcialbym wywolywac metode zmienZamowienie. Owa metoda robi tak na prawde 2 rzeczy -> cancelluje 1 zamowienie i sklada nastepne poprawione.
Moglbym zrobic cos takiego ze await na cancell i jesli sie powiedzie, skladam 2gie zamowienie. Jednak chcialbym zeby bylo to zrobione bez czekania jedno na 2gie.
Wymyslilem sobie taka metode:

    async changeExist(obj)
    {
        let cancelResult = this.cancelSingleOrder(obj).then(function(res){ // <<< nie wywoluje sie then z jakiegos powodu
            console.log("dfgdfg");
        })
        
        //if(cancelResult.result[0].result == "OK")
        //{
            
            let order;
            try{
                 order = this.placeOrder(obj);
            }catch(e)
            {
                order = {error: e, obj: obj, action: "changeExistError", from: "changeExtistTrade"};
            }
        //}else
        //{
        //    return {error: cancelResult.error, obj: obj, action: "changeExistTradeCancelerror"};
        //}

//PSEUDO KOD nizej
        if(order)
        {
            let s = cancelResult[PromiseStatus];
            let p = cancelResult.PromiseValue;
            console.log(order);
        }

    }


    async cancelSingleOrder(obj, callback)
    {
                let result = await new Promise( (resolve, reject) => {
                    this.placeOrder(String(obj.orderId), function(res, id){//id), function(res){
                        if(res && !res.hasOwnProperty("error"))
                        {
                            if( callback instanceof Function && callback !== null)
                            {
                                callback(obj, res);
                            }
                            resolve(res, id);
                        }
                        else
                        {
                            reject({error: {error: {message: "unstandard error"}}, obj: obj, action: "cancelOrder"});
                        }

                })});


    }

Czemu let cancelResult = this.cancelSingleOrder(obj).then(function(res){
then sie nie wywoluje.
Mysle ze najlepiej to zrobic w stylu:

PSEUDOKOD

changeOrder(){
     let isCancelledResponse = false;
    let isNewOrder = false;
     let cancelResult = this.cancel(obj).then( res => {
              isCancelledResponse  = true;
              if(isNewOrder)
              {
                        //tutaj wiem jaki jest wynik skladania orderu i cancelowania wiem jaki jest wynik cancellowania, moge odpowiednio zadzialac.
               }
   }.catch(e)
  {
       return {mojJakisError}
  }

  let newOrder = this.placeOrder(obj).then(val => {
        isNewOrder = true;
        f(isCancelledResponse )
              {
                        //tutaj wiem jaki jest wynik cancellowania oraz nowego orderu i moge odpowiednio zadzialac
               }
 }catch(e)
{
    return {mojJakisError};
}

}

Tylko cos te then nie dzialaja, gdzie tu jest blad?

Twój kod jest niesamowicie zagmatwany - w jego interpretacji nie pomaga fakt, że arbitralnie mieszasz async z callbackami.

Do "obsługi dwóch promisów" wystarczy Promise.all() - dlaczego go nie wykorzystasz?

Fakt, jakas zacme mialem :)