bitcoin-atm

App.js

(11229B)

 /**
  * Main Angular Module
  */
 var app = angular.module("app", [
    'ngTouch',
    'ui.bootstrap',
    'ui.mask',
    'mgo-angular-wizard', 
    'angular-qr-scanner', 
    'disabler',
    'ngKeypad'
 ]);
 
 /**
  * Detects when there's a slight touch on the screen.
  */
 app.directive('detectTap', [ '$swipe', function($swipe) {
 	return {
 		restrict : 'A',
 		scope : {
 			detectCallback : '&'
 		},
 		link : function(scope, el) {
 			$swipe.bind(el, {
 				'start' : function() {
 					scope.detectCallback();
 				}
 			});
 		}
 	};
 } ]);
 
 /**
  * Price Ticker shows price per bitcoin.
  */
 app.controller('FSMCtrl', ['$scope', '$rootScope', 'WizardHandler', '$window', '$timeout', function($scope, $rootScope, WizardHandler, $window, $timeout) {
 	
 	/**
 	 * Email regex.
 	 */
 	$rootScope.email_regex = /^(([^<>()[\]\\.,;:\s@\"]+(\.[^<>()[\]\\.,;:\s@\"]+)*)|(\".+\"))@((\[[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\])|(([a-zA-Z\-0-9]+\.)+[a-zA-Z]{2,}))$/;
 	
 	/**
 	 * Session information is any data that was inserted into input and
 	 * held aside for the current session. It is cleared when transaction is over.
 	 */
 	$rootScope.session = {};
 	
 	/**
 	 * Contains the system's configurations such as machine name,
 	 * buy limit, etc.
 	 */
 	$rootScope.config = {};
 	
 	/**
 	 * Whether the user can go to the next screen or not.
 	 */
 	$rootScope.holdScreen = false;
 	
 	/**
 	 * Whether it can send the touch signal to Overlord.
 	 */
 	var canTouch = true;
 	
 	/**
 	 * Sends the touch signal to Overlord so it can know someone
 	 * touched the screen.
 	 */
 	$rootScope.touch = function() {
 		if(canTouch) {
 			$window.overlord.send("touch");
 			canTouch = false;
 			$timeout(function(){
 				canTouch = true;
 			}, 1000); 
 		}
 	};
 	
 	/**
 	 * Clears the current transaction session.
 	 */
 	$scope.clearSession = function() {
 		if($rootScope.holdScreen === false) {
 			$rootScope.holdScreen = true;
 			$timeout(function(){
 				$rootScope.holdScreen = false;
 			}, 1000); 
 		}
 		
 		$rootScope.fsm.data = {};
 		$rootScope.session = {};
 	};
 	
 	/**
 	 * Finite State Machine that remains synchronized with Overlord.
 	 */
 	$rootScope.fsm = {
 			initial: 'Uninitialized',
 			state: 'Uninitialized',
 			data: {},
 			events: [
 			    // Still hasn't initialized Screen
 			    {from: '*', to: 'Uninitialized', screen: 'Uninitialized'},
 
 			    // Idle Screen
 			    {from: '*', to: 'Idle', screen: 'Idle', preStart: "$scope.clearSession()"},
 			    
 			    // Malfunctioning Screen
 			    {from: '*', to: 'Malfunctioning', screen: 'Malfunctioning'},
 			    
 			    // Network Outage Screen
 			    {from: '*', to: 'NetworkOutage', screen: 'NetworkOutage'},
 			    
 			    // Error Screen
 			    {from: '*', to: 'ErrorState', screen: 'ErrorState'},
 			    {from: 'ErrorState', to: '*', postStart: "$scope.afterErrorState()"},
 				
 				// Timeout & fall back ScanQr Screen
 			    {from: '*', to: 'QrScan', screen: 'QrScan', preStart: "$rootScope.startScanning()"},
 			    {from: 'QrScan', to: '*', preStart: "$rootScope.stopScanning()"},
 			    {from: 'QrValidate', to: 'QrScan', preStart: "$scope.setQrError('Invalid bitcoin wallet')"},
 			    {from: 'UserLogin', to: 'QrScan', preStart: "$scope.setQrError('Failed connection to server')"},
 			    {from: 'PhoneLogin', to: 'QrScan', preStart: "$scope.setQrError('Failed connection to server')"},
 			    {from: 'HistoryAudit', to: 'QrScan', preStart: "$scope.setQrError('Failed to verify wallet address')"},
 			    {from: 'TxCreate', to: 'QrScan', preStart: "$scope.setQrError('Failed to create transaction')"},
 				
 				// Prepare Tx Screen
 				{from: 'QrScan', to: 'QrValidate', screen: 'PreparingTx'},
 				{from: 'QrValidate', to: 'UserLogin', screen: 'PreparingTx'},
 				{from: 'UserLogin', to: 'PhoneLogin', screen: 'PreparingTx'},
 				{from: 'UserLogin', to: 'HistoryAudit', screen: 'PreparingTx'},
 				{from: 'PhoneLogin', to: 'HistoryAudit', screen: 'PreparingTx'},
 				{from: 'HistoryAudit', to: 'TxCreate', screen: 'PreparingTx'},
 				
 				// Cash Insert
 				{from: '*', to: 'CashInsert', screen: 'CashInsert'},
 				{from: '*', to: 'CashValidate', screen: 'CashInsert'},
 				
 				// Insufficient Funds
 				{from: '*', to: 'InsufficientFunds', screen: 'InsufficientFunds'},
 				
 				// Limit Reached Screen
 				{from: '*', to: 'LimitReached', screen: 'LimitReached'},
 				{from: 'LimitReached', to: '*', postStart: "$scope.afterLimitReached()"},
 				
 				// Sending Bitcoins Screen
 				{from: 'CashInsert', to: 'Sending', screen: 'Sending'},
 				
 				// Thank You Screen
 				{from: 'Sending', to: 'ThankYou', screen: 'ThankYou'},
 				
 				// receipt screen
 				{from: 'ThankYou', to: 'Receipt', screen: 'Receipt', postStart: "$scope.beforeReceipt()"},
 				{from: 'Receipt', to: '*', postStart: "$scope.afterReceipt()"},
 				
 				// Ad
 				{from: '*', to: 'Ad', screen: 'Ad', postStart: "$('#ad-overlay').addClass('roll-out')"},
 				{from: 'Ad', to: '*', postStart: "$('#ad-overlay').removeClass('roll-out')"}
 			]
 	};
 	
 	/**
 	 * Function executes when there is a state transition.
 	 */
 	var transition = function(from, to) {
 		
 		var events = _.filter($rootScope.fsm.events, function(e){
 			return (e.from === from || e.from === "*") && (e.to === to || e.to === "*"); 
 		});
 				
 		_.each(events, function(e){
 			if(e.hasOwnProperty('preStart')) {
 				eval(e.preStart);
 			}
 		});
 		
 		var event = _.find(events, function(e){
 			return e.hasOwnProperty('screen');
 		});
 		
 		if(typeof event === 'undefined') {
 			$window.console.error("State transition event not found: "+from+" -> "+to);
 			return;
 		}
 		
 		if(event.hasOwnProperty('screen')) {
 			WizardHandler.wizard().goTo(event.screen);
 		}
 
 		$rootScope.fsm.state = to;
 		
 		_.each(events, function(e){
 			if(e.hasOwnProperty('postStart')) {
 				eval(e.postStart);
 			}
 		});
 	};
 	
 	/**
 	 * Event that updates the client-side FSM data.
 	 */
 	$rootScope.$on("dataUpdate", function (event, message) {
 		$rootScope.fsm.data = angular.copy(message);
 	});
 	
 	/**
 	 * Event that updates the client-side FSM data.
 	 */
 	$rootScope.$on("stateUpdate", function (event, message) {
 		var from = ((message.from) ? message.from : $rootScope.fsm.state);
 		var to = ((message.to) ? message.to : message);
 		transition(from, to);
 	});
 	
 	/**
 	 * Event that updates the client-side price ticker.
 	 */
 	$rootScope.$on("priceUpdate", function (event, message) {
 		$rootScope.price = message;
 	});
 	
 	/**
 	 * Updates the client-side configurations.
 	 */
 	$rootScope.$on("configUpdate", function (event, message) {
 		$rootScope.config = message;
 	});
 	
 	/**
 	 * Updates the client-side session data.
 	 */
 	$rootScope.$on("sessionUpdate", function (event, message) {
 		jQuery.extend($rootScope.session, message);
 	});
 	
 	/**
 	 * Sends the continue command to Overlord to
 	 * possibly go to the next screen.
 	 */
 	$rootScope.nextScreen = function(wznext) {
 		if($rootScope.holdScreen === false) {
 			$window.overlord.send("continue");
 			
 			if(wznext) {
 				WizardHandler.wizard().next();
 			}
 		}
 	};
 	
 	/**
 	 * Sends the previous command to Overlord to
 	 * possibly go to the previous screen.
 	 */
 	$rootScope.previousScreen = function(wzprevious) {
 		if($rootScope.holdScreen === false) {
 			$window.overlord.send("previous");
 			
 			if(wzprevious) {
 				WizardHandler.wizard().previous();
 			}
 		}
 	};
 	
 	/**
 	 * Sends the buy command to Overlord to complete the transaction
 	 * and send the bitcoins.
 	 */
 	$rootScope.buy = function() {
 		$window.overlord.send("buy");
 	};
 	
 	/**
 	 * Sets error message that occurred before 
 	 * transaction was created or while scanning 
 	 * QR code.
 	 */
 	$scope.setQrError = function(msg) {
 		$rootScope.qrError = true;
 		$rootScope.qrErrorMsg = msg;
 		$timeout(function() {
 			$rootScope.qrError = false;
   		}, 6000);
 	};
 	
 	/**
 	 * Displays input screen given the input name.
 	 * Inputs are available in /templates-hidden/input directory.
 	 */
 	$rootScope.unwrapInput = function(name, animate) {
 		$("#"+name).removeClass("hidden");
 		
 		if(typeof animate === 'undefined' || animate) {
 			$("#"+name).addClass("animated fadeIn");
 			$("#"+name+" .input-container").addClass("animated zoomIn");
 			$("#"+name+" button").addClass("animated zoomIn");
 		} else {
 			$("#"+name).css("opacity", "1");
 		}
 		
 		$("#"+name+" input").focus();
 	};
 	
 	/**
 	 * Hides input screen given the input name.
 	 */
 	$rootScope.wrapInput = function(name) {
 		$("#"+name).addClass("hidden");
 		$("#"+name).removeClass("animated fadeIn");
 		$("#"+name+" .input-container").removeClass("animated zoomIn");
 		$("#"+name+" button").removeClass("animated zoomIn");
 	};
 	
 	/**
 	 * Runs before receipt screen is shown.
 	 */
 	$scope.beforeReceipt = function() {
 		$('#receipt-holder').addClass('print');
 	};
 	
 	/**
 	 * Runs after receipt screen is shown.
 	 */
 	$scope.afterReceipt = function() {
 		$('#receipt-holder').removeClass('print');
 		$rootScope.wrapInput('receipt-email');
 		$rootScope.loading = false;
 	};
 	
 	/**
 	 * Runs after limit reached screen is shown.
 	 */
 	$scope.afterLimitReached = function() {
 		$rootScope.wrapInput('verify-phone');
 		$rootScope.wrapInput('verify-sms');
 		$rootScope.loading = false;
 	};
 	
 	/**
 	 * Runs after error state screen is shown.
 	 */
 	$scope.afterErrorState = function() {
 		$rootScope.wrapInput('error-phone');
 		$rootScope.wrapInput('error-email');
 		$rootScope.loading = false;
 	};
 	
 	/**
 	 * Sends receipt email.
 	 */
 	$rootScope.sendReceipt = function() {
 		$window.overlord.send({email: $rootScope.session.email});
 		$rootScope.loading = true;
 	};
 	
 	/**
 	 * Sends customer support text message.
 	 */
 	$rootScope.sendPhoneError = function() {
 		$window.overlord.send({phone: $rootScope.session.phone});
 		$rootScope.loading = true;
 	};
 	
 	/**
 	 * Sends customer support email.
 	 */
 	$rootScope.sendEmailError = function() {
 		$window.overlord.send({email: $rootScope.session.email});
 		$rootScope.loading = true;
 	};
 	
 	/**
 	 * Sends text message to phone number to verify.
 	 */
 	$rootScope.sms = function() {
 		$window.overlord.send({phone: $rootScope.session.phone});
 		$rootScope.wrapInput('verify-phone');
 		$rootScope.unwrapInput('verify-sms', false);
 	};
 	
 	/**
 	 * Checks if submitted SMS code matches the authenticated code.
 	 */
 	$rootScope.verifyPhone = function() {
 		if($rootScope.session.input_smscode === $rootScope.session.smscode) {
 			$window.overlord.send({phone: $rootScope.session.phone, verified: true});
 		} else {
 			$rootScope.session.wrong_smscode = true;
 			$rootScope.session.input_smscode = "";
 			$("#verify-sms input").focus();
 		}
 	};
 	
 	
 	$timeout(function(){
 		
 		// register anything here
 		
 	}, 4000);
 }]);
 
 
 app.controller('IdleCtrl', ['$scope', '$rootScope', '$timeout', function($scope, $rootScope, $timeout) {
 	
 	var animations = ['wobble', 'tada', 'swing', 'shake', 'bounce'];
 	
 	var animate = function() {
 		var animation = animations[Math.floor(Math.random()*animations.length)];
 		document.getElementById("bitcoin").className = 'animated '+animation;
 		$timeout(animate, 60000);
 	};
 	
 	var actions = ['BUY', 'WANT', 'NEED', 'GET', 'GO', 'DESIRE'];
 	
 	var newAction = function() {
 		$rootScope.bitcoinAction = actions[Math.floor(Math.random()*actions.length)];
 		$timeout(newAction, 60000 * 10); // every 10 minutes
 	};
 	
 	newAction();
 	$timeout(animate, 60000);
 }]);