Explaining how promises work and addressing any confusion:

When you write:

$scope.results = getResults(value.id);

This assigns the return value of getResults to the $scope.results variable. Now, let's examine your getResults function.

 var getResults = function(id) {
    api.getHistoryData(id)
        .then(function (results) {
            return results.data;
    });
 };

A few key points to note:

1. The getResults function does not have a return statement, meaning nothing is returned from getResults for assignment to $scope.results.
2. The getResults function makes an asynchronous request, so execution and response retrieval happen at different times.
3. The return statement lies within a function inside getResults, not directly in getResults itself.
4. If it worked as expected, the value of $scope.results would be overwritten on every server response, likely undesirable behavior.

To address this, consider adjusting the getResults function like so:

angular.forEach($scope.orderHistory, function(value) {
    console.log('1 - Get results for ', value.id);
    getResults(value.id);    
});
 var getResults = function(id) {
    console.log('2 - GetResults called');
    api.getHistoryData(id)
        .then(function (results) {
            console.log('3 - Get results has data');
            return results.data;
    });
 };

In code above, 1 and 2 console.logs occur first, followed by all 3's at a later point due to JavaScript's asynchronous nature. This demonstrates the need to leverage Promises in AngularJS for handling asynchronous events across functions.

Rework your code using Promises:

angular.forEach($scope.orderHistory, function(value) {
    getResults(value.id).then(function(results) {
        $scope.results[value.id] = results.data;
    });    
});
 var getResults = function(id) {
    return api.getHistoryData(id);
 };

This modification returns a promise from getResults and updates $scope.results when the promise resolves. Clarifying the process. Hope this helps!

It seems to me that the promise is not being utilized correctly:

$scope.orderHistory = {};
$scope.results = {};

var obtainHistory = function (max,offset)
 {
    //perform some operations
    $scope.orderHistory = data.entities;

    angular.forEach($scope.orderHistory,function(value)
    {
        // getResults function returns a promise
        // we utilize the promise to update $scope.results
        acquireResults(value.id).then(function(results){
            $scope.results = results.data;
        });      
    });

 }

 // acquireResults function returns a promise
 var acquireResults = function(id)
 {
    return api.fetchData(id);
 };

The value of $scope.results will only change once the promise has been resolved.

Furthermore, in its current form, $scope.results will be replaced for each value.id. If this is not the intended behavior, consider transforming it into an array and using push to add each new value.

It is important to clarify that the variables orderHistory and results are objects, not arrays. While using the angular.forEach function allows iteration over both arrays and object properties, it does not mean that the object being iterated is an array. Elad's point about the results variable being overwritten with each iteration is indeed correct.

If you intend to maintain all the results from the getResults function, it is necessary to initialize results as an array. To ensure that your view accurately reflects the results, push them directly into your scope variable from the asynchronous result.

$scope.orderHistory = {};
$scope.results = [];

var getHistoryData = function(max, offset) {
    // perform actions
    $scope.orderHistory = data.entities;

    angular.forEach($scope.orderHistory, function(value) {
        getResults(value.id);
    });
}

var getResults = function(id) {
    api.getHistoryData(id)
        .then(function(results) {
            $scope.results.push(results);
        });
};

please update the getResults function by incorporating a return statement

var getResults = function(newId)
 {
    return api.fetchData(newId)
        .then ( function (response)
        {
            return response.data;
        });
 };

Below are 2 key points to note. First and foremost, the getResults function does not actually return anything; it simply processes a chain of promises. To rectify this, we can modify getResults to return a promise that will eventually yield a result:

var getResults = function(id)
 {
    return api.getHistoryData(id)
        .then ( function (results)
        {
            return results.data;
        });
 };

Secondly, starting from Angular version 1.2 (although the exact version is uncertain), Angular no longer automatically resolves promises, necessitating manual resolution:

angular.forEach($scope.orderHistory,function(value)
{
    getResults(value.id).then(function(results){
       $scope.results = results;
       console.log($scope.results);
   })
});

The complete code snippet is as follows:

$scope.orderHistory = {};
$scope.results = {};
var getHistory = function (max,offset)
 {
    //perform necessary operations
    $scope.orderHistory = data.entities;
    angular.forEach($scope.orderHistory,function(value)
    {
        getResults(value.id).then(function(results){
           $scope.results = results;
           console.log($scope.results);
       })     
    });
 }
 // returns a promise
 var getResults = function(id)
 {
   return api.getHistoryData(id)
        .then ( function (results)
        {
            return results.data;
        });
 };