Open a Locker with IOTA

var IOTA = require ("@iota/core")				// iota.js library
const converter = require('@iota/converter');	// iota utils
var Gpio = require('onoff').Gpio;				// raspberry GPIO library
var lock = new Gpio(26, 'out');
var http = require('http');
var fs = require('fs');

// set remote iota node
const iota = IOTA.composeAPI({
    provider: 'https://nodes.thetangle.org:443'
})

// set seed
var seed = 'YOURSEEDHERE999999999999999999999999999999999999999999999999999999999999999999999'

var cost = 60;			  // cost per minute in iotas
var minimumCheckIn = 60;  // cost to start (check-in)
var watchInterval = 5000; // 5 seconds interval to check the tangle

const AVAILABLE = 0;	  
const IN_USE = 1;		  

var status; 			// AVAILABLE or IN_USE
var index;				// index for generating new addresses from seed
var checkInAddress;		// address to start the process
var checkOutAddress;	// address to finish and open the lock
var userBundle;			// bundle of the checkin tx sent by the user
var userAddress;		// address from user to interact
var paid;				// sum of balances from checkIn + checkOut
var checkInTime;		// time of use
var balanceWatchLoop;	// endless loop that keeps track of certain address
var timerLoop;			// loop during use for update cost and display
var errorCount;

// cost calculation
var checkInBalance;
var totalCost;

// check conectivity with iota node
iota.getNodeInfo()
    .then(info => {
    	console.log(info)
    	index = 60
    	reset()
    })
    .catch(error => {
        console.log(`Request error getNodeInfo: ${error.message}`)
    })

// reset all values
function reset() {
	status = AVAILABLE
	checkInTime = undefined
	checkInBalance = 0
	checkInAddress = null;
	checkOutAddress = null;
	totalCost = 0
	remainingAmount = 0
	errorCount = 0;
	userAddress = '';
	clearInterval(balanceWatchLoop)
	setTimer(false)
	setNextAddress();
}

// set new unused address (balance = 0)
function setNextAddress(async) {

	var address = IOTA.generateAddress(seed,index, 2, true)
	index++
	console.log(`Verifying address with index ${index}`)

	iota.getBalances([address],100)
		.then(({ balances }) => {
		    console.log(`..balance: ${balances}`)
		    errorCount = 0;
		    
		    if (balances != 0) {
		    	// check next address
		    	setNextAddress()
		    } else {
		    	// address is good to use

		    	if (status == AVAILABLE) {
		    		// set check-in address
		    		checkInAddress = address
		    		console.log(`..checkInAddress set: ${address}`)
	    			startBalanceWatch()

		    	} else {
		    		// set check-out address
		    		checkOutAddress = address
		    		console.log(`..checkOutAddress set: ${checkOutAddress}`)
		    		sendCheckOutAddress()
		    		startBalanceWatch()
		    	}
		    }
		})
		.catch(err => {
			errorCount++;
			console.log(`Request error ${errorCount} getBalances: ${err.message}`)
			if (errorCount < 3) {
				setNextAddress()
			}
	    })
}

// keep checking income transactions
function startBalanceWatch() {

	console.log(`Starting balance watch...`)
	balanceWatchLoop = setInterval(function() { 
			
			if (status == AVAILABLE) console.log('Waiting check-in...');

			addressToWatch = status == AVAILABLE ? checkInAddress : checkOutAddress
			if (addressToWatch === null) return; // may happen if it takes longer to define next address

			iota.findTransactionObjects({ addresses: [addressToWatch] })
		   		.then(transactions => {
		   			var sum = 0;
		       		for (var i=0; i < transactions.length; i++) {
		       			sum += transactions[i].value;
		       		}

					if (status == AVAILABLE) {
						if (sum >= minimumCheckIn) {
							
							// check-in
							console.log(`***** CHECKING IN! *****`)

							clearInterval(balanceWatchLoop)
							status = IN_USE
							checkInBalance = sum;
							userBundle = transactions[transactions.length - 1].bundle;
							openLock()
							setTimer(true)
							setNextAddress()
						}
					} else {
						// calculate values
						paid = (parseInt(checkInBalance) + parseInt(sum))
						if (paid === undefined) paid = "";
						var remainingAmount = parseInt(totalCost) - paid;
						if (remainingAmount < 0) remainingAmount = 0;

						console.log(`(check-in ${checkInBalance}) + (check-out ${sum}) = Paid: ${paid} | Total cost: ${totalCost}`)

						if (totalCost > minimumCheckIn && paid >= totalCost) {

							// check-out
							console.log(`***** CHECKING OUT! *****`)

							openLock()								
							reset()
						}
					}

		   		})
		   		.catch(err => {
		       		console.log(`Request error findTransactionObjects: ${err.message}`)
		   		})

		}, watchInterval);
}

// open locker through gpio
function openLock() {

	console.log(`Opening lock...`);
	setInterval(function() {
		lock.writeSync(0);	
	}, 6000); // keep locker 6 seconds open
	lock.writeSync(1);
}

// usage timer
function setTimer(start) {

	if (start) {
		console.log(`Starting timer...`);

		// increase cost every minute
		timerLoop = setInterval(function() {
			totalCost += cost;	
		}, 60000);
		
	} else {
		clearInterval(timerLoop)
		console.log(`Timer stopped!`);
	}
}

// after check-in, send new unused (checl-out) address to user
function sendCheckOutAddress() {

	iota.findTransactionObjects({ bundles: [userBundle] })
	   		.then(transactions => {
				console.log('Transactions found: ' + transactions.length);
	       		for (var i=0; i < transactions.length; i++) {
	       			if (transactions[i].value < 0) {
	       				userAddress = transactions[i].address;
						break;
	       			}
	       		}

	       		console.log(`User address: ${userAddress}`);
	       		if (userAddress == '') {
	       			console.log(`Could not determine user address`)	
	       			return;
	       		}

				// send message to user
				const transfers = [{
				    address: userAddress,
				    value: 0,
				    tag: '',
				    message: converter.asciiToTrytes(checkOutAddress)
				}]

				return iota.prepareTransfers(seed, transfers)
			})
			.then(trytes => {
		        console.log('transfer prepared!')
		        return iota.sendTrytes(trytes, 3, 14) // trytes, depth, minWeightMagnitude
		    })
		    .then(bundle => {
		        console.log(`Published transaction with tail hash: ${bundle[0].hash}`)
		        console.log(`Bundle: ${bundle}`)
		    })
	   		.catch(err => {
	       		console.log(`Error sendCheckOutAddress: ${err.message}`)
	   		})
}

// setup server for front-end requests
var server = http.createServer(function(req, res) {

	if (req.url == '/') {
		res.writeHead(200, {'Content-type': 'text/html'});
		var myReadStream = fs.createReadStream(__dirname + '/index.html', 'utf8');
		myReadStream.pipe(res);

	} else if (req.url == '/r') {
		res.writeHead(200, {'Content-type': 'aaplication/json'});

		var obj = {
			status: status,
			checkInAddress: checkInAddress,
			minimumCheckIn: minimumCheckIn,
			paid: (paid == null ? "" : paid),
			totalCost: totalCost + cost // charge extra minute for network delay
		}
		res.end(JSON.stringify(obj));

	} else {
		res.end('nothing here...');
	}
});
server.listen(3000, '127.0.0.1');