1 files changed, 90 insertions, 43 deletions

diff --git a/src/settingsdialognexus.cpp b/src/settingsdialognexus.cpp
index 29873d23..14a16204 100644
--- a/src/settingsdialognexus.cpp
+++ b/src/settingsdialognexus.cpp
@@ -1,6 +1,7 @@
 #include "settingsdialognexus.h"
 #include "log.h"
 #include "nexusinterface.h"
+#include "nexusoauthlogin.h"
 #include "serverinfo.h"
 #include "ui_nexusmanualkey.h"
 #include "ui_settingsdialog.h"
@@ -100,7 +101,19 @@ NexusConnectionUI::NexusConnectionUI(QWidget* parent, Settings* s,
     });
   }
 
-  if (GlobalSettings::hasNexusApiKey()) {
+  QObject::connect(NexusInterface::instance().getAccessManager(),
+                   &NXMAccessManager::updateOAuthState, this,
+                   [&](NXMAccessManager::OAuthState state, QString message) {
+                     onOAuthStateChanged(state, message);
+                   });
+
+  QObject::connect(NexusInterface::instance().getAccessManager(),
+                   &NXMAccessManager::tokensReceived, this,
+                   [&](const NexusOAuthTokens tokens) {
+                     onTokensReceived(tokens);
+                   });
+
+  if (GlobalSettings::hasNexusOAuthTokens() || GlobalSettings::hasNexusApiKey()) {
     addLog(tr("Connected."));
   } else {
     addLog(tr("Not connected."));
@@ -117,18 +130,11 @@ void NexusConnectionUI::connect()
   }
 
   if (!m_nexusLogin) {
-    m_nexusLogin.reset(new NexusSSOLogin);
-
-    m_nexusLogin->keyChanged = [&](auto&& s) {
-      onSSOKeyChanged(s);
-    };
-
-    m_nexusLogin->stateChanged = [&](auto&& s, auto&& e) {
-      onSSOStateChanged(s, e);
-    };
+    m_nexusLogin.reset(new NexusOAuthLogin(m_parent));
   }
 
   m_log->clear();
+  m_pendingTokens.reset();
   m_nexusLogin->start();
   updateState();
 }
@@ -147,22 +153,29 @@ void NexusConnectionUI::manual()
 
   const auto key = d.key();
   if (key.isEmpty()) {
-    clearKey();
+    clearCredentials();
     return;
   }
 
   m_log->clear();
-  validateKey(key);
+  auto tokens = NexusInterface::instance().getAccessManager()->tokens();
+  if (!tokens) {
+    tokens = NexusOAuthTokens();
+  }
+  tokens->apiKey = key;
+  NexusInterface::instance().getAccessManager()->setTokens(*tokens);
+  m_pendingTokens = tokens;
+  validateCredentials(*tokens);
 }
 
 void NexusConnectionUI::disconnect()
 {
-  clearKey();
+  clearCredentials();
   m_log->clear();
   addLog(tr("Disconnected."));
 }
 
-void NexusConnectionUI::validateKey(const QString& key)
+void NexusConnectionUI::validateCredentials(const NexusOAuthTokens& tokens)
 {
   if (!m_nexusValidator) {
     m_nexusValidator.reset(new NexusKeyValidator(
@@ -173,25 +186,40 @@ void NexusConnectionUI::validateKey(const QString& key)
     };
   }
 
-  addLog(tr("Checking API key..."));
-  m_nexusValidator->start(key, NexusKeyValidator::OneShot);
+  addLog(tr("Authorizing with Nexus..."));
+  m_nexusValidator->start(tokens, NexusKeyValidator::OneShot);
 }
 
-void NexusConnectionUI::onSSOKeyChanged(const QString& key)
+void NexusConnectionUI::onTokensReceived(const NexusOAuthTokens& tokens)
 {
-  if (key.isEmpty()) {
-    clearKey();
+  if (GlobalSettings::hasNexusOAuthTokens() || GlobalSettings::hasNexusApiKey()) {
+    NexusOAuthTokens oldTokens;
+    GlobalSettings::nexusOAuthTokens(oldTokens);
+    GlobalSettings::nexusApiKey(oldTokens.apiKey);
+    NexusOAuthTokens newTokens(tokens);
+    if (tokens.apiKey.isEmpty()) {
+      newTokens.apiKey = oldTokens.apiKey;
+    }
+    if (tokens.accessToken.isEmpty()) {
+      newTokens.accessToken  = oldTokens.accessToken;
+      newTokens.refreshToken = oldTokens.refreshToken;
+      newTokens.tokenType    = oldTokens.tokenType;
+      newTokens.expiresAt    = oldTokens.expiresAt;
+      newTokens.scope        = oldTokens.scope;
+    }
+    m_pendingTokens = newTokens;
   } else {
-    addLog(tr("Received API key."));
-    validateKey(key);
+    m_pendingTokens = tokens;
   }
+  addLog(tr("Received authorization from Nexus."));
+  validateCredentials(tokens);
 }
 
-void NexusConnectionUI::onSSOStateChanged(NexusSSOLogin::States s, const QString& e)
+void NexusConnectionUI::onOAuthStateChanged(NXMAccessManager::OAuthState s,
+                                            const QString& e)
 {
-  if (s != NexusSSOLogin::Finished) {
-    // finished state is handled in onSSOKeyChanged()
-    const auto log = NexusSSOLogin::stateToString(s, e);
+  if (s != NXMAccessManager::OAuthState::Finished) {
+    const auto log = NXMAccessManager::stateToString(s, e);
 
     for (auto&& line : log.split("\n")) {
       addLog(line);
@@ -205,14 +233,19 @@ void NexusConnectionUI::onValidatorFinished(ValidationAttempt::Result r,
                                             const QString& message,
                                             std::optional<APIUserAccount> user)
 {
+  Q_UNUSED(r);
   if (user) {
     NexusInterface::instance().setUserAccount(*user);
     addLog(tr("Received user account information"));
 
-    if (setKey(user->apiKey())) {
-      addLog(tr("Linked with Nexus successfully."));
+    if (m_pendingTokens) {
+      if (persistTokens(*m_pendingTokens)) {
+        addLog(tr("Linked with Nexus successfully."));
+      } else {
+        addLog(tr("Failed to store OAuth tokens."));
+      }
     } else {
-      addLog(tr("Failed to set API key"));
+      addLog(tr("Linked with Nexus successfully."));
     }
   } else {
     if (message.isEmpty()) {
@@ -223,6 +256,7 @@ void NexusConnectionUI::onValidatorFinished(ValidationAttempt::Result r,
     }
   }
 
+  m_pendingTokens.reset();
   updateState();
 }
 
@@ -232,26 +266,32 @@ void NexusConnectionUI::addLog(const QString& s)
   m_log->scrollToBottom();
 }
 
-bool NexusConnectionUI::setKey(const QString& key)
+bool NexusConnectionUI::persistTokens(const NexusOAuthTokens& tokens)
 {
-  const bool ret = GlobalSettings::setNexusApiKey(key);
+  const bool ret  = GlobalSettings::setNexusOAuthTokens(tokens);
+  const bool ret2 = GlobalSettings::setNexusApiKey(tokens.apiKey);
+  if (ret && ret2) {
+    NexusInterface::instance().getAccessManager()->setTokens(tokens);
+  }
+
   updateState();
 
   emit keyChanged();
 
-  return ret;
+  return ret && ret2;
 }
 
-bool NexusConnectionUI::clearKey()
+bool NexusConnectionUI::clearCredentials()
 {
-  const auto ret = GlobalSettings::clearNexusApiKey();
+  auto ret  = GlobalSettings::clearNexusOAuthTokens();
+  auto ret2 = GlobalSettings::clearNexusApiKey();
 
-  NexusInterface::instance().getAccessManager()->clearApiKey();
+  NexusInterface::instance().getAccessManager()->clearCredentials();
   updateState();
 
   emit keyChanged();
 
-  return ret;
+  return ret && ret2;
 }
 
 void NexusConnectionUI::updateState()
@@ -266,22 +306,29 @@ void NexusConnectionUI::updateState()
   };
 
   if (m_nexusLogin && m_nexusLogin->isActive()) {
-    // api key is in the process of being retrieved
     setButton(m_connect, true, QObject::tr("Cancel"));
     setButton(m_disconnect, false);
     setButton(m_manual, false, QObject::tr("Enter API Key Manually"));
   } else if (m_nexusValidator && m_nexusValidator->isActive()) {
-    // api key is in the process of being tested
     setButton(m_connect, false, QObject::tr("Connect to Nexus"));
     setButton(m_disconnect, false);
-    setButton(m_manual, true, QObject::tr("Cancel"));
-  } else if (GlobalSettings::hasNexusApiKey()) {
-    // api key is present
-    setButton(m_connect, false, QObject::tr("Connect to Nexus"));
+  } else if (GlobalSettings::hasNexusOAuthTokens() ||
+             GlobalSettings::hasNexusApiKey()) {
+    NexusOAuthTokens tokens;
+    GlobalSettings::nexusOAuthTokens(tokens);
+    GlobalSettings::nexusApiKey(tokens.apiKey);
+    if (tokens.accessToken.isEmpty()) {
+      setButton(m_connect, true, QObject::tr("Connect to Nexus"));
+    } else {
+      setButton(m_connect, false, QObject::tr("Connect to Nexus"));
+    }
     setButton(m_disconnect, true);
-    setButton(m_manual, false, QObject::tr("Enter API Key Manually"));
+    if (tokens.apiKey.isEmpty()) {
+      setButton(m_manual, true, QObject::tr("Enter API Key Manually"));
+    } else {
+      setButton(m_manual, false, QObject::tr("Enter API Key Manually"));
+    }
   } else {
-    // api key not present
     setButton(m_connect, true, QObject::tr("Connect to Nexus"));
     setButton(m_disconnect, false);
     setButton(m_manual, true, QObject::tr("Enter API Key Manually"));