test

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/AutoConfig.cs

@@ -0,0 +1,76 @@
+using System;
+using Codice.Client.Common;
+using Codice.CM.Common;
+using Codice.LogWrapper;
+using PlasticGui;
+using PlasticGui.WorkspaceWindow.Home;
+using Unity.PlasticSCM.Editor.Configuration.CloudEdition.Welcome;
+using Unity.PlasticSCM.Editor.WebApi;
+using UnityEngine;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal static class AutoConfig
+    {
+        internal static TokenExchangeResponse PlasticCredentials(
+            string unityAccessToken,
+            string serverName)
+        {
+            SetupUnityEditionToken.CreateCloudEditionTokenIfNeeded();
+
+            var startTick = Environment.TickCount;
+
+            var tokenExchangeResponse = WebRestApiClient.PlasticScm.TokenExchange(unityAccessToken);
+
+            mLog.DebugFormat("TokenExchange time {0} ms", Environment.TickCount - startTick);
+
+            if (tokenExchangeResponse == null)
+            {
+                var warning = PlasticLocalization.GetString(PlasticLocalization.Name.TokenExchangeResponseNull);
+                mLog.Warn(warning);
+                Debug.LogWarning(warning);
+                return null;
+            }
+
+            if (tokenExchangeResponse.Error != null)
+            {
+                var warning = string.Format(
+                    PlasticLocalization.GetString(PlasticLocalization.Name.TokenExchangeResponseError),
+                    tokenExchangeResponse.Error.Message, tokenExchangeResponse.Error.ErrorCode);
+                mLog.ErrorFormat(warning);
+                Debug.LogWarning(warning);
+                return tokenExchangeResponse;
+            }
+
+            if (string.IsNullOrEmpty(tokenExchangeResponse.AccessToken))
+            {
+                var warning = string.Format(
+                    PlasticLocalization.GetString(PlasticLocalization.Name.TokenExchangeAccessEmpty), 
+                    tokenExchangeResponse.User);
+                mLog.InfoFormat(warning);
+                Debug.LogWarning(warning);
+                return tokenExchangeResponse;
+            }
+            
+            // This creates the client.conf if needed but doesn't overwrite it if it exists already,
+            // and it also updates the profiles.conf and tokens.conf with the new AccessToken
+            UserAccounts.SaveAccount(
+                serverName,
+                SEIDWorkingMode.SSOWorkingMode, // Hub sign-in working mode
+                tokenExchangeResponse.User,
+                tokenExchangeResponse.AccessToken,
+                null,
+                null,
+                null);
+
+            CloudEditionWelcomeWindow.SaveDefaultCloudServer(
+                serverName,
+                tokenExchangeResponse.User);
+
+            return tokenExchangeResponse;
+        }
+
+        static readonly ILog mLog = PlasticApp.GetLogger("AutoConfig");
+    }
+}
+

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/AutoConfig.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7c21251ff4b7d844292a388e81e47e59
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/ChannelCertificateUiImpl.cs

@@ -0,0 +1,93 @@
+using Codice.Client.Common;
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticPipe.Certificates;
+using Unity.PlasticSCM.Editor.UI;
+using UnityEditor;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal class ChannelCertificateUiImpl : IChannelCertificateUI
+    {
+        internal ChannelCertificateUiImpl()
+        {
+        }
+
+        CertOperationResult IChannelCertificateUI.AcceptNewServerCertificate(PlasticCertInfo serverCertificate)
+        {
+            return GetUserResponse(
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.NewCertificateTitle),
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.NewCertificateMessageUnityVCS),
+                serverCertificate);
+        }
+
+        CertOperationResult IChannelCertificateUI.AcceptChangedServerCertificate(PlasticCertInfo serverCertificate)
+        {
+            return GetUserResponse(
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.ExistingCertificateChangedTitle),
+                PlasticLocalization.GetString(
+                    PlasticLocalization.Name.ExistingCertificateChangedMessageUnityVCS),
+                serverCertificate);
+        }
+
+        bool IChannelCertificateUI.AcceptInvalidHostname(string certHostname, string serverHostname)
+        {
+            bool result = false;
+
+            GUIActionRunner.RunGUIAction(delegate {
+                result = EditorUtility.DisplayDialog(
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.InvalidCertificateHostnameTitle),
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.InvalidCertificateHostnameMessage,
+                        certHostname, serverHostname),
+                    PlasticLocalization.GetString(PlasticLocalization.Name.YesButton),
+                    PlasticLocalization.GetString(PlasticLocalization.Name.NoButton));
+            });
+
+            return result;
+        }
+
+        CertOperationResult GetUserResponse(
+            string title, string message, PlasticCertInfo serverCertificate)
+        {
+            GuiMessage.GuiMessageResponseButton result =
+                GuiMessage.GuiMessageResponseButton.Neutral;
+
+            GUIActionRunner.RunGUIAction(delegate {
+                result = GuiMessage.ShowQuestion(
+                    title,
+                    GetCertificateMessageString(message, serverCertificate),
+                    PlasticLocalization.GetString(PlasticLocalization.Name.YesButton),
+                    PlasticLocalization.GetString(PlasticLocalization.Name.CancelButton),
+                    PlasticLocalization.GetString(PlasticLocalization.Name.NoButton));
+            });
+
+            switch (result)
+            {
+                case GuiMessage.GuiMessageResponseButton.Positive:
+                    return CertOperationResult.AddToStore;
+                case GuiMessage.GuiMessageResponseButton.Negative:
+                    return CertOperationResult.DoNotAddToStore;
+                case GuiMessage.GuiMessageResponseButton.Neutral:
+                    return CertOperationResult.Cancel;
+                default:
+                    return CertOperationResult.Cancel;
+            }
+        }
+
+        string GetCertificateMessageString(string message, PlasticCertInfo serverCertificate)
+        {
+            return string.Format(message,
+                CertificateUi.GetCnField(serverCertificate.Subject),
+                CertificateUi.GetCnField(serverCertificate.Issuer),
+                serverCertificate.Format,
+                serverCertificate.ExpirationDateString,
+                serverCertificate.KeyAlgorithm,
+                serverCertificate.CertHashString);
+        }
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/ChannelCertificateUiImpl.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 628bc1ed591aa164ab9124ac22e02d9a
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 0b593e05bcd27824eb229f8c6b20e13b
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 86d9084a265d35f4db65c4e31e0b6769
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/AutoLogin.cs

@@ -0,0 +1,199 @@
+using System;
+using System.Collections.Generic;
+
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Client.Common.Threading;
+using Codice.LogWrapper;
+using PlasticGui;
+using PlasticGui.Configuration.OAuth;
+using PlasticGui.WebApi.Responses;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Progress;
+using Unity.PlasticSCM.Editor.WebApi;
+
+namespace Unity.PlasticSCM.Editor.Configuration.CloudEdition.Welcome
+{
+    internal class AutoLogin : OAuthSignIn.INotify
+    {
+        internal enum State : byte
+        { 
+            Off = 0,
+            Started = 1,
+            Running = 2,
+            ResponseInit = 3,
+            ResponseEnd = 6,
+            ResponseSuccess = 7,
+            OrganizationChoosed = 8,
+            InitializingPlastic = 9,
+            ErrorNoToken = 20,
+            ErrorTokenException = 21,
+            ErrorResponseNull = 22,
+            ErrorResponseError = 23,
+            ErrorTokenEmpty = 24,
+            ErrorResponseCancel = 25
+        }
+
+        internal string AccessToken;
+        internal string UserName;
+
+        internal void Run()
+        {
+            mPlasticWindow = GetPlasticWindow();
+
+            if (!string.IsNullOrEmpty(CloudProjectSettings.accessToken))
+            {
+                ExchangeTokensAndJoinOrganization(CloudProjectSettings.accessToken);
+                return;
+            }
+            
+            mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorNoToken;
+        }
+
+        void OAuthSignIn.INotify.SuccessForConfigure(
+            List<string> organizations,
+            bool canCreateAnOrganization,
+            string userName,
+            string accessToken)
+        {
+        }
+
+        void OAuthSignIn.INotify.SuccessForSSO(string organization)
+        {
+        }
+
+        void OAuthSignIn.INotify.SuccessForProfile(string email)
+        {
+        }
+
+        void OAuthSignIn.INotify.SuccessForHomeView(string userName)
+        {
+            mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ResponseSuccess;
+            ChooseOrganization(userName);
+        }
+
+        void OAuthSignIn.INotify.SuccessForCredentials(
+            string email,
+            string accessToken)
+        {
+        }
+
+        void OAuthSignIn.INotify.Cancel(string errorMessage)
+        {
+            mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorResponseCancel;
+        }
+
+        void ExchangeTokensAndJoinOrganization(string unityAccessToken)
+        {
+            int ini = Environment.TickCount;
+
+            TokenExchangeResponse tokenExchangeResponse = null;
+
+            IThreadWaiter waiter = ThreadWaiter.GetWaiter(10);
+            waiter.Execute(
+            /*threadOperationDelegate*/ delegate
+            {
+                mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ResponseInit;
+                tokenExchangeResponse = WebRestApiClient.PlasticScm.TokenExchange(unityAccessToken);
+            },
+            /*afterOperationDelegate*/ delegate
+            {
+                mLog.DebugFormat(
+                    "TokenExchange time {0} ms",
+                    Environment.TickCount - ini);
+
+                if (waiter.Exception != null)
+                {
+                    mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorTokenException;
+                    ExceptionsHandler.LogException(
+                        "TokenExchangeSetting",
+                        waiter.Exception);
+                    Debug.LogWarning(waiter.Exception.Message);
+                    return;
+                }
+
+                if (tokenExchangeResponse == null)
+                {
+                    mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorResponseNull;
+                    var warning = PlasticLocalization.GetString(PlasticLocalization.Name.TokenExchangeResponseNull);
+                    mLog.Warn(warning);
+                    Debug.LogWarning(warning);
+                    return;
+                }
+                   
+                if (tokenExchangeResponse.Error != null)
+                {
+                    mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorResponseError;
+                    var warning = string.Format(
+                        PlasticLocalization.GetString(PlasticLocalization.Name.TokenExchangeResponseError),
+                        tokenExchangeResponse.Error.Message, tokenExchangeResponse.Error.ErrorCode);
+                    mLog.ErrorFormat(warning);
+                    Debug.LogWarning(warning);
+                    return;
+                }
+
+                if (string.IsNullOrEmpty(tokenExchangeResponse.AccessToken))
+                {
+                    mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ErrorTokenEmpty;
+                    var warning = string.Format(
+                        PlasticLocalization.GetString(PlasticLocalization.Name.TokenExchangeAccessEmpty), 
+                        tokenExchangeResponse.User);
+                    mLog.InfoFormat(warning);
+                    Debug.LogWarning(warning);
+                    return;
+                }
+
+                mPlasticWindow.GetWelcomeView().autoLoginState = AutoLogin.State.ResponseEnd;
+                AccessToken = tokenExchangeResponse.AccessToken;
+                UserName = tokenExchangeResponse.User;
+                GetOrganizationList();
+            });
+        }
+
+        void GetOrganizationList()
+        {
+            OAuthSignIn.GetOrganizationsFromAccessToken(
+                SsoProvider.UNITY_URL_ACTION,
+                UserName,
+                AccessToken,
+                OAuthSignIn.Mode.HomeView,
+                new ProgressControlsForDialogs(),
+                this,
+                PlasticGui.Plastic.WebRestAPI
+            );
+        }
+
+        void ChooseOrganization(
+            string userName)
+        {
+            mPlasticWindow = GetPlasticWindow();
+
+            CloudEditionWelcomeWindow.ShowWindow(
+                PlasticGui.Plastic.WebRestAPI,
+                mPlasticWindow.CmConnectionForTesting, null, true);
+
+            mCloudEditionWelcomeWindow = CloudEditionWelcomeWindow.GetWelcomeWindow();
+            mCloudEditionWelcomeWindow.ShowOrganizationPanelFromAutoLogin();
+            mCloudEditionWelcomeWindow.Focus();
+            mCloudEditionWelcomeWindow.FillUser(userName);
+        }
+
+        static PlasticWindow GetPlasticWindow()
+        {
+            var windows = Resources.FindObjectsOfTypeAll<PlasticWindow>();
+            PlasticWindow plasticWindow = windows.Length > 0 ? windows[0] : null;
+
+            if (plasticWindow == null)
+                plasticWindow = ShowWindow.Plastic();
+
+            return plasticWindow;
+        }
+
+        PlasticWindow mPlasticWindow;
+        CloudEditionWelcomeWindow mCloudEditionWelcomeWindow;
+
+        static readonly ILog mLog = PlasticApp.GetLogger("TokensExchange");
+    }
+
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/AutoLogin.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 806bdb4f911275c4ca1ee81fde4b4d4f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/CloudEditionWelcomeWindow.cs

@@ -0,0 +1,260 @@
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using PlasticGui;
+using PlasticGui.WebApi;
+using PlasticGui.Configuration.CloudEdition.Welcome;
+using PlasticGui.Configuration.OAuth;
+using System.Collections.Generic;
+using Codice.Client.Common.Servers;
+using Codice.Client.Common;
+using Codice.Utils;
+using Unity.PlasticSCM.Editor.Views.Welcome;
+
+using Codice.CM.Common;
+
+namespace Unity.PlasticSCM.Editor.Configuration.CloudEdition.Welcome
+{
+    internal interface IWelcomeWindowNotify
+    {
+        void SuccessForHomeView(string userName);
+        void Back();
+    }
+
+    internal class CloudEditionWelcomeWindow :
+        EditorWindow,
+        OAuthSignIn.INotify,
+        IWelcomeWindowNotify
+    {
+        internal static void ShowWindow(
+            IPlasticWebRestApi restApi,
+            CmConnection cmConnection,
+            WelcomeView welcomeView,
+            bool autoLogin = false)
+        {
+            sRestApi = restApi;
+            sCmConnection = cmConnection;
+            sAutoLogin = autoLogin;
+            CloudEditionWelcomeWindow window = GetWindow<CloudEditionWelcomeWindow>();
+
+            window.titleContent = new GUIContent(
+                PlasticLocalization.GetString(PlasticLocalization.Name.SignInToUnityVCS));
+            window.minSize = window.maxSize = new Vector2(450, 300);
+
+            window.mWelcomeView = welcomeView;
+
+            window.Show();
+        }
+
+        internal static CloudEditionWelcomeWindow GetWelcomeWindow()
+        {
+            return GetWindow<CloudEditionWelcomeWindow>();
+        }
+
+        // Save the Default Server in the config files of all clients, so they are already configured.
+        // Avoids having the Desktop application asking the user again later.
+        internal static void SaveDefaultCloudServer(string cloudServer, string username)
+        {
+            SaveCloudServer.ToPlasticGuiConfig(cloudServer);
+            SaveCloudServer.ToPlasticGuiConfigFile(
+                cloudServer, GetPlasticConfigFileToSaveOrganization());
+            SaveCloudServer.ToPlasticGuiConfigFile(
+                cloudServer, GetGluonConfigFileToSaveOrganization());
+
+            KnownServers.ServersFromCloud.InitializeForWindows(
+                PlasticGuiConfig.Get().Configuration.DefaultCloudServer);
+
+            SetupUnityEditionToken.CreateCloudEditionTokenIfNeeded();
+
+            ClientConfigData clientConfigData = ConfigurationChecker.GetClientConfigData();
+
+            if (sAutoLogin)
+            {
+                clientConfigData.WorkspaceServer = cloudServer;
+                clientConfigData.WorkingMode = SEIDWorkingMode.SSOWorkingMode.ToString();
+                clientConfigData.SecurityConfig = username;
+
+                GetWindow<PlasticWindow>().GetWelcomeView().autoLoginState = AutoLogin.State.OrganizationChoosed;
+            }
+
+            ClientConfig.Get().Save(clientConfigData);
+        }
+
+        internal static string GetPlasticConfigFileToSaveOrganization()
+        {
+            if (PlatformIdentifier.IsMac())
+            {
+                return "macgui.conf";
+            }
+
+            return "plasticgui.conf";
+        }
+
+        internal static string GetGluonConfigFileToSaveOrganization()
+        {
+            if (PlatformIdentifier.IsMac())
+            {
+                return "gluon.conf";
+            }
+
+            return "gameui.conf";
+        }
+
+        internal void CancelJoinOrganization()
+        {
+            if (sAutoLogin)
+            {
+                GetWindow<PlasticWindow>().GetWelcomeView().autoLoginState = AutoLogin.State.Started;
+            }
+        }
+
+        internal void SaveDefaultCloudServer(string organization)
+        {
+            SaveDefaultCloudServer(organization, mUserName);
+        }
+
+        internal void ReplaceRootPanel(VisualElement panel)
+        {
+            rootVisualElement.Clear();
+            rootVisualElement.Add(panel);
+        }
+
+        internal void ShowOrganizationPanel(string title)
+        {
+            mOrganizationPanel = new OrganizationPanel(
+                this,
+                sRestApi,
+                title);
+
+            ReplaceRootPanel(mOrganizationPanel);
+        }
+
+        internal void FillUser(string userName)
+        {
+            mUserName = userName;
+        }
+
+        internal void ShowOrganizationPanelFromAutoLogin()
+        {
+            ShowOrganizationPanel(GetWindowTitle());
+        }
+
+        internal string GetWindowTitle()
+        {
+            return PlasticLocalization.Name.SignInToUnityVCS.GetString();
+        }
+
+        internal SignInPanel GetSignInPanel()
+        {
+            return mSignInPanel;
+        }
+
+        void OAuthSignIn.INotify.SuccessForConfigure(
+            List<string> organizations,
+            bool canCreateAnOrganization,
+            string userName,
+            string accessToken)
+        {
+            // empty implementation
+        }
+
+        void OAuthSignIn.INotify.SuccessForSSO(string organization)
+        {
+            // empty implementation
+        }
+
+        void OAuthSignIn.INotify.SuccessForProfile(string email)
+        {
+            // empty implementation
+        }
+
+        void OAuthSignIn.INotify.SuccessForHomeView(string userName)
+        {
+            ShowOrganizationPanel(GetWindowTitle());
+
+            Focus();
+
+            mUserName = userName;
+        }
+
+        void OAuthSignIn.INotify.SuccessForCredentials(
+            string email,
+            string accessToken)
+        {
+            // empty implementation
+        }
+
+        void OAuthSignIn.INotify.Cancel(string errorMessage)
+        {
+            Focus();
+        }
+
+        void IWelcomeWindowNotify.SuccessForHomeView(string userName)
+        {
+            GetWindow<PlasticWindow>().InitializePlastic();
+                
+            ShowOrganizationPanel(GetWindowTitle());
+
+            Focus();
+
+            mUserName = userName;
+        }
+
+        void IWelcomeWindowNotify.Back()
+        {
+            rootVisualElement.Clear();
+            rootVisualElement.Add(mSignInPanel);
+        }
+
+        void OnEnable()
+        {
+            BuildComponents();
+        }
+
+        void OnDestroy()
+        {
+            Dispose();
+
+            if (mWelcomeView != null)
+                mWelcomeView.OnUserClosedConfigurationWindow();
+        }
+
+        void Dispose()
+        {
+            if (mSignInPanel != null)
+                mSignInPanel.Dispose();
+
+            if (mOrganizationPanel != null)
+                mOrganizationPanel.Dispose();
+        }
+
+        void BuildComponents()
+        {
+            VisualElement root = rootVisualElement;
+
+            root.Clear();
+
+            mSignInPanel = new SignInPanel(
+                this,
+                sRestApi,
+                sCmConnection);
+
+            titleContent = new GUIContent(GetWindowTitle());
+
+            root.Add(mSignInPanel);
+            if (sAutoLogin)
+                mSignInPanel.SignInWithUnityIdButtonAutoLogin();
+        }
+
+        string mUserName;
+
+        OrganizationPanel mOrganizationPanel;
+        SignInPanel mSignInPanel;
+        WelcomeView mWelcomeView;
+
+        static IPlasticWebRestApi sRestApi;
+        static CmConnection sCmConnection;
+        static bool sAutoLogin = false;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/CloudEditionWelcomeWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 0ad54f9e1bb701142b116d0d1ed98437
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/OrganizationPanel.cs

@@ -0,0 +1,243 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+using UnityEngine;
+using UnityEditor.UIElements;
+using UnityEngine.UIElements;
+
+using Codice.Client.Common.Threading;
+using PlasticGui;
+using PlasticGui.WebApi;
+using PlasticGui.WebApi.Responses;
+using PlasticGui.WorkspaceWindow.Home;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.UIElements;
+
+namespace Unity.PlasticSCM.Editor.Configuration.CloudEdition.Welcome
+{
+    internal class OrganizationPanel : VisualElement
+    {
+        internal OrganizationPanel(
+            CloudEditionWelcomeWindow parentWindow,
+            IPlasticWebRestApi restApi,
+            string title)
+        {
+            mParentWindow = parentWindow;
+            mRestApi = restApi;
+
+            InitializeLayoutAndStyles();
+
+            BuildComponents(title);
+
+            EditorWindowFocus.OnApplicationActivated += OnEditorActivated;
+
+            OnEditorActivated();
+        }
+
+        internal void Dispose()
+        {
+            EditorWindowFocus.OnApplicationActivated -= OnEditorActivated;
+
+            mParentWindow.CancelJoinOrganization();
+
+            if (mJoinSingleOrganizationButton != null)
+                mJoinSingleOrganizationButton.clicked -= JoinOrganizationButton_clicked;
+
+            if (mJoinMultipleOrganizationsButton != null)
+                mJoinMultipleOrganizationsButton.clicked -= JoinOrganizationButton_clicked;
+
+            if (mOpenUnityDashboardButton != null)
+                mOpenUnityDashboardButton.clicked -= OpenUnityDashboardButton_clicked;
+        }
+
+        void OnEditorActivated()
+        {
+            if (!mReloadOrganizationsNeeded)
+                return;
+
+            mReloadOrganizationsNeeded = false;
+            mProgressControls.ShowProgress(PlasticLocalization.Name.LoadingOrganizations.GetString());
+
+            OrganizationsResponse organizationResponse = null;
+            IThreadWaiter waiter = ThreadWaiter.GetWaiter();
+            waiter.Execute(
+                /*threadOperationDelegate*/ delegate
+                {
+                    organizationResponse = mRestApi.GetCloudServers();
+                },
+                /*afterOperationDelegate*/ delegate
+                {
+                    mProgressControls.HideProgress();
+
+                    if (waiter.Exception != null)
+                    {
+                        mProgressControls.ShowError(PlasticLocalization.Name.UnexpectedError.GetString());
+                        ExceptionsHandler.LogException(typeof(OrganizationPanel).Name, waiter.Exception);
+                        return;
+                    }
+
+                    if (organizationResponse.Error != null)
+                    {
+                        mReloadOrganizationsNeeded = true;
+                        mProgressControls.ShowError(organizationResponse.Error.Message);
+                        return;
+                    }
+
+                    // This is crucial to initialize the internal cache of slugs in the plastic library
+                    OrganizationsInformation.UpdateOrganizationSlugs(organizationResponse);
+
+                    List<OrganizationInfo> organizationsInfo = OrganizationsInformation.FromServersOrdered(organizationResponse.CloudServers);
+
+                    ProcessOrganizations(organizationsInfo);
+                });
+        }
+
+        void ProcessOrganizations(List<OrganizationInfo> organizations)
+        {
+            this.Query<VisualElement>("noOrganization").Collapse();
+            this.Query<VisualElement>("joinSingleOrganization").Collapse();
+            this.Query<VisualElement>("joinMultipleOrganizations").Collapse();
+
+            if (organizations.Count == 0)
+            {
+                mReloadOrganizationsNeeded = true;
+                BuildNoOrganizationSection();
+
+                mOpenUnityDashboardButton = this.Q<Button>("openUnityDashboardButton");
+                mOpenUnityDashboardButton.clicked += OpenUnityDashboardButton_clicked;
+
+                return;
+            }
+
+            mReloadOrganizationsNeeded = false;
+
+            if (organizations.Count == 1)
+            {
+                BuildSingleOrganizationSection(organizations.First());
+
+                mJoinSingleOrganizationButton = this.Q<Button>("joinSingleOrganizationButton");
+                mJoinSingleOrganizationButton.clicked += JoinOrganizationButton_clicked;
+
+                return;
+            }
+
+            BuildMultipleOrganizationsSection(organizations);
+
+            mJoinMultipleOrganizationsButton = this.Q<Button>("joinMultipleOrganizationsButton");
+            mJoinMultipleOrganizationsButton.clicked += JoinOrganizationButton_clicked;
+            mOrganizationToJoin = organizations.First().Server;
+        }
+
+        void InitializeLayoutAndStyles()
+        {
+            this.LoadLayout(typeof(OrganizationPanel).Name);
+            this.LoadStyle(typeof(OrganizationPanel).Name);
+        }
+
+        void JoinOrganizationButton_clicked()
+        {
+            mParentWindow.SaveDefaultCloudServer(mOrganizationToJoin);
+
+            // TODO: Closing the window for now. Need to connect this event to the main on boarding
+            //       workflow.
+            mParentWindow.Close();
+        }
+
+        void OpenUnityDashboardButton_clicked()
+        {
+            Application.OpenURL(UnityUrl.UnityDashboard.Plastic.Get());
+        }
+
+        void BuildComponents(string title)
+        {
+            mParentWindow.titleContent = new UnityEngine.GUIContent(title);
+
+            mProgressControls = new ProgressControlsForDialogs(null);
+
+            mProgressContainer = this.Q<VisualElement>("progressContainer");
+            mProgressContainer.Add((VisualElement)mProgressControls);
+        }
+
+        void BuildSingleOrganizationSection(OrganizationInfo organizationInfo)
+        {
+            this.SetControlText<Label>("confirmationMessage",
+                PlasticLocalization.Name.JoinOrganizationTitle);
+
+            mOrganizationToJoin = organizationInfo.Server;
+
+            this.Query<VisualElement>("joinSingleOrganization").Show();
+
+            this.SetControlText<Label>("joinSingleOrganizationLabel",
+                PlasticLocalization.Name.YouBelongToOrganization,  organizationInfo.DisplayName);
+
+            this.SetControlText<Button>("joinSingleOrganizationButton",
+                PlasticLocalization.Name.JoinButton);
+        }
+
+        void BuildMultipleOrganizationsSection(List<OrganizationInfo> organizations)
+        {
+            organizations.Sort((x, y) =>
+                string.Compare(x.DisplayName, y.DisplayName, StringComparison.CurrentCulture));
+
+            this.SetControlText<Label>("confirmationMessage",
+                PlasticLocalization.Name.JoinOrganizationTitle);
+
+            this.Query<VisualElement>("joinMultipleOrganizations").Show();
+
+            this.SetControlText<Label>("joinMultipleOrganizationsLabel",
+                PlasticLocalization.Name.YouBelongToSeveralOrganizations);
+
+            VisualElement organizationDropdown = this.Query<VisualElement>("organizationDropdown");
+            ToolbarMenu toolbarMenu = new ToolbarMenu
+            {
+                text = organizations.First().DisplayName,
+            };
+
+            foreach (OrganizationInfo organization in organizations)
+            {
+                string organizationDisplayName = organization.DisplayName;
+
+                toolbarMenu.menu.AppendAction(organizationDisplayName, x => 
+                {
+                    toolbarMenu.text = organizationDisplayName;
+                    mOrganizationToJoin = organization.Server;
+                }, DropdownMenuAction.AlwaysEnabled);
+                organizationDropdown.Add(toolbarMenu);
+            }
+
+            this.SetControlText<Button>("joinMultipleOrganizationsButton",
+                PlasticLocalization.Name.JoinButton);
+        }
+
+        void BuildNoOrganizationSection()
+        {
+            this.SetControlText<Label>("confirmationMessage",
+                PlasticLocalization.Name.CreateOrganizationTitle);
+
+            this.Query<VisualElement>("noOrganization").Show();
+
+            this.SetControlImage("iconUnity",
+                Images.Name.ButtonSsoSignInUnity);
+
+            this.SetControlText<Label>("noOrganizationLabel",
+                PlasticLocalization.Name.ClickButtonBelowToCreateOrg);
+
+            this.SetControlText<Button>("openUnityDashboardButton",
+                PlasticLocalization.Name.MainSidebarOpenUnityDashboardItem);
+        }
+
+        string mOrganizationToJoin = "";
+        bool mReloadOrganizationsNeeded = true;
+
+        Button mJoinSingleOrganizationButton;
+        Button mJoinMultipleOrganizationsButton;
+        Button mOpenUnityDashboardButton;
+        VisualElement mProgressContainer;
+
+        IProgressControls mProgressControls;
+
+        readonly CloudEditionWelcomeWindow mParentWindow;
+        readonly IPlasticWebRestApi mRestApi;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/OrganizationPanel.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 615ff93ab52eb8242a9194d4f711676f
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/SignInPanel.cs

@@ -0,0 +1,173 @@
+using System;
+
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using Codice.Client.Common;
+using Codice.Client.Common.OAuth;
+using Codice.CM.Common;
+using PlasticGui;
+using PlasticGui.WebApi;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.UIElements;
+using PlasticGui.Configuration.CloudEdition.Welcome;
+using PlasticGui.Configuration.OAuth;
+
+namespace Unity.PlasticSCM.Editor.Configuration.CloudEdition.Welcome
+{
+    internal class SignInPanel : VisualElement
+    {
+        internal SignInPanel(
+            CloudEditionWelcomeWindow parentWindow,
+            IPlasticWebRestApi restApi,
+            CmConnection cmConnection)
+        {
+            mParentWindow = parentWindow;
+            mRestApi = restApi;
+            mCmConnection = cmConnection;
+
+            InitializeLayoutAndStyles();
+
+            BuildComponents();
+        }
+
+        internal void Dispose()
+        {
+            mSignInWithUnityIdButton.clicked -= SignInWithUnityIdButton_Clicked;
+            mSignInWithEmailButton.clicked -= SignInWithEmailButton_Clicked;
+            mPrivacyPolicyStatementButton.clicked -= PrivacyPolicyStatementButton_Clicked;
+            mSignUpButton.clicked -= SignUpButton_Clicked;
+
+            if (mSignInWithEmailPanel != null)
+                mSignInWithEmailPanel.Dispose();
+
+            if (mWaitingSignInPanel != null)
+                mWaitingSignInPanel.Dispose();
+        }
+
+        void SignInWithEmailButton_Clicked()
+        {
+            mSignInWithEmailPanel = new SignInWithEmailPanel(
+                mParentWindow,
+                mParentWindow,
+                mRestApi);
+
+            mParentWindow.ReplaceRootPanel(mSignInWithEmailPanel);
+        }
+
+        void SignUpButton_Clicked()
+        {
+            Application.OpenURL(UnityUrl.DevOps.GetSignUp());
+        }
+
+        internal void SignInWithUnityIdButton_Clicked()
+        {
+            mWaitingSignInPanel = new WaitingSignInPanel(
+                mParentWindow,
+                mParentWindow,
+                mRestApi,
+                mCmConnection);
+
+            mParentWindow.ReplaceRootPanel(mWaitingSignInPanel);
+
+            Guid state = Guid.NewGuid();
+            GetOauthProviders.AuthInfo provider =
+                GetCloudSsoProviders.BuildAuthInfoForUnityId(string.Empty, state);
+            mWaitingSignInPanel.OAuthSignIn(
+                SEIDWorkingMode.SSOWorkingMode,
+                state,
+                provider.SignInUrl,
+                provider.ProviderName,
+                new GetCloudSsoToken(mRestApi));
+        }
+
+        internal void SignInWithUnityIdButtonAutoLogin()
+        {
+            mWaitingSignInPanel = new WaitingSignInPanel(
+                mParentWindow,
+                mParentWindow,
+                mRestApi,
+                mCmConnection);
+
+            mWaitingSignInPanel.OnAutoLogin();
+
+            mParentWindow.ReplaceRootPanel(mWaitingSignInPanel);
+        }
+
+        void PrivacyPolicyStatementButton_Clicked()
+        {
+            Application.OpenURL(SignUp.PRIVACY_POLICY_URL);
+        }
+
+        void BuildComponents()
+        {
+            BuildSignUpArea();
+            BuildSignInUnityIdArea();
+            BuildSignInEmailArea();
+            BuildPrivatePolicyArea();
+        }
+
+        void BuildPrivatePolicyArea()
+        {
+            this.SetControlText<Label>(
+                "privacyStatementText",
+                PlasticLocalization.Name.PrivacyStatementText,
+                PlasticLocalization.GetString(PlasticLocalization.Name.PrivacyStatement));
+
+            mPrivacyPolicyStatementButton = this.Query<Button>("privacyStatement");
+            mPrivacyPolicyStatementButton.text = PlasticLocalization.Name.PrivacyStatement.GetString();
+            mPrivacyPolicyStatementButton.clicked += PrivacyPolicyStatementButton_Clicked;
+        }
+
+        void BuildSignInEmailArea()
+        {
+            this.SetControlImage(
+                "iconEmail",
+                Images.Name.ButtonSsoSignInEmail);
+
+            mSignInWithEmailButton = this.Query<Button>("emailButton");
+            mSignInWithEmailButton.text = PlasticLocalization.Name.SignInWithEmail.GetString();
+            mSignInWithEmailButton.clicked += SignInWithEmailButton_Clicked;
+        }
+
+        void BuildSignInUnityIdArea()
+        {
+            this.SetControlImage(
+                "iconUnity",
+                Images.Name.ButtonSsoSignInUnity);
+
+            mSignInWithUnityIdButton = this.Query<Button>("unityIDButton");
+            mSignInWithUnityIdButton.text = PlasticLocalization.Name.SignInWithUnityID.GetString();
+            mSignInWithUnityIdButton.clicked += SignInWithUnityIdButton_Clicked;
+        }
+
+        void BuildSignUpArea()
+        {
+            Label signUpLabel = this.Query<Label>("signUpLabel");
+            signUpLabel.text = PlasticLocalization.Name.LoginOrSignUp.GetString();
+
+            mSignUpButton = this.Query<Button>("signUpButton");
+            mSignUpButton.text = PlasticLocalization.Name.SignUpButton.GetString();
+            mSignUpButton.clicked += SignUpButton_Clicked;
+        }
+
+        void InitializeLayoutAndStyles()
+        {
+            AddToClassList("grow");
+            
+            this.LoadLayout(typeof(SignInPanel).Name);
+            this.LoadStyle(typeof(SignInPanel).Name);
+        }
+
+        SignInWithEmailPanel mSignInWithEmailPanel;
+        WaitingSignInPanel mWaitingSignInPanel;
+        Button mSignInWithUnityIdButton;
+        Button mSignInWithEmailButton;
+        Button mPrivacyPolicyStatementButton;
+        Button mSignUpButton;
+
+        readonly CloudEditionWelcomeWindow mParentWindow;
+        readonly IPlasticWebRestApi mRestApi;
+        readonly CmConnection mCmConnection;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/SignInPanel.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bba806fdb20eb5a4da6cc856323d6273
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/SignInWithEmailPanel.cs

@@ -0,0 +1,202 @@
+using System.Collections.Generic;
+
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using PlasticGui;
+using PlasticGui.Configuration.CloudEdition.Welcome;
+using PlasticGui.Configuration.CloudEdition;
+using PlasticGui.WebApi;
+using Unity.PlasticSCM.Editor.UI.UIElements;
+
+namespace Unity.PlasticSCM.Editor.Configuration.CloudEdition.Welcome
+{
+    internal class SignInWithEmailPanel :
+        VisualElement,
+        Login.INotify
+    {
+        internal SignInWithEmailPanel(
+            CloudEditionWelcomeWindow parentWindow,
+            IWelcomeWindowNotify notify,
+            IPlasticWebRestApi restApi)
+        {
+            mParentWindow = parentWindow;
+            mNotify = notify;
+            mRestApi = restApi;
+
+            InitializeLayoutAndStyles();
+
+            BuildComponents();
+        }
+
+        internal void Dispose()
+        {
+            mSignInButton.clicked -= SignInButton_Clicked;
+            mBackButton.clicked -= BackButton_Clicked;
+            mSignUpButton.clicked -= SignUpButton_Clicked;
+        }
+
+        void Login.INotify.SuccessForConfigure(
+            List<string> organizations,
+            bool canCreateAnOrganization,
+            string userName,
+            string password)
+        {
+            // Do nothing
+        }
+
+        void Login.INotify.SuccessForSSO(
+            string organization)
+        {
+            // Do nothing
+        }
+
+        void Login.INotify.SuccessForProfile(
+            string userName)
+        {
+            // Do nothing
+        }
+
+        void Login.INotify.SuccessForCredentials(string userName, string password)
+        {
+            // Do nothing
+        }
+
+        void Login.INotify.SuccessForHomeView(string userName)
+        {
+            mNotify.SuccessForHomeView(userName);
+        }
+
+        void Login.INotify.ValidationFailed(
+            Login.ValidationResult validationResult)
+        {
+            if (validationResult.UserError != null)
+            {
+                mEmailNotificationLabel.text = validationResult.UserError;
+            }
+
+            if (validationResult.PasswordError != null)
+            {
+                mPasswordNotificationLabel.text = validationResult.PasswordError;
+            }
+        }
+
+        void Login.INotify.SignUpNeeded(
+            Login.Data loginData)
+        {
+            ShowSignUpNeeded();
+        }
+
+        void ShowSignUpNeeded()
+        {
+            mSignUpNeededNotificationContainer.Show();
+        }
+
+        void HideSignUpNeeded()
+        {
+            mSignUpNeededNotificationContainer.Collapse();
+        }
+
+        void Login.INotify.Error(
+            string message)
+        {
+            HideSignUpNeeded();
+            mProgressControls.ShowError(message);
+        }
+
+        void CleanNotificationLabels()
+        {
+            mEmailNotificationLabel.text = string.Empty;
+            mPasswordNotificationLabel.text = string.Empty;
+
+            HideSignUpNeeded();
+        }
+
+        void SignInButton_Clicked()
+        {
+            CleanNotificationLabels();
+
+            Login.Run(
+                mRestApi,
+                new SaveCloudEditionCreds(),
+                mEmailField.text,
+                mPasswordField.text,
+                string.Empty,
+                string.Empty,
+                Login.Mode.HomeView,
+                mProgressControls,
+                this);
+        }
+
+        void BackButton_Clicked()
+        {
+            mNotify.Back();
+        }
+
+        void InitializeLayoutAndStyles()
+        {
+            this.LoadLayout(typeof(SignInWithEmailPanel).Name);
+            this.LoadStyle(typeof(SignInWithEmailPanel).Name);
+        }
+        
+        void SignUpButton_Clicked()
+        {
+            Application.OpenURL(UnityUrl.DevOps.GetSignUp());
+        }
+
+        void BuildComponents()
+        {
+            mEmailField = this.Q<TextField>("email");
+            mPasswordField = this.Q<TextField>("password");
+            mEmailNotificationLabel = this.Q<Label>("emailNotification");
+            mPasswordNotificationLabel = this.Q<Label>("passwordNotification");
+            mSignInButton = this.Q<Button>("signIn");
+            mBackButton = this.Q<Button>("back");
+            mSignUpButton = this.Q<Button>("signUpButton");
+            mProgressContainer = this.Q<VisualElement>("progressContainer");
+            mSignUpNeededNotificationContainer = this.Q<VisualElement>("signUpNeededNotificationContainer");
+
+            mSignInButton.clicked += SignInButton_Clicked;
+            mBackButton.clicked += BackButton_Clicked;
+            mSignUpButton.clicked += SignUpButton_Clicked;
+            mEmailField.FocusOnceLoaded();
+
+            mProgressControls = new ProgressControlsForDialogs(new VisualElement[] { mSignInButton });
+            mProgressContainer.Add((VisualElement)mProgressControls);
+
+            this.SetControlText<Label>("signInLabel",
+                PlasticLocalization.Name.SignInWithEmail);
+            this.SetControlLabel<TextField>("email",
+                PlasticLocalization.Name.Email);
+            this.SetControlLabel<TextField>("password",
+                PlasticLocalization.Name.Password);
+            this.SetControlText<Button>("signIn",
+                PlasticLocalization.Name.SignIn);
+            this.SetControlText<Button>("back",
+                PlasticLocalization.Name.BackButton);
+            this.SetControlText<Label>("signUpNeededNotificationLabel",
+                PlasticLocalization.Name.SignUpNeededNoArgs);
+            this.SetControlText<Button>("signUpButton",
+                PlasticLocalization.Name.SignUp);
+        }
+
+        TextField mEmailField;
+        TextField mPasswordField;
+
+        Label mEmailNotificationLabel;
+        Label mPasswordNotificationLabel;
+
+        Button mSignInButton;
+        Button mBackButton;
+        Button mSignUpButton;
+
+        VisualElement mProgressContainer;
+        VisualElement mSignUpNeededNotificationContainer;
+
+        IProgressControls mProgressControls;
+
+        readonly CloudEditionWelcomeWindow mParentWindow;
+        readonly IWelcomeWindowNotify mNotify;
+        readonly IPlasticWebRestApi mRestApi;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/SignInWithEmailPanel.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 85f4628ae66f0eb439e59db66adbc696
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/WaitingSignInPanel.cs

@@ -0,0 +1,131 @@
+using System;
+
+using Codice.Client.Common;
+using Codice.Client.Common.OAuth;
+using Codice.CM.Common;
+
+using PlasticGui;
+using PlasticGui.Configuration.OAuth;
+using PlasticGui.WebApi;
+using Unity.PlasticSCM.Editor.UI.UIElements;
+using UnityEngine.UIElements;
+
+namespace Unity.PlasticSCM.Editor.Configuration.CloudEdition.Welcome
+{
+    internal class WaitingSignInPanel : VisualElement
+    {
+        internal WaitingSignInPanel(
+            IWelcomeWindowNotify parentNotify,
+            OAuthSignIn.INotify notify,
+            IPlasticWebRestApi restApi,
+            CmConnection cmConnection)
+        {
+            mParentNotify = parentNotify;
+
+            mNotify = notify;
+            mRestApi = restApi;
+            mCmConnection = cmConnection;
+
+            InitializeLayoutAndStyles();
+
+            BuildComponents();
+        }
+
+        internal void OAuthSignIn(
+            SEIDWorkingMode workingMode,
+            Guid state,
+            Uri signInUrl,
+            string ssoProviderName,
+            IGetOauthToken getToken)
+        {
+            mSignIn = new OAuthSignIn();
+
+            mSignIn.ForHomeView(
+                string.Empty,
+                workingMode,
+                signInUrl,
+                state,
+                ssoProviderName,
+                string.Empty,
+                mProgressControls,
+                mNotify,
+                mCmConnection,
+                new OAuthSignIn.Browser(),
+                getToken,
+                mRestApi);
+
+            ShowWaitingSpinner();
+        }
+
+        internal void OnAutoLogin()
+        {
+            mCompleteOnBrowserLabel.visible = false;
+            mCancelButton.visible = false;
+
+            mProgressControls.ProgressData.ProgressMessage =
+                PlasticLocalization.Name.SigningIn.GetString();
+
+            ShowWaitingSpinner();
+        }
+
+        internal void Dispose()
+        {
+            mCancelButton.clicked -= CancelButton_Clicked;
+        }
+
+        void InitializeLayoutAndStyles()
+        {
+            this.LoadLayout(typeof(WaitingSignInPanel).Name);
+            this.LoadStyle(typeof(WaitingSignInPanel).Name);
+        }
+
+        void ShowWaitingSpinner()
+        {
+            var spinner = new LoadingSpinner();
+            mProgressContainer.Add(spinner);
+            spinner.Start();
+
+            var checkinMessageLabel = new Label(mProgressControls.ProgressData.ProgressMessage);
+            checkinMessageLabel.style.paddingLeft = 20;
+            mProgressContainer.Add(checkinMessageLabel);
+        }
+
+        void CancelButton_Clicked()
+        {
+            mSignIn.Cancel();
+            mParentNotify.Back();
+        }
+
+        void BuildComponents()
+        {
+            this.SetControlText<Label>("signInToPlasticSCM",
+                PlasticLocalization.Name.SignInToUnityVCS);
+
+            mCompleteOnBrowserLabel = this.Q<Label>("completeSignInOnBrowser");
+            mCompleteOnBrowserLabel.text = PlasticLocalization.Name.CompleteSignInOnBrowser.GetString();
+
+            mProgressContainer = this.Q<VisualElement>("progressContainer");
+
+            mProgressControls = new UI.Progress.ProgressControlsForDialogs();
+
+            mCancelButton = this.Query<Button>("cancelButton");
+            mCancelButton.text = PlasticLocalization.GetString(
+                PlasticLocalization.Name.CancelButton);
+            mCancelButton.visible = true;
+            mCancelButton.clicked += CancelButton_Clicked;
+        }
+
+        Button mCancelButton;
+        VisualElement mProgressContainer;
+        Label mCompleteOnBrowserLabel;
+
+        OAuthSignIn mSignIn;
+
+        UI.Progress.ProgressControlsForDialogs mProgressControls;
+
+        readonly IPlasticWebRestApi mRestApi;
+        readonly CmConnection mCmConnection;
+        readonly OAuthSignIn.INotify mNotify;
+        readonly IWelcomeWindowNotify mParentNotify;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CloudEdition/Welcome/WaitingSignInPanel.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 077387e98bf29fb4a97bccfb592cfaf7
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/ConfigurePartialWorkspace.cs

@@ -0,0 +1,33 @@
+using System.Collections.Generic;
+using System.IO;
+
+using Codice.Client.Commands.WkTree;
+using Codice.Client.Common;
+using Codice.Client.Common.GameUI;
+using Codice.CM.Common;
+using Codice.CM.Common.Mount;
+using Codice.CM.Common.Partial;
+using Codice.CM.WorkspaceServer.DataStore.Configuration;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal static class ConfigurePartialWorkspace
+    {
+        internal static void AsFullyChecked(WorkspaceInfo wkInfo)
+        {
+            string rootPath = WorkspacePath.GetWorkspacePathFromCmPath(
+                wkInfo.ClientPath, "/", Path.DirectorySeparatorChar);
+
+            WorkspaceTreeNode rootWkNode = CmConnection.Get().GetWorkspaceTreeHandler().
+                WkGetWorkspaceTreeNode(rootPath);
+
+            FullyCheckedDirectory rootDirectory = new FullyCheckedDirectory(
+                MountPointId.WORKSPACE_ROOT, rootWkNode.RevInfo.ItemId);
+
+            List<FullyCheckedDirectory> directoryList = new List<FullyCheckedDirectory>();
+            directoryList.Add(rootDirectory);
+
+            FullyCheckedDirectoriesStorage.Save(wkInfo, directoryList);
+        }
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/ConfigurePartialWorkspace.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2b3223ee740687445a7e4bc793fa2aae
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CredentialsDialog.cs

@@ -0,0 +1,160 @@
+using UnityEngine;
+
+using UnityEditor;
+
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Progress;
+using Codice.CM.Common;
+using Codice.Client.Common.Connection;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal class CredentialsDialog : PlasticDialog
+    {
+        protected override Rect DefaultRect
+        {
+            get
+            {
+                var baseRect = base.DefaultRect;
+                return new Rect(baseRect.x, baseRect.y, 525, 250);
+            }
+        }
+
+        internal static AskCredentialsToUser.DialogData RequestCredentials(
+            string server,
+            SEIDWorkingMode seidWorkingMode,
+            EditorWindow parentWindow)
+        {
+            CredentialsDialog dialog = Create(
+                server, seidWorkingMode, new ProgressControlsForDialogs());
+
+            ResponseType dialogResult = dialog.RunModal(parentWindow);
+
+            return dialog.BuildCredentialsDialogData(dialogResult);
+        }
+
+        protected override void OnModalGUI()
+        {
+            Title(PlasticLocalization.GetString(
+                PlasticLocalization.Name.CredentialsDialogTitle));
+
+            Paragraph(PlasticLocalization.GetString(
+                PlasticLocalization.Name.CredentialsDialogExplanation, mServer));
+
+            GUILayout.Space(5);
+
+            DoEntriesArea();
+
+            GUILayout.Space(10);
+
+            DrawProgressForDialogs.For(
+                mProgressControls.ProgressData);
+
+            GUILayout.Space(10);
+
+            DoButtonsArea();
+        }
+
+        protected override string GetTitle()
+        {
+            return PlasticLocalization.GetString(
+                PlasticLocalization.Name.CredentialsDialogTitle);
+        }
+
+        AskCredentialsToUser.DialogData BuildCredentialsDialogData(
+            ResponseType dialogResult)
+        {
+            return new AskCredentialsToUser.DialogData(
+                dialogResult == ResponseType.Ok,
+                mUser, mPassword, mSaveProfile, mSeidWorkingMode);
+        }
+
+        void DoEntriesArea()
+        {
+            mUser = TextEntry(PlasticLocalization.GetString(
+                PlasticLocalization.Name.UserName), mUser,
+                ENTRY_WIDTH, ENTRY_X);
+
+            GUILayout.Space(5);
+
+            mPassword = PasswordEntry(PlasticLocalization.GetString(
+                PlasticLocalization.Name.Password), mPassword,
+                ENTRY_WIDTH, ENTRY_X);
+
+            GUILayout.Space(5);
+
+            mSaveProfile = ToggleEntry(PlasticLocalization.GetString(
+                PlasticLocalization.Name.RememberCredentialsAsProfile),
+                mSaveProfile, ENTRY_WIDTH, ENTRY_X);
+        }
+
+        void DoButtonsArea()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+
+                if (Application.platform == RuntimePlatform.WindowsEditor)
+                {
+                    DoOkButton();
+                    DoCancelButton();
+                    return;
+                }
+
+                DoCancelButton();
+                DoOkButton();
+            }
+        }
+
+        void DoOkButton()
+        {
+            if (!AcceptButton(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.OkButton)))
+                return;
+
+            OkButtonWithValidationAction();
+        }
+
+        void DoCancelButton()
+        {
+            if (!NormalButton(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.CancelButton)))
+                return;
+
+            CancelButtonAction();
+        }
+
+        void OkButtonWithValidationAction()
+        {
+            CredentialsDialogValidation.AsyncValidation(
+                BuildCredentialsDialogData(ResponseType.Ok), this, mProgressControls);
+        }
+
+        static CredentialsDialog Create(
+            string server,
+            SEIDWorkingMode seidWorkingMode,
+            ProgressControlsForDialogs progressControls)
+        {
+            var instance = CreateInstance<CredentialsDialog>();
+            instance.mServer = server;
+            instance.mSeidWorkingMode = seidWorkingMode;
+            instance.mProgressControls = progressControls;
+            instance.mEnterKeyAction = instance.OkButtonWithValidationAction;
+            instance.mEscapeKeyAction = instance.CancelButtonAction;
+            return instance;
+        }
+
+        string mUser;
+        string mPassword = string.Empty;
+
+        ProgressControlsForDialogs mProgressControls;
+        bool mSaveProfile;
+
+        string mServer;
+        SEIDWorkingMode mSeidWorkingMode;
+
+        const float ENTRY_WIDTH = 345f;
+        const float ENTRY_X = 150f;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CredentialsDialog.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c46424c57c6462945b14ac0c95281406
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CredentialsUIImpl.cs

@@ -0,0 +1,133 @@
+using System;
+using UnityEditor;
+
+using Codice.CM.Common;
+using System.Threading.Tasks;
+using Codice.Client.Common;
+using Codice.Client.Common.Connection;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+using Codice.Client.Common.Threading;
+using Unity.PlasticSCM.Editor.WebApi;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal class CredentialsUiImpl : AskCredentialsToUser.IGui
+    {
+        AskCredentialsToUser.DialogData AskCredentialsToUser.IGui.AskUserForCredentials(string servername, SEIDWorkingMode seidWorkingMode)
+        {
+            AskCredentialsToUser.DialogData result = null;
+
+            if (!PlasticPlugin.ConnectionMonitor.IsConnected)
+                return result;
+
+            GUIActionRunner.RunGUIAction(delegate
+            {
+                result = CredentialsDialog.RequestCredentials(
+                        servername, seidWorkingMode, ParentWindow.Get());
+            });
+
+            return result;
+        }
+
+        void AskCredentialsToUser.IGui.ShowSaveProfileErrorMessage(string message)
+        {
+            if (!PlasticPlugin.ConnectionMonitor.IsConnected)
+                return;
+
+            GUIActionRunner.RunGUIAction(delegate
+            {
+                GuiMessage.ShowError(string.Format(
+                    PlasticLocalization.GetString(
+                        PlasticLocalization.Name.CredentialsErrorSavingProfile),
+                    message));
+            });
+        }
+
+        AskCredentialsToUser.DialogData AskCredentialsToUser.IGui.AskUserForOidcCredentials(
+            string server)
+        {
+            throw new NotImplementedException("OIDC authentication not supported yet.");
+        }
+
+        AskCredentialsToUser.DialogData AskCredentialsToUser.IGui.AskUserForSamlCredentials(
+            string server)
+        {
+            throw new NotImplementedException("SAML authentication not supported yet.");
+        }
+
+        AskCredentialsToUser.DialogData AskCredentialsToUser.IGui.AskUserForSsoCredentials(
+            string cloudServer)
+        {
+            AskCredentialsToUser.DialogData result = null;
+
+            if (!PlasticPlugin.ConnectionMonitor.IsConnected)
+                return result;
+
+            GUIActionRunner.RunGUIAction(delegate
+            {
+                result = RunSSOCredentialsRequest(
+                    cloudServer, CloudProjectSettings.accessToken);
+            });
+
+            return result;
+        }
+
+        AskCredentialsToUser.DialogData RunSSOCredentialsRequest(
+            string cloudServer,
+            string unityAccessToken)
+        {
+            if (string.IsNullOrEmpty(unityAccessToken))
+            {
+                return SSOCredentialsDialog.RequestCredentials(
+                    cloudServer, ParentWindow.Get());
+            }
+
+            TokenExchangeResponse tokenExchangeResponse =
+                WaitUntilTokenExchange(unityAccessToken);
+
+            // There is no internet connection, so no way to get credentials
+            if (tokenExchangeResponse == null)
+            {
+                return new AskCredentialsToUser.DialogData(
+                    false, null, null, false,
+                    SEIDWorkingMode.SSOWorkingMode);
+            }
+
+            if (tokenExchangeResponse.Error == null)
+            {
+                return new AskCredentialsToUser.DialogData(
+                    true, 
+                    tokenExchangeResponse.User,
+                    tokenExchangeResponse.AccessToken, 
+                    false,
+                    SEIDWorkingMode.SSOWorkingMode);
+            }
+
+            return SSOCredentialsDialog.RequestCredentials(
+                cloudServer, ParentWindow.Get());
+        }
+
+        static TokenExchangeResponse WaitUntilTokenExchange(
+            string unityAccessToken)
+        {
+            TokenExchangeResponse result = null;
+
+            Task.Run(() =>
+            {
+                try
+                {
+                    result = WebRestApiClient.PlasticScm.
+                        TokenExchange(unityAccessToken);
+                }
+                catch (Exception ex)
+                {
+                    ExceptionsHandler.LogException(
+                        "CredentialsUiImpl", ex);
+                }
+            }).Wait();
+
+            return result;
+        }
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/CredentialsUIImpl.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 50d82b3e371b7cc42abc2999039b19cb
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/EncryptionConfigurationDialog.cs

@@ -0,0 +1,196 @@
+using UnityEditor;
+using UnityEngine;
+
+using Codice.Utils;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal class EncryptionConfigurationDialog : PlasticDialog
+    {
+        protected override Rect DefaultRect
+        {
+            get
+            {
+                var baseRect = base.DefaultRect;
+                return new Rect(baseRect.x, baseRect.y, 650, 425);
+            }
+        }
+
+        internal static EncryptionConfigurationDialogData RequestEncryptionPassword(
+            string server,
+            EditorWindow parentWindow)
+        {
+            EncryptionConfigurationDialog dialog = Create(server);
+
+            ResponseType dialogResult = dialog.RunModal(parentWindow);
+
+            EncryptionConfigurationDialogData result =
+                dialog.BuildEncryptionConfigurationData();
+
+            result.Result = dialogResult == ResponseType.Ok;
+            return result;
+        }
+
+        protected override void OnModalGUI()
+        {
+            Title(PlasticLocalization.GetString(
+                PlasticLocalization.Name.EncryptionConfiguration));
+
+            GUILayout.Space(20);
+
+            Paragraph(PlasticLocalization.GetString(
+                PlasticLocalization.Name.EncryptionConfigurationExplanation, mServer));
+
+            DoPasswordArea();
+
+            Paragraph(PlasticLocalization.GetString(
+                PlasticLocalization.Name.EncryptionConfigurationRemarks, mServer));
+
+            GUILayout.Space(10);
+
+            DoNotificationArea();
+
+            GUILayout.Space(10);
+
+            DoButtonsArea();
+        }
+
+        protected override string GetTitle()
+        {
+            return PlasticLocalization.GetString(
+                PlasticLocalization.Name.EncryptionConfiguration);
+        }
+
+        EncryptionConfigurationDialogData BuildEncryptionConfigurationData()
+        {
+            return new EncryptionConfigurationDialogData(
+                CryptoServices.GetEncryptedPassword(mPassword.Trim()));
+        }
+
+        void DoPasswordArea()
+        {
+            Paragraph(PlasticLocalization.GetString(
+                PlasticLocalization.Name.EncryptionConfigurationEnterPassword));
+
+            GUILayout.Space(5);
+
+            mPassword = PasswordEntry(PlasticLocalization.GetString(
+                PlasticLocalization.Name.Password), mPassword,
+                PASSWORD_TEXT_WIDTH, PASSWORD_TEXT_X);
+
+            GUILayout.Space(5);
+
+            mRetypePassword = PasswordEntry(PlasticLocalization.GetString(
+                PlasticLocalization.Name.RetypePassword), mRetypePassword,
+                PASSWORD_TEXT_WIDTH, PASSWORD_TEXT_X);
+
+            GUILayout.Space(18f);
+        }
+
+        void DoNotificationArea()
+        {
+            if (string.IsNullOrEmpty(mErrorMessage))
+                return;
+
+            var rect = GUILayoutUtility.GetRect(
+                GUILayoutUtility.GetLastRect().width, 30);
+
+            EditorGUI.HelpBox(rect, mErrorMessage, MessageType.Error);
+        }
+
+        void DoButtonsArea()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+
+                if (Application.platform == RuntimePlatform.WindowsEditor)
+                {
+                    DoOkButton();
+                    DoCancelButton();
+                    return;
+                }
+
+                DoCancelButton();
+                DoOkButton();
+            }
+        }
+
+        void DoOkButton()
+        {
+            if (!AcceptButton(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.OkButton)))
+                return;
+
+            OkButtonWithValidationAction();
+        }
+
+        void DoCancelButton()
+        {
+            if (!NormalButton(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.CancelButton)))
+                return;
+
+            CancelButtonAction();
+        }
+
+        void OkButtonWithValidationAction()
+        {
+            if (IsValidPassword(
+                    mPassword.Trim(), mRetypePassword.Trim(),
+                    out mErrorMessage))
+            {
+                mErrorMessage = string.Empty;
+                OkButtonAction();
+                return;
+            }
+
+            mPassword = string.Empty;
+            mRetypePassword = string.Empty;
+        }
+
+        static bool IsValidPassword(
+            string password, string retypePassword,
+            out string errorMessage)
+        {
+            errorMessage = string.Empty;
+
+            if (string.IsNullOrEmpty(password))
+            {
+                errorMessage = PlasticLocalization.GetString(
+                    PlasticLocalization.Name.InvalidEmptyPassword);
+                return false;
+            }
+
+            if (!password.Equals(retypePassword))
+            {
+                errorMessage = PlasticLocalization.GetString(
+                    PlasticLocalization.Name.PasswordDoesntMatch);
+                return false;
+            }
+
+            return true;
+        }
+
+        static EncryptionConfigurationDialog Create(string server)
+        {
+            var instance = CreateInstance<EncryptionConfigurationDialog>();
+            instance.mServer = server;
+            instance.mEnterKeyAction = instance.OkButtonWithValidationAction;
+            instance.mEscapeKeyAction = instance.CancelButtonAction;
+            return instance;
+        }
+
+        string mPassword = string.Empty;
+        string mRetypePassword = string.Empty;
+        string mErrorMessage = string.Empty;
+
+        string mServer = string.Empty;
+
+        const float PASSWORD_TEXT_WIDTH = 250f;
+        const float PASSWORD_TEXT_X = 200f;
+    }
+}
+

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/EncryptionConfigurationDialog.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 68d5bb402c52edc48b494a59b8971758
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/MissingEncryptionPasswordPromptHandler.cs

@@ -0,0 +1,36 @@
+using UnityEditor;
+
+using Codice.Client.Common.Encryption;
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal class MissingEncryptionPasswordPromptHandler :
+        ClientEncryptionServiceProvider.IEncryptioPasswordProvider
+    {
+        string ClientEncryptionServiceProvider.IEncryptioPasswordProvider
+            .GetEncryptionEncryptedPassword(string server)
+        {
+            string result = null;
+
+            GUIActionRunner.RunGUIAction(delegate
+            {
+                result = AskForEncryptionPassword(server);
+            });
+
+            return result;
+        }
+
+        string AskForEncryptionPassword(string server)
+        {
+            EncryptionConfigurationDialogData dialogData =
+                EncryptionConfigurationDialog.RequestEncryptionPassword(server, ParentWindow.Get());
+
+            if (!dialogData.Result)
+                return null;
+
+            return dialogData.EncryptedPassword;
+        }
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/MissingEncryptionPasswordPromptHandler.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 4f6e4f3809c687045b21461609e2f78b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/SSOCredentialsDialog.cs

@@ -0,0 +1,295 @@
+using System;
+
+using UnityEngine;
+using UnityEditor;
+
+using PlasticGui;
+using Unity.PlasticSCM.Editor.UI;
+using Unity.PlasticSCM.Editor.UI.Progress;
+using Codice.CM.Common;
+using Codice.Client.Common.OAuth;
+using Codice.Client.Common.Connection;
+using Unity.PlasticSCM.Editor.Configuration.CloudEdition.Welcome;
+using PlasticGui.Configuration.CloudEdition.Welcome;
+using PlasticGui.Configuration.OAuth;
+using System.Collections.Generic;
+using PlasticGui.WebApi.Responses;
+using PlasticGui.Configuration.CloudEdition;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal class SSOCredentialsDialog : PlasticDialog, OAuthSignIn.INotify, Login.INotify
+    {
+        protected override Rect DefaultRect
+        {
+            get
+            {
+                var baseRect = base.DefaultRect;
+                return new Rect(baseRect.x, baseRect.y, 525, 450);
+            }
+        }
+
+        internal static AskCredentialsToUser.DialogData RequestCredentials(
+            string cloudServer,
+            EditorWindow parentWindow)
+        {
+            SSOCredentialsDialog dialog = Create(
+                cloudServer, new ProgressControlsForDialogs());
+
+            ResponseType dialogResult = dialog.RunModal(parentWindow);
+
+            return dialog.BuildCredentialsDialogData(dialogResult);
+        }
+
+        protected override void OnModalGUI()
+        {
+            Title(PlasticLocalization.GetString(
+               PlasticLocalization.Name.CredentialsDialogTitle));
+
+            Paragraph(PlasticLocalization.GetString(
+                PlasticLocalization.Name.CredentialsDialogExplanation, mServer));
+
+            GUILayout.Space(20);
+
+            DoEntriesArea();
+
+            GUILayout.Space(10);
+
+            DrawProgressForDialogs.For(
+                mProgressControls.ProgressData);
+
+            GUILayout.Space(10);
+
+            DoButtonsArea();
+        }
+
+        protected override string GetTitle()
+        {
+            return PlasticLocalization.GetString(
+                PlasticLocalization.Name.CredentialsDialogTitle);
+        }
+
+        AskCredentialsToUser.DialogData BuildCredentialsDialogData(
+            ResponseType dialogResult)
+        {
+            return new AskCredentialsToUser.DialogData(
+                dialogResult == ResponseType.Ok,
+                mEmail, mPassword, false, SEIDWorkingMode.SSOWorkingMode);
+        }
+
+        void OAuthSignIn.INotify.SuccessForSSO(string organization)
+        {
+            OkButtonAction();
+        }
+
+        void OAuthSignIn.INotify.SuccessForProfile(string email)
+        {
+            OkButtonAction();
+        }
+
+        void OAuthSignIn.INotify.SuccessForCredentials(
+            string email,
+            string accessToken)
+        {
+            OkButtonAction();
+        }
+
+        void OAuthSignIn.INotify.SuccessForHomeView(string usrName)
+        {
+        }
+
+        void OAuthSignIn.INotify.Cancel(string errorMessage)
+        {
+            CancelButtonAction();
+        }
+        void OAuthSignIn.INotify.SuccessForConfigure(
+            List<string> organizations,
+            bool canCreateAnOrganization,
+            string userName,
+            string accessToken)
+        {
+            mEmail = userName;
+            mPassword = accessToken;
+
+            if (!organizations.Contains(mServer))
+            {
+                CancelButtonAction();
+                return;
+            }
+
+            CloudEditionWelcomeWindow.SaveDefaultCloudServer(mServer, userName);
+
+            GetWindow<PlasticWindow>().InitializePlastic();
+            OkButtonAction();
+        }
+
+        void DoButtonsArea()
+        {
+            using (new EditorGUILayout.HorizontalScope())
+            {
+                GUILayout.FlexibleSpace();
+
+                if (Application.platform == RuntimePlatform.WindowsEditor)
+                {
+                    DoOkButton();
+                    DoCancelButton();
+                    return;
+                }
+
+                DoCancelButton();
+                DoOkButton();
+            }
+        }
+
+        internal void OAuthSignInForConfigure(Uri signInUrl, Guid state, IGetOauthToken getOauthToken)
+        {
+            OAuthSignIn mSignIn = new OAuthSignIn();
+
+            mSignIn.ForConfigure(
+                signInUrl,
+                state,
+                mProgressControls,
+                this,
+                GetWindow<PlasticWindow>().CmConnectionForTesting,
+                getOauthToken,
+                PlasticGui.Plastic.WebRestAPI);
+        }
+
+        void DoUnityIDButton()
+        {
+            if (NormalButton("Sign in with Unity ID"))
+            {
+                Guid state = Guid.NewGuid();
+                OAuthSignInForConfigure(
+                    GetCloudSsoProviders.BuildAuthInfoForUnityId(string.Empty, state).SignInUrl,
+                    state,
+                    new GetCloudSsoToken(PlasticGui.Plastic.WebRestAPI));
+            }
+        }
+
+        void DoEntriesArea()
+        {
+            Paragraph("Sign in with Unity ID");
+            GUILayout.Space(5);
+
+            DoUnityIDButton();
+
+            GUILayout.Space(25);
+            Paragraph("    --or--    ");
+
+            Paragraph("Sign in with email");
+
+            mEmail = TextEntry(PlasticLocalization.GetString(
+                PlasticLocalization.Name.Email), mEmail,
+                ENTRY_WIDTH, ENTRY_X);
+
+            GUILayout.Space(5);
+
+            mPassword = PasswordEntry(PlasticLocalization.GetString(
+                PlasticLocalization.Name.Password), mPassword,
+                ENTRY_WIDTH, ENTRY_X);
+        }
+
+        void DoOkButton()
+        {
+            if (!AcceptButton(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.OkButton)))
+                return;
+
+            OkButtonWithValidationAction();
+        }
+
+        void DoCancelButton()
+        {
+            if (!NormalButton(PlasticLocalization.GetString(
+                    PlasticLocalization.Name.CancelButton)))
+                return;
+
+            CancelButtonAction();
+        }
+
+        void OkButtonWithValidationAction()
+        {
+            Login.Run(
+              PlasticGui.Plastic.WebRestAPI,
+              new SaveCloudEditionCreds(),
+              mEmail,
+              mPassword,
+              string.Empty,
+              string.Empty,
+              Login.Mode.Configure,
+              mProgressControls,
+              this);
+        }
+
+        void Login.INotify.SuccessForConfigure(
+            List<string> organizations,
+            bool canCreateAnOrganization,
+            string userName,
+            string password)
+        {
+            OkButtonAction();
+        }
+
+        void Login.INotify.SuccessForSSO(
+            string organization)
+        {
+            OkButtonAction();
+        }
+        void Login.INotify.SuccessForCredentials(string userName, string password)
+        {
+            OkButtonAction();
+        }
+
+
+        void Login.INotify.SuccessForProfile(
+            string userName)
+        {
+            OkButtonAction();
+        }
+
+        void Login.INotify.SuccessForHomeView(string userName)
+        {
+        }
+
+        void Login.INotify.ValidationFailed(
+            Login.ValidationResult validationResult)
+        {
+            CancelButtonAction();
+        }
+
+        void Login.INotify.SignUpNeeded(
+            Login.Data loginData)
+        {
+            CancelButtonAction();
+        }
+
+        void Login.INotify.Error(
+            string message)
+        {
+            CancelButtonAction();
+        }
+
+        static SSOCredentialsDialog Create(
+            string server,
+            ProgressControlsForDialogs progressControls)
+        {
+            var instance = CreateInstance<SSOCredentialsDialog>();
+            instance.mServer = server;
+            instance.mProgressControls = progressControls;
+            instance.mEnterKeyAction = instance.OkButtonWithValidationAction;
+            instance.mEscapeKeyAction = instance.CancelButtonAction;
+            return instance;
+        }
+
+        string mEmail;
+        string mPassword = string.Empty;
+
+        ProgressControlsForDialogs mProgressControls;
+
+        string mServer;
+
+        const float ENTRY_WIDTH = 345f;
+        const float ENTRY_X = 150f;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/SSOCredentialsDialog.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f1969c6a4a44a474983058896f48d9f5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/TeamEdition.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: e9d092d8c9e8ffe48882f0c22e0e880d
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/TeamEdition/TeamEditionConfigurationWindow.cs

@@ -0,0 +1,314 @@
+using System;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+using PlasticGui;
+using Codice.CM.Common;
+using Codice.Client.Common;
+using Unity.PlasticSCM.Editor.UI.UIElements;
+using PlasticGui.Configuration.TeamEdition;
+using PlasticGui.Configuration;
+using PlasticGui.WebApi;
+using Unity.PlasticSCM.Editor.Views.Welcome;
+
+namespace Unity.PlasticSCM.Editor.Configuration.TeamEdition
+{
+    internal class TeamEditionConfigurationWindow : EditorWindow
+    {
+        internal static void ShowWindow(IPlasticWebRestApi restApi, WelcomeView welcomeView)
+        {
+            TeamEditionConfigurationWindow window = GetWindow<TeamEditionConfigurationWindow>();
+            window.mRestApi = restApi;
+            window.mWelcomeView = welcomeView;
+            window.titleContent = new GUIContent(
+                PlasticLocalization.GetString(PlasticLocalization.Name.WelcomeToUnityVCS));
+            window.minSize = window.maxSize = new Vector2(650, 300);
+            window.Show();
+        }
+
+        void OnEnable()
+        {
+            InitializeLayoutAndStyles();
+
+            BuildComponents();
+        }
+
+        void Dispose()
+        {
+            mConnectButton.clicked -= ConnectButton_Clicked;
+            mCheckConnectionButton.clicked -= CheckConnectionButton_Clicked;
+            mOkButton.clicked -= OkButton_Clicked;
+            mCancelButton.clicked -= CancelButton_Clicked;
+            mServerTextField.UnregisterValueChangedCallback(OnServerTextFieldChanged);
+            mUseSslToggle.UnregisterValueChangedCallback(OnUseSslToggleChanged);
+
+            mLoadingSpinner.Dispose();
+        }
+
+        void ConnectButton_Clicked()
+        {
+            ConfigurationConnectServerButtonClickEvent.Click(
+                server: mUserAssistant.GetProposedServer(),
+                HideValidation: HideValidation,
+                ShowError: ShowServerValidationError,
+                ShowProgress: ShowProgress,
+                HideProgress: HideProgress,
+                ShowNotification: ShowServerNotificationMessage,
+                DisableButtons: () => { mConnectButton.SetEnabled(false); },
+                EnableButtons: () => { mConnectButton.SetEnabled(true); },
+                UpdatePasswordEntries: (seidWorkingMode) =>
+                {
+                    UpdatePasswordEntries(ValidateServerAndCreds.
+                        IsPasswordRequired(seidWorkingMode));
+                },
+                NotifyWorkingMode: (mode) => { mSEIDWorkingMode = mode; },
+                NotifyConnectedStatus: (b) => { });
+
+            mUserTextField.SetEnabled(true);
+        }
+
+        void OnDestroy()
+        {
+            Dispose();
+
+            if (mWelcomeView != null)
+                mWelcomeView.OnUserClosedConfigurationWindow();
+        }
+
+        void CheckConnectionButton_Clicked()
+        {
+            ConfigurationCheckCredentialsButtonClickEvent.Click(
+                mSEIDWorkingMode,
+                mUserTextField.value,
+                mPasswordTextField.value,
+                Edition.Team,
+                mUserAssistant,
+                HideCredentialsValidationError,
+                ShowCheckCredentialsError,
+                ShowProgress,
+                HideProgress,
+                ShowNotification: ShowCredentialsNotificationMessage,
+                DisableButtons: () => { mCheckConnectionButton.SetEnabled(false); mConnectButton.SetEnabled(false); },
+                EnableButtons: () => { mCheckConnectionButton.SetEnabled(true); mConnectButton.SetEnabled(true); },
+                NotifyWorkingMode: (mode) => { mSEIDWorkingMode = mode; },
+                NotifyConnectedStatus: (status) => { },
+                restApi: mRestApi,
+                cmConnection: CmConnection.Get());
+        }
+
+        void CancelButton_Clicked()
+        {
+            Close();
+        }
+
+        void OkButton_Clicked()
+        {
+            if (!ValidateServerAndCreds.IsValidInput(
+                mUserAssistant.GetProposedServer(),
+                mUserTextField.value,
+                mSEIDWorkingMode,
+                mPasswordTextField.value,
+                ShowCheckCredentialsError))
+            {
+                return;
+            }
+
+            ConfigurationActions.SaveClientConfig(
+                mServerTextField.value,
+                mSEIDWorkingMode,
+                mUserTextField.value,
+                mPasswordTextField.value);
+
+            Close();
+        }
+
+        void HideCredentialsValidationError()
+        {
+            mCredentialsLabel.RemoveFromClassList("error");
+            mCredentialsLabel.Hide();
+        }
+
+        void BuildComponents()
+        {
+            VisualElement root = rootVisualElement;
+
+            root.Query<Label>("plasticConfigurationTitle").First().text =
+                PlasticLocalization.GetString(PlasticLocalization.Name.PlasticConfigurationTitleUnityVCS);
+
+            root.SetControlText<Label>(
+                "plasticConfigurationExplanation",
+                PlasticLocalization.Name.PlasticConfigurationExplanation);
+
+            root.SetControlText<Label>("configurationServerInfo",
+                PlasticLocalization.Name.PlasticSCMServerLabel);
+
+            root.SetControlText<Button>(
+                "connect",
+                PlasticLocalization.Name.Connect);
+
+            root.SetControlText<Label>("useSsl",
+                PlasticLocalization.Name.UseSsl);
+
+            root.SetControlText<Label>("configurationUserNameInfo",
+               PlasticLocalization.Name.ConfigurationUserNameInfo);
+
+            root.SetControlText<Label>("configurationCredentialsInfo",
+                PlasticLocalization.Name.ConfigurationCredentialsInfo);
+
+            root.SetControlText<Button>("check",
+                PlasticLocalization.Name.Check);
+
+            root.SetControlText<Label>("credentialsOk",
+                PlasticLocalization.Name.CredentialsOK);
+
+            root.SetControlText<Button>("okButton",
+                PlasticLocalization.Name.OkButton);
+
+            root.SetControlText<Button>("cancelButton",
+                PlasticLocalization.Name.CancelButton);
+
+            mSpinnerContainer = root.Query<VisualElement>("spinnerContainer").First();
+            mSpinnerLabel = root.Query<Label>("spinnerLabel").First();
+
+            mLoadingSpinner = new LoadingSpinner();
+            mSpinnerContainer.Add(mLoadingSpinner);
+            mSpinnerContainer.Hide();
+
+            mCheckConnectionButton = root.Query<Button>("check").First();
+            mCheckConnectionButton.clicked += CheckConnectionButton_Clicked;
+
+            mConnectButton = root.Query<Button>("connect").First();
+            mConnectButton.clicked += ConnectButton_Clicked;
+
+            mServerTextField = root.Query<TextField>("serverTextField").First();
+            mServerTextField.RegisterValueChangedCallback(OnServerTextFieldChanged);
+
+            mUseSslToggle = root.Query<Toggle>("useSslToogle").First();
+            mUseSslToggle.RegisterValueChangedCallback(OnUseSslToggleChanged);
+
+            mUserTextField = root.Query<TextField>("userTextField").First();
+            mUserTextField.SetEnabled(false);
+
+            mPasswordTextField = root.Query<TextField>("passwordTextField").First();
+            mPasswordTextField.isPasswordField = true;
+
+            mConnectedLabel = root.Query<Label>("connectedLabel").First();
+
+            mCredentialsLabel = root.Query<Label>("credentialsOk").First();
+
+            mOkButton = root.Query<Button>("okButton").First();
+            mOkButton.clicked += OkButton_Clicked;
+
+            mCancelButton = root.Query<Button>("cancelButton").First();
+            mCancelButton.clicked += CancelButton_Clicked;
+        }
+
+        void OnUseSslToggleChanged(ChangeEvent<bool> evt)
+        {
+            mUserAssistant.OnSslChanged(mServerTextField.value, evt.newValue);
+            mServerTextField.value = mUserAssistant.GetProposedServer();
+        }
+
+        void InitializeLayoutAndStyles()
+        {
+            VisualElement root = rootVisualElement;
+
+            root.LoadLayout(typeof(TeamEditionConfigurationWindow).Name);
+
+            root.LoadStyle(typeof(TeamEditionConfigurationWindow).Name);
+        }
+
+        void OnServerTextFieldChanged(ChangeEvent<string> evt)
+        {
+            mUserAssistant.OnServerChanged(evt.newValue);
+            mUseSslToggle.value = mUserAssistant.IsSslServer(evt.newValue);
+        }
+
+        void ShowServerNotificationMessage(string message)
+        {
+            mConnectedLabel.text = message;
+            mConnectedLabel.Show();
+        }
+
+        void ShowServerValidationError(string message)
+        {
+            mConnectedLabel.text = message;
+            mConnectedLabel.AddToClassList("error");
+            mConnectedLabel.Show();
+        }
+
+        void ShowCredentialsNotificationMessage(string message)
+        {
+            mCredentialsLabel.text = message;
+            mCredentialsLabel.Show();
+        }
+
+        void ShowCheckCredentialsError(string message)
+        {
+            mCredentialsLabel.text = message;
+            mCredentialsLabel.AddToClassList("error");
+            mCredentialsLabel.Show();
+        }
+
+        void HideValidation()
+        {
+            mConnectedLabel.RemoveFromClassList("error");
+            mConnectedLabel.Hide();
+        }
+
+        void ShowProgress(string text)
+        {
+            mSpinnerLabel.text = text;
+
+            mSpinnerContainer.Show();
+            mSpinnerLabel.Show();
+            mLoadingSpinner.Start();
+        }
+
+        void HideProgress()
+        {
+            mLoadingSpinner.Stop();
+            mSpinnerContainer.Hide();
+            mSpinnerLabel.Hide();
+        }
+
+        void UpdatePasswordEntries(bool bIsPasswordRequired)
+        {
+            if (!bIsPasswordRequired)
+            {
+                mPasswordTextField.Collapse();
+                mUserTextField.SetEnabled(false);
+                mUserTextField.value = Environment.UserName;
+                return;
+            }
+
+            mUserTextField.SetEnabled(true);
+            mPasswordTextField.Show();
+            mUserTextField.SelectAll();
+            mUserTextField.FocusWorkaround();
+        }
+
+        Button mConnectButton;
+        Label mConnectedLabel;
+        TextField mServerTextField;
+        TextField mPasswordTextField;
+        Toggle mUseSslToggle;
+        LoadingSpinner mLoadingSpinner;
+        Label mSpinnerLabel;
+        VisualElement mSpinnerContainer;
+        Button mCheckConnectionButton;
+        Label mCredentialsLabel;
+        Button mOkButton;
+        Button mCancelButton;
+
+        SEIDWorkingMode mSEIDWorkingMode = SEIDWorkingMode.UPWorkingMode;
+
+        ConfigurationDialogUserAssistant mUserAssistant =
+            new ConfigurationDialogUserAssistant();
+
+        IPlasticWebRestApi mRestApi;
+        WelcomeView mWelcomeView;
+        TextField mUserTextField;
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/TeamEdition/TeamEditionConfigurationWindow.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: c95121e1e2d89e648b9d0aed259caad9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/ToolConfig.cs

@@ -0,0 +1,26 @@
+using System.IO;
+
+using Codice.Utils;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal static class ToolConfig
+    {
+        internal static string GetUnityPlasticLogConfigFile()
+        {
+            return GetConfigFilePath(LOG_CONFIG_FILE);
+        }
+
+        static string GetConfigFilePath(string configfile)
+        {
+            string file = Path.Combine(ApplicationLocation.GetAppPath(), configfile);
+
+            if (File.Exists(file))
+                return file;
+
+            return UserConfigFolder.GetConfigFile(configfile);
+        }
+
+        const string LOG_CONFIG_FILE = "unityplastic.log.conf";
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/ToolConfig.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: ee776820547bd654980004e8471df8e3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/WriteLogConfiguration.cs

@@ -0,0 +1,66 @@
+using System.IO;
+
+namespace Unity.PlasticSCM.Editor.Configuration
+{
+    internal class WriteLogConfiguration
+    {
+        internal static void For(string logConfigPath)
+        {
+            string logDirectoryPath = GetPlasticLogDirectoryPath(logConfigPath);
+            string relevantLogFile = Path.Combine(logDirectoryPath, RELEVANT_LOG_FILE_NAME);
+            string debugLogFile = Path.Combine(logDirectoryPath, DEBUG_LOG_FILE_NAME);
+
+            using (StreamWriter sw = File.CreateText(logConfigPath))
+            {
+                sw.Write(string.Format(
+                    LOG_CONFIGURATION,
+                    relevantLogFile,
+                    debugLogFile));
+            }
+        }
+
+        static string GetPlasticLogDirectoryPath(string logConfigPath)
+        {
+            return Path.Combine(
+                Directory.GetParent(logConfigPath).FullName,
+                LOGS_DIRECTORY);
+        }
+
+        const string LOGS_DIRECTORY = "logs";
+        const string RELEVANT_LOG_FILE_NAME = "unityplastic.relevant.log.txt";
+        const string DEBUG_LOG_FILE_NAME = "unityplastic.debug.log.txt";
+        const string LOG_CONFIGURATION = 
+@"<log4net>
+  <appender name=""RelevantInfoAppender"" type=""log4net.Appender.RollingFileAppender"">
+    <file value=""{0}"" />
+    <appendToFile value=""true"" />
+    <rollingStyle value=""Size"" />
+    <maxSizeRollBackups value=""10"" />
+    <maximumFileSize value=""2MB"" />
+    <layout type=""log4net.Layout.PatternLayout"">
+      <conversionPattern value=""%date %username %-5level %logger - %message%newline"" />
+    </layout>
+    <filter type=""log4net.Filter.LevelRangeFilter""><levelMin value=""INFO"" /><levelMax value=""FATAL"" /></filter>
+  </appender>
+
+  <appender name=""DebugAppender"" type=""log4net.Appender.RollingFileAppender"">
+    <file value=""{1}"" />
+    <appendToFile value=""true"" />
+    <rollingStyle value=""Size"" />
+    <maxSizeRollBackups value=""10"" />
+    <maximumFileSize value=""10MB"" />
+    <staticLogFileName value=""true"" />
+    <layout type=""log4net.Layout.PatternLayout"">
+      <conversionPattern value=""%date %username %-5level %logger - %message%newline"" />
+    </layout>
+  </appender>
+
+  <root>
+    <level value=""DEBUG"" />
+    <appender-ref ref=""RelevantInfoAppender"" />
+    <appender-ref ref=""DebugAppender"" />
+  </root>
+</log4net>
+";
+    }
+}

My project/Library/PackageCache/com.unity.collab-proxy/Editor/PlasticSCM/Configuration/WriteLogConfiguration.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 332442c8f4f7b1943bb9e12fc97356e4
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: