linux-packaging-mono/mcs/class/referencesource/System.Web.Entity.Design/System/Data/WebControls/Design/EntityDataSourceConfigureObjectContext.cs

//------------------------------------------------------------------------------
// <copyright file="EntityDataSourceConfigureObjectContext.cs" company="Microsoft">
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner       Microsoft
// @backupOwner Microsoft
//
// Manages the properties that can be set on the first page of the wizard
//------------------------------------------------------------------------------

using System.Collections.Generic;
using System.Web.UI.Design.WebControls.Util;
using System.Diagnostics;
using System.Globalization;
using System.Windows.Forms;

namespace System.Web.UI.Design.WebControls
{
    // delegate for event handler to process notifications when the DefaultContainerName is changed
    internal delegate void EntityDataSourceContainerChangedEventHandler(object sender, EntityDataSourceContainerNameItem newContainerName);

    internal class EntityDataSourceConfigureObjectContext
    {
        #region Private readonly fields
        private readonly EntityDataSourceConfigureObjectContextPanel _panel;
        private readonly EntityDataSourceDesignerHelper _helper;
        #endregion

        #region Private writeable fields
        private EntityDataSourceContainerChangedEventHandler _containerNameChanged; // used to notify the DataSelection panel that a change has been made
        #endregion

        #region Private fields for temporary storage of property values
        private EntityConnectionStringBuilderItem _selectedConnectionStringBuilder;
        private bool _connectionStringHasValue;
        private List<EntityConnectionStringBuilderItem> _namedConnections;
        private List<EntityDataSourceContainerNameItem> _containerNames;
        private EntityDataSourceContainerNameItem _selectedContainerName;
        private readonly EntityDataSourceState _entityDataSourceState;        
        private readonly EntityDataSourceWizardForm _wizardForm;
        #endregion

        #region Constructors
        internal EntityDataSourceConfigureObjectContext(EntityDataSourceConfigureObjectContextPanel panel, EntityDataSourceWizardForm wizardForm, EntityDataSourceDesignerHelper helper, EntityDataSourceState entityDataSourceState)
        {
            try
            {
                Cursor.Current = Cursors.WaitCursor;
                _panel = panel;
                _helper = helper;

                // Explicitly load metadata here to ensure that we get the latest changes in the project
                _helper.ReloadResources();

                _panel.Register(this);

                _wizardForm = wizardForm;
                _entityDataSourceState = entityDataSourceState;
            }
            finally
            {
                Cursor.Current = Cursors.Default;
            }
        }
        #endregion

        #region Events
        internal event EntityDataSourceContainerChangedEventHandler ContainerNameChanged
        {
            add
            {
                _containerNameChanged += value;
            }
            remove
            {
                _containerNameChanged -= value;
            }
        }

        // Fires the event to notify that a container has been chosen from the list
        private void OnContainerNameChanged(EntityDataSourceContainerNameItem selectedContainerName)
        {
            if (_containerNameChanged != null)
            {
                _containerNameChanged(this, selectedContainerName);
            }
        }
        
        #endregion        

        #region Methods to manage temporary state and wizard contents
        // Save current wizard settings back to the EntityDataSourceState
        internal void SaveState()
        {
            SaveConnectionString();
            SaveContainerName();            
        }

        // Load the initial state of the wizard
        internal void LoadState()
        {
            LoadConnectionStrings();
            LoadContainerNames(_entityDataSourceState.DefaultContainerName, true /*initialLoad*/);            
        }

        #region DefaultContainerName
        /// <summary>
        /// Populates the DefaultContainerName ComboBox with all of the EntityContainers in the loaded metadata
        /// If the specified DefaultContainerName property on the data source control is not empty and 'initialLoad' is true, 
        /// it is added to the list and selected in the control
        /// </summary>
        /// <param name="containerName">The container name to find</param>
        /// <param name="initialLoad">if true, this is the initial load so the container name is added to the list if it is not found.</param>
        private void LoadContainerNames(string containerName, bool initialLoad)
        {
            // Get a list of EntityContainers from the metadata in the connection string
            _containerNames = _helper.GetContainerNames(false /*sortResults*/);
            
            // Try to find the specified container in list
            _selectedContainerName = FindContainerName(containerName, initialLoad /*addIfNotFound*/);

            // Sort the list now, after we may have added a new entry above
            _containerNames.Sort();

            // Update the controls
            _panel.SetContainerNames(_containerNames);
            _panel.SetSelectedContainerName(_selectedContainerName, initialLoad /*initialLoad*/);
        }

        /// <summary>
        /// Find the current container in the current list of containers
        /// </summary>
        /// <param name="containerName">The container name to find</param>
        /// <param name="addIfNotFound">if true, adds the container name to the list if it is not found.</param>
        /// <returns></returns>
        private EntityDataSourceContainerNameItem FindContainerName(string containerName, bool addIfNotFound)
        {
            Debug.Assert(_containerNames != null, "_containerNames have already been initialized and should not be null");

            if (!String.IsNullOrEmpty(containerName))
            {
                EntityDataSourceContainerNameItem containerToSelect = null;
                foreach (EntityDataSourceContainerNameItem containerNameItem in _containerNames)
                {
                    // Ignore case here when searching the list for a matching item, but set the temporary state property to the
                    // correctly-cased version from metadata so that if the user clicks Finish, the correct one will be saved. This
                    // allows some flexibility the designer without preserving an incorrectly-cased value that could cause errors at runtime.
                    if (String.Equals(containerName, containerNameItem.EntityContainerName, StringComparison.OrdinalIgnoreCase))
                    {
                        containerToSelect = containerNameItem;
                    }
                }

                // didn't find a matching container, so just create a placeholder for one using the specified name and add it to the list
                if (containerToSelect == null && addIfNotFound)
                {
                    containerToSelect = new EntityDataSourceContainerNameItem(containerName);
                    _containerNames.Add(containerToSelect);                    
                }

                Debug.Assert(addIfNotFound == false || containerToSelect != null, "expected a non-null EntityDataSourceContainerNameItem");
                return containerToSelect;
            }

            return null;
        }

        // Set the container name in temporary storage, update the connection string, and fire the event so the EntitySet will know there has been a change
        internal void SelectContainerName(EntityDataSourceContainerNameItem selectedContainer)
        {
            _selectedContainerName = selectedContainer;

            UpdateWizardState();
            OnContainerNameChanged(_selectedContainerName);
        }

        private void SaveContainerName()
        {
            Debug.Assert(_selectedContainerName != null, "wizard data should not be saved if container name is empty");
            _entityDataSourceState.DefaultContainerName = _selectedContainerName.EntityContainerName;
        }
        #endregion

        #region ConnectionString
        // Populates the NamedConnection ComboBox with all of the EntityClient connections from the web.config.
        // If the specified connectionString is a named connection (if it contains "name=ConnectionName"), it is added to the list and selected.        
        // If the specified connectionString is not a named connection, the plain connection string option is selected and populated with the specified value.
        private void LoadConnectionStrings()
        {
            // Get a list of all named EntityClient connections in the web.config
            _namedConnections = _helper.GetNamedEntityClientConnections(false /*sortResults*/);

            EntityConnectionStringBuilderItem connStrBuilderItem = _helper.GetEntityConnectionStringBuilderItem(_entityDataSourceState.ConnectionString);
            Debug.Assert(connStrBuilderItem != null, "expected GetEntityConnectionStringBuilder to always return non-null");

            if (connStrBuilderItem.IsNamedConnection)
            {
                // Try to find the specified connection in the list or add it
                connStrBuilderItem = FindCurrentNamedConnection(connStrBuilderItem);
                Debug.Assert(connStrBuilderItem != null, "expected a non-null connStrBuilderItem for the named connection because it should have added it if it didn't exist");
            }

            // Sort results now, after we may have added a new item above
            _namedConnections.Sort();

            SelectConnectionStringBuilder(connStrBuilderItem, false /*resetContainer*/);
            
            // Update the controls
            _panel.SetNamedConnections(_namedConnections);
            _panel.SetConnectionString(_selectedConnectionStringBuilder);
        }

        // Find the current named connection in the list of connections
        // The returned item may refer to the same connection as the specified item, but it will be the actual reference from the list
        private EntityConnectionStringBuilderItem FindCurrentNamedConnection(EntityConnectionStringBuilderItem newBuilderItem)
        {
            Debug.Assert(_namedConnections != null, "_namedConnections should have already been initialized and should not be null");
            Debug.Assert(newBuilderItem != null && newBuilderItem.IsNamedConnection, "expected non-null newBuilderItem");

            foreach (EntityConnectionStringBuilderItem namedConnectionItem in _namedConnections)
            {
                if (((IComparable<EntityConnectionStringBuilderItem>)newBuilderItem).CompareTo(namedConnectionItem) == 0)
                {
                    // returning the one that was actually in the list, so we can select it in the control
                    return namedConnectionItem;
                }
            }

            // didn't find it in the list, so add it
            _namedConnections.Add(newBuilderItem);
            return newBuilderItem;            
        }

        internal EntityConnectionStringBuilderItem GetEntityConnectionStringBuilderItem(string connectionString)
        {
            return _helper.GetEntityConnectionStringBuilderItem(connectionString);
        }

        // Set the connection string in temporary storage
        // Returns true if the metadata was successfully loaded for the specified connections
        internal bool SelectConnectionStringBuilder(EntityConnectionStringBuilderItem selectedConnection, bool resetContainer)
        {
            _selectedConnectionStringBuilder = selectedConnection;

            bool metadataLoaded = false;
            if (selectedConnection != null)
            {
                if (selectedConnection.EntityConnectionStringBuilder != null)
                {
                    metadataLoaded = _helper.LoadMetadata(selectedConnection.EntityConnectionStringBuilder);                    
                }
                else
                {
                    // Since we don't have a valid connection string builder, we don't have enough information to load metadata.
                    // Clear any existing metadata so we don't see an old item collection on any subsequent calls that access it.
                    // Don't need to display an error here because that was handled by the caller who created the builder item
                    _helper.ClearMetadata();                    
                }
            }

            // Reset the list of containers if requested and set the ComboBox to have no selection.
            // In some cases the containers do not need to be reset because the caller wants to delay that until a later event or wants to preserve a specific value
            if (resetContainer)
            {
                string defaultContainerName = _selectedConnectionStringBuilder.EntityConnectionStringBuilder == null ? null : _selectedConnectionStringBuilder.EntityConnectionStringBuilder.Name;
                LoadContainerNames(defaultContainerName, false /*initialLoad*/);
            }
            
            // Update the controls
            UpdateWizardState();

            return metadataLoaded;
        }

        // Set a flag indicating that the connection string textbox or named connection dropdown has a value
        // This value has not be verified at this point, or may not even be complete, so we don't want to validate it yet and turn it into a builder
        internal void SelectConnectionStringHasValue(bool connectionStringHasValue)
        {
            _connectionStringHasValue = connectionStringHasValue;

            // Update the controls
            UpdateWizardState();
        }

        private void SaveConnectionString()
        {
            Debug.Assert(_selectedConnectionStringBuilder != null, "wizard data should not be saved if connection string is empty");
            _entityDataSourceState.ConnectionString = _selectedConnectionStringBuilder.ConnectionString;
        }

        
        #endregion        
        #endregion

        #region Wizard button state management
        // Update the state of the wizard buttons
        internal void UpdateWizardState()
        {
            _wizardForm.SetCanNext(this.CanEnableNext);

            // Finish button should never be enabled at this stage
            _wizardForm.SetCanFinish(false);
        }

        // Next button can only be enabled when the following are true:
        // (1) DefaultContainerName has a value             
        // (2) Either a named connection is selected or the connection string textbox has a value            
        internal bool CanEnableNext
        { 
            get
            {
                return _selectedContainerName != null && _connectionStringHasValue;
            }
        }
        #endregion
    }
}