Source: fvsessions.js

  1. /// <reference path="/ss/st/fvterm/web/Scripts/FVTermParent.js" />
  2. /// <reference path="/ss/st/fvterm/web/Scripts/FVTermMsgApi.js" />
  3. (function ()
  4. {
  5. 	'use strict';
  6. 	function log(text)
  7. 	{
  8. 		/* not active
  9. 		if (typeof (console) != 'undefined')
  10. 			console.log(text);
  11. 		*/
  12. 	}
  13. /**
  14.  * @fileOverview The FVSessions Module contains the FVSessions.Manager class function and the FVSessions.Session class
  15.  * @author Inventu Corporation <support@inventu.com">
  16.  * @version 1.0.20
  17.  */
  18. 	var FVSMGR, FVSESS,
  19. 			enterKeys = 'EC123456789abcdefghijklmnoxyz';
  20. 	//trim polyfill
  21. 	if (!String.prototype.trim)
  22. 	{
  23. 		String.prototype.trim = function ()
  24. 		{
  25. 			return this.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, '');
  26. 		};
  27. 	}
  28. /**
  29.  * @namespace FVSessions
  30.  */
  31.  	if (!window.FVSessions)
  32. 		window.FVSessions = {};
  33. 	FVSessions.config = {
  34. 		fvBaseUrl: '/fvterm/',
  35. 		fvTermPage: 'scterm.html',
  36. 		fvMacrosMgr: 'macros/FlowMacros.aspx',
  37. 		fvProfileMgr: 'SCProfile.aspx',
  38. 		msgAPI:true
  39. 	};
  41. 	// #region Manager class
  42. /** The Manager Class is used to initialize the environment and host Session objects
  43.  * In September 2023, the FVSessions.config setting msgAPI was added with a default value of true.
  44.  * This now assumes that FVTermMsgApi.js instead of FVTermParent.js is the corresponding JS file 
  45.  * providing the iFrame API management.  FVTermMsgApi.js utilizes inter-window messaging instead
  46.  * of direct calls that require document.domain to be set in many environments.
  47.  * If you are using FVSessions.js with the direct API module FVTermParent.js, you will need to set
  48.  * FVSessions.config.msgAPI=false prior to creating a new connection.
  49.  * @typedef { FVSessions.Manager } Manager
  50.  */
  52. /** @typedef {Object} Connection
  53.  * @description Defines how a Session connects when started--matches all documented properties for the FVTermParent ConnectFVTerm function
  54.  * @property {string} application (optional--overrides the SessionControl property of same name if defined) Name of application defined in web.config for screen recognition
  55.  * @property {string} hostName Host name defined for the Inventu service that this session connects to
  56.  * @property {boolean} autoStart If true the session will automatically connect to the host at start time 
  57.  * @property {boolean} keepAliveOnClose If true, the session will not be terminated/closed by the browser logic if the user closes the browser at the desktop level
  58.  * @property {string} userID Can be set prior to start session--this is the UserID to be associated with the session in the Inventu Service
  59.  * @property {Session} fnSessClass Needed at constructor time--defines class for sessions, such as FVSessions.HODSession-default is FVSessions.Session
  60.   */
  62. /** @typedef {Object} SessionControl
  63.  * @description Keyed by SessionID -- included in the SessionDef object passed as the control parameter to the Manager Class Constructor
  64.  * @property {function(Session, rows, screenName)} onnewscreen Event function called any time a new screen is received from the host
  65.  * @property {function(Session)} onclose Event function called when the session is closed
  66.  * @property {function(Session, enterKey)} onsend Event function called whenever the user enters a screen
  67.  * @property {string} frameId Optional frameID that this session should be opened/started in--if not set the name is 'FVSWin_' + the session id
  68.  * @property {Connection} connection Defines how the session will connect during the Manager.StartSession function
  69.  */
  71. /** @typedef {Object} SessionDef
  72.  * @property {string} application Default name of application defined in web.config for screen recognition -- can be overridden in session connection property
  73.  * @property {function(Session, rows, screenName)} onnewscreen Default Event function called any time a new screen is received from the host--
  74.  * can be overridden for each Session in the sessions SessionControl object
  75.  * @property {function(Session)} onclose Default Event function called when the session is closed--
  76.  * can be overridden for each Session in the sessions SessionControl object
  77.  * @property {function(Session, enterKey)} onsend Default Event function called whenever the user enters a screen--
  78.  * can be overridden for each Session in the sessions SessionControl object
  79.  * @property {SessionControl} sessions One or more session definitions keyed by the sessionID
  80.  */
  82. 	/** @constructor
  83. 	* @description Manager Class Constructor function--please ensure that the FVSessions.config.msgAPI is set
  84.    * to correspond with the API JS file you are using (see FVSessions.Manager class documentation)
  85. 	* @param {Object} win The Window object for the environment this Manager will run in
  86.    * @param {SessionDef} control Settings for the events and sessions, with objects keyed by sessionID key property for each session is connection
  87.    * @param {function(Object)} fnReady Completion function called when ready--includes a reference to the sessions object, indexed by session ids
  88. 	*/
  89. 	FVSessions.Manager = function (win, control, fnReady)
  90. 	{
  91. 		var key, me = this, session, sessionKey, sessionChecks = [],
  92. 			sessions = (control && control.sessions) ? control.sessions : null, bindings, sessObj,
  93. 			fnSessClass = (control.fnSessClass) ? control.fnSessClass : FVSessions.Session;
  94. 		this.sessions = {};
  95. 		if (control.application)
  96. 			this.application = control.application;
  97. 		this.win = win;
  98. 		this.doc = win.document;
  99. 		if (sessions)
  100. 		{
  101. 			for (key in sessions)
  102. 			{
  103. 				if (sessions.hasOwnProperty(key))
  104. 				{
  105. 					bindings = {};
  106. 					sessObj = sessions[key];
  107. 					if (control.onalert || sessObj.onalert)
  108. 						bindings.onalert = (sessObj.onalert) ? sessObj.onalert : control.onalert;
  109. 					if (control.onsend || sessObj.onsend)
  110. 						bindings.onsend = (sessObj.onsend) ? sessObj.onsend : control.onsend;
  111. 					if (control.onclose || sessObj.onclose)
  112. 						bindings.onclose = (sessObj.onclose) ? sessObj.onclose : control.onclose;
  113. 					if (control.onnewscreen || sessObj.onnewscreen)
  114. 						bindings.onnewscreen = (sessObj.onnewscreen) ? sessObj.onnewscreen : control.onnewscreen;
  115. 					this.sessions[key] = session = new fnSessClass(key, this, sessObj, bindings);
  116. 					if (session.sessionKey)
  117. 						sessionChecks.push(session.sessionKey);
  118. 				}
  119. 			}
  120. 			if (sessionChecks.length)
  121. 			{
  122. 				this.ServerCall(FVSessions.config.fvBaseUrl + FVSessions.config.fvMacrosMgr + '?action=verifySessions', sessionChecks, { method: 'POST' }, function (statuses)
  123. 				{
  124. 					var i, id;
  125. 					for (i = 0; i < statuses.length; i++)
  126. 					{
  127. 						session = me.FindSessionByKey(sessionChecks[i]);
  128. 						session.SetStatus(statuses[i]);
  129. 					}
  130. 					if (fnReady)
  131. 						fnReady(me.sessions);
  132. 				});
  133. 			}
  134. 			else
  135. 			{
  136. 				if (fnReady)
  137. 					window.setTimeout(function () { fnReady(me.sessions) }, 1);
  138. 			}
  139. 		}
  140. 	};
  141. 	FVSMGR = FVSessions.Manager.prototype;
  143. 	/** @memberof! FVSessions.Manager.prototype
  144. 	 * @description Find a Session object based on a sessionKey
  145. 	* @param {String} sessionKey The SessionKey to use in the search
  146. 	* @returns {Session} Found session or null
  147. 	*/
  148. 	FVSMGR.FindSessionByKey = function (sessionKey)
  149. 	{
  150. 		var key;
  151. 		for (key in this.sessions)
  152. 		{
  153. 			if (this.sessions[key].sessionKey == sessionKey)
  154. 				return this.sessions[key];
  155. 		}
  156. 	}
  158. 	/** @memberof! FVSessions.Manager.prototype
  159. 	* @description Resize all Sessions
  160. 	* @param {Integer} width New Width for each Session
  161. 	* @param {Integer} height New height for each sessions
  162. 	*/
  163. 	FVSMGR.ResizeSessions = function (width, height)
  164. 	{
  165. 		var key, session;
  166. 		for (key in this.sessions)
  167. 		{
  168. 			if (!this.sessions.hasOwnProperty(key))
  169. 				continue;
  170. 			session = this.sessions[key];
  171. 			if (session.fvWin)
  172. 			{
  173. 				session.fvWin.style.width = width + 'px';
  174. 				session.fvWin.style.height = height + 'px';
  175. 			}
  176. 		}
  177. 	};
  179. 	/** @memberof! FVSessions.Manager.prototype
  180. 	 * @description Start a Session
  181. 	* @param {String} id The ID of the session - must match one of the sessions defined in the constructor
  182. 	* @param {Object} styles (Optional) - If not null, an object with property names matching styles to attach to the new session's iFrame
  183. 	* @param {Object} parentElem Parent DOM element--if not included, the document.body element will be the parent of the new iFrame
  184. 	* @param {function(Session)} fnReady Completion function called when the session has been started
  185. 	*/
  186. 	FVSMGR.StartSession = function (id, styles, parentElem, fnReady)
  187. 	{
  188. 		var key, me = this, session = this.sessions[id], parentDiv,
  189. 			fvWin = (session.fvWin) ? session.fvWin : this.doc.getElementById(session.frameId),
  190. 			url = FVSessions.config.fvBaseUrl + FVSessions.config.fvTermPage,
  191. 			connection = session.connection,
  192. 			fnConnect = (FVSessions.config.msgAPI) ? FVMsgApi.ConnectMsgFVTerm : ConnectFVTerm;
  194. 		if (!fvWin)
  195. 		{
  196. 			if (!parentElem)
  197. 				parentElem = this.doc.body;
  198. 			parentDiv = this.doc.createElement('div');
  199. 			parentDiv.style.display = 'inline';
  200. 			parentElem.appendChild(parentDiv);
  201. 			parentDiv.innerHTML = '<iframe id="' + session.frameId + '" />';
  202. 			fvWin = this.doc.getElementById(session.frameId);
  203. 			session.fvWin = fvWin;
  204. 		}
  205. 		/* If msgApi, turn fvWin into a proxy and save the real fvWin
  206. 		 */
  207. 		if (styles)
  208. 		{
  209. 			for (key in styles)
  210. 			{
  211. 				if (styles.hasOwnProperty(key))
  212. 				{
  213. 					fvWin.style[key] = styles[key];
  214. 				}
  215. 			}
  216. 		}
  217. 		if (session.status != 'offline')
  218. 		{
  219. 			connection = { "sessionKey": session.sessionKey };
  220. 			if (session.connection.keepAliveOnClose)
  221. 				connection.keepAliveOnClose = session.connection.keepAliveOnClose;
  222. 			if (this.application)
  223. 				connection.application = this.application;
  224. 		}
  225. 		//fnConnect(fvWin.id, url, connection, async function (fvApi, sessionKey) need async?
  226. 		fnConnect(fvWin.id, url, connection, async function (fvApi, sessionKey)
  227. 		{
  228. 			if (fvApi)
  229. 				await session.BindNewSession(fvApi, sessionKey);
  230. 			else
  231. 				session.connectError = sessionKey;
  232. 			if (fnReady)
  233. 				fnReady(session);
  234. 		});
  235. 	};
  237. 	/** @memberof! FVSessions.Manager.prototype
  238. 	 * @description Call a server function that supports the session manager
  239. 	* @param {String} url Action portion of the url
  240. 	* @param {Object} data (Optional) - For a post, the object that will be sent as JSON stringified null value is ignored
  241. 	* @param {Object} options (optional) properties include method (GET/POST), mimeType, credUser and credPW all optional--null is ignored
  242. 	* @param {function(Object)} fnReady Completion function called with returned object converted from JSON
  243. 	* @returns {FVSMGR.ServerCall} object
  244. 	*/
  245. 	FVSMGR.ServerCall = function (url, data, options, fnReady)
  246. 	{
  247. 		var xmlHttp = null,
  248. 			me = this, key,
  249. 			err, method = (options && options.method) ? options.method : 'GET',
  250. 			mimeType = (options && options.mimeType) ? options.mimeType : 'application/json',
  251. 			credUser = (options && options.credUser) ? options.credUser : null,
  252. 			credPW = (options && options.credPW) ? options.credPW : null,
  253. 			query = [], postData = null;
  254. 		try
  255. 		{
  256. 			if (window.XMLHttpRequest)
  257. 			{
  258. 				// If IE7, Mozilla, Safari, etc: Use native object
  259. 				xmlHttp = new XMLHttpRequest();
  260. 				if (xmlHttp.overrideMimeType)
  261. 					xmlHttp.overrideMimeType(mimeType);
  262. 			}
  263. 			else if (window.ActiveXObject)
  264. 			{
  265. 				// ...otherwise, use the ActiveX control for IE5.x and IE6
  266. 				xmlHttp = new ActiveXObject('MSXML2.XMLHTTP.3.0');
  267. 			}
  269. 			if (data)
  270. 			{
  271. 				if ((method == 'GET') ||
  272. 					(mimeType != 'application/json'))
  273. 				{
  274. 					for (key in data)
  275. 					{
  276. 						if (data.hasOwnProperty(key))
  277. 							query.push(encodeURIComponent(key) + '=' + encodeURIComponent(data[key]));
  278. 					}
  279. 				}
  280. 				if (method == 'GET')
  281. 				{
  282. 					if (url.indexOf('?') == -1)
  283. 						url += '?';
  284. 					url += query.join('&');
  285. 				}
  286. 				else
  287. 				{
  288. 					if (mimeType == 'application/json')
  289. 						postData = JSON.stringify(data);
  290. 					else
  291. 						postData = query.join('&');
  292. 				}
  293. 			}
  295. 			xmlHttp.open(method, url, true, credUser, credPW);
  296. 			xmlHttp.onreadystatechange = function ()
  297. 			{
  298. 				if (xmlHttp.readyState >= 4)
  299. 				{
  300. 					var result;
  301. 					if (xmlHttp.status == 200)
  302. 					{
  303. 						if (mimeType == 'application/json')
  304. 							result = JSON.parse(xmlHttp.responseText);
  305. 						else
  306. 							result = xmlHttp.responseText;
  307. 						me.httpError = false;
  308. 					}
  309. 					else
  310. 					{
  311. 						result = { status: 'error', code: xmlHttp.status };
  312. 						me.httpError = true;
  313. 					}
  314. 					if (fnReady)
  315. 					{
  316. 						fnReady(result);
  317. 					}
  318. 				}
  320. 			};
  321. 			if (method == 'POST')
  322. 				xmlHttp.setRequestHeader('Content-type', 'application/json; charset=utf-8');
  323. 			xmlHttp.send(postData);
  324. 		}
  325. 		catch (e)
  326. 		{
  327. 			alert(e.message);
  328. 			return null;
  329. 		}
  330. 		return xmlHttp;
  331. 	};
  332. 	// #endregion Manager Class
  334. 	// #region Session Class
  335. /** The Session class manages an individual FVTerm session and is created using the Manager
  336. * @typedef {FVSessions.Session} Session
  337. */
  338. 	/** @description Session Class Constructor function
  339. 	* @constructor
  340. 	* @param {String} id  The id for this session, used for access and naming
  341.    * @param {Object}	mgr The owning FVSessions.Manager object
  342.    * @param {Object} settings The source properties including connection which has connection details
  343.    * @param {Object} bindings Any event/call forwarders
  344. 	*/
  345. 	FVSessions.Session = function (id, mgr, settings, bindings)
  346. 	{
  347. 		if (!id)
  348. 			return;
  349. 		this.id = id;
  350. 		this.mgr = mgr;
  351. 		this.settings = settings;
  352. 		this.connection = settings.connection;
  353. 		if (!this.connection.application && mgr.application)
  354. 			this.connection.application = mgr.application;
  355. 		this.status = 'offline';
  356. 		this.frameId = (settings.frameId) ? settings.frameId : 'FVSWin_' + id;
  357. 		this.storeId = 'FVSK_' + id;
  358. 		this.sessionKey = this.GetSessionKey();
  359. 		this.bindings = bindings;
  360. 		if (FVSessions.config.msgAPI)
  361. 			FVSessions.SetMsgMethods();
  362. 		else
  363. 			FVSessions.SetLocalMethods();
  364. 	};
  365. 	FVSESS = FVSessions.Session.prototype;
  367. 	/**  @memberof! FVSessions.Session.prototype
  368. 		 * @description Internal function that binds the FVTermParent events to the client's onnewscreen, 
  369. 		 * onclose, onsend and onalert (when each handler is present) in support of the FVTermMsgApi.js module
  370. 		 * implemented September of 2023, this function is flagged async as the fvApi.GetCookieEx must run
  371. 		 * with an await to retain synchronicity in the messaging environment.
  372. 		 * @param {Object} fvApi Api Control Object
  373. 		 * @param {String} sessionKey SessionKey if for active session
  374. 		 * */
  375. 	FVSESS.BindNewSession = async function (fvApi, sessionKey)
  376. 	{
  377. 		var me = this,
  378. 			realSessionKey = (sessionKey && (sessionKey.substr(0, 4) == 'FVC_')) ? await fvApi.GetCookieEx(sessionKey) : sessionKey;
  379. 		this.fvApi = fvApi;
  380. 		if (sessionKey)
  381. 			log('BindNewSession for ' + sessionKey + ' (' + realSessionKey + ')');
  382. 		else
  383. 			log('BindNewSession for failed session');
  384. 		if (sessionKey)
  385. 			this.SaveSessionKey(realSessionKey);
  386. 		this.SetStatus('started');
  387. 		fvApi.onnewscreen = function (rows, screenName)
  388. 		{
  389. 			me.screenName = screenName;
  390. 			if (me.bindings.onnewscreen)
  391. 				me.bindings.onnewscreen(me, rows, screenName);
  392. 		};
  393. 		fvApi.onclose = function (closeType)
  394. 		{
  395. 			me.SetStatus('offline'); // clears sessionkey
  396. 			if (me.bindings.onclose)
  397. 				me.bindings.onclose(me, closeType);
  398. 		};
  399. 		fvApi.onsend = function (enterKey)
  400. 		{
  401. 			if (me.bindings.onsend)
  402. 				return me.bindings.onsend(me, enterKey);
  403. 			else
  404. 				return true;
  405. 		};
  406. 		fvApi.onalert = function (alertObj, msg, bgColor, fnOnClick, buttons)
  407. 		{
  408. 			if (me.bindings.onalert)
  409. 				return me.bindings.onalert(me, alertObj, msg, bgColor, fnOnClick, buttons);
  410. 			else
  411. 				return null; // not handle
  412. 		};
  413. 	};
  415. 	/**  @memberof! FVSessions.Session.prototype
  416. 	* @description Internal use only function used to set functions when FVSessions.config.msgAPI is true
  417. 	*/
  418. 	FVSessions.SetMsgMethods = function ()
  419. 	{
  420. 		/**  @memberof! FVSessions.Session.prototype
  421. 		* @description Close the Session if active
  422. 		*/
  423. 		FVSESS.Close = function ()
  424. 		{
  425. 			if (this.status != 'offline')
  426. 			{
  427. 				try
  428. 				{
  429. 					this.fvApi.CloseTerm();
  430. 				}
  431. 				catch (e) { }
  432. 			}
  433. 		};
  435. 		/**  @memberof! FVSessions.Session.prototype
  436. 		* @description Control if the session has focus - Note for MsgAPI need to await this if you want it
  437. 		* to be synchronous
  438. 		* @param {boolean} focusOn If true the session will have focus set, if false, focus will be off and locked off until 
  439. 		* @param {boolean} activate If true, when focusOn is true, will also set browser focus into the FVTerm body
  440. 		* set back on with this call
  441. 	   * @returns {Promise} For MsgAPI returns a Promise
  442. 		*/
  443. 		FVSESS.SetFocus = async function (focusOn, activate)
  444. 		{
  445. 			var me = this;
  446. 			return new Promise(async (resolve) =>
  447. 			{
  448. 				if (this.status != 'offline')
  449. 				{
  450. 					try
  451. 					{
  452. 						if (focusOn)
  453. 						{
  454. 							await me.fvApi.EmActive(2, 'FVSession');
  455. 							if (activate)
  456. 								await me.fvApi.SCSetTermFocus();
  457. 						}
  458. 						else
  459. 						{
  460. 							await me.fvApi.EmActive(-1, 'FVSession');
  461. 						}
  462. 						resolve(true);
  463. 					}
  464. 					catch (e)
  465. 					{
  466. 						log('Exception during SetFocus=' + e);
  467. 						resolve(false);
  468. 					}
  469. 				}
  470. 			});
  471. 		};
  473. 		/** @memberof! FVSessions.Session.prototype
  474. 		* @description Read from the active screen--will trim blanks from the text that is read--
  475. 	   * Note that for MsgAPI you need to await this call to get the right value
  476. 		* @param {Integer} row Row to read from where 1 is the first row
  477. 		* @param {Integer} column Column to read from where 1 is the first column
  478. 		* @param {Integer} length Length to read--if row/column is entry field this is ignored
  479. 		* @returns {String} Text from the screen at row, column for length
  480. 		*/
  481. 		FVSESS.GetScreenText = async function (row, column, length)
  482. 		{
  483. 			return this.fvApi.GetScnTextEx(row, column, length); // returns a promise
  484. 		};
  485. 		/**  @memberof! FVSessions.Session.prototype
  486. 		 * @description Send a set of keys to the session, should end with Enter or Function key
  487. 		* @param {String} transactions  Transactions to run separated by the vertical bar (|) -- grammar for each transaction: 
  488. 		* <ul style=list-style:none;">
  489. 		* <li>F^row^column=move cursor to location;</li>
  490. 		* <li>H^enterKeys^waitForScreen= enterkeys that end with enter or function key and waitForScreen is a screen in the active application's definition file</li>
  491. 		* <li>I^keystrokes= keystrokes are a mix of text and @T for tab and so on (default action if no I^ is present at start of the transaction)</li>
  492. 		* <li>T^text^row^column=Enter text into an unprotected field at row and column where each starts with 1</li>
  493. 		* <li>S^milliseconds=Sleep for the milliseconds like S^2000 for 2 second sleep</li>
  494. 		* <li>W^milliseconds^waitForScreen=Sleep for the milliseconds like S^2000 for 2 second sleep but if screen comes in move on</li>
  495. 		* </ul>
  496. 		* Example: H^RMIS@E^RMIS|T^123456789^3^23|T^10081958^5^23|H^@E^RMIM will enter the transaction "RMIS" then wait for a screen identified as RMIS;
  497. 		* then it will key "123456789" at a field at row 3 column 23; then a field "10081958" at row 5, column 23; then will send an ENTER and wait again for RMIS to appear
  498. 		* @param {function(screenName)} onComplete  Optional completion function for when the transactions are completed
  499. 		* @param {boolean} bubble Set true for screen updates to be bubbled to the onload
  500. 		*/
  501. 		FVSESS.Transactions = function (transactions, onComplete, bubble)
  502. 		{
  503. 			this.fvApi.Transactions(transactions, onComplete, bubble);
  504. 		};
  506. 		/**  @memberof! FVSessions.Session.prototype
  507. 		* @description Set a field's value for MsgAPI use await to ensure synchronous operation
  508. 		* @param {String} text  Text to set into an unprotected entry field on the screen
  509. 		* @param {integer} row  Row to set the text on starting with 1
  510. 		* @param {integer} column Column to set thet ext on starting with 1
  511. 	   * @returns {Boolean} Function succeeded (MsgAPI only)
  512. 		*/
  513. 		FVSESS.SetField = function (text, row, column)
  514. 		{
  515. 			var me = this;
  516. 			return new Promise(async (resolve) =>
  517. 			{
  518. 				var ok=await me.fvApi.SetField(row, column, text);
  519. 				resolve(ok);
  520. 			});
  521. 		};
  522. 	};
  524. 	/**  @memberof! FVSessions.Session.prototype
  525. 	* @description Internal use only function used to set functions when FVSessions.config.msgAPI is false
  526. 	*/
  527. 	FVSessions.SetLocalMethods = function ()
  528. 	{
  529. 		/** @memberof! FVSessions.Session.prototype
  530. 		 * @description Split keys so that hllapi enters and function keys break into individual objects -- 
  531. 		 * NOT SUPPORTED for MsgAPI=true
  532. 		* @param {String} text Hllapi string with @ mnemonics (not [enter] style for now!)
  533. 		* @returns {Object}	Array of strings where each has keys ending with an AID (enter/function)
  534. 		*/
  535. 		FVSESS.SplitKeys = function (text)
  536. 		{
  537. 			try
  538. 			{
  539. 				var i, ch, parts = [], keys, start = 0, state = 0;
  540. 				for (i = 0; i < text.length; i++)
  541. 				{
  542. 					ch = text.substr(i, 1);
  543. 					switch (state)
  544. 					{
  545. 						case 0:
  546. 							start = i;
  547. 							state = 1;
  548. 						// fall through
  549. 						case 1:
  550. 							if (ch == '@')
  551. 								state = 2;
  552. 							break;
  553. 						case 2:
  554. 							if (enterKeys.indexOf(ch) != -1)
  555. 							{
  556. 								parts.push(text.substr(start, (i - start) + 1));
  557. 								state = 0;
  558. 							}
  559. 							else
  560. 								state = 1;
  561. 							break;
  562. 					}
  563. 				}
  564. 				return parts;
  565. 			}
  566. 			catch (e)
  567. 			{
  568. 				log('SplitKeys exception=' + e);
  569. 				return [text];
  570. 			}
  571. 		};
  573. 		FVSESS.Close = function ()
  574. 		{
  575. 			if (this.status != 'offline')
  576. 			{
  577. 				try
  578. 				{
  579. 					this.fvApi.fvWin.CloseTerm();
  580. 				}
  581. 				catch (e) { }
  582. 			}
  583. 		};
  585. 		FVSESS.SetFocus = function (focusOn, activate)
  586. 		{
  587. 			if (this.status != 'offline')
  588. 			{
  589. 				try
  590. 				{
  591. 					if (focusOn)
  592. 					{
  593. 						this.fvApi.fvWin.EmActive(2, 'FVSession');
  594. 						if (activate)
  595. 							this.fvApi.fvWin.SCSetTermFocus();
  596. 					}
  597. 					else
  598. 					{
  599. 						this.fvApi.fvWin.EmActive(-1, 'FVSession');
  600. 					}
  601. 				}
  602. 				catch (e) { }
  603. 			}
  604. 		};
  606. 		FVSESS.GetScreenText = async function (row, column, length)
  607. 		{
  608. 			return new Promise((resolve) =>
  609. 			{
  610. 				resolve(this.fvApi.GetScnTextEx(row, column, length));
  611. 			});
  612. 		};
  614. 		FVSESS.Transactions = function (transactions, onComplete, bubble)
  615. 		{
  616. 			var me = this, lastScreen = this.screenName, timeoutHandle = null, atTran = 0, parts, tran, wait = false, waitingFor = '*', trans = transactions.split('|'),
  617. 				topHasFocus = this.fvApi.fvWin.topHasFocus,
  618. 				nextTran = function ()
  619. 				{
  620. 					atTran++;
  621. 					if (timeoutHandle)
  622. 					{
  623. 						clearTimeout(timeoutHandle);
  624. 						timeoutHandle = null;
  625. 					}
  626. 					if (atTran < trans.length)
  627. 					{
  628. 						if (trans[atTran] == '')
  629. 							nextTran();
  630. 						else
  631. 							window.setTimeout(function () { innerExec() }, 1); // let current screen event complete!
  632. 					}
  633. 					else
  634. 					{
  635. 						fixFocus();
  636. 						if (onComplete)
  637. 							onComplete(lastScreen);
  638. 					}
  639. 				},
  640. 				fixFocus = function ()
  641. 				{
  642. 					if (me.fvApi.fvWin.topHasFocus != topHasFocus)
  643. 						me.fvApi.fvWin.EmActive((topHasFocus) ? 1 : 0, 'FVSess.Transactions');
  644. 					//log('Transactions end topHasfocus=' + me.fvApi.fvWin.topHasFocus);
  645. 				},
  646. 				screenWaiter = function (rows, screenName)
  647. 				{
  648. 					//log(me.id + ' Transactions screenWaiter waitingFor=' + waitingFor + ' result screenName=' + screenName);
  649. 					lastScreen = screenName;
  650. 					if (waitingFor == '*') // any screen
  651. 						nextTran();
  652. 					else
  653. 					{
  654. 						if (screenName != waitingFor)
  655. 							me.fvApi.fnNextScreen = screenWaiter;
  656. 						else
  657. 							nextTran();
  658. 					}
  659. 					return bubble; // determines if next screen is bubbled up
  660. 				},
  661. 				innerExec = function ()
  662. 				{
  663. 					tran = trans[atTran];
  664. 					parts = (tran.indexOf('^') == -1) ? ['I', tran] : tran.split('^');
  665. 					//log(me.id + ' ('+me.sessionKey+') Transactions innerExec atTran=' + atTran + ' trans.length=' + trans.length+' transaction=' + tran);
  666. 					try
  667. 					{
  668. 						switch (parts[0])
  669. 						{
  670. 							case 'F': // move cursor to location
  671. 								me.fvApi.SetCursor(parseInt(parts[1]), parseInt(parts[2]));
  672. 								nextTran();
  673. 								break;
  674. 							case 'H': // send hllapi and wait for screen
  675. 								waitingFor = parts[2];
  676. 								//log(me.id + ' Transactions send and wait=' + parts[1] + ', ' + waitingFor);
  677. 								me.fvApi.SendKeys(parts[1], screenWaiter);
  678. 								timeoutHandle = window.setTimeout(function ()
  679. 								{
  680. 									// If we hit this a wait function went longer than 30 seconds
  681. 									atTran = trans.length;
  682. 									fixFocus();
  683. 									if (onComplete)
  684. 										onComplete(lastScreen, 'TIMED-OUT waiting for ' + waitingFor);
  685. 								}, 30000);
  686. 								break;
  687. 							case 'W': // wait for screen or timeout
  688. 								waitingFor = parts[2];
  689. 								me.fvApi.fnNextScreen = screenWaiter;
  690. 								timeoutHandle = window.setTimeout(function ()
  691. 								{
  692. 									// If we hit this a wait function went longer than wait point
  693. 									nextTran();
  694. 								}, parseInt(parts[1]));
  695. 								break;
  696. 							case 'I': // just perform keystrokes
  697. 								waitingFor = '*';
  698. 								//me.fvApi.SendKeys(parts[1], screenWaiter);
  699. 								if (me.TypeKeys(parts[1], screenWaiter))
  700. 									nextTran();
  701. 								break;
  702. 							case 'T': // Type text into row column
  703. 								me.TypeAtRowCol(parts[1], parseInt(parts[2]), parseInt(parts[3]));
  704. 								nextTran();
  705. 								break;
  706. 							case 'S':
  707. 								window.setTimeout(function () { nextTran(); }, parseInt(parts[1]));
  708. 								break;
  709. 							default: // extra | maybe?
  710. 								nextTran();
  711. 								break;
  712. 						}
  713. 					}
  714. 					catch (e)
  715. 					{
  716. 						log(me.id + ' Transactions innerExec exception=' + e);
  717. 					}
  718. 				}
  719. 			bubble = (typeof (bubble) == 'undefined') ? false : bubble;
  720. 			//log('Transactions start topHasfocus=' + this.fvApi.fvWin.topHasFocus);		
  721. 			innerExec();
  722. 		};
  723. 		/** @memberof! FVSessions.Session.prototype
  724. 		* @description Type HLLAPI string starting at current row and column
  725. 		* NOT SUPPORTED for MsgAPI=true
  726. 		* @param {String} text  Text to type into unprotected entry field(s) on the screen, can include @T for tab and end
  727. 		* with @E or other AID string, which will be sent to the host for processing
  728. 		* @param {function(screenRows,screenName)} screenWaiter Provides callback instead of onLoad
  729. 		* @returns {boolean} Keys were typed OK
  730. 		*/
  731. 		FVSESS.TypeKeys = function (text, screenWaiter)
  732. 		{
  733. 			var me = this, i, ch, keys, state = 0,
  734. 				ev, kev, em = me.fvApi.emSess,
  735. 				fvWin = me.fvApi.fvWin,
  736. 				SetEV = function (chr)
  737. 				{
  738. 					ev = {};
  739. 					if (chr)
  740. 						ev.keyCode = chr.charCodeAt(0);
  741. 					kev = fvWin.SCKEV(em, -1, ev);
  742. 					kev.apiCall = true;
  743. 				};
  744. 			try
  745. 			{
  746. 				for (i = 0; i < text.length; i++)
  747. 				{
  748. 					ch = text.substr(i, 1);
  749. 					switch (state)
  750. 					{
  751. 						case 0:
  752. 							if (ch == '@')
  753. 								state = 1;
  754. 							else
  755. 							{
  756. 								// type character
  757. 								SetEV(ch);
  758. 								fvWin.SCKeyPress(em, ev, kev);
  759. 							}
  760. 							break;
  761. 						case 1:
  762. 							if (enterKeys.indexOf(ch) != -1) // AID, end of this!
  763. 							{
  764. 								me.fvApi.SendKeys(text.substr(i - 1), screenWaiter);
  765. 								return false;
  766. 							}
  767. 							else
  768. 							{
  769. 								state = 0; // assume single character
  770. 								SetEV();
  771. 								switch (ch)
  772. 								{
  773. 									case 'D':
  774. 										fvWin.SCDelete(em, kev);
  775. 										break;
  776. 									case 'q':
  777. 										fvWin.SCCursorEnd(em, kev);
  778. 										break;
  779. 									case '0':
  780. 										fvWin.CursorHome(em, kev, true);
  781. 										break;
  782. 									case 'A':
  783. 										state = 2;
  784. 										break;
  785. 									case 'C':
  786. 										state = 3;
  787. 										break;
  788. 									case 'F': // FieldExit
  789. 										fvWin.FieldExit(em, kev, 'NT');
  790. 										break;
  791. 									case 'T': // tab
  792. 										fvWin.SCTab(em, ev, kev);
  793. 										break;
  794. 									case 'B':
  795. 										fvWin.SCBackTab(em, ev, kev);
  796. 										break;
  797. 									case 'L':
  798. 										fvWin.CursorLeft(em, kev);
  799. 										break;
  800. 									case 'U':
  801. 										fvWin.CursorUp(em, kev);
  802. 										break;
  803. 									case 'Z':
  804. 										fvWin.CursorRight(em, kev);
  805. 										break;
  806. 									case 'V':
  807. 										fvWin.CursorDown(em, kev);
  808. 										break;
  809. 									default:
  810. 										log('TypeKeys unknown HLLAPI Code-@' + ch);
  811. 										break;
  812. 								}
  813. 							}
  814. 							break;
  815. 						case 2: // first char was 'A'
  816. 							if (ch == 'E')
  817. 								fvWin.FieldExit(em, kev, '+');
  818. 							else
  819. 								log('TypeKeys unknown HLLAPI Code-@A@' + ch);
  820. 							state = 0;
  821. 							break;
  822. 						case 3: // first char was 'C'
  823. 							if (ch == 'H')
  824. 								fvWin.SCBackSp(em, kev);
  825. 							else
  826. 								log('TypeKeys unknown HLLAPI Code-@C@' + ch);
  827. 							state = 0;
  828. 							break;
  829. 					}
  830. 				}
  831. 			}
  832. 			catch (e)
  833. 			{
  834. 				log('TypeKeys exception=' + e);
  835. 			}
  836. 			return true;
  837. 		};
  839. 		/**  @memberof! FVSessions.Session.prototype
  840. 		* @description Type text starting at a row and column - if length of text exceeds first field will autoskip to next
  841. 	   * NOT SUPPORTED FOR MsgAPI=true
  842. 		* @param {String} text  Text to type into unprotected entry field(s) on the screen
  843. 		* @param {integer} row  Row to type the text on starting with 1
  844. 		* @param {integer} column Column to type the text on starting with 1
  845. 		*/
  846. 		FVSESS.TypeAtRowCol = function (text, row, column)
  847. 		{
  848. 			var ev = {}, kev;
  849. 			ev.keyCode = 600;
  850. 			//log('TypeAtRowCol: "' + text + '" @' + row + ',' + column);
  851. 			this.fvApi.SetCursor(row, column);
  852. 			kev = this.fvApi.fvWin.SCKEV(this.fvApi.emSess, -1, ev);
  853. 			kev.apiCall = true;
  854. 			this.fvApi.fvWin.SCPaste(this.fvApi.emSess, kev, text);
  855. 		};
  857. 		FVSESS.SetField = function (text, row, column)
  858. 		{
  859. 			this.fvApi.SetField(row, column, text);
  860. 		};
  861. 	};
  863. 	/**  @memberof! FVSessions.Session.prototype
  864.    * @description Enter the active screen using a hllapi string
  865. 	* @param {String} enterKeys  Should be one or more keys with an enter/function/action key at the end like @E or @C ([enter] or [clear] or @T for Tabbing with ASCII host)
  866. 	* @param {function(screenName)} onComplete  Optional completion function for when the screen has been entered
  867. 	*/
  868. 	FVSESS.EnterScreen = function (enterKeys, onComplete)
  869. 	{
  870. 		this.fvApi.SendKeys(enterKeys, function (rows, screenName)
  871. 		{
  872. 			if (onComplete)
  873. 				onComplete(screenName);
  874. 		});
  875. 	};
  877. 	/**  @memberof! FVSessions.Session.prototype
  878. 	 * @description Set the status of the Session
  879. 	* @param {String} newStatus  Status which includes offline, started (needs logon) and ready (not on any logon screens)
  880. 	*/
  881. 	FVSESS.SetStatus = function (newStatus)
  882. 	{
  883. 		this.status = newStatus;
  884. 		switch (newStatus)
  885. 		{
  886. 			case 'offline':
  887. 				this.SaveSessionKey();
  888. 				break;
  889. 		}
  890. 	};
  892. 	/**  @memberof! FVSessions.Session.prototype
  893. 	 * @description Get the current session key from local storage
  894. 	* @returns {String} Sessionkey or null if not found
  895. 	*/
  896. 	FVSESS.GetSessionKey = function ()
  897. 	{
  898. 		var sessionKey = localStorage.getItem(this.storeId);
  899. 		log('GetSessionKey for ' + this.storeId + '=' + sessionKey);
  900. 		return sessionKey;
  901. 	};
  903. 	/**   @memberof! FVSessions.Session.prototype
  904. 	 * @description Save a sessionKey for this session to local storage
  905. 	* @param {String} sessionKey SessionKey to save -- if null, the localstorage will be cleared
  906. 	*/
  907. 	FVSESS.SaveSessionKey = function (sessionKey)
  908. 	{
  909. 		if (!this.connection.keepAliveOnClose)
  910. 			return; // only save sessionKey when keepAliveOnClose is true...
  911. 		if (!sessionKey)
  912. 		{
  913. 			this.sessionKey = null;
  914. 			log('SaveSessionKey deleted key for ' + this.storeId);
  915. 			localStorage.removeItem(this.storeId);
  916. 		}
  917. 		else
  918. 		{
  919. 			log('SaveSessionKey saved ' + sessionKey + ' for ' + this.storeId);
  920. 			this.sessionKey = sessionKey;
  921. 			localStorage.setItem(this.storeId, sessionKey);
  922. 		}
  923. 	};
  924. 	// #endregion Session Class
  925. }());