Search for webmap

// Copyright 2021 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
// You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
// language governing permissions and limitations under the License.

using ArcGIS.Helpers;
using Esri.ArcGISRuntime;
using Esri.ArcGISRuntime.Mapping;
using Esri.ArcGISRuntime.Portal;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows;

namespace ArcGIS.WPF.Samples.SearchPortalMaps
{
    [ArcGIS.Samples.Shared.Attributes.Sample(
        name: "Search for webmap",
        category: "Map",
        description: "Find webmap portal items by using a search term.",
        instructions: "Enter search terms into the search bar. Once the search is complete, a list is populated with the resultant webmaps. Tap on a webmap to set it to the map view. Scrolling to the bottom of the webmap recycler view will get more results.",
        tags: new[] { "keyword", "query", "search", "webmap" })]
    [ArcGIS.Samples.Shared.Attributes.ClassFile("Helpers\\ArcGISLoginPrompt.cs")]
    public partial class SearchPortalMaps
    {
        private const string ArcGISOnlineUrl = "https://www.arcgis.com/sharing/rest";

        // Constructor for sample class
        public SearchPortalMaps()
        {
            this.Loaded += (s, e) => { _ = Initialize(); };
            InitializeComponent();
        }

        private async Task Initialize()
        {
            ArcGISLoginPrompt.SetChallengeHandler();

            bool loggedIn = await ArcGISLoginPrompt.EnsureAGOLCredentialAsync();

            // Display a default map
            if (loggedIn) DisplayDefaultMap();
        }

        private void DisplayDefaultMap() => MyMapView.Map = new Map(BasemapStyle.ArcGISLightGray);

        private async void SearchButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                // Get web map portal items in the current user's folder or from a keyword search
                IEnumerable<PortalItem> mapItems;
                ArcGISPortal portal;

                // See if the user wants to search public web map items
                if (SearchPublicMaps.IsChecked == true)
                {
                    // Connect to the portal (anonymously)
                    portal = await ArcGISPortal.CreateAsync();

                    // Create a query expression that will get public items of type 'web map' with the keyword(s) in the items tags
                    string queryExpression = string.Format("tags:\"{0}\" access:public type: (\"web map\" NOT \"web mapping application\")", SearchText.Text);

                    // Create a query parameters object with the expression and a limit of 10 results
                    PortalQueryParameters queryParams = new PortalQueryParameters(queryExpression, 10);

                    // Search the portal using the query parameters and await the results
                    PortalQueryResultSet<PortalItem> findResult = await portal.FindItemsAsync(queryParams);

                    // Get the items from the query results
                    mapItems = findResult.Results;
                }
                else
                {
                    // Call a sub that will force the user to log in to ArcGIS Online (if they haven't already).
                    bool loggedIn = await ArcGISLoginPrompt.EnsureAGOLCredentialAsync();
                    if (!loggedIn) { return; }

                    // Connect to the portal (will connect using the provided credentials)
                    portal = await ArcGISPortal.CreateAsync(new Uri(ArcGISOnlineUrl));

                    // Get the user's content (items in the root folder and a collection of sub-folders)
                    PortalUserContent myContent = await portal.User.GetContentAsync();

                    // Get the web map items in the root folder
                    mapItems = from item in myContent.Items where item.Type == PortalItemType.WebMap select item;

                    // Loop through all sub-folders and get web map items, add them to the mapItems collection
                    foreach (PortalFolder folder in myContent.Folders)
                    {
                        IEnumerable<PortalItem> folderItems = await portal.User.GetContentAsync(folder.FolderId);
                        mapItems = mapItems.Concat(from item in folderItems where item.Type == PortalItemType.WebMap select item);
                    }
                }

                // Show the web map portal items in the list box
                MapListBox.ItemsSource = mapItems;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.ToString(), "Error");
            }
        }

        private void LoadMapButtonClick(object sender, RoutedEventArgs e)
        {
            // Get the selected web map item in the list box
            PortalItem selectedMap = MapListBox.SelectedItem as PortalItem;
            if (selectedMap == null) { return; }

            // Create a new map, pass the web map portal item to the constructor
            Map webMap = new Map(selectedMap);

            // Handle change in the load status (to report load errors)
            webMap.LoadStatusChanged += WebMapLoadStatusChanged;

            // Show the web map in the map view
            MyMapView.Map = webMap;
        }

        private void WebMapLoadStatusChanged(object sender, Esri.ArcGISRuntime.LoadStatusEventArgs e)
        {
            // Report errors if map failed to load
            if (e.Status == LoadStatus.FailedToLoad)
            {
                Map map = (Map)sender;
                Exception err = map.LoadError;
                if (err != null)
                {
                    MessageBox.Show(err.Message, "Map Load Error");
                }
            }
        }
    }
}

<UserControl x:Class="ArcGIS.WPF.Samples.SearchPortalMaps.SearchPortalMaps"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:esri="http://schemas.esri.com/arcgis/runtime/2013">
    <Grid>
        <esri:MapView x:Name="MyMapView" />
        <Border Style="{StaticResource BorderStyle}">
            <Grid>
                <Grid.ColumnDefinitions>
                    <ColumnDefinition />
                    <ColumnDefinition />
                </Grid.ColumnDefinitions>
                <Grid.RowDefinitions>
                    <RowDefinition />
                    <RowDefinition />
                    <RowDefinition />
                    <RowDefinition Height="100" />
                    <RowDefinition />
                </Grid.RowDefinitions>
                <RadioButton x:Name="SearchPublicMaps"
                             Grid.Row="0"
                             Grid.Column="0"
                             HorizontalAlignment="Left"
                             Content="Search public maps:"
                             IsChecked="True" />
                <TextBox x:Name="SearchText"
                         Grid.Row="0"
                         Grid.Column="1"
                         IsEnabled="{Binding ElementName=SearchPublicMaps, Path=IsChecked}" />
                <RadioButton x:Name="BrowseMyMaps"
                             Grid.Row="1"
                             Grid.Column="0"
                             HorizontalAlignment="Left"
                             Content="Browse my maps" />
                <Button x:Name="SearchButton"
                        Grid.Row="2"
                        Grid.Column="0"
                        Grid.ColumnSpan="2"
                        Margin="0,5,0,0"
                        Click="SearchButton_Click"
                        Content="Get maps" />
                <ListBox x:Name="MapListBox"
                         Grid.Row="3"
                         Grid.Column="0"
                         Grid.ColumnSpan="2"
                         Margin="0,5,0,0"
                         DisplayMemberPath="Title"
                         ScrollViewer.HorizontalScrollBarVisibility="Disabled"
                         SelectionMode="Single" />
                <Button x:Name="LoadMapButton"
                        Grid.Row="4"
                        Grid.Column="0"
                        Grid.ColumnSpan="2"
                        Margin="0,5,0,0"
                        Click="LoadMapButtonClick"
                        Content="Load selected map" />
            </Grid>
        </Border>
    </Grid>
</UserControl>

// Copyright 2021 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
// You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
// language governing permissions and limitations under the License.

using Esri.ArcGISRuntime.Security;
using Microsoft.Web.WebView2.Core;
using Microsoft.Web.WebView2.Wpf;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Windows;
using System.Windows.Threading;

namespace ArcGIS.Helpers
{
    internal static class ArcGISLoginPrompt
    {
        private const string ArcGISOnlineUrl = "https://www.arcgis.com/sharing/rest";

        // - The Client ID for an app registered with the server (the ID below is for a public app created by the ArcGIS Maps SDK for Native Apps team).
        private const string AppClientId = "lgAdHkYZYlwwfAhC";

        // - An optional client secret for the app (only needed for the OAuthClientCredentials authorization type).
        private const string ClientSecret = "";

        // - A URL for redirecting after a successful authorization (this must be a URL configured with the app).
        private const string OAuthRedirectUrl = "my-ags-app://auth";

        public static async Task<bool> EnsureAGOLCredentialAsync()
        {
            Credential currentCredential = AuthenticationManager.Current.FindCredential(new Uri(ArcGISOnlineUrl), AuthenticationType.Token);
            if (currentCredential != null)
            {
                return true; // already logged in
            }

            try
            {
                var userConfig = new OAuthUserConfiguration(new Uri(ArcGISOnlineUrl), AppClientId, new Uri(OAuthRedirectUrl));
                Credential cred = await OAuthUserCredential.CreateAsync(userConfig);
                AuthenticationManager.Current.AddCredential(cred);
            }
            catch (OperationCanceledException)
            {
                // OAuth login was canceled, no need to display error to user.
            }
            catch (Exception ex)
            {
                // Login failure
                MessageBox.Show("Login failed: " + ex.Message);
            }
            return false;
        }

        public static void SetChallengeHandler()
        {
            var userConfig = new OAuthUserConfiguration(new Uri(ArcGISOnlineUrl), AppClientId, new Uri(OAuthRedirectUrl));
            AuthenticationManager.Current.OAuthUserConfigurations.Add(userConfig);
            AuthenticationManager.Current.OAuthAuthorizeHandler = new OAuthAuthorize();
        }

        #region OAuth handler

        // In a desktop (WPF) app, an IOAuthAuthorizeHandler component is used to handle some of the OAuth details. Specifically, it
        //     implements AuthorizeAsync to show the login UI (generated by the server that hosts secure content) in a web control.
        //     When the user logs in successfully, cancels the login, or closes the window without continuing, the IOAuthAuthorizeHandler
        //     is responsible for obtaining the authorization from the server or raising an OperationCanceledException.
        public class OAuthAuthorize : IOAuthAuthorizeHandler
        {
            // Window to contain the OAuth UI.
            private Window _authWindow;

            // Use a TaskCompletionSource to track the completion of the authorization.
            private TaskCompletionSource<IDictionary<string, string>> _tcs;

            // URL for the authorization callback result (the redirect URI configured for your application).
            private string _callbackUrl;

            // URL that handles the OAuth request.
            private string _authorizeUrl;

            // Function to handle authorization requests, takes the URIs for the secured service, the authorization endpoint, and the redirect URI.
            public Task<IDictionary<string, string>> AuthorizeAsync(Uri serviceUri, Uri authorizeUri, Uri callbackUri)
            {
                if (_tcs != null && !_tcs.Task.IsCompleted)
                    throw new Exception("Task in progress");

                _tcs = new TaskCompletionSource<IDictionary<string, string>>();

                // Store the authorization and redirect URLs.
                _authorizeUrl = authorizeUri.AbsoluteUri;
                _callbackUrl = callbackUri.AbsoluteUri;

                // Call a function to show the login controls, make sure it runs on the UI thread for this app.
                Dispatcher dispatcher = Application.Current.Dispatcher;
                if (dispatcher == null || dispatcher.CheckAccess())
                {
                    AuthorizeOnUIThread(_authorizeUrl);
                }
                else
                {
                    Action authorizeOnUIAction = () => AuthorizeOnUIThread(_authorizeUrl);
                    dispatcher.BeginInvoke(authorizeOnUIAction);
                }

                // Return the task associated with the TaskCompletionSource.
                return _tcs.Task;
            }

            // Challenge for OAuth credentials on the UI thread.
            private void AuthorizeOnUIThread(string authorizeUri)
            {
                // Initialize a WebView2 control to display the authorize page.
                WebView2 webBrowser = new WebView2() { MinWidth = 500, MinHeight = 500 };

                // Handle the navigation event for the browser to check for a response to the redirect URL.
                webBrowser.NavigationStarting += WebBrowserOnNavigationStarting;

                // Display the web browser in a new window.
                _authWindow = new Window
                {
                    Content = webBrowser,
                    SizeToContent = SizeToContent.WidthAndHeight,
                    WindowStartupLocation = WindowStartupLocation.CenterOwner
                };

                // Set the app's window as the owner of the browser window (if main window closes, so will the browser).
                if (Application.Current != null && Application.Current.MainWindow != null)
                {
                    _authWindow.Owner = Application.Current.MainWindow;
                }

                // Handle window loaded event as the WebView2 control can only be initialized after it is visible in the UI
                _authWindow.Loaded += async (s, e) =>
                {
                    await webBrowser.EnsureCoreWebView2Async();
                    webBrowser.CoreWebView2.Navigate(authorizeUri);
                };

                // Handle the window closed event
                _authWindow.Closed += OnWindowClosed;

                // Display the window.
                _authWindow.ShowDialog();
            }

            // Handle the browser window closing.
            private void OnWindowClosed(object sender, EventArgs e)
            {
                // If the browser window closes, return the focus to the main window.
                if (_authWindow != null && _authWindow.Owner != null)
                {
                    _authWindow.Owner.Focus();
                }

                // If the task wasn't completed, the user must have closed the window without logging in.
                if (!_tcs.Task.IsCompleted)
                {
                    // Set the task completion source exception to indicate a canceled operation.
                    _tcs.SetCanceled();
                }

                _authWindow = null;
            }

            // Handle browser navigation
            private void WebBrowserOnNavigationStarting(object sender, CoreWebView2NavigationStartingEventArgs e)
            {
                // Check for a response to the callback url.
                const string portalApprovalMarker = "/oauth2/approval";

                Uri uri = new Uri(e.Uri);

                // If no browser, uri, or an empty url, return.
                if (sender == null || uri == null || string.IsNullOrEmpty(uri.AbsoluteUri))
                    return;

                // Check for redirect.
                bool isRedirected = uri.AbsoluteUri.StartsWith(_callbackUrl) ||
                    _callbackUrl.Contains(portalApprovalMarker) && uri.AbsoluteUri.Contains(portalApprovalMarker);

                // Check if browser was redirected to the callback URL. (This indicates succesful authentication.)
                if (isRedirected)
                {
                    e.Cancel = true;

                    // Call a helper function to decode the response parameters.
                    IDictionary<string, string> authResponse = DecodeParameters(uri);

                    // Set the result for the task completion source.
                    _tcs.SetResult(authResponse);

                    // Close the window.
                    if (_authWindow != null)
                    {
                        _authWindow.Close();
                    }
                }
            }

            private static IDictionary<string, string> DecodeParameters(Uri uri)
            {
                // Create a dictionary of key value pairs returned in an OAuth authorization response URI query string.
                string answer = "";

                // Get the values from the URI fragment or query string.
                if (!string.IsNullOrEmpty(uri.Fragment))
                {
                    answer = uri.Fragment.Substring(1);
                }
                else
                {
                    if (!string.IsNullOrEmpty(uri.Query))
                    {
                        answer = uri.Query.Substring(1);
                    }
                }

                // Parse parameters into key / value pairs.
                Dictionary<string, string> keyValueDictionary = new Dictionary<string, string>();
                string[] keysAndValues = answer.Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries);
                foreach (string kvString in keysAndValues)
                {
                    string[] pair = kvString.Split('=');
                    string key = pair[0];
                    string value = string.Empty;
                    if (key.Length > 1)
                    {
                        value = Uri.UnescapeDataString(pair[1]);
                    }

                    keyValueDictionary.Add(key, value);
                }

                // Return the dictionary of string keys/values.
                return keyValueDictionary;
            }
        }

        #endregion OAuth handler
    }
}