Enhancing the GoToWebinar Connection from Thrive Themes

I am in the process of moving all of my websites over to Thrive Themes (which I really love, by the way).

A Bit of Background

As you have probably noticed, I host a lot of webinars so having good integration between my web site and GoToWebinar was essential.  Luckily, Thrive Themes ships with a connector for GoToWebinar which allows you to use a Thrive Theme component to collect webinar registration information which will be passed to GoToWebinar to register an individual for a webinar, without them having to visit a GoToWebinar registration page.

This is great on several levels, the most important of which is the fact that a visitor does not need to leave your site.

You can learn more about how to connect Thrive Themes and GoToWebinar here.


The problem is that the Thrive Theme connector only asks for the information required by GoToWebinar, which is currently just the person’s name and email address.


While this is fine for most cases, I typically request more demographic data such as their location.

Unfortunately, the API is not configurable so you are kind of stuck with just those fields.

Note: The name is assumed to be the person’s full name. GoToWebinar will parse the name into what it feels are first name and last name when the person is registered.

The Solution

The solution is to use an HTML Form connector instead of the API. This requires a bit of work up front, but after you have it working, it is fairly easy to maintain and modify.

Let’s walk through the process.

Step 1: Create Your Webinar

So create your webinar like you normally do. Here is a test webinar that I created:


I have also added the demographic questions to the registration:


Since I work with people all over the planet, this keeps me informed of where my people are located.  It also helps to cut down on webinar SPAM – and yes, there is such a thing.

Step 2: Capture the Registration Form HTML

In order to use the HTML connector with Thrive Themes, we have to extract the Form HTML from the registration page.  Click on the registration link found within the webinar management page:


Which will display the registration page for this webinar:


Viewing the Page Source Code

We need to view the raw HTML that makes up the page so right-click anywhere on the page to display the pop-up menu.

Internet Explorer

Here is the IE pop-up menu. Select the View Source.




Here is the Chrome pop-up menu. Select View page source.


Extracting the HTML Form

Within the HTML we need to locate and extract the form tag so search for:


Copy everything from the beginning <, through the ending > of:


Paste it into a text editor of some type.  I am using Notepad++ in this example and it looks something like this:


Editing the Form HTML

We have to make a few small edits to the HTML code.

First, we need to make the URL that the form posts to a fully-qualified path.  Find this line:

<form id="registrationForm" action="/registration.tmpl" method="POST" role="form">

and make it look like this:

<form id="registrationForm" action="https://attendee.gotowebinar.com/registration.tmpl" method="POST" role="form">

All I did was to copy the beginning of the URL from the registration page and added it to beginning of the action path.

Finding the Webinar ID

The most important piece of information in this file is the webinar ID, which looks like this:

<input type="hidden" id="webinar" name="webinar" value="12345678901234567890" />

This value is unique to the webinar and must be edited each time you create a new webinar. If you always ask for the same set of information, you may save this segment of Form HTML and use it again and again, only changing the value property of the webinar field to reflect the new webinar ID.

Step 3: Modifying the Thrive Lightbox

Now that we have our HTML code, we need to modify the lightbox and connect it to GoToWebinar using an HTML form connection. Follow these steps:

1. Open the Thrive Lightbox in the editor


2. Click on the button (Reserve My Seat, in this case) to display the Lead Generation options.

3. Click on the Connect to Service button.


4. When the Connect to Service dialog is displayed, click Create a new Connection


5. Select HTML Form code, then click the Go to next step button.


6. Paste the Form HTML you have in your text editor into the text box that says Insert your code here


7. Click the Generate Fields button and you will see something resembling the following:


8. Set the properties of the various fields, as shown below:


9. Click the Save button to save your work and you will be returned to the Thrive Themes editor.

The end product should look something like this:


Note: You may need to modify the light box to handle the new fields, depending on the layout of the control.

10. Save your changes.

Step 4: Testing

To test your modifications, click on the Preview button and it should preview your lightbox.

Enter the information into the fields below, then click the Reserve My Seat button.


Assuming all is correct, you should see a GoToWebinar confirmation page:



Next Steps

As I mentioned, you can reuse this code as long as you don’t change the fields. The most important item is to always replace the Webinar ID number we discussed earlier.

When you make any modifications to the HTML, you must always click the Generate Fields button to make sure it will be using the latest HTML code. Failure to do so will result in your changes being ignored. In most cases, the Generate Fields operation does not cause you to loose your previous configuration if you have not changed the fields.



This technique has totally changed the way I conduct webinar registrations and I hope you find it valuable as well.

Please let me know if my instructions were not clear and I will edit as necessary.

Thanks, Mitch

Now Available: Fun with fields, a Dynamics CRM Customization Training Guide

Happy Friday Everyone,

I have just released a new training guide for those of you interested in growing your Microsoft Dynamics CRM knowledge.

The purpose is to walk you through the creation of every type of data entry field, format, and behavior available within the Dynamics CRM system.

It was written against Dynamics CRM 2016, so some of the newer features will not be available within earlier versions, but much of the basics will.

Check it out here.

Have a great weekend.


Dynamics CRM SDK 8.0.2 is available

The SDK for Dynamics CRM 2016 has been updated. You may download it here.

Release history for SDK Version 8.0.2, February 2016


Updated the assemblies for Microsoft Dynamics CRM Online 2016 Update and Microsoft Dynamics CRM 2016 (on-premises).

Create early bound entity classes with the code generation tool (CrmSvcUtil.exe)

Added two new command line parameters: /interactivelogin, and /connectionstring.

Added support for multi factor authentication when using either the command line or interactive logon.

Trace logging configuration is now provided in the default CrmSvcUtil.exe.config file. There is now more granular control of the logged data.

Microsoft Dynamics CRM Web API Limitations

Updated the topic to include information about limitations removed after update rollup 1 is applied. Added the Limitations addressed in Microsoft Dynamics CRM 2016 Update 1.1 section to call out the changes. Some of the limitations in the initial release remain.

Query Data using the Web API

Updated the Retrieve a count of entities section to show that the count value is limited by the maximum number of entities that can be returned by a query, which is 5000.

Retrieve and execute predefined queries

In the Use custom FetchXML section, there is a new Paging with FetchXML sub-section that describes how to apply paging when using fetchXML queries with the Web API.

Sample: Simplified connection quick start using Microsoft Dynamics CRM

Updated the sample to use the CrmServiceClient Class instead of the CrmConnection Class.

Web API ComplexType Reference

The following complex types were added with update rollup 1:

  • CheckIncomingEmailResponse ComplexType
  • ComplexAttributeMetadata ComplexType
  • ComplexEntityKeyMetadata ComplexType
  • ComplexEntityMetadata ComplexType
  • ComplexManyToManyRelationshipMetadata ComplexType
  • ComplexOneToManyRelationshipMetadata ComplexType
  • FindParentResourceGroupResponse ComplexType
  • GetQuantityDecimalResponse ComplexType
  • IsValidStateTransitionResponse ComplexType
  • QueryMultipleSchedulesResponse ComplexType
  • RetrieveAllEntitiesResponse ComplexType
  • RetrieveLocLabelsResponse ComplexType
  • RetrievePrincipalAccessResponse ComplexType
  • TimeInfoCollection ComplexType
  • ValidateRecurrenceRuleResponse ComplexType

Web API EnumType Reference

The following enum types were added with update rollup 1:

  • AccessRights EnumType
  • EntityFilters EnumType
  • TargetFieldType EnumType

Web API Function Reference

The following functions were added with update rollup 1:

  • CheckIncomingEmail Function
  • FindParentResourceGroup Function
  • GetQuantityDecimal Function
  • IncrementKnowledgeArticleViewCount Function
  • InitializeFrom Function
  • IsValidStateTransition Function
  • QueryMultipleSchedules Function
  • RetrieveAllEntities Function
  • RetrieveDuplicates Function
  • RetrieveLocLabels Function
  • RetrievePrincipalAccess Function
  • RetrieveRecordWall Function
  • RetrieveUnpublishedMultiple Function
  • SearchByBodyKbArticle Function
  • SearchByKeywordsKbArticle Function
  • SearchByTitleKbArticle Function
  • ValidateRecurrenceRule Function

SnagIt Cut Out Options

I use Techsmith’s SnagIt utility every day for just about everything: blog posts, documentation, troubleshooting, etc.

One of the features I use a lot is Cut Out tool, which allows you to remove a horizontal or vertical slice of an image.  There are six different options available, so I thought I’d try each to see what I liked the best.


I’ll show the horizontal version since the vertical will be exactly the same.

Original Image

Here is the original image that I started with. For the purposes of the documentation I was creating, I do not need the fields from the bottom of the Name edit box to the top of the Type label.

Field - Email Address 1 -G

Totally Remove

This option will actually remove a section of an image. This is the one I typically use.

Field - Email Address 1 - A


This removes a section then fades out and back in after presenting a gap.

Field - Email Address 1 - B


This simulates the manual tearing of a piece of paper.

Field - Email Address 1 -CB


This adds a jagged edge between the cut-out areas.

Field - Email Address 1 -D


This adds a wave effect.

Field - Email Address 1 -E

Saw Tooth

This adds an edge much like the teeth on a woodworking hand saw.

Field - Email Address 1 -F



After experimenting with all six styles, I think I’ll stick with the simple Remove option. I found the others to be too distracting.

Click here to download a PDF showing the options in a document setting.

Unexpected interaction between a Plugin and the Dynamics CRM Social Pane

One of my customers has customized the Appointment and added Appointment Type and a Competitor fields to allow them to perform analytics on the interactions with their customers.

One of the a business requirements that a competitor must be specified when a specific set of Appointment Types are selected.

If the user attempts to complete the Appointment without selecting a competitor, a message is displayed asking them to do so.

This works fine when the Appointment is open, but we found instances where people were using the Complete button on the Social Pane to complete the appointment:


Since the Appointment form is not actually opened, the JavaScript that performs the checks is not executed.

That means that in this instance, I have to fall back to using a plugin.  That worked great, except for the fact that the error message I display is not what actually shows up to the user. They see this instead:


Technically, the goal was for them to not be able to complete the Appointment without a Competitor being specified when the Appointment Type was set to a specific set of values.

The plugin does its job and prevents the user from completing the Appointment, but in this case, they have no idea why.

This can be solved with training, but it would be nice if the error message thrown by the plugin was shown to the user.

V4.3 of SnapShot! for Dynamics CRM is available


Version 4.3 of SnapShot! for Dynamics CRM is available and you may read more about it here:


Most of the work on this version is internal to the application and includes:

  • Upgraded to the .NET Framework 4.5.2. This may require this framework be installed on your computer, if it is not already installed.
  • Updated to use the Dynamics CRM 2015 SDK assemblies

There were a few minor bug fixes related to Dynamics CRM 2011. These were mostly around a difference of implementation between CRM 2011 and the later versions.

A check is now performed to verify that the user running SnapShot! is a Dynamics CRM System Administrator. If not, a warning will be displayed. In most cases, SnapShot! cannot full retrieve information from CRM without the proper security privileges.

A trip down .NET Application upgrade lane

All of my Dynamics CRM-related utilities have, until this point, been built and maintained with Visual Studio 2010, which is really not a personal choice, but of of practicality.

Most of the reasoning behind this decision is led by some technology changes introduced in later versions of Visual Studio (2013 mostly) as well as some problems with some third-party components that I use for the user interface.

This past weekend I was able to successfully upgrade my SnapShot! application to use Visual Studio 2013 (I could have gone to 2015 but chose not too).

Here are the changes that I had to make:

Installer Technology

I do not have any complicated installer scenarios but really and truly just need files copied to the computer, folders created, and items added to the Start menu. The built-in Setup project that shipped with Visual Studio 2010 is more than sufficient to meet my needs.

Then Microsoft discontinued that project type so I lost my application installer.  Their alternative is to use InstallShield Limited Edition (ISLE). While this works, I once spent about 3 hours and 4-5 iterations trying to get all of the missing components installed.  Not wanting to repeat this process, I just stayed on Visual Studio 2010.  You can call me lazy, but it was just not worth the investment of time and energy.

Then Microsoft shipped a new installer project type as a Visual Studio extension. Both VS 2013 and 2015 are supported:

Microsoft Visual Studio 2015 Installer Projects
Microsoft Visual Studio 2013 Installer Projects

Exit Visual Studio, install one of these extensions, restart Visual Studio and load your solution and it is like your upgrade to VS2013/15 never happened.  Everything just works.

Yay Visual Studio Team!

Third-Party Components

Many years ago I purchased a most excellent component library for Windows Forms applications. It was really great to work with but unfortunately is no longer being supported. My previous attempts in migrating one of my applications to Visual Studio 2013 caused a wide variety of unexpected issues so I again delayed the move. Mostly because I could not modify the user interface visually.

After digging around a little I found an article on StackOverflow that showed how to manually add the components to the Visual Studio toolbox. I followed those instructions, reopened my SnapShot! solution, and everything seemed to work just fine.

Dynamics CRM SDK

Since I have to communicate with Dynamics CRM 2011, 2013, 2015, and 2016, all from a single application, I had settled on using the CRM 2013 SDK DLLs to provide connectivity to the different versions of CRM. It was a happy medium that allowed me to access almost all functionality points of Dynamics CRM, regardless of version.

The 2013 DLLs were also .NET 4.0, which was the highest level of .NET that I could use with Visual Studio 2013.

Then I started running into issues where I need to use or access features and functionality from Dynamics CRM 2015+ which means I have to be using the 2015 DLLs, which are .NET 4.5.2.

Once I upgraded to VS 2013, I had access to .NET 4.5.2 and was able to convert all of my projects to the newer .NET, replace the CRM 2013 DLLs with CRM 2015 DLLs, and everything worked as it did within Visual Studio 2010.

Note: I did not move to the CRM 2016 DLLs due to an architecture change where functionality was moved and I have seen reports regarding the replacement technology that I didn’t wish to encounter.


Overall, it only took me a couple of hours to get the kinks worked out and I was really pleased that everything worked the way it did.

Now I can get back to adding more features and functionality.

A journey of a thousand miles starts with a single step–and a Blog Post

Hi Everyone,

I started this blog in December of 2005. Ten years and 1,069 blog posts later, I thought it would be a good time to reflect on the last ten years within the Microsoft Dynamics CRM community.

Here is my very first post, which was a method for hiding a tab within Dynamics CRM 3.0.  I actually had to open a support case to get this information and since I had invested $125 in the process, I decided to share that solution with the world in hopes of saving at least a few people that same $125.

Over the next year I went on to publish an additional 219 posts of varying technical depth.  As I discussed in my article, Why do you not blog, writing articles on my discoveries was a way to pay it forward, to the people from whom I had learned much.

That path lead me to this:

Microsoft MVP Award


Last Friday my ten-year disk was delivered. It marks a totally unexpected milestone in my career.

To think that I have been part of a world-wide family of Dynamics CRM professionals for this long is very humbling. When I told my wife Jenny that my ten-year disk had arrived she said she remember when I got my five-year disk like it was yesterday.

A lot has changed in ten years. My first MVP Summit had us all sitting around a table in one of Microsoft’s smaller conference rooms. Today we occupy Microsoft’s largest meeting rooms. While the numbers have changed, the discussions and camaraderie have not.  It’s still a great honor to be associated with so many fine individuals.

The future of Dynamics CRM is extremely bright and if anything, the speed of development has increased. With that increase comes new features, challenges, and opportunities.  All of which will make for great topics of conversation, blog posts, and videos.  So stay tuned to not only this blog, but many of the others in our community.

And while you are at it, write your own blog!

Thank you for your support over the past ten years and as always, please let me know what I can do to help.`

Thanks, Mitch

What exactly is a minimum viable product (MVP)?

Earlier this month I gave a talk to several groups of 8th graders at a middle school where a friend of mine teaches.  I talked to them about what it was like to be a software developer, what I did, what my day was like, and what they would need to do if they chose such a path.

Beside just rambling on about the processes of learning and practice, I also showed them a Xamarin Forms application called About Time that I had written quite a while ago that is a quirky kind of clock.  I showed them a bit of the code the deployed and ran it on my iPad – which was about the coolest thing I could think of related to some of the normal development that I do which most 8th-graders would not be too enthused about.  But creating an app that you could put on your iPad, that was something else.

The app was just a learning experience for me when I was learning Xamarin Forms and while I have considered it many times, I have not spent any actual time to finish it up to publish the Apple App Store.

A couple of days ago I get a package in the mail that contained a stack of thank you cards from the school and from the students themselves. Most were of the “thanks for coming and talking to us” variety but a few were very appreciative and inventive in what they had to say and you could tell they actually took the time to write what they thought.

One young lady named Alexis, had this to say:

I really think you should make that software into an app. The only advice is if you could change the background so it could be personal to users.

Does she look like a future product manager or what?

So Alexis, let’s discuss the application development process and what it actually means to ship an application that people will either purchase or use.

Minimum Viable Product (MVP)

A minimum viable product, is exactly that: It is a version of your product that contains the minimum amount of functionality required to perform its job.

The purpose of an MVP is to get it into the hands of the users.

Why is this so important? Back in the late 1800’s, a Prussian army general named Helmuth von Moltke the Elder coined phrase (paraphrased):

No plan survives contact with the enemy.

My updated version of this is:

No plan survives contact with reality.

The basic concept is that we as software developers do not often know what our user want.  In fact, in most cases, the users themselves do not know what they want.  So what do we do?  We guess.  We may shroud this in market research, focus groups, one-on-one’s, etc., but in reality, until people see a thing, it’s really just conjecture.

Don’t believe me, listen to these guys:



So, the idea is that you create a product, get it into the hands of users, the take their feedback to improve the product.

So you want me to ship crap?

Nope. That is not what I said. Your product needs to be professional, functional, and perform the basic tasks for which it was designed.  But, it does not need to have a million bells and whistles that people may or may not use or need.

Consider this:


Pretty scary to think about, but unfortunately it contains a lot of truth.

Why is this important?

It all comes back to time and money. It serves no useful purpose to spend months and thousands of dollars adding features that you are not sure people will need or want.  Stick with the basics then iterate from there. It costs less to add a feature than it does to change a feature once implemented.

It is also important to note that this practice is valuable no matter of this is a paid application or a free application. Time is still money and they don’t make any more than they used to.

I have personally spent months developing software that people did not buy and let me tell you, the thought of the sunk cost of that effort makes me queasy every time I think about it.

So let’s get back to the application that I demonstrated to the kids as an example of an MVP, the possible update process, and how things can work.

About Time, now and future

The idea for About Time came from a watch that I read about ten years ago. I thought it was a pretty cool idea but later research seems to indicate that the watch never made it out of the prototype phase.

My version is slightly different, but it uses the same concept of telling time using phrases that many people commonly use when telling someone the time of day.

Here are some screen shots showing About Time in action:


At around 5:35am.


6:10am or so.

Here is the path that About Time could take:

About Time v1.0

Version 1.0 is my MVP and really needs to have just the basic functionality:

  • Display the time
  • Change the background image to reflect the time of day
  • Update the time should the application be running on the screen so we always have the current time

At this point, it does everything that it is designed to do so I can bundle it up and ship it to the app store. My main decision point now is the price. Here are my options:

  • Give it away
  • Charge $.99

Remember that on the Apple App Store, once a user purchases your application, they get future updates for free. The only way to charge for an update is to create a new application. So once you have their $.99 (minus the Apple commission), you have made all of the money that you can make off of the sale to that customer, unless you create a new app. (we’ll discuss other monetary options in a minute.)

About Time v1.1

Assuming people are using the application and that you have received good feedback and ratings, consider moving the the Android and Windows Phone market places. Since the code was written in Xamarin Forms, it is already cross-platform and just needs to be published to those markets.

About Time v1.2

The phrases are hard-coded into the application so let’s make them configurable by the user. Let’s also ship some pre-defined phrases from other countries.

About Time v1.3

The times that the app uses to determine when to switch background images is hard-coded. Let’s add a call to an Internet web service that will get the location of the device to determine the proper boundaries for sunrise, sunset, day, and night.

About Time v1.4

Apple Watch edition. Assuming by this time that Apple actually allows us to create applications that can show you the time of day.

About Time v1.5

At this point we need to discuss and discover if we need to add an alarm clock feature. If so, then do it now.  How do we know if we need an alarm feature? We ask our users to see if that would be something they would find useful.

About Time v2.0

In this version, we add the following features available as in-app purchases:

  • The ability to add custom background images
  • Synchronizing configuration data (phrases, images, etc.) with a cloud-based database so that About Time running on any of the user’s devices will always have the same configuration.

This will be the final version of About Time, baring any maintenance updates.

So what is the point of the multiple versions?

Well, there are several things to consider:

1. Regular updates will increase your visibility within the App Store.

2. You have a methodology that allows for a constant feedback loop with your customers.

3. You don’t have to worry about spending time on unused features should the feedback not be favorable. You can halt development at any point in this product plan, should you choose.

#3 is the most important point, so let me give you an example of why:

In v2.0 we are going to allow the users to select a background photo of their own.  While this seems like a trivial exercise, here are the actual steps required:

  1. Selection of the photo for each of the four times of day
  2. Storage of the photos
  3. Photo analysis. In order to have a text color that allows the time-phrase to be shown, we have to sample to photo to determine what the main color is so that we can properly adjust the phrase to be either black or white.

Again, not rocket-science steps here, but things that must be considered and which will take time to do properly.

In Conclusion

So to wrap things up, just ship the damn thing. You can make it perfect later.

Sharing information and lessons learned with other developers

Sign up for our new KnowledgeBits service and get news, tips and tricks and more, delivered straight to your inbox.