(res, callback) => {
        // In order to call the callback after we are done, we have to use a counter
        var counter = res.length;
        var markOneAsProcessed = () => { if (--counter == 0) callback(); };

        // For each person
        for (var i = 0; i < res.length; i++) {
            var p = res[i];

            // If Person is customer
            if (p.isCustomer) {
                async.waterfall([
                    // Read customer details for person
                    callback => database.collection("Customer", callback),
                    (custColl, callback) => custColl.findOne({ id: p.customerId }, callback),

                    // Print person and customer details
                    (cust, callback) => { console.log(`John ${cust.lastName} works for ${cust.customerName}.`); callback(); },
                ], (err, result) => markOneAsProcessed());
            } else {
                async.waterfall([
                    // Read supplier details for person
                    callback => database.collection("Supplier", callback),
                    (supplColl, callback) => supplColl.findOne({ id: p.supplierId }, callback),

                    // Print person and supplier details
                    (suppl, callback) => { console.log(`John ${suppl.lastName} works for ${suppl.customerName}.`); callback(); },
                ], (err, result) => markOneAsProcessed());
            }
        }
    }

			fs.exists(dir, (exists:bool) => {
				if (!exists) return callback('path does not exists: ' + dir, null);

				async.waterfall([
					(callback:AsyncCallback) => {
						return fs.stat(dir, callback);
					},
					(stats, callback:AsyncCallback) => {
						if (!stats.isDirectory()) {
							return callback('path is not a directory: ' + dir, null);
						}
						return fs.readdir(dir, callback);
					},
					(files:string[], callback:AsyncCallback) => {
						//check each file
						async.forEach(files, (file:string, callback:AsyncCallback) => {
							var full = path.join(dir, file);
							fs.stat(full, (err, stats)=> {
								if (err) return callback(err, null);
								if (stats.isFile()) {
									return fs.unlink(full, callback);
								}
								return callback(null, null);
							})
						}, callback);
					}
				], callback);
			});

    gatherFicInfos(completedCallback: AsyncResultCallback<any, any>) : void
    {
        var self = this;
        Async.waterfall([
            function (callback: typedef.Callback) 
            {
                var id = self.findId();
                if (!id)
                    return callback("Couldn't find fic ID.");

                callback(null);
            },
            function (callback: typedef.Callback) 
            {
                self.getPageSourceCode(0, callback);
            },
            function (body: string, callback: typedef.Callback) 
            {
                if (self.isValidFic(body)) 
                {
                    var infos = self.findFicInfos(body);
                    callback(null)
                }
                else
                    callback("Invalid fic URL.");
            }
        ], completedCallback);
    }

function proveAndSend(program:any, server:Server, block:any, issuer:any, difficulty:any, done:any) {
  const logger = server.logger;
  async.waterfall([
    function (next:any) {
      block.issuer = issuer;
      program.show && console.log(block.getRawSigned());
      (async () => {
        try {
          const host:string = program.submitHost
          const port:string = program.submitPort
          const trialLevel = isNaN(difficulty) ? await server.getBcContext().getIssuerPersonalizedDifficulty(server.PeeringService.selfPubkey) : difficulty
          const prover = new BlockProver(server);
          const proven = await prover.prove(block, trialLevel);
          if (program.submitLocal) {
            await server.writeBlock(proven)
            next()
          } else {
            const peer = PeerDTO.fromJSONObject({
              endpoints: [['BASIC_MERKLED_API', host, port].join(' ')]
            });
            program.show && console.log(proven.getRawSigned());
            logger.info('Posted block ' + proven.getRawSigned());
            const p = PeerDTO.fromJSONObject(peer);
            const contact = new Contacter(p.getHostPreferDNS(), p.getPort());
            await contact.postBlock(proven.getRawSigned());
            next()
          }
        } catch(e) {
          next(e);
        }
      })()
    }
  ], done);
}

    breakupFile(filepath, final_callback) {
        async.waterfall([
            (callback) => {
                let command = OS_BATCH_RUN_PREFIX + ' pdftk ' + filepath + ' dump_data';
                logging.info('Running external command: ' + command);
                child_process.exec(command, function (err, stdout, stderr) {
                    if (err || !stdout)
                        return callback(err || stderr);
                    let pageCount = parseInt(/NumberOfPages: (\d+)/.exec(stdout)[1]);
                    if (!pageCount) return callback('Error reading number of pages');
                    callback(null, pageCount);
                });
            },
            (pageCount, callback) => {
                let output = BURST_FOLDER + duid.getDUID(1)[0] + '_page_%02d.pdf';
                mkdirp.sync(BURST_FOLDER); //this folder is periodically removed

                let command = OS_BATCH_RUN_PREFIX + ' pdftk ' + filepath + ' burst output ' + output;
                logging.info('Running external command: ' + command);
                child_process.exec(command, (err, stdout, stderr)=> {
                    if (err)
                        return callback(err || stderr);

                    let files = [];
                    let i = 1;
                    while (i <= pageCount) {
                        let no = ('0' + (i++).toString()).slice(-2);
                        files.push(output.replace('%02d', no));
                    }
                    callback(null, files);
                });
            }], final_callback);
    }

function compileAndDeploy(filename: string, callback: Function) {
  let web3: Web3 = new Web3()
  web3.setProvider(new Provider())
  let compilationData: object
  let accounts: string[]
  async.waterfall([
    function getAccountList(next: Function): void {
      web3.eth.getAccounts((_err: Error | null | undefined, _accounts: string[]) => {
        accounts = _accounts
        next(_err)
      })
    },
    function compile(next: Function): void {
      compileFileOrFiles(filename, false, { accounts }, next)
    },
    function deployAllContracts(compilationResult: object, next: Function): void {
      try {
        compilationData = compilationResult
        deployAll(compilationResult, web3, next)
      } catch (e) {
        throw e
      }
    }
  ], function (_err: Error | null | undefined, contracts: any): void {
    callback(null, compilationData, contracts, accounts)
  })
}

 private openRecentOrderAux2(final_callback, tx, cookie, orders) {
     var data = new Object as any;
     async.waterfall([
         (callback) => {
             let result = _.last(orders);
             result = result.entity;
             data.placeid = result.key.path[1].name;
             data.tab = Util.fromProtoEntity(result.properties);
             app.business.find(data.placeid, {}, callback, tx);
         },
         (business, callback) => {
             data.business = business;
             app.orderArticle.fetchByCookieId(cookie, data.placeid, callback, tx);
         },
         (result, queryinfo, callback) => {
             this.fetchAllOrderArticles(result, data, callback);
         },
         (results, callback) => {
             this.populateArticlesOrRemoveIfEmpty(cookie, results, data, (err, result) => {
                 if (!err && !result)
                     this.openRecentOrderAux2(callback, tx, cookie, orders);
                 else
                     callback(err, result);
             });
         }
     ], final_callback);
 }

     .exec((err, user) => {
     if (err) return next(err);
     if (!user) return next({ message: 'Invalid user' });
     if (user) {
         async.waterfall([
             function(cb) {
                 crypto.randomBytes(5, (err, buf) => {
                     let token = buf.toString('hex');
                     cb(err, token);
                 });
             }, function(token, cb) {
                 user.resetPasswordToken = token;
                 user.resetPasswordDate = Date.now() + 3600000;
                 user.save((err) => {
                   if(err) return next(err);
                     cb(err, token, user);
                 });
             }, function(token, user: app.i.IUser, cb) {
                 let mailOptions = {
                     from: 'Folio Team <[email protected]>',
                     to: user.email,
                     subject: 'Folio Password Reset',
                     html: 'Hey ' + user.name + ',<br><br>' + 'We heard you forgot your password.<br><br>' + 'Click on the link below to reset<br>' + 'https://ccfolio.herokuapp.com/resetPassword/' + token + '<br><br>' + 'If you did not request a reset, please ignore this email. Your password will not be reset.<br><br>' + 'Have a great day!<br><br>' + 'xo,<br>' + 'The Folio Team'
                 };
                 transporter.sendMail(mailOptions, (err) => {
                   if(err) return next(err);
                     return res.redirect('/');
                 })
             }], function(err) {
                 if (err) return next(err);
                 return res.redirect('/');
             })
     }
 });

            return new Promise<any>((resolve: Function, reject: Function) => {

                // start the pre and then run the rest of the wrapped
                waterfall([constant.apply(undefined, args)].concat(f.stack.pre), (err: Error, ...args: Array<any>) => {

                    // if error is made
                    if (err) {
                        return reject(err);
                    }

                    // apply the new arguments and get actor results
                    applyEach(f.stack.actor, args, (err: Error, result: Array<any>) => {

                        // if error is made
                        if (err) {
                            return reject(err);
                        }

                        // push result into args
                        args.push(result);

                        // start the post hooks and return values
                        waterfall([constant.apply(undefined, args)].concat(f.stack.post), (err: Error, ...results: Array<any>) => {

                            // if error is made
                            if (err) {
                                return reject(err);
                            }

                            // return the actual result as the last elemnt of the array
                            resolve(results[results.length - 1]);
                        });
                    });
                });
            });

export function kongPostApi(apiConfig: KongApi, callback: Callback<KongApi>): void {
    debug('kongPostApi()');
    const { service, route } = wicked.kongApiToServiceRoute(apiConfig);
    let persistedService: KongService = null;
    let persistedRoute: KongRoute = null;
    async.waterfall([
        callback => kongPostService(service, callback),
        (s: KongService, callback) => {
            persistedService = s;
            route.service = {
                id: s.id
            }
            kongPostRoute(route, callback);
        },
        (r: KongRoute, callback) => {
            persistedRoute = r;
            return callback(null);
        }
    ], (err) => {
        if (err)
            return callback(err);
        return callback(null, wicked.kongServiceRouteToApi(persistedService, persistedRoute));
    })
    //kongPost('apis', apiConfig, callback);
}

export function download(params:any, userIdKey: string, callback: type.Callback) {
    function validate(params:any) {
        var checks = [];
        if (!params) checks.push('Parameter is required.');
        if (params && !params.fileId) checks.push('FileID is required.');
        if (checks.length > 0) {
            callback.onFailure(new error.InvalidParamsError(checks, null));
            return false;
        }
        return true;
    }
    if (!validate(params)) return;

    var con = new db.Database();

    var caseDAO = new model_assurance_case.AssuranceCaseDAO(con);
    async.waterfall([
        (next) => {
            caseDAO.get(params.fileId, (err: any, acase: model_assurance_case.AssuranceCase) => next(err, acase));
        }],
        (err:any, result: model_assurance_case.AssuranceCase) => {
            con.close();
            if (err) {
                callback.onFailure(err);
                return;
            }
        callback.onSuccess({content: result.data});
    });

}

 pow: function (conf:ConfDTO, done:any) {
   async.waterfall([
     function (next:any){
       simpleInteger("Start computation of a new block if none received since (seconds)", "powDelay", conf, next);
     }
   ], done);
 }

        function (req: restify.Request, res: restify.Response, next: restify.Next) {
            if (!isShallowSubset(req.body, user_schema.properties))
                return res.json(400, {
                        error: 'ValidationError',
                        error_message: 'Invalid keys detected in body'
                    }) && next();
            else if (!req.body || !Object.keys(req.body).length)
                return res.json(400, {error: 'ValidationError', error_message: 'Body required'}) && next();

            const User: waterline.Query = collections['user_tbl'];

            async.waterfall([
                cb => User.findOne({email: req['user_id']},
                    (err: waterline.WLError, user: IUser) => {
                        if (err) cb(err);
                        else if (!user) cb(new NotFoundError('User'));
                        return cb(err, user)
                    }),
                (user, cb) =>
                    User.update(user, req.body, (e, r: IUser) => cb(e, r[0]))
            ], (error, result) => {
                if (error) return next(fmtError(error));
                res.json(200, result);
                return next()
            });
        }

 (recipient, next) => {
   async.waterfall(
     [
       (next) => {
         this._getDataForTemplate(notification, recipient, next);
       },
       (data, next) => {
         async.map(
           ['plain', 'html'],
           (type, next) => {
             this._loadTemplate(emailType, recipient, '.' + type, (
               err,
               template
             ) => {
               if (err && type == 'html') return next();
               if (err) return next(err);
               this._applyTemplate(template, data, (err, res) => {
                 return next(err, [type, res]);
               });
             });
           },
           (err, res: any) => {
             return next(err, _.fromPairs(res.filter(Boolean)));
           }
         );
       },
       (result, next) => {
         next(null, result);
       }
     ],
     (err, res) => {
       next(err, [recipient.language, res]);
     }
   );
 },

  fs.readFile(fileName, 'utf-8', (err, data) => {
    if (err) {
      dialog.showErrorBox('File reading error', err.message);
      return;
    }

    const config = JSON.parse(data);
    const brokenFileActions = [];

    if (config.length) {
      config.forEach(configItem => {
        normalizeModelToOpen(configItem.model, currentDir, brokenFileActions);
      });

      async.waterfall(brokenFileActions, () => {
        const newConfig = getConfigWithoutAbandonedData(config);

        if (!_.isEmpty(newConfig)) {
          sender.send('do-open-all-completed', newConfig);
        }

        setTimeout(() => {
          sender.send('check-tab-by-default');
        }, 500);
      });
    }

    if (!config.length) {
      normalizeModelToOpen(config, currentDir, brokenFileActions);

      async.waterfall(brokenFileActions, () => {
        const newConfigAsArray = getConfigWithoutAbandonedData(config);

        if (!_.isEmpty(newConfigAsArray)) {
          const newConfig = _.head(newConfigAsArray);

          if (!_.isEmpty(newConfig)) {
            sender.send('do-open-completed', {tab: newConfig, file: fileNameOnly});
          }
        }

        setTimeout(() => {
          sender.send('check-tab-by-default');
        }, 500);
      });
    }
  });

export let postForgot = (req: Request, res: Response, next: NextFunction) => {
  req.assert("email", "Please enter a valid email address.").isEmail();
  req.sanitize("email").normalizeEmail({ gmail_remove_dots: false });

  const errors = req.validationErrors();

  if (errors) {
    req.flash("errors", errors);
    return res.redirect("/forgot");
  }

  async.waterfall([
    function createRandomToken(done: Function) {
      crypto.randomBytes(16, (err, buf) => {
        const token = buf.toString("hex");
        done(err, token);
      });
    },
    function setRandomToken(token: AuthToken, done: Function) {
      User.findOne({ email: req.body.email }, (err, user: any) => {
        if (err) { return done(err); }
        if (!user) {
          req.flash("errors", { msg: "Account with that email address does not exist." });
          return res.redirect("/forgot");
        }
        user.passwordResetToken = token;
        user.passwordResetExpires = Date.now() + 3600000; // 1 hour
        user.save((err: WriteError) => {
          done(err, token, user);
        });
      });
    },
    function sendForgotPasswordEmail(token: AuthToken, user: UserModel, done: Function) {
      const transporter = nodemailer.createTransport({
        service: "SendGrid",
        auth: {
          user: process.env.SENDGRID_USER,
          pass: process.env.SENDGRID_PASSWORD
        }
      });
      const mailOptions = {
        to: user.email,
        from: "[email protected]",
        subject: "Reset your password on Hackathon Starter",
        text: `You are receiving this email because you (or someone else) have requested the reset of the password for your account.\n\n
          Please click on the following link, or paste this into your browser to complete the process:\n\n
          http://${req.headers.host}/reset/${token}\n\n
          If you did not request this, please ignore this email and your password will remain unchanged.\n`
      };
      transporter.sendMail(mailOptions, (err) => {
        req.flash("info", { msg: `An e-mail has been sent to ${user.email} with further instructions.` });
        done(err);
      });
    }
  ], (err) => {
    if (err) { return next(err); }
    res.redirect("/forgot");
  });
};

export function compileFileOrFiles(filename: string, isDirectory: boolean, opts: any, cb: Function) {
    let compiler: any
    let accounts = opts.accounts || []
    const sources = {
        'tests.sol': { content: require('../sol/tests.sol.js') },
        'remix_tests.sol': { content: require('../sol/tests.sol.js') },
        'remix_accounts.sol': { content: writeTestAccountsContract(accounts) }
    }
    const filepath = (isDirectory ? filename : path.dirname(filename))
    // TODO: for now assumes filepath dir contains all tests, later all this
    // should be replaced with remix's & browser solidity compiler code

    // This logic is wrong
    // We should only look into current file if a full file name with path is given
    // We should only walk through directory if a directory name is passed
    try {
        // walkSync only if it is a directory
        fs.walkSync(filepath, (foundpath: string) => {
            // only process .sol files
            if (foundpath.split('.').pop() === 'sol') {
                let c = fs.readFileSync(foundpath).toString()
                const s = /^(import)\s['"](remix_tests.sol|tests.sol)['"];/gm
                let includeTestLibs = '\nimport \'remix_tests.sol\';\n'
                if (foundpath.indexOf('_test.sol') > 0 && regexIndexOf(c, s) < 0) {
                    c = includeTestLibs.concat(c)
                }
                sources[foundpath] = { content: c }
            }
        })
    } catch (e) {
        throw e
    } finally {
        async.waterfall([
            function loadCompiler(next: Function) {
                compiler = new RemixCompiler()
                compiler.onInternalCompilerLoaded()
                // compiler.event.register('compilerLoaded', this, function (version) {
                next()
                // });
            },
            function doCompilation(next: Function) {
                // @ts-ignore
                compiler.event.register('compilationFinished', this, (success, data, source) => {
                    next(null, data)
                })
                compiler.compile(sources, filepath)
            }
        ], function (err: Error | null | undefined, result: any) {
            let errors = (result.errors || []).filter((e) => e.type === 'Error' || e.severity === 'error')
            if (errors.length > 0) {
                if (!isBrowser) require('signale').fatal(errors)
                return cb(new Error('errors compiling'))
            }
            cb(err, result.contracts)
        })
    }
}

export let postReset = (req: Request, res: Response, next: NextFunction) => {
  req.assert("password", "Password must be at least 4 characters long.").len({ min: 4 });
  req.assert("confirm", "Passwords must match.").equals(req.body.password);

  const errors = req.validationErrors();

  if (errors) {
    req.flash("errors", errors);
    return res.redirect("back");
  }

  async.waterfall([
    function resetPassword(done: Function) {
      User
        .findOne({ passwordResetToken: req.params.token })
        .where("passwordResetExpires").gt(Date.now())
        .exec((err, user: any) => {
          if (err) { return next(err); }
          if (!user) {
            req.flash("errors", { msg: "Password reset token is invalid or has expired." });
            return res.redirect("back");
          }
          user.password = req.body.password;
          user.passwordResetToken = undefined;
          user.passwordResetExpires = undefined;
          user.save((err: WriteError) => {
            if (err) { return next(err); }
            req.logIn(user, (err) => {
              done(err, user);
            });
          });
        });
    },
    function sendResetPasswordEmail(user: UserModel, done: Function) {
      const transporter = nodemailer.createTransport({
        service: "SendGrid",
        auth: {
          user: process.env.SENDGRID_USER,
          pass: process.env.SENDGRID_PASSWORD
        }
      });
      const mailOptions = {
        to: user.email,
        from: "[email protected]",
        subject: "Your password has been changed",
        text: `Hello,\n\nThis is a confirmation that the password for your account ${user.email} has just been changed.\n`
      };
      transporter.sendMail(mailOptions, (err) => {
        req.flash("success", { msg: "Success! Your password has been changed." });
        done(err);
      });
    }
  ], (err) => {
    if (err) { return next(err); }
    res.redirect("/");
  });
};

		/**
		 * Recreate all tsd json files from repo data
		 */
		updateTsd(options:any, callback:(err?, res?:RecreateResult) => void) {

			options = _.defaults(options || {}, {
				parse: 'all',
				export: 'parsed'
			});

			var ret = new RecreateResult(this.repos, options);

			async.waterfall([(callback:(err) => void) => {
				//why compare? (split this into recreate new/changed/all)
				var comparer = new DefinitionComparer(this.repos);
				comparer.compare(callback);

			}, (compareResult:CompareResult, callback:(err?, res?:ImportResult) => void) => {
				if (!compareResult) return callback('DefinitionComparer.compare returned no result');

				ret.compareResult = compareResult;

				var importer = new DefinitionImporter(this.repos);
				var defs:Def[] = compareResult.repoAll;
				if (options.parse === 'new') {
					defs = compareResult.repoUnlisted;
				}
				ret.importSelection = defs;

				importer.parseDefinitions(defs, callback);

			}, (importResult:ImportResult, callback:(err?, res?:ExportResult) => void) => {
				if (!importResult) return callback('DefinitionImporter.parseDefinitions returned no result');

				ret.importResult = importResult;

				var exporter = new DefinitionExporter(this.repos, this.info);
				helper.removeFilesFromDir(exporter.repos.out, (err) => {
					if (err) return callback(err, null);

					var list:deftools.DefData[] = importResult.parsed;
					if (options.export === 'all') {
						list = importResult.all;
					}
					else if (options.export === 'error') {
						list = importResult.error;
					}
					ret.exportSelection = list;

					exporter.exportDefinitions(list, callback);

				});
			}], (err?, exportResult?:ExportResult) => {
				if (err) return callback(err);

				ret.exportResult = exportResult;

				callback(null, ret);
			});
		}

 return new Promise((resolve, reject) => {
   if (!program.submitLocal) {
     if (!program.submitHost) {
       throw 'Option --submitHost is required.'
     }
     if (!program.submitPort) {
       throw 'Option --submitPort is required.'
     }
     if (isNaN(parseInt(program.submitPort))) {
       throw 'Option --submitPort must be a number.'
     }
   }
   async.waterfall([
     function (next:any) {
       const method = getGenerationMethod(server);
       (async() => {
         const simulationValues:any = {}
         if (program.show && program.check) {
           if (program.at && !isNaN(program.at)) {
             simulationValues.medianTime = program.at
           }
         }
         const block = await method(null, simulationValues);
         next(null, block);
       })()
     },
     function (block:any, next:any) {
       if (program.check) {
         block.time = block.medianTime;
         program.show && console.log(block.getRawSigned());
         (async() => {
           try {
             const parsed = parsers.parseBlock.syncWrite(block.getRawSigned());
             await server.BlockchainService.checkBlock(parsed, false);
             logger.info('Acceptable block');
             next();
           } catch (e) {
             next(e);
           }
         })()
       }
       else {
         logger.debug('Block to be sent: %s', block.getRawInnerPart());
         async.waterfall([
           function (subNext:any) {
             proveAndSend(program, server, block, server.conf.pair.pub, parseInt(difficulty), subNext);
           }
         ], next);
       }
     }
   ], (err:any, data:any) => {
     err && reject(err);
     !err && resolve(data);
   });
 });