AngularJS Verzögerung (Timeout) jeden http Anruf in einer Schleife

Question

Ich habe ein Array. Während ich durch Array loop, komponiere ich Anfrage und mache http Anrufe. Aber ich möchte, dass jede dieser http PUT-Anforderungen innerhalb von 16 Sekunden Lücke gemacht werden. Ich habe viele Wege ausprobiert. Ich habe versucht, http.then mit $ timeout, $ interval zu Schleife 1 Zeit zu wickeln, Timeout: 16000 zu http config hinzugefügt. Keiner von ihnen verzögert den HTTP-Aufruf. Nur erster Aufruf in der Schleife verzögert. Wie verzögere ich jeden tatsächlichen HTTP-Anruf um 16 Sekunden? Hier ist mein Code. Ich habe Timeout in http Config sowie $ Timeout hinzugefügt. Ich habe es mit einem nach dem anderen versucht. Keine funktioniert

angular.forEach($scope.provisionDataArray, function(provReq, index) { 
     var userProvisionSCIMUrl = someurl; 

     scimProvReq = prepareProvisionRequestJSON(provReq, $scope.refData, $scope.App); 
     var scimReq = { 
     method: 'PUT', 
     url: someurl, 
     headers: { 
      'Content-Type': 'application/json' 
     }, 
     timeout: 16000, 
     data: scimProvReq 
     } 
     $timeout(function() { 
      $http(scimReq).then(function successCallback(response) { 

        var provStatus = {}; 
        provStatus.reqNum = index; 
        provStatus.nbid = response.data.id; 
        provStatus.id = response.data.request.id; 
        provStatus.status = response.data.request.status; 
        provStatus.statusMessage = response.data.request.statusMessage; 
        $scope.provisionStatus.push(provStatus); 

       }, 
       function errorCallback(response) { 
        $scope.errors.push({ 
         error: "Error processing, 
    line: index 
    });     
    }); 
},16000,$scope.provisionDataArray.length) 
} 
}); 

Answer 1

Verwenden einer Rekursionstaktik, Aufruf jeder Anfrage nach dem vorherigen abgeschlossen.

var index = 0 

function recursionRequests() { 
    if (typeof $scope.provisionDataArray[index] == 'undefined') return; // breaking condition when reached our last request 

    var provReq = $scope.provisionDataArray[index]; 

    var userProvisionSCIMUrl = someurl; 

    scimProvReq = prepareProvisionRequestJSON(provReq, $scope.refData, $scope.App); 

    var scimReq = { 
    method: 'PUT', 
    url: someurl, 
    headers: { 
     'Content-Type': 'application/json' 
    }, 
    timeout: 16000, 
    data: scimProvReq 
    } 

    $http(scimReq).then(function successCallback(response) { 
     var provStatus = {}; 
     provStatus.reqNum = index; 
     provStatus.nbid = response.data.id; 
     provStatus.id = response.data.request.id; 
     provStatus.status = response.data.request.status; 
     provStatus.statusMessage = response.data.request.statusMessage; 
     $scope.provisionStatus.push(provStatus); 
    }, 
    function errorCallback(response) { 
     $scope.errors.push({ 
     error: "Error processing", 
     line: index 
     }); 

    }); 

    $timeout(recursionRequests, 16000); 
    index++; 
} 

Update: vergessen haben fast das Timeout XD

Answer 2

Sie so etwas versuchen könnte.

var scimReq = { 
    method: 'PUT', 
    url: someurl, 
    headers: { 
      'Content-Type' : 'application/json' 
    }, 
    timeout: 16000, 
    data: scimProvReq, 
    index: 0 
} 

$scope.doIt = function() { 
    if($scope.provisionDataArray.length > 0){ 
     $timeout(function(){ 
      $http(scimReq).then(function(){ 
       if(scimReq.index !== $scope.provisionDataArray.length){ 
        scimReq.index = scimReq.index + 1; 
        $scope.doIt(); 
       } 
      }); 
     }, scimReq.timeout); 
    } 
} 

$scope.doIt(); 

$ interval führt aus, was in ihm alle X Millisekunden ist. Das Problem mit Ihrem Code ist, dass der einzige Teil innerhalb des Intervalls der $ http-Aufruf ist, so dass er iteriert und $ interval ($ http) für jedes Element sofort aufruft.

Answer 3

Ich löste dies mit unten Code. Wenn ich die Schleife unterbricht, um HTTP-Anrufe zu machen, dachte ich, ich könnte Verzögerung implementieren. Also habe ich mein Array in eine Chunk-Größe von 1 geschnitten und dann eine Zeitüberschreitung hinzugefügt. Wenn ich die Chunk-Größe auf 2 setze, wird die Verzögerung nach zwei Aufrufen hinzugefügt.

var provisionChunks = sliceProvisionArray($scope.provisionDataArray, chunkSize); 
angular.forEach(provisionChunks, function(provReqs, index) { 
    console.log("provReqs ,index ",provReqs + " " + index); 
     angular.forEach(provReqs, function(provReq, index1) { 
      setTimeout(function(x) { 
       return function() { 
        provisionUsers(provReq, index1, provRequestCount);        
       }; 
       }(index), 12000*index); 
      }); 
      }); 

function sliceProvisionArray(arr, chunkSize) { 
    var slicedProvArray = [], i; 
     for (i = 0; i < arr.length; i += chunkSize) { 
      slicedProvArray.push(arr.slice(i, i + chunkSize)); 
     } 
     return slicedProvArray; 
    } 

function provisionUsers(provReq, index, provReqCount) { 
    var userProvisionSCIMUrl = "https://link" 
    var scimProvReq = prepareProvisionRequestJSON(provReq, $scope.referenceData, $scope.virtualApp); 
     var scimReq = makePUTSCIMReq(scimProvReq,userProvisionSCIMUrl); 
     $http(scimReq).then(function successCallback(response) { 

     } 
    }, 
    function errorCallback(response) {              
     }