crypto-nodes/gemini.js

const utils = require('./lib/utils');

var exchange_id  = 'gemini';

var obj = false;

module.exports = function(RED) {

    function geminiData(config) {

		RED.nodes.createNode(this,config);
		var node = this;

		if(config.config) {
			config.config = RED.nodes.getNode(config.config);
		} else {
			node.status({ fill: 'red',shape:'ring', text: 'Not Configured' });
			return;
		}
 
		utils.load(exchange_id, config.config, function (exchange_obj) {

			// console.log('------------------ SETUP!!');
			//console.log(exchange_obj);

			if(!exchange_obj) {
				node.status({ fill: 'red',shape:'ring', text: 'Could Not Start' });
				return;
			}
			// Initialize
			var ok = exchange_obj.data.create(node, config);

			if(!ok) {
				console.log('NO INIT');
				node.status({ fill: 'red',shape:'ring', text: 'Could Not Initialize' });
				return;
			}

	       	node.on('close', function() {

	       		// Update UI
			   	node.status({ fill: 'red',shape:'ring', text: 'Offline' });

			   	// Close connections
			    exchange_obj.data.close();
			});

	   		node.on('input', function(msg) {

	   			//console.log(msg);

		        if(msg.payload && msg.payload.op == 'subscribe') {
		        	// console.log(exchange_obj);
		        	// Subscribe to symbols
		        	exchange_obj.data.subscribe(msg.payload.symbols);

		        }
		    });

		});
		
	
    }
    
	function geminiOrder(config) {

		RED.nodes.createNode(this,config);
		var node = this;
		console.log('ORDER OBJ ::');

		if(config.config) {
			config.config = RED.nodes.getNode(config.config);
		} else {
			node.status({ fill: 'red',shape:'ring', text: 'Not Configured' });
			return;
		}

		if(config.server_fix) {
			config.config.server_fix = config.server_fix;
		}
		if(config.server_fix_port) {
			config.config.server_fix_port = config.server_fix_port;
		}

		utils.load(exchange_id, config.config, function (exchange_obj) {

			console.log('ORDER OBJ ::');
//			console.log(exchange_obj);
			
			// This exchange supports FIX
			exchange_obj.fix.init(node, config.config);

			node.on('input', function(msg) {
			
			// Basic validate its an exchange order for this exchange

				if(msg.payload && 
				   msg.payload.op && 
				   msg.payload.op == 'exchange_order' && 
				   msg.payload.exchange == exchange_id &&
				   msg.payload.tx) {

				   	//console.log(msg);

					exchange_obj.order(msg.payload, node);

				}

			});

			

		});

	}

	function geminiBalance(config) {

		RED.nodes.createNode(this,config);
		var node = this;

		if(config.config) {
			config.config = RED.nodes.getNode(config.config);
		} else {
			node.status({ fill: 'red',shape:'ring', text: 'Not Configured' });
			return;
		}

		utils.load(exchange_id, config.config, async function (exchange_obj) {
			console.log('BALANCE OBJ ::');
//			console.log(exchange_obj);
			
			node.on('input', async function(msg) {
			
				if(msg.payload && msg.payload.op && msg.payload.op == 'get_balance') {
					if(msg.payload.exchange && (msg.payload.exchange == 'all' || msg.payload.exchange == exchange_id)) {
						//console.log(exchange_obj);
						let balances = await exchange_obj.ccxt.fetchBalance().catch(function (e) {
							console.log(e);
							console.log('Could not load balances for exchange ' + exchange_id);
							return false;
						});

						var out = {};

						for(x in balances.free) {
							out[x] = { balance: balances.free[x] };
						}

						console.log(out);

						node.send({ payload: { exchange: exchange_id, op: 'get_balance', balances: out } });

						var text = '';
						for(x in out) {
							text += x + ' = ' + out[x].balance + ', ';
						}
						text = text.substr(0, text.length - 2);
						node.status({ fill: 'green',shape:'ring', text: 'Received balance data ' + text });

					}
				}

			});

		});

	}	


    RED.nodes.registerType("geminiData", geminiData);
    RED.nodes.registerType("geminiOrder", geminiOrder);
    RED.nodes.registerType("geminiBalance", geminiBalance);

	
}