first commit

Library/PackageCache/com.unity.collab-proxy@2.5.2/Editor/PlasticSCM/Configuration/CloudEdition/Welcome.meta

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

Library/PackageCache/com.unity.collab-proxy@2.5.2/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");
+    }
+
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/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: 

Library/PackageCache/com.unity.collab-proxy@2.5.2/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;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/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: 

Library/PackageCache/com.unity.collab-proxy@2.5.2/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;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/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: 

Library/PackageCache/com.unity.collab-proxy@2.5.2/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;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/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: 

Library/PackageCache/com.unity.collab-proxy@2.5.2/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;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/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: 

Library/PackageCache/com.unity.collab-proxy@2.5.2/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;
+    }
+}

Library/PackageCache/com.unity.collab-proxy@2.5.2/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: