How to use the async.forEachSeries function in async

// Setup ODM
if ( config.odm && config.odm.enabled ) {
  mongoose.connect(config.mongoose.uri);
}

// Run our model injection service
modelInjector( models );

var seedData = require('./../schema/seedData.json');

var assocMap = {};
Object.keys(seedData).forEach(function( modelName ) {
    assocMap[modelName] = [];
});

async.forEachSeries(
    Object.keys(seedData),
    function forEachModelType( modelName, cb ) {
        var ModelType = models.ORM[modelName]
            , Models = seedData[modelName];

        async.forEachSeries(
            Models,
            function forEachModel( data, modelCb ) {
                var assocs = data.associations;
                delete data.associations;

                ModelType.create(data).success(function( model ) {
                    data.associations = assocs;

                    console.log('Created ' + modelName);
                    assocMap[modelName].push(model);

return;
  }

  var cmethods=[] ,dmethods=[], cnames=[], dnames=[];
  for(var key in conditions) {
    if(typeof key !== 'string' || typeof conditions[key] !== 'function') {
      logger.error('transaction conditions parameter is error format, condition name: %s, condition function: %j.', key, conditions[key]);
      return;
    }
    cnames.push(key);
    cmethods.push(conditions[key]);
  }

  var i = 0;
  // execute conditions
  async.forEachSeries(cmethods, function(method, cb) {
    method(cb);
    transactionLogger.info('[%s]:[%s] condition is executed.', name, cnames[i]);
    i++;
  }, function(err) {
    if(err) {
      process.nextTick(function() {
        transactionLogger.error('[%s]:[%s] condition is executed with err: %j.', name, cnames[--i], err.stack);
        var log = {
          name: name,
          method: cnames[i],
          time: Date.now(),
          type: 'condition',
          description: err.stack
        };
        transactionErrorLogger.error(JSON.stringify(log));
      });

console.log()
            callback.apply(null, arguments)
          }
      )
    }

  , focusKey = Object.keys(tests).filter(function (k) { return (/\=>/).test(k) })

if (focusKey.length) {
  var focusTest = tests[focusKey[0]]
  tests = {}
  tests[focusKey[0]] = focusTest
}

require('colors')
async.forEachSeries(Object.keys(tests), runTest)

function hint() {
	var hint = require('jshint').JSHINT,
		hintOpts = config.hint === true ? null : config.hint;

	async.forEachSeries(files, function(file, callback) {
		var hinted = hint(file.content, hintOpts);

		if (!hinted) {
			if (hint.errors[hint.errors.length - 1] === null) {
				console.error(clc.red('JSHint encountered a fatal error in ' + file.path));
				process.exit(1);
			}

			console.warn(clc.yellow('JSHint found ' + hint.errors.length + ' problem(s) with ' + file.path + '.'));

			async.forEachSeries(hint.errors, function(error, cb) {
				console.warn('	' + error.line + '.' + error.character + ': ' + error.reason);
				cb();
			}, function() {
				callback();
			});

if (help.isLocalPath(source)) {
    configPath = path.join(source, 'config.json');
    if (fsExt.existsSync(configPath)) {
      config = eval('(' + fs.readFileSync(configPath) + ')');
      mergeConfig(project, config);
    } else {
      console.log(errMsg);
    }
    callback();
  } else {
    var sourceUrls = [source];
    var root = project.root;
    if (root && root !== '#') {
      sourceUrls.unshift(source + '/' + root);
    }
    async.forEachSeries(sourceUrls, function(sourceUrl, callback) {
      mergeSourceConfig(sourceUrl, callback);
    }, function(err) {
      callback();
    });
  }
};

function processIds(ids, outdir, doneCallback) {
  shell.mkdir('-p', outdir);
  var aggregatedStats = {};
  async.forEachSeries(ids, function (id, callback) {
    var mInfo = assetsDb.getAssetInfo(argv.source + '.' + id);
    var loadInfo = assetManager.getLoadModelInfo(argv.source, id, mInfo);
    assetManager.getModelInstanceFromLoadModelInfo(loadInfo, function (mInst) {
      segments.init(mInst);
      mInst.model.info.annId = loadInfo.annId;
      segments.loadSegments(function (err, res) {
        if (!err) {
          var filename = outdir + '/' + id + '.anns.json';
          cleanAnnotations(loadInfo, filename, segments, aggregatedStats);
        }
        setTimeout(function () {
          callback();
        }, 0);
      });
    });
  }, function (err, results) {

}
            catch (e) {
                currentArgs.unshift(e);
                applyHook(l, "_postFail", currentArgs);
                return q.reject(e);
            }

        }).then(function() {
            return results;
        });
    }

    //remove callback
    args.pop();

    return async.forEachSeries(this._listeners, function(l, next) {
        var currentArgs = args.slice(0);
        currentArgs.push(next);
        l.fn.apply(l.context, currentArgs);

    }, arguments[arguments.length - 1]);
};

missing.push(u);
                } else {
                    imagesInfo.push(iiFromUuid[u]);
                }
            });
            if (missing.length) {
                callback(new errors.UsageError(
                    'no install image with the given UUID(s): '
                    + missing.join(', ')));
                return;
            }
        } else {
            imagesInfo = ii;
        }

        async.forEachSeries(
            imagesInfo,
            updateImage,
            function (err) {
                if (err) {
                    callback(err);
                } else if (updateErrs.length === 1) {
                    callback(updateErrs[0]);
                } else if (updateErrs.length > 1) {
                    callback(new errors.MultiError(updateErrs));
                } else {
                    callback();
                }
            });
    });

function forEachAsset(assets, callback, finishedCallback) {
	async.forEachSeries(Object.keys(assets), function(extensionName, nextGroup) {
		var extensionAssets = assets[extensionName];
		async.forEachSeries(Object.keys(extensionAssets), function(groupName, nextAssetType) {
			var group = extensionAssets[groupName];
			async.forEachSeries(group, function(asset, nextAsset) {
				callback({
					extensionAssets : extensionAssets,
					extensionName : extensionName,
					group : group,
					groupName : groupName,
					asset : asset
				}, nextAsset);
			}, function(err) { nextAssetType(err); });
		}, function(err) { nextGroup(err); });
	}, function(err) { finishedCallback(err); });
}