private handleSessionCreatedNotification()

in src/objectExplorer/objectExplorerService.ts [70:148]
68 lines of code
19 McCabe index (conditional complexity)

	private handleSessionCreatedNotification(): NotificationHandler<SessionCreatedParameters> {
		const self = this;
		const handler = async (result: SessionCreatedParameters) => {
			if (self._currentNode instanceof ConnectTreeNode) {
				self.currentNode = getParentNode(self.currentNode);
			}
			if (result.success) {
				let nodeLabel = this._nodePathToNodeLabelMap.get(result.rootNode.nodePath);
				// if no node label, check if it has a name in saved profiles
				// in case this call came from new query
				let savedConnections = this._connectionManager.connectionStore.loadAllConnections();
				let nodeConnection = this._sessionIdToConnectionCredentialsMap.get(result.sessionId);
				for (let connection of savedConnections) {
					if (Utils.isSameConnection(connection.connectionCreds, nodeConnection)) {
						// if it's not the defaul label
						if (connection.label !== connection.connectionCreds.server) {
							nodeLabel = connection.label;
						}
						break;
					}
				}
				// set connection and other things
				let node: TreeNodeInfo;

				if (self._currentNode && (self._currentNode.sessionId === result.sessionId)) {
					nodeLabel = !nodeLabel ? self.createNodeLabel(self._currentNode.connectionInfo) : nodeLabel;
					node = TreeNodeInfo.fromNodeInfo(result.rootNode, result.sessionId,
						undefined, self._currentNode.connectionInfo, nodeLabel, Constants.serverLabel);
				} else {
					nodeLabel = !nodeLabel ? self.createNodeLabel(nodeConnection) : nodeLabel;
					node = TreeNodeInfo.fromNodeInfo(result.rootNode, result.sessionId,
						undefined, nodeConnection, nodeLabel, Constants.serverLabel);
				}
				// make a connection if not connected already
				const nodeUri = ObjectExplorerUtils.getNodeUri(node);
				if (!this._connectionManager.isConnected(nodeUri) &&
					!this._connectionManager.isConnecting(nodeUri)) {
					const profile = <IConnectionProfile>node.connectionInfo;
					await this._connectionManager.connect(nodeUri, profile);
				}

				self.updateNode(node);
				self._objectExplorerProvider.objectExplorerExists = true;
				const promise = self._sessionIdToPromiseMap.get(result.sessionId);
				// remove the sign in node once the session is created
				if (self._treeNodeToChildrenMap.has(node)) {
					self._treeNodeToChildrenMap.delete(node);
				}
				return promise.resolve(node);
			} else {
				// create session failure
				if (self._currentNode.connectionInfo?.password) {
					self._currentNode.connectionInfo.password = '';
				}
				let error = LocalizedConstants.connectErrorLabel;
				if (result.errorMessage) {
					error += ` : ${result.errorMessage}`;
				}
				self._connectionManager.vscodeWrapper.showErrorMessage(error);
				const promise = self._sessionIdToPromiseMap.get(result.sessionId);

				// handle session failure because of firewall issue
				if (ObjectExplorerUtils.isFirewallError(result.errorMessage)) {
					let handleFirewallResult = await self._connectionManager.firewallService.handleFirewallRule
						(Constants.errorFirewallRule, result.errorMessage);
					if (handleFirewallResult.result && handleFirewallResult.ipAddress) {
						const nodeUri = ObjectExplorerUtils.getNodeUri(self._currentNode);
						const profile = <IConnectionProfile>self._currentNode.connectionInfo;
						self.updateNode(self._currentNode);
						self._connectionManager.connectionUI.handleFirewallError(nodeUri, profile, handleFirewallResult.ipAddress);
					}
				}
				if (promise) {
					return promise.resolve(undefined);
				}
			}
		};
		return handler;
	}