All posts tagged BCS

Business Connectivity Services – It’s Not Dead… Yet

I had a great time recently presenting at CalSpoug’s SharePoint Saturday.  The first session I presented was on SharePoint Business Connectivity Service.  I have done this session quite a few times and I always have at least one attendee state they have never heard of BCS before.  This session was no different.  One of the things I cover is the importance of BCS in different environments.  Many will argue it is an old, unnecessary system.  I do not necessarily disagree with this.  However, I argue it isn’t dead yet.  If you are working with simple data in a SQL Database or even more complex but well-organized data in a database the ease of use within BCS is quickly seen.  In 5-10 minutes you can connect to your data and present it within SharePoint utilizing built-in forms (no custom form development).  Users will be able to read and update the data immediately (assuming permissions are configured already).  There’s more to it than just this and you can take a look at my slide deck to see.

Having said that, I do believe that I see an end to BCS.  PowerApps and Flows make accessing data just as easy and more configurable through the many, many connectors available.  As these connectors mature and the tools grow, the use cases for BCS will slowly disappear.  However, we aren’t there yet.  BCS is still there and still very easy to use.

 

Take a look at my slide deck and if you have questions, please reach out.

 

Thanks for reading!

SharePoint Business Connectivity Services in SharePoint Online

I have always been a strong supporter of the SharePoint Business Connectivity feature.  I find that in many cases it allows for easy access to data you would normally have to develop custom solutions for or even pay large amounts of money in licencing for (SAP, PeopleSoft, etc).  BCS brings the ability to present data located in other systems into SharePoint.  A tool that many understand and use daily.  In this presentation I discuss using Business Connectivity Services within SharePoint Online as opposed to on premises.  You can find the slide deck here.  Thanks for attending my session on this topic.

 

Thanks for reading!!

Manipulating SharePoint External Lists using REST

In this third post on accessing SharePoint External Lists we are going to be manipulating sharePoint external lists using REST APIs.  You can view the previous two posts of this series by clicking on one of the following links:

Of all the methods of coding against external lists I would have to say that REST is probably the easiest.  You don’t have to create any complicated CAML queries to find items to read, delete or update as you would with CSOM.  You don’t have to add Service Context scope as you do with PowerShell.  In fact, with REST you can actually access data using the ID of the list item.

But Dave, I thought you said external lists don’t have IDs

Actually, they do.  However, as I said in the first post, the do not have Numerical IDs.  The IDs are actual text based.  Once fantastic about SharePoint REST API is you actually have a method you can call named: GetItemByStringId.  This method is exactly as it sounds.  Using it you will be able to get the internal ID of the list item generated when the item is added into the external list.

Unlike my previous posts I am not going to show you how to access internal lists and then compare the external access.  There isn’t a lot of code to write for this as I just want to give you the basics and Fiddler allows for that perfectly.  There is a great post on how to work with internal lists on the Office Dev Center.  You can access that here.

Manipulating SharePoint External Lists using REST

I decided that because I had done my previous posts using SharePoint on-prem that this time to show it doesn’t matter which environment you develop against, I am actually updating lists in my SharePoint Online tenant.

Just a quick disclaimer: You will notice that all of my Fiddler screenshots contain a cookie entry in the Request Header.  This is simply for accessing SharePoint Online via Fiddler.  It is not required for SharePoint on-premises.

For the purpose of this post I will be working with the following list:

Manipulating SharePoint External Lists using REST - External List

Note I have included the BDC Identity column.  For external lists, this is the item id.

 

Read Items

To read an item from the list we will use the endpoint: “_api/Web/Lists/getbytitle(‘<ListName>’)/GetItemByStringId(‘<item id>’)”  Special note: when using the BDC Identity, ensure it starts with a double underscore.

Manipulating SharePoint External Lists using REST - Read List Item

Manipulating SharePoint External Lists using REST - Read Item Response

Insert New Items

To insert data into an external list is actually exactly the same as it is for an internal list.  The endpoint: “_api/web/lists/getbytitle(‘SmallAsset’)/Items” is used here.  Having data in the Request Body (seen in the picture below) is what tells SharePoint to insert the data.

Manipulating SharePoint External Lists using REST - External List Insert

You can see that line 10 was added to the list:

Manipulating SharePoint External Lists using REST - External List After Insert

Update List Item

As discussed above, getting an item from an external list is a bit different.  With external lists you have to use GetByStringID instead of simply placing the item id after the indicating you are accessing items from a list in the REST call.  The call to the endpoint is similar to: “_api/Web/Lists/getbytitle(‘<List Title>’)/GetItemByStringId(‘<BDC Identity>’)“.  In the following I want to update AssetID#3 and set the location to Regina and the Details to “Updated with Rest”.

Manipulating SharePoint External Lists using REST - External List Item Update

You can see that the list item updated successfully.

Manipulating SharePoint External Lists using REST - External List After Update

Delete List Item

Deleting a list item is very similar to updating an existing item.  You simply need to change the http method to “DELETE” and remove the request body.  The call to the endpoint will be the same as the Update one in fact (“_api/Web/Lists/getbytitle(‘<List Title>’)/GetItemByStringId(‘<BDC Identity>’)“).  You can see in following screenshots that I deleted the entry that indicated it was added by Fiddler (AssetID: #9).

Manipulating SharePoint External Lists using REST - External List Delete Item

You can see the item is now removed

Manipulating SharePoint External Lists using REST - External List After Delete

That’s the basics of working with External Lists and REST APIs.  As you can see it’s really easy.  Each of the methods I illustrated today could be moved to on-prem SharePoint simply by changing the URL and nothing else.

 

Thanks for reading!!

Manipulating SharePoint External Lists using CSOM

This is the second part in my series on developing code to modify external lists.  In this post we will be updating SharePoint external lists using CSOM.  Like standard PowerShell there is not any real difference in the execution of the update between internal and external lists.  What is different is how the data is obtained when performing an update, read or deletion.  Like PowerShell, in CSOM you can find the item you wish to access using the ID.  However, because there isn’t a list ID field in an external list you have to query to find the item(s) you need.  You could loop through each item in the list until you find one with the particular attributes you are looking for, but that is not efficient and it may be difficult if the fields you are checking have multiple rows with the same values.  So brush up on your CAML query.

Using CSOM to Manage Data in Internal Lists

CSOM has come a long way since its inception in SharePoint 2010.  I would still be recommending it over REST except that unlike REST things are a bit different between on-prem and SharePoint Online CSOM versions (you need a different versions for each).  This post isn’t meant as a discussion on the pros and cons of REST vs CSOM though (You can get more information here if you are curious though).  CSOM is probably a little more complicated than the PowerShell examples I provided in my previous post, but one you get the hang of loading the data you need before working with it the process is pretty easy.

To show you what we are going to be doing here’s the list we will be starting off with:

Updating SharePoint External Lists using CSOM - Internal List Before Code

Using this config:

<Lists>
    <List ParentSiteURL="http://teams.drevsp2016.com/bcs/" ListName="DemoCode">
        <ListItems>
            <ListItem Action="Insert" ID="">
                <Fields>
                    <Field Title="Title" Value="CSOM Added Item"/>
                    <Field Title="Description" Value="This Field was created using PowerShell and CSOM"/>
                </Fields>
            </ListItem>
            <ListItem Action="Update" ID="5">
                <Fields>
                    <Field Title="Title" Value="BCS is the bees knees"/>
                    <Field Title="Description" Value="This Field was UPDATED using PowerShell and CSOM"/>
                </Fields>
            </ListItem>
            <ListItem Action="Update" ID="11">
                <Fields>
                    <Field Title="Title" Value="I did this with CSOM"/>
                    <Field Title="Description" Value="This Field was UPDATED using PowerShell and CSOM"/>
                </Fields>
            </ListItem>
            <ListItem Action="Read" ID="5">
                <Fields>
                    <Field Title="Title" Value=""/>
                    <Field Title="Description" Value=""/>
                </Fields>
            </ListItem>
            <ListItem Action="Delete" ID="1">
                <Fields>
                    <Field Title="" Value=""/>
                    <Field Title="" Value=""/>
                </Fields>
            </ListItem>
        </ListItems>
    </List>
</Lists>

we will update the list with the following code:

foreach($xmlList in $testInternalList.Config.Lists.List)
{
    $ctx = New-Object Microsoft.SharePoint.Client.ClientContext($xmlList.ParentSiteURL)
    $spLists = $ctx.web.Lists;
    $spList = $spLists.GetByTitle($xmlList.ListName);

    foreach($xmlItem in $xmlList.ListItems.ListItem)
    {
        switch($xmlItem.Action)
        {
            "Insert"
            {
                $spListItemInfo =  New-Object Microsoft.SharePoint.Client.ListItemCreationInformation;
                $newListItem = $spList.AddItem($spListItemInfo);
                
                foreach($xmlField in $xmlItem.Fields.Field)
                {
                    $newListItem[$xmlField.Title] = $xmlField.Value;
                }

                #Update the new list item
                $newListItem.Update();

                #execute the query
                $ctx.load($spList);      
                $ctx.executeQuery();

                break;
            }

            "Update"
            {
                $updateListItem = $spList.GetItemByID($xmlItem.ID);

                foreach($xmlField in $xmlItem.Fields.Field)
                {
                    $updateListItem[$xmlField.Title] = $xmlField.Value;
                }

                #Update the new list item
                $updateListItem.Update();

                #execute the query
                $ctx.load($updateListItem);      
                $ctx.executeQuery();

                break;
            }

            "Read"
            {
                $readListItem =  $spList.GetItemByID($xmlItem.ID);

                #execute the query
                $ctx.load($readListItem);      
                $ctx.executeQuery();

                foreach($xmlField in $xmlItem.Fields.Field)
                {
                    write-host("The Value of field '{0}' is '{1}'" -f $xmlField.Title, $readListItem[$xmlField.Title]) -ForegroundColor Cyan;
                }
                
                break;
            }
            "Delete"
            {
                $deleteListItem =  $spList.GetItemByID($xmlItem.ID);
                $deleteListItem.DeleteObject();

                #execute the query      
                $ctx.executeQuery();

                Write-Host("Successfully deleted item #{0}" -f $xmlItem.ID) -ForegroundColor Magenta;
                
                break;
            }
        }
    }
}

Running the code:

Updating SharePoint External Lists using CSOM - Internal List Running Code

The list gets updated as expected:

Updating SharePoint External Lists using CSOM - Internal List After Code

 

Using CSOM to Update External Lists

As I stated above, the code is very similar to internal lists except there you need to use CAML Query to access the items.  Note with CSOM you don’t have to define the ServiceContext scope.

The list:

Updating SharePoint External Lists using CSOM - External List Before Code

Will get modified based on this config:

<Lists>
    <List ParentSiteURL="http://teams.drevsp2016.com/bcs/" ParentSiteColURL="http://teams.drevsp2016.com" ListName="SmallAsset">
        <ListItems>
            <ListItem Action="Insert" AssetID="">
                <Fields>
                    <Field Title="Type" Value="Tablet"/>
                    <Field Title="Make" Value="Microsoft"/>
                    <Field Title="Model" Value="Surface Pro 4"/>                        
                    <Field Title="Details" Value="This Item Added using PowerShell and CSOM"/>
                </Fields>
            </ListItem>
            <ListItem Action="Update" AssetID="30">
                <Fields>
                    <Field Title="Location" Value="Denver"/>
                    <Field Title="Details" Value="This Field was UPDATED using PowerShell and CSOM"/>
                </Fields>
            </ListItem>
            <ListItem Action="Update" AssetID="29">
                <Fields>
                    <Field Title="Type" Value="Monitor"/>
                    <Field Title="Make" Value="Samsung"/>
                    <Field Title="Model" Value="30inch"/>
                    <Field Title="Details" Value="This Field was UPDATED using PowerShell and CSOM"/>
                </Fields>
            </ListItem>
            <ListItem Action="Read" AssetID="9">
                <Fields>
                    <Field Title="Type" Value=""/>
                    <Field Title="Make" Value=""/>
                    <Field Title="Model" Value=""/>
                    <Field Title="Details" Value=""/>
                </Fields>
            </ListItem>
            <ListItem Action="Delete" AssetID="32">
                <Fields>
                    <Field Title="" Value=""/>
                    <Field Title="" Value=""/>
                </Fields>
            </ListItem>
        </ListItems>
    </List>
</Lists>

Reviewing the code, note the insertion of the CAML Query to find a specific item.  One important thing to note with the CAML query.  You have to use the name of the function used to define the Read-List process in the External Content Type

foreach($xmlList in $testExternalList.Config.Lists.List)
{
    $ctx = New-Object Microsoft.SharePoint.Client.ClientContext($xmlList.ParentSiteURL)
    $spLists = $ctx.web.Lists;
    $spList = $spLists.GetByTitle($xmlList.ListName);

    foreach($xmlItem in $xmlList.ListItems.ListItem)
    {
        switch($xmlItem.Action)
        {
            "Insert"
            {
                $spListItemInfo =  New-Object Microsoft.SharePoint.Client.ListItemCreationInformation;
                $newListItem = $spList.AddItem($spListItemInfo);
                
                foreach($xmlField in $xmlItem.Fields.Field)
                {
                    $newListItem[$xmlField.Title] = $xmlField.Value;
                }

                #Update the new list item
                $newListItem.Update();

                #execute the query
                $ctx.load($spList);      
                $ctx.executeQuery();

                break;
            }

            "Update"
            {
                $camlText = ("<View><Method Name='Read List'/><Query><Where><Eq><FieldRef Name='AssetID' /><Value Type='Number'>{0}</Value></Eq></Where></Query></View>" -f [int]$xmlItem.AssetID);
                $spQuery = New-Object Microsoft.SharePoint.Client.CamlQuery;
                $spQuery.ViewXml = $camlText;

                $updateItemList = $spList.GetItems($spQuery);

                $ctx.Load($updateItemList)
                $ctx.ExecuteQuery()

                foreach($updateListItem in $updateItemList)
                {
                    foreach($xmlField in $xmlItem.Fields.Field)
                    {
                        $updateListItem[$xmlField.Title] = $xmlField.Value;
                    }

                    #Update the new list item
                    $updateListItem.Update();

                    #execute the query
                    $ctx.load($updateListItem);      
                    $ctx.executeQuery();
                }
                break;
            }

            "Read"
            {
                $camlText = ("<View><Method Name='Read List'/><Query><Where><Eq><FieldRef Name='AssetID' /><Value Type='Number'>{0}</Value></Eq></Where></Query><ViewFields><FieldRef Name='Type' /><FieldRef Name='Make' /><FieldRef Name='Model' /><FieldRef Name='Details' /></ViewFields></View>" -f [int]$xmlItem.AssetID);
                $spQuery = New-Object Microsoft.SharePoint.Client.CamlQuery;
                $spQuery.ViewXml = $camlText;

                $readItemList = $spList.GetItems($spQuery);

                $ctx.Load($readItemList)
                $ctx.ExecuteQuery()
                
                foreach($readListItem in $readItemList)
                {
                    foreach($xmlField in $xmlItem.Fields.Field)
                    {
                        write-host("The Value of field '{0}' is '{1}'" -f $xmlField.Title, $readListItem[$xmlField.Title]) -ForegroundColor Cyan;
                    }
                }
                break;
            }
            "Delete"
            {
                $camlText = ("<View><Method Name='Read List'/><Query><Where><Eq><FieldRef Name='AssetID' /><Value Type='Number'>{0}</Value></Eq></Where></Query></View>" -f [int]$xmlItem.AssetID);
                $spQuery = New-Object Microsoft.SharePoint.Client.CamlQuery;
                $spQuery.ViewXml = $camlText;

                $delItemList = $spList.GetItems($spQuery);

                $ctx.Load($delItemList)
                $ctx.ExecuteQuery()
                
                $deleteListItem = $delItemList[0];  
                #$deleteListItem =  $spList.GetItemByID($xmlItem.ID);
                $deleteListItem.DeleteObject();

                #execute the query      
                $ctx.executeQuery();

                Write-Host("Successfully deleted item #{0}" -f $xmlItem.AssetID) -ForegroundColor Magenta;
                
                break;
            }
        }
    }
}

Running the code:

Updating SharePoint External Lists using CSOM - External List Running Code

Leaves us with the following updated list:

Updating SharePoint External Lists using CSOM - External List After Code

So again, other than gathering the item to update, managing items in an external list is very similar to managing items in an internal list.  My next post we will cover the differences in manipulating internal and external items with REST.

Thanks for reading!!

Using PowerShell to Access Data In External Lists

I created my  blog series on SharePoint BCS quite some time ago in order to illustrate how easy it is to access data outside of SharePoint and present it within a list or document library.  I have been meaning for quite some time to demonstrate how writing code for external lists\libraries is very similar to writing code for internal lists\libraries.  Today I am going to start a new three part series on SharePoint BCS development by showing you how you can enhance your solutions using PowerShell to access data in external lists.  The posts aren’t going to be too in-depth, but meant to get you started.  I hope to build on them later and post a series on creating an entire solution around BCS.

Using PowerShell to Manage Data in Internal Lists

With SharePoint PowerShell you are basically using the server object model for development.  So this means you have access to the methods and processes utilised by this system.  What you’ll notice is that code to perform inserts, updates, reads and deletions is pretty much exactly the same.  Where the code differs between internal and external is actually around accessing the item to be updated, read or deleted.

To illustrate I have created a script that performs an insert, update, read and delete.  To show you what’s happening here’s the config for the code:

 

<List ParentSiteURL="http://teams.drevsp2016.com/bcs/" ListName="DemoCode">
    <ListItems>
        <ListItem Action="Insert" ID="">
            <Fields>
                <Field Title="Title" Value="New Item"/>
                <Field Title="Description" Value="This Field was created using PowerShell and SOM"/>
            </Fields>
        </ListItem>
        <ListItem Action="Update" ID="1">
            <Fields>
                <Field Title="Title" Value="BCS is Really Awesome"/>
                <Field Title="Description" Value="This Field was UPDATED using PowerShell and SOM"/>
            </Fields>
        </ListItem>
        <ListItem Action="Update" ID="3">
            <Fields>
                <Field Title="Title" Value="Dave is a great speaker and should get a great review"/>
                <Field Title="Description" Value="This Field was UPDATED using PowerShell and SOM"/>
            </Fields>
        </ListItem>
        <ListItem Action="Read" ID="4">
            <Fields>
                <Field Title="Title" Value=""/>
                <Field Title="Description" Value=""/>
            </Fields>
        </ListItem>
        <ListItem Action="Delete" ID="2">
            <Fields>
                <Field Title="" Value=""/>
                <Field Title="" Value=""/>
            </Fields>
        </ListItem>
    </ListItems>
</List>

As you can see the code should insert a new item, update two, read a third and finally delete.  The code is pretty straight forward:

foreach($xmlItem in $xmlList.ListItems.ListItem)
{
    switch($xmlItem.Action)
    {
        "Insert"
        {
            $newListItem = $spList.AddItem();
            
            foreach($xmlField in $xmlItem.Fields.Field)
            {
                $newListItem[$xmlField.Title] = $xmlField.Value;
            }

            #Update the new list item
            $newListItem.Update();

            break;
        }

        "Update"
        {
            $updateListItem = $spList.GetItemByID($xmlItem.ID);

            foreach($xmlField in $xmlItem.Fields.Field)
            {
                $updateListItem[$xmlField.Title] = $xmlField.Value;
            }

            #Update the new list item
            $updateListItem.Update();

            break;
        }

        "Read"
        {
            $readListItem =  $spList.GetItemByID($xmlItem.ID);

            foreach($xmlField in $xmlItem.Fields.Field)
            {
                write-host("The Value of field '{0}' is '{1}'" -f $xmlField.Title, $readListItem[$xmlField.Title]) -ForegroundColor Cyan;
            }
            
            break;
        }
        "Delete"
        {
            $deleteListItem =  $spList.GetItemByID($xmlItem.ID);

            $deleteListItem.Delete();

            Write-Host("Successfully deleted item #{0}" -f $xmlItem.ID) -ForegroundColor Magenta;
            
            break;
        }
    }
}

Using the following list:

Using PowerShell to Access Data In External Lists - Internal List Before Code

And running the above script:

Using PowerShell to Access Data In External Lists - InternalListRunningCode

We end up with the result:

Using PowerShell to Access Data In External Lists - Internal List After Code

 

Using PowerShell to Update External Lists

The code is almost identical.  What actually changes is the code used for finding the items we want to update.  We also have to define the ServiceContext scope to process the transactions.  External list manipulation requires the scope to import the data catalogue (more information can be found here).  First the config to see what the plan is:

<Lists>
    <List ParentSiteURL="http://teams.drevsp2016.com/bcs/" ParentSiteColURL="http://teams.drevsp2016.com" ListName="Asset List">
        <ListItems>
            <ListItem Action="Insert" AssetID="">
                <Fields>
                    <Field Title="Type" Value="Printer"/>
                    <Field Title="Make" Value="Brother"/>
                    <Field Title="Model" Value="MJD-2500"/>                        
                    <Field Title="Details" Value="This Item Added Via PowerShell"/>
                </Fields>
            </ListItem>
            <ListItem Action="Update" AssetID="1">
                <Fields>
                    <Field Title="Location" Value="Denver"/>
                    <Field Title="Details" Value="This Field was UPDATED using PowerShell and SOM"/>
                </Fields>
            </ListItem>
            <ListItem Action="Update" AssetID="9">
                <Fields>
                    <Field Title="Type" Value="Monitor"/>
                    <Field Title="Make" Value="Samsung"/>
                    <Field Title="Model" Value="30inch"/>
                    <Field Title="Details" Value="This Field was UPDATED using PowerShell and SOM"/>
                </Fields>
            </ListItem>
            <ListItem Action="Read" AssetID="9">
                <Fields>
                    <Field Title="Type" Value=""/>
                    <Field Title="Make" Value=""/>
                    <Field Title="Model" Value=""/>
                    <Field Title="Details" Value=""/>
                </Fields>
            </ListItem>
            <ListItem Action="Delete" AssetID="22">
                <Fields>
                    <Field Title="" Value=""/>
                    <Field Title="" Value=""/>
                </Fields>
            </ListItem>
        </ListItems>
    </List>
</Lists>

Then using the code:

foreach($xmlList in $testExternalList.Config.Lists.List)
{
    #Define the SPServiceContextScope to access the Data Catalog
    $ctx = get-SPServiceContext $xmlList.ParentSiteColURL;
    $scope = new-object Microsoft.SharePoint.SPServiceContextScope $ctx

    $spWeb = Get-SPWeb $xmlList.ParentSiteURL;
    $spList = $spWeb.Lists[$xmlList.ListName];

    foreach($xmlItem in $xmlList.ListItems.ListItem)
    {
        switch($xmlItem.Action)
        {
            "Insert"
            {
                $newListItem = $spList.Items.Add();
                
                foreach($xmlField in $xmlItem.Fields.Field)
                {
                    $newListItem[$xmlField.Title] = $xmlField.Value;
                }

                #Update the new list item
                $newListItem.Update();
                
                Write-Host "Successfully inserted new item" -ForegroundColor Cyan;

                break;
            }

            "Update"
            {
                $updAssetID = [int]$xmlItem.AssetID;

                #Use PowerShell query to find the item to update
                $updateListItem = $spList.Items | Where-Object {$_["AssetID"] -eq $updAssetID};

                foreach($xmlField in $xmlItem.Fields.Field)
                {
                    $updateListItem[$xmlField.Title] = $xmlField.Value;
                }

                #Update the new list item
                $updateListItem.Update();

                Write-Host ("Updated AssetID: {0}" -f $updAssetID) -ForegroundColor Green;
                
                break;
            }

            "Read"
            {
                $readAssetID = [int]$xmlItem.AssetID;

                #Use PowerShell query to find the item to update
                $readListItem =  $spList.Items | Where-Object {$_["AssetID"] -eq $readAssetID};

                foreach($xmlField in $xmlItem.Fields.Field)
                {
                    write-host("The Value of field '{0}' is '{1}'" -f $xmlField.Title, $readListItem[$xmlField.Title]) -ForegroundColor Cyan;
                }
                
                break;
            }
            "Delete"
            {
                $delAssetID = [int]$xmlItem.AssetID;

                #Use PowerShell query to find the item to update
                $deleteListItem =  $spList.Items | Where-Object {$_["AssetID"] -eq $delAssetID};

                $deleteListItem.Delete();

                Write-Host("Successfully deleted item #{0}" -f $delAssetID) -ForegroundColor Magenta;
                
                break;
            }
        }
    }
}

Notice in the code above that we are using a pipe to gather the data.  One thing to note with External Lists is they do not have a numerical ID field.  However, in this case we are grabbing the ID field of the Asset so we can search on the AssetID of the item.

We then update the following list:

Using PowerShell to Access Data In External Lists - External List Before Code

by running the code:

Using PowerShell to Access Data In External Lists - External List Running Code

And receive the following updated list:

Using PowerShell to Access Data In External Lists - External List After Code

 

That’s the basics of updating an External List with PowerShell.  In the next post I will cover updating using CSOM.

 

Thanks for Reading!