Refactor: Return without json

1 files changed, 241 insertions, 55 deletions

diff --git a/state.go b/state.go
index 1354ffc..4911ac9 100644
--- a/state.go
+++ b/state.go
@@ -14,9 +14,15 @@ import (
 	"github.com/jwijenbergh/eduvpn-common/internal/util"
 )
 
-type ServerInfo = server.ServerInfoScreen
+type (
+	ServerInfo    = server.ServerInfoScreen
+	VPNServerBase = server.ServerBase
+)
 
 type VPNState struct {
+	// The language used for language matching
+	Language string `json:"-"` // language should not be saved
+
 	// The chosen server
 	Servers server.Servers `json:"servers"`
 
@@ -40,6 +46,7 @@ func (state *VPNState) GetSavedServers() *server.ServersConfiguredScreen {
 	return state.Servers.GetServersConfigured()
 }
 
+// TODO: Refactor this to a `New` method?
 func (state *VPNState) Register(
 	name string,
 	directory string,
@@ -55,6 +62,7 @@ func (state *VPNState) Register(
 	}
 	// Initialize the logger
 	logLevel := log.LOG_WARNING
+	state.Language = "en"
 
 	if debug {
 		logLevel = log.LOG_INFO
@@ -83,18 +91,28 @@ func (state *VPNState) Register(
 	_, currentServerErr := state.Servers.GetCurrentServer()
 	// Only actually return the error if we have no disco servers and no current server
 	if discoServersErr != nil && discoServers == "" && currentServerErr != nil {
-		state.Logger.Error(fmt.Sprintf("No configured servers, discovery servers is empty and no servers with error: %s", GetErrorTraceback(discoServersErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"No configured servers, discovery servers is empty and no servers with error: %s",
+				GetErrorTraceback(discoServersErr),
+			),
+		)
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: discoServersErr}
 	}
 	discoOrgs, discoOrgsErr := state.GetDiscoOrganizations()
 
 	// Only actually return the error if we have no disco organizations and no current server
-	if discoOrgsErr != nil && discoOrgs == "" && currentServerErr != nil {
-		state.Logger.Error(fmt.Sprintf("No configured organizations, discovery organizations empty and no servers with error: %s", GetErrorTraceback(discoOrgsErr)))
+	if discoOrgsErr != nil && discoOrgs.Version == 0 && currentServerErr != nil {
+		state.Logger.Error(
+			fmt.Sprintf(
+				"No configured organizations, discovery organizations empty and no servers with error: %s",
+				GetErrorTraceback(discoOrgsErr),
+			),
+		)
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: discoOrgsErr}
 	}
 	// Go to the No Server state with the saved servers
-	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.GetSavedServers(), true)
+	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.Servers, true)
 	return nil
 }
 
@@ -121,7 +139,7 @@ func (state *VPNState) GoBack() error {
 	}
 
 	// FIXME: Abitrary back transitions don't work because we need the approriate data
-	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.GetSavedServers(), false)
+	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.Servers, false)
 	// state.FSM.GoBack()
 	return nil
 }
@@ -157,7 +175,10 @@ func (state *VPNState) ensureLogin(chosenServer server.Server) error {
 	return nil
 }
 
-func (state *VPNState) getConfigAuth(chosenServer server.Server, forceTCP bool) (string, string, error) {
+func (state *VPNState) getConfigAuth(
+	chosenServer server.Server,
+	forceTCP bool,
+) (string, string, error) {
 	loginErr := state.ensureLogin(chosenServer)
 	if loginErr != nil {
 		return "", "", loginErr
@@ -181,7 +202,10 @@ func (state *VPNState) getConfigAuth(chosenServer server.Server, forceTCP bool)
 	return server.GetConfig(chosenServer, forceTCP)
 }
 
-func (state *VPNState) retryConfigAuth(chosenServer server.Server, forceTCP bool) (string, string, error) {
+func (state *VPNState) retryConfigAuth(
+	chosenServer server.Server,
+	forceTCP bool,
+) (string, string, error) {
 	errorMessage := "failed authorized config retry"
 	config, configType, configErr := state.getConfigAuth(chosenServer, forceTCP)
 	if configErr != nil {
@@ -189,10 +213,16 @@ func (state *VPNState) retryConfigAuth(chosenServer server.Server, forceTCP bool
 
 		// Only retry if the error is that the tokens are invalid
 		if errors.As(configErr, &error) {
-			retryConfig, retryConfigType, retryConfigErr := state.getConfigAuth(chosenServer, forceTCP)
+			retryConfig, retryConfigType, retryConfigErr := state.getConfigAuth(
+				chosenServer,
+				forceTCP,
+			)
 			if retryConfigErr != nil {
 				state.GoBack()
-				return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: retryConfigErr}
+				return "", "", &types.WrappedErrorMessage{
+					Message: errorMessage,
+					Err:     retryConfigErr,
+				}
 			}
 			return retryConfig, retryConfigType, nil
 		}
@@ -202,7 +232,6 @@ func (state *VPNState) retryConfigAuth(chosenServer server.Server, forceTCP bool
 	return config, configType, nil
 }
 
-
 func (state *VPNState) getConfig(
 	chosenServer server.Server,
 	forceTCP bool,
@@ -221,8 +250,13 @@ func (state *VPNState) getConfig(
 		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
 	}
 
+	currentServer, currentServerErr := state.Servers.GetCurrentServer()
+	if currentServerErr != nil {
+		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+	}
+
 	// Signal the server display info
-	state.FSM.GoTransitionWithData(STATE_DISCONNECTED, state.getServerInfoData(), false)
+	state.FSM.GoTransitionWithData(STATE_DISCONNECTED, currentServer, false)
 
 	// Save the config
 	state.Config.Save(&state)
@@ -235,14 +269,25 @@ func (state *VPNState) SetSecureLocation(countryCode string) error {
 
 	server, serverErr := state.Discovery.GetServerByCountryCode(countryCode, "secure_internet")
 	if serverErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed getting secure internet server by country code: %s with error: %s", countryCode, GetErrorTraceback(serverErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed getting secure internet server by country code: %s with error: %s",
+				countryCode,
+				GetErrorTraceback(serverErr),
+			),
+		)
 		state.GoBack()
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
 	}
 
 	setLocationErr := state.Servers.SetSecureLocation(server)
 	if setLocationErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed setting secure internet server with error: %s", GetErrorTraceback(serverErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed setting secure internet server with error: %s",
+				GetErrorTraceback(serverErr),
+			),
+		)
 		state.GoBack()
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: setLocationErr}
 	}
@@ -267,7 +312,10 @@ func (state *VPNState) askSecureLocation() error {
 	// The state has changed, meaning setting the secure location was not successful
 	if state.FSM.Current != STATE_ASK_LOCATION {
 		// TODO: maybe a custom type for this errors.new?
-		return &types.WrappedErrorMessage{Message: "failed setting secure location", Err: errors.New("failed loading secure location")}
+		return &types.WrappedErrorMessage{
+			Message: "failed setting secure location",
+			Err:     errors.New("failed loading secure location"),
+		}
 	}
 	return nil
 }
@@ -316,7 +364,7 @@ func (state *VPNState) RemoveSecureInternet() error {
 	}
 	// No error because we can only have one secure internet server and if there are no secure internet servers, this is a NO-OP
 	state.Servers.RemoveSecureInternet()
-	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.GetSavedServers(), false)
+	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.Servers, false)
 	// Save the config
 	state.Config.Save(&state)
 	return nil
@@ -331,7 +379,7 @@ func (state *VPNState) RemoveInstituteAccess(url string) error {
 	}
 	// No error because this is a NO-OP if the server doesn't exist
 	state.Servers.RemoveInstituteAccess(url)
-	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.GetSavedServers(), false)
+	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.Servers, false)
 	// Save the config
 	state.Config.Save(&state)
 	return nil
@@ -346,7 +394,7 @@ func (state *VPNState) RemoveCustomServer(url string) error {
 	}
 	// No error because this is a NO-OP if the server doesn't exist
 	state.Servers.RemoveCustomServer(url)
-	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.GetSavedServers(), false)
+	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.Servers, false)
 	// Save the config
 	state.Config.Save(&state)
 	return nil
@@ -363,7 +411,12 @@ func (state *VPNState) GetConfigSecureInternet(
 	state.FSM.GoTransition(STATE_LOADING_SERVER)
 	server, serverErr := state.addSecureInternetHomeServer(orgID)
 	if serverErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed adding a secure internet server with error: %s", GetErrorTraceback(serverErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed adding a secure internet server with error: %s",
+				GetErrorTraceback(serverErr),
+			),
+		)
 		state.GoBack()
 		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
 	}
@@ -372,7 +425,12 @@ func (state *VPNState) GetConfigSecureInternet(
 
 	config, configType, configErr := state.getConfig(server, forceTCP)
 	if configErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed getting a secure internet configuration with error: %s", GetErrorTraceback(configErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed getting a secure internet configuration with error: %s",
+				GetErrorTraceback(configErr),
+			),
+		)
 		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
 	}
 	return config, configType, nil
@@ -425,14 +483,24 @@ func (state *VPNState) GetConfigInstituteAccess(url string, forceTCP bool) (stri
 	state.FSM.GoTransition(STATE_LOADING_SERVER)
 	server, serverErr := state.addInstituteServer(url)
 	if serverErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed adding an institute access server with error: %s", GetErrorTraceback(serverErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed adding an institute access server with error: %s",
+				GetErrorTraceback(serverErr),
+			),
+		)
 		state.GoBack()
 		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
 	}
 
 	config, configType, configErr := state.getConfig(server, forceTCP)
 	if configErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed getting an institute access server configuration with error: %s", GetErrorTraceback(configErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed getting an institute access server configuration with error: %s",
+				GetErrorTraceback(configErr),
+			),
+		)
 		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
 	}
 	return config, configType, nil
@@ -444,14 +512,24 @@ func (state *VPNState) GetConfigCustomServer(url string, forceTCP bool) (string,
 	server, serverErr := state.addCustomServer(url)
 
 	if serverErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed adding a custom server with error: %s", GetErrorTraceback(serverErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed adding a custom server with error: %s",
+				GetErrorTraceback(serverErr),
+			),
+		)
 		state.GoBack()
 		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
 	}
 
 	config, configType, configErr := state.getConfig(server, forceTCP)
 	if configErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed getting a custom server with error: %s", GetErrorTraceback(configErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed getting a custom server with error: %s",
+				GetErrorTraceback(configErr),
+			),
+		)
 		return "", "", &types.WrappedErrorMessage{Message: errorMessage, Err: configErr}
 	}
 	return config, configType, nil
@@ -472,7 +550,12 @@ func (state *VPNState) CancelOAuth() error {
 
 	currentServer, serverErr := state.Servers.GetCurrentServer()
 	if serverErr != nil {
-		state.Logger.Warning(fmt.Sprintf("Failed cancelling OAuth, no server configured to cancel OAuth for (err: %v)", serverErr))
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed cancelling OAuth, no server configured to cancel OAuth for (err: %v)",
+				serverErr,
+			),
+		)
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
 	}
 	server.CancelOAuth(currentServer)
@@ -486,27 +569,43 @@ func (state *VPNState) ChangeSecureLocation() error {
 		state.Logger.Error("Failed changing secure internet location, not in the right state")
 		return &types.WrappedErrorMessage{
 			Message: errorMessage,
-			Err:     FSMWrongStateError{Got: state.FSM.Current, Want: STATE_NO_SERVER}.CustomError(),
+			Err: FSMWrongStateError{
+				Got:  state.FSM.Current,
+				Want: STATE_NO_SERVER,
+			}.CustomError(),
 		}
 	}
 
 	askLocationErr := state.askSecureLocation()
 	if askLocationErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed changing secure internet location, err: %s", GetErrorTraceback(askLocationErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed changing secure internet location, err: %s",
+				GetErrorTraceback(askLocationErr),
+			),
+		)
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: askLocationErr}
 	}
 
 	// Go back to the main screen
-	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.GetSavedServers(), false)
+	state.FSM.GoTransitionWithData(STATE_NO_SERVER, state.Servers, false)
 
 	return nil
 }
 
-func (state *VPNState) GetDiscoOrganizations() (string, error) {
+func (state *VPNState) GetDiscoOrganizations() (*types.DiscoveryOrganizations, error) {
 	orgs, orgsErr := state.Discovery.GetOrganizationsList()
 	if orgsErr != nil {
-		state.Logger.Warning(fmt.Sprintf("Failed getting discovery organizations, Err: %s", GetErrorTraceback(orgsErr)))
-		return "", &types.WrappedErrorMessage{Message: "failed getting discovery organizations list", Err: orgsErr}
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed getting discovery organizations, Err: %s",
+				GetErrorTraceback(orgsErr),
+			),
+		)
+		return nil, &types.WrappedErrorMessage{
+			Message: "failed getting discovery organizations list",
+			Err:     orgsErr,
+		}
 	}
 	return orgs, nil
 }
@@ -514,8 +613,13 @@ func (state *VPNState) GetDiscoOrganizations() (string, error) {
 func (state *VPNState) GetDiscoServers() (string, error) {
 	servers, serversErr := state.Discovery.GetServersList()
 	if serversErr != nil {
-		state.Logger.Warning(fmt.Sprintf("Failed getting discovery servers, Err: %s", GetErrorTraceback(serversErr)))
-		return "", &types.WrappedErrorMessage{Message: "failed getting discovery servers list", Err: serversErr}
+		state.Logger.Warning(
+			fmt.Sprintf("Failed getting discovery servers, Err: %s", GetErrorTraceback(serversErr)),
+		)
+		return "", &types.WrappedErrorMessage{
+			Message: "failed getting discovery servers list",
+			Err:     serversErr,
+		}
 	}
 	return servers, nil
 }
@@ -524,14 +628,21 @@ func (state *VPNState) SetProfileID(profileID string) error {
 	errorMessage := "failed to set the profile ID for the current server"
 	server, serverErr := state.Servers.GetCurrentServer()
 	if serverErr != nil {
-		state.Logger.Warning(fmt.Sprintf("Failed setting a profile ID because no server configured, Err: %s", GetErrorTraceback(serverErr)))
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed setting a profile ID because no server configured, Err: %s",
+				GetErrorTraceback(serverErr),
+			),
+		)
 		state.GoBack()
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: serverErr}
 	}
 
 	base, baseErr := server.GetBase()
 	if baseErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed setting a profile ID, Err: %s", GetErrorTraceback(serverErr)))
+		state.Logger.Error(
+			fmt.Sprintf("Failed setting a profile ID, Err: %s", GetErrorTraceback(serverErr)),
+		)
 		state.GoBack()
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: baseErr}
 	}
@@ -541,7 +652,12 @@ func (state *VPNState) SetProfileID(profileID string) error {
 
 func (state *VPNState) SetSearchServer() error {
 	if !state.FSM.HasTransition(STATE_SEARCH_SERVER) {
-		state.Logger.Warning(fmt.Sprintf("Failed setting search server, wrong state %s", GetStateName(state.FSM.Current)))
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed setting search server, wrong state %s",
+				GetStateName(state.FSM.Current),
+			),
+		)
 		return &types.WrappedErrorMessage{
 			Message: "failed to set search server",
 			Err: FSMWrongStateTransitionError{
@@ -558,21 +674,32 @@ func (state *VPNState) SetSearchServer() error {
 func (state *VPNState) getServerInfoData() *server.ServerInfoScreen {
 	info, infoErr := state.Servers.GetCurrentServerInfo()
 	if infoErr != nil {
-		state.Logger.Error(fmt.Sprintf("Failed getting server info data with error: %s", GetErrorTraceback(infoErr)))
+		state.Logger.Error(
+			fmt.Sprintf(
+				"Failed getting server info data with error: %s",
+				GetErrorTraceback(infoErr),
+			),
+		)
 	}
 	return info
 }
 
 func (state *VPNState) SetConnected() error {
+	errorMessage := "failed to set connected"
 	if state.InFSMState(STATE_CONNECTED) {
 		// already connected, show no error
 		state.Logger.Warning("Already connected")
 		return nil
 	}
 	if !state.FSM.HasTransition(STATE_CONNECTED) {
-		state.Logger.Warning(fmt.Sprintf("Failed setting connected, wrong state: %s", GetStateName(state.FSM.Current)))
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed setting connected, wrong state: %s",
+				GetStateName(state.FSM.Current),
+			),
+		)
 		return &types.WrappedErrorMessage{
-			Message: "failed to set connected",
+			Message: errorMessage,
 			Err: FSMWrongStateTransitionError{
 				Got:  state.FSM.Current,
 				Want: STATE_CONNECTED,
@@ -580,7 +707,18 @@ func (state *VPNState) SetConnected() error {
 		}
 	}
 
-	state.FSM.GoTransitionWithData(STATE_CONNECTED, state.getServerInfoData(), false)
+	currentServer, currentServerErr := state.Servers.GetCurrentServer()
+	if currentServerErr != nil {
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed setting connected, cannot get current server with error: %s",
+				GetErrorTraceback(currentServerErr),
+			),
+		)
+		return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+	}
+
+	state.FSM.GoTransitionWithData(STATE_CONNECTED, currentServer, false)
 	return nil
 }
 
@@ -591,7 +729,12 @@ func (state *VPNState) SetConnecting() error {
 		return nil
 	}
 	if !state.FSM.HasTransition(STATE_CONNECTING) {
-		state.Logger.Warning(fmt.Sprintf("Failed setting connecting, wrong state: %s", GetStateName(state.FSM.Current)))
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed setting connecting, wrong state: %s",
+				GetStateName(state.FSM.Current),
+			),
+		)
 		return &types.WrappedErrorMessage{
 			Message: "failed to set connecting",
 			Err: FSMWrongStateTransitionError{
@@ -606,15 +749,21 @@ func (state *VPNState) SetConnecting() error {
 }
 
 func (state *VPNState) SetDisconnecting() error {
+	errorMessage := "failed to set disconnecting"
 	if state.InFSMState(STATE_DISCONNECTING) {
 		// already disconnecting, show no error
 		state.Logger.Warning("Already disconnecting")
 		return nil
 	}
 	if !state.FSM.HasTransition(STATE_DISCONNECTING) {
-		state.Logger.Warning(fmt.Sprintf("Failed setting disconnecting, wrong state: %s", GetStateName(state.FSM.Current)))
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed setting disconnecting, wrong state: %s",
+				GetStateName(state.FSM.Current),
+			),
+		)
 		return &types.WrappedErrorMessage{
-			Message: "failed to set disconnecting",
+			Message: errorMessage,
 			Err: FSMWrongStateTransitionError{
 				Got:  state.FSM.Current,
 				Want: STATE_DISCONNECTING,
@@ -622,7 +771,18 @@ func (state *VPNState) SetDisconnecting() error {
 		}
 	}
 
-	state.FSM.GoTransitionWithData(STATE_DISCONNECTING, state.getServerInfoData(), false)
+	currentServer, currentServerErr := state.Servers.GetCurrentServer()
+	if currentServerErr != nil {
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed setting disconnected, cannot get current server with error: %s",
+				GetErrorTraceback(currentServerErr),
+			),
+		)
+		return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+	}
+
+	state.FSM.GoTransitionWithData(STATE_DISCONNECTING, currentServer, false)
 	return nil
 }
 
@@ -634,7 +794,12 @@ func (state *VPNState) SetDisconnected(cleanup bool) error {
 		return nil
 	}
 	if !state.FSM.HasTransition(STATE_DISCONNECTED) {
-		state.Logger.Warning(fmt.Sprintf("Failed setting disconnected, wrong state: %s", GetStateName(state.FSM.Current)))
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed setting disconnected, wrong state: %s",
+				GetStateName(state.FSM.Current),
+			),
+		)
 		return &types.WrappedErrorMessage{
 			Message: errorMessage,
 			Err: FSMWrongStateTransitionError{
@@ -644,18 +809,23 @@ func (state *VPNState) SetDisconnected(cleanup bool) error {
 		}
 	}
 
+	currentServer, currentServerErr := state.Servers.GetCurrentServer()
+	if currentServerErr != nil {
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed setting disconnect, failed getting current server with error: %s",
+				GetErrorTraceback(currentServerErr),
+			),
+		)
+		return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
+	}
+
 	if cleanup {
 		// Do the /disconnect API call and go to disconnected after...
-		currentServer, currentServerErr := state.Servers.GetCurrentServer()
-		if currentServerErr != nil {
-			state.Logger.Warning(fmt.Sprintf("Failed getting current server to send /disconnect API call, error: %s", GetErrorTraceback(currentServerErr)))
-			return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
-		}
-
 		server.Disconnect(currentServer)
 	}
 
-	state.FSM.GoTransitionWithData(STATE_DISCONNECTED, state.getServerInfoData(), false)
+	state.FSM.GoTransitionWithData(STATE_DISCONNECTED, currentServer, false)
 
 	return nil
 }
@@ -665,13 +835,23 @@ func (state *VPNState) RenewSession() error {
 
 	currentServer, currentServerErr := state.Servers.GetCurrentServer()
 	if currentServerErr != nil {
-		state.Logger.Warning(fmt.Sprintf("Failed getting current server to renew, error: %s", GetErrorTraceback(currentServerErr)))
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed getting current server to renew, error: %s",
+				GetErrorTraceback(currentServerErr),
+			),
+		)
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: currentServerErr}
 	}
 
 	loginErr := state.ensureLogin(currentServer)
 	if loginErr != nil {
-		state.Logger.Warning(fmt.Sprintf("Failed logging in server for renew, error: %s", GetErrorTraceback(loginErr)))
+		state.Logger.Warning(
+			fmt.Sprintf(
+				"Failed logging in server for renew, error: %s",
+				GetErrorTraceback(loginErr),
+			),
+		)
 		return &types.WrappedErrorMessage{Message: errorMessage, Err: loginErr}
 	}
 
@@ -679,7 +859,9 @@ func (state *VPNState) RenewSession() error {
 }
 
 func (state *VPNState) ShouldRenewButton() bool {
-	if !state.InFSMState(STATE_CONNECTED) && !state.InFSMState(STATE_CONNECTING) && !state.InFSMState(STATE_DISCONNECTED) && !state.InFSMState(STATE_DISCONNECTING) {
+	if !state.InFSMState(STATE_CONNECTED) && !state.InFSMState(STATE_CONNECTING) &&
+		!state.InFSMState(STATE_DISCONNECTED) &&
+		!state.InFSMState(STATE_DISCONNECTING) {
 		return false
 	}
 
@@ -717,3 +899,7 @@ func GetErrorTraceback(err error) string {
 func GetErrorJSONString(err error) (string, error) {
 	return types.GetErrorJSONString(err)
 }
+
+func (state *VPNState) GetTranslated(languages map[string]string) string {
+	return util.GetLanguageMatched(languages, state.Language)
+}