Portal metadata and search

The ArcGISPortal class is the entry point to the portal services hosted by ArcGIS Online and ArcGIS Enterprise. An ArcGISPortal instance provides access to the portal's information, including its name, URL, and other metadata. You can also use it to search for the PortalItems and PortalGroups that the portal contains.

The most common workflow for a ArcGIS Maps SDK for .NET app focuses on portal items, including searching for items, retrieving item details, managing items, and displaying items as web maps, web scenes, and galleries. The use of the PortalUser and PortalGroup classes is typically secondary, as these classes are primarily used to find items associated with the a user or a group. The tasks of creating and managing users and groups is performed through the ArcGIS Online or ArcGIS Enterprise web interface or an automation script that uses the ArcGIS Python API.

Create a portal instance

Start by creating an instance of the ArcGISPortal class, passing the URL of the portal and whether the user needs to log in to the portal (authenticated access) or not (anonymous access).

The AuthenticationManager.CreateAsync() method has several overloads for creating an ArcGISPortal instance, including one that takes a Boolean parameter to indicate whether or not the user needs to authenticate to connect to the portal. If the argument is false or not provided, an anonymous connection to the portal is made.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
    // Create a portal instance with anonymous access.
    var portal = await ArcGISPortal.CreateAsync(new System.Uri("https://your-portal-url.com"));

Use an argument of true to ensure the user is authenticated before connecting to the portal. If the user is not already authenticated, they will be prompted to log in.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
    // Create a portal instance that requires the user to log in.
    var securePortal = await ArcGISPortal.CreateAsync(new System.Uri("https://your-portal-url.com"), loginRequired: true);

Portal properties

ArcGISPortal provides components applicable to the portal as a whole via such functions as:

• GetBasemapsAsync()
• GetFeaturedGroupsAsync()
• GetFeaturedItemsAsync()
• GetStylesAsync()
• GetSymbolSetsAsync()

The ArcGISPortal.User property returns the current user in the case of authenticated access. In the case of anonymous access, it returns null. The property is of type PortalUser.

Portal info

While ArcGISPortal contains many properties to describe basic information about the portal, it also exposes the PortalInfo class to provide additional metadata for the portal. You can access this metadata from the ArcGISPortal.PortalInfo property. The PortalInfo class exposes information about the organization, including: default basemaps and extent to use when creating new maps, the thumbnail and banner images displayed on the organization page, a variety of query strings you can use to query groups, and more.

Search for portal items and groups

The ArcGISPortal class enables you to search for portal items and portal groups. You can use ArcGISPortal.FindItemsAsync() to find items based on various criteria, such as keywords, tags, and owner. Similarly, ArcGISPortal.FindGroupsAsync() allows you to find groups within the portal. Both methods take a PortalQueryParameters as a parameter.

The key to using PortalQueryParameters effectively is to understand how to create an object of the class.

Call the appropriate factory method to create query parameters suited to your search:

• CreateForGroups(): groups that have a specific owner and title.
• CreateForItemsWithId(): an item that has a specific item ID.
• CreateForItemsOfTypes(): items with the specified PortalItemTypes. (You can also restrict the search to a specific item owner, a group ID, and/or query string.)

Search for items in a group

You can search for portal items that belong to a specific group using the PortalGroup class. The PortalGroup.FindItemsAsync() method takes a PortalGroupContentSearchParameters instance.

You can use the appropriate factory method to create query parameters suited to your search:

• CreateForItemWithId(): a portal item in the group that has a specific ID.
• CreateForItemsOfTypes(): items within the group with the specified types.

There are several ways to obtain a PortalGroup instance. If you know the group ID, you can instantiate PortalGroup using its ID. To find a specific group that the current user belongs to, use the PortalUser.Groups property to get a list of all the user's groups. You can then iterate through the list to find the group you want.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
        List<PortalItem> publicItems = [];

        // Iterate all groups the current user is a member of.
        // (User is available with authenticated connections)
        var usersGroups = portal.User.Groups;
        foreach (var group in usersGroups)
        {
            // Search for public items in the group.
            var searchParams = new PortalGroupContentSearchParameters("access:public", 10);
            var findResult = await group.FindItemsAsync(searchParams);
            // Iterate the results.
            var items = findResult.Results;
            foreach (var itm in items)
            {
                // Add each item to the list.
                publicItems.Add(itm);
            }
        }
        // Display the results in a ListBox in the UI.
        ItemsListBox.ItemsSource = publicItems;

Search for items by user

You can search for portal items by PortalUser. To find items owned by a user, callPortalUser.GetContentAsync(). This returns a PortalUserContent object representing the content (folders and items) owned by the user. Its properties include:

• PortalUserContent.Items a collection of the portal items under the username (the user's "root" folder).
• PortalUserContent.Folders a collection of the user's subfolders.

You can then iterate over the collection of subfolders. For each subfolder, call PortalUser.GetContentInFolderAsync() and pass in the subfolder name to retrieve the portal items in the folder.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
        // Get the current user (requires an authenticated connection to the portal).
        var portalUser = portal.User;

        // Get the content the user owns.
        var userContent = await portalUser.GetContentAsync();

        // Iterate the user's folders.
        var subfolders = userContent.Folders;
        foreach (var folder in subfolders)
        {
            // Get the content in each folder.
            var folderContent = await portalUser.GetContentAsync(folder.FolderId);
            // Iterate the items in the folder.
            Debug.WriteLine($"Contents of folder: {folder.Title}");
            foreach (var item in folderContent)
            {
                Debug.WriteLine($"  {item.Title} ({item.Type})");
            }
        }